@backbay/glia 0.2.0-alpha.1

package/dist/vision/raymond/canvas/Eye.js

@@ -0,0 +1,50 @@
+import { newPoint, vec_sub } from "../math";
+import { apply, inverse, transformObject } from "../transform";
+const MAX_RAYS = 60;
+export class Eye {
+    transform;
+    numRays = MAX_RAYS;
+    fov = Math.PI / 4;
+    constructor(transform) {
+        this.transform = transform;
+    }
+    hitTest(worldPoint) {
+        const local = apply(inverse(this.transform), worldPoint);
+        if (local.x >= -1 &&
+            local.x <= 0.2 &&
+            local.y >= -0.8 &&
+            local.y <= 0.4) {
+            return true;
+        }
+        return false;
+    }
+    // Returns the relative positions in local space of the object's handle
+    handlePositions() {
+        const rotation = newPoint(0, 1.2);
+        // FOV of pi <-> x = 0
+        // FOV of 0  <-> x = 1
+        const lensX = 1 - this.fov / Math.PI;
+        // 1 ray    <-> y = 0
+        // max rays <-> y = 1
+        const lensY = (this.numRays - 1) / MAX_RAYS;
+        return [rotation, newPoint(lensX, lensY)];
+    }
+    // TODO: Would be cleaner for shapes not to know about their handles
+    handleMoved(handleIndex, _, newPos) {
+        if (handleIndex === 0) {
+            // 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,
+            }));
+        }
+        else {
+            const posLocal = apply(inverse(this.transform), newPos);
+            this.fov = Math.max(0, Math.min(Math.PI, (1 - posLocal.x) * Math.PI));
+            this.numRays = Math.max(1, Math.min(MAX_RAYS, 1 + posLocal.y * MAX_RAYS));
+        }
+    }
+}

package/dist/vision/raymond/canvas/PointLight.d.ts

@@ -0,0 +1,12 @@
+import { type Vec3 } from "../math";
+import type { Color } from "../shared/color";
+import { type Transform } from "../transform";
+export declare class PointLight {
+    color: Color;
+    transform: Transform;
+    constructor(color: Color, transform: Transform);
+    hitTest(pointWorld: Vec3): boolean;
+    handlePositions(): Vec3[];
+    handleMoved(): void;
+}
+//# sourceMappingURL=PointLight.d.ts.map

package/dist/vision/raymond/canvas/PointLight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PointLight.d.ts","sourceRoot":"","sources":["../../../../src/vision/raymond/canvas/PointLight.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,IAAI,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9D,qBAAa,UAAU;IACnB,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,SAAS,CAAC;gBAET,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS;IAK9C,OAAO,CAAC,UAAU,EAAE,IAAI,GAAG,OAAO;IAOlC,eAAe,IAAI,IAAI,EAAE;IAIzB,WAAW;CACd"}

package/dist/vision/raymond/canvas/PointLight.js

@@ -0,0 +1,20 @@
+import { newPoint, vec_magnitude, vec_sub } from "../math";
+import { apply, inverse } from "../transform";
+export class PointLight {
+    color;
+    transform;
+    constructor(color, transform) {
+        this.color = color;
+        this.transform = transform;
+    }
+    hitTest(pointWorld) {
+        const pointLocal = apply(inverse(this.transform), pointWorld);
+        console.log(pointLocal);
+        return vec_magnitude(vec_sub(pointLocal, newPoint(0, 0))) < 0.3;
+    }
+    // Returns the relative positions in local space of the object's handle
+    handlePositions() {
+        return [];
+    }
+    handleMoved() { }
+}

package/dist/vision/raymond/canvas/lightingModel.d.ts

@@ -0,0 +1,26 @@
+import type { Eye } from "./Eye";
+import type { Shape } from "../shapes";
+import type { PointLight } from "./PointLight";
+import type { OpticsResult } from "./optics";
+export interface LightingModelParameter {
+    id: string;
+    name: string;
+    type: "boolean" | "number" | "select";
+    min?: number;
+    max?: number;
+    step?: number;
+    default: unknown;
+    options?: {
+        label: string;
+        value: unknown;
+    }[];
+}
+export type LightingModelParams = Record<string, unknown>;
+export interface LightingModel {
+    id: string;
+    name: string;
+    description: string;
+    parameters: LightingModelParameter[];
+    computeSegments(eye: Eye, shapes: Shape[], lights: PointLight[], params: LightingModelParams): OpticsResult;
+}
+//# sourceMappingURL=lightingModel.d.ts.map

