@woosh/meep-engine 2.138.17 → 2.138.19

package/src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderDepthV0.js

@@ -0,0 +1,99 @@
+import { GLSL3, NoBlending, RawShaderMaterial } from "three";
+
+
+// Shadow-pass depth material for voxel impostors. World-space-sized
+// camera-facing billboard, same geometry as the colour pass — in the
+// shadow pass `modelViewMatrix = light_view * model`, so the quad
+// expansion (which happens in view space here) lands as a light-facing
+// world-sized splat. The depth at every fragment of the splat equals
+// the splat centre's depth in light space (the corner offset is in
+// view-XY only), so gl_FragCoord.z directly gives the splat's distance
+// from the light.
+//
+// Mirrors three.js's packDepthToRGBA so the PCF shadow sampler can
+// unpack our output; identical encoding to ImpostorShaderDepthV0.
+const shader_vx = `
+    in vec3 position;
+    in vec2 uv;
+    in vec3 iPosition;
+    in vec3 iNormal;
+
+    out vec2 vUv;
+
+    uniform mat4 modelMatrix;
+    uniform mat4 modelViewMatrix;
+    uniform mat4 projectionMatrix;
+    uniform float uPointDiameter;
+
+    void main() {
+        vUv = uv;
+
+        float model_scale = length(modelMatrix[0].xyz);
+        float world_diameter = uPointDiameter * model_scale;
+        float radius_OS = uPointDiameter * 0.5;
+
+        // Inward-shift must match the colour pass exactly so the
+        // cast silhouette agrees with the visible one — see
+        // VoxelImpostorShaderV0 for the rationale.
+        vec3 centre_OS = iPosition - iNormal * radius_OS;
+        vec4 centre_view = modelViewMatrix * vec4(centre_OS, 1.0);
+        vec2 corner = position.xy * world_diameter;
+        gl_Position = projectionMatrix * (centre_view + vec4(corner, 0.0, 0.0));
+    }
+`;
+
+const shader_fg = `
+    precision highp float;
+    precision highp int;
+
+    in vec2 vUv;
+
+    out vec4 color_out;
+
+    uniform bool uDiscMask;
+
+    const float PackUpscale = 256.0 / 255.0;
+    const vec3 PackFactors = vec3(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0);
+    const float ShiftRight8 = 1.0 / 256.0;
+
+    vec4 packDepthToRGBA(const in float v) {
+        vec4 r = vec4(fract(v * PackFactors), v);
+        r.yzw -= r.xyz * ShiftRight8;
+        return r * PackUpscale;
+    }
+
+    void main() {
+        if (uDiscMask) {
+            vec2 c = vUv - 0.5;
+            if (dot(c, c) > 0.25) {
+                discard;
+            }
+        }
+        color_out = packDepthToRGBA(gl_FragCoord.z);
+    }
+`;
+
+
+/**
+ * Depth-pass companion to {@link VoxelImpostorShaderLitV0}. Wire as
+ * ShadedGeometry.depth_material so the impostor casts a shadow whose
+ * silhouette matches the visible splat cloud (modulo the half-splat
+ * normal bias the lit shader applies on the receiver side).
+ *
+ * Keep `uPointDiameter` and `uDiscMask` aligned with the colour pass.
+ */
+export class VoxelImpostorShaderDepthV0 extends RawShaderMaterial {
+    constructor() {
+        super({
+            vertexShader: shader_vx,
+            fragmentShader: shader_fg,
+            glslVersion: GLSL3,
+            uniforms: {
+                uPointDiameter: { value: 0.05 },
+                uDiscMask: { value: false }
+            }
+        });
+
+        this.blending = NoBlending;
+    }
+}

package/src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderLitV0.d.ts

@@ -0,0 +1,19 @@
+/**
+ * PBR-lit voxel impostor material. Each voxel is a world-space-sized
+ * camera-facing billboard; lighting follows the baked per-voxel normal,
+ * not the quad orientation. Casts and receives shadows.
+ *
+ * Pair with {@link ShadedGeometry.from}(geometry, material) — default
+ * DrawMode.Triangles is correct.
+ *
+ * Per-instance attributes: iPosition / iNormal / iAlbedo / iORM (set
+ * up by make_voxel_impostor_geometry). Per-instance uniforms:
+ *   - uPointDiameter: splat diameter in OBJECT space. The shader
+ *     multiplies by the entity's modelMatrix scale at draw time.
+ *   - diffuse / emissive / roughness / metalness — standard PBR knobs.
+ */
+export class VoxelImpostorShaderLitV0 extends ShaderMaterial {
+    constructor();
+}
+import { ShaderMaterial } from "three";
+//# sourceMappingURL=VoxelImpostorShaderLitV0.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VoxelImpostorShaderLitV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderLitV0.js"],"names":[],"mappings":"AA+LA;;;;;;;;;;;;;GAaG;AACH;IACI,cAuBC;CACJ;+BAtOiE,OAAO"}

