@backbay/glia 0.2.0-alpha.1

package/dist/vision/raymond/index.js

@@ -0,0 +1,14 @@
+export * from "./math.js";
+export * from "./camera.js";
+export * from "./transform.js";
+export * from "./types.js";
+export * from "./shapes.js";
+export * from "./shared/color.js";
+export * from "./shared/material.js";
+export * from "./shared/util.js";
+export * from "./canvas/Eye.js";
+export * from "./canvas/PointLight.js";
+export * from "./canvas/lightingModel.js";
+export * from "./canvas/lightingModelRegistry.js";
+export * from "./canvas/optics.js";
+export * from "./canvas/models/phongTracingModel.js";

package/dist/vision/raymond/math.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Transpose a 3x3 matrix.
+ */
+export declare function mat3_transpose(m: Mat3): Mat3;
+export interface Vec3 {
+    x: number;
+    y: number;
+    w: number;
+}
+export type Mat2 = number[][];
+export type Mat3 = number[][];
+export declare function newVector(x: number, y: number): Vec3;
+export declare function newPoint(x: number, y: number): Vec3;
+export declare function vec_add(a: Vec3, b: Vec3): Vec3;
+export declare function vec_sub(a: Vec3, b: Vec3): Vec3;
+export declare function vec_mul(a: Vec3, scalar: number): Vec3;
+export declare function vec_div(a: Vec3, scalar: number): Vec3;
+export declare function vec_magnitude(a: Vec3): number;
+export declare function vec_magnitude_sq(a: Vec3): number;
+export declare function vec_normalize(a: Vec3): Vec3;
+export declare function vec_dot(a: Vec3, b: Vec3): number;
+export declare function mat2_mul(a: Mat2, scalar: number): Mat2;
+export declare function mat2_mul_mat2(a: Mat2, b: Mat2): Mat2;
+export declare function mat3_identity(): Mat3;
+export declare function mat3_equal(a: Mat3, b: Mat3): boolean;
+export declare function mat3_mul_mat(a: Mat3, b: Mat3): Mat3;
+export declare function mat3_chain(matrices: Mat3[]): Mat3;
+export declare function mat3_mul(m: Mat3, scalar: number): Mat3;
+/**
+ * Apply a 3x3 affine matrix to a 2D vector (homogeneous coords).
+ * Returns a Vector; if the resulting w is non-1, performs perspective divide.
+ */
+export declare function mat3_mul_vec(m: Mat3, v: Vec3): Vec3;
+/**
+ * Compute the inverse of a 3x3 matrix. Returns undefined if singular.
+ */
+export declare function mat3_inverse(m: Mat3): Mat3 | undefined;
+export declare function mat_inverse(m: Mat2): Mat2 | undefined;
+//# sourceMappingURL=math.d.ts.map

package/dist/vision/raymond/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../../src/vision/raymond/math.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAM5C;AACD,MAAM,WAAW,IAAI;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,MAAM,IAAI,GAAG,MAAM,EAAE,EAAE,CAAC;AAC9B,MAAM,MAAM,IAAI,GAAG,MAAM,EAAE,EAAE,CAAC;AAE9B,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAEpD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAEnD;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAE9C;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAE9C;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAErD;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAErD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAE7C;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAEhD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAE3C;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAEhD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAKtD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAWpD;AAGD,wBAAgB,aAAa,IAAI,IAAI,CAMpC;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,WAS1C;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAgBnD;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,IAAI,EAAE,GAAG,IAAI,CAMjD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAUtD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAKnD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAuCtD;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAUrD"}

package/dist/vision/raymond/math.js

