@backbay/glia 0.2.0-alpha.1

package/dist/vision/adapters/canvasCapture.js

@@ -0,0 +1,64 @@
+export class CanvasCaptureAdapter {
+    id;
+    label;
+    getCanvas;
+    topologyProvider;
+    channelId;
+    format;
+    quality;
+    constructor(options) {
+        this.id = options.id ?? "canvas-capture";
+        this.label = options.label;
+        this.getCanvas = options.getCanvas;
+        this.topologyProvider = options.getTopology;
+        this.channelId = options.channelId ?? "color";
+        this.format = options.format ?? "image/png";
+        this.quality = options.quality;
+    }
+    getTopology() {
+        return this.topologyProvider?.() ?? null;
+    }
+    async capture(options) {
+        const canvas = this.getCanvas();
+        const capturedAt = Date.now();
+        if (!canvas) {
+            return {
+                source: this.id,
+                capturedAt,
+                channels: [],
+                topology: options?.includeTopology ? this.topologyProvider?.() ?? undefined : undefined,
+                meta: { error: "canvas_unavailable" },
+            };
+        }
+        const targetSize = options?.size ?? { width: canvas.width, height: canvas.height };
+        const outputCanvas = targetSize.width === canvas.width && targetSize.height === canvas.height
+            ? canvas
+            : this.scaleCanvas(canvas, targetSize.width, targetSize.height);
+        const dataUrl = outputCanvas.toDataURL(this.format, this.quality);
+        const channel = {
+            id: this.channelId,
+            kind: "color",
+            data: dataUrl,
+            width: targetSize.width,
+            height: targetSize.height,
+            meta: { format: this.format },
+        };
+        return {
+            source: this.id,
+            capturedAt,
+            size: targetSize,
+            channels: [channel],
+            topology: options?.includeTopology ? this.topologyProvider?.() ?? undefined : undefined,
+        };
+    }
+    scaleCanvas(source, width, height) {
+        const scaled = document.createElement("canvas");
+        scaled.width = width;
+        scaled.height = height;
+        const ctx = scaled.getContext("2d");
+        if (ctx) {
+            ctx.drawImage(source, 0, 0, width, height);
+        }
+        return scaled;
+    }
+}

package/dist/vision/adapters/raymondAdapter.d.ts

@@ -0,0 +1,62 @@
+import type { VisionAdapter, VisionCaptureOptions, VisionFrame, VisionTopology, VisionTopologyNode } from "../types.js";
+import { type Shape } from "../raymond/shapes.js";
+import { Eye } from "../raymond/canvas/Eye.js";
+import { PointLight } from "../raymond/canvas/PointLight.js";
+import type { LightingModel, LightingModelParams } from "../raymond/canvas/lightingModel.js";
+import { type Material } from "../raymond/shared/material.js";
+export interface RaymondEyeOptions {
+    position?: [number, number];
+    rotation?: number;
+    fov?: number;
+    rays?: number;
+}
+export interface RaymondLightOptions {
+    position: [number, number];
+    color?: string;
+}
+export interface RaymondScene {
+    eye: Eye;
+    shapes: Shape[];
+    lights: PointLight[];
+    lightingModel: LightingModel;
+    lightingParams: LightingModelParams;
+}
+export interface RaymondVisionAdapterOptions {
+    id?: string;
+    label?: string;
+    topologyProvider?: () => VisionTopology | null;
+    sceneProvider?: () => RaymondScene | null;
+    eye?: RaymondEyeOptions;
+    lights?: RaymondLightOptions[];
+    axis?: "xy" | "xz" | "yz";
+    scale?: number;
+    includeSegments?: boolean;
+    includeShadowRays?: boolean;
+    lightingModel?: LightingModel;
+    lightingParams?: LightingModelParams;
+    nodeMaterial?: (node: VisionTopologyNode, fallback: Material) => Material;
+    nodeShape?: (node: VisionTopologyNode) => "circle" | "quad";
+}
+export declare class RaymondVisionAdapter implements VisionAdapter {
+    id: string;
+    label?: string;
+    private topologyProvider?;
+    private sceneProvider?;
+    private eyeOptions;
+    private lights;
+    private axis;
+    private scale;
+    private includeSegments;
+    private includeShadowRays;
+    private lightingModel?;
+    private lightingParams?;
+    private nodeMaterial?;
+    private nodeShape?;
+    constructor(options?: RaymondVisionAdapterOptions);
+    getTopology(): VisionTopology | null;
+    capture(options?: VisionCaptureOptions): Promise<VisionFrame>;
+    private buildSceneFromTopology;
+    private mapNodeToShape;
+    private nodeScale;
+}
+//# sourceMappingURL=raymondAdapter.d.ts.map

