@woosh/meep-engine 2.138.3 → 2.138.5

package/src/engine/graphics/ecs/light/shadow/extend_shadow_camera_near_for_casters.js

@@ -0,0 +1,97 @@
+import {
+    clipping_volume_matrix4_project
+} from "../../../../../core/geom/3d/frustum/clipping_volume_matrix4_project.js";
+import { hexahedron_from_aabb } from "../../../../../core/geom/3d/frustum/hexahedron_from_aabb.js";
+
+const scratch_local_planes = new Float32Array(24);
+const scratch_world_planes = new Float32Array(24);
+const scratch_range = { near: 0, far: 0 };
+
+// Half-extent of the z range used for the caster query. We want any object in
+// the column above the receivers regardless of how far it sits along the light
+// direction, so the query volume is effectively unbounded in z; the BVH walk's
+// AABB-vs-frustum test is happy with a wide-but-finite range and avoids
+// infinities propagating through plane math.
+const CASTER_QUERY_HALF_RANGE = 1e7;
+
+/**
+ * Push the shadow camera's near plane back toward the light to include any
+ * occluder whose shadow would fall within the camera's x/y bounds, even when
+ * the occluder itself sits outside the main view frustum.
+ *
+ * Without this step the textbook "fit shadow camera to view frustum" leaves
+ * the near plane at the closest receiver — a brick floating just above the
+ * view frustum gets clipped out of the shadow map and casts no shadow on the
+ * ground below.
+ *
+ * Algorithm:
+ *   1. Take the shadow camera's existing left/right/top/bottom (already fit
+ *      to receivers) as the x/y extents of a light-local query box. Extend z
+ *      to a wide range so any caster along the light direction is captured.
+ *   2. Transform the 6 box planes to world space via the shadow camera's
+ *      matrixWorld.
+ *   3. Walk every render layer's BVH through `compute_depth_range` against
+ *      this world-space volume, measured along the shadow camera's view
+ *      direction.
+ *   4. If the closest depth found is smaller than the camera's current near,
+ *      replace near with it.
+ *
+ * Far is intentionally left alone: casters behind the farthest receiver (in
+ * light direction) can't shadow anything in the view.
+ *
+ * @param {THREE.OrthographicCamera} shadow_camera
+ * @param {RenderLayerManager} layers
+ */
+export function extend_shadow_camera_near_for_casters(shadow_camera, layers) {
+    if (layers === null) {
+        return;
+    }
+
+    const x0 = shadow_camera.left;
+    const x1 = shadow_camera.right;
+    const y0 = shadow_camera.bottom;
+    const y1 = shadow_camera.top;
+
+    hexahedron_from_aabb(
+        scratch_local_planes, 0,
+        x0, y0, -CASTER_QUERY_HALF_RANGE,
+        x1, y1, CASTER_QUERY_HALF_RANGE
+    );
+
+    clipping_volume_matrix4_project(
+        scratch_world_planes, 0,
+        scratch_local_planes, 0,
+        6,
+        shadow_camera.matrixWorld.elements
+    );
+
+    // Depth plane: world-space, normal along the shadow camera's view direction
+    // (-Z column of matrixWorld), passing through the camera position. A point's
+    // distance to this plane equals its depth in front of the camera.
+    const m = shadow_camera.matrixWorld.elements;
+    const nx = -m[8];
+    const ny = -m[9];
+    const nz = -m[10];
+    const plane_constant = -(nx * m[12] + ny * m[13] + nz * m[14]);
+
+    scratch_range.near = Number.POSITIVE_INFINITY;
+    scratch_range.far = Number.NEGATIVE_INFINITY;
+
+    layers.traverse((layer) => {
+        if (!layer.state.visible) {
+            return;
+        }
+
+        const compute = layer.compute_depth_range;
+
+        if (compute === null) {
+            return;
+        }
+
+        compute(scratch_range, scratch_world_planes, nx, ny, nz, plane_constant);
+    });
+
+    if (isFinite(scratch_range.near) && scratch_range.near < shadow_camera.near) {
+        shadow_camera.near = scratch_range.near;
+    }
+}