@@ -0,0 +1,162 @@
+/**
+ * Transpose a 3x3 matrix.
+ */
+export function mat3_transpose(m) {
+    return [
+        [m[0][0], m[1][0], m[2][0]],
+        [m[0][1], m[1][1], m[2][1]],
+        [m[0][2], m[1][2], m[2][2]],
+    ];
+}
+export function newVector(x, y) {
+    return { x, y, w: 0 };
+}
+export function newPoint(x, y) {
+    return { x, y, w: 1 };
+}
+export function vec_add(a, b) {
+    return { x: a.x + b.x, y: a.y + b.y, w: a.w + b.w };
+}
+export function vec_sub(a, b) {
+    return { x: a.x - b.x, y: a.y - b.y, w: a.w - b.w };
+}
+export function vec_mul(a, scalar) {
+    return { x: a.x * scalar, y: a.y * scalar, w: a.w * scalar };
+}
+export function vec_div(a, scalar) {
+    return { x: a.x / scalar, y: a.y / scalar, w: a.w / scalar };
+}
+export function vec_magnitude(a) {
+    return Math.sqrt(Math.pow(a.x, 2) + Math.pow(a.y, 2) + Math.pow(a.w, 2));
+}
+export function vec_magnitude_sq(a) {
+    return Math.pow(a.x, 2) + Math.pow(a.y, 2) + Math.pow(a.w, 2);
+}
+export function vec_normalize(a) {
+    return vec_div(a, vec_magnitude(a));
+}
+export function vec_dot(a, b) {
+    return a.x * b.x + a.y * b.y + a.w * b.w;
+}
+export function mat2_mul(a, scalar) {
+    return [
+        [a[0][0] * scalar, a[0][1] * scalar],
+        [a[1][0] * scalar, a[1][1] * scalar],
+    ];
+}
+export function mat2_mul_mat2(a, b) {
+    return [
+        [
+            a[0][0] * b[0][0] + a[0][1] * b[1][0],
+            a[0][0] * b[0][1] + a[0][1] * b[1][1],
+        ],
+        [
+            a[1][0] * b[0][0] + a[1][1] * b[1][0],
+            a[1][0] * b[0][1] + a[1][1] * b[1][1],
+        ],
+    ];
+}
+// 3x3 matrix (homogeneous coordinates) helpers for 2D affine transforms
+export function mat3_identity() {
+    return [
+        [1, 0, 0],
+        [0, 1, 0],
+        [0, 0, 1],
+    ];
+}
+export function mat3_equal(a, b) {
+    for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < 3; j++) {
+            if (a[i][j] !== b[i][j]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+export function mat3_mul_mat(a, b) {
+    const res = [
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0],
+    ];
+    for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < 3; j++) {
+            let v = 0;
+            for (let k = 0; k < 3; k++) {
+                v += a[i][k] * b[k][j];
+            }
+            res[i][j] = v;
+        }
+    }
+    return res;
+}
+export function mat3_chain(matrices) {
+    let ret = mat3_identity();
+    for (let i = 0; i < matrices.length; i++) {
+        ret = mat3_mul_mat(matrices[matrices.length - 1 - i], ret);
+    }
+    return ret;
+}
+export function mat3_mul(m, scalar) {
+    const ret = [];
+    for (let i = 0; i < 3; i++) {
+        const row = [];
+        for (let j = 0; j < 3; j++) {
+            row.push(m[i][j] * scalar);
+        }
+        ret.push(row);
+    }
+    return ret;
+}
+/**
+ * Apply a 3x3 affine matrix to a 2D vector (homogeneous coords).
+ * Returns a Vector; if the resulting w is non-1, performs perspective divide.
+ */
+export function mat3_mul_vec(m, v) {
+    const x = m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.w;
+    const y = m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.w;
+    const w = m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.w;
+    return { x, y, w };
+}
+/**
+ * Compute the inverse of a 3x3 matrix. Returns undefined if singular.
+ */
+export function mat3_inverse(m) {
+    // Compute the determinant
+    const a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];
+    const a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];
+    const a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];
+    const det = a00 * (a11 * a22 - a12 * a21) -
+        a01 * (a10 * a22 - a12 * a20) +
+        a02 * (a10 * a21 - a11 * a20);
+    if (det === 0)
+        return undefined;
+    const invDet = 1 / det;
+    // Compute adjugate (transpose of cofactor matrix)
+    const b00 = (a11 * a22 - a12 * a21) * invDet;
+    const b01 = -(a01 * a22 - a02 * a21) * invDet;
+    const b02 = (a01 * a12 - a02 * a11) * invDet;
+    const b10 = -(a10 * a22 - a12 * a20) * invDet;
+    const b11 = (a00 * a22 - a02 * a20) * invDet;
+    const b12 = -(a00 * a12 - a02 * a10) * invDet;
+    const b20 = (a10 * a21 - a11 * a20) * invDet;
+    const b21 = -(a00 * a21 - a01 * a20) * invDet;
+    const b22 = (a00 * a11 - a01 * a10) * invDet;
+    return [
+        [b00, b01, b02],
+        [b10, b11, b12],
+        [b20, b21, b22],
+    ];
+}
+export function mat_inverse(m) {
+    const det = m[0][0] * m[1][1] - m[0][1] * m[1][0];
+    if (det == 0) {
+        return undefined;
+    }
+    const a = [
+        [m[1][1], -m[0][1]],
+        [-m[1][0], m[0][0]],
+    ];
+    return mat2_mul(a, 1 / det);
+}

