@woosh/meep-engine 2.138.1 → 2.138.3

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.3",
   "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/ecs/mesh-v2/aggregate/prototypeSGMesh.js

@@ -1,5 +1,4 @@
 import { initializeEditor } from "../../../../../../../model/game/initializeEditor.js";
-import { OrbitingBehavior } from "../../../../../../../model/game/util/behavior/OrbitingBehavior.js";
 import { enableEditor } from "../../../../../../editor/enableEditor.js";
 import { AABB3 } from "../../../../../core/geom/3d/aabb/AABB3.js";
 import Quaternion from "../../../../../core/geom/Quaternion.js";
@@ -15,6 +14,7 @@ import { Transform } from "../../../../ecs/transform/Transform.js";
 import { EngineHarness } from "../../../../EngineHarness.js";
 import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { OrbitingBehavior } from "../../../../intelligence/behavior/ecs/OrbitingBehavior.js";
 import Highlight from "../../highlight/Highlight.js";
 import { ShadedGeometryHighlightSystem } from "../../highlight/system/ShadedGeometryHighlightSystem.js";
 import { MeshSystem } from "../../mesh/MeshSystem.js";

package/src/engine/graphics/ecs/mesh-v2/sample/prototypeShadedGeometry.js

@@ -1,5 +1,4 @@
 import { BoxBufferGeometry, MeshStandardMaterial, OctahedronGeometry } from "three";
-import { OrbitingBehavior } from "../../../../../../../model/game/util/behavior/OrbitingBehavior.js";
 import { Color } from "../../../../../core/color/Color.js";
 import Quaternion from "../../../../../core/geom/Quaternion.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
@@ -19,6 +18,7 @@ import { SequenceBehavior } from "../../../../intelligence/behavior/composite/Se
 import { RepeatBehavior } from "../../../../intelligence/behavior/decorator/RepeatBehavior.js";
 import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { OrbitingBehavior } from "../../../../intelligence/behavior/ecs/OrbitingBehavior.js";
 import { ActionBehavior } from "../../../../intelligence/behavior/primitive/ActionBehavior.js";
 import { DelayBehavior } from "../../../../intelligence/behavior/util/DelayBehavior.js";
 import { ShadedGeometry } from "../ShadedGeometry.js";

package/src/engine/graphics/ecs/mesh-v2/sample/prototype_sg_raycast.js

@@ -5,7 +5,6 @@ import {
     OctahedronGeometry,
     SphereBufferGeometry
 } from "three";
-import { OrbitingBehavior } from "../../../../../../../model/game/util/behavior/OrbitingBehavior.js";
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import Quaternion from "../../../../../core/geom/Quaternion.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
@@ -24,6 +23,7 @@ import { Transform } from "../../../../ecs/transform/Transform.js";
 import { EngineHarness } from "../../../../EngineHarness.js";
 import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { OrbitingBehavior } from "../../../../intelligence/behavior/ecs/OrbitingBehavior.js";
 import {
     MicronShadedGeometryRenderAdapter
 } from "../../../micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js";

package/src/engine/graphics/ecs/trail2d/prototypeTrail2D.js

@@ -1,4 +1,3 @@
-import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/OrbitingBehavior.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { make_justified_point_grid } from "../../../../core/geom/3d/util/make_justified_point_grid.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
@@ -8,6 +7,7 @@ import { Transform } from "../../../ecs/transform/Transform.js";
 import { EngineHarness } from "../../../EngineHarness.js";
 import { BehaviorComponent } from "../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import { BehaviorSystem } from "../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { OrbitingBehavior } from "../../../intelligence/behavior/ecs/OrbitingBehavior.js";
 import Trail2D from "./Trail2D.js";
 import Trail2DSystem from "./Trail2DSystem.js";
 

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":"AA+TA;IACI,cAmEC;IAHG,4CAAyB;CAIhC;kCA5XM,OAAO"}

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