package/src/engine/graphics/ecs/mesh/MeshSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh/MeshSystem.js"],"names":[],"mappings":"AA6BA;IAiZI;;;;;;;OAOG;IACH,kCANW,IAAI,uCAEJ,OAAO,GACL,OAAO,CAQnB;IA7ZD;;;;;OAKG;IACH,4BAwDC;IAjDG;;;;OAIG;IACH,iBAAsB;IAEtB,iDAAqC;IAErC,4DAEC;IAGD;;;OAGG;IACH,2BAAgC;IAEhC,sBAAwB;IAExB;;;OAGG;IACH,YAFU,MAAO,MAAO,aAAa,CAAC,CAAC,CAEnB;IAEpB,cAAwB;IAExB;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAEvB;;;;OAIG;IACH,+BAAmC;IAEnC;;;;OAIG;IACH,qBAA6B;IAGjC;;;;;;OAMG;IACH,8BALW,MAAM,4DAGN,IAAI,QA+Bd;IAED,2CAuDC;IAED;;;;OAIG;IACH,gCAHoB,IAAI,QAAE,MAAM,+BA8C/B;IAED,4CAEC;IAED;;;;;OAKG;IACH,YAHW,IAAI,aADJ,SAAS,UAET,MAAM,QAkChB;IAED;;;;;OAKG;IACH,cAHW,IAAI,aADJ,SAAS,YAET,MAAM,QAmChB;IAED;;;;OAIG;IACH,gCAFW,IAAI,QA+Ed;IAED,6BAoBC;CAgBJ;uBAnbsB,wBAAwB;0BACrB,qCAAqC;iBAO/B,WAAW;4CAVC,uDAAuD;8BAJrE,iDAAiD;oBAE3D,kCAAkC"}
+{"version":3,"file":"MeshSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh/MeshSystem.js"],"names":[],"mappings":"AA8BA;IAsZI;;;;;;;OAOG;IACH,kCANW,IAAI,uCAEJ,OAAO,GACL,OAAO,CAQnB;IAlaD;;;;;OAKG;IACH,4BAwDC;IAjDG;;;;OAIG;IACH,iBAAsB;IAEtB,iDAAqC;IAErC,4DAEC;IAGD;;;OAGG;IACH,2BAAgC;IAEhC,sBAAwB;IAExB;;;OAGG;IACH,YAFU,MAAO,MAAO,aAAa,CAAC,CAAC,CAEnB;IAEpB,cAAwB;IAExB;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAEvB;;;;OAIG;IACH,+BAAmC;IAEnC;;;;OAIG;IACH,qBAA6B;IAGjC;;;;;;OAMG;IACH,8BALW,MAAM,4DAGN,IAAI,QA+Bd;IAED,2CA4DC;IAED;;;;OAIG;IACH,gCAHoB,IAAI,QAAE,MAAM,+BA8C/B;IAED,4CAEC;IAED;;;;;OAKG;IACH,YAHW,IAAI,aADJ,SAAS,UAET,MAAM,QAkChB;IAED;;;;;OAKG;IACH,cAHW,IAAI,aADJ,SAAS,YAET,MAAM,QAmChB;IAED;;;;OAIG;IACH,gCAFW,IAAI,QA+Ed;IAED,6BAoBC;CAgBJ;uBAxbsB,wBAAwB;0BACrB,qCAAqC;iBAO/B,WAAW;4CAVC,uDAAuD;8BAJrE,iDAAiD;oBAE3D,kCAAkC"}

package/src/engine/graphics/ecs/mesh/MeshSystem.js

@@ -1,6 +1,7 @@
 import { BoxBufferGeometry, MeshLambertMaterial } from "three";
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import { SignalBinding } from "../../../../core/events/signal/SignalBinding.js";
 
 import Vector3 from "../../../../core/geom/Vector3.js";
@@ -157,6 +158,11 @@ export class MeshSystem extends System {
             }
         )
 