package/dist/vision/adapters/raymondAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raymondAdapter.d.ts","sourceRoot":"","sources":["../../../src/vision/adapters/raymondAdapter.ts"],"names":[],"mappings":"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"}

package/dist/vision/adapters/raymondAdapter.js

@@ -0,0 +1,227 @@
+import { Circle, Quad } from "../raymond/shapes.js";
+import { Eye } from "../raymond/canvas/Eye.js";
+import { PointLight } from "../raymond/canvas/PointLight.js";
+import { PhongTracingModel } from "../raymond/canvas/models/phongTracingModel.js";
+import { defaultMaterial } from "../raymond/shared/material.js";
+import { fromObjectTransform } from "../raymond/transform.js";
+import { newVector } from "../raymond/math.js";
+export class RaymondVisionAdapter {
+    id;
+    label;
+    topologyProvider;
+    sceneProvider;
+    eyeOptions;
+    lights;
+    axis;
+    scale;
+    includeSegments;
+    includeShadowRays;
+    lightingModel;
+    lightingParams;
+    nodeMaterial;
+    nodeShape;
+    constructor(options = {}) {
+        this.id = options.id ?? "raymond-vision";
+        this.label = options.label;
+        this.topologyProvider = options.topologyProvider;
+        this.sceneProvider = options.sceneProvider;
+        this.eyeOptions = options.eye ?? {};
+        this.lights = options.lights ?? [{ position: [-4, 2], color: "#ffffff" }];
+        this.axis = options.axis ?? "xz";
+        this.scale = options.scale ?? 1;
+        this.includeSegments = options.includeSegments ?? false;
+        this.includeShadowRays = options.includeShadowRays ?? false;
+        this.lightingModel = options.lightingModel;
+        this.lightingParams = options.lightingParams;
+        this.nodeMaterial = options.nodeMaterial;
+        this.nodeShape = options.nodeShape;
+    }
+    getTopology() {
+        return this.topologyProvider?.() ?? null;
+    }
+    async capture(options) {
+        const capturedAt = Date.now();
+        const topology = this.topologyProvider?.() ?? undefined;
+        const scene = this.sceneProvider?.() ?? this.buildSceneFromTopology(topology, options);
+        if (!scene) {
+            return {
+                source: this.id,
+                capturedAt,
+                channels: [],
+                topology: options?.includeTopology ? topology : undefined,
+                meta: { error: "scene_unavailable" },
+            };
+        }
+        const result = scene.lightingModel.computeSegments(scene.eye, scene.shapes, scene.lights, scene.lightingParams);
+        const visionChannel = {
+            id: "raymond:vision",
+            kind: "raymond/vision",
+            data: result.vision,
+            width: result.vision.length,
+            height: 1,
+        };
+        const channels = [visionChannel];
+        if (this.includeSegments) {
+            channels.push({
+                id: "raymond:segments",
+                kind: "raymond/segments",
+                data: result.segments,
+            });
+        }
+        if (this.includeShadowRays) {
+            channels.push({
+                id: "raymond:shadow-rays",
+                kind: "raymond/shadow-rays",
+                data: result.shadowRays,
+            });
+        }
+        return {
+            source: this.id,
+            capturedAt,
+            size: { width: result.vision.length, height: 1 },
+            channels,
+            topology: options?.includeTopology ? topology : undefined,
+            meta: {
+                lightingModel: scene.lightingModel.id,
+            },
+        };
+    }
+    buildSceneFromTopology(topology, options) {
+        const model = this.lightingModel ?? new PhongTracingModel();
+        const lightingParams = this.lightingParams ?? defaultLightingParams(model);
+        const nodes = topology?.nodes ?? [];
+        const shapes = nodes
+            .map((node) => this.mapNodeToShape(node))
+            .filter((shape) => Boolean(shape));
+        const lights = this.lights.map((light) => {
+            const transform = fromObjectTransform({
+                translation: newVector(light.position[0], light.position[1]),
+                rotation: 0,
+                scale: newVector(1, 1),
+            });
+            return new PointLight(hexToColor(light.color ?? "#ffffff"), transform);
+        });
+        const eye = buildEye(nodes, this.eyeOptions, this.axis, options);
+        return {
+            eye,
+            shapes,
+            lights,
+            lightingModel: model,
+            lightingParams,
+        };
+    }
+    mapNodeToShape(node) {
+        if (!node.position)
+            return null;
+        const [x, y] = projectPosition(node.position, this.axis);
+        const scale = this.nodeScale(node) * this.scale;
+        const transform = fromObjectTransform({
+            translation: newVector(x, y),
+            rotation: 0,
+            scale: newVector(scale, scale),
+        });
+        const baseMaterial = defaultMaterial();
+        const material = this.nodeMaterial
+            ? this.nodeMaterial(node, baseMaterial)
+            : { ...baseMaterial, color: hexToColor(node.color ?? "#66cc66") };
+        const shape = this.nodeShape?.(node) ?? inferShape(node);
+        return shape === "quad"
+            ? new Quad(transform, material)
+            : new Circle(transform, material);
+    }
+    nodeScale(node) {
+        if (node.radius)
+            return Math.max(node.radius, 0.05);
+        if (node.bounds) {
+            const dx = Math.abs(node.bounds.max[0] - node.bounds.min[0]);
+            const dy = Math.abs(node.bounds.max[1] - node.bounds.min[1]);
+            const dz = Math.abs(node.bounds.max[2] - node.bounds.min[2]);
+            return Math.max(dx, dy, dz) / 2;
+        }
+        return 0.5;
+    }
+}
+function defaultLightingParams(model) {
+    const params = {};
+    for (const param of model.parameters) {
+        params[param.id] = param.default;
+    }
+    return params;
+}
+function buildEye(nodes, options, axis, captureOptions) {
+    const bounds = computeBounds(nodes, axis);
+    const position = options.position ?? [bounds.minX - 4, bounds.centerY];
+    const rotation = options.rotation ?? 0;
+    const transform = fromObjectTransform({
+        translation: newVector(position[0], position[1]),
+        rotation,
+        scale: newVector(1, 1),
+    });
+    const eye = new Eye(transform);
+    eye.fov = options.fov ?? Math.PI / 3;
+    const targetRays = options.rays ?? captureOptions?.size?.width ?? 120;
+    eye.numRays = Math.max(1, Math.min(240, Math.round(targetRays)));
+    return eye;
+}
+function inferShape(node) {
+    const explicit = node.meta?.shape;
+    if (explicit === "quad" || explicit === "circle")
+        return explicit;
+    return node.type === "node" ? "quad" : "circle";
+}
+function projectPosition(position, axis) {
+    const [x, y, z] = position;
+    switch (axis) {
+        case "xz":
+            return [x, z];
+        case "yz":
+            return [y, z];
+        case "xy":
+        default:
+            return [x, y];
+    }
+}
+function computeBounds(nodes, axis) {
+    const initial = {
+        minX: 0,
+        maxX: 0,
+        minY: 0,
+        maxY: 0,
+        centerY: 0,
+    };
+    if (nodes.length === 0)
+        return initial;
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    nodes.forEach((node) => {
+        if (!node.position)
+            return;
+        const [x, y] = projectPosition(node.position, axis);
+        minX = Math.min(minX, x);
+        maxX = Math.max(maxX, x);
+        minY = Math.min(minY, y);
+        maxY = Math.max(maxY, y);
+    });
+    if (!Number.isFinite(minX)) {
+        return initial;
+    }
+    return {
+        minX,
+        maxX,
+        minY,
+        maxY,
+        centerY: (minY + maxY) / 2,
+    };
+}
+function hexToColor(input) {
+    const hex = input.replace("#", "");
+    if (hex.length !== 6) {
+        return { r: 1, g: 1, b: 1 };
+    }
+    const r = Number.parseInt(hex.slice(0, 2), 16) / 255;
+    const g = Number.parseInt(hex.slice(2, 4), 16) / 255;
+    const b = Number.parseInt(hex.slice(4, 6), 16) / 255;
+    return { r, g, b };
+}