@@ -13,291 +13,307 @@ 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;
+    // View-space position of this vertex. Interpolated per-fragment for the
+    // tangent-space parallax computation in the fragment shader.
+    out vec3 vViewPos;
+
+    // Octahedral atlas frame indices and triangle interpolation weights are
+    // chosen once per-impostor and forwarded as flat varyings so every
+    // fragment samples the same 3 atlas frames (without this, a perspective
+    // camera could flip the chosen frame across the card and produce
+    // visible seams).
+    flat out vec2 vGridFloor;
+    flat out vec4 vWeights;
+
+    // Card's TBN basis in view space. The card is oriented so its NORMAL
+    // points along the weighted blend of the 3 nearest baked view
+    // directions, and TANGENT/BINORMAL line up with the bake camera's
+    // right/up at bake time — i.e. with the texture's X/Y axes. This is
+    // what makes the depth field (which is perpendicular to the bake
+    // direction) usable as a tangent-space height map. flat because the
+    // basis is the same for every vertex of the card.
+    flat out vec3 vTangent;
+    flat out vec3 vBinormal;
+    flat out vec3 vNormal;
 
     uniform mat4 modelViewMatrix;
     uniform mat4 projectionMatrix;
-    uniform mat3 normalMatrix;
-    
+
     uniform vec3 uOffset;
     uniform float uRadius;
     uniform float uFrames;
