@woosh/meep-engine 2.33.36 → 2.33.40

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -456,7 +456,7 @@ function init() {
 
     // sample_gltf_sponza();
     // sample_gltf_rts_factory();
-    sample_lucy();
+    // sample_lucy();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
     // sample_gltf_broken_isiflow();
@@ -465,6 +465,9 @@ function init() {
     // gltf_sample('data/models/moicon/08-clickable-assets/model.gltf');
     // gltf_sample('data/models/moicon/05-ground-floor/model.gltf');
     // gltf_sample('data/models/moicon/isiflow_Oct_15_21/0/model.gltf');
+    // gltf_sample('moicon/29_Dec_2021_Nammo/1/model.gltf');
+    // gltf_sample('moicon/29_Dec_2021_Nammo/1-onematerial/model.gltf');
+    gltf_sample('moicon/29_Dec_2021_Nammo/2/model.gltf');
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 

package/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -122,6 +122,7 @@ export class VGThreeRenderer {
         // clear contexts
         const contexts = this.__contexts_array;
         const context_count = contexts.length;
+
         for (let i = 0; i < context_count; i++) {
             const ctx = contexts[i];
 
@@ -142,8 +143,11 @@ export class VGThreeRenderer {
             }
         };
 
-        for (let i = 0; i < this.__inputs.length; i++) {
-            const input_object = this.__inputs[i];
+        const inputs = this.__inputs;
+        const input_count = inputs.length;
+
+        for (let i = 0; i < input_count; i++) {
+            const input_object = inputs[i];
 
             input_object.traverse(processObject);
         }

package/engine/graphics/particles/node-based/rendering/billboard/ParticleBillboardShader.js

@@ -42,7 +42,7 @@ export const ParticleBillboardShader = {
                 
                 #ifdef DEPTH_SOFT_ENABLED
 			    
-				vFadeDistance = 1.0 / radius;
+				    vFadeDistance = 1.0 / radius;
 				
 				#endif
                 				

package/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js

@@ -2,7 +2,6 @@ import { inverseLerp } from "../../../../../../core/math/inverseLerp.js";
 import { assert } from "../../../../../../core/assert.js";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { min2 } from "../../../../../../core/math/min2.js";
-import { mix } from "../../../../../../core/math/mix.js";
 import { ParameterLookupTableFlags } from "./ParameterLookupTableFlags.js";
 import { ParameterLookupTableSerializationAdapter } from "../emitter/serde/ParameterLookupTableSerializationAdapter.js";
 import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
@@ -125,7 +124,7 @@ export class ParameterLookupTable {
      */
     sample(position, result) {
         assert.isNumber(position, 'position');
-        assert.greaterThanOrEqual(position, 0, 'position');
+        // assert.greaterThanOrEqual(position, 0, 'position');
         // assert.ok(position >= 0 && position <= 1, `position must be between 0 and 1, instead was ${position}`);
 
         const itemSize = this.itemSize;
@@ -140,32 +139,28 @@ export class ParameterLookupTable {
         let highIndex = lowIndex;
         let fraction = 0;
 
-        //find position index
-        for (i = 0; i < numValues; i++) {
-            //NOTE: no complex search is used, since for small data sizes linear scan is typically faster
-            const p = positions[i];
+        if (position <= positions[0]) {
 
-            if (p === position) {
+            // special case, seek position is at or before the start of the table
+            lowIndex = 0;
+            highIndex = 0;
 
-                // found the exact match
-                lowIndex = i;
-                highIndex = i;
-                fraction = 0;
-                break;
+        } else {
+
+            //find position index
+            for (i = 1; i < numValues; i++) {
+                //NOTE: no complex search is used, since for small data sizes linear scan is typically faster
+                const p = positions[i];
 
-            } else if (p > position) {
-                // next position if over the seek position
-                highIndex = i;
-                if (i === 0) {
-                    lowIndex = i;
-                    fraction = 0;
-                } else {
+                if (p >= position) {
+                    // next position if over the seek position
+                    highIndex = i;
                     lowIndex = i - 1;
-                    const prevPosition = positions[lowIndex];
-                    fraction = inverseLerp(prevPosition, p, position);
-                }
 
-                break;
+                    fraction = inverseLerp(positions[lowIndex], p, position);
+
+                    break;
+                }
             }
         }
 
@@ -177,7 +172,8 @@ export class ParameterLookupTable {
             const lowValue = data[low_offset + i];
             const highValue = data[high_offset + i];
 
-            const value = mix(lowValue, highValue, fraction);
+            // inlined for speed: mix(low, high, fraction)
+            const value = lowValue * (1 - fraction) + highValue * fraction;
 
             result[i] = value;
         }

package/engine/graphics/particles/particular/engine/renderers/billboard/ParticleBillboardMaterial.js

@@ -17,9 +17,9 @@ const CHUNK_LAMBERT_LIGHTING = `
 vec3 diffuse = vec3( 1.0 );
 
 GeometricContext geometry;
-geometry.position = mvPosition.xyz;
+geometry.position = -vViewPosition;
 geometry.normal = normalize( transformedNormal );
-geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
+geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -vViewPosition.xyz );
 
 GeometricContext backGeometry;
 backGeometry.position = geometry.position;
@@ -156,28 +156,11 @@ function make_vertex_shader() {
                 varying vec2 vRotationMultiplier;
                 varying float vBlending;
                 
-                
                 #if defined(LIGHTS_ENABLED)
-                    #include <common>
-                    #include <bsdfs>
-                    #include <lights_pars_begin>
-                    
-                    struct LambertMaterial {
-                        vec3 diffuseColor;
-                    };
-                    
-                    void RE_Direct_Lambert( const in IncidentLight directLight, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
-                        vec3 irradiance = directLight.color;
-                        reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
-                    }
-                    
-                    void RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
-                        reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
-                    }
-                    
-                    #define RE_Direct				RE_Direct_Lambert
-                    #define RE_IndirectDiffuse		RE_IndirectDiffuse_Lambert
+                    varying vec3 vViewPosition;
                 #endif
+                    
+                
                 
                 void main() {
                    
@@ -194,10 +177,11 @@ function make_vertex_shader() {
                     
                     #if defined(LIGHTS_ENABLED)
                         vec4 mvPosition = modelViewMatrix * position4;
-                        vec3 vViewPosition = -mvPosition.xyz;
+                        vViewPosition = -mvPosition.xyz;
                         
                         vec3 transformedNormal = vec3(0.0,0.0,1.0);
-                    #else
+                        
+                        #include <worldpos_vertex>
                     #endif
                     
                     gl_Position = modelViewProjectionMatrix * position4;
@@ -222,7 +206,6 @@ function make_vertex_shader() {
                             
                         }
                     #endif
-                    //
                     
                     vRotationMultiplier = vec2( cos(rotationGlobal),sin(rotationGlobal) );
                     
@@ -238,30 +221,6 @@ function make_vertex_shader() {
                     
                     gl_PointSize = projected_radius;
                 
-                    #if defined(LIGHTS_ENABLED)
-                        vec3 vLightFront;
-                        vec3 vIndirectFront;
-                        
-                        #include <worldpos_vertex>
-                        ${CHUNK_LAMBERT_LIGHTING}
-                        
-                        LambertMaterial material = LambertMaterial(vColor.rgb);
-                        
-                        ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
-                        vec3 totalEmissiveRadiance = vec3(0.0);
-                        
-                        reflectedLight.indirectDiffuse += vIndirectFront;
-                        reflectedLight.indirectDiffuse *= BRDF_Lambert( vColor.rgb );
-                        
-                        reflectedLight.directDiffuse = vLightFront;
-                        reflectedLight.directDiffuse *= BRDF_Lambert( vColor.rgb ); // shadowmask goes here
-                        
-                        //@injection_point FORWARD_PLUS:accumulation
-                        
-                        vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
-                        
-                        vColor.rgb = outgoingLight;
-                    #endif
                     
                 }`;
 }
@@ -276,6 +235,10 @@ function make_fragment_shader() {
                 uniform float cameraFar;
                 uniform mat4 modelViewMatrix;
                 uniform mat4 projectionMatrix;
+                      
+                uniform mat4 uProjectionInverse;
+                uniform mat4 uViewInverse;
+                
                 uniform vec2 resolution;
                 
                 varying float vFadeDistance;
@@ -285,7 +248,6 @@ function make_fragment_shader() {
                 varying vec2 vRotationMultiplier;
                 varying float vBlending;
                 
-                
                 out highp vec4 pc_fragColor;
                 
                 float depthToLinear( float z ) {
@@ -334,6 +296,58 @@ function make_fragment_shader() {
                     return zFade;
                 }
                 
+                
+                #if defined(LIGHTS_ENABLED)
+                
+                    vec3 computeWorldPositionFromFragmentPosition(vec3 coord){
+                         vec4 ndc = vec4(
+                        (coord.x - 0.5) * 2.0,
+                        (coord.y - 0.5) * 2.0,
+                        (coord.z - 0.5) * 2.0,
+                        1.0);
+                    
+                        vec4 clip = uProjectionInverse * ndc;
+                        return (uViewInverse* (clip / clip.w) ).xyz;
+                    }
+                
+                    vec3 construct_spherical_normal_from_point_coord(vec2 coord){
+                        float x = coord.x * 2.0 - 1.0;
+                        float y = coord.y * 2.0 - 1.0; // note we flip Y
+                    
+                        float z = sqrt(1.0 - clamp(x*x + y*y, 0.0, 1.0));
+                    
+                        
+                        vec3 position = vec3(x, -y, z);
+                    
+                        vec3 normal = normalize(position);
+                        
+                        return normal;
+                    }
+                
+                    #include <common>
+                    #include <bsdfs>
+                    #include <lights_pars_begin>
+                    
+                    struct LambertMaterial {
+                        vec3 diffuseColor;
+                    };
+                    
+                    void RE_Direct_Lambert( const in IncidentLight directLight, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
+                        float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
+                        vec3 irradiance =  dotNL * directLight.color;
+                        reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+                    }
+                    
+                    void RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in GeometricContext geometry, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
+                        reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+                    }
+                    
+                    #define RE_Direct				RE_Direct_Lambert
+                    #define RE_IndirectDiffuse		RE_IndirectDiffuse_Lambert
+                    
+                    varying vec3 vViewPosition;
+                #endif
+                
                 void main() {
                     float fragmentDepth = gl_FragCoord.z;
                     
@@ -365,6 +379,37 @@ function make_fragment_shader() {
                     
                     vec4 texel = spriteColor * vColor;
                     
+                    #if defined(LIGHTS_ENABLED)
+                        // compute world position
+                        vec3 v_world_position = computeWorldPositionFromFragmentPosition(gl_FragCoord.xyz);
+               
+                
+                        vec3 vLightFront;
+                        vec3 vIndirectFront;
+                        
+                        vec3 transformedNormal = construct_spherical_normal_from_point_coord(gl_PointCoord.xy);
+                        
+                        ${CHUNK_LAMBERT_LIGHTING}
+                        
+                        LambertMaterial material = LambertMaterial(texel.rgb);
+                        
+                        ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
+                        vec3 totalEmissiveRadiance = vec3(0.0);
+                        
+                        reflectedLight.indirectDiffuse += vIndirectFront;
+                        reflectedLight.indirectDiffuse *= BRDF_Lambert( texel.rgb );
+                        
+                        reflectedLight.directDiffuse = vLightFront;
+                        reflectedLight.directDiffuse *= BRDF_Lambert( texel.rgb ); // shadowmask goes here
+                        
+                        //@injection_point FORWARD_PLUS:accumulation
+                        
+                        vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
+                        
+                        texel.rgb = outgoingLight;
+                    #endif
+                                    
+                    
                     // premultiply alpha
                     texel.xyz *= texel.a;
                     
@@ -379,9 +424,8 @@ function make_fragment_shader() {
                         texel *= zFade;
                     
                     #endif
-                                    
-                    pc_fragColor = texel;
                     
+                    pc_fragColor = texel;
                 }`;
 }
 
@@ -426,7 +470,9 @@ export function make_particle_billboard_shader({ lights = false } = {}) {
         resolution: {
             type: 'v2',
             value: new ThreeVector2()
-        }
+        },
+        uViewInverse: { type: 'm4', value: new Matrix4() },
+        uProjectionInverse: { type: 'm4', value: new Matrix4() },
     };
 
     if (lights) {
@@ -439,8 +485,7 @@ export function make_particle_billboard_shader({ lights = false } = {}) {
             DEPTH_READ_ENABLED: true,
             DEPTH_SOFT_ENABLED: true,
             ALIGN_DIRECTION_ENABLED: false,
-            LIGHTS_ENABLED: lights,
-            LIGHTING_VERTEX_ONLY: true
+            LIGHTS_ENABLED: lights
         },
         uniforms: uniforms,
         vertexShader: make_vertex_shader(),

package/engine/graphics/particles/particular/engine/shader/ShaderManager.js

@@ -117,7 +117,7 @@ export class ShaderManager {
             generateMipmaps: true,
             minFilter: LinearMipMapLinearFilter,
             magFilter: LinearFilter,
-            anisotropy: 0
+            anisotropy: 0 // sprites are always facing the screen, anisotropic filtering would be pointless
         });
 
         this.spriteTexture.name = 'Sprite sheet';
@@ -189,7 +189,9 @@ export class ShaderManager {
             },
             cameraFar: {
                 value: 0
-            }
+            },
+            uViewInverse: { type: 'm4', value: new Matrix4() },
+            uProjectionInverse: { type: 'm4', value: new Matrix4() },
         };
 
         // debugAtlas(this.spriteAtlas.atlas, { scale: new Vector2(1, 1) });
@@ -396,6 +398,9 @@ export class ShaderManager {
         uniforms.modelViewMatrix.value = modelViewMatrix;
         uniforms.cameraNear.value = cameraNear;
         uniforms.cameraFar.value = cameraFar;
+
+        uniforms.uProjectionInverse.value.copy(camera.projectionMatrixInverse);
+        uniforms.uViewInverse.value.copy(camera.matrixWorld);
     }
 
     /**

package/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.js

@@ -123,6 +123,7 @@ export class ParticleVolume {
             "softDepth": true,
             "depthSort": false,
             "velocityAlign": false,
+            "receiveLight": true,
             "blendingMode": 0,
             "layers": [
                 {

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -609,8 +609,8 @@ async function main(engine) {
 
     engine.graphics.renderer.setClearColor('rgba(99,99,99,1)');
 
-    // await sample_scene_nam(engine);
-    await sample_scene_0(engine);
+    await sample_scene_nam(engine);
+    // await sample_scene_0(engine);
 }
 
 /**

package/engine/graphics/render/buffer/simple-fx/DepthLimitedBlur.js

@@ -26,14 +26,16 @@ export class DepthLimitedBlur {
             uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
             defines: Object.assign({}, DepthLimitedBlurShader.defines),
             vertexShader: DepthLimitedBlurShader.vertexShader,
-            fragmentShader: DepthLimitedBlurShader.fragmentShader
+            fragmentShader: DepthLimitedBlurShader.fragmentShader,
+            blending: NoBlending
         });
 
         this.__material_blur_y = new ShaderMaterial({
             uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
             defines: Object.assign({}, DepthLimitedBlurShader.defines),
             vertexShader: DepthLimitedBlurShader.vertexShader,
-            fragmentShader: DepthLimitedBlurShader.fragmentShader
+            fragmentShader: DepthLimitedBlurShader.fragmentShader,
+            blending: NoBlending
         });
 
 
@@ -97,7 +99,10 @@ export class DepthLimitedBlur {
      */
     execute(renderer) {
         // update intermediate buffer size based on input size
-        if (this.__intermediate.width !== this.__rt_output.width || this.__intermediate.height !== this.__rt_output.height) {
+        if (
+            this.__intermediate.width !== this.__rt_output.width
+            || this.__intermediate.height !== this.__rt_output.height
+        ) {
             this.__intermediate.setSize(this.__rt_output.width, this.__rt_output.height);
         }
 
@@ -118,7 +123,7 @@ export class DepthLimitedBlur {
 
         renderer.setRenderTarget(this.__rt_output);
         renderer.clearColor();
-        
+
         renderScreenSpace(renderer, my);
 
         // restore state

package/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js

@@ -286,7 +286,13 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
 
         const size = graphics.viewport.size;
 
-        this.__render_target.setSize(size.x, size.y);
+        const target_resolution_x = Math.ceil(size.x * this.__resolution_scale);
+        const target_resolution_y = Math.ceil(size.y * this.__resolution_scale);
+
+        this.__render_target.setSize(
+            target_resolution_x,
+            target_resolution_y
+        );
     }
 
     async startup() {