package/dist/vision/hooks/useVisionCaptureController.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+export type VisionCaptureMode = "manual" | "interval" | "topology";
+export interface VisionCaptureControllerOptions {
+    capture: () => Promise<void>;
+    ready?: boolean;
+    topology?: unknown;
+    initialMode?: VisionCaptureMode;
+    initialIntervalMs?: number;
+    minIntervalMs?: number;
+}
+export interface VisionCaptureControllerState {
+    mode: VisionCaptureMode;
+    setMode: React.Dispatch<React.SetStateAction<VisionCaptureMode>>;
+    intervalMs: number;
+    setIntervalMs: React.Dispatch<React.SetStateAction<number>>;
+    busy: boolean;
+    captureNow: () => Promise<void>;
+    requestCapture: () => void;
+}
+export declare function useVisionCaptureController(options: VisionCaptureControllerOptions): VisionCaptureControllerState;
+//# sourceMappingURL=useVisionCaptureController.d.ts.map

package/dist/vision/hooks/useVisionCaptureController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVisionCaptureController.d.ts","sourceRoot":"","sources":["../../../src/vision/hooks/useVisionCaptureController.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAC;AAEnE,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,8BAA8B,GACtC,4BAA4B,CA2D9B"}

package/dist/vision/hooks/useVisionCaptureController.js