package/dist/vision/raymond/canvas/lightingModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightingModel.d.ts","sourceRoot":"","sources":["../../../../src/vision/raymond/canvas/lightingModel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,WAAW,sBAAsB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;CACjD;AAED,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1D,MAAM,WAAW,aAAa;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,sBAAsB,EAAE,CAAC;IACrC,eAAe,CACX,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,KAAK,EAAE,EACf,MAAM,EAAE,UAAU,EAAE,EACpB,MAAM,EAAE,mBAAmB,GAC5B,YAAY,CAAC;CACnB"}

package/dist/vision/raymond/canvas/lightingModel.js

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

package/dist/vision/raymond/canvas/lightingModelRegistry.d.ts

@@ -0,0 +1,12 @@
+import type { LightingModel } from "./lightingModel";
+export declare class LightingModelRegistry {
+    private models;
+    private defaultModelId;
+    register(id: string, model: LightingModel, isDefault?: boolean): void;
+    get(id: string): LightingModel | undefined;
+    getAll(): LightingModel[];
+    getDefault(): LightingModel;
+    getDefaultId(): string;
+}
+export declare const lightingModelRegistry: LightingModelRegistry;
+//# sourceMappingURL=lightingModelRegistry.d.ts.map

package/dist/vision/raymond/canvas/lightingModelRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightingModelRegistry.d.ts","sourceRoot":"","sources":["../../../../src/vision/raymond/canvas/lightingModelRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,MAAM,CAAyC;IACvD,OAAO,CAAC,cAAc,CAAuB;IAE7C,QAAQ,CACJ,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,aAAa,EACpB,SAAS,GAAE,OAAe,GAC3B,IAAI;IAOP,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI1C,MAAM,IAAI,aAAa,EAAE;IAIzB,UAAU,IAAI,aAAa;IAa3B,YAAY,IAAI,MAAM;CAMzB;AAED,eAAO,MAAM,qBAAqB,uBAA8B,CAAC"}

package/dist/vision/raymond/canvas/lightingModelRegistry.js

@@ -0,0 +1,33 @@
+export class LightingModelRegistry {
+    models = new Map();
+    defaultModelId = null;
+    register(id, model, isDefault = false) {
+        this.models.set(id, model);
+        if (isDefault || this.defaultModelId === null) {
+            this.defaultModelId = id;
+        }
+    }
+    get(id) {
+        return this.models.get(id);
+    }
+    getAll() {
+        return Array.from(this.models.values());
+    }
+    getDefault() {
+        if (this.defaultModelId === null) {
+            throw new Error("No default lighting model registered");
+        }
+        const model = this.models.get(this.defaultModelId);
+        if (!model) {
+            throw new Error(`Default lighting model "${this.defaultModelId}" not found`);
+        }
+        return model;
+    }
+    getDefaultId() {
+        if (this.defaultModelId === null) {
+            throw new Error("No default lighting model registered");
+        }
+        return this.defaultModelId;
+    }
+}
+export const lightingModelRegistry = new LightingModelRegistry();

package/dist/vision/raymond/canvas/models/phongTracingModel.d.ts

@@ -0,0 +1,13 @@
+import type { LightingModel, LightingModelParameter, LightingModelParams } from "../lightingModel";
+import type { OpticsResult } from "../optics";
+import type { Eye } from "../Eye";
+import type { Shape } from "../../shapes";
+import type { PointLight } from "../PointLight";
+export declare class PhongTracingModel implements LightingModel {
+    id: string;
+    name: string;
+    description: string;
+    parameters: LightingModelParameter[];
+    computeSegments(eye: Eye, shapes: Shape[], lights: PointLight[], params: LightingModelParams): OpticsResult;
+}
+//# sourceMappingURL=phongTracingModel.d.ts.map