package/src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderLitV0.js

@@ -0,0 +1,231 @@
+import { Color, ShaderMaterial, UniformsLib, UniformsUtils } from "three";
+
+
+// PBR-lit variant of {@link VoxelImpostorShaderV0}. Each voxel renders
+// as a camera-facing billboard sized in WORLD space; the per-instance
+// baked normal drives the lighting equations and the per-instance ORM
+// modulates roughness / metalness / AO. ShaderMaterial (not Raw) so
+// three.js auto-injects modelMatrix / viewMatrix / normalMatrix /
+// UniformsLib.lights via lights: true.
+//
+// Shadow handling — receiver side:
+//   The vertex shader builds a worldPosition for <shadowmap_vertex>
+//   that uses the splat CENTRE (every quad vertex shares the same
+//   iPosition, so the shadow coord is uniform across the splat — what
+//   you want for a single point sample), shifted along the surface
+//   normal by exactly the splat's world-space radius. That's the
+//   "50% of the quad size" normal-bias trick — at the impostor's
+//   design viewing distance this is sub-pixel (~half a pixel) and so
+//   invisible, while being more than enough to keep the splat from
+//   shadowing itself.
+//
+// Caster side is the paired VoxelImpostorShaderDepthV0.
+//
+// GLSL 1.0 syntax (attribute / varying) so three.js can mix in its
+// chunks; three.js auto-converts to GLSL 3.0 on WebGL2.
+const shader_vx = `
+    #define STANDARD
+
+    attribute vec3 iPosition;
+    attribute vec3 iNormal;
+    attribute vec3 iAlbedo;
+    attribute vec3 iORM;
+
+    flat varying vec3 vAlbedo;
+    flat varying vec3 vNormal_OS;
+    flat varying vec3 vORM;
+    varying vec3 vViewPosition;
+    varying vec2 vUv;
+
+    uniform float uPointDiameter;
+
+    #include <common>
+    #include <fog_pars_vertex>
+    #include <shadowmap_pars_vertex>
+    #include <logdepthbuf_pars_vertex>
+    #include <clipping_planes_pars_vertex>
+
+    void main() {
+        vUv = uv;
+        vAlbedo = iAlbedo;
+        vORM = iORM;
+        vNormal_OS = iNormal;
+
+        // World-sized camera-facing billboard. Same as the unlit V0:
+        // expand the quad in view space (which is rigid w.r.t. world)
+        // by the OS diameter scaled into world units.
+        float model_scale = length(modelMatrix[0].xyz);
+        float world_diameter = uPointDiameter * model_scale;
+        float world_radius   = world_diameter * 0.5;
+        float radius_OS      = uPointDiameter * 0.5;
+
+        // Inward-shift the splat centre so its outer edge sits at
+        // the original surface. iPosition from the voxeliser is the
+        // surface centroid (un-shifted) — see voxelize_samples.js.
+        vec3 centre_OS = iPosition - iNormal * radius_OS;
+
+        vec4 centre_view = modelViewMatrix * vec4(centre_OS, 1.0);
+        vec2 corner = position.xy * world_diameter;
+        vec4 pos_view = centre_view + vec4(corner, 0.0, 0.0);
+
+        vViewPosition = -pos_view.xyz;
+        gl_Position = projectionMatrix * pos_view;
+
+        // Surface normal in view space — drives the lit fragment
+        // pipeline and is consumed by <shadowmap_vertex> to compute a
+        // world-space normal for its bias step.
+        vec3 transformedNormal = normalize(normalMatrix * iNormal);
+
+        // worldPosition for <shadowmap_vertex>:
+        //
+        //   Use the UN-SHIFTED iPosition (= the surface centroid) as
+        //   the base, then add a normal-direction bias of one world
+        //   radius. The chunk adds the per-light shadowNormalBias on
+        //   top.
+        //
+        //   This is the "50% of the quad size" bias the user asked
+        //   for, with a useful symmetry: the visible splat is centred
+        //   at (surface - radius * normal), and its outer edge on the
+        //   normal side sits at the surface — exactly where the
+        //   receiver's shadow coord lands once we add (+radius * normal)
+        //   to the un-shifted surface position. So the shadow lookup
+        //   happens at the splat's own outer-edge depth, which is
+        //   sub-pixel-stable against the caster's depth across
+        //   typical viewing distances. Self-shadow acne goes away.
+        vec3 normal_world = normalize(mat3(modelMatrix) * iNormal);
+        vec3 centre_world = (modelMatrix * vec4(iPosition, 1.0)).xyz;
+        vec4 worldPosition = vec4(centre_world + normal_world * world_radius, 1.0);
+
+        #include <logdepthbuf_vertex>
+        #include <clipping_planes_vertex>
+        #include <shadowmap_vertex>
+        #include <fog_vertex>
+    }
+`;
+const shader_fg = `
+    #define STANDARD
+
+    uniform vec3 diffuse;
+    uniform vec3 emissive;
+    uniform float roughness;
+    uniform float metalness;
+    uniform float opacity;
+
+    flat varying vec3 vAlbedo;
+    flat varying vec3 vNormal_OS;
+    flat varying vec3 vORM;
+    varying vec3 vViewPosition;
+
+    uniform mat3 normalMatrix;
+
+    uniform bool uDiscMask;
+    varying vec2 vUv;  // for disc mask via uv interpolation
+
+    #include <common>
+    #include <packing>
+    #include <dithering_pars_fragment>
+    #include <color_pars_fragment>
+    #include <bsdfs>
+    #include <cube_uv_reflection_fragment>
+    #include <envmap_common_pars_fragment>
+    #include <envmap_physical_pars_fragment>
+    #include <fog_pars_fragment>
+    #include <lights_pars_begin>
+    #include <lights_physical_pars_fragment>
+    #include <shadowmap_pars_fragment>
+    #include <logdepthbuf_pars_fragment>
+    #include <clipping_planes_pars_fragment>
+
+    void main() {
+        #include <clipping_planes_fragment>
+
+        if (uDiscMask) {
+            vec2 c = vUv - 0.5;
+            if (dot(c, c) > 0.25) {
+                discard;
+            }
+        }
+
+        // sRGB -> linear (voxeliser re-encodes the averaged-linear
+        // albedo to sRGB so the on-GPU sample matches the octahedral
+        // atlas's "sRGB bytes labelled linear" format).
+        vec3 albedo_linear = sRGBToLinear(vec4(vAlbedo, 1.0)).rgb;
+
+        vec4 diffuseColor = vec4(albedo_linear * diffuse, 1.0);
+        ReflectedLight reflectedLight = ReflectedLight(vec3(0.0), vec3(0.0), vec3(0.0), vec3(0.0));
+
+        float occlusionFactor  = vORM.r;
+        float roughnessFactor  = roughness * vORM.g;
+        float metalnessFactor  = metalness * vORM.b;
+
+        vec3 totalEmissiveRadiance = emissive;
+
+        vec3 normal = normalize(normalMatrix * vNormal_OS);
+        vec3 geometryNormal = normal;
+
+        #include <logdepthbuf_fragment>
+
+        #include <lights_physical_fragment>
+        #include <lights_fragment_begin>
+        #include <lights_fragment_maps>
+        #include <lights_fragment_end>
+
+        reflectedLight.directDiffuse    *= occlusionFactor;
+        reflectedLight.indirectDiffuse  *= occlusionFactor;
+        reflectedLight.indirectSpecular *= occlusionFactor;
+
+        vec3 totalDiffuse  = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
+        vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
+        vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
+
+        gl_FragColor = vec4(outgoingLight, 1.0);
+
+        #include <tonemapping_fragment>
+        #include <encodings_fragment>
+        #include <fog_fragment>
+        #include <premultiplied_alpha_fragment>
+        #include <dithering_fragment>
+    }
+`;
+
+
+/**
+ * PBR-lit voxel impostor material. Each voxel is a world-space-sized
+ * camera-facing billboard; lighting follows the baked per-voxel normal,
+ * not the quad orientation. Casts and receives shadows.
+ *
+ * Pair with {@link ShadedGeometry.from}(geometry, material) — default
+ * DrawMode.Triangles is correct.
+ *
+ * Per-instance attributes: iPosition / iNormal / iAlbedo / iORM (set
+ * up by make_voxel_impostor_geometry). Per-instance uniforms:
+ *   - uPointDiameter: splat diameter in OBJECT space. The shader
+ *     multiplies by the entity's modelMatrix scale at draw time.
+ *   - diffuse / emissive / roughness / metalness — standard PBR knobs.
+ */
+export class VoxelImpostorShaderLitV0 extends ShaderMaterial {
+    constructor() {
+        const uniforms = UniformsUtils.merge([
+            UniformsLib.common,
+            UniformsLib.fog,
+            UniformsLib.lights,
+            {
+                roughness: { value: 1.0 },
+                metalness: { value: 0.0 },
+                emissive: { value: new Color(0x000000) }
+            },
+            {
+                uPointDiameter: { value: 0.05 },
+                uDiscMask: { value: false }
+            }
+        ]);
+
+        super({
+            uniforms,
+            vertexShader: shader_vx,
+            fragmentShader: shader_fg,
+            lights: true,
+            fog: true
+        });
+    }
+}

