@woosh/meep-engine 2.138.1 → 2.138.2

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.138.1",
+  "version": "2.138.2",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/process/worker/WorkerProxy.d.ts

@@ -1,3 +1,12 @@
+export type WorkerStatus = string;
+/**
+ * @enum {string}
+ */
+export const WorkerStatus: Readonly<{
+    STOPPED: "STOPPED";
+    RUNNING: "RUNNING";
+    FAILED: "FAILED";
+}>;
 export default WorkerProxy;
 declare class WorkerProxy {
     /**
@@ -12,7 +21,17 @@ declare class WorkerProxy {
      * @private
      */
     private __pending;
-    __isRunning: boolean;
+    /**
+     * @type {WorkerStatus}
+     * @private
+     */
+    private __status;
+    /**
+     * Error captured when the worker transitions to FAILED. Used to reject any subsequent requests.
+     * @type {Error|null}
+     * @private
+     */
+    private __failure;
     /**
      *
      * @type {Worker|null}
@@ -60,9 +79,14 @@ declare class WorkerProxy {
      */
     private __handleMessage;
     isRunning(): boolean;
+    /**
+     * @returns {WorkerStatus}
+     */
+    getStatus(): WorkerStatus;
     /**
      * Stop the worker.
      * If the worker is not running, this method does nothing.
+     * A worker in FAILED state cannot be stopped (it has already been terminated).
      */
     stop(): void;
     /**
@@ -81,5 +105,19 @@ declare class WorkerProxy {
      *
      */
     start(): void;
+    /**
+     * Worker-level error handler. Fires when the worker script itself fails
+     * (e.g. importScripts 404) or when an uncaught error escapes a handler.
+     * Treats the worker as permanently failed: rejects all pending and future requests.
+     *
+     * @param {ErrorEvent} errorEvent
+     * @private
+     */
+    private __handleError;
+    /**
+     * @param {Error} err
+     * @private
+     */
+    private __failAllPending;
 }
 //# sourceMappingURL=WorkerProxy.d.ts.map

package/src/core/process/worker/WorkerProxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WorkerProxy.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/worker/WorkerProxy.js"],"names":[],"mappings":";AAsCA;IAiCI;;;;OAIG;IACH,iBAHW,MAAM,gBAQhB;IAzCD;;;;OAIG;IACH,kBAAe;IAEf,qBAAoB;IAEpB;;;;OAIG;IACH,iBAAgB;IAEhB;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;OAKG;IACH,eAAiB;IAQb,YAAc;IACd,aAAsB;IAK1B;;;;;;OAMG;IACH,wBAJW,MAAM,2BAkDhB;IAED;;;;OAIG;IACH,qBAgBC;IAED;;;OAGG;IACH,sBAQC;IAED;;;;OAIG;IACH,wBAqCC;IAED,qBAEC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,kBAJW,MAAM,eACN,MAAM,GACJ,OAAO,CAkCnB;IAED,4BAmBC;IAED;;;;;;OAMG;IACH,cAoBC;CACJ"}
+{"version":3,"file":"WorkerProxy.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/worker/WorkerProxy.js"],"names":[],"mappings":"2BAIU,MAAM;AADhB;;GAEG;AACH;;;;GAIG;;AAqCH;IA4CI;;;;OAIG;IACH,iBAHW,MAAM,gBAQhB;IApDD;;;;OAIG;IACH,kBAAe;IAEf;;;OAGG;IACH,iBAAgC;IAEhC;;;;OAIG;IACH,kBAAiB;IAEjB;;;;OAIG;IACH,iBAAgB;IAEhB;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;OAKG;IACH,eAAiB;IAQb,YAAc;IACd,aAAsB;IAK1B;;;;;;OAMG;IACH,wBAJW,MAAM,2BAsDhB;IAED;;;;OAIG;IACH,qBAgBC;IAED;;;OAGG;IACH,sBAQC;IAED;;;;OAIG;IACH,wBAqCC;IAED,qBAEC;IAED;;OAEG;IACH,aAFa,YAAY,CAIxB;IAED;;;;OAIG;IACH,aAMC;IAED;;;;;OAKG;IACH,kBAJW,MAAM,eACN,MAAM,GACJ,OAAO,CAkCnB;IAED,4BAmBC;IAED;;;;;;OAMG;IACH,cAqBC;IAED;;;;;;;OAOG;IACH,sBAmBC;IAED;;;OAGG;IACH,yBAaC;CACJ"}