-    
-    void main() {
-        vUv = uv;
-        
-        vec2 framesMinusOne = uFrames - vec2(1.0);
-        
-        mat4 m4 = modelViewMatrix;
-        
-        m4[0][0] = 1.0;
-        m4[0][1] = 0.0;
-        m4[0][2] = 0.0;
-
-        m4[1][0] = 0.0;
-        m4[1][1] = 1.0;
-        m4[1][2] = 0.0;
-
-        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;
-        object_scale *= card_diameter;
-        
-        vec3 transformedNormal = normalize(normalMatrix * normal);
-        
-        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;
-    }
-`;
-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; 
-    
-    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;
-    };
-    
+
+    // ----- direction -> octahedral grid coord (range -1..+1) -----
+
     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){
+        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;
-    
+
+    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 vec)
+
+    vec2 VectorToGrid(vec3 v)
     {
-        if (uIsFullSphere)
-        {
-            return VecToSphereOct(vec);
-        }
-        else
-        {
-            return VecToHemiSphereOct(vec);
+        if (uIsFullSphere) {
+            return VecToSphereOct(v);
+        } else {
+            return VecToHemiSphereOct(v);
         }
     }
-    
-    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)
+
+    // ----- octahedral grid coord (range 0..1) -> direction -----
+    //
+    // Inverse of VectorToGrid (after the 0.5/2.0 remap). Given the
+    // normalised position of a frame in the atlas, return the world-space
+    // direction the bake camera was sitting at when it captured that frame.
+
+    vec3 OctaSphereDec(vec2 coord)
     {
-        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;
+        coord = (coord - 0.5) * 2.0;
+        vec3 p = vec3(coord.x, 0.0, coord.y);
+        vec2 a = abs(p.xz);
+        p.y = 1.0 - a.x - a.y;
+        if (p.y < 0.0) {
+            p.xz = sign(p.xz) * vec2(1.0 - a.y, 1.0 - a.x);
+        }
+        return p;
     }
-    
-    vec4 ImposterBlendWeightsNearest(sampler2D tex, vec2 frame0, vec2 frame1, vec2 frame2, vec4 weights, vec4 ddxy)
+
+    vec3 OctaHemiSphereDec(vec2 coord)
     {
-        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;
+        vec3 p = vec3(coord.x - coord.y, 0.0, -1.0 + coord.x + coord.y);
+        vec2 a = abs(p.xz);
+        p.y = 1.0 - a.x - a.y;
+        return p;
     }
-        
-    
-    void calcuateXYbasis(vec3 plane_normal, out vec3 plane_x, out vec3 plane_y)
+
+    vec3 GridToVector(vec2 coord)
     {
-        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);
+        if (uIsFullSphere) {
+            return OctaSphereDec(coord);
+        } else {
+            return OctaHemiSphereDec(coord);
         }
-        plane_x = normalize(cross(plane_normal, up));
-        plane_y = normalize(cross(plane_x, plane_normal));
     }
 
-    vec3 projectOnPlaneBasis(vec3 ray, vec3 plane_normal, vec3 plane_x, vec3 plane_y)
+    // Frame index (gridFloor + corner offset) -> baked view direction.
+    // Frame coords at the grid border can sit slightly outside the
+    // [0, uFrames-1] range (e.g. gridFloor + (1,1) at the corner); clamp so
+    // we don't feed invalid UVs to the octahedral decoder.
+    vec3 FrameToRay(vec2 frame, vec2 framesMinusOne)
     {
-        //reproject plane normal onto planeXY basos
-        return normalize(vec3( 
-            dot(plane_x,ray), 
-            dot(plane_y,ray), 
-            dot(plane_normal,ray) 
-        ));
+        vec2 f = clamp(frame / framesMinusOne, 0.0, 1.0);
+        return normalize(GridToVector(f));
     }
-    
-    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;
-        
-        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;
+
+    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(){
-        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);
+
+    void main() {
+        vUv = uv;
+
+        // 1. Octahedral atlas lookup.
+        //    cameraPos_OS is the camera position in the impostor's local
+        //    space — the same coordinate frame the meshes were in during
+        //    the bake. The encoded direction is what picks which atlas
+        //    frames we'll sample.
+        vec3 cameraPos_OS = (inverse(modelViewMatrix) * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
+        vec3 pivotToCameraRay = normalize(cameraPos_OS);
+
+        vec2 framesMinusOne = vec2(uFrames - 1.0);
+        vec2 octahedral_uv = clamp(VectorToGrid(pivotToCameraRay) * 0.5 + 0.5, 0.0, 1.0);
+        vec2 grid = octahedral_uv * framesMinusOne;
         vec2 gridFloor = floor(grid);
-                
-        vec4 weights = TriangleInterpolate( gridFrac ); 
-        
-        vec2 frame_uv = vUv;
-        
-        //3 nearest frames
+        vec4 weights = TriangleInterpolate(fract(grid));
+
+        vGridFloor = gridFloor;
+        vWeights = weights;
+
+        // 2. Decode each of the 3 chosen frame indices back into the
+        //    bake-time view direction, then blend with the triangle weights.
+        //    projectedRay is the "effective" baked view direction the card
+        //    is showing — the direction the depth and colour textures we're
+        //    blending were captured along.
         vec2 frame0 = gridFloor;
-        vec2 frame1 = gridFloor + mix(vec2(0,1),vec2(1,0),weights.w);
-        vec2 frame2 = gridFloor + 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 texel_color = ImposterBlendWeights(
-        // vec4 texel_color = ImposterBlendWeightsNearest(
-            tBase,
-            uv0,
-            uv1,
-            uv2,
-            weights, ddxy
+        vec2 frame1 = gridFloor + mix(vec2(0.0, 1.0), vec2(1.0, 0.0), weights.w);
+        vec2 frame2 = gridFloor + vec2(1.0, 1.0);
+        vec3 ray0 = FrameToRay(frame0, framesMinusOne);
+        vec3 ray1 = FrameToRay(frame1, framesMinusOne);
+        vec3 ray2 = FrameToRay(frame2, framesMinusOne);
+        vec3 projectedRay = normalize(
+            ray0 * weights.x + ray1 * weights.y + ray2 * weights.z
+        );
+
+        // 3. Build the card's TBN in object-local space.
+        //    NORMAL    = projectedRay (the effective bake direction).
+        //    TANGENT   = cross(up, NORMAL) — matches three.js Camera.lookAt
+        //                (which is what the baker used), so position.x of
+        //                the cutout shape lines up with the texture's X.
+        //    BINORMAL  = cross(NORMAL, TANGENT) — matches the bake camera's
+        //                up axis, so position.y lines up with texture Y.
+        //
+        //    The bake used world-up (0,1,0). The bake's world frame IS our
+        //    object-local frame (the meshes lived there during the bake),
+        //    so we use object-local (0,1,0) here too. The fallback covers
+        //    the degenerate pole case where NORMAL is parallel to up.
+        vec3 normal_OS = projectedRay;
+        vec3 up_OS = abs(normal_OS.y) > 0.999
+                     ? vec3(0.0, 0.0, -1.0)
+                     : vec3(0.0, 1.0,  0.0);
+        vec3 tangent_OS  = normalize(cross(up_OS, normal_OS));
+        vec3 binormal_OS = cross(normal_OS, tangent_OS);
+
+        // 4. Position the card vertex in object-local space.
+        //    position.xy is in [-0.5, 0.5] (the centred cutout shape), so
+        //    multiplying by card_diameter places it on a card whose half-
+        //    width and half-height are uRadius — tangentially spanning the
+        //    bounding sphere. uOffset is the bounding sphere centre in
+        //    object-local space (captured at bake time).
+        float card_diameter = uRadius * 2.0;
+        vec3 pos_OS = uOffset
+                    + position.x * card_diameter * tangent_OS
+                    + position.y * card_diameter * binormal_OS;
+
+        vec4 mvPosition = modelViewMatrix * vec4(pos_OS, 1.0);
+        vViewPos = mvPosition.xyz;
+        gl_Position = projectionMatrix * mvPosition;
+
+        // 5. TBN in view space — what the fragment shader needs to convert
+        //    its view-space view-dir into tangent space. For typical
+        //    impostor transforms (rigid + uniform scale) mat3(modelView) is
+        //    orthogonal up to a uniform scalar, so renormalising after the
+        //    multiply is sufficient; non-uniform scale would require the
+        //    inverse-transpose.
+        mat3 m3 = mat3(modelViewMatrix);
+        vTangent  = normalize(m3 * tangent_OS);
+        vBinormal = normalize(m3 * binormal_OS);
+        vNormal   = normalize(m3 * normal_OS);
+    }
+`;
+const shader_fg = `
+    precision highp float;
+    precision highp int;
+
+    in vec2 vUv;
+    in vec3 vViewPos;
+
+    // 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;
+
+    // Card's TBN in view space. The card is no longer view-aligned — it's
+    // oriented perpendicular to the effective bake direction — so we have
+    // to convert the view-space view direction into this tangent frame
+    // before doing parallax.
+    flat in vec3 vTangent;
+    flat in vec3 vBinormal;
+    flat in vec3 vNormal;
+
+    out vec4 color_out;
+
+    uniform sampler2D tBase;
+    uniform sampler2D tGeometry;
+    uniform float uFrames;
+    uniform float uDepthScale;
+
+    // Sample the same within-frame UV from the three chosen atlas frames and
+    // blend with the triangle weights from the vertex shader. Used for both
+    // depth and colour.
+    vec4 blend_3_frames(sampler2D tex, vec2 frame_uv, vec2 f0, vec2 f1, vec2 f2, vec4 w)
+    {
+        vec2 frame_size = vec2(1.0 / uFrames);
+        vec4 s0 = texture(tex, (f0 + frame_uv) * frame_size);
+        vec4 s1 = texture(tex, (f1 + frame_uv) * frame_size);
+        vec4 s2 = texture(tex, (f2 + frame_uv) * frame_size);
+        return s0 * w.x + s1 * w.y + s2 * w.z;
+    }
+
+    void main() {
+        // 3 nearest frames — flat from vertex shader, 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);
+
+        // View direction in the card's tangent space. The card is oriented
+        // perpendicular to the effective bake direction, not view-aligned,
+        // so we project the view-space view-dir onto the (T, B, N) basis we
+        // built in the vertex shader.
+        vec3 view_dir_view = normalize(-vViewPos);
+        vec3 view_dir = vec3(
+            dot(vTangent,  view_dir_view),
+            dot(vBinormal, view_dir_view),
+            dot(vNormal,   view_dir_view)
         );
-        
-        
-        // texel_color = vec4(texel_color.aaa, 1.0);
-        
-        if(texel_color.a <= 0.5){
-            texel_color.r = 1.0;
+
+        // One-step approximate parallax: sample the blended depth at the
+        // un-corrected UV, then shift the UV by the height that depth
+        // implies.
+        //
+        // Our bake writes depth = 1 at the near plane (front of the bounding
+        // sphere, closest to the bake camera), depth = 0 at the far plane,
+        // depth = 0.5 at the bounding sphere centre — i.e. the card plane.
+        // So (depth - 0.5) is the signed height of the surface above the
+        // card plane, in units where ±0.5 = ±radius. The card spans 2*radius
+        // mapped to UV [0,1], so that height is already in card-UV units.
+        //
+        // Standard parallax-mapping formula: shift base_uv by V.xy / V.z * h,
+        // where V is the view direction in tangent space and h is the
+        // surface height above the card plane.
+        vec2 base_uv = vUv;
+        float depth = blend_3_frames(tGeometry, base_uv, frame0, frame1, frame2, vWeights).a;
+        base_uv += (view_dir.xy / view_dir.z) * (depth - 0.5) * uDepthScale;
+
+        // Keep the parallax-shifted sample inside the current frame's tile.
+        // Without this, large shifts at oblique angles bleed colour from the
+        // neighbouring atlas frame (a completely different bake direction).
+        base_uv = clamp(base_uv, 0.0, 1.0);
+
+        vec4 texel_color = blend_3_frames(tBase, base_uv, frame0, frame1, frame2, vWeights);
+
+        if (texel_color.a <= 0.5) {
             discard;
         }
-    
+
         color_out = texel_color;
-        // color_out = vec4(  snapped_oct_uv, 1.0, 1.0);
     }
 `;
 
