@woosh/meep-engine 3.14.2 → 3.14.3

package/src/shade/playground/texture_encode/panel_view.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Where the picture sits on a panel: the panel pixel of texel (0, 0) and how many panel pixels a
+ * texel spans. Panel pixels are CSS pixels; the device pixel ratio is applied at drawing time.
+ *
+ * @typedef {Object} PanelView
+ * @property {number} scale panel pixels per texel
+ * @property {number} x panel pixel of texel column 0
+ * @property {number} y panel pixel of texel row 0
+ */
+/**
+ * The view that fits a picture into a square panel, centred: the largest scale at which all of it
+ * is inside.
+ *
+ * @param {number} width texels
+ * @param {number} height texels
+ * @param {number} size panel side, panel pixels
+ * @returns {PanelView}
+ */
+export function panel_view_fit(width: number, height: number, size: number): PanelView;
+/**
+ * The view after zooming by a factor about a point of the panel: the texel under that point is the
+ * same texel afterwards. The scale is held between the bounds, and at a bound the factor is reduced
+ * to what the bound allows rather than the zoom refused, so the anchor holds there too.
+ *
+ * @param {PanelView} view
+ * @param {number} px panel pixel the zoom is about
+ * @param {number} py
+ * @param {number} factor above one zooms in
+ * @param {number} minimum_scale
+ * @param {number} maximum_scale
+ * @returns {PanelView}
+ */
+export function panel_view_zoom(view: PanelView, px: number, py: number, factor: number, minimum_scale: number, maximum_scale: number): PanelView;
+/**
+ * The view moved by a panel-pixel offset.
+ *
+ * @param {PanelView} view
+ * @param {number} dx
+ * @param {number} dy
+ * @returns {PanelView}
+ */
+export function panel_view_pan(view: PanelView, dx: number, dy: number): PanelView;
+/**
+ * The texel under a point of the panel, fractional: (0.5, 0.5) is the centre of the first texel,
+ * and a point off the picture gives a coordinate outside [0, width) or [0, height).
+ *
+ * @param {PanelView} view
+ * @param {number} px
+ * @param {number} py
+ * @returns {{x: number, y: number}}
+ */
+export function panel_view_texel(view: PanelView, px: number, py: number): {
+    x: number;
+    y: number;
+};
+/**
+ * The panel point of a texel coordinate; the inverse of {@link panel_view_texel}.
+ *
+ * @param {PanelView} view
+ * @param {number} tx
+ * @param {number} ty
+ * @returns {{x: number, y: number}}
+ */
+export function panel_view_point(view: PanelView, tx: number, ty: number): {
+    x: number;
+    y: number;
+};
+/**
+ * @typedef {Object} PanelGroup
+ * @property {function(number, Uint8Array, number, number): void} set_picture put opaque RGBA bytes
+ * on a panel: `(panel, rgba, width, height)`. A size different from the pictures already shown
+ * starts over: the other panels are cleared until they are set again and the view is refitted.
+ */
+/**
+ * Wire square canvases into panels that share one view and one cursor.
+ *
+ * @param {Object} options
+ * @param {HTMLCanvasElement[]} options.canvases one per panel
+ * @param {number} options.size side of every panel, CSS pixels
+ * @param {function(?{x: number, y: number}): void} options.on_cursor called when the texel under
+ * the cursor changes, with its integer coordinates, or with null when the cursor leaves the picture
+ * @returns {PanelGroup}
+ */
+export function create_panel_group({ canvases, size, on_cursor }: {
+    canvases: HTMLCanvasElement[];
+    size: number;
+    on_cursor: (arg0: {
+        x: number;
+        y: number;
+    } | null) => void;
+}): PanelGroup;
+/**
+ * Where the picture sits on a panel: the panel pixel of texel (0, 0) and how many panel pixels a
+ * texel spans. Panel pixels are CSS pixels; the device pixel ratio is applied at drawing time.
+ */
+export type PanelView = {
+    /**
+     * panel pixels per texel
+     */
+    scale: number;
+    /**
+     * panel pixel of texel column 0
+     */
+    x: number;
+    /**
+     * panel pixel of texel row 0
+     */
+    y: number;
+};
+export type PanelGroup = {
+    /**
+     * put opaque RGBA bytes
+     * on a panel: `(panel, rgba, width, height)`. A size different from the pictures already shown
+     * starts over: the other panels are cleared until they are set again and the view is refitted.
+     */
+    set_picture: (arg0: number, arg1: Uint8Array, arg2: number, arg3: number) => void;
+};
+//# sourceMappingURL=panel_view.d.ts.map