package/dist/vision/raymond/canvas/models/phongTracingModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phongTracingModel.d.ts","sourceRoot":"","sources":["../../../../../src/vision/raymond/canvas/models/phongTracingModel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,qBAAa,iBAAkB,YAAW,aAAa;IACnD,EAAE,SAAmB;IACrB,IAAI,SAAuB;IAC3B,WAAW,SACgE;IAE3E,UAAU,EAAE,sBAAsB,EAAE,CAwDlC;IAEF,eAAe,CACX,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,KAAK,EAAE,EACf,MAAM,EAAE,UAAU,EAAE,EACpB,MAAM,EAAE,mBAAmB,GAC5B,YAAY;CAoBlB"}

package/dist/vision/raymond/canvas/models/phongTracingModel.js

@@ -0,0 +1,72 @@
+import { computeSegments as computeOpticsSegments } from "../optics";
+export class PhongTracingModel {
+    id = "phong-tracing";
+    name = "Phong Ray Tracing";
+    description = "Classic ray tracing with Phong shading, reflections, and refractions";
+    parameters = [
+        {
+            id: "maxDepth",
+            name: "Max Recursion Depth",
+            type: "number",
+            min: 1,
+            max: 20,
+            step: 1,
+            default: 10,
+        },
+        {
+            id: "schlickEnabled",
+            name: "Fresnel Reflections (Schlick)",
+            type: "boolean",
+            default: true,
+        },
+        {
+            id: "showInfiniteRays",
+            name: "Show Rays to Infinity (Slow!)",
+            type: "boolean",
+            default: false,
+        },
+        {
+            id: "showVisionBoundaries",
+            name: "Show Vision Cell Boundaries",
+            type: "boolean",
+            default: false,
+        },
+        {
+            id: "showNormals",
+            name: "Show Normal Vectors",
+            type: "boolean",
+            default: false,
+        },
+        {
+            id: "showShadowRays",
+            name: "Show Shadow Rays",
+            type: "boolean",
+            default: false,
+        },
+        {
+            id: "showReflections",
+            name: "Show Reflection Angle",
+            type: "boolean",
+            default: false,
+        },
+        {
+            id: "visionPosition",
+            name: "Vision Rectangle Position",
+            type: "select",
+            default: "bottom",
+            options: [
+                { label: "Bottom", value: "bottom" },
+                { label: "Left", value: "left" },
+            ],
+        },
+    ];
+    computeSegments(eye, shapes, lights, params) {
+        const maxDepth = params.maxDepth ?? 10;
+        const schlickEnabled = params.schlickEnabled ?? true;
+        const showInfiniteRays = params.showInfiniteRays ?? false;
+        const showNormals = params.showNormals ?? false;
+        const showShadowRays = params.showShadowRays ?? false;
+        const showReflections = params.showReflections ?? false;
+        return computeOpticsSegments(eye, shapes, lights, maxDepth, schlickEnabled, showInfiniteRays, showNormals, showShadowRays, showReflections);
+    }
+}

package/dist/vision/raymond/canvas/optics.d.ts

@@ -0,0 +1,37 @@
+import { type Vec3 } from "../math";
+import { Shape } from "../shapes";
+import { type Color } from "../shared/color";
+import { Eye } from "./Eye";
+import type { PointLight } from "./PointLight";
+export interface RaySegment {
+    start: Vec3;
+    end: Vec3;
+    color: Color;
+    attenuation: number;
+    dashed?: boolean;
+    normal?: Vec3;
+    reflect?: Vec3;
+}
+export declare function setLogging(logging: boolean): void;
+export interface OpticsResult {
+    segments: RaySegment[];
+    vision: Color[];
+    shadowRays: RaySegment[];
+}
+/**
+ * Returns all ray segments generated by the given laser.
+ * This amounts to traversing a tree:
+ * - The root node represents the laser source
+ * - Leaf nodes represent the infinitely distant endpoints of segments that don't hit any shape
+ * - All intermediate nodes represent the intersection of a segment with some shape in the scene.
+ * It's a tree, not a list, because when a beam hits a surface it will typically generate (at least) one reflected
+ * ray and (at least) one refracted ray, depending on the material properties.
+ * Each edge (segment) needs to be appended to the return array. Its color depends on the color of its child edges,
+ * and on the material properties of its child node (intersection point).
+ * @param eye
+ * @param shapes
+ * @returns
+ */
+export declare function computeSegments(eye: Eye, shapes: Shape[], lights: PointLight[], maxDepth?: number, schlickEnabled?: boolean, showInfiniteRays?: boolean, showNormals?: boolean, showShadowRays?: boolean, showReflections?: boolean): OpticsResult;
+export declare function toggleSchlick(): void;
+//# sourceMappingURL=optics.d.ts.map