@@ -0,0 +1,55 @@
+import * as React from "react";
+export function useVisionCaptureController(options) {
+    const { capture, ready = true, topology, initialMode = "manual", initialIntervalMs = 2000, minIntervalMs = 500, } = options;
+    const [mode, setMode] = React.useState(initialMode);
+    const [intervalMs, setIntervalMs] = React.useState(initialIntervalMs);
+    const [busy, setBusy] = React.useState(false);
+    const busyRef = React.useRef(false);
+    const lastCaptureRef = React.useRef(0);
+    const captureNow = React.useCallback(async () => {
+        if (!ready || busyRef.current)
+            return;
+        busyRef.current = true;
+        setBusy(true);
+        try {
+            await capture();
+        }
+        finally {
+            setBusy(false);
+            busyRef.current = false;
+        }
+    }, [capture, ready]);
+    const requestCapture = React.useCallback(() => {
+        if (!ready || busyRef.current)
+            return;
+        const now = Date.now();
+        if (now - lastCaptureRef.current < minIntervalMs)
+            return;
+        lastCaptureRef.current = now;
+        void captureNow();
+    }, [ready, captureNow, minIntervalMs]);
+    React.useEffect(() => {
+        if (!ready || mode !== "interval")
+            return;
+        const intervalId = window.setInterval(() => {
+            requestCapture();
+        }, Math.max(minIntervalMs, intervalMs));
+        return () => window.clearInterval(intervalId);
+    }, [mode, intervalMs, ready, requestCapture, minIntervalMs]);
+    React.useEffect(() => {
+        if (!ready || mode !== "topology")
+            return;
+        if (!topology)
+            return;
+        requestCapture();
+    }, [mode, topology, ready, requestCapture]);
+    return {
+        mode,
+        setMode,
+        intervalMs,
+        setIntervalMs,
+        busy,
+        captureNow,
+        requestCapture,
+    };
+}

package/dist/vision/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./adapters/canvasCapture.js";
+export * from "./adapters/raymondAdapter.js";
+export * from "./hooks/useVisionCaptureController.js";
+export * from "./raymond/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vision/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,oBAAoB,CAAC"}

package/dist/vision/index.js

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./adapters/canvasCapture.js";
+export * from "./adapters/raymondAdapter.js";
+export * from "./hooks/useVisionCaptureController.js";
+export * from "./raymond/index.js";

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