package/dist/vision/raymond/shapes.d.ts

@@ -0,0 +1,37 @@
+import { type Vec3 } from "./math.js";
+import { type Material } from "./shared/material.js";
+import { type Transform } from "./transform.js";
+import type { Ray } from "./types.js";
+export interface Intersection {
+    t: number;
+    shape: Shape;
+}
+export type ShapeType = "quad" | "circle";
+export declare abstract class Shape {
+    transform: Transform;
+    material: Material;
+    constructor(transform: Transform, material?: Material);
+    abstract type(): string;
+    abstract _intersectLocal(ray: Ray): number[];
+    abstract _normalAtLocal(point: Vec3): Vec3;
+    abstract _hitTest(point: Vec3): boolean;
+    intersect(ray: Ray): number[];
+    normalAt(pointWorld: Vec3): Vec3;
+    hitTest(pointWorld: Vec3): boolean;
+    handlePositions(): Vec3[];
+    handleMoved(handleIndex: number, _: Vec3, newPos: Vec3): void;
+}
+export declare class Circle extends Shape {
+    type(): string;
+    _intersectLocal(ray: Ray): number[];
+    _normalAtLocal(point: Vec3): Vec3;
+    _hitTest(point: Vec3): boolean;
+}
+export declare class Quad extends Shape {
+    type(): string;
+    _checkAxis(start: number, direction: number): number[];
+    _intersectLocal(ray: Ray): number[];
+    _normalAtLocal(point: Vec3): Vec3;
+    _hitTest(point: Vec3): boolean;
+}
+//# sourceMappingURL=shapes.d.ts.map

package/dist/vision/raymond/shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.d.ts","sourceRoot":"","sources":["../../../src/vision/raymond/shapes.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,KAAK,IAAI,EAKZ,MAAM,WAAW,CAAC;AACnB,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EACH,KAAK,SAAS,EAIjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAItC,MAAM,WAAW,YAAY;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,KAAK,CAAC;CAChB;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE1C,8BAAsB,KAAK;IACvB,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;gBAEP,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,QAAQ;IAKrD,QAAQ,CAAC,IAAI,IAAI,MAAM;IAGvB,QAAQ,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,EAAE;IAG5C,QAAQ,CAAC,cAAc,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI;IAG1C,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO;IAEvC,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,EAAE;IAS7B,QAAQ,CAAC,UAAU,EAAE,IAAI,GAAG,IAAI;IAiBhC,OAAO,CAAC,UAAU,EAAE,IAAI,GAAG,OAAO;IAMlC,eAAe,IAAI,IAAI,EAAE;IAKzB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI;CAazD;AAED,qBAAa,MAAO,SAAQ,KAAK;IAC7B,IAAI,IAAI,MAAM;IAId,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,EAAE;IAiBnC,cAAc,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI;IAIjC,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO;CAGjC;AAED,qBAAa,IAAK,SAAQ,KAAK;IAC3B,IAAI,IAAI,MAAM;IAId,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IAqBtD,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,EAAE;IASnC,cAAc,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI;IASjC,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO;CAGjC"}