+        const bvh = this.__bvh_binary;
+        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        };
+
         const visibleSet = this.renderLayer.visibleSet;
 
         visibleSet.onAdded.add(m => {

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js"],"names":[],"mappings":"AA6DA;IACI;;;OAGG;IACH,4BAmEC;IAjEG,2DAA+C;IAE/C;;;;OAIG;IACH,iBAAsB;IAEtB;;;;OAIG;IACH,uBAA0B;IAE1B;;;;OAIG;IACH,wBAAgC;IAEhC;;;;OAIG;IACH,4BAAoC;IAEpC;;;;OAIG;IACH,kCAA0C;IAE1C;;;;OAIG;IACH,qBAA6B;IAI7B,0BAYE;IAEF,yBAIC;IAIL;;;OAGG;IACH,eAEC;IAED;;;OAGG;IACH,4BAFa,IAAI,MAAM,EAAC,MAAM,CAAC,CAI9B;IAED;;;;OAIG;IACH,+BAHW,MAAM,+CAsBhB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACL,OAAO,CAmBlB;IAED;;;;OAIG;IACH,4BASC;IAED;;;;OAIG;IACH,8BAMC;IAED,2CAgCC;IAED,4CAcC;IAED;;;;;OAKG;IACH,SAJW,cAAc,KACd,SAAS,UACT,MAAM,QAqBhB;IAED;;;;;OAKG;IACH,WAJW,cAAc,KACd,SAAS,UACT,MAAM,QAsBhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GACxB,MAAM,CAQlB;IAED;;;;;;;;;;;OAWG;IACH,kBAVW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,uEAGJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAC;QAAC,OAAO,EAAE,aAAa,CAAA;KAAC,EAAE,CA8D1E;IAGD;;;;;;;;;;;;OAYG;IACH,wBAXW,aAAa,YACb,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,uEAGJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAA;KAAC,GAAC,SAAS,CAmF1D;CACJ;uBAxfsB,wBAAwB;0BACrB,qCAAqC;+BAGhC,qBAAqB;iBARnC,uCAAuC;oBAXpC,mCAAmC;2BAO5B,yCAAyC;8BAEtC,2CAA2C"}
+{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js"],"names":[],"mappings":"AA8DA;IACI;;;OAGG;IACH,4BAmEC;IAjEG,2DAA+C;IAE/C;;;;OAIG;IACH,iBAAsB;IAEtB;;;;OAIG;IACH,uBAA0B;IAE1B;;;;OAIG;IACH,wBAAgC;IAEhC;;;;OAIG;IACH,4BAAoC;IAEpC;;;;OAIG;IACH,kCAA0C;IAE1C;;;;OAIG;IACH,qBAA6B;IAI7B,0BAYE;IAEF,yBAIC;IAIL;;;OAGG;IACH,eAEC;IAED;;;OAGG;IACH,4BAFa,IAAI,MAAM,EAAC,MAAM,CAAC,CAI9B;IAED;;;;OAIG;IACH,+BAHW,MAAM,+CAsBhB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACL,OAAO,CAmBlB;IAED;;;;OAIG;IACH,4BASC;IAED;;;;OAIG;IACH,8BAMC;IAED,2CAqCC;IAED,4CAcC;IAED;;;;;OAKG;IACH,SAJW,cAAc,KACd,SAAS,UACT,MAAM,QAqBhB;IAED;;;;;OAKG;IACH,WAJW,cAAc,KACd,SAAS,UACT,MAAM,QAsBhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GACxB,MAAM,CAQlB;IAED;;;;;;;;;;;OAWG;IACH,kBAVW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,uEAGJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAC;QAAC,OAAO,EAAE,aAAa,CAAA;KAAC,EAAE,CA8D1E;IAGD;;;;;;;;;;;;OAYG;IACH,wBAXW,aAAa,YACb,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,uEAGJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAA;KAAC,GAAC,SAAS,CAmF1D;CACJ;uBA7fsB,wBAAwB;0BACrB,qCAAqC;+BAGhC,qBAAqB;iBARnC,uCAAuC;oBAZpC,mCAAmC;2BAQ5B,yCAAyC;8BAEtC,2CAA2C"}

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -1,6 +1,7 @@
 import { mat4 } from "gl-matrix";
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_generic.js";
 import {
     bvh_query_user_data_overlaps_frustum
@@ -256,6 +257,11 @@ export class ShadedGeometrySystem extends System {
             return ctx.collect(destination, destination_offset, graphics.renderer, view, this.__bvh_binary, ecd);
         });
 
+        const bvh = this.__bvh_binary;
+        this.__render_layer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        };
+
         this.__optimization_task.state.set(TaskState.INITIAL);
         engine.executor.run(this.__optimization_task);
 

package/src/engine/graphics/ecs/trail2d/Trail2DSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Trail2DSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail2d/Trail2DSystem.js"],"names":[],"mappings":";AAyBA;IAkCI;;;OAGG;IACH,4BA4BC;IAjED,oDAAoC;IAEpC,+DAEE;IAEF;;;OAGG;IACH,WAFU,4BAA4B,CAES;IAE/C;;;;OAIG;IACH,wBAAiC;IAGjC;;;;OAIG;IACH,oBAAgB;IAEhB;;;OAGG;IACH,YAAgB;IAcZ;;;;OAIG;IACH,iBAAsB;IAEtB;;;OAGG;IACH,UAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,2CAcC;IAED,4CAIC;IAED;;;;;OAKG;IACH,sBAoDC;IAED;;;;;OAKG;IACH,YAHW,OAAO,aADP,SAAS,YAET,MAAM,QAahB;IAED;;;;;OAKG;IACH,kBAJW,OAAO,aACP,SAAS,UACT,MAAM,QAShB;IAED;;;;OAIG;IACH,yBAHW,OAAO,aACP,SAAS,QAoCnB;IAED,6BAWC;CACJ;uBA/PsB,wBAAwB;0BACrB,qCAAqC;oBAY3C,cAAc;4CAdU,uDAAuD;6CAYtD,yDAAyD;+BARvE,yBAAyB"}
+{"version":3,"file":"Trail2DSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail2d/Trail2DSystem.js"],"names":[],"mappings":";AA0BA;IAkCI;;;OAGG;IACH,4BA4BC;IAjED,oDAAoC;IAEpC,+DAEE;IAEF;;;OAGG;IACH,WAFU,4BAA4B,CAES;IAE/C;;;;OAIG;IACH,wBAAiC;IAGjC;;;;OAIG;IACH,oBAAgB;IAEhB;;;OAGG;IACH,YAAgB;IAcZ;;;;OAIG;IACH,iBAAsB;IAEtB;;;OAGG;IACH,UAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,2CAmBC;IAED,4CAIC;IAED;;;;;OAKG;IACH,sBAoDC;IAED;;;;;OAKG;IACH,YAHW,OAAO,aADP,SAAS,YAET,MAAM,QAahB;IAED;;;;;OAKG;IACH,kBAJW,OAAO,aACP,SAAS,UACT,MAAM,QAShB;IAED;;;;OAIG;IACH,yBAHW,OAAO,aACP,SAAS,QAoCnB;IAED,6BAWC;CACJ;uBApQsB,wBAAwB;0BACrB,qCAAqC;oBAY3C,cAAc;4CAdU,uDAAuD;6CAYtD,yDAAyD;+BARvE,yBAAyB"}

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

@@ -1,5 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import Vector3 from '../../../../core/geom/Vector3.js';
 import { clamp } from "../../../../core/math/clamp.js";
 import { max2 } from "../../../../core/math/max2.js";
@@ -104,6 +105,11 @@ class Trail2DSystem extends System {
             }
         );
 
