@woosh/meep-engine 2.169.0 → 2.169.2

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

@@ -7,6 +7,13 @@ import {
     RawShaderMaterial,
     Vector3
 } from "three";
+import {
+    GLSL_IMPOSTOR_APPLY_FRAME_XFORM,
+    GLSL_IMPOSTOR_BILINEAR_WEIGHTS,
+    GLSL_IMPOSTOR_BLEND_4_FRAMES,
+    GLSL_IMPOSTOR_COMPUTE_FRAME_XFORM,
+    GLSL_OCTAHEDRAL_GRID
+} from "../../../shaders/chunks/glsl_octahedral_impostor.js";
 
 /*
  *
@@ -66,123 +73,9 @@ const shader_vx = `
     uniform float uFrames;
     uniform bool uIsFullSphere;
 
-    // ----- direction -> octahedral grid coord (range -1..+1) -----
-
-    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);
-        }
-    }
-
-    // ----- 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)
-    {
-        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;
-    }
-
-    vec3 OctaHemiSphereDec(vec2 coord)
-    {
-        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;
-    }
-
-    vec3 GridToVector(vec2 coord)
-    {
-        if (uIsFullSphere) {
-            return OctaSphereDec(coord);
-        } else {
-            return OctaHemiSphereDec(coord);
-        }
-    }
-
-    // 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)
-    {
-        vec2 f = clamp(frame / framesMinusOne, 0.0, 1.0);
-        return normalize(GridToVector(f));
-    }
-
-    // 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;
-        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
-        );
-    }
+${GLSL_OCTAHEDRAL_GRID}
+${GLSL_IMPOSTOR_COMPUTE_FRAME_XFORM}
+${GLSL_IMPOSTOR_BILINEAR_WEIGHTS}
 
     void main() {
         vUv = uv;
@@ -315,43 +208,8 @@ const shader_fg = `
     uniform float uFrames;
     uniform float uDepthScale;
 
-    // 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);
-        // 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;
-    }
+${GLSL_IMPOSTOR_APPLY_FRAME_XFORM}
+${GLSL_IMPOSTOR_BLEND_4_FRAMES}
 
     void main() {
         // View direction in the card's tangent space. The card is oriented

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

@@ -1 +1 @@
-{"version":3,"file":"ImpostorShaderViewportDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderViewportDepthV0.js"],"names":[],"mappings":"AAiUA;;;;;;;;GAQG;AACH;IACI,cAkBC;CACJ;kCA9V6D,OAAO"}
+{"version":3,"file":"ImpostorShaderViewportDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderViewportDepthV0.js"],"names":[],"mappings":"AA6OA;;;;;;;;GAQG;AACH;IACI,cAkBC;CACJ;kCA1Q6D,OAAO"}

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

@@ -1,4 +1,10 @@
 import { GLSL3, NoBlending, RawShaderMaterial, Vector3 } from "three";
+import {
+    GLSL_IMPOSTOR_APPLY_FRAME_XFORM,
+    GLSL_IMPOSTOR_BILINEAR_WEIGHTS,
+    GLSL_IMPOSTOR_COMPUTE_FRAME_XFORM,
+    GLSL_OCTAHEDRAL_GRID
+} from "../../../shaders/chunks/glsl_octahedral_impostor.js";
 
 // Debug-viz variant: shows the parallax-corrected surface's VIEWPORT
 // depth as grayscale. This is the same value ImpostorShaderDepthV0
@@ -43,92 +49,9 @@ const shader_vx = `
     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)
-    {
-        return uIsFullSphere ? VecToSphereOct(v) : VecToHemiSphereOct(v);
-    }
-
-    vec3 OctaSphereDec(vec2 coord)
-    {
-        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;
-    }
-
-    vec3 OctaHemiSphereDec(vec2 coord)
-    {
-        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;
-    }
-
-    vec3 GridToVector(vec2 coord)
-    {
-        return uIsFullSphere ? OctaSphereDec(coord) : OctaHemiSphereDec(coord);
-    }
-
-    vec3 FrameToRay(vec2 frame, vec2 framesMinusOne)
-    {
-        vec2 f = clamp(frame / framesMinusOne, 0.0, 1.0);
-        return normalize(GridToVector(f));
-    }
-
-    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)
-        );
-    }
-
-    vec4 BilinearWeights(vec2 frac_uv)
-    {
-        vec2 omuv = vec2(1.0) - frac_uv;
-        return vec4(
-            omuv.x * omuv.y,
-            frac_uv.x * omuv.y,
-            omuv.x * frac_uv.y,
-            frac_uv.x * frac_uv.y
-        );
-    }
+${GLSL_OCTAHEDRAL_GRID}
+${GLSL_IMPOSTOR_COMPUTE_FRAME_XFORM}
+${GLSL_IMPOSTOR_BILINEAR_WEIGHTS}
 
     void main() {
         vUv = uv;
@@ -222,14 +145,7 @@ const shader_fg = `
     uniform float uRadius;
     uniform float uDepthScale;
 
-    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;
-    }
+${GLSL_IMPOSTOR_APPLY_FRAME_XFORM}
 
     void main() {
         // Parallax shift in CAMERA tangent space — this is the visible

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":"AAgKA;IACI,cA2DC;IAHG,4CAAyB;CAIhC;kCArNM,OAAO"}
+{"version":3,"file":"ImpostorShaderWireframeV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderWireframeV0.js"],"names":[],"mappings":"AAgGA;IACI,cA2DC;IAHG,4CAAyB;CAIhC;kCArJM,OAAO"}

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

@@ -7,6 +7,10 @@ import {
     RawShaderMaterial,
     Vector3
 } from "three";
+import {
+    GLSL_IMPOSTOR_BILINEAR_WEIGHTS,
+    GLSL_OCTAHEDRAL_GRID
+} from "../../../shaders/chunks/glsl_octahedral_impostor.js";
 
 // The wireframe must trace the SAME card geometry that ImpostorShaderV0
 // produces, otherwise the red outline lies about where the impostor surface
@@ -28,79 +32,11 @@ const shader_vx = `
 
     // ----- direction -> octahedral grid coord (range -1..+1) -----
 
-    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)
-    {
-        return uIsFullSphere ? VecToSphereOct(v) : VecToHemiSphereOct(v);
-    }
-
-    // ----- octahedral grid coord (range 0..1) -> direction -----
-
-    vec3 OctaSphereDec(vec2 coord)
-    {
-        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;
-    }
+${GLSL_OCTAHEDRAL_GRID}
+
 
-    vec3 OctaHemiSphereDec(vec2 coord)
-    {
-        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;
-    }
-
-    vec3 GridToVector(vec2 coord)
-    {
-        return uIsFullSphere ? OctaSphereDec(coord) : OctaHemiSphereDec(coord);
-    }
-
-    vec3 FrameToRay(vec2 frame, vec2 framesMinusOne)
-    {
-        vec2 f = clamp(frame / framesMinusOne, 0.0, 1.0);
-        return normalize(GridToVector(f));
-    }
-
-    vec4 BilinearWeights(vec2 frac_uv)
-    {
-        vec2 omuv = vec2(1.0) - frac_uv;
-        return vec4(
-            omuv.x * omuv.y,
-            frac_uv.x * omuv.y,
-            omuv.x * frac_uv.y,
-            frac_uv.x * frac_uv.y
-        );
-    }
+${GLSL_IMPOSTOR_BILINEAR_WEIGHTS}
+
 
     void main() {
         // Pivot-to-camera direction in object-local space; same as V0.

package/src/engine/graphics/impostors/octahedral/shader/glsl/common.glsl

@@ -1,3 +1,13 @@
+// NAME COLLISION WARNING.
+//
+// `VecToSphereOct`, `VectorToGrid` and `GridToVector` below are the HLSL-derived
+// V1/Standard convention: they fold via `_ImposterFullSphere`, divide only the
+// .xz components by the L1 norm, and use HLSL intrinsics (`frac`, `saturate`,
+// `tex2Dgrad`). They are NOT the same mapping as the identically-named functions
+// in `engine/graphics/shaders/chunks/glsl_octahedral_impostor.js`, which is what
+// the V0 impostor family and the CPU bake path use. Do not assume a function
+// named `VecToSphereOct` in this repository produces one particular mapping —
+// check which preamble the shader you are reading pulls in.
 struct ImposterData
 {
     vec2 uv;

package/src/engine/graphics/impostors/voxel/bake/read_atlas_to_samples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read_atlas_to_samples.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/voxel/bake/read_atlas_to_samples.js"],"names":[],"mappings":"AAuLA;;;;;;;;;;;;;;;;GAgBG;AACH;IAJuC,QAAQ;IACR,QAAQ,EAApC,MAAM,aAAa;;aACP,YAAY;kBAAgB,MAAM;EA2IxD;AA3UD;;;;;;;;;;;GAWG;AACH,kCAFU,MAAM,CAEsB"}
+{"version":3,"file":"read_atlas_to_samples.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/voxel/bake/read_atlas_to_samples.js"],"names":[],"mappings":"AAuMA;;;;;;;;;;;;;;;;GAgBG;AACH;IAJuC,QAAQ;IACR,QAAQ,EAApC,MAAM,aAAa;;aACP,YAAY;kBAAgB,MAAM;EAgJxD;AAhWD;;;;;;;;;;;GAWG;AACH,kCAFU,MAAM,CAEsB"}

package/src/engine/graphics/impostors/voxel/bake/read_atlas_to_samples.js

@@ -45,36 +45,33 @@ function read_atlas_texture_rgba_u8(renderer, texture) {
 
 
 /**
- * Decode the bake-time view-space normal back into the impostor's local
- * (object) space. Inverse of the encode side in BakeShaderStandard.
- *
- * The baker placed an OrthographicCamera at
+ * Number of values in a bake frame basis: right.xyz, up.xyz, D.xyz.
+ * @type {number}
+ */
+const BAKE_FRAME_STRIDE = 9;
+
+/**
+ * Rebuild the bake camera's orthonormal basis for one atlas frame.
  *
- *     camera_pos = centre + radius * D_frame
+ * The baker placed an OrthographicCamera at `centre + radius * D_frame` and
+ * pointed it at `centre` with three.js's `lookAt` using world-up = (0,1,0).
+ * That gives the object-space basis `(bake_right, bake_up, +D)`. Both the
+ * normal decode and the position reconstruction have to rebuild EXACTLY that
+ * basis, including the polar nudge, or they disagree with each other and with
+ * the baker — which is why this is one function rather than the two copies it
+ * replaces. The copies even said so ("Same polar nudge as the normal decoder,
+ * so right/up agree") without being able to enforce it.
  *
- * with three.js's lookAt(centre) using world-up = (0,1,0). That gives a
- * camera basis (bake_right, bake_up, +D_frame) in object space. The
- * baker wrote the surface normal as (normal.x = dot(n, right),
- * normal.y = dot(n, up), normal.z = dot(n, D_frame)) and packed it into
- * the atlas RGB channels as (* 0.5 + 0.5). So to reverse, decode the RGB
- * back to ±1 and recombine through the same basis.
+ * `D` is written into the output too: the nudge can change it, and every
+ * consumer needs the nudged value, not the caller's original.
  *
- * @param {number[]} out          length-3 output, object-space normal
- * @param {number} nr             encoded R in [0,1]
- * @param {number} ng             encoded G in [0,1]
- * @param {number} nb             encoded B in [0,1]
- * @param {number[]} D_frame      bake direction in object space (unit)
+ * @param {number[]} out_frame length {@link BAKE_FRAME_STRIDE}: [right.xyz, up.xyz, D.xyz]
+ * @param {number[]} D_frame bake direction in object space (unit)
  */
