@woosh/meep-engine 2.165.4 → 2.165.6

package/src/engine/graphics/trail/tube/TubeMaterialX.js

@@ -1,12 +1,25 @@
-import { DoubleSide, NormalBlending, ShaderMaterial } from "three";
+import { DoubleSide, NormalBlending, ShaderMaterial, UniformsLib, UniformsUtils } from "three";
 
 const TWO_PI = "6.283185307179586";
 
 /**
- * Unlit tube material. Vertices arrive as ring CENTRES; the actual surface vertex
+ * Tube material. Vertices arrive as ring CENTRES; the actual surface vertex
  * is extruded here in WORLD space from the per-knot tangent frame (tn, tb) and the
  * vertex's angular position `tubeUv.x`. The mesh transform is identity (centres are
  * already world space, written CPU-side), so modelViewMatrix == viewMatrix.
+ *
+ * Unlit by default. The LIT define switches the fragment stage onto the standard
+ * three.js light chain instead — specular is forced to zero, so the tube shades as
+ * a matte (Lambert) surface under ambient / hemisphere / light-probe / directional /
+ * point / spot lights, and receives shadows (it never casts them). The surface
+ * normal is the ring's radial direction; the per-knot thickness taper's tilt is
+ * ignored.
+ *
+ * The lit variant deliberately follows the three.js chunk conventions —
+ * `void main() {`, `transformed`, `#include <worldpos_vertex>`,
+ * `#include <lights_pars_begin>`, `#include <lights_fragment_begin>` — because the
+ * Forward+ {@link MaterialTransformer} keys its textual injections on exactly these
+ * markers to add clustered point-light accumulation and decals.
  */
 const vertexShader = `
     varying vec2 vUv;
@@ -19,18 +32,44 @@ const vertexShader = `
     attribute float thickness;
     attribute vec3 color;
 