@@ -347,9 +363,17 @@ export class ImpostorShaderV0 extends RawShaderMaterial {
                 uIsFullSphere: {
                     value: false
                 },
+                /**
+                 * Strength of the tangent-space parallax offset. The
+                 * geometrically-correct value for a true sphere surface is
+                 * about 1.0, but in practice 0.3–0.5 produces a more
+                 * believable result because the bake only contains the
+                 * silhouette and front-facing geometry — strong parallax
+                 * starts revealing missing/occluded parts at oblique angles.
+                 * Range: [0, 1].
+                 */
                 uDepthScale:{
-                    // value should be in range between 0 and 1
-                    value:1
+                    value: 0.5
                 }
             },
             glslVersion: GLSL3

package/src/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -9,7 +9,6 @@ import {
 } from "three";
 import FacingDirectionSystem from "../../../../../../../model/game/ecs/system/FacingDirectionSystem.js";
 import { makeEngineOptionsModel } from "../../../../../../../model/game/options/makeEngineOptionsModel.js";
-import { OrbitingBehavior } from "../../../../../../../model/game/util/behavior/OrbitingBehavior.js";
 import { enableEditor } from "../../../../../../editor/enableEditor.js";
 import { makeHelperSphereGeometry } from "../../../../../../editor/process/symbolic/makeHelperSphereGeometry.js";
 import { parse_color } from "../../../../../core/color/parse_color.js";