package/src/shade/playground/texture_encode/panel_view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel_view.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/texture_encode/panel_view.js"],"names":[],"mappings":"AAeA;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,sCALW,MAAM,UACN,MAAM,QACN,MAAM,GACJ,SAAS,CAUrB;AAED;;;;;;;;;;;;GAYG;AACH,sCARW,SAAS,MACT,MAAM,MACN,MAAM,UACN,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,SAAS,CAWrB;AAED;;;;;;;GAOG;AACH,qCALW,SAAS,MACT,MAAM,MACN,MAAM,GACJ,SAAS,CAQrB;AAED;;;;;;;;GAQG;AACH,uCALW,SAAS,MACT,MAAM,MACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAOlC;AAED;;;;;;;GAOG;AACH,uCALW,SAAS,MACT,MAAM,MACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAOlC;AAkCD;;;;;GAKG;AAEH;;;;;;;;;GASG;AACH;IANwC,QAAQ,EAArC,iBAAiB,EAAE;IACH,IAAI,EAApB,MAAM;IAC2C,SAAS,SAAhD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,YAAG,IAAI;IAErC,UAAU,CAwMtB;;;;;;;;;WAtVa,MAAM;;;;OACN,MAAM;;;;OACN,MAAM;;;;;;;;wBA+HG,MAAM,QAAE,UAAU,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI"}

package/src/shade/playground/texture_encode/panel_view.js