package/src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderNormalsV0.d.ts

@@ -0,0 +1,5 @@
+export class VoxelImpostorShaderNormalsV0 extends RawShaderMaterial {
+    constructor();
+}
+import { RawShaderMaterial } from "three";
+//# sourceMappingURL=VoxelImpostorShaderNormalsV0.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VoxelImpostorShaderNormalsV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderNormalsV0.js"],"names":[],"mappings":"AAyDA;IACI,cAUC;CACJ;kCArEwC,OAAO"}

package/src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderNormalsV0.js

@@ -0,0 +1,70 @@
+import { GLSL3, RawShaderMaterial } from "three";
+
+
+// Debug visualisation: shows each voxel's baked OBJECT-space normal as
+// RGB. Same world-space-sized camera-facing quad as the unlit V0.
+const shader_vx = `
+    in vec3 position;
+    in vec2 uv;
+    in vec3 iPosition;
+    in vec3 iNormal;
+
+    out vec2 vUv;
+    flat out vec3 vNormal_OS;
+
+    uniform mat4 modelMatrix;
+    uniform mat4 modelViewMatrix;
+    uniform mat4 projectionMatrix;
+    uniform float uPointDiameter;
+
+    void main() {
+        vUv = uv;
+        vNormal_OS = iNormal;
+
+        float model_scale = length(modelMatrix[0].xyz);
+        float world_diameter = uPointDiameter * model_scale;
+        float radius_OS = uPointDiameter * 0.5;
+
+        // Inward-shift; see VoxelImpostorShaderV0 for rationale.
+        vec3 centre_OS = iPosition - iNormal * radius_OS;
+        vec4 centre_view = modelViewMatrix * vec4(centre_OS, 1.0);
+        vec2 corner = position.xy * world_diameter;
+        gl_Position = projectionMatrix * (centre_view + vec4(corner, 0.0, 0.0));
+    }
+`;
+
+const shader_fg = `
+    precision highp float;
+    precision highp int;
+
+    in vec2 vUv;
+    flat in vec3 vNormal_OS;
+
+    out vec4 color_out;
+
+    uniform bool uDiscMask;
+
+    void main() {
+        if (uDiscMask) {
+            vec2 c = vUv - 0.5;
+            if (dot(c, c) > 0.25) {
+                discard;
+            }
+        }
+        color_out = vec4(vNormal_OS * 0.5 + 0.5, 1.0);
+    }
+`;
+
+export class VoxelImpostorShaderNormalsV0 extends RawShaderMaterial {
+    constructor() {
+        super({
+            vertexShader: shader_vx,
+            fragmentShader: shader_fg,
+            glslVersion: GLSL3,
+            uniforms: {
+                uPointDiameter: { value: 0.05 },
+                uDiscMask: { value: false }
+            }
+        });
+    }
+}