@@ -0,0 +1,36 @@
+import { type Vec3 } from "./math.js";
+import { type Transform } from "./transform.js";
+export interface CameraSetup {
+    center: Vec3;
+    size: Vec3;
+    rotation: number;
+}
+export default class Camera {
+    screenWidth: number;
+    screenHeight: number;
+    transform: Transform;
+    constructor(screenWidth: number, screenHeight: number);
+    _initialTransform(screenWidth: number, screenHeight: number): Transform;
+    /**
+     * Given a point in world space, returns the pixel coordinates at which it should appear on the screen.
+     */
+    worldToScreen(point: Vec3): Vec3;
+    setSetup(s: CameraSetup): void;
+    getSetup(): CameraSetup;
+    /**
+     * Given a point on the screen in pixel coordinates, returns the point in world space this represents.
+     */
+    screenToWorld(point: Vec3): Vec3;
+    /**
+     * Zooms the camera in or out.
+     * @param fraction The fraction by which to zoom in or out. E.g. +0.1 zooms in 10%. -0.1 zooms out 10%.
+     * @param invariantPoint Typically the mouse position. The point in screen space which should be unaffected by this zoom transformation.
+     */
+    zoom(fraction: number, invariantPoint: Vec3): void;
+    /**
+     * Pans the camera the given distance in screen space
+     */
+    pan(delta: Vec3): void;
+    static interpSetup(a: CameraSetup, b: CameraSetup, x: number): CameraSetup;
+}
+//# sourceMappingURL=camera.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../../../src/vision/raymond/camera.ts"],"names":[],"mappings":"AAAA,OAAO,EAOH,KAAK,IAAI,EACZ,MAAM,WAAW,CAAC;AACnB,OAAO,EACH,KAAK,SAAS,EAMjB,MAAM,gBAAgB,CAAC;AAGxB,MAAM,WAAW,WAAW;IACxB,MAAM,EAAE,IAAI,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,CAAC,OAAO,OAAO,MAAM;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,SAAS,CAAC;gBAET,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IAMrD,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,SAAS;IAUvE;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI;IAIhC,QAAQ,CAAC,CAAC,EAAE,WAAW;IAwBvB,QAAQ,IAAI,WAAW;IAyCvB;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI;IAIhC;;;;OAIG;IACH,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,IAAI;IAY3C;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,IAAI;IAMf,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW;CA4B7E"}

package/dist/vision/raymond/camera.js