-function decode_normal_to_object_space(out, nr, ng, nb, D_frame) {
-    // 1. Decode bake-view-space normal from [0,1] to [-1,1]
-    const nx = nr * 2 - 1;
-    const ny = ng * 2 - 1;
-    const nz = nb * 2 - 1;
-
-    // 2. Mirror three.js Camera.lookAt's polar nudge — when D_frame is
-    //    parallel to world-up, lookAt jiggles +Z slightly to avoid a
-    //    degenerate cross product. We have to do the same so our basis
-    //    matches the baker's.
+function bake_frame_from_direction(out_frame, D_frame) {
+    // Mirror three.js Camera.lookAt's polar nudge — when D_frame is parallel
+    // to world-up, lookAt jiggles +Z slightly to avoid a degenerate cross
+    // product. We have to do the same so our basis matches the baker's.
     let Dx = D_frame[0], Dy = D_frame[1], Dz = D_frame[2];
     if (Math.abs(Dy) > 0.99999) {
         // Normalise (D + (0, 0, 0.0001)) — same nudge the lit shader uses.
@@ -85,8 +82,8 @@ function decode_normal_to_object_space(out, nr, ng, nb, D_frame) {
         Dz = dz_n / len;
     }
 
-    // 3. bake_right = normalize(cross((0,1,0), D))
-    //    Cross product: (0,1,0) × (Dx,Dy,Dz) = (Dz, 0, -Dx)
+    // bake_right = normalize(cross((0,1,0), D))
+    // Cross product: (0,1,0) × (Dx,Dy,Dz) = (Dz, 0, -Dx)
     let rx = Dz;
     let ry = 0;
     let rz = -Dx;
@@ -94,13 +91,49 @@ function decode_normal_to_object_space(out, nr, ng, nb, D_frame) {
         const len = Math.sqrt(rx * rx + ry * ry + rz * rz);
         rx /= len; ry /= len; rz /= len;
     }
-    // 4. bake_up = cross(D, right) — no normalise needed, D and right
-    //    are already orthonormal.
-    const ux = Dy * rz - Dz * ry;
-    const uy = Dz * rx - Dx * rz;
-    const uz = Dx * ry - Dy * rx;
 
-    // 5. Recompose in object space.
+    // bake_up = cross(D, right) — no normalise needed, D and right are
+    // already orthonormal.
+    out_frame[0] = rx;
+    out_frame[1] = ry;
+    out_frame[2] = rz;
+
+    out_frame[3] = Dy * rz - Dz * ry;
+    out_frame[4] = Dz * rx - Dx * rz;
+    out_frame[5] = Dx * ry - Dy * rx;
+
+    out_frame[6] = Dx;
+    out_frame[7] = Dy;
+    out_frame[8] = Dz;
+}
+
+
+/**
+ * Decode the bake-time view-space normal back into the impostor's local
+ * (object) space. Inverse of the encode side in BakeShaderStandard.
+ *
+ * The baker wrote the surface normal as (normal.x = dot(n, right),
+ * normal.y = dot(n, up), normal.z = dot(n, D_frame)) and packed it into
+ * the atlas RGB channels as (* 0.5 + 0.5). So to reverse, decode the RGB
+ * back to ±1 and recombine through the same basis.
+ *
+ * @param {number[]} out          length-3 output, object-space normal
+ * @param {number} nr             encoded R in [0,1]
+ * @param {number} ng             encoded G in [0,1]
+ * @param {number} nb             encoded B in [0,1]
+ * @param {number[]} frame        bake basis from {@link bake_frame_from_direction}
+ */
+function decode_normal_to_object_space(out, nr, ng, nb, frame) {
+    // Decode bake-view-space normal from [0,1] to [-1,1]
+    const nx = nr * 2 - 1;
+    const ny = ng * 2 - 1;
+    const nz = nb * 2 - 1;
+
+    const rx = frame[0], ry = frame[1], rz = frame[2];
+    const ux = frame[3], uy = frame[4], uz = frame[5];
+    const Dx = frame[6], Dy = frame[7], Dz = frame[8];
+
+    // Recompose in object space.
     out[0] = rx * nx + ux * ny + Dx * nz;
     out[1] = ry * nx + uy * ny + Dy * nz;
     out[2] = rz * nx + uz * ny + Dz * nz;
@@ -137,31 +170,14 @@ function decode_normal_to_object_space(out, nr, ng, nb, D_frame) {
  * @param {number} depth01       depth in [0,1] as stored in atlas alpha
  * @param {number} frame_u_local frame-local X in [-1, +1]
  * @param {number} frame_v_local frame-local Y in [-1, +1]
- * @param {number[]} D_frame     bake direction in object space (unit)
+ * @param {number[]} frame       bake basis from {@link bake_frame_from_direction}
  * @param {number} radius        bounding sphere radius
  * @param {number[]} centre      bounding sphere centre (object space)
  */
-function reconstruct_position(out, depth01, frame_u_local, frame_v_local, D_frame, radius, centre) {
-    // Same polar nudge as the normal decoder, so right/up agree.
-    let Dx = D_frame[0], Dy = D_frame[1], Dz = D_frame[2];
-    if (Math.abs(Dy) > 0.99999) {
-        const dz_n = Dz + 0.0001;
-        const len = Math.sqrt(Dx * Dx + Dy * Dy + dz_n * dz_n);
-        Dx /= len;
-        Dy /= len;
-        Dz = dz_n / len;
-    }
-
-    // Same basis as decode_normal_to_object_space; see the cross-product
-    // derivation there.
-    let rx = Dz, ry = 0, rz = -Dx;
-    {
-        const len = Math.sqrt(rx * rx + ry * ry + rz * rz);
-        rx /= len; ry /= len; rz /= len;
-    }
-    const ux = Dy * rz - Dz * ry;
-    const uy = Dz * rx - Dx * rz;
-    const uz = Dx * ry - Dy * rx;
+function reconstruct_position(out, depth01, frame_u_local, frame_v_local, frame, radius, centre) {
+    const rx = frame[0], ry = frame[1], rz = frame[2];
+    const ux = frame[3], uy = frame[4], uz = frame[5];
+    const Dx = frame[6], Dy = frame[7], Dz = frame[8];
 
     // C = centre + radius * D
     const cx = centre[0] + radius * Dx;
@@ -235,6 +251,9 @@ export function read_atlas_to_samples({ impostor, renderer }) {
     const D_frame = [0, 0, 0];
     const pos_scratch = [0, 0, 0];
     const nrm_scratch = [0, 0, 0];
+    // The bake basis is constant across a whole frame tile, so it is built
+    // once per tile rather than twice per covered pixel.
+    const frame_basis = new Array(BAKE_FRAME_STRIDE).fill(0);
 
     const max_frame_index = frame_count - 1;
     const inv_255 = 1 / 255;
@@ -261,6 +280,8 @@ export function read_atlas_to_samples({ impostor, renderer }) {
 
             encoder.uv_to_unit(D_frame, [frame_u, frame_v]);
 
+            bake_frame_from_direction(frame_basis, D_frame);
+
             // Per-pixel decode within this frame tile.
             const px_end = Math.ceil(frame_size);
             for (let py = 0; py < px_end; py++) {
@@ -286,14 +307,14 @@ export function read_atlas_to_samples({ impostor, renderer }) {
                     const frame_u_local = ((px + 0.5) * inv_frame_size) * 2 - 1;
 
                     const depth01 = geometry_bytes[pixel + 3] * inv_255;
-                    reconstruct_position(pos_scratch, depth01, frame_u_local, frame_v_local, D_frame, radius, centre);
+                    reconstruct_position(pos_scratch, depth01, frame_u_local, frame_v_local, frame_basis, radius, centre);
 
                     decode_normal_to_object_space(
                         nrm_scratch,
                         geometry_bytes[pixel] * inv_255,
                         geometry_bytes[pixel + 1] * inv_255,
                         geometry_bytes[pixel + 2] * inv_255,
-                        D_frame
+                        frame_basis
                     );
 
                     const out_offset = sample_count * ATLAS_SAMPLE_STRIDE;

package/src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderDepthV0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VoxelImpostorShaderDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderDepthV0.js"],"names":[],"mappings":"AA4EA;;;;;;;GAOG;AACH;IACI,cAYC;CACJ;kCAlGoD,OAAO"}
+{"version":3,"file":"VoxelImpostorShaderDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderDepthV0.js"],"names":[],"mappings":"AAiEA;;;;;;;GAOG;AACH;IACI,cAYC;CACJ;kCAvFoD,OAAO"}