@woosh/meep-engine 2.138.13 → 2.138.16

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

@@ -22,7 +22,12 @@ import { ShadedGeometryFlags } from "../../ecs/mesh-v2/ShadedGeometryFlags.js";
 import { ShadedGeometrySystem } from "../../ecs/mesh-v2/ShadedGeometrySystem.js";
 import { ImpostorBaker } from "./ImpostorBaker.js";
 import { ImpostorCaptureType } from "./ImpostorCaptureType.js";
+import { ImpostorShaderDepthV0 } from "./shader/ImpostorShaderDepthV0.js";
+import { ImpostorShaderLitV0 } from "./shader/ImpostorShaderLitV0.js";
+import { ImpostorShaderNormalsV0 } from "./shader/ImpostorShaderNormalsV0.js";
+import { ImpostorShaderPerPixelV0 } from "./shader/ImpostorShaderPerPixelV0.js";
 import { ImpostorShaderV0 } from "./shader/ImpostorShaderV0.js";
+import { ImpostorShaderViewportDepthV0 } from "./shader/ImpostorShaderViewportDepthV0.js";
 import { ImpostorShaderWireframeV0 } from "./shader/ImpostorShaderWireframeV0.js";
 import { build_geometry_from_cutout_shape } from "./util/build_geometry_from_cutout_shape.js";
 import { load_mesh_for_bake } from "./util/load_mesh_for_bake.js";
@@ -42,6 +47,13 @@ async function main(engine) {
         enableLights: true,
         enableShadows: true,
         cameraAutoClip: true,
+        // Default terrain is 20x20 (size 10 * gridScale 2). The impostor
+        // lineup below stretches x=10..25, so widen the plane to fit
+        // everything plus a small margin on each side.
+        terrainSize: new Vector2(18, 12),
+        // Recentre the camera focus on the lineup's midpoint so the
+        // wider terrain is framed correctly rather than slid off-screen.
+        focus: new Vector3(17, 0, 10),
     });
 
 