package/src/core/process/worker/WorkerProxy.js

@@ -1,6 +1,15 @@
 import { assert } from "../../assert.js";
 import { array_remove_first } from "../../collection/array/array_remove_first.js";
 
+/**
+ * @enum {string}
+ */
+export const WorkerStatus = Object.freeze({
+    STOPPED: 'STOPPED',
+    RUNNING: 'RUNNING',
+    FAILED: 'FAILED',
+});
+
 /**
  *
  * @param {Worker} worker
@@ -45,7 +54,18 @@ class WorkerProxy {
      */
     __pending = {};
 
-    __isRunning = false;
+    /**
+     * @type {WorkerStatus}
+     * @private
+     */
+    __status = WorkerStatus.STOPPED;
+
+    /**
+     * Error captured when the worker transitions to FAILED. Used to reject any subsequent requests.
+     * @type {Error|null}
+     * @private
+     */
+    __failure = null;
 
     /**
      *
@@ -91,6 +111,10 @@ class WorkerProxy {
     $submitRequest(name, args) {
         assert.isString(name, "name");
 
+        if (this.__status === WorkerStatus.FAILED) {
+            return Promise.reject(this.__failure);
+        }
+
         const pending = this.__pending[name];
 
         const argumentCount = args.length;
@@ -218,20 +242,27 @@ class WorkerProxy {
     }
 
     isRunning() {
-        return this.__isRunning;
+        return this.__status === WorkerStatus.RUNNING;
+    }
+
+    /**
+     * @returns {WorkerStatus}
+     */
+    getStatus() {
+        return this.__status;
     }
 
     /**
      * Stop the worker.
      * If the worker is not running, this method does nothing.
+     * A worker in FAILED state cannot be stopped (it has already been terminated).
      */
     stop() {
-        if (!this.__isRunning) {
-            //not running
+        if (this.__status !== WorkerStatus.RUNNING) {
             return;
         }
         this.__worker.terminate();
-        this.__isRunning = false;
+        this.__status = WorkerStatus.STOPPED;
     }
 
     /**
@@ -258,7 +289,7 @@ class WorkerProxy {
             if (request.id === id) {
 
 
-                if (!this.__isRunning) {
+                if (this.__status !== WorkerStatus.RUNNING) {
                     // not running, simply cut from the queue
 
                     requestQueue.splice(i, 1);
@@ -303,26 +334,75 @@ class WorkerProxy {
      *
      */
     start() {
-        if (this.__isRunning) {
+        if (this.__status === WorkerStatus.RUNNING) {
             //already running
             return;
         }
 
+        if (this.__status === WorkerStatus.FAILED) {
+            // FAILED is terminal — refuse to restart. A re-spawn on the same URL would just hit the same load error.
+            return;
+        }
+
         this.__worker = new Worker(this.url,{
             name: this.__name
         });
 
         this.__worker.onmessage = this.__handleMessage;
+        this.__worker.onerror = this.__handleError;
 
-        // TODO attach proper error handler
-        this.__worker.onerror = (errorEvent) => {
-            console.error('Worker error:', errorEvent);
-        };
-
-        this.__isRunning = true;
+        this.__status = WorkerStatus.RUNNING;
 
         this.sendPendingRequests();
     }
+
+    /**
+     * Worker-level error handler. Fires when the worker script itself fails
+     * (e.g. importScripts 404) or when an uncaught error escapes a handler.
+     * Treats the worker as permanently failed: rejects all pending and future requests.
+     *
+     * @param {ErrorEvent} errorEvent
+     * @private
+     */
+    __handleError = (errorEvent) => {
+        const message = errorEvent.message || 'unknown error';
+        const filename = errorEvent.filename || this.url;
+        const lineno = errorEvent.lineno || 0;
+
+        const err = new Error(`Worker '${this.__name}' failed: ${message} (${filename}:${lineno})`);
+
+        // Set status BEFORE rejecting requests so any synchronous resubmission in a rejection
+        // handler immediately fails fast instead of being queued against a dead worker.
+        this.__status = WorkerStatus.FAILED;
+        this.__failure = err;
+
+        if (this.__worker !== null) {
+            this.__worker.terminate();
+        }
+
+        this.__failAllPending(err);
+
+        console.error('Worker error:', errorEvent);
+    }
+
+    /**
+     * @param {Error} err
+     * @private
+     */
+    __failAllPending(err) {
+        for (const methodName in this.__pending) {
+            if (!this.__pending.hasOwnProperty(methodName)) {
+                continue;
+            }
+
+            const queue = this.__pending[methodName];
+            const requests = queue.splice(0, queue.length);
+
+            for (const request of requests) {
+                request.reject(err);
+            }
+        }
+    }
 }
 
 export default WorkerProxy;

package/src/engine/graphics/impostors/octahedral/prototypeBaker.js

@@ -54,10 +54,10 @@ async function main(engine) {
     const renderer = engine.graphics.renderer;
     baker.renderer = renderer;
 
-    // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
     // const path = 'data/models/samples/textured_unit_cube.gltf';
     // const path = 'data/models/samples/teapot.gltf';
-    const path = 'data/models/samples/just_a_girl/scene.gltf';
+    // const path = 'data/models/samples/just_a_girl/scene.gltf';
     // const path = 'data/models/road_bike/road_bike.gltf'; //large CAD-type model
     // const path = 'data/models/LowPolyTownshipSet/Barrel/model.gltf';
     // const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
@@ -96,7 +96,7 @@ async function main(engine) {
             offset: new Vector2(0, 0)
         }))
         .add(GUIElement.fromView(ctrl))