package/src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderV0.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unlit voxel impostor material. Each voxel renders as a camera-facing
+ * billboard sized in world space, so the on-screen footprint scales
+ * naturally with viewing distance.
+ *
+ * Pair with {@link ShadedGeometry.from}(geometry, material) — the
+ * default DrawMode.Triangles is correct, since the splat is a quad.
+ */
+export class VoxelImpostorShaderV0 extends RawShaderMaterial {
+    constructor();
+}
+import { RawShaderMaterial } from "three";
+//# sourceMappingURL=VoxelImpostorShaderV0.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VoxelImpostorShaderV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderV0.js"],"names":[],"mappings":"AA4FA;;;;;;;GAOG;AACH;IACI,cAwBC;CACJ;kCA9HwC,OAAO"}

package/src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderV0.js

@@ -0,0 +1,127 @@
+import { GLSL3, RawShaderMaterial } from "three";
+
+
+// Unlit voxel-impostor shader.
+//
+// Per-instance camera-facing billboard quad, sized in WORLD space. The
+// quad expansion happens in view space — and since the view matrix is
+// rigid (rotation + translation, no scale), distances in view space
+// equal distances in world. So a corner offset of `world_diameter * 0.5`
+// added to the splat centre's view-space position gives the right
+// world-aligned footprint, and perspective projection scales it with
+// distance automatically — close in, the splat covers many pixels;
+// far away, it shrinks below a pixel.
+//
+// uPointDiameter is in OBJECT space (bake space); the shader multiplies
+// by the entity's uniform scale (length(modelMatrix[0])) to bring it
+// into world space at draw time. This decouples the impostor data from
+// the runtime entity scale.
+const shader_vx = `
+    in vec3 position;
+    in vec2 uv;
+
+    in vec3 iPosition;
+    in vec3 iNormal;
+    in vec3 iAlbedo;
+    in vec3 iORM;
+
+    out vec2 vUv;
+    flat out vec3 vNormalView;
+    flat out vec3 vAlbedo;
+    flat out vec3 vORM;
+
+    uniform mat4 modelMatrix;
+    uniform mat4 modelViewMatrix;
+    uniform mat4 projectionMatrix;
+    uniform mat3 normalMatrix;
+    uniform float uPointDiameter;
+
+    void main() {
+        vUv = uv;
+        vAlbedo = iAlbedo;
+        vORM = iORM;
+        vNormalView = normalize(normalMatrix * iNormal);
+
+        float model_scale = length(modelMatrix[0].xyz);
+        float world_diameter = uPointDiameter * model_scale;
+        float radius_OS = uPointDiameter * 0.5;
+
+        // Inward-shift along the surface normal so the splat's OUTER
+        // edge (= centre + radius along normal) lands at the original
+        // surface position (iPosition is the un-shifted surface
+        // centroid the voxeliser produced). Without the shift, a
+        // camera-facing quad of diameter D centred at the surface
+        // extends D/2 past it on silhouette voxels, inflating the
+        // outline. With the shift, silhouette voxels render edge-on
+        // exactly at the mesh outline; inside voxels are pushed
+        // slightly below the surface (sub-pixel at design distance).
+        vec3 centre_OS = iPosition - iNormal * radius_OS;
+
+        vec4 centre_view = modelViewMatrix * vec4(centre_OS, 1.0);
+        vec2 corner = position.xy * world_diameter;
+        vec4 pos_view = centre_view + vec4(corner, 0.0, 0.0);
+
+        gl_Position = projectionMatrix * pos_view;
+    }
+`;
+
+const shader_fg = `
+    precision highp float;
+    precision highp int;
+
+    in vec2 vUv;
+    flat in vec3 vNormalView;
+    flat in vec3 vAlbedo;
+    flat in vec3 vORM;
+
+    out vec4 color_out;
+
+    uniform bool uDiscMask;
+
+    void main() {
+        if (uDiscMask) {
+            vec2 c = vUv - 0.5;
+            if (dot(c, c) > 0.25) {
+                discard;
+            }
+        }
+        color_out = vec4(vAlbedo, 1.0);
+    }
+`;
+
+
+/**
+ * Unlit voxel impostor material. Each voxel renders as a camera-facing
+ * billboard sized in world space, so the on-screen footprint scales
+ * naturally with viewing distance.
+ *
+ * Pair with {@link ShadedGeometry.from}(geometry, material) — the
+ * default DrawMode.Triangles is correct, since the splat is a quad.
+ */
+export class VoxelImpostorShaderV0 extends RawShaderMaterial {
+    constructor() {
+        super({
+            vertexShader: shader_vx,
+            fragmentShader: shader_fg,
+            glslVersion: GLSL3,
+            uniforms: {
+                /**
+                 * World-space diameter of each splat, in OBJECT-space
+                 * units. Multiplied by the entity's modelMatrix scale
+                 * at draw time. For tight coverage set to the voxel
+                 * cell size (see VoxelImpostorDescription.voxel_size).
+                 */
+                uPointDiameter: {
+                    value: 0.05
+                },
+                /**
+                 * If true, discards fragments outside the inscribed
+                 * disc — turns square splats into round ones.
+                 */
+                uDiscMask: {
+                    value: false
+                }
+            }
+        });
+    }
+}