-    void main(){
+    #ifdef LIT
+
+        varying vec3 vNormal;
+        varying vec3 vViewPosition;
+
+        #include <common>
+        #include <shadowmap_pars_vertex>
+
+    #endif
+
+    void main() {
         float angle = tubeUv.x * ${TWO_PI};
 
         // radial direction in the knot's frame; unit, perpendicular to the tangent
         vec3 radial = cos(angle) * tn + sin(angle) * tb;
 
-        vec3 surface = position + radial * (thickness * 0.5);
+        // extruded surface vertex, named per three.js chunk convention
+        vec3 transformed = position + radial * (thickness * 0.5);
 
         vUv = tubeUv;
         vColor = vec4(color / 255.0, alpha);
 
-        gl_Position = projectionMatrix * modelViewMatrix * vec4(surface, 1.0);
+        vec4 mvPosition = modelViewMatrix * vec4(transformed, 1.0);
+
+        #ifdef LIT
+
+            // the tube's surface normal is the radial direction itself
+            vec3 transformedNormal = normalMatrix * radial;
+
+            vNormal = transformedNormal;
+            vViewPosition = -mvPosition.xyz;
+
+            #include <worldpos_vertex>
+            #include <shadowmap_vertex>
+
+        #endif
+
+        gl_Position = projectionMatrix * mvPosition;
     }
 `;
 
@@ -40,7 +79,21 @@ const fragmentShader = `
 
     uniform sampler2D uDiffuse;
 
-    void main(){
+    #ifdef LIT
+
+        // vViewPosition is declared by <lights_phong_pars_fragment>
+        varying vec3 vNormal;
+
+        #include <common>
+        #include <packing>
+        #include <bsdfs>
+        #include <lights_pars_begin>
+        #include <lights_phong_pars_fragment>
+        #include <shadowmap_pars_fragment>
+
+    #endif
+
+    void main() {
         vec4 diffuseColor = vColor;
 
         #ifdef USE_TEXTURE
@@ -48,24 +101,67 @@ const fragmentShader = `
             diffuseColor *= texel;
         #endif
 
-        gl_FragColor = diffuseColor;
+        #ifdef LIT
+
+            ReflectedLight reflectedLight = ReflectedLight(vec3(0.0), vec3(0.0), vec3(0.0), vec3(0.0));
+
+            #include <normal_fragment_begin>
+
+            // Blinn-Phong with specular forced to zero = pure Lambert; a trail is a
+            // matte surface, highlights on a fading tube read as artifacts
+            BlinnPhongMaterial material;
+            material.diffuseColor = diffuseColor.rgb;
+            material.specularColor = vec3(0.0);
+            material.specularShininess = 1.0;
+            material.specularStrength = 0.0;
+
+            #include <lights_fragment_begin>
+            #include <lights_fragment_end>
+
+            vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
+
+            gl_FragColor = vec4(outgoingLight, diffuseColor.a);
+
+            #include <tonemapping_fragment>
+            #include <encodings_fragment>
+
+        #else
+
+            gl_FragColor = diffuseColor;
+
+        #endif
     }
 `;
 
 export class TubeMaterialX extends ShaderMaterial {
-    constructor(params) {
+    /**
+     * @param {Object} params three.js material parameters, plus:
+     * @param {boolean} [params.lit=false] compile the lit variant — standard light
+     *     chain, receive-only shadows — instead of the unlit one
+     */
+    constructor({ lit = false, ...params } = {}) {
         super({
             fragmentShader,
             vertexShader,
-            uniforms: {
-                uDiffuse: {
-                    type: 't',
-                    value: null
-                }
-            },
+            uniforms: lit
+                ? UniformsUtils.merge([
+                    UniformsLib.lights,
+                    { uDiffuse: { value: null } }
+                ])
+                : {
+                    uDiffuse: {
+                        type: 't',
+                        value: null
+                    }
+                },
             defines: {
-                USE_TEXTURE: false
+                USE_TEXTURE: false,
+                // a `false` define is omitted from the compiled shader entirely,
+                // not emitted as "#define LIT false"
+                LIT: lit
             },
+            // wires the renderer's light state into the merged uniforms
+            lights: lit,
             blending: NormalBlending,
             transparent: true,
             // The primary use is transparent trails (depthWrite: false). Callers that

package/src/engine/graphics/trail/tube/TubeXMaterialSpec.d.ts

@@ -1,7 +1,7 @@
 /**
  * Material configuration for a {@link TubeX}. Used as a cache key in
  * {@link TubeXPlugin}, so any field that changes the compiled material (texture,
- * depth-write mode) participates in {@link equals}/{@link hash}.
+ * depth-write mode, lighting) participates in {@link equals}/{@link hash}.
  */
 export class TubeXMaterialSpec {
     /**
@@ -16,11 +16,18 @@ export class TubeXMaterialSpec {
      * @type {boolean}
      */
     depthWrite: boolean;
+    /**
+     * When true the tube shades as a matte surface under the standard scene
+     * lights and receives shadows; when false (default) it renders unlit.
+     * @type {boolean}
+     */
+    lit: boolean;
     equals(other: any): boolean;
     hash(): number;
-    fromJSON({ diffuse, depthWrite }: {
+    fromJSON({ diffuse, depthWrite, lit }: {
         diffuse: any;
         depthWrite?: boolean;
+        lit?: boolean;
     }): void;
 }
 //# sourceMappingURL=TubeXMaterialSpec.d.ts.map

package/src/engine/graphics/trail/tube/TubeXMaterialSpec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TubeXMaterialSpec.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/trail/tube/TubeXMaterialSpec.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IAEI;;;OAGG;IACH,SAFU,SAAO,IAAI,CAEN;IAEf;;;;;OAKG;IACH,YAFU,OAAO,CAEE;IAEnB,4BAGC;IAED,eAEC;IAED;;;aAYC;CACJ"}
+{"version":3,"file":"TubeXMaterialSpec.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/trail/tube/TubeXMaterialSpec.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IAEI;;;OAGG;IACH,SAFU,SAAO,IAAI,CAEN;IAEf;;;;;OAKG;IACH,YAFU,OAAO,CAEE;IAEnB;;;;OAIG;IACH,KAFU,OAAO,CAEL;IAEZ,4BAIC;IAED,eAEC;IAED;;;;aAeC;CACJ"}

package/src/engine/graphics/trail/tube/TubeXMaterialSpec.js

@@ -4,7 +4,7 @@ import { computeStringHash } from "../../../../core/primitives/strings/computeSt
 /**
  * Material configuration for a {@link TubeX}. Used as a cache key in
  * {@link TubeXPlugin}, so any field that changes the compiled material (texture,
- * depth-write mode) participates in {@link equals}/{@link hash}.
+ * depth-write mode, lighting) participates in {@link equals}/{@link hash}.
  */
 export class TubeXMaterialSpec {
 
@@ -22,16 +22,24 @@ export class TubeXMaterialSpec {
      */
     depthWrite = false;
 
+    /**
+     * When true the tube shades as a matte surface under the standard scene
+     * lights and receives shadows; when false (default) it renders unlit.
+     * @type {boolean}
+     */
+    lit = false;
+
     equals(other) {
         return this.diffuse === other.diffuse
-            && this.depthWrite === other.depthWrite;
+            && this.depthWrite === other.depthWrite
+            && this.lit === other.lit;
     }
 
     hash() {
-        return (computeStringHash(this.diffuse) * 2) + (this.depthWrite ? 1 : 0);
+        return (computeStringHash(this.diffuse) * 4) + (this.lit ? 2 : 0) + (this.depthWrite ? 1 : 0);
     }
 
-    fromJSON({ diffuse, depthWrite = false }) {
+    fromJSON({ diffuse, depthWrite = false, lit = false }) {
 
         if (diffuse !== undefined && diffuse !== null) {
             assert.isString(diffuse, "diffuse");
@@ -43,5 +51,8 @@ export class TubeXMaterialSpec {
 
         assert.isBoolean(depthWrite, "depthWrite");
         this.depthWrite = depthWrite;
+
+        assert.isBoolean(lit, "lit");
+        this.lit = lit;
     }
 }

package/src/engine/graphics/trail/tube/TubeXPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TubeXPlugin.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/trail/tube/TubeXPlugin.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH;IAOI,8BAWC;IARG,WAAyB;IAU7B;;;OAGG;IACH,4CAFa,aAAa,CAIzB;;CAsCJ;6BA3E4B,iCAAiC;8BAChC,oBAAoB"}
+{"version":3,"file":"TubeXPlugin.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/trail/tube/TubeXPlugin.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH;IAOI,8BAWC;IARG,WAAyB;IAU7B;;;OAGG;IACH,4CAFa,aAAa,CAIzB;;CA4CJ;6BAjF4B,iCAAiC;8BAChC,oBAAoB"}

package/src/engine/graphics/trail/tube/TubeXPlugin.js

@@ -48,6 +48,7 @@ export class TubeXPlugin extends EnginePlugin {
     #build_material(spec) {
 
         const material = new TubeMaterialX({
+            lit: spec.lit,
             transparent: true,
             depthWrite: spec.depthWrite,
             wireframe: false
@@ -75,6 +76,11 @@ export class TubeXPlugin extends EnginePlugin {
             material.needsUpdate = true;
         }
 
-        return material;
+        // Hand the material to the material manager so renderer-wide compile steps
+        // apply — under Forward+ the lit variant is rewritten to also receive
+        // clustered point lights and decals. With no steps registered this is a
+        // pass-through. The async texture callback above still lands: the compiled
+        // material shares the source's uniform objects.
+        return this.engine.graphics.getMaterialManager().obtain(material).getValue();
     }
 }