@woosh/meep-engine 2.138.13 → 2.138.15

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

@@ -0,0 +1,356 @@
+import {
+    GLSL3,
+    NoBlending,
+    RawShaderMaterial,
+    Vector3
+} from "three";
+
+// Debug-viz variant: shows the parallax-corrected surface's VIEWPORT
+// depth as grayscale. This is the same value ImpostorShaderDepthV0
+// writes to gl_FragDepth in the shadow pass (just using the main camera
+// instead of the shadow camera), so side-by-side with the lit impostor
+// it answers "is the receiver agreeing with the caster on where this
+// pixel actually is?"
+//
+// Output mapping: gl_FragCoord.z range is [0, 1] (0 = near plane,
+// 1 = far plane). We invert so closer surfaces appear brighter, which
+// reads more intuitively against a typical scene background.
+//
+// Same uniforms / card geometry as ImpostorShaderV0.
+const shader_vx = `
+
+    in vec2 uv;
+    in vec3 position;
+
+    out vec2 vUv;
+    out vec3 vViewPos;
+
+    out vec3 vCardPos_OS;
+    flat out vec3 vCardNormal_OS;
+
+    flat out vec2 vGridFloor;
+    flat out vec4 vWeights;
+
+    flat out vec3 vTangent;
+    flat out vec3 vBinormal;
+    flat out vec3 vNormal;
+
+    flat out vec4 vFrameXform00;
+    flat out vec4 vFrameXform10;
+    flat out vec4 vFrameXform01;
+    flat out vec4 vFrameXform11;
+
+    uniform mat4 modelViewMatrix;
+    uniform mat4 projectionMatrix;
+
+    uniform vec3 uOffset;
+    uniform float uRadius;
+    uniform float uFrames;
+    uniform bool uIsFullSphere;
+
+    vec2 VecToSphereOct(vec3 pivotToCamera)
+    {
+        vec3 octant = sign(pivotToCamera);
+        float sum = dot(pivotToCamera, octant);
+        vec3 octahedron = pivotToCamera / sum;
+        if (octahedron.y < 0.0) {
+            vec3 absolute = abs(octahedron);
+            octahedron.xz = octant.xz * vec2(1.0 - absolute.z, 1.0 - absolute.x);
+        }
+        return octahedron.xz;
+    }
+
+    vec2 VecToHemiSphereOct(vec3 v)
+    {
+        v.y = max(v.y, 0.001);
+        v = normalize(v);
+        vec3 octant = sign(v);
+        float sum = dot(v, octant);
+        vec3 octahedron = v / sum;
+        return vec2(
+            octahedron.x + octahedron.z,
+            octahedron.z - octahedron.x
+        );
+    }
+
+    vec2 VectorToGrid(vec3 v)
+    {
+        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
+        );
+    }
+
+    void main() {
+        vUv = uv;
+
+        vec3 cameraPos_OS = (inverse(modelViewMatrix) * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
+        // Atlas lookup must be relative to the bounding-sphere centre
+        // (uOffset), since the bake's D_frame is measured from the centre,
+        // not from the object origin.
+        vec3 pivotToCameraRay = normalize(cameraPos_OS - uOffset);
+
+        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 = min(floor(grid), framesMinusOne - 1.0);
+        vec4 weights = BilinearWeights(grid - gridFloor);
+
+        vGridFloor = gridFloor;
+        vWeights = weights;
+
+        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(
+            ray00 * weights.x +
+            ray10 * weights.y +
+            ray01 * weights.z +
+            ray11 * weights.w
+        );
+
+        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);
+
+        float card_diameter = uRadius * 2.0;
+        vec3 pos_OS = uOffset
+                    + position.x * card_diameter * tangent_OS
+                    + position.y * card_diameter * binormal_OS;
+
+        vCardPos_OS    = pos_OS;
+        vCardNormal_OS = normal_OS;
+
+        vec4 mvPosition = modelViewMatrix * vec4(pos_OS, 1.0);
+        vViewPos = mvPosition.xyz;
+        gl_Position = projectionMatrix * mvPosition;
+
+        mat3 m3 = mat3(modelViewMatrix);
+        vTangent  = normalize(m3 * tangent_OS);
+        vBinormal = normalize(m3 * binormal_OS);
+        vNormal   = normalize(m3 * normal_OS);
+
+        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 = `
+    precision highp float;
+    precision highp int;
+
+    in vec2 vUv;
+    in vec3 vViewPos;
+
+    in vec3 vCardPos_OS;
+    flat in vec3 vCardNormal_OS;
+
+    flat in vec2 vGridFloor;
+    flat in vec4 vWeights;
+
+    flat in vec3 vTangent;
+    flat in vec3 vBinormal;
+    flat in vec3 vNormal;
+
+    flat in vec4 vFrameXform00;
+    flat in vec4 vFrameXform10;
+    flat in vec4 vFrameXform01;
+    flat in vec4 vFrameXform11;
+
+    out vec4 color_out;
+
+    uniform mat4 modelViewMatrix;
+    uniform mat4 projectionMatrix;
+
+    uniform sampler2D tBase;
+    uniform sampler2D tGeometry;
+    uniform float uFrames;
+    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;
+    }
+
+    void main() {
+        // Parallax shift in CAMERA tangent space — this is the visible
+        // pass, so the depth we visualise is the depth the camera would
+        // see through this card pixel, not the depth from the light.
+        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)
+        );
+
+        vec2 frame_size = vec2(1.0 / uFrames);
+        vec2 base_uv = vUv;
+
+        vec2 uv00 = clamp(apply_frame_xform(base_uv, vFrameXform00), 0.0, 1.0);
+        vec2 uv10 = clamp(apply_frame_xform(base_uv, vFrameXform10), 0.0, 1.0);
+        vec2 uv01 = clamp(apply_frame_xform(base_uv, vFrameXform01), 0.0, 1.0);
+        vec2 uv11 = clamp(apply_frame_xform(base_uv, vFrameXform11), 0.0, 1.0);
+
+        vec2 atlas_uv00 = (vGridFloor + vec2(0.0, 0.0) + uv00) * frame_size;
+        vec2 atlas_uv10 = (vGridFloor + vec2(1.0, 0.0) + uv10) * frame_size;
+        vec2 atlas_uv01 = (vGridFloor + vec2(0.0, 1.0) + uv01) * frame_size;
+        vec2 atlas_uv11 = (vGridFloor + vec2(1.0, 1.0) + uv11) * frame_size;
+
+        // Pass 1: depth at un-shifted UV (drives the parallax shift).
+        float d00 = texture(tGeometry, atlas_uv00).a;
+        float d10 = texture(tGeometry, atlas_uv10).a;
+        float d01 = texture(tGeometry, atlas_uv01).a;
+        float d11 = texture(tGeometry, atlas_uv11).a;
+        float blended_depth =
+            d00 * vWeights.x + d10 * vWeights.y +
+            d01 * vWeights.z + d11 * vWeights.w;
+
+        base_uv += (view_dir.xy / view_dir.z) * (blended_depth - 0.5) * uDepthScale;
+        base_uv = clamp(base_uv, 0.0, 1.0);
+
+        // Pass 2: re-sample at parallax-shifted UV. Alpha-discard on the
+        // colour atlas so the viz silhouette matches V0 / lit exactly.
+        uv00 = clamp(apply_frame_xform(base_uv, vFrameXform00), 0.0, 1.0);
+        uv10 = clamp(apply_frame_xform(base_uv, vFrameXform10), 0.0, 1.0);
+        uv01 = clamp(apply_frame_xform(base_uv, vFrameXform01), 0.0, 1.0);
+        uv11 = clamp(apply_frame_xform(base_uv, vFrameXform11), 0.0, 1.0);
+
+        atlas_uv00 = (vGridFloor + vec2(0.0, 0.0) + uv00) * frame_size;
+        atlas_uv10 = (vGridFloor + vec2(1.0, 0.0) + uv10) * frame_size;
+        atlas_uv01 = (vGridFloor + vec2(0.0, 1.0) + uv01) * frame_size;
+        atlas_uv11 = (vGridFloor + vec2(1.0, 1.0) + uv11) * frame_size;
+
+        vec4 b00 = texture(tBase, atlas_uv00);
+        vec4 b10 = texture(tBase, atlas_uv10);
+        vec4 b01 = texture(tBase, atlas_uv01);
+        vec4 b11 = texture(tBase, atlas_uv11);
+        vec4 albedo =
+            b00 * vWeights.x + b10 * vWeights.y +
+            b01 * vWeights.z + b11 * vWeights.w;
+
+        if (albedo.a <= 0.5) {
+            discard;
+        }
+
+        // Re-sample geometry at the shifted UV for the surface depth.
+        // Same convention as the bake: depth=1 at +radius along the card
+        // normal (closer to the bake/camera), 0.5 at the card plane,
+        // 0 at -radius.
+        float g00a = texture(tGeometry, atlas_uv00).a;
+        float g10a = texture(tGeometry, atlas_uv10).a;
+        float g01a = texture(tGeometry, atlas_uv01).a;
+        float g11a = texture(tGeometry, atlas_uv11).a;
+        float surface_depth =
+            g00a * vWeights.x + g10a * vWeights.y +
+            g01a * vWeights.z + g11a * vWeights.w;
+
+        float height_OS = (surface_depth - 0.5) * 2.0 * uRadius;
+        vec3 surface_OS_pos = vCardPos_OS + height_OS * vCardNormal_OS;
+
+        // Project surface through the main camera's MVP exactly like the
+        // depth material does (just with the runtime camera's matrices
+        // instead of the shadow camera's).
+        vec4 surface_clip = projectionMatrix * modelViewMatrix * vec4(surface_OS_pos, 1.0);
+        float surface_ndc_z = surface_clip.z / surface_clip.w;
+        float viewport_depth = clamp(surface_ndc_z * 0.5 + 0.5, 0.0, 1.0);
+
+        // Invert so closer = brighter. Closer surfaces have small
+        // viewport_depth; 1.0 - depth puts them near white.
+        color_out = vec4(vec3(1.0 - viewport_depth), 1.0);
+    }
+`;
+
+/**
+ * Debug viz: outputs the parallax-corrected surface's viewport depth
+ * (gl_FragCoord.z-equivalent) as grayscale. Same parallax + atlas-decode
+ * math as ImpostorShaderLitV0 and ImpostorShaderDepthV0, so anything
+ * that looks off here is also driving the lit shader's shadow coord
+ * and the caster's gl_FragDepth.
+ *
+ * Same uniforms as ImpostorShaderV0.
+ */
+export class ImpostorShaderViewportDepthV0 extends RawShaderMaterial {
+    constructor() {
+        super({
+            fragmentShader: shader_fg,
+            vertexShader: shader_vx,
+            uniforms: {
+                tBase: { value: null },
+                tGeometry: { value: null },
+                tMaterial: { value: null },
+                uFrames: { value: 0 },
+                uRadius: { value: 0 },
+                uOffset: { value: new Vector3(0, 0, 0) },
+                uIsFullSphere: { value: false },
+                uDepthScale: { value: 0.5 }
+            },
+            glslVersion: GLSL3
+        });
+
+        this.blending = NoBlending;
+    }
+}

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":"AA6JA;IACI,cA2DC;IAHG,4CAAyB;CAIhC;kCAlNM,OAAO"}
+{"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"}

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

@@ -105,7 +105,10 @@ const shader_vx = `
     void main() {
         // Pivot-to-camera direction in object-local space; same as V0.
         vec3 cameraPos_OS = (inverse(modelViewMatrix) * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
-        vec3 pivotToCameraRay = normalize(cameraPos_OS);
+        // Atlas lookup must be relative to the bounding-sphere centre
+        // (uOffset), since the bake's D_frame is measured from the centre,
+        // not from the object origin. Mirrors V0.
+        vec3 pivotToCameraRay = normalize(cameraPos_OS - uOffset);
 
         // Pick the cell and its 4-corner bilinear weights, then blend the
         // four corner rays into the "effective" bake direction the card is