@woosh/meep-engine 2.33.55 → 2.33.56

package/core/geom/3d/shape/json/type_adapters.js

@@ -2,7 +2,7 @@ import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
 import { UnitSphereShape3D } from "../UnitSphereShape3D.js";
 import { TransformedShape3D } from "../TransformedShape3D.js";
 import { UnionShape3D } from "../UnionShape3D.js";
-import { shape_from_json} from "./shape_from_json.js";
+import { shape_from_json } from "./shape_from_json.js";
 import { shape_to_json } from "./shape_to_json.js";
 
 export const type_adapters = {

package/core/math/MathUtils.spec.js

@@ -13,7 +13,6 @@ import { isValueBetweenInclusive } from "./isValueBetweenInclusive.js";
 import { solveQuadratic } from "./solveQuadratic.js";
 import { overlap1D } from "./overlap1D.js";
 import { computeHashFloat } from "./hash/computeHashFloat.js";
-import { computeHashFloatArray } from "./hash/computeHashFloatArray.js";
 
 test('min2', () => {
     expect(min2(0, 0)).toBe(0);

package/engine/ecs/transform/Transform.d.ts

@@ -25,4 +25,8 @@ export class Transform {
     clone(): Transform
 
     equals(other: Transform): void
+
+    toMatrix4(result: ArrayLike<number>): void
+
+    fromMatrix4(matrix: ArrayLike<number>): void
 }

package/engine/graphics/composit/CompositLayer.js

@@ -1,4 +1,13 @@
-import { AddEquation, CustomBlending, Mesh, OneFactor, OneMinusSrcAlphaFactor, ShaderMaterial } from "three";
+import {
+    AddEquation,
+    CustomBlending,
+    Mesh,
+    OneFactor,
+    OneMinusSrcAlphaFactor,
+    RedFormat,
+    RGBAFormat,
+    ShaderMaterial
+} from "three";
 import Vector2 from "../../../core/geom/Vector2.js";
 import { assert } from "../../../core/assert.js";
 import { blendingType2three } from "../texture/sampler/blendingType2Three.js";
@@ -201,10 +210,21 @@ export class CompositLayer {
             }
         };
 
+        // determine swizzle for the material
+        let swizzle;
+        const texture_format = this.renderTarget.texture.format;
+        if (texture_format === RedFormat) {
+            swizzle = ['r', 'r', 'r', 1];
+        } else if (texture_format === RGBAFormat) {
+            swizzle = ['r', 'g', 'b', 'a'];
+        } else {
+            throw new Error('Unsupported format');
+        }
+
         const material = new ShaderMaterial({
             uniforms,
             vertexShader: ScreenSpaceQuadShader.vertexShader(),
-            fragmentShader: ScreenSpaceQuadShader.fragmentShader(),
+            fragmentShader: ScreenSpaceQuadShader.fragmentShader(swizzle),
             lights: false,
             fog: false,
             depthTest: false,

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

@@ -28,27 +28,11 @@ backGeometry.viewDir = geometry.viewDir;
 
 vLightFront = vec3( 0.0 );
 vIndirectFront = vec3( 0.0 );
-#ifdef DOUBLE_SIDED
-	vLightBack = vec3( 0.0 );
-	vIndirectBack = vec3( 0.0 );
-#endif
 
 IncidentLight directLight;
 float dotNL;
 vec3 directLightColor_Diffuse;
 
-vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
-
-vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
-
-#ifdef DOUBLE_SIDED
-
-	vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
-
-	vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
-
-#endif
-
 #if NUM_POINT_LIGHTS > 0
 
 	#pragma unroll_loop_start
@@ -56,17 +40,8 @@ vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
 
 		getPointLightInfo( pointLights[ i ], geometry, directLight );
 
-		dotNL = dot( geometry.normal, directLight.direction );
-		directLightColor_Diffuse = directLight.color;
-
-		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
-
-		#ifdef DOUBLE_SIDED
-
-			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
-
-		#endif
-
+		RE_Direct( directLight, geometry, material, reflectedLight );
+		
 	}
 	#pragma unroll_loop_end
 
@@ -79,16 +54,7 @@ vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
 
 		getSpotLightInfo( spotLights[ i ], geometry, directLight );
 
-		dotNL = dot( geometry.normal, directLight.direction );
-		directLightColor_Diffuse = directLight.color;
-
-		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
-
-		#ifdef DOUBLE_SIDED
-
-			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
-
-		#endif
+		RE_Direct( directLight, geometry, material, reflectedLight );
 	}
 	#pragma unroll_loop_end
 
@@ -101,38 +67,50 @@ vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
 
 		getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
 
-		dotNL = dot( geometry.normal, directLight.direction );
-		directLightColor_Diffuse = directLight.color;
-
-		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
-
-		#ifdef DOUBLE_SIDED
-
-			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
-
-		#endif
+		RE_Direct( directLight, geometry, material, reflectedLight );
 
 	}
 	#pragma unroll_loop_end
 
 #endif
 
-#if NUM_HEMI_LIGHTS > 0
 
-	#pragma unroll_loop_start
-	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
 
-		vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
+#if defined( RE_IndirectDiffuse )
+    vec3 iblIrradiance = vec3( 0.0 );
+    vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
+    irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );
+    #if NUM_HEMI_LIGHTS > 0
 