@@ -0,0 +1,129 @@
+import { mat3_chain, mat3_identity, mat3_inverse, newVector, vec_add, vec_mul, } from "./math.js";
+import { apply, inverse, fromObjectTransform, scaling, translation, } from "./transform.js";
+export default class Camera {
+    screenWidth;
+    screenHeight;
+    transform;
+    constructor(screenWidth, screenHeight) {
+        this.screenWidth = screenWidth;
+        this.screenHeight = screenHeight;
+        this.transform = this._initialTransform(screenWidth, screenHeight);
+    }
+    _initialTransform(screenWidth, screenHeight) {
+        // Flip so y axis points upwards and stretch so each unit is much larger than one pixel.
+        // Translate so origin is at centre of screen.
+        return fromObjectTransform({
+            scale: newVector(100, -100),
+            rotation: 0,
+            translation: newVector(screenWidth / 2, screenHeight / 2),
+        });
+    }
+    /**
+     * Given a point in world space, returns the pixel coordinates at which it should appear on the screen.
+     */
+    worldToScreen(point) {
+        return apply(this.transform, point);
+    }
+    setSetup(s) {
+        const cos = Math.cos(s.rotation);
+        const sin = Math.sin(s.rotation);
+        // scale from world-units-in-camera-space to pixels
+        const sx = this.screenWidth / s.size.x; // world width -> viewport width
+        const sy = this.screenHeight / s.size.y; // world height -> viewport height
+        const m00 = sx * cos;
+        const m01 = sx * sin;
+        const m02 = -s.center.x * m00 - s.center.y * m01 + this.screenWidth / 2;
+        const m10 = sy * sin;
+        const m11 = -sy * cos; // minus to flip Y so screen y is down
+        const m12 = -s.center.x * m10 - s.center.y * m11 + this.screenHeight / 2;
+        this.transform = [
+            [m00, m01, m02],
+            [m10, m11, m12],
+            [0, 0, 1],
+        ];
+    }
+    getSetup() {
+        const [[m00, m01, m02], [m10, m11, m12], [_m20, _m21, _m22]] = this.transform;
+        // Extract scales (sx, sy) from the rotation+scale part.
+        const sx = Math.hypot(m00, m01); // = viewportWidth / size.x
+        const sy = Math.hypot(m10, m11); // = viewportHeight / size.y
+        if (sx === 0 || sy === 0) {
+            throw new Error("Non-invertible camera matrix: zero scale.");
+        }
+        // Recover rotation.
+        const rotation = Math.atan2(m01, m00);
+        // Recover size from scales.
+        const sizeX = this.screenWidth / sx;
+        const sizeY = this.screenHeight / sy;
+        // Solve for center:
+        const b0 = this.screenWidth / 2 - m02;
+        const b1 = this.screenHeight / 2 - m12;
+        const det = m00 * m11 - m01 * m10;
+        const eps = 1e-12;
+        if (Math.abs(det) < eps) {
+            throw new Error("Non-invertible camera matrix: rotation/scale block is singular.");
+        }
+        const cx = (b0 * m11 - b1 * m01) / det;
+        const cy = (m00 * b1 - m10 * b0) / det;
+        return {
+            center: { x: cx, y: cy, w: 1 },
+            size: { x: sizeX, y: sizeY, w: 0 },
+            rotation,
+        };
+    }
+    /**
+     * Given a point on the screen in pixel coordinates, returns the point in world space this represents.
+     */
+    screenToWorld(point) {
+        return apply(inverse(this.transform), point);
+    }
+    /**
+     * Zooms the camera in or out.
+     * @param fraction The fraction by which to zoom in or out. E.g. +0.1 zooms in 10%. -0.1 zooms out 10%.
+     * @param invariantPoint Typically the mouse position. The point in screen space which should be unaffected by this zoom transformation.
+     */
+    zoom(fraction, invariantPoint) {
+        const invariantWorld = this.screenToWorld(invariantPoint);
+        const trans = translation(invariantWorld.x, invariantWorld.y);
+        const transInv = mat3_inverse(trans) ?? mat3_identity();
+        this.transform = mat3_chain([
+            this.transform,
+            trans,
+            scaling(1 - fraction),
+            transInv,
+        ]);
+    }
+    /**
+     * Pans the camera the given distance in screen space
+     */
+    pan(delta) {
+        const deltaWorld = this.screenToWorld(vec_mul(delta, -1));
+        const setup = this.getSetup();
+        this.setSetup({ ...setup, center: vec_add(setup.center, deltaWorld) });
+    }
+    static interpSetup(a, b, x) {
+        // Clamp x to [0, 1]
+        const t = Math.max(0, Math.min(1, x));
+        // Decompose both cameras into CameraSetup parameters
+        // Interpolate rotation safely (optionally handle wrap-around)
+        let dRot = b.rotation - a.rotation;
+        // Wrap shortest path around ±π
+        if (dRot > Math.PI)
+            dRot -= 2 * Math.PI;
+        else if (dRot < -Math.PI)
+            dRot += 2 * Math.PI;
+        const rotation = a.rotation + t * dRot;
+        // Interpolate position and size
+        const center = {
+            x: a.center.x + t * (b.center.x - a.center.x),
+            y: a.center.y + t * (b.center.y - a.center.y),
+            w: 1,
+        };
+        const size = {
+            x: a.size.x + t * (b.size.x - a.size.x),
+            y: a.size.y + t * (b.size.y - a.size.y),
+            w: 0,
+        };
+        return { center, size, rotation };
+    }
+}

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

@@ -0,0 +1,12 @@
+import { type Vec3 } from "../math";
+import { type Transform } from "../transform";
+export declare class Eye {
+    transform: Transform;
+    numRays: number;
+    fov: number;
+    constructor(transform: Transform);
+    hitTest(worldPoint: Vec3): boolean;
+    handlePositions(): Vec3[];
+    handleMoved(handleIndex: number, _: Vec3, newPos: Vec3): void;
+}
+//# sourceMappingURL=Eye.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Eye.d.ts","sourceRoot":"","sources":["../../../../src/vision/raymond/canvas/Eye.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,IAAI,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,EAAmC,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAI/E,qBAAa,GAAG;IACZ,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,MAAM,CAAY;IAC3B,GAAG,EAAE,MAAM,CAAe;gBAEd,SAAS,EAAE,SAAS;IAIhC,OAAO,CAAC,UAAU,EAAE,IAAI,GAAG,OAAO;IAelC,eAAe,IAAI,IAAI,EAAE;IAezB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI;CAuBzD"}