+        const bvh = this.bvh;
+        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        };
+
         this.__ribbon_plugin = await this.__engine.plugins.acquire(RibbonXPlugin);
     }
 

package/src/engine/graphics/ecs/water/WaterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAYA;IAyBI;;;;OAIG;IACH,sCAYC;IAzCD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,4CAMC;IAED,2CA4DC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBA/QsB,wBAAwB;kBAM7B,YAAY;oBAPV,mCAAmC"}
+{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAaA;IAyBI;;;;OAIG;IACH,sCAYC;IAzCD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,4CAMC;IAED,2CAiEC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBApRsB,wBAAwB;kBAM7B,YAAY;oBARV,mCAAmC"}

package/src/engine/graphics/ecs/water/WaterSystem.js

@@ -1,6 +1,7 @@
 import { BackSide, PlaneBufferGeometry } from 'three';
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import { System } from '../../../ecs/System.js';
 import { obtainTerrain } from "../../../ecs/terrain/util/obtainTerrain.js";
 import { make_bvh_visibility_builder } from "../../render/make_bvh_visibility_builder.js";
@@ -90,6 +91,11 @@ class WaterSystem extends System {
             }
         )
 
+        const bvh = this.bvh;
+        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        };
+
 
         const self = this;
 

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

@@ -39,14 +39,11 @@ async function main(engine) {
         enableWater: false,
         cameraFieldOfView: 45,
         showFps: false,
-        enableLights: false
+        enableLights: true,
+        enableShadows: true,
+        cameraAutoClip: true,
     });
 