-		#ifdef DOUBLE_SIDED
-
-			vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
+	#pragma unroll_loop_start
+        for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
+    
+            vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
+    
+        }
+        #pragma unroll_loop_end
+    
+    #endif
+
+	#if defined( USE_ENVMAP ) && defined( ENVMAP_TYPE_CUBE_UV )
+		iblIrradiance += getIBLIrradiance( geometry.normal );
+	#endif
+#endif
 
-		#endif
+#if defined( RE_IndirectSpecular )
+    vec3 radiance = vec3( 0.0 );
+    vec3 clearcoatRadiance = vec3( 0.0 );
+#endif
 
-	}
-	#pragma unroll_loop_end
+#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
+	radiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );
+#endif
 
+#if defined( RE_IndirectDiffuse )
+	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );
+#endif
+#if defined( RE_IndirectSpecular )
+	RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );
 #endif
 `;
 
@@ -389,18 +367,12 @@ function make_fragment_shader() {
                         
                         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
+                        ${CHUNK_LAMBERT_LIGHTING}
+                       
+                        vec3 totalEmissiveRadiance = vec3(0.0);
                         
                         //@injection_point FORWARD_PLUS:accumulation
                         

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

@@ -169,7 +169,7 @@ export class AttributeValue {
                 throw new Error(`Expected 'value' to be an array, instead got something else (=${value})`);
             }
         } else {
-            this.__value = [];
+            // retain current value
         }
 
         if (lookup !== undefined) {

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

@@ -257,8 +257,10 @@ export class ParticleVolume {
     init_attributes() {
         const spec = PARTICULAR_PARTICLE_SPECIFICATION;
 
-        for (let i = 0; i < spec.attributes.length; i++) {
-            const attributeSpec = spec.attributes[i];
+        const attributeSpecs = spec.attributes;
+        const attribute_count = attributeSpecs.length;
+        for (let i = 0; i < attribute_count; i++) {
+            const attributeSpec = attributeSpecs[i];
 
             const av = new AttributeValue();
             av.spec = attributeSpec;
@@ -300,6 +302,7 @@ export class ParticleVolume {
      * @param {number} [particle_size]
      * @param {AbstractShape3D} [shape]
      * @param {boolean} sort
+     * @param {boolean} lighting
      * @param {string} [sprite]
      */
     from({
@@ -307,14 +310,19 @@ export class ParticleVolume {
              particle_size = 1,
              shape = new UnitCubeShape3D(),
              sort = false,
+             lighting = true,
              sprite = "data/textures/particle/smokeparticle.png"
          } = {}) {
 
         this.__density = density;
         this.__shape = shape;
 
-        this.__emitter.writeFlag(ParticleEmitterFlag.DepthSorting, sort);
-        this.__emitter.layers.get(0).imageURL = sprite;
+        const emitter = this.__emitter;
+
+        emitter.writeFlag(ParticleEmitterFlag.DepthSorting, sort);
+        emitter.writeFlag(ParticleEmitterFlag.Lit, lighting);
+
+        emitter.layers.get(0).imageURL = sprite;
 
         const attributes = this.attributes;
 
@@ -328,6 +336,7 @@ export class ParticleVolume {
      * @param {number} [particle_size]
      * @param {Object} shape
      * @param {boolean} [is_sorted]
+     * @param {boolean} [is_lit]
      * @param {string} sprite
      * @param {Object<Object>} [attributes]
      */
@@ -337,6 +346,7 @@ export class ParticleVolume {
                  particle_size = 1,
                  shape,
                  is_sorted = true,
+                 is_lit = true,
                  sprite,
                  attributes = {}
              }) {
@@ -350,9 +360,11 @@ export class ParticleVolume {
             shape: shape_object,
             particle_size,
             sort: is_sorted,
+            lighting: is_lit,
             sprite
         });
 
+        // parse attributes
         for (const attributesKey in attributes) {
             const attribute_object = this.attributes[attributesKey];
 
@@ -397,13 +409,13 @@ export class ParticleVolume {
 
         const layer = emitter.layers.get(0);
 
+        // build transform matrix
         const m4_transform = new Matrix4();
 
         const t = this.__transform;
 
         composeMatrix4(m4_transform, t.position, t.rotation, t.scale);
 
-
         const m4_layer = new Matrix4();
 
         composeMatrix4(m4_layer, layer.position, new Quaternion(), layer.scale);
@@ -414,11 +426,14 @@ export class ParticleVolume {
 
         m4_final.multiplyMatrices(m4_transform, m4_layer);
 
-        for (let i = 0; i < particle_count; i++) {
+        // cache variables to save a bit on de-referencing
+        const matrix_elements = m4_final.elements;
+        const shape = this.__shape;
 
-            this.__shape.sample_random_point_in_volume(v3_position, 0, random);
+        for (let i = 0; i < particle_count; i++) {
+            shape.sample_random_point_in_volume(v3_position, 0, random);
 
-            vec3.transformMat4(v3_position, v3_position, m4_final.elements);
+            vec3.transformMat4(v3_position, v3_position, matrix_elements);
 
             particles.writeAttributeVector3(i, PARTICLE_ATTRIBUTE_POSITION, v3_position[0], v3_position[1], v3_position[2]);
         }

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

@@ -1,9 +1,9 @@
-import { NoBlending, ShaderMaterial, UniformsUtils, Vector2, WebGLMultisampleRenderTarget } from "three";
+import { NoBlending, RGBAFormat, ShaderMaterial, UniformsUtils, Vector2, WebGLMultisampleRenderTarget } from "three";
 import { BlurShaderUtils, DepthLimitedBlurShader } from "three/examples/jsm/shaders/DepthLimitedBlurShader.js";
 import { renderScreenSpace } from "../../utils/renderScreenSpace.js";
 
 export class DepthLimitedBlur {
-    constructor() {
+    constructor({ format = RGBAFormat }) {
 
         /**
          *
@@ -19,7 +19,7 @@ export class DepthLimitedBlur {
          */
         this.__rt_output = null;
 
-        this.__intermediate = new WebGLMultisampleRenderTarget({});
+        this.__intermediate = new WebGLMultisampleRenderTarget({ format });
 
 
         this.__material_blur_x = new ShaderMaterial({
@@ -161,4 +161,8 @@ export class DepthLimitedBlur {
         this.__rt_output = render_target;
 
     }
+
+    dispose() {
+        this.__intermediate.dispose();
+    }
 }

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

@@ -1,8 +1,9 @@
 import { EnginePlugin } from "../../../../../plugin/EnginePlugin.js";
 import {
+    GLSL3,
     LinearFilter,
     NoBlending,
-    RGBAFormat,
+    RedFormat,
     ShaderMaterial,
     UniformsUtils,
     WebGLMultisampleRenderTarget
@@ -25,9 +26,18 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
             defines: defines,
             fragmentShader: SAOShader.fragmentShader,
             vertexShader: SAOShader.vertexShader,
-            uniforms: UniformsUtils.clone(SAOShader.uniforms)
+            uniforms: UniformsUtils.clone(SAOShader.uniforms),
+            glslVersion: GLSL3
         });
 
+        // AO parameters
+        const uniforms = this.__material.uniforms;
+        uniforms.bias.value = 0.5;
+        uniforms.intensity.value = 1;
+
+        uniforms.kernelRadius.value = 30;
+        uniforms.minResolution.value = 0;
+
         this.__material.blending = NoBlending;
 
         this.__material.extensions.derivatives = true;
@@ -43,7 +53,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         defines.NUM_SAMPLES = 13;
 
         // More rings = better quality
-        defines.NUM_RINGS = 4;
+        defines.NUM_RINGS = 5;
 
         /**
          * Should normal buffer be used or not? Using normal buffer might be significantly more expensive, as this would require normal buffer to be built every frame. If there are other users of the buffer - this is not an issue
@@ -78,10 +88,10 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
             minFilter: LinearFilter,
             magFilter: LinearFilter,
 
-            format: RGBAFormat,
+            format: RedFormat,
             depthBuffer: false,
             stencilBuffer: false,
-            generateMipmaps: false
+            generateMipmaps: false,
         });
 
         /**
@@ -96,7 +106,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
          * @type {DepthLimitedBlur}
          * @private
          */
-        this.__blur = new DepthLimitedBlur();
+        this.__blur = new DepthLimitedBlur({ format: RedFormat });
     }
 
     /**
@@ -156,16 +166,6 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         uniforms.cameraInverseProjectionMatrix.value.copy(camera.projectionMatrixInverse);
         uniforms.cameraProjectionMatrix.value.copy(camera.projectionMatrix);
 
-        // AO parameters
-        uniforms.bias.value = 0.5;
-        uniforms.intensity.value = 0.18;
-
-        // scale is divided by camera far in the shader, we unbias it here
-        // TODO remove this term from the shader
-        uniforms.scale.value = far * 0.25;
-
-        uniforms.kernelRadius.value = 30;
-        uniforms.minResolution.value = 0;
 
         // trigger uniform update
         material.uniformsNeedUpdate = true;
@@ -300,7 +300,12 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         const graphics = engine.graphics;
 
         // bind compositing layer
-        this.__composit_layer = graphics.layerComposer.createLayer({}, BlendingType.Multiply);
+        this.__composit_layer = graphics.layerComposer.createLayer(
+            {
+                format: RedFormat
+            },
+            BlendingType.Multiply
+        );
         this.__composit_layer.name = 'Ambient Occlusion';
 
         // apply ambient occlusion on opaque pass, otherwise it would occlude transparent geometry
@@ -344,6 +349,8 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         this.__composit_layer.on.preRender.remove(this.__render, this);
         graphics.viewport.size.onChanged.add(this.__update_render_target_size, this);
 
+        this.__blur.dispose();
+
         return super.shutdown();
     }
 

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

@@ -25,7 +25,6 @@ const SAOShader = {
         'cameraProjectionMatrix': { value: new Matrix4() },
         'cameraInverseProjectionMatrix': { value: new Matrix4() },
 
-        'scale': { value: 1.0 },
         'intensity': { value: 0.1 },
         'bias': { value: 0.5 },
 
@@ -63,7 +62,6 @@ const SAOShader = {
 		uniform mat4 cameraProjectionMatrix;
 		uniform mat4 cameraInverseProjectionMatrix;
 
-		uniform float scale;
 		uniform float intensity;
 		uniform float bias;
 		uniform float kernelRadius;
@@ -74,6 +72,8 @@ const SAOShader = {
 		// RGBA depth
 
 		#include <packing>
+		
+		out float out_occlusion;
 
 		vec4 getDefaultColor( const in vec2 screenPosition ) {
 			#if DIFFUSE_TEXTURE == 1
@@ -115,15 +115,18 @@ const SAOShader = {
 			#endif
 		}
 
-		float scaleDividedByCameraFar;
 		float minResolutionMultipliedByCameraFar;
 
 		float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {
 			vec3 viewDelta = sampleViewPosition - centerViewPosition;
+			
 			float viewDistance = length( viewDelta );
-			float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;
-
-			return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );
+			
+            float vn = dot( centerViewNormal, viewDelta );
+            float a2 = (vn - minResolutionMultipliedByCameraFar) / viewDistance - bias;
+            float a1 = (1.0 + pow2( viewDistance ) );
+            
+			return max(0.0, a2) / a1;
 		}
 
 		// moving costly divides into consts
@@ -132,31 +135,34 @@ const SAOShader = {
 
 		float getAmbientOcclusion( const in vec3 centerViewPosition ) {
 			// precompute some variables require in getOcclusion.
-			scaleDividedByCameraFar = scale / cameraFar;
 			minResolutionMultipliedByCameraFar = minResolution * cameraFar;
 			vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );
 
 			// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
 			float angle = rand( vUv + randomSeed ) * PI2;
 			vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;
-			vec2 radiusStep = radius;
 
 			float occlusionSum = 0.0;
 			float weightSum = 0.0;
 
 			for( int i = 0; i < NUM_SAMPLES; i ++ ) {
-				vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;
-				radius += radiusStep;
+				vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius * float(i+1);
+				
 				angle += ANGLE_STEP;
 
 				float sampleDepth = getDepth( sampleUv );
+				
 				if( sampleDepth >= ( 1.0 - EPSILON ) ) {
+				    // skip, too far
 					continue;
 				}
 
 				float sampleViewZ = getViewZ( sampleDepth );
+				
 				vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );
+				
 				occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );
+				
 				weightSum += 1.0;
 			}
 
@@ -177,12 +183,8 @@ const SAOShader = {
 			float ambientOcclusion = getAmbientOcclusion( viewPosition );
 			
 			float invOcclusion = 1.0 - ambientOcclusion;
-			#if DIFFUSE_TEXTURE == 1
-			    gl_FragColor = getDefaultColor( vUv );
-			    gl_FragColor.xyz *=  invOcclusion;
-			#else
-			    gl_FragColor = vec4(invOcclusion,invOcclusion,invOcclusion,1.0);
-			#endif
+			
+			out_occlusion = invOcclusion;
 		}`
 
 };