package/dist/vision/raymond/canvas/optics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optics.d.ts","sourceRoot":"","sources":["../../../../src/vision/raymond/canvas/optics.ts"],"names":[],"mappings":"AAGA,OAAO,EASH,KAAK,IAAI,EACZ,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,KAAK,EAAqB,MAAM,WAAW,CAAC;AACrD,OAAO,EAIH,KAAK,KAAK,EACb,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,UAAU;IACvB,KAAK,EAAE,IAAI,CAAC;IACZ,GAAG,EAAE,IAAI,CAAC;IACV,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,IAAI,CAAC;IACd,OAAO,CAAC,EAAE,IAAI,CAAC;CAClB;AAyBD,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,QAE1C;AAED,MAAM,WAAW,YAAY;IACzB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,UAAU,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC3B,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,KAAK,EAAE,EACf,MAAM,EAAE,UAAU,EAAE,EACpB,QAAQ,GAAE,MAAW,EACrB,cAAc,GAAE,OAAc,EAC9B,gBAAgB,GAAE,OAAe,EACjC,WAAW,GAAE,OAAe,EAC5B,cAAc,GAAE,OAAe,EAC/B,eAAe,GAAE,OAAe,GACjC,YAAY,CA0Dd;AAuOD,wBAAgB,aAAa,SAE5B"}

package/dist/vision/raymond/canvas/optics.js