-    await EngineHarness.buildLights({
-        engine,
-        sunIntensity: 0,
-        ambientIntensity: 1
-    });
 
     const ecd = engine.entityManager.dataset;
 
@@ -75,7 +72,7 @@ async function main(engine) {
     // console.profile('bake');
     const id = baker.bake({
         objects,
-        frames: 8,
+        frames: 32,
         resolution: 1024,
         type: ImpostorCaptureType.FullSphere
     });
@@ -86,7 +83,7 @@ async function main(engine) {
     const ctrl = makeImpostorAtlasPreview({
         impostor: id,
         renderer,
-        mode: 'diffuse'
+        mode: 'albedo'
     });
 
     ctrl.scale.setScalar(1);
@@ -119,8 +116,8 @@ async function main(engine) {
 
     const sg_mesh = SGMesh.fromURL(path);
 
-    sg_mesh.castShadow = false;
-    sg_mesh.receiveShadow = false;
+    sg_mesh.castShadow = true;
+    sg_mesh.receiveShadow = true;
 
     const entity_true_mesh = new Entity();
     entity_true_mesh

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+TA;IACI,cAmEC;IAHG,4CAAyB;CAIhC;kCA5XM,OAAO"}
+{"version":3,"file":"ImpostorShaderV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderV0.js"],"names":[],"mappings":"AAiZA;IACI,cAmEC;IAHG,4CAAyB;CAIhC;kCA9cM,OAAO"}

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

@@ -22,25 +22,42 @@ const shader_vx = `
     // 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).
+    // The 4 atlas frames at the corners of the current grid cell are chosen
+    // once per-impostor and forwarded as flat varyings so every fragment
+    // samples the same set (without this, a perspective camera could flip
+    // the chosen frames across the card and produce visible seams).
+    //
+    // We use bilinear interpolation over a full 2x2 cell, not a triangle
+    // interpolation over 3 corners. Triangle interpolation has a
+    // C1-discontinuous "diagonal switch" where one of the three contributing
+    // frames swaps between (gridFloor+(1,0)) and (gridFloor+(0,1)); even
+    // though the swap happens at zero weight (so the result is C0), the
+    // weight DERIVATIVE jumps, which the eye perceives as a snap inside the
+    // cell. Bilinear has no such switch — all 4 corners always contribute
+    // with weights that are smooth products of fract(grid).
     flat out vec2 vGridFloor;
-    flat out vec4 vWeights;
+    flat out vec4 vWeights;       // (w00, w10, w01, w11)
 
     // 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.
+    // points along the weighted blend of the 4 nearest baked view
+    // directions, and TANGENT/BINORMAL line up with the *blended* bake
+    // camera's right/up. Used by the fragment shader to transform the
+    // view-space view-dir into the card's tangent frame.
     flat out vec3 vTangent;
     flat out vec3 vBinormal;
     flat out vec3 vNormal;
 
+    // Per-frame card-UV -> texture-UV rotation matrices, one per cell
+    // corner. Each frame was baked with its own camera right/up (from
+    // three.js Camera.lookAt with up=(0,1,0)); near the octahedral pole
+    // those right-axes can swing 90° or more between adjacent frames.
+    // These matrices rotate the sample-UV into each frame's bake-camera
+    // basis so the four corners line up consistently when blended.
+    flat out vec4 vFrameXform00;
+    flat out vec4 vFrameXform10;
+    flat out vec4 vFrameXform01;
+    flat out vec4 vFrameXform11;
+
     uniform mat4 modelViewMatrix;
     uniform mat4 projectionMatrix;
 
@@ -130,19 +147,41 @@ const shader_vx = `
         return normalize(GridToVector(f));
     }
 
-    vec4 TriangleInterpolate(vec2 frac_uv)
+    // Build the 2x2 matrix that maps card-centred UV (vUv - 0.5) into the
+    // texture-centred UV of a single baked frame. The matrix is just the
+    // (tangent_OS, binormal_OS) basis expressed in the frame's own
+    // (bake_right, bake_up) basis — i.e. how a step along the card's local
+    // axes shows up in the texture the frame was rendered into.
+    //
+    // bake_right/bake_up follow three.js Camera.lookAt with up=(0,1,0).
+    // We mirror its polar nudge so our shader basis matches what the
+    // baker actually used when D_frame is parallel to up.
+    vec4 ComputeFrameXform(vec3 D_frame, vec3 tangent_OS, vec3 binormal_OS)
+    {
+        vec3 D = abs(D_frame.y) > 0.99999
+                 ? normalize(D_frame + vec3(0.0, 0.0, 0.0001))
+                 : D_frame;
+        vec3 bake_right = normalize(cross(vec3(0.0, 1.0, 0.0), D));
+        vec3 bake_up    = cross(D, bake_right);
+        return vec4(
+            dot(tangent_OS,  bake_right),
+            dot(binormal_OS, bake_right),
+            dot(tangent_OS,  bake_up),
+            dot(binormal_OS, bake_up)
+        );
+    }
+
+    // Bilinear weights over the 4 corners of the current cell, in the
+    // order (w00, w10, w01, w11) matching gridFloor + (0,0)/(1,0)/(0,1)/(1,1).
+    vec4 BilinearWeights(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;
+        return vec4(
+            omuv.x * omuv.y,    // w00
+            frac_uv.x * omuv.y, // w10
+            omuv.x * frac_uv.y, // w01
+            frac_uv.x * frac_uv.y // w11
+        );
     }
 
     void main() {
@@ -159,25 +198,28 @@ const shader_vx = `
         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(fract(grid));
+        // Clamp gridFloor so the +1 corners never reference past the last
+        // valid frame index when grid is at the upper edge.
+        vec2 gridFloor = min(floor(grid), framesMinusOne - 1.0);
+        vec4 weights = BilinearWeights(grid - gridFloor);
 
         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.
+        // 2. Decode each of the 4 cell-corner frame indices back into its
+        //    bake-time view direction, then blend with the bilinear 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.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 ray00 = FrameToRay(gridFloor + vec2(0.0, 0.0), framesMinusOne);
+        vec3 ray10 = FrameToRay(gridFloor + vec2(1.0, 0.0), framesMinusOne);
+        vec3 ray01 = FrameToRay(gridFloor + vec2(0.0, 1.0), framesMinusOne);
+        vec3 ray11 = FrameToRay(gridFloor + vec2(1.0, 1.0), framesMinusOne);
         vec3 projectedRay = normalize(
-            ray0 * weights.x + ray1 * weights.y + ray2 * weights.z
+            ray00 * weights.x +
+            ray10 * weights.y +
+            ray01 * weights.z +
+            ray11 * weights.w
         );
 
         // 3. Build the card's TBN in object-local space.
@@ -224,6 +266,13 @@ const shader_vx = `
         vTangent  = normalize(m3 * tangent_OS);
         vBinormal = normalize(m3 * binormal_OS);
         vNormal   = normalize(m3 * normal_OS);
+
+        // 6. Per-frame UV rotation matrices. ComputeFrameXform handles the
+        //    polar-singularity nudge in three.js's lookAt internally.
+        vFrameXform00 = ComputeFrameXform(ray00, tangent_OS, binormal_OS);
+        vFrameXform10 = ComputeFrameXform(ray10, tangent_OS, binormal_OS);
+        vFrameXform01 = ComputeFrameXform(ray01, tangent_OS, binormal_OS);
+        vFrameXform11 = ComputeFrameXform(ray11, tangent_OS, binormal_OS);
     }
 `;
 const shader_fg = `
@@ -233,20 +282,25 @@ const shader_fg = `
     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.
+    // Cell base + bilinear weights for the 4 corners (w00, w10, w01, w11),
+    // computed per-impostor in the vertex shader. flat = no interpolation.
     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.
+    // Card's TBN in view space (perpendicular to the effective bake
+    // direction). Used to express the view direction in the card's tangent
+    // frame for parallax.
     flat in vec3 vTangent;
     flat in vec3 vBinormal;
     flat in vec3 vNormal;
 
+    // Per-frame 2x2 rotation matrices (a, b, c, d) that map card-centred
+    // UV into each frame's bake-camera basis. Each cell corner has its own.
+    flat in vec4 vFrameXform00;
+    flat in vec4 vFrameXform10;
+    flat in vec4 vFrameXform01;
+    flat in vec4 vFrameXform11;
+
     out vec4 color_out;
 
     uniform sampler2D tBase;
@@ -254,25 +308,45 @@ const shader_fg = `
     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)