package/src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderViewportDepthV0.d.ts

@@ -0,0 +1,5 @@
+export class VoxelImpostorShaderViewportDepthV0 extends RawShaderMaterial {
+    constructor();
+}
+import { RawShaderMaterial } from "three";
+//# sourceMappingURL=VoxelImpostorShaderViewportDepthV0.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VoxelImpostorShaderViewportDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderViewportDepthV0.js"],"names":[],"mappings":"AAuDA;IACI,cAUC;CACJ;kCAnEwC,OAAO"}

package/src/engine/graphics/impostors/voxel/shader/VoxelImpostorShaderViewportDepthV0.js

@@ -0,0 +1,68 @@
+import { GLSL3, RawShaderMaterial } from "three";
+
+
+// Debug visualisation: viewport depth of each voxel as grayscale.
+// Same world-space-sized camera-facing quad as the other shaders.
+const shader_vx = `
+    in vec3 position;
+    in vec2 uv;
+    in vec3 iPosition;
+    in vec3 iNormal;
+
+    out vec2 vUv;
+
+    uniform mat4 modelMatrix;
+    uniform mat4 modelViewMatrix;
+    uniform mat4 projectionMatrix;
+    uniform float uPointDiameter;
+
+    void main() {
+        vUv = uv;
+
+        float model_scale = length(modelMatrix[0].xyz);
+        float world_diameter = uPointDiameter * model_scale;
+        float radius_OS = uPointDiameter * 0.5;
+
+        // Inward-shift; see VoxelImpostorShaderV0 for rationale.
+        vec3 centre_OS = iPosition - iNormal * radius_OS;
+        vec4 centre_view = modelViewMatrix * vec4(centre_OS, 1.0);
+        vec2 corner = position.xy * world_diameter;
+        gl_Position = projectionMatrix * (centre_view + vec4(corner, 0.0, 0.0));
+    }
+`;
+
+const shader_fg = `
+    precision highp float;
+    precision highp int;
+
+    in vec2 vUv;
+
+    out vec4 color_out;
+
+    uniform bool uDiscMask;
+
+    void main() {
+        if (uDiscMask) {
+            vec2 c = vUv - 0.5;
+            if (dot(c, c) > 0.25) {
+                discard;
+            }
+        }
+        float d = 1.0 - gl_FragCoord.z;
+        color_out = vec4(d, d, d, 1.0);
+    }
+`;
+
+export class VoxelImpostorShaderViewportDepthV0 extends RawShaderMaterial {
+    constructor() {
+        super({
+            vertexShader: shader_vx,
+            fragmentShader: shader_fg,
+            glslVersion: GLSL3,
+            uniforms: {
+                uPointDiameter: { value: 0.05 },
+                uDiscMask: { value: false }
+            }
+        });
+    }
+}