-        .build(ecd);
+        // .build(ecd);
 
     // build out preview scene with impostor and the original
     const t0 = Transform.fromJSON({

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderV0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImpostorShaderV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderV0.js"],"names":[],"mappings":"AA+SA;IACI,cA2DC;IAHG,4CAAyB;CAIhC;kCApWM,OAAO"}
+{"version":3,"file":"ImpostorShaderV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderV0.js"],"names":[],"mappings":"AAgNA;IACI,cA2DC;IAHG,4CAAyB;CAIhC;kCArQM,OAAO"}

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderV0.js

@@ -13,34 +13,87 @@ import {
  * For ray projection using projection matrix : https://encreative.blogspot.com/2019/05/computing-ray-origin-and-direction-from.html
  */
 const shader_vx = `
-    
+
     in vec2 uv;
     in vec3 position;
-    in vec3 normal;
-    
+
     out vec2 vUv;
-    out vec4 plane0;
-    out vec4 plane1;
-    out vec4 plane2;
-       
-    out vec3 local_ray_near;
-    out vec3 local_ray_far;
+
+    // Octahedral atlas frame indices and triangle interpolation weights are
+    // chosen once per-impostor — the pivot-to-camera direction is constant
+    // for all vertices of the card, so every vertex computes the same answer.
+    // Forwarded as flat varyings so every fragment samples the same 3 atlas
+    // frames; otherwise a perspective camera would flip the chosen frame
+    // across the card and produce visible seams.
+    flat out vec2 vGridFloor;
+    flat out vec4 vWeights;
 
     uniform mat4 modelViewMatrix;
     uniform mat4 projectionMatrix;
-    uniform mat3 normalMatrix;
-    
+
     uniform vec3 uOffset;
     uniform float uRadius;
     uniform float uFrames;
-    
+    uniform bool uIsFullSphere;
+
+    vec2 VecToSphereOct(vec3 pivotToCamera)
+    {
+        vec3 octant = sign(pivotToCamera);
+        float sum = dot(pivotToCamera, octant);
+        vec3 octahedron = pivotToCamera / sum;
+        if (octahedron.y < 0.0) {
+            vec3 absolute = abs(octahedron);
+            octahedron.xz = octant.xz * vec2(1.0 - absolute.z, 1.0 - absolute.x);
+        }
+        return octahedron.xz;
+    }
+
+    vec2 VecToHemiSphereOct(vec3 v)
+    {
+        v.y = max(v.y, 0.001);
+        v = normalize(v);
+        vec3 octant = sign(v);
+        float sum = dot(v, octant);
+        vec3 octahedron = v / sum;
+        return vec2(
+            octahedron.x + octahedron.z,
+            octahedron.z - octahedron.x
+        );
+    }
+
+    vec2 VectorToGrid(vec3 v)
+    {
+        if (uIsFullSphere) {
+            return VecToSphereOct(v);
+        } else {
+            return VecToHemiSphereOct(v);
+        }
+    }
+
+    vec4 TriangleInterpolate(vec2 frac_uv)
+    {
+        vec2 omuv = vec2(1.0) - frac_uv;
+        vec4 res;
+        // frame 0 weight (corner (0,0) of the quad)
+        res.x = min(omuv.x, omuv.y);
+        // frame 1 weight (off-diagonal corner — picked by res.w)
+        res.y = abs(frac_uv.x - frac_uv.y);
+        // frame 2 weight (corner (1,1) of the quad)
+        res.z = min(frac_uv.x, frac_uv.y);
+        // triangle-half mask: 1 in the lower-right half, 0 in the upper-left
+        res.w = clamp(ceil(frac_uv.x - frac_uv.y), 0.0, 1.0);
+        return res;
+    }
+
     void main() {
         vUv = uv;
-        
-        vec2 framesMinusOne = uFrames - vec2(1.0);
-        
+
+        // View-aligned billboard: strip the rotation out of modelViewMatrix,
+        // keeping only its translation column. The card always faces the
+        // camera in screen space. (Step 3 will replace this with a card
+        // oriented to the bake direction.)
         mat4 m4 = modelViewMatrix;
-        
+
         m4[0][0] = 1.0;
         m4[0][1] = 0.0;
         m4[0][2] = 0.0;
@@ -52,252 +105,104 @@ const shader_vx = `
         m4[2][0] = 0.0;
         m4[2][1] = 0.0;
         m4[2][2] = 1.0;
-        
+
         vec3 object_scale = vec3(
             length(modelViewMatrix[0].xyz),
             length(modelViewMatrix[1].xyz),
             length(modelViewMatrix[2].xyz)
-        ); 
-        
+        );
+
         // scale by object's baking bounding sphere's radius
-        float card_diameter = uRadius*2.0;
+        float card_diameter = uRadius * 2.0;
         object_scale *= card_diameter;
-        
-        vec3 transformedNormal = normalize(normalMatrix * normal);
-        
-        vec4 mvPosition = m4 * vec4( object_scale*(position+uOffset/card_diameter), 1.0 );
-                
+
+        vec4 mvPosition = m4 * vec4(object_scale * (position + uOffset / card_diameter), 1.0);
         gl_Position = projectionMatrix * mvPosition;
-        
-        mat4 inverse_matrix = inverse(projectionMatrix * modelViewMatrix);
-        
-        //
-        //get 2D projection of this vertex in normalized device coordinates
-        vec2 pos = gl_Position.xy/gl_Position.w;
-       
-        //compute ray's start and end as inversion of this coordinates
-        //in near and far clip planes
-        vec4 near_4 = inverse_matrix * (vec4(pos, -1.0, 1.0));       
-        vec4 far_4 = inverse_matrix * (vec4(pos, 1.0, 1.0));
-        
-        local_ray_near = near_4.xyz / near_4.w;
-        local_ray_far = far_4.xyz/ far_4.w;
+
+        // Pivot-to-camera direction in the impostor's object-local space —
+        // the same frame the atlas was baked in. The camera sits at the
+        // origin in view space; inverting modelViewMatrix takes that back
+        // into object-local space. Constant across all vertices of the card.
+        vec3 cameraPos_OS = (inverse(modelViewMatrix) * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
+        vec3 pivotToCameraRay = normalize(cameraPos_OS);
+
+        vec2 octahedral_uv = clamp(VectorToGrid(pivotToCameraRay) * 0.5 + 0.5, 0.0, 1.0);
+        vec2 grid = octahedral_uv * (uFrames - 1.0);
+        vGridFloor = floor(grid);
+        vWeights = TriangleInterpolate(fract(grid));
     }
 `;
 const shader_fg = `
     precision highp float;
     precision highp int;
-    
+
     const float depth_scale = 0.5;
 
     in vec2 vUv;
-    
-    in vec4 plane0;
-    in vec4 plane1;
-    in vec4 plane2;
-    
-    in vec3 vViewPosition; 
-    in vec3 vFacingDirection; 
-    
+
+    // Frame indices + triangle weights are computed per-impostor in the
+    // vertex shader. flat = no interpolation; every fragment sees the same
+    // values and samples the same 3 atlas frames.
+    flat in vec2 vGridFloor;
+    flat in vec4 vWeights;
+
     out vec4 color_out;
-    
+
     uniform sampler2D tBase;
     uniform sampler2D tGeometry;
     uniform float uFrames;
     uniform float uDepthScale;
-    uniform bool uIsFullSphere;
-    
-    
-    in vec3 local_ray_near;
-    in vec3 local_ray_far;
-    
-    struct Material{
-        vec3 diffuse;
-        vec3 normal;
-        float depth;
-        float occlusion;
-        float roughness;
-        float metalness;
-    };
-    
-    vec2 VecToSphereOct(vec3 pivotToCamera)
-    {
-        vec3 octant = sign(pivotToCamera);
-    
-        //  |x| + |y| + |z| = 1
-        float sum = dot(pivotToCamera, octant);
-        vec3 octahedron = pivotToCamera / sum;
-    
-        if (octahedron.y < 0.0){
-            vec3 absolute = abs(octahedron);
-            octahedron.xz = octant.xz * vec2(1.0 - absolute.z, 1.0 - absolute.x);
-        }
-        return octahedron.xz;
-    }
-    
-    //for hemisphere
-    vec2 VecToHemiSphereOct(vec3 vec)
-    {        
-        vec.y = max(vec.y, 0.001);
-        vec = normalize(vec);
-        vec3 octant = sign(vec);
-    
-        //  |x| + |y| + |z| = 1
-        float sum = dot(vec, octant);
-        vec3 octahedron = vec / sum;
-    
-        return vec2(
-            octahedron.x + octahedron.z,
-            octahedron.z - octahedron.x
-        );
-    }
-    
-    vec2 VectorToGrid(vec3 vec)
-    {
-        if (uIsFullSphere)
-        {
-            return VecToSphereOct(vec);
-        }
-        else
-        {
-            return VecToHemiSphereOct(vec);
-        }
-    }
-    
-    vec4 TriangleInterpolate(vec2 uv){
-        uv = fract(uv);
-    
-        vec2 omuv = vec2(1.0, 1.0) - uv.xy;
-    
-        vec4 res = vec4(0, 0, 0, 0);
-        //frame 0
-        res.x = min(omuv.x, omuv.y);
-        //frame 1
-        res.y = abs(dot(uv, vec2(1.0, -1.0)));
-        //frame 2
-        res.z = min(uv.x, uv.y);
-        //mask
-        res.w = clamp(ceil(uv.x-uv.y),0.0, 1.0);
-    
-        return res;
-    }
-    
-    
-    vec4 ImposterBlendWeights(sampler2D tex, vec2 frame0, vec2 frame1, vec2 frame2, vec4 weights, vec4 ddxy)
-    {
-        vec4 samp0 = textureGrad(tex, frame0, ddxy.xy, ddxy.zw);
-        vec4 samp1 = textureGrad(tex, frame1, ddxy.xy, ddxy.zw);
-        vec4 samp2 = textureGrad(tex, frame2, ddxy.xy, ddxy.zw);
-    
-        vec4 result = samp0*weights.x + samp1*weights.y + samp2*weights.z;
-    
-        return result;
-    }
-    
-    vec4 ImposterBlendWeightsNearest(sampler2D tex, vec2 frame0, vec2 frame1, vec2 frame2, vec4 weights, vec4 ddxy)
-    {
-        vec4 samp0 = textureGrad(tex, frame0, ddxy.xy, ddxy.zw);
-        vec4 samp1 = textureGrad(tex, frame1, ddxy.xy, ddxy.zw);
-        vec4 samp2 = textureGrad(tex, frame2, ddxy.xy, ddxy.zw);
-    
-        vec4 result;
-    
-        if(weights.x > weights.y && weights.x > weights.z){
-            result = samp0;
-        }if(weights.y > weights.z){
-            result = samp1;
-        }else{
-            result = samp2;
-        }
-    
-        return result;
-    }
-        
-    
-    void calcuateXYbasis(vec3 plane_normal, out vec3 plane_x, out vec3 plane_y)
+
+    vec4 ImposterBlendWeights(sampler2D tex, vec2 uv0, vec2 uv1, vec2 uv2, vec4 weights, vec4 ddxy)
     {
-        vec3 up = vec3(0,1,0);
-            //cross product doesnt work if we look directly from bottom
-        if (abs(plane_normal.y) > 0.999f)
-        {
-            up = vec3(0,0,1);
-        }
-        plane_x = normalize(cross(plane_normal, up));
-        plane_y = normalize(cross(plane_x, plane_normal));
+        vec4 samp0 = textureGrad(tex, uv0, ddxy.xy, ddxy.zw);
+        vec4 samp1 = textureGrad(tex, uv1, ddxy.xy, ddxy.zw);
+        vec4 samp2 = textureGrad(tex, uv2, ddxy.xy, ddxy.zw);
+
+        return samp0 * weights.x + samp1 * weights.y + samp2 * weights.z;
     }
 
-    vec3 projectOnPlaneBasis(vec3 ray, vec3 plane_normal, vec3 plane_x, vec3 plane_y)
+    vec2 recompute_uv(vec2 frame, vec2 frame_uv, sampler2D gBuffer)
     {
-        //reproject plane normal onto planeXY basos
-        return normalize(vec3( 
-            dot(plane_x,ray), 
-            dot(plane_y,ray), 
-            dot(plane_normal,ray) 
-        ));
-    }
-    
-    vec2 recompute_uv(vec2 frame, vec2 frame_uv, sampler2D gBuffer){
-        vec2 frame_size = vec2(1.0/ uFrames);
-        
-        vec2 source_uv = (frame + frame_uv)*frame_size;
-        
+        vec2 frame_size = vec2(1.0 / uFrames);
+        vec2 source_uv = (frame + frame_uv) * frame_size;
         float n_depth = texture(gBuffer, source_uv).a;
-            
-        vec2 offset = clamp(length(frame_uv*2.0 - 1.0) * vec2(0.5-n_depth ) * depth_scale,0.0, 1.0);
-        
-        vec2 uv_f = clamp(frame_uv+offset, 0.0, 1.0);
-        
-        uv_f = ( frame + uv_f)*frame_size;
-        
-        return clamp(uv_f,0.0, 1.0);
-        // return source_uv;
+
+        vec2 offset = (frame_uv * 2.0 - 1.0) * (0.5 - n_depth) * depth_scale;
+        vec2 uv_f = clamp(frame_uv + offset, 0.0, 1.0);
+        uv_f = (frame + uv_f) * frame_size;
+        return clamp(uv_f, 0.0, 1.0);
     }
-    
-    void main(){
-        vec3 view_direction = normalize(local_ray_near-local_ray_far);
-        
-        vec2 octahedral_uv = clamp(VectorToGrid(view_direction)*0.5 + 0.5, 0.0, 1.0);
-        vec2 grid =  octahedral_uv * vec2(uFrames - 1.0);
-        
-        vec2 gridFrac = fract(grid);
-        vec2 gridFloor = floor(grid);
-                
-        vec4 weights = TriangleInterpolate( gridFrac ); 
-        
+
+    void main() {
         vec2 frame_uv = vUv;
-        
-        //3 nearest frames
-        vec2 frame0 = gridFloor;
-        vec2 frame1 = gridFloor + mix(vec2(0,1),vec2(1,0),weights.w);
-        vec2 frame2 = gridFloor + vec2(1.0,1.0);
-        
+
+        // 3 nearest frames — chosen in the vertex shader (vGridFloor +
+        // vWeights are flat, so frame0/1/2 are identical for every fragment
+        // of this impostor card).
+        vec2 frame0 = vGridFloor;
+        vec2 frame1 = vGridFloor + mix(vec2(0.0, 1.0), vec2(1.0, 0.0), vWeights.w);
+        vec2 frame2 = vGridFloor + vec2(1.0, 1.0);
+
         vec2 uv0 = recompute_uv(frame0, frame_uv, tGeometry);
         vec2 uv1 = recompute_uv(frame1, frame_uv, tGeometry);
         vec2 uv2 = recompute_uv(frame2, frame_uv, tGeometry);
-        
-        vec4 ddxy = vec4( dFdx(vUv.xy), dFdy(vUv.xy) );
-        
-        vec2 frame_size = vec2(1.0/ uFrames);
-                
+
+        vec4 ddxy = vec4(dFdx(vUv.xy), dFdy(vUv.xy));
+
         vec4 texel_color = ImposterBlendWeights(
-        // vec4 texel_color = ImposterBlendWeightsNearest(
             tBase,
             uv0,
             uv1,
             uv2,
-            weights, ddxy
+            vWeights, ddxy
         );
-        
-        
-        // texel_color = vec4(texel_color.aaa, 1.0);
-        
-        if(texel_color.a <= 0.5){
-            texel_color.r = 1.0;
+
+        if (texel_color.a <= 0.5) {
             discard;
         }
-    
+
         color_out = texel_color;
-        // color_out = vec4(  snapped_oct_uv, 1.0, 1.0);
     }
 `;
 

package/src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BufferedGeometryBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js"],"names":[],"mappings":"AAwCA;IAkBI;;;OAGG;IACH,eAFW,KAAK,GAAC,MAAM,EAAE,QAIxB;IAIG;;;;OAIG;IACH,mBAAsB;IAEtB;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,6BAAgC;IAGhC;;;;OAIG;IACH,yBAAyB;IAG7B;;;OAGG;IACH,WAFW,MAAM,cAAc,QA8C9B;IAED;;;;;OAKG;IACH,qBAFa,OAAO,CAmHnB;IAED;;;;;;;OAOG;IACH,4BANW,aAAa,KACb,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAUnB;IAGD;;;;;;OAMG;IACH,iBAJW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,GACX,MAAM,CAoIlB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,GACX,MAAM,CA2ElB;;CACJ;sBA9eqB,wCAAwC;8BAGhC,2CAA2C"}
+{"version":3,"file":"BufferedGeometryBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js"],"names":[],"mappings":"AAwCA;IAkBI;;;OAGG;IACH,eAFW,KAAK,GAAC,MAAM,EAAE,QAIxB;IAIG;;;;OAIG;IACH,mBAAsB;IAEtB;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,6BAAgC;IAGhC;;;;OAIG;IACH,yBAAyB;IAG7B;;;OAGG;IACH,WAFW,MAAM,cAAc,QAgD9B;IAED;;;;;OAKG;IACH,qBAFa,OAAO,CAmHnB;IAED;;;;;;;OAOG;IACH,4BANW,aAAa,KACb,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAUnB;IAGD;;;;;;OAMG;IACH,iBAJW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,GACX,MAAM,CAoIlB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,GACX,MAAM,CA2ElB;;CACJ;sBAhfqB,wCAAwC;8BAGhC,2CAA2C"}

package/src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js

@@ -129,10 +129,12 @@ export class BufferedGeometryBVH {
             array_positions,
             this.#morton_codes,
             this.#bounds,
-            16
+            2
         );
 
-        ebvh_optimize_treelet(bvh);
+        for (let i = 0; i < 3; i++) {
+            ebvh_optimize_treelet(bvh);
+        }
 
         //
         // ebvh_build_for_geometry_incremental(bvh, index_array, array_positions, 1);

package/src/engine/graphics/sh3/path_tracer/PathTracedScene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAoDA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAG1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,mBAAmB,CAAC,CAElC;IAmBtB;;;;OAIG;IACH,6BAA6C;IAkF7C,iBAOC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAiCnB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACZ,OAAO,CAgBnB;IAED;;;;OAIG;IACH,yBAHW,MAAM,QAAQ,oBAKxB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QAavB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,IAAI,QA0Cd;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAsCnB;IAED;;;;;OAKG;IACH,WAJW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,IAAI,GACZ,MAAM,CA+CjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,QAwHlB;;CACJ;oBA1lB8B,mCAAmC;+BAqBnC,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B;qBARzC,sCAAsC"}
+{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAoDA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAG1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,mBAAmB,CAAC,CAElC;IAmBtB;;;;OAIG;IACH,6BAA6C;IAoF7C,iBAOC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAiCnB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACZ,OAAO,CAgBnB;IAED;;;;OAIG;IACH,yBAHW,MAAM,QAAQ,oBAKxB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QAavB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,IAAI,QA0Cd;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAsCnB;IAED;;;;;OAKG;IACH,WAJW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,IAAI,GACZ,MAAM,CA+CjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,QAwHlB;;CACJ;oBA5lB8B,mCAAmC;+BAqBnC,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B;qBARzC,sCAAsC"}

package/src/engine/graphics/sh3/path_tracer/PathTracedScene.js

@@ -177,9 +177,11 @@ export class PathTracedScene {
         array_copy(nodes, 0, unprocessed_nodes, 0, node_leaf_count);
 
         // assign root
-        bvh.__root = ebvh_build_hierarchy(bvh, unprocessed_nodes, node_leaf_count, nodes, node_leaf_count,16);
+        bvh.__root = ebvh_build_hierarchy(bvh, unprocessed_nodes, node_leaf_count, nodes, node_leaf_count, 3);
 
-        ebvh_optimize_treelet(bvh);
+        for (let i = 0; i < 3; i++) {
+            ebvh_optimize_treelet(bvh);
+        }
     }
 
     optimize() {

package/src/engine/graphics/sh3/path_tracer/prototypePathTracer.js

@@ -67,8 +67,8 @@ vCanvas.css({
  * How many rays to use per-pixel
  * @type {number}
  */
-const PIXEL_SAMPLE_COUNT = 1;
-const PIXEL_RENDER_RATIO = 0.5;
+const PIXEL_SAMPLE_COUNT = 16;
+const PIXEL_RENDER_RATIO = 1;
 
 const scene = new PathTracedScene();
 const pt = new PathTracer();