+    // Apply a per-frame 2x2 rotation matrix to a card UV, rotating around
+    // the texture centre (0.5, 0.5). xform = (a, b, c, d) packs row-major
+    // [a b ; c d].
+    vec2 apply_frame_xform(vec2 card_uv, vec4 xform)
     {
+        vec2 c = card_uv - 0.5;
+        return vec2(
+            xform.x * c.x + xform.y * c.y,
+            xform.z * c.x + xform.w * c.y
+        ) + 0.5;
+    }
+
+    // Sample the same card-UV from the 4 cell-corner atlas frames, applying
+    // each frame's own UV rotation so the textures land in a consistent
+    // orientation, then blend with the bilinear weights. Used for both
+    // depth and colour.
+    vec4 blend_4_frames(
+        sampler2D tex, vec2 card_uv,
+        vec2 gridFloor, vec4 w,
+        vec4 x00, vec4 x10, vec4 x01, vec4 x11
+    ) {
         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;
+        // Clamp inside the unit square AFTER the per-frame rotation: at
+        // sharp angles the rotation can push a corner UV outside [0,1] and
+        // bleed into the neighbouring atlas tile (which is a completely
+        // different bake direction). Clamping keeps the sample inside the
+        // frame it's supposed to belong to.
+        vec2 uv00 = clamp(apply_frame_xform(card_uv, x00), 0.0, 1.0);
+        vec2 uv10 = clamp(apply_frame_xform(card_uv, x10), 0.0, 1.0);
+        vec2 uv01 = clamp(apply_frame_xform(card_uv, x01), 0.0, 1.0);
+        vec2 uv11 = clamp(apply_frame_xform(card_uv, x11), 0.0, 1.0);
+        vec4 s00 = texture(tex, (gridFloor + vec2(0.0, 0.0) + uv00) * frame_size);
+        vec4 s10 = texture(tex, (gridFloor + vec2(1.0, 0.0) + uv10) * frame_size);
+        vec4 s01 = texture(tex, (gridFloor + vec2(0.0, 1.0) + uv01) * frame_size);
+        vec4 s11 = texture(tex, (gridFloor + vec2(1.0, 1.0) + uv11) * frame_size);
+        return s00 * w.x + s10 * w.y + s01 * w.z + s11 * w.w;
     }
 
     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