@@ -0,0 +1,363 @@
+/**
+ * Three canvases showing one place in one picture: the source, the hardware's decode of it and the
+ * FLIP map between them share a view — the wheel zooms about the pointer, a drag pans, a double
+ * click refits — and a cursor that marks the same texel on all three, drawn as an open circle so
+ * what is under it stays visible.
+ *
+ * The view arithmetic is in free functions so it can be pinned without a document; the wiring to
+ * canvases and pointer events is {@link create_panel_group}.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+import { assert } from "../../../core/assert.js";
+
+/**
+ * Where the picture sits on a panel: the panel pixel of texel (0, 0) and how many panel pixels a
+ * texel spans. Panel pixels are CSS pixels; the device pixel ratio is applied at drawing time.
+ *
+ * @typedef {Object} PanelView
+ * @property {number} scale panel pixels per texel
+ * @property {number} x panel pixel of texel column 0
+ * @property {number} y panel pixel of texel row 0
+ */
+
+/**
+ * The view that fits a picture into a square panel, centred: the largest scale at which all of it
+ * is inside.
+ *
+ * @param {number} width texels
+ * @param {number} height texels
+ * @param {number} size panel side, panel pixels
+ * @returns {PanelView}
+ */
+export function panel_view_fit(width, height, size) {
+    const scale = size / Math.max(width, height);
+
+    return {
+        scale,
+        x: (size - width * scale) / 2,
+        y: (size - height * scale) / 2
+    };
+}
+
+/**
+ * The view after zooming by a factor about a point of the panel: the texel under that point is the
+ * same texel afterwards. The scale is held between the bounds, and at a bound the factor is reduced
+ * to what the bound allows rather than the zoom refused, so the anchor holds there too.
+ *
+ * @param {PanelView} view
+ * @param {number} px panel pixel the zoom is about
+ * @param {number} py
+ * @param {number} factor above one zooms in
+ * @param {number} minimum_scale
+ * @param {number} maximum_scale
+ * @returns {PanelView}
+ */
+export function panel_view_zoom(view, px, py, factor, minimum_scale, maximum_scale) {
+    const scale = Math.min(maximum_scale, Math.max(minimum_scale, view.scale * factor));
+    const applied = scale / view.scale;
+
+    return {
+        scale,
+        x: px - (px - view.x) * applied,
+        y: py - (py - view.y) * applied
+    };
+}
+
+/**
+ * The view moved by a panel-pixel offset.
+ *
+ * @param {PanelView} view
+ * @param {number} dx
+ * @param {number} dy
+ * @returns {PanelView}
+ */
+export function panel_view_pan(view, dx, dy) {
+    return {
+        scale: view.scale,
+        x: view.x + dx,
+        y: view.y + dy
+    };
+}
+
+/**
+ * The texel under a point of the panel, fractional: (0.5, 0.5) is the centre of the first texel,
+ * and a point off the picture gives a coordinate outside [0, width) or [0, height).
+ *
+ * @param {PanelView} view
+ * @param {number} px
+ * @param {number} py
+ * @returns {{x: number, y: number}}
+ */
+export function panel_view_texel(view, px, py) {
+    return {
+        x: (px - view.x) / view.scale,
+        y: (py - view.y) / view.scale
+    };
+}
+
+/**
+ * The panel point of a texel coordinate; the inverse of {@link panel_view_texel}.
+ *
+ * @param {PanelView} view
+ * @param {number} tx
+ * @param {number} ty
+ * @returns {{x: number, y: number}}
+ */
+export function panel_view_point(view, tx, ty) {
+    return {
+        x: view.x + tx * view.scale,
+        y: view.y + ty * view.scale
+    };
+}
+
+/**
+ * A wheel notch is a hundred pixels of delta in Chromium; this makes a notch about a fifth in or
+ * out.
+ *
+ * @type {number}
+ */
+const WHEEL_ZOOM_RATE = 0.002;
+
+/**
+ * A line of wheel delta, where a browser reports lines rather than pixels
+ * @type {number}
+ */
+const WHEEL_LINE_PIXELS = 16;
+
+/**
+ * The widest a texel is drawn, panel pixels
+ * @type {number}
+ */
+const MAXIMUM_SCALE = 64;
+
+/**
+ * How far out of the fitted view the picture can be pushed, as a fraction of the fitted scale
+ * @type {number}
+ */
+const MINIMUM_SCALE_OF_FIT = 0.5;
+
+/**
+ * Radius of the cursor circle, panel pixels
+ * @type {number}
+ */
+const CURSOR_RADIUS = 9;
+
+/**
+ * @typedef {Object} PanelGroup
+ * @property {function(number, Uint8Array, number, number): void} set_picture put opaque RGBA bytes
+ * on a panel: `(panel, rgba, width, height)`. A size different from the pictures already shown
+ * starts over: the other panels are cleared until they are set again and the view is refitted.
+ */
+
+/**
+ * Wire square canvases into panels that share one view and one cursor.
+ *
+ * @param {Object} options
+ * @param {HTMLCanvasElement[]} options.canvases one per panel
+ * @param {number} options.size side of every panel, CSS pixels
+ * @param {function(?{x: number, y: number}): void} options.on_cursor called when the texel under
+ * the cursor changes, with its integer coordinates, or with null when the cursor leaves the picture
+ * @returns {PanelGroup}
+ */
+export function create_panel_group({ canvases, size, on_cursor }) {
+    assert.isNumber(size, 'size');
+    assert.greaterThan(size, 0, 'size');
+
+    const panels = canvases.map(canvas => {
+        canvas.style.width = `${size}px`;
+        canvas.style.height = `${size}px`;
+
+        return {
+            canvas,
+            context: canvas.getContext('2d'),
+            /** @type {?HTMLCanvasElement} the picture at its own resolution */
+            image: null
+        };
+    });
+
+    let width = 0;
+    let height = 0;
+
+    let fitted = panel_view_fit(1, 1, size);
+    let view = fitted;
+
+    /** @type {?{x: number, y: number}} fractional texel under the pointer, inside the picture */
+    let cursor = null;
+
+    /** @type {?{x: number, y: number}} the integer texel last given to `on_cursor` */
+    let reported = null;
+
+    /** @type {?{x: number, y: number, view: PanelView}} where a drag started, and the view then */
+    let drag = null;
+
+    function render() {
+        const dpr = window.devicePixelRatio || 1;
+        const backing = Math.round(size * dpr);
+
+        for (const panel of panels) {
+            const { canvas, context } = panel;
+
+            if (canvas.width !== backing || canvas.height !== backing) {
+                canvas.width = backing;
+                canvas.height = backing;
+            }
+
+            context.setTransform(dpr, 0, 0, dpr, 0, 0);
+            context.fillStyle = '#000';
+            context.fillRect(0, 0, size, size);
+
+            if (panel.image !== null) {
+                // nearest where a texel is wider than a pixel, so a block is a block; the browser's
+                // filter where it is narrower, so an overview is an average rather than every fifth
+                // texel
+                context.imageSmoothingEnabled = view.scale < 1;
+                context.imageSmoothingQuality = 'high';
+
+                context.setTransform(dpr * view.scale, 0, 0, dpr * view.scale, dpr * view.x, dpr * view.y);
+                context.drawImage(panel.image, 0, 0);
+                context.setTransform(dpr, 0, 0, dpr, 0, 0);
+            }
+
+            if (cursor !== null) {
+                const point = panel_view_point(view, cursor.x, cursor.y);
+
+                // a dark ring under a light one reads on the black of an unseen difference and on
+                // the yellow of a certain one alike
+                context.beginPath();
+                context.arc(point.x, point.y, CURSOR_RADIUS, 0, Math.PI * 2);
+                context.lineWidth = 3;
+                context.strokeStyle = 'rgba(0, 0, 0, 0.75)';
+                context.stroke();
+                context.lineWidth = 1.5;
+                context.strokeStyle = '#fff';
+                context.stroke();
+            }
+        }
+    }
+
+    /**
+     * @param {?{x: number, y: number}} texel fractional
+     */
+    function set_cursor(texel) {
+        cursor = texel !== null && texel.x >= 0 && texel.y >= 0 && texel.x < width && texel.y < height
+            ? texel
+            : null;
+
+        const integer = cursor === null ? null : { x: Math.floor(cursor.x), y: Math.floor(cursor.y) };
+
+        const changed = integer === null || reported === null
+            ? integer !== reported
+            : integer.x !== reported.x || integer.y !== reported.y;
+
+        if (changed) {
+            reported = integer;
+
+            on_cursor(integer);
+        }
+    }
+
+    /**
+     * @param {HTMLCanvasElement} canvas
+     * @param {MouseEvent} event
+     * @returns {{x: number, y: number}} panel pixels
+     */
+    function local(canvas, event) {
+        const rect = canvas.getBoundingClientRect();
+
+        return {
+            x: (event.clientX - rect.left) * size / rect.width,
+            y: (event.clientY - rect.top) * size / rect.height
+        };
+    }
+
+    for (const panel of panels) {
+        const canvas = panel.canvas;
+
+        canvas.addEventListener('wheel', event => {
+            event.preventDefault();
+
+            const delta = event.deltaMode === WheelEvent.DOM_DELTA_LINE ? event.deltaY * WHEEL_LINE_PIXELS : event.deltaY;
+            const point = local(canvas, event);
+
+            view = panel_view_zoom(view, point.x, point.y, Math.exp(-delta * WHEEL_ZOOM_RATE), fitted.scale * MINIMUM_SCALE_OF_FIT, MAXIMUM_SCALE);
+
+            set_cursor(panel_view_texel(view, point.x, point.y));
+            render();
+        }, { passive: false });
+
+        canvas.addEventListener('pointerdown', event => {
+            canvas.setPointerCapture(event.pointerId);
+
+            drag = { x: event.clientX, y: event.clientY, view };
+        });
+
+        canvas.addEventListener('pointermove', event => {
+            if (drag !== null) {
+                view = panel_view_pan(drag.view, event.clientX - drag.x, event.clientY - drag.y);
+            }
+
+            const point = local(canvas, event);
+
+            set_cursor(panel_view_texel(view, point.x, point.y));
+            render();
+        });
+
+        const end_drag = () => {
+            drag = null;
+        };
+
+        canvas.addEventListener('pointerup', end_drag);
+        canvas.addEventListener('pointercancel', end_drag);
+
+        canvas.addEventListener('pointerleave', () => {
+            if (drag === null) {
+                set_cursor(null);
+                render();
+            }
+        });
+
+        canvas.addEventListener('dblclick', () => {
+            view = fitted;
+
+            render();
+        });
+    }
+
+    render();
+
+    return {
+        set_picture(index, rgba, picture_width, picture_height) {
+            if (picture_width !== width || picture_height !== height) {
+                width = picture_width;
+                height = picture_height;
+
+                for (const other of panels) {
+                    other.image = null;
+                }
+
+                fitted = panel_view_fit(width, height, size);
+                view = fitted;
+
+                set_cursor(null);
+            }
+
+            const image = document.createElement('canvas');
+
+            image.width = width;
+            image.height = height;
+
+            const context = image.getContext('2d');
+            const data = context.createImageData(width, height);
+
+            data.data.set(rgba);
+            context.putImageData(data, 0, 0);
+
+            panels[index].image = image;
+
+            render();
+        }
+    };
+}