@@ -73,7 +85,7 @@ async function main(engine) {
     const id = baker.bake({
         objects,
         frames: 32,
-        resolution: 1024,
+        resolution: 1024*8,
         type: ImpostorCaptureType.FullSphere
     });
     // console.profileEnd('bake');
@@ -95,7 +107,12 @@ async function main(engine) {
         .add(GUIElement.fromView(ctrl))
         // .build(ecd);
 
-    // build out preview scene with impostor and the original
+    // build out preview scene: lay out the five variants side-by-side
+    // (V0 / per-pixel V0 / lit / world-normal viz / true mesh) so they
+    // share the same scene lighting and the differences are easy to
+    // compare. The normals viz sits next to lit because it shows exactly
+    // what the lit shader is feeding to the lighting equations — handy
+    // for diagnosing wrong-looking shading.
     const t0 = Transform.fromJSON({
         position: { x: 10, y: 0.5, z: 10 },
         scale: 3,
@@ -104,15 +121,45 @@ async function main(engine) {
 
     t0.scale.setScalar(3 / (id.sphere_radius * 2));
 
+    // Slot 0: original V0 + its wireframe overlay.
     const entity_impostor = make_impostor_entity(id, t0);
     entity_impostor.build(ecd);
 
     const entity_impostor_wireframe = make_impostor_wireframe(id, t0);
     entity_impostor_wireframe.build(ecd);
 
-    const t1 = new Transform();
-    t1.copy(t0);
-    t1.position._add(3, 0, 0);
+    // Slot 1: per-pixel projection variant (visually identical to V0).
+    const t_per_pixel = new Transform();
+    t_per_pixel.copy(t0);
+    t_per_pixel.position._add(3, 0, 0);
+    make_impostor_per_pixel_entity(id, t_per_pixel).build(ecd);
+
+    // Slot 2: lit variant — only one that responds to scene lights and
+    // receives shadows from neighbours.
+    const t_lit = new Transform();
+    t_lit.copy(t0);
+    t_lit.position._add(6, 0, 0);
+    make_impostor_lit_entity(id, t_lit).build(ecd);
+
+    // Slot 3: world-space normal viz (debug pair for the lit variant).
+    const t_normals = new Transform();
+    t_normals.copy(t0);
+    t_normals.position._add(9, 0, 0);
+    make_impostor_normals_entity(id, t_normals).build(ecd);
+
+    // Slot 4: viewport-depth viz — shows the parallax surface's
+    // gl_FragCoord.z-equivalent as grayscale. Same construction the
+    // caster's gl_FragDepth uses; useful for spotting where the lit
+    // shader's shadow coord diverges from what the shadow map holds.
+    const t_depth = new Transform();
+    t_depth.copy(t0);
+    t_depth.position._add(12, 0, 0);
+    make_impostor_viewport_depth_entity(id, t_depth).build(ecd);
+
+    // Slot 5: original mesh as ground-truth reference.
+    const t_truth = new Transform();
+    t_truth.copy(t0);
+    t_truth.position._add(15, 0, 0);
 
     const sg_mesh = SGMesh.fromURL(path);
 
@@ -122,7 +169,7 @@ async function main(engine) {
     const entity_true_mesh = new Entity();
     entity_true_mesh
         .add(sg_mesh)
-        .add(t1)
+        .add(t_truth)
         .build(ecd);
 
 
@@ -153,7 +200,7 @@ function make_spin(entity, speed = 1, axis = Vector3.up) {
 
 /**
  *
- * @param {{tBase,tGeometry,uFrames,uOffset,uRadius,uIsFullSphere}} uniforms
+ * @param {{tBase,tGeometry,uFrames,uOffset,uRadius,uIsFullSphere,tMaterial?}} uniforms
  * @param {ImpostorDescription} id
  */
 function write_impostor_definition_to_material_uniforms(uniforms, id) {
@@ -164,6 +211,12 @@ function write_impostor_definition_to_material_uniforms(uniforms, id) {
     uniforms.uOffset.value.set(id.offset[0], id.offset[1], id.offset[2]);
     uniforms.uRadius.value = id.sphere_radius;
     uniforms.uIsFullSphere.value = id.capture_type === ImpostorCaptureType.FullSphere;
+
+    // ORM texture is only consumed by the lit shader; older variants
+    // declare the uniform but never read it, so the assignment is harmless.
+    if (uniforms.tMaterial !== undefined) {
+        uniforms.tMaterial.value = id.rt.texture[2];
+    }
 }
 
 function make_impostor_wireframe(id, t = new Transform()) {
@@ -188,6 +241,19 @@ function make_impostor_wireframe(id, t = new Transform()) {
         ;
 }
 
+/**
+ * Build a `depth_material` instance for shadow casting that mirrors the
+ * card geometry of whichever colour material we're using. Pulling this
+ * out keeps the per-variant factories below short.
+ *
+ * @param {ImpostorDescription} id
+ */
+function make_impostor_depth_material(id) {
+    const depth_mat = new ImpostorShaderDepthV0();
+    write_impostor_definition_to_material_uniforms(depth_mat.uniforms, id);
+    return depth_mat;
+}
+
 /**
  *
  * @param {ImpostorDescription} id
@@ -206,7 +272,104 @@ function make_impostor_entity(id, t = new Transform()) {
 
     const sg = ShadedGeometry.from(build_geometry_from_cutout_shape(id.cutout), mat);
 
-    sg.depth_material = mat;
+    // V0 is unlit so it has no shadow to receive; it can still CAST a
+    // shadow using ImpostorShaderDepthV0, which traces the same parallax
+    // surface so the silhouette matches.
+    sg.depth_material = make_impostor_depth_material(id);
+    sg.clearFlag(ShadedGeometryFlags.ReceiveShadow);
+
+    return new Entity()
+        .add(transform)
+        .add(sg)
+        ;
+
+}
+
+/**
+ * Same as {@link make_impostor_entity} but with the per-pixel projection
+ * variant. Visually identical at the same camera distance — the difference
+ * is purely where the projection math runs on the GPU.
+ *
+ * @param {ImpostorDescription} id
+ * @param {Transform} t
+ * @returns {Entity}
+ */
+function make_impostor_per_pixel_entity(id, t = new Transform()) {
+
+    const mat = new ImpostorShaderPerPixelV0();
+
+    write_impostor_definition_to_material_uniforms(mat.uniforms, id);
+
+    const transform = new Transform();
+    transform.copy(t);
+
+    const sg = ShadedGeometry.from(build_geometry_from_cutout_shape(id.cutout), mat);
+
+    sg.depth_material = make_impostor_depth_material(id);
+    sg.clearFlag(ShadedGeometryFlags.ReceiveShadow);
+
+    return new Entity()
+        .add(transform)
+        .add(sg)
+        ;
+}
+
+/**
+ * Debug viz: shows the world-space surface normal at each impostor pixel
+ * as RGB. Same parallax + atlas-decode math as the lit shader, so any
+ * weirdness here is also producing the lit shader's lighting.
+ *
+ * @param {ImpostorDescription} id
+ * @param {Transform} t
+ * @returns {Entity}
+ */
+function make_impostor_normals_entity(id, t = new Transform()) {
+
+    const mat = new ImpostorShaderNormalsV0();
+
+    write_impostor_definition_to_material_uniforms(mat.uniforms, id);
+
+    const transform = new Transform();
+    transform.copy(t);
+
+    const sg = ShadedGeometry.from(build_geometry_from_cutout_shape(id.cutout), mat);
+
+    // Viz pass: don't participate in shadow casting/receiving — otherwise
+    // it'd influence its lit neighbour's shadow and confuse the comparison.
+    sg.depth_material = make_impostor_depth_material(id);
+    sg.clearFlag(ShadedGeometryFlags.CastShadow);
+    sg.clearFlag(ShadedGeometryFlags.ReceiveShadow);
+
+    return new Entity()
+        .add(transform)
+        .add(sg)
+        ;
+}
+
+/**
+ * Debug viz: shows the parallax-corrected surface's VIEWPORT depth as
+ * grayscale (closer = brighter). Same surface-position math as the lit
+ * shader's shadow coord and the depth material's gl_FragDepth write, so
+ * if shadows look wrong this slot is the most direct check.
+ *
+ * @param {ImpostorDescription} id
+ * @param {Transform} t
+ * @returns {Entity}
+ */
+function make_impostor_viewport_depth_entity(id, t = new Transform()) {
+
+    const mat = new ImpostorShaderViewportDepthV0();
+
+    write_impostor_definition_to_material_uniforms(mat.uniforms, id);
+
+    const transform = new Transform();
+    transform.copy(t);
+
+    const sg = ShadedGeometry.from(build_geometry_from_cutout_shape(id.cutout), mat);
+
+    // Same as normals viz — opt out of shadow casting/receiving so it
+    // doesn't influence what its neighbours see.
+    sg.depth_material = make_impostor_depth_material(id);
     sg.clearFlag(ShadedGeometryFlags.CastShadow);
     sg.clearFlag(ShadedGeometryFlags.ReceiveShadow);
 
@@ -214,7 +377,38 @@ function make_impostor_entity(id, t = new Transform()) {
         .add(transform)
         .add(sg)
         ;
+}
+
+/**
+ * Lit impostor — applies three.js's STANDARD lighting model and receives
+ * shadow maps in addition to casting them.
+ *
+ * @param {ImpostorDescription} id
+ * @param {Transform} t
+ * @returns {Entity}
+ */
+function make_impostor_lit_entity(id, t = new Transform()) {
+
+    const mat = new ImpostorShaderLitV0();
 
+    write_impostor_definition_to_material_uniforms(mat.uniforms, id);
+
+    const transform = new Transform();
+    transform.copy(t);
+
+    const sg = ShadedGeometry.from(build_geometry_from_cutout_shape(id.cutout), mat);
+
+    sg.depth_material = make_impostor_depth_material(id);
+    // CastShadow + ReceiveShadow on by default. Self-cast works because
+    // both sides (caster via gl_FragDepth, receiver via per-fragment
+    // customShadowCoord computed from the same atlas-derived parallax
+    // surface) agree on where the impostor's surface actually is in
+    // world space.
+
+    return new Entity()
+        .add(transform)
+        .add(sg)
+        ;
 }
 
 new EngineHarness().initialize({

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Depth-pass companion to ImpostorShaderV0. Use this as
+ * ShadedGeometry.depth_material so the impostor casts a shadow whose
+ * silhouette matches the visible card.
+ */
+export class ImpostorShaderDepthV0 extends RawShaderMaterial {
+    constructor();
+}
+import { RawShaderMaterial } from "three";
+//# sourceMappingURL=ImpostorShaderDepthV0.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImpostorShaderDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.js"],"names":[],"mappings":"AAsXA;;;;GAIG;AACH;IACI,cAoCC;CACJ;kCA5ZM,OAAO"}