@@ -299,7 +373,11 @@ const shader_fg = `
         // 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;
+        float depth = blend_4_frames(
+            tGeometry, base_uv,
+            vGridFloor, vWeights,
+            vFrameXform00, vFrameXform10, vFrameXform01, vFrameXform11
+        ).a;
         base_uv += (view_dir.xy / view_dir.z) * (depth - 0.5) * uDepthScale;
 
         // Keep the parallax-shifted sample inside the current frame's tile.
@@ -307,7 +385,11 @@ const shader_fg = `
         // 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);
+        vec4 texel_color = blend_4_frames(
+            tBase, base_uv,
+            vGridFloor, vWeights,
+            vFrameXform00, vFrameXform10, vFrameXform01, vFrameXform11
+        );
 
         if (texel_color.a <= 0.5) {
             discard;

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

@@ -1 +1 @@
-{"version":3,"file":"ImpostorShaderWireframeV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderWireframeV0.js"],"names":[],"mappings":"AAwEA;IACI,cA2DC;IAHG,4CAAyB;CAIhC;kCA7HM,OAAO"}
+{"version":3,"file":"ImpostorShaderWireframeV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderWireframeV0.js"],"names":[],"mappings":"AA6JA;IACI,cA2DC;IAHG,4CAAyB;CAIhC;kCAlNM,OAAO"}