package/src/shade/renderer/Renderer.js

@@ -1949,6 +1949,8 @@ export class Renderer {
 
         // gr_velocity = graph_mipmap_nearest(graph, gr_velocity, G_BUFFER_MIP_LEVELS);
 
+        // rg8unorm: r is the history confidence, g records which texel won the nearest-depth search,
+        // so the TAA resolve can reproject with exactly the velocity this pass validated.
         let [gr_occlusion_clip] = graph_image_pass({
             graph,
             shader: shader_depth_occlusion_clip,
@@ -2333,8 +2335,6 @@ export class Renderer {
                     texture_color_history: gr_texture_taa_history,
                     texture_velocity: gr_velocity,
                     texture_occlusion: gr_occlusion_clip,
-                    camera_current: gr_buffer_camera_current,
-                    camera_previous: gr_buffer_camera_previous,
                 });
             }
         }

package/src/shade/renderer/animation/GPUAnimationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AA4HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAyMI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA4ElB;IA8ED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAyDlB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAkChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA2ChB;IA0FD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA8FD,gBAYC;;CACJ;4BArtD2B,gCAAgC"}
+{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AA4HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IA0NI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA4ElB;IA8ED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAyDlB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAkChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA2ChB;IAqHD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA8FD,gBAYC;;CACJ;4BAjwD2B,gCAAgC"}

package/src/shade/renderer/animation/GPUAnimationManager.js

@@ -293,6 +293,23 @@ export class GPUAnimationManager {
      */
     #curve_id_cache = new WeakMap();
 
+    /**
+     * The curves uploaded so far, by what they are rather than which instance they were: the
+     * `hash()` of a curve's keys, to every uploaded curve with that hash and its GPU id.
+     *
+     * An instance cache alone shares nothing between two parses of one file, and a character
+     * instanced a few hundred times is a few hundred parses — each with its own instances of the
+     * same keys, filling the keyframe-block table with copies of one dance until its page limit
+     * refuses the next dancer. Curves are read-only once uploaded and nothing here releases them,
+     * so equal content can safely mean one upload.
+     *
+     * A hash bucket is a list because a hash is not an identity: a curve is only shared with one
+     * whose every key `equals` its own, tangents included.
+     *
+     * @type {Map<number, {curve: AnimationCurve, id: number}[]>}
+     */
+    #curve_id_by_content = new Map();
+
     /**
      * Cache of track-id-on-GPU keyed by `(curve_id_x, curve_id_y,
      * curve_id_z, curve_id_w, mask)`. With curve dedup already
@@ -1379,22 +1396,49 @@ export class GPUAnimationManager {
     }
 
     /**
-     * Identity-cached wrapper around {@link add_curve}. First time
-     * the manager sees a given {@link AnimationCurve} instance, it
-     * uploads via the low-level path and caches the resulting GPU id.
-     * Subsequent calls with the same instance reuse that id —
-     * keyframe blocks are shared, not duplicated.
+     * Cached wrapper around {@link add_curve}: one upload per distinct curve, where distinct means
+     * distinct *content*.
+     *
+     * The instance cache answers first — the common case inside one clip, and free. Otherwise the
+     * curve's keys are hashed and held against every uploaded curve with that hash; a match on
+     * every key, tangents included, reuses that upload, and only a curve nobody has uploaded before
+     * goes through the low-level path. Either way the instance is remembered, so the next look-up
+     * of it is the free one.
      *
      * @param {AnimationCurve} curve
      * @returns {number} curve id (index into the `animation_curves` table)
      */
     #intern_curve(curve) {
         const cached = this.#curve_id_cache.get(curve);
+
         if (cached !== undefined) {
             return cached;
         }
+
+        const hash = curve.hash();
+
+        let bucket = this.#curve_id_by_content.get(hash);
+
+        if (bucket === undefined) {
+            bucket = [];
+
+            this.#curve_id_by_content.set(hash, bucket);
+        } else {
+            for (const entry of bucket) {
+                if (entry.curve.equals(curve)) {
+                    this.#curve_id_cache.set(curve, entry.id);
+
+                    return entry.id;
+                }
+            }
+        }
+
         const id = this.add_curve(curve);
+
         this.#curve_id_cache.set(curve, id);
+
+        bucket.push({ curve, id });
+
         return id;
     }
 

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAyEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA2MI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,qBAAqB;QACrC,iBAAuB,sBAAsB;QAC7C,aAAmB,kBAAkB;QACrC,MAAY,YAAY;KACrB,EAYH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAFa,MAAM,CAelB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iCAFW,MAAM,QAmBhB;IAED;;;;;;;OAOG;IACH,gCAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,gCAYC;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAYhB;IAyCD;;;;;;;;;;;;;;;OAeG;IACH,8CAkNC;IAsSD,gBAiBC;;CACJ"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAyEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAoNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,qBAAqB;QACrC,iBAAuB,sBAAsB;QAC7C,aAAmB,kBAAkB;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAFa,MAAM,CAelB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iCAFW,MAAM,QAmBhB;IAED;;;;;;;OAOG;IACH,gCAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,gCAYC;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAYhB;IAyCD;;;;;;;;;;;;;;;OAeG;IACH,8CAyNC;IAqSD,gBAkBC;;CACJ"}