package/engine/graphics/shaders/ScreenSpaceQuadShader.js

@@ -11,13 +11,33 @@ function vertexShader() {
         `;
 }
 
-function fragmentShader() {
+/**
+ *
+ * @param {string[]} [swizzle] what to read from the texture
+ * @returns {string}
+ */
+function fragmentShader(swizzle = ['r', 'g', 'b', 'a']) {
+    const swizzle_read = [];
+    const n = swizzle.length;
+    for (let i = 0; i < n; i++) {
+        const token = swizzle[i];
+
+        if (typeof token === "string") {
+            swizzle_read[i] = `texel.${token}`;
+        } else if (typeof token === "number") {
+            swizzle_read[i] = Number(token).toFixed(4);
+        } else {
+            throw new Error(`Unsupported swizzle token '${token}'`);
+        }
+    }
+
     return `
                 uniform sampler2D tTexture;
                 varying vec2 vUv;
                             
                 void main(){
-                    gl_FragColor = texture2D( tTexture, vUv );
+                    vec4 texel = texture2D( tTexture, vUv );
+                    gl_FragColor = vec4(${swizzle_read.join(',')});
                 }
         `;
 }
@@ -25,4 +45,4 @@ function fragmentShader() {
 export const ScreenSpaceQuadShader = {
     vertexShader,
     fragmentShader
-};
+};

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.55",
+  "version": "2.33.56",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",