package/src/engine/graphics/impostors/voxel/util/make_voxel_impostor_geometry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * InstancedBufferGeometry with one instance per voxel. Each instance is
+ * a unit quad whose vertex shader pushes the quad to a world-space
+ * footprint around the voxel's iPosition. Because the splat's size is
+ * specified in world units, it scales correctly with viewing distance:
+ *
+ *   - At the impostor's design distance (where one voxel projects to
+ *     about one screen pixel), the quad covers a single pixel.
+ *   - Closer in, the quad expands to cover the same voxel cell on
+ *     screen — no holes.
+ *   - Farther out, the quad shrinks below a pixel — no z-fighting.
+ *
+ * This is the camera-facing-billboard reading of the Witcher 4 "voxel
+ * point" — the on-screen size of each voxel is whatever its world-space
+ * cell projects to, not a fixed screen size. Shadows work for free
+ * because the depth caster, rendered with the same shader from the
+ * light's view, also produces world-sized splats in light space.
+ *
+ * The interleaved point buffer is shared across iPosition / iNormal /
+ * iAlbedo / iORM via offsets — one GPU upload covers the lot.
+ *
+ * @param {VoxelImpostorDescription} description
+ * @returns {InstancedBufferGeometry}
+ */
+export function make_voxel_impostor_geometry(description: VoxelImpostorDescription): InstancedBufferGeometry;
+import { InstancedBufferGeometry } from "three";
+//# sourceMappingURL=make_voxel_impostor_geometry.d.ts.map