@woosh/meep-engine 2.34.40 → 2.34.41

package/core/bvh2/BinaryNode.spec.js

@@ -287,6 +287,7 @@ test("setChildren", () => {
     b.setBounds(-1, -2, -3, 0, 2, 2);
 
     root.setChildren(a, b);
+    root.refit();
 
     expect(a.parentNode).toBe(root);
     expect(b.parentNode).toBe(root);

package/engine/graphics/composit/CompositLayer.js

@@ -58,7 +58,7 @@ export class CompositLayer {
          *
          * @type {BlendingType}
          */
-        this.blending = blending;
+        this.__blending = blending;
         /**
          *
          * @type {WebGLRenderTarget}
@@ -98,6 +98,20 @@ export class CompositLayer {
         };
     }
 
+    get blending() {
+        return this.__blending;
+    }
+
+    set blending(v) {
+        if (v === this.__blending) {
+            return;
+        }
+
+        this.__blending = v;
+
+        assignMaterialBlending(this.object.material, v);
+    }
+
     /**
      *
      * @param {number} v

package/engine/graphics/ecs/highlight/plugin/OutlineRenderPlugin.js

@@ -8,6 +8,7 @@ import { ObjectPoolFactory } from "../../../../../core/model/object/ObjectPoolFa
 import { HighlightRenderElement } from "../renderer/HighlightRenderElement.js";
 import { noop } from "../../../../../core/function/Functions.js";
 import { CompositingStages } from "../../../composit/CompositingStages.js";
+import { ProcessState } from "../../../../../core/process/ProcessState.js";
 
 export class OutlineRenderPlugin extends EnginePlugin {
     constructor() {
@@ -137,6 +138,12 @@ export class OutlineRenderPlugin extends EnginePlugin {
     }
 
     async startup() {
+
+        if (this.getState().getValue() === ProcessState.Running) {
+            //already running
+            return;
+        }
+
         const graphics = this.engine.graphics;
         const viewport_size = graphics.viewport.size;
 

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

@@ -1,9 +1,19 @@
-import { NoBlending, RGBAFormat, ShaderMaterial, UniformsUtils, Vector2, WebGLMultisampleRenderTarget } from "three";
+import {
+    Color,
+    NoBlending,
+    RGBAFormat,
+    ShaderMaterial,
+    UniformsUtils,
+    Vector2,
+    WebGLMultisampleRenderTarget
+} from "three";
 import { BlurShaderUtils, DepthLimitedBlurShader } from "three/examples/jsm/shaders/DepthLimitedBlurShader.js";
 import { renderScreenSpace } from "../../utils/renderScreenSpace.js";
 
+const scratch_color = new Color();
+
 export class DepthLimitedBlur {
-    constructor({ format = RGBAFormat, radius = 8 }) {
+    constructor({ format = RGBAFormat, radius = 8, clear_color = 0, clear_alpha = 1 }) {
 
         /**
          *
@@ -43,6 +53,9 @@ export class DepthLimitedBlur {
 
         this.__blur_radius = radius;
         this.__blur_std_dev = 4;
+
+        this.__clear_color = new Color(clear_color);
+        this.__clear_alpha = clear_alpha;
     }
 
     configureMaterials() {
@@ -113,21 +126,31 @@ export class DepthLimitedBlur {
         mx.uniforms.size.value.set(this.__rt_output.width, this.__rt_output.height);
         my.uniforms.size.value.set(this.__rt_output.width, this.__rt_output.height);
 
-
+        // remember renderer state
         const __old_state_rt = renderer.getRenderTarget();
-
+        const __old_clear_color = scratch_color;
+        renderer.getClearColor(__old_clear_color);
+        const __old_clear_alpha = renderer.getClearAlpha();
+        const __old_auto_clear = renderer.autoClear;
+
+        //
+        renderer.autoClear = false;
+        renderer.setClearColor(this.__clear_color);
         renderer.setRenderTarget(this.__intermediate);
         renderer.clearColor();
 
         renderScreenSpace(renderer, mx);
 
         renderer.setRenderTarget(this.__rt_output);
+
         renderer.clearColor();
 
         renderScreenSpace(renderer, my);
 
         // restore state
         renderer.setRenderTarget(__old_state_rt);
+        renderer.setClearColor(__old_clear_color, __old_clear_alpha);
+        renderer.autoClear = __old_auto_clear;
     }
 
     /**

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

@@ -6,6 +6,7 @@ import {
     RedFormat,
     ShaderMaterial,
     UniformsUtils,
+    UnsignedByteType,
     WebGLMultisampleRenderTarget
 } from "three";
 import { SAOShader } from "./SAOShader.js";
@@ -91,6 +92,8 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
             magFilter: LinearFilter,
 
             format: RedFormat,
+            type: UnsignedByteType,
+            internalFormat: 'R8',
             depthBuffer: false,
             stencilBuffer: false,
             generateMipmaps: false,
@@ -108,7 +111,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
          * @type {DepthLimitedBlur}
          * @private
          */
-        this.__blur = new DepthLimitedBlur({ format: RedFormat });
+        this.__blur = new DepthLimitedBlur({ format: RedFormat, clear_color: 0xFFFFFF });
     }
 
     /**
@@ -304,7 +307,9 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         // bind compositing layer
         this.__composit_layer = graphics.layerComposer.createLayer(
             {
-                format: RedFormat
+                format: RedFormat,
+                type: UnsignedByteType,
+                internalFormat: 'R8'
             },
             BlendingType.Multiply
         );

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

@@ -1,187 +1,186 @@
-import { Matrix4, Vector2 } from 'three';
-
-/**
- * TODO
- */
-
-const SAOShader = {
-    defines: {
-        'NUM_SAMPLES': 7,
-        'NUM_RINGS': 4,
-        'NORMAL_TEXTURE': 0,
-        'DIFFUSE_TEXTURE': 0,
-        'DEPTH_PACKING': 1,
-        'PERSPECTIVE_CAMERA': 1
-    },
-    uniforms: {
-
-        'tDepth': { value: null },
-        'tNormal': { value: null },
-        'size': { value: new Vector2(512, 512) },
-
-        'cameraNear': { value: 1 },
-        'cameraFar': { value: 100 },
-        'cameraProjectionMatrix': { value: new Matrix4() },
-        'cameraInverseProjectionMatrix': { value: new Matrix4() },
-
-        'intensity': { value: 0.1 },
-        'bias': { value: 0.5 },
-
-        'minResolution': { value: 0.0 },
-        'kernelRadius': { value: 100.0 },
-        'randomSeed': { value: 0.0 }
-    },
-    vertexShader: /* glsl */`
-
-		varying vec2 vUv;
-
-		void main() {
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-		}`,
-
-    fragmentShader: /* glsl */`
-
-		#include <common>
-
-		varying vec2 vUv;
-
-		uniform sampler2D tDepth;
-
-		#if NORMAL_TEXTURE == 1
-		uniform sampler2D tNormal;
-		#endif
-
-		uniform float cameraNear;
-		uniform float cameraFar;
-		uniform mat4 cameraProjectionMatrix;
-		uniform mat4 cameraInverseProjectionMatrix;
-
-		uniform float intensity;
-		uniform float bias;
-		uniform float kernelRadius;
-		uniform float minResolution;
-		uniform vec2 size;
-		uniform float randomSeed;
-
-		// RGBA depth
-
-		#include <packing>
-		
-		out float out_occlusion;
-
-		float getDepth( const in vec2 screenPosition ) {
-			#if DEPTH_PACKING == 1
-			return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
-			#else
-			return texture2D( tDepth, screenPosition ).x;
-			#endif
-		}
-
-		float getViewZ( const in float depth ) {
-			#if PERSPECTIVE_CAMERA == 1
-			return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
-			#else
-			return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
-			#endif
-		}
-
-		vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {
-			float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];
-			vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );
-			clipPosition *= clipW; // unprojection.
-
-			return ( cameraInverseProjectionMatrix * clipPosition ).xyz;
-		}
-
-		vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {
-			#if NORMAL_TEXTURE == 1
-			return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );
-			#else
-			return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );
-			#endif
-		}
-		
-		// Non-sin based hash function, fast and has good randomness
-        float hash12(vec2 p){
-            vec3 p3  = fract(vec3(p.xyx) * .1031);
-            p3 += dot(p3, p3.yzx + 33.33);
-            return fract((p3.x + p3.y) * p3.z);
-        }
-        
-		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 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
-		const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
-		const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
-
-		float getAmbientOcclusion( const in vec3 centerViewPosition ) {
-			// precompute some variables require in getOcclusion.
-			minResolutionMultipliedByCameraFar = minResolution * cameraFar;
-			vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );
-
-			// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
-			float angle = hash12( vUv + randomSeed ) * PI2;
-			vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;
-
-			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 * 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;
-			}
-
-			if( weightSum == 0.0 ) discard;
-
-			return occlusionSum * ( intensity / weightSum );
-		}
-
-		void main() {
-			float centerDepth = getDepth( vUv );
-			if( centerDepth >= ( 1.0 - EPSILON ) ) {
-				out_occlusion = 1.0;
-				return;
-			}
-
-			float centerViewZ = getViewZ( centerDepth );
-			vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );
-
-			float ambientOcclusion = getAmbientOcclusion( viewPosition );
-			
-			float invOcclusion = 1.0 - ambientOcclusion;
-			
-			out_occlusion = invOcclusion;
-		}`
-
-};
-
-export { SAOShader };
+import { Matrix4, Vector2 } from 'three';
+
+/**
+ * TODO
+ */
+
+const SAOShader = {
+    defines: {
+        'NUM_SAMPLES': 7,
+        'NUM_RINGS': 4,
+        'NORMAL_TEXTURE': 0,
+        'DIFFUSE_TEXTURE': 0,
+        'DEPTH_PACKING': 1,
+        'PERSPECTIVE_CAMERA': 1
+    },
+    uniforms: {
+
+        'tDepth': { value: null },
+        'tNormal': { value: null },
+        'size': { value: new Vector2(512, 512) },
+
+        'cameraNear': { value: 1 },
+        'cameraFar': { value: 100 },
+        'cameraProjectionMatrix': { value: new Matrix4() },
+        'cameraInverseProjectionMatrix': { value: new Matrix4() },
+
+        'intensity': { value: 0.1 },
+        'bias': { value: 0.5 },
+
+        'minResolution': { value: 0.0 },
+        'kernelRadius': { value: 100.0 },
+        'randomSeed': { value: 0.0 }
+    },
+    vertexShader: /* glsl */`
+
+		varying vec2 vUv;
+
+		void main() {
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+		}`,
+
+    fragmentShader: /* glsl */`
+
+		#include <common>
+
+		varying vec2 vUv;
+
+		uniform sampler2D tDepth;
+
+		#if NORMAL_TEXTURE == 1
+		uniform sampler2D tNormal;
+		#endif
+
+		uniform float cameraNear;
+		uniform float cameraFar;
+		uniform mat4 cameraProjectionMatrix;
+		uniform mat4 cameraInverseProjectionMatrix;
+
+		uniform float intensity;
+		uniform float bias;
+		uniform float kernelRadius;
+		uniform float minResolution;
+		uniform vec2 size;
+		uniform float randomSeed;
+
+		// RGBA depth
+
+		#include <packing>
+		
+		out float out_occlusion;
+
+		float getDepth( const in vec2 screenPosition ) {
+			#if DEPTH_PACKING == 1
+			return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
+			#else
+			return texture2D( tDepth, screenPosition ).x;
+			#endif
+		}
+
+		float getViewZ( const in float depth ) {
+			#if PERSPECTIVE_CAMERA == 1
+			return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
+			#else
+			return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
+			#endif
+		}
+
+		vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {
+			float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];
+			vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );
+			clipPosition *= clipW; // unprojection.
+
+			return ( cameraInverseProjectionMatrix * clipPosition ).xyz;
+		}
+
+		vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {
+			#if NORMAL_TEXTURE == 1
+			return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );
+			#else
+			return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );
+			#endif
+		}
+		
+		// Non-sin based hash function, fast and has good randomness
+        float hash12(vec2 p){
+            vec3 p3  = fract(vec3(p.xyx) * .1031);
+            p3 += dot(p3, p3.yzx + 33.33);
+            return fract((p3.x + p3.y) * p3.z);
+        }
+        
+		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 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
+		const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
+		const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
+
+		float getAmbientOcclusion( const in vec3 centerViewPosition ) {
+			// precompute some variables require in getOcclusion.
+			minResolutionMultipliedByCameraFar = minResolution * cameraFar;
+			vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );
+
+			// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
+			float angle = hash12( vUv + randomSeed ) * PI2;
+			vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;
+
+			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 * 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;
+			}
+
+			if( weightSum == 0.0 ) discard;
+
+			return occlusionSum * ( intensity / weightSum );
+		}
+
+		void main() {
+			float centerDepth = getDepth( vUv );
+			if( centerDepth >= ( 1.0 - EPSILON ) ) {
+				discard;
+			}
+
+			float centerViewZ = getViewZ( centerDepth );
+			vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );
+
+			float ambientOcclusion = getAmbientOcclusion( viewPosition );
+			
+			float invOcclusion = 1.0 - ambientOcclusion;
+			
+			out_occlusion = invOcclusion;
+		}`
+
+};
+
+export { SAOShader };

package/engine/graphics/render/visibility/hiz/buildCanvasViewFromTexture.js

@@ -89,12 +89,12 @@ function makeShader(texture) {
  * @param {THREE.Texture} texture
  * @param {THREE.WebGLRenderer} renderer
  * @param flipY
- * @return {{view: View, render: render}}
+ * @return {{view: View, render: function}}
  */
 export function buildCanvasViewFromTexture({
-                                               height,
-                                               width,
                                                texture = CheckersTexture.create(),
+                                               width = texture.image.width,
+                                               height = texture.image.height,
                                                renderer,
                                                flipY = true
                                            }) {

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.34.40",
+  "version": "2.34.41",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",