package/dist/vision/raymond/shapes.js

@@ -0,0 +1,123 @@
+import { mat3_mul_vec, mat3_transpose, newPoint, newVector, vec_dot, vec_magnitude_sq, vec_normalize, vec_sub, } from "./math.js";
+import { defaultMaterial } from "./shared/material.js";
+import { apply, inverse, transformObject, } from "./transform.js";
+const EPS = 0.00001;
+export class Shape {
+    transform;
+    material;
+    constructor(transform, material) {
+        this.transform = transform;
+        this.material = material ?? defaultMaterial();
+    }
+    intersect(ray) {
+        // Transform the ray to the shape's local space
+        const rayLocal = {
+            start: apply(inverse(this.transform), ray.start),
+            direction: apply(inverse(this.transform), ray.direction),
+        };
+        return this._intersectLocal(rayLocal);
+    }
+    normalAt(pointWorld) {
+        // Transform point from world space to local space, then normal from local back to world
+        const pointLocal = apply(inverse(this.transform), pointWorld);
+        const normalLocal = this._normalAtLocal(pointLocal);
+        const inv = inverse(this.transform);
+        let normalWorld = { ...normalLocal };
+        if (inv) {
+            const inv_transpose = mat3_transpose(inv);
+            normalWorld = mat3_mul_vec(inv_transpose, normalLocal);
+        }
+        normalWorld.w = 0;
+        return vec_normalize(normalWorld);
+    }
+    hitTest(pointWorld) {
+        const pointLocal = apply(inverse(this.transform), pointWorld);
+        return this._hitTest(pointLocal);
+    }
+    // Returns the relative positions in local space of the object's handle
+    handlePositions() {
+        return [newPoint(0, 1.2)];
+    }
+    // TODO: Would be cleaner for shapes not to know about their handles
+    handleMoved(handleIndex, _, newPos) {
+        if (handleIndex !== 0) {
+            return; // Scaling not implemented yet
+        }
+        // We are rotating the shape. The centre of the shape, top of the shape, and mouse position should be collinear.
+        const shapeCentreWorld = apply(this.transform, newPoint(0, 0));
+        const d = vec_sub(newPos, shapeCentreWorld);
+        const theta = Math.atan2(d.y, d.x);
+        this.transform = transformObject(this.transform, (o) => ({
+            ...o,
+            rotation: theta - Math.PI / 2,
+        }));
+    }
+}
+export class Circle extends Shape {
+    type() {
+        return "circle";
+    }
+    _intersectLocal(ray) {
+        const sphereToRay = vec_sub(ray.start, newPoint(0, 0)); // Effectively just sets w = 0
+        const a = vec_magnitude_sq(ray.direction);
+        const b = 2 * vec_dot(ray.start, ray.direction);
+        const c = vec_magnitude_sq(sphereToRay) - 1;
+        const disc = b * b - 4 * a * c;
+        if (disc < 0) {
+            return [];
+        }
+        const rootDisc = Math.sqrt(disc);
+        const tlo = (-b - rootDisc) / (2 * a);
+        const thi = (-b + rootDisc) / (2 * a);
+        return [tlo, thi];
+    }
+    _normalAtLocal(point) {
+        return vec_sub(point, newPoint(0, 0));
+    }
+    _hitTest(point) {
+        return vec_magnitude_sq(vec_sub(point, newPoint(0, 0))) <= 1;
+    }
+}
+export class Quad extends Shape {
+    type() {
+        return "quad";
+    }
+    _checkAxis(start, direction) {
+        const tminNumerator = -1 - start;
+        const tmaxNumerator = +1 - start;
+        let tmin, tmax;
+        if (Math.abs(direction) >= EPS) {
+            tmin = tminNumerator / direction;
+            tmax = tmaxNumerator / direction;
+        }
+        else {
+            tmin = tminNumerator * Infinity;
+            tmax = tmaxNumerator * Infinity;
+        }
+        if (tmin > tmax) {
+            const temp = tmax;
+            tmax = tmin;
+            tmin = temp;
+        }
+        return [tmin, tmax];
+    }
+    _intersectLocal(ray) {
+        const [xtmin, xtmax] = this._checkAxis(ray.start.x, ray.direction.x);
+        const [ytmin, ytmax] = this._checkAxis(ray.start.y, ray.direction.y);
+        const tmin = Math.max(xtmin, ytmin);
+        const tmax = Math.min(xtmax, ytmax);
+        return tmin < tmax ? [tmin, tmax] : [];
+    }
+    _normalAtLocal(point) {
+        const maxc = Math.max(Math.abs(point.x), Math.abs(point.y));
+        if (maxc == Math.abs(point.x)) {
+            return newVector(point.x, 0);
+        }
+        else {
+            return newVector(0, point.y);
+        }
+    }
+    _hitTest(point) {
+        return Math.abs(point.x) <= 1 && Math.abs(point.y) <= 1;
+    }
+}

