canvas-emulator 1.0.0

package/src/common/hash.ts

@@ -0,0 +1,46 @@
+import { toBatched } from "./array";
+
+const isFloat = (x: number): boolean => !Number.isInteger(x);
+
+export const toUint32 = (x: number | BigInt): number => {
+  const buffer = new ArrayBuffer(4);
+  const view = new DataView(buffer);
+  const n = Number(x);
+  if (isFloat(n)) {
+    view.setFloat32(0, n);
+  } else {
+    view.setUint32(0, n);
+  }
+  return view.getUint32(0);
+};
+
+export const hashU32 = (arr: number[]) => {
+  const U = toUint32;
+  const pad = 7;
+  const batches = toBatched(
+    arr.map((v) => U(v)),
+    2,
+    pad,
+  );
+
+  let h = 0;
+  for (let i = 0; i < batches.length; i++) {
+    let [x, y] = batches[i % batches.length]!;
+    let j1 = (~x >> 2) * 53;
+    let j2 = (~y >> 3) * 53;
+    x += j2;
+    x ^= x << 17;
+    x ^= x >> 13;
+    x ^= x << 5;
+    x *= 0xa40b130c;
+    y ^= x;
+    y += j1;
+    y ^= y << 17;
+    y ^= y >> 13;
+    y ^= y << 5;
+    y *= 0xe0b0591a;
+    h = U(h + (x * 7 + y * 3) * 5013 + 1013 * (j1 * 3 + j2));
+  }
+
+  return U(h);
+};

package/src/common/index.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./array";
+export * from "./hash";
+export * from "./ppm";
+export * from "./scalar";
+export * from "./colors";

package/src/common/ppm.ts

@@ -0,0 +1,28 @@
+import { clamp } from "./scalar";
+
+export const createPPM = (
+  width: number,
+  height: number,
+  pixels: [number, number, number][],
+): string => {
+  const expectedPixels = width * height;
+  if (pixels.length !== expectedPixels) {
+    throw new Error(
+      `Invalid pixel data: Expected ${expectedPixels} pixels, but got ${pixels.length}.`,
+    );
+  }
+
+  let ppmContent = `P3\n${width} ${height}\n255\n`;
+
+  for (let i = 0; i < pixels.length; i++) {
+    const [x, y, z] = pixels[i]!;
+
+    const r = clamp(Math.round(x * 255), 0, 255);
+    const g = clamp(Math.round(y * 255), 0, 255);
+    const b = clamp(Math.round(z * 255), 0, 255);
+
+    ppmContent += `${r} ${g} ${b}\n`;
+  }
+
+  return ppmContent;
+};

package/src/common/scalar.ts

@@ -0,0 +1,72 @@
+export const clamp = (x: number, min: number, max: number): number =>
+  Math.max(min, Math.min(max, x));
+
+export const lerp = (vFrom: number, vTo: number, scale: number) =>
+  vFrom + (vTo - vFrom) * scale;
+
+export const remap = (
+  x: number,
+  range1: [number, number],
+  range2: [number, number],
+): number => {
+  const min1 = range1[0];
+  const max1 = range1[1];
+  const min2 = range2[0];
+  const max2 = range2[1];
+  const div = max1 - min1;
+
+  if (Math.abs(div) <= 0.00000000000000000001) return min2;
+
+  return min2 + ((clamp(x, min1, max1) - min1) / div) * (max2 - min2);
+};
+
+export const smoothstep = (
+  edge0: number,
+  edge1: number,
+  value: number,
+): number => {
+  const x = clamp((value - edge0) / (edge1 - edge0), 0.0, 1.0);
+  return x * x * (3.0 - 2.0 * x);
+};
+
+/**
+ * Smooth greater-than
+ */
+export const sgt = (a: number, b: number, s: number) => {
+  const h = clamp(0.5 + (0.5 * (a - b)) / s, 0.0, 1.0);
+  return lerp(0.0, 1.0, h * h * (3.0 - 2.0 * h));
+};
+
+/**
+ * Smooth less-than
+ */
+export const slt = (a: number, b: number, s: number) => {
+  const h = clamp(0.5 + (0.5 * (b - a)) / s, 0.0, 1.0);
+  return lerp(0.0, 1.0, h * h * (3.0 - 2.0 * h));
+};
+
+/**
+ * Smooth minimum
+ */
+export const smin = (a: number, b: number, k: number) => {
+  const h = clamp(0.5 + (0.5 * (b - a)) / k, 0.0, 1.0);
+  return lerp(b, a, h) - k * h * (1.0 - h);
+};
+
+/**
+ * Smooth maximum
+ */
+export const smax = (a: number, b: number, k: number) => {
+  const h = clamp(0.5 + (0.5 * (b - a)) / k, 0.0, 1.0);
+  return lerp(b, a, h) + k * h * (1.0 - h);
+};
+
+export const fract = (x: number) => x - Math.floor(x);
+
+/**
+ * Absolute modulus
+ */
+export const amod = (value: number, modulus: number): number =>
+  ((value % modulus) + modulus) % modulus;
+
+export const sigmoid = (x: number) => 1 / (1 + Math.exp(-x));

package/src/common/types.ts

@@ -0,0 +1,10 @@
+export type Pair<A, B> = [A, B];
+export type Triple<A, B, C> = [A, B, C];
+
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+export type V2 = [number, number];
+export type V3 = [number, number, number];
+export type V4 = [number, number, number, number];

package/src/data/font/index.ts

@@ -0,0 +1 @@
+export * from "./noto-mono-regular-48";