@@ -52,6 +51,7 @@ import InputControllerSystem from "../../../../input/ecs/systems/InputController
 import { InputSystem } from "../../../../input/ecs/systems/InputSystem.js";
 import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { OrbitingBehavior } from "../../../../intelligence/behavior/ecs/OrbitingBehavior.js";
 import PathFollowingSystem from "../../../../navigation/ecs/path_following/PathFollowingSystem.js";
 import { SoundEmitterSystem } from "../../../../sound/ecs/emitter/SoundEmitterSystem.js";
 import SoundControllerSystem from "../../../../sound/ecs/SoundControllerSystem.js";

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();

package/src/engine/intelligence/behavior/ecs/OrbitingBehavior.d.ts

@@ -0,0 +1,63 @@
+export class OrbitingBehavior extends EntityBehavior {
+    /**
+     *
+     * @param {Vector3} [center]
+     * @param {number} [radius]
+     * @param {number} [rate]
+     * @returns {OrbitingBehavior}
+     */
+    static from({ center, radius, rate }?: Vector3): OrbitingBehavior;
+    /**
+     * Radians per second.
+     * Can be negative for counter-clockwise rotation.
+     * @type {number}
+     */
+    rate: number;
+    /**
+     *
+     * @type {number}
+     */
+    radius: number;
+    /**
+     * Initial offset in radians
+     * @type {number}
+     */
+    phase: number;
+    /**
+     *
+     * @type {number}
+     */
+    angle: number;
+    /**
+     * Offset from the origin
+     * @type {Vector3}
+     */
+    offset: Vector3;
+    /**
+     *
+     * @type {number}
+     */
+    parent: number;
+    /**
+     *
+     * @type {number}
+     */
+    easing: number;
+    orientation: Quaternion;
+    /**
+     *
+     * @type {Vector3}
+     */
+    center: Vector3;
+    /**
+     *
+     * @type {Quaternion}
+     */
+    lookRotation: Quaternion;
+    tick(timeDelta: any): BehaviorStatus.Running | BehaviorStatus.Failed;
+}
+import { EntityBehavior } from "./EntityBehavior.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+import Quaternion from "../../../../core/geom/Quaternion.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+//# sourceMappingURL=OrbitingBehavior.d.ts.map

package/src/engine/intelligence/behavior/ecs/OrbitingBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrbitingBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/ecs/OrbitingBehavior.js"],"names":[],"mappings":"AAQA;IA4DI;;;;;;OAMG;IACH,uCALW,OAAO,GAGL,gBAAgB,CAmB5B;IAlFD;;;;OAIG;IACH,MAFU,MAAM,CAED;IAEf;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,OAAO,CAEM;IAEvB;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,wBAA+B;IAE/B;;;OAGG;IACH,QAFU,OAAO,CAEM;IAGvB;;;OAGG;IACH,cAFU,UAAU,CAEY;IAwChC,qEAgGC;CACJ;+BArM8B,qBAAqB;oBAJhC,kCAAkC;uBAD/B,qCAAqC;+BAI7B,sBAAsB"}

package/src/engine/intelligence/behavior/ecs/OrbitingBehavior.js