package/dist/vision/raymond/shared/color.d.ts

@@ -0,0 +1,18 @@
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+}
+export declare function color_mul(c: Color, scalar: number): {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare function color_add(a: Color, b: Color): {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare function color_html(color: Color, alpha: number): string;
+export declare function color_hadamard(a: Color, b: Color): Color;
+//# sourceMappingURL=color.d.ts.map

package/dist/vision/raymond/shared/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../../../src/vision/raymond/shared/color.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,KAAK;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;;;;EAEjD;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;;;;EAE3C;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAI9D;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAExD"}

package/dist/vision/raymond/shared/color.js

@@ -0,0 +1,12 @@
+export function color_mul(c, scalar) {
+    return { r: scalar * c.r, g: scalar * c.g, b: scalar * c.b };
+}
+export function color_add(a, b) {
+    return { r: a.r + b.r, g: a.g + b.g, b: a.b + b.b };
+}
+export function color_html(color, alpha) {
+    return `rgba(${color.r * 255}, ${color.g * 255}, ${color.b * 255}, ${alpha})`;
+}
+export function color_hadamard(a, b) {
+    return { r: a.r * b.r, g: a.g * b.g, b: a.b * b.b };
+}

package/dist/vision/raymond/shared/material.d.ts

@@ -0,0 +1,13 @@
+import type { Color } from "./color";
+export interface Material {
+    color: Color;
+    reflectivity: number;
+    transparency: number;
+    refractiveIndex: number;
+    ambient: number;
+    diffuse: number;
+    specular: number;
+    shininess: number;
+}
+export declare function defaultMaterial(): Material;
+//# sourceMappingURL=material.d.ts.map

package/dist/vision/raymond/shared/material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"material.d.ts","sourceRoot":"","sources":["../../../../src/vision/raymond/shared/material.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,MAAM,WAAW,QAAQ;IACrB,KAAK,EAAE,KAAK,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IAExB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,eAAe,IAAI,QAAQ,CAY1C"}

package/dist/vision/raymond/shared/material.js

@@ -0,0 +1,12 @@
+export function defaultMaterial() {
+    return {
+        color: { r: 100 / 255, g: 150 / 255, b: 65 / 255 },
+        reflectivity: 0,
+        transparency: 0,
+        refractiveIndex: 1.5,
+        ambient: 0.1,
+        diffuse: 0.9,
+        specular: 0.9,
+        shininess: 200,
+    };
+}

package/dist/vision/raymond/shared/util.d.ts

@@ -0,0 +1,2 @@
+export declare function clamped(val: number, min: number, max: number): number;
+//# sourceMappingURL=util.d.ts.map

package/dist/vision/raymond/shared/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/vision/raymond/shared/util.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE"}

package/dist/vision/raymond/shared/util.js

@@ -0,0 +1,3 @@
+export function clamped(val, min, max) {
+    return Math.min(max, Math.max(val, min));
+}

package/dist/vision/raymond/transform.d.ts

@@ -0,0 +1,24 @@
+import { type Vec3, type Mat3 } from "./math.js";
+export interface ObjectTransform {
+    scale: Vec3;
+    rotation: number;
+    translation: Vec3;
+}
+export type Transform = Mat3;
+/** Converts an object transform to the more general form of a matrix transform. */
+export declare function fromObjectTransform(t: ObjectTransform): Transform;
+/** Converts a general matrix transform to an object transform, assuming no shear. */
+export declare function toObjectTransform(t: Transform): ObjectTransform;
+export declare function inverse(transform: Transform): Transform;
+export declare function apply(transform: Transform, vec: Vec3): Vec3;
+/** Linearly interpolates the scale, translation and rotations of the two transforms,
+ *  allowing for smooth animation between the two. **/
+export declare function interp(a: Transform, b: Transform, x: number): Mat3;
+export declare function translation(tx: number, ty: number): Mat3;
+export declare function rotation(theta: number): Mat3;
+export declare function scaling(sx: number, sy?: number): Mat3;
+export declare function transformObject(t: Transform, f: (o: ObjectTransform) => ObjectTransform): Mat3;
+export declare function rotateObject(t: Transform, theta: number): Transform;
+export declare function translateObject(t: Transform, delta: Vec3): Transform;
+export declare function scaleObject(t: Transform, scale: Vec3): Transform;
+//# sourceMappingURL=transform.d.ts.map

package/dist/vision/raymond/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/vision/raymond/transform.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,KAAK,IAAI,EAET,KAAK,IAAI,EAGZ,MAAM,WAAW,CAAC;AAEnB,MAAM,WAAW,eAAe;IAC5B,KAAK,EAAE,IAAI,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,IAAI,CAAC;CACrB;AAED,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC;AAE7B,mFAAmF;AACnF,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,eAAe,GAAG,SAAS,CAMjE;AAED,qFAAqF;AACrF,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,GAAG,eAAe,CAkB/D;AAED,wBAAgB,OAAO,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,CAEvD;AAED,wBAAgB,KAAK,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,CAE3D;AAED;sDACsD;AACtD,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,QAU3D;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAMxD;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAQ5C;AAED,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAOrD;AAGD,wBAAgB,eAAe,CAC3B,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,CAAC,CAAC,EAAE,eAAe,KAAK,eAAe,QAK7C;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAEnE;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,GAAG,SAAS,CAKpE;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,GAAG,SAAS,CAKhE"}

package/dist/vision/raymond/transform.js

@@ -0,0 +1,86 @@
+import { mat3_chain, mat3_inverse, mat3_mul_vec, newVector, vec_add, vec_mul, } from "./math.js";
+/** Converts an object transform to the more general form of a matrix transform. */
+export function fromObjectTransform(t) {
+    return mat3_chain([
+        translation(t.translation.x, t.translation.y),
+        rotation(t.rotation),
+        scaling(t.scale.x, t.scale.y),
+    ]);
+}
+/** Converts a general matrix transform to an object transform, assuming no shear. */
+export function toObjectTransform(t) {
+    const [a, b, tx] = [...t[0]];
+    const [c, d, ty] = [...t[1]];
+    // Extract translation, scale and rotation of new matrix
+    const rotation = Math.atan2(c, a);
+    const scaleX = Math.sqrt(a * a + c * c);
+    const scaleY = (a * d - b * c) / scaleX;
+    const scale = newVector(scaleX, scaleY);
+    const translation = newVector(tx, ty);
+    return {
+        scale,
+        rotation,
+        translation,
+    };
+}
+export function inverse(transform) {
+    return mat3_inverse(transform) ?? transform;
+}
+export function apply(transform, vec) {
+    return mat3_mul_vec(transform, vec);
+}
+/** Linearly interpolates the scale, translation and rotations of the two transforms,
+ *  allowing for smooth animation between the two. **/
+export function interp(a, b, x) {
+    const oa = toObjectTransform(a);
+    const ob = toObjectTransform(b);
+    const rotation = (1 - x) * oa.rotation + x * ob.rotation;
+    const scale = vec_add(vec_mul(oa.scale, 1 - x), vec_mul(ob.scale, x));
+    const translation = vec_add(vec_mul(oa.translation, 1 - x), vec_mul(ob.translation, x));
+    return fromObjectTransform({ scale, rotation, translation });
+}
+export function translation(tx, ty) {
+    return [
+        [1, 0, tx],
+        [0, 1, ty],
+        [0, 0, 1],
+    ];
+}
+export function rotation(theta) {
+    const c = Math.cos(theta);
+    const s = Math.sin(theta);
+    return [
+        [c, -s, 0],
+        [s, c, 0],
+        [0, 0, 1],
+    ];
+}
+export function scaling(sx, sy) {
+    const _sy = typeof sy === "number" ? sy : sx;
+    return [
+        [sx, 0, 0],
+        [0, _sy, 0],
+        [0, 0, 1],
+    ];
+}
+// Helpers for rotating, scaling and translating object transforms.
+export function transformObject(t, f) {
+    const o = toObjectTransform(t);
+    const oNew = f(o);
+    return fromObjectTransform(oNew);
+}
+export function rotateObject(t, theta) {
+    return transformObject(t, (o) => ({ ...o, rotation: o.rotation + theta }));
+}
+export function translateObject(t, delta) {
+    return transformObject(t, (o) => ({
+        ...o,
+        translation: vec_add(o.translation, delta),
+    }));
+}
+export function scaleObject(t, scale) {
+    return transformObject(t, (o) => ({
+        ...o,
+        scale: newVector(o.scale.x * scale.x, o.scale.y * scale.y),
+    }));
+}

package/dist/vision/raymond/types.d.ts

@@ -0,0 +1,33 @@
+import type Camera from "./camera";
+import type { Eye } from "./canvas/Eye";
+import { type Vec3 } from "./math";
+import type { Shape } from "./shapes";
+export interface RaymondState {
+    debug: boolean;
+    lastMousePos: Vec3;
+    isMouseDown: boolean;
+    placementStartWorld: Vec3 | null;
+    panStart: Vec3 | null;
+    tool: ToolType;
+    eyes: Eye[];
+    shapes: Shape[];
+    /** Which shape is currently selected, if any? */
+    selectedShapeIndex: number | null;
+    /** Is the currently selected shape being dragged? */
+    shapeDragged: boolean;
+    /** Which `handle` of the currently selected shape is being interacted with? By convention, 0 is the rotation handle, 1-8 the scale handles. */
+    activeHandleIndex: number | null;
+    camera: Camera;
+    mousePosScreen: Vec3;
+}
+export interface Ray {
+    start: Vec3;
+    direction: Vec3;
+}
+export type ToolType = "eye" | "quad" | "circle" | "pan" | "select";
+export interface Tool {
+    type: ToolType;
+    hotkey: string;
+    name: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/vision/raymond/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/vision/raymond/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC,MAAM,WAAW,YAAY;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,EAAE,IAAI,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,mBAAmB,EAAE,IAAI,GAAG,IAAI,CAAC;IACjC,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,iDAAiD;IACjD,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,qDAAqD;IACrD,YAAY,EAAE,OAAO,CAAC;IACtB,+IAA+I;IAC/I,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,GAAG;IAChB,KAAK,EAAE,IAAI,CAAC;IACZ,SAAS,EAAE,IAAI,CAAC;CACnB;AAED,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEpE,MAAM,WAAW,IAAI;IACjB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CAChB"}

package/dist/vision/raymond/types.js

@@ -0,0 +1 @@
+export {};