@@ -0,0 +1,343 @@
+/* This module handles the calculations of which ray segments should appear in the scene, given the locations
+of light sources and objects. */
+import { newPoint, newVector, vec_add, vec_dot, vec_magnitude, vec_mul, vec_normalize, vec_sub, } from "../math";
+import { color_add, color_hadamard, color_mul, } from "../shared/color";
+import { apply, toObjectTransform } from "../transform";
+const BLACK = { r: 0, g: 0, b: 0 };
+let SCHLICK_ENABLED = true;
+let SHOW_INFINITE_RAYS = false;
+let SHOW_NORMALS = false;
+let SHOW_REFLECTIONS = false;
+let SHOW_SHADOW_RAYS = false;
+let shadowRays = [];
+let doLogging = false;
+export function setLogging(logging) {
+    doLogging = logging;
+}
+/**
+ * Returns all ray segments generated by the given laser.
+ * This amounts to traversing a tree:
+ * - The root node represents the laser source
+ * - Leaf nodes represent the infinitely distant endpoints of segments that don't hit any shape
+ * - All intermediate nodes represent the intersection of a segment with some shape in the scene.
+ * It's a tree, not a list, because when a beam hits a surface it will typically generate (at least) one reflected
+ * ray and (at least) one refracted ray, depending on the material properties.
+ * Each edge (segment) needs to be appended to the return array. Its color depends on the color of its child edges,
+ * and on the material properties of its child node (intersection point).
+ * @param eye
+ * @param shapes
+ * @returns
+ */
+export function computeSegments(eye, shapes, lights, maxDepth = 10, schlickEnabled = true, showInfiniteRays = false, showNormals = false, showShadowRays = false, showReflections = false) {
+    // Store the parameters in module state for use in child functions
+    SCHLICK_ENABLED = schlickEnabled;
+    SHOW_INFINITE_RAYS = showInfiniteRays;
+    SHOW_NORMALS = showNormals;
+    SHOW_SHADOW_RAYS = showShadowRays;
+    SHOW_REFLECTIONS = showReflections;
+    shadowRays = [];
+    if (doLogging) {
+        console.log("Computing segments for eye: ", eye);
+    }
+    // Calculate initial rays
+    const eyePos = apply(eye.transform, newPoint(0, 0));
+    const eyeDir = vec_normalize(vec_sub(apply(eye.transform, newPoint(1, 0)), apply(eye.transform, newPoint(0, 0))));
+    const filmCentre = vec_add(eyePos, eyeDir);
+    const filmParallel = newVector(eyeDir.y, -eyeDir.x);
+    const halfWidth = Math.tan(eye.fov / 2);
+    const pixelStep = (2 * halfWidth) / eye.numRays;
+    const rays = [];
+    // There's got to be a better way to do this, but it's 10pm and I'm tired.
+    for (let i = -Math.floor(eye.numRays / 2); i < Math.floor(eye.numRays / 2) + 1; i++) {
+        const filmPos = vec_add(filmCentre, vec_mul(filmParallel, i * pixelStep));
+        rays.push({
+            start: eyePos,
+            direction: vec_normalize(vec_sub(filmPos, eyePos)),
+        });
+    }
+    let allSegments = [];
+    const vision = [];
+    for (const ray of rays) {
+        const segments = castRay(shapes, lights, ray, maxDepth, 1);
+        if (segments.length === 0) {
+            vision.push(BLACK);
+        }
+        else {
+            vision.push(segments[0].color);
+        }
+        allSegments = allSegments.concat(segments);
+    }
+    return {
+        segments: allSegments,
+        vision,
+        shadowRays,
+    };
+}
+function castRay(shapes, lights, ray, remaining, attenuation) {
+    const intersections = shapes.flatMap((shape) => shape.intersect(ray).map((t) => ({ t, shape })));
+    intersections.sort((a, b) => a.t - b.t);
+    // The "hit" is the first intersection in front of the ray source.
+    // If no hit, then there are no more segments along this path.
+    const hit = intersections.find((x) => x.t >= 0);
+    if (!hit) {
+        // If we should show infinite rays, create a dashed white segment
+        if (SHOW_INFINITE_RAYS) {
+            // Project the ray out to a reasonable distance (e.g., 100 units)
+            const infiniteDistance = 100;
+            const end = vec_add(ray.start, vec_mul(ray.direction, infiniteDistance));
+            return [
+                {
+                    start: ray.start,
+                    end: end,
+                    color: BLACK,
+                    attenuation: attenuation,
+                    dashed: true,
+                },
+            ];
+        }
+        return [];
+    }
+    const hitPoint = pointOnRay(ray, hit.t);
+    const data = computeIntersectionData(hit, ray, intersections);
+    if (doLogging) {
+        console.log("Intersection data:");
+        console.log(data);
+    }
+    // Shade hit
+    let surface = BLACK;
+    if (lights.length > 0) {
+        for (const light of lights) {
+            const shadowed = isShadowed(data.overPoint, shapes, light);
+            surface = color_add(surface, lighting(data, light, shadowed));
+            // Generate shadow rays if enabled
+            if (SHOW_SHADOW_RAYS) {
+                generateShadowRay(data, light, shapes);
+            }
+        }
+    }
+    else {
+        surface = data.shape.material.color;
+    }
+    surface = color_mul(surface, 1 - data.shape.material.transparency);
+    const reflected = castReflectedRay(shapes, lights, data, remaining, attenuation);
+    const refracted = castRefractedRay(shapes, lights, data, remaining, attenuation);
+    const reflectedColor = color_mul(reflected[0]?.color ?? BLACK, data.shape.material.reflectivity);
+    const refractedColor = color_mul(refracted[0]?.color ?? BLACK, data.shape.material.transparency);
+    if (doLogging) {
+        console.log("reflected color: ", reflectedColor);
+        console.log("refracted color: ", refractedColor);
+    }
+    let color;
+    const material = data.shape.material;
+    if (SCHLICK_ENABLED &&
+        material.reflectivity > 0 &&
+        material.transparency > 0) {
+        const reflectance = schlick(data);
+        color = color_add(surface, color_add(color_mul(reflectedColor, reflectance), color_mul(refractedColor, 1 - reflectance)));
+    }
+    else {
+        color = color_add(surface, color_add(refractedColor, reflectedColor));
+    }
+    const firstSegment = {
+        start: ray.start,
+        end: hitPoint,
+        color,
+        attenuation,
+        normal: SHOW_NORMALS ? data.normalv : undefined,
+        reflect: SHOW_REFLECTIONS ? data.reflectv : undefined,
+    };
+    return [firstSegment, ...reflected, ...refracted];
+}
+function lighting(data, light, inShadow) {
+    const material = data.shape.material;
+    const effectiveColor = color_hadamard(material.color, light.color);
+    const o = toObjectTransform(light.transform);
+    const lightPos = newPoint(o.translation.x, o.translation.y);
+    if (doLogging) {
+        console.log("lightPos: ", lightPos);
+    }
+    const lightv = vec_normalize(vec_sub(lightPos, data.point));
+    const ambient = color_mul(effectiveColor, material.ambient);
+    if (inShadow) {
+        return ambient;
+    }
+    const lightDotNormal = vec_dot(lightv, data.normalv);
+    let diffuse;
+    let specular;
+    if (lightDotNormal < 0) {
+        diffuse = BLACK;
+        specular = BLACK;
+    }
+    else {
+        diffuse = color_mul(effectiveColor, material.diffuse * lightDotNormal);
+        const reflectv = reflect(vec_mul(lightv, -1), data.normalv);
+        const reflectDotEye = vec_dot(reflectv, data.eyev);
+        if (reflectDotEye <= 0) {
+            specular = BLACK;
+        }
+        else {
+            const factor = Math.pow(reflectDotEye, material.shininess);
+            specular = color_mul(light.color, material.specular * factor);
+        }
+    }
+    return color_add(color_add(ambient, diffuse), specular);
+}
+function castReflectedRay(shapes, lights, data, remaining, attenuation) {
+    if (remaining === 0 || data.shape.material.reflectivity === 0) {
+        return [];
+    }
+    const ray = {
+        start: data.overPoint,
+        direction: data.reflectv,
+    };
+    return castRay(shapes, lights, ray, remaining - 1, attenuation * data.shape.material.reflectivity);
+}
+function castRefractedRay(shapes, lights, data, remaining, attenuation) {
+    if (remaining === 0 || data.shape.material.transparency === 0) {
+        // No refraction
+        return [];
+    }
+    const { n1, n2, eyev, normalv, underPoint } = data;
+    // Refractions
+    const nRatio = n1 / n2;
+    const cos_i = vec_dot(eyev, normalv);
+    const sin2_t = nRatio * nRatio * (1 - cos_i * cos_i);
+    if (sin2_t > 1) {
+        // Total internal reflection
+        return [];
+    }
+    const cos_t = Math.sqrt(1 - sin2_t);
+    const refractv = vec_sub(vec_mul(normalv, nRatio * cos_i - cos_t), vec_mul(eyev, nRatio));
+    const refractedRay = {
+        start: underPoint,
+        direction: refractv,
+    };
+    return castRay(shapes, lights, refractedRay, remaining - 1, attenuation * data.shape.material.transparency);
+}
+export function toggleSchlick() {
+    SCHLICK_ENABLED = !SCHLICK_ENABLED;
+}
+/* Uses the Schlick reflectance model to return the fraction of light that should be reflected
+on interface with a transparent materisl */
+function schlick(data) {
+    // Find the cosine of the angle between the eye and normal vectors
+    let cos = vec_dot(data.eyev, data.normalv);
+    // Total internal reflection can only occur if n1 > n2
+    if (data.n1 > data.n2) {
+        const n = data.n1 / data.n2;
+        const sin2_t = n * n * (1 - cos * cos);
+        if (sin2_t > 1) {
+            // Total internal reflection
+            return 1;
+        }
+        cos = Math.sqrt(1 - sin2_t);
+    }
+    const r0 = Math.pow((data.n1 - data.n2) / (data.n1 + data.n2), 2);
+    return r0 + (1 - r0) * Math.pow(1 - cos, 5);
+}
+function computeIntersectionData(hit, ray, intersections) {
+    const point = pointOnRay(ray, hit.t);
+    let normalv = hit.shape.normalAt(point);
+    const eyev = vec_mul(ray.direction, -1);
+    const inside = vec_dot(eyev, normalv) < 0;
+    if (inside) {
+        normalv = vec_mul(normalv, -1);
+    }
+    const nudge = vec_mul(normalv, 0.001);
+    const overPoint = vec_add(point, nudge);
+    const underPoint = vec_sub(point, nudge);
+    const reflectv = reflect(ray.direction, normalv);
+    // Determine the refractive indexes of the two materials the ray is transitioning between.
+    let n1 = 1.0;
+    let n2 = 1.0;
+    let containers = [];
+    for (const x of intersections) {
+        if (x === hit && containers.length > 0) {
+            n1 = containers[containers.length - 1].material.refractiveIndex;
+        }
+        if (containers.includes(x.shape)) {
+            containers = containers.filter((s) => s !== x.shape);
+        }
+        else {
+            containers.push(x.shape);
+        }
+        if (x === hit && containers.length > 0) {
+            n2 = containers[containers.length - 1].material.refractiveIndex;
+        }
+    }
+    return {
+        ...hit,
+        point,
+        eyev,
+        normalv,
+        inside,
+        overPoint,
+        underPoint,
+        reflectv,
+        n1,
+        n2,
+    };
+}
+function reflect(inVec, normal) {
+    return vec_sub(inVec, vec_mul(normal, 2 * vec_dot(inVec, normal)));
+}
+function pointOnRay(ray, t) {
+    return vec_add(ray.start, vec_mul(ray.direction, t));
+}
+function generateShadowRay(data, light, shapes) {
+    const o = toObjectTransform(light.transform);
+    const lightPos = newPoint(o.translation.x, o.translation.y);
+    const toLight = vec_sub(lightPos, data.overPoint);
+    const distance = vec_magnitude(toLight);
+    const direction = vec_normalize(toLight);
+    const ray = {
+        start: data.overPoint,
+        direction,
+    };
+    const intersections = shapes.flatMap((shape) => shape.intersect(ray).map((t) => ({ t, shape })));
+    intersections.sort((a, b) => a.t - b.t);
+    const hit = intersections.find((x) => x.t >= 0);
+    const shadowColor = light.color;
+    if (!hit || hit.t >= distance) {
+        // Unobstructed - draw full ray in light color
+        shadowRays.push({
+            start: data.point,
+            end: lightPos,
+            color: shadowColor,
+            attenuation: 1,
+        });
+    }
+    else {
+        // Obstructed - draw fainter dotted line from start to blocking object
+        const blockPoint = pointOnRay(ray, hit.t);
+        const faintColor = {
+            r: shadowColor.r * 0.5,
+            g: shadowColor.g * 0.5,
+            b: shadowColor.b * 0.5,
+        };
+        shadowRays.push({
+            start: data.point,
+            end: blockPoint,
+            color: faintColor,
+            attenuation: 1,
+            dashed: true,
+        });
+    }
+}
+/**
+ * Returns whether or not the given point is in shadow w.r.t. the given point light source.
+ */
+function isShadowed(point, shapes, light) {
+    const o = toObjectTransform(light.transform);
+    const v = vec_sub(newPoint(o.translation.x, o.translation.y), point);
+    const distance = vec_magnitude(v);
+    const direction = vec_normalize(v);
+    const ray = {
+        start: point,
+        direction,
+    };
+    const intersections = shapes.flatMap((shape) => shape.intersect(ray).map((t) => ({ t, shape })));
+    intersections.sort((a, b) => a.t - b.t);
+    const hit = intersections.find((x) => x.t >= 0);
+    return hit != null && hit.t < distance;
+}

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

@@ -0,0 +1,15 @@
+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";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vision/raymond/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,oBAAoB,CAAC;AACnC,cAAc,sCAAsC,CAAC"}