@@ -0,0 +1,204 @@
+import { assert } from "../../../../core/assert.js";
+import Quaternion from "../../../../core/geom/Quaternion.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+import { lerp } from "../../../../core/math/lerp.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+import { EntityBehavior } from "./EntityBehavior.js";
+
+export class OrbitingBehavior extends EntityBehavior {
+
+    /**
+     * Radians per second.
+     * Can be negative for counter-clockwise rotation.
+     * @type {number}
+     */
+    rate = Math.PI;
+
+    /**
+     *
+     * @type {number}
+     */
+    radius = 1;
+
+    /**
+     * Initial offset in radians
+     * @type {number}
+     */
+    phase = 0;
+
+    /**
+     *
+     * @type {number}
+     */
+    angle = 0;
+
+    /**
+     * Offset from the origin
+     * @type {Vector3}
+     */
+    offset = new Vector3();
+
+    /**
+     *
+     * @type {number}
+     */
+    parent = -1;
+
+    /**
+     *
+     * @type {number}
+     */
+    easing = 1;
+
+    orientation = new Quaternion();
+
+    /**
+     *
+     * @type {Vector3}
+     */
+    center = new Vector3();
+
+
+    /**
+     *
+     * @type {Quaternion}
+     */
+    lookRotation = new Quaternion();
+
+    /**
+     *
+     * @param {Vector3} [center]
+     * @param {number} [radius]
+     * @param {number} [rate]
+     * @returns {OrbitingBehavior}
+     */
+    static from({
+                    center = Vector3.zero,
+                    radius = 1,
+                    rate = 1
+                }) {
+
+        assert.defined(center, 'center')
+        assert.isNumber(radius, 'radius')
+        assert.isNumber(rate, 'rate')
+
+        const r = new OrbitingBehavior();
+
+        r.offset.copy(center);
+        r.radius = radius;
+        r.rate = rate;
+
+        return r;
+    }
+
+    initialize(context) {
+        super.initialize(context);
+
+        const easing = this.easing;
+
+        this.easing = 1;
+
+        this.tick(0);
+
+        this.easing = easing;
+    }
+
+    tick(timeDelta) {
+
+        const angleDelta = timeDelta * this.rate;
+
+        this.angle += angleDelta;
+
+        const entity = this.context.entity;
+        const ecd = this.context.ecd;
+
+        /**
+         *
+         * @type {Transform}
+         */
+        const transform = ecd.getComponent(entity, Transform);
+
+        if (transform === undefined) {
+            return BehaviorStatus.Failed;
+        }
+
+        const a = this.angle + this.phase;
+
+        const cos = Math.cos(a);
+        const sin = Math.sin(a);
+
+        let center_x = this.offset.x;
+        let center_y = this.offset.y;
+        let center_z = this.offset.z;
+
+        const r = this.radius;
+
+
+        let x = r * cos;
+        let y = 0;
+        let z = r * sin;
+
+        const q = this.orientation;
+
+        //transform point into quaternion
+        const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
+
+        // calculate quat * vector
+
+        var ix = qw * x + qy * z;
+        var iy = qz * x - qx * z;
+        var iz = qw * z - qy * x;
+        var iw = -qx * x - qz * z;
+
+        // calculate result * inverse quat
+
+        x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+        y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+        z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+
+
+        if (this.parent !== -1 && ecd.entityExists(this.parent)) {
+
+            const parentTransform = ecd.getComponent(this.parent, Transform);
+
+            center_x += parentTransform.position.x;
+            center_y += parentTransform.position.y;
+            center_z += parentTransform.position.z;
+
+
+            const parentScape = parentTransform.scale;
+
+            x *= parentScape.x;
+            y *= parentScape.y;
+            z *= parentScape.z;
+        }
+
+        center_x = lerp(this.center.x, center_x, this.easing);
+        center_y = lerp(this.center.y, center_y, this.easing);
+        center_z = lerp(this.center.z, center_z, this.easing);
+
+        this.center.set(center_x, center_y, center_z);
+
+        const _x = center_x + x;
+        const _y = center_y + y;
+        const _z = center_z + z;
+
+        const p = transform.position;
+
+        const old_x = p.x;
+        const old_y = p.y;
+        const old_z = p.z;
+
+        if (old_x !== _x || old_y !== _y || old_z !== _z) {
+
+            transform.rotation._lookRotation(_x - old_x, _y - old_y, _z - old_z, 0, 1, 0);
+            transform.rotation.multiplyQuaternions(transform.rotation, this.lookRotation);
+
+        }
+
+        p.set(_x, _y, _z);
+
+        return BehaviorStatus.Running;
+    }
+}