@woosh/meep-engine 2.34.37 → 2.34.41

package/core/bvh2/BinaryNode.js

@@ -34,7 +34,7 @@ let stackPointer = 0;
  */
 const stack = [];
 
-export class BinaryNode extends Node{
+export class BinaryNode extends Node {
     constructor() {
         super();
 
@@ -58,10 +58,17 @@ export class BinaryNode extends Node{
 
         /**
          * Number of leaf nodes in the hierarchy
+         * @deprecated
          * @type {number}
          * @private
          */
         this.leafNodeCount = 0;
+
+        /**
+         * Leaf node will have height 0, root node will have height equal to maximum depth of the tree
+         * @type {number}
+         */
+        this.height = 0;
     }
 
     /**
@@ -107,38 +114,38 @@ export class BinaryNode extends Node{
      * @param {*} [thisArg]
      */
     traverseLeavesPreOrderUsingStack(visitor, thisArg) {
-            let visitCount = 0;
+        let visitCount = 0;
 
-            const stackOffset = stackPointer;
+        const stackOffset = stackPointer;
 
-            stack[stackPointer++] = this;
+        stack[stackPointer++] = this;
 
-            let n;
+        let n;
 
-            while (stackPointer-- > stackOffset) {
+        while (stackPointer-- > stackOffset) {
 
-                visitCount++;
+            visitCount++;
 
-                n = stack[stackPointer];
+            n = stack[stackPointer];
 
-                if (n.isLeafNode) {
-                    visitor.call(thisArg, n);
-                } else {
-                    //a binary node
-                    if (n.right !== null) {
-                        stack[stackPointer++] = n.right;
-                    }
-                    if (n.left !== null) {
-                        stack[stackPointer++] = n.left;
-                    }
+            if (n.isLeafNode) {
+                visitor.call(thisArg, n);
+            } else {
+                //a binary node
+                if (n.right !== null) {
+                    stack[stackPointer++] = n.right;
+                }
+                if (n.left !== null) {
+                    stack[stackPointer++] = n.left;
                 }
             }
+        }
 
         // drop stack frame
         stackPointer = stackOffset;
 
-            return visitCount;
-        }
+        return visitCount;
+    }
 
 
     /**
@@ -154,6 +161,7 @@ export class BinaryNode extends Node{
         this.right = null;
 
         this.leafNodeCount = 0;
+        this.height = 0;
 
         this.setNegativelyInfiniteBounds();
     }
@@ -167,10 +175,6 @@ export class BinaryNode extends Node{
         this.left = left;
         this.right = right;
 
-        this.updateLeafNodeCount()
-
-        this.refitFor2();
-
         left.parentNode = this;
         right.parentNode = this;
     }
@@ -183,11 +187,6 @@ export class BinaryNode extends Node{
         assert.isNull(this.left, 'left');
 
         this.left = child;
-
-        this.updateLeafNodeCount();
-
-        this.refit();
-
         child.parentNode = this;
     }
 
@@ -199,16 +198,12 @@ export class BinaryNode extends Node{
         assert.isNull(this.right, 'right');
 
         this.right = child;
-
-        this.updateLeafNodeCount();
-
-        this.refit();
-
         child.parentNode = this;
     }
 
     /**
      * For incremental insertion, a sibling needs to be found, newly inserted node will be parented together with this sibling
+     * @see https://github.com/erincatto/box2d/blob/9dc24a6fd4f32442c4bcf80791de47a0a7d25afb/src/collision/b2_dynamic_tree.cpp#L197
      * @param {AABB3} box
      * @returns {BinaryNode|LeafNode}
      */
@@ -503,6 +498,35 @@ export class BinaryNode extends Node{
         return surfaceAreaHeuristic(thisArea, leftArea, rightArea, leftLeaves, rightLeaves);
     }
 
+    updateHeight() {
+        let node = this;
+        let n = 0;
+
+        while (node !== null) {
+            n = 0;
+
+            const right = node.right;
+
+            if (right !== null) {
+                n = right.height;
+            }
+
+            const left = this.left;
+
+            if (left !== null) {
+                n = max2(n, left.height);
+            }
+
+            node.height = n + 1;
+
+            // propagate update up the tree
+            node = node.parentNode;
+        }
+    }
+
+    /**
+     * @deprecated
+     */
     updateLeafNodeCount() {
         let node = this;
 
@@ -568,6 +592,7 @@ export class BinaryNode extends Node{
         r.right = rL;
 
         r.updateLeafNodeCount();
+        r.updateHeight();
 
         r.bubbleRefit();
     }
@@ -575,25 +600,26 @@ export class BinaryNode extends Node{
     rotateRight() {
         const r = this.right;
 
-        const l = this.left;
+        const left = this.left;
 
-        const lL = l.left;
-        const lR = l.right;
+        const lL = left.left;
+        const lR = left.right;
 
         if (lL !== null) {
             lL.parentNode = this;
         }
 
-        l.right = r;
+        left.right = r;
         if (r !== null) {
-            r.parentNode = l;
+            r.parentNode = left;
         }
 
-        l.left = lR;
+        left.left = lR;
 
-        l.updateLeafNodeCount();
+        left.updateLeafNodeCount();
+        left.updateHeight();
 
-        l.bubbleRefit();
+        left.bubbleRefit();
     }
 
     /**
@@ -624,8 +650,14 @@ export class BinaryNode extends Node{
             for (i = 0; i < remaining_nodes - 1; i += 2) {
                 const a = nodes[i];
                 const b = nodes[i + 1];
+
                 n = new BinaryNode();
+
                 n.setChildren(a, b);
+
+                n.updateHeight();
+                n.refitFor2();
+
                 nodes[i >> 1] = n;
             }
 
@@ -994,15 +1026,19 @@ export class BinaryNode extends Node{
         const sibling = this.__insertion_findSiblingFor(child);
 
         const sibling_parent = sibling.parentNode;
+        let parent = sibling_parent;
+
         if (sibling_parent === null) {
-            // root node
+            // "sibling" is the root node
+
+            parent = sibling;
 
             if (sibling.left === null) {
                 sibling.setChildLeft(child);
             } else if (sibling.right === null) {
                 sibling.setChildRight(child);
             } else {
-                const parent = new BinaryNode();
+                parent = new BinaryNode();
 
                 parent.setChildren(sibling.right, child);
                 sibling.right = parent;
@@ -1025,12 +1061,23 @@ export class BinaryNode extends Node{
 
             } else {
 
-                transplantNewCommonParent(sibling, child)
+                parent = transplantNewCommonParent(sibling, child)
 
             }
 
-            sibling_parent.bubbleRefit();
+        }
+
+        // walk back up the tree fixing heights and bounds
+        while (parent !== null) {
+            // parent = this.balance();
+
+            const left = parent.left;
+            const right = parent.right;
 
+            parent.height = 1 + max2(left !== null ? left.height : 0, right !== null ? right.height : 0);
+            parent.refit();
+
+            parent = parent.parentNode;
         }
     }
 
@@ -1116,38 +1163,6 @@ function inclusion_cost_lower_bound(node, addition) {
 }
 
 
-/**
- *
- * @param {Node} n0
- * @param {Node} n1
- * @return {number}
- */
-function sortMortonCodes(n0, n1) {
-    return n0._mortonCode - n1._mortonCode;
-}
-
-
-/**
- *
- * @param node
- */
-function countLeaves(node) {
-    if (isLeaf(node)) {
-        return 1;
-    }
-
-    let result = 0;
-
-    node.traversePreOrderUsingStack(function (node) {
-        if (isLeaf(node)) {
-            result++;
-        }
-    });
-
-    return result;
-}
-
-
 /**
  * @private
  * Used in intersection traversal methods. Should be invoked via Function.apply and Function.call only and not be called directly
@@ -1179,10 +1194,6 @@ function transplantNewCommonParent(node, child) {
     bNode.setChildren(node, child);
     bNode.parentNode = parent;
 
-    parent.bubbleExpandToFit(bNode);
-
-    parent.updateLeafNodeCount();
-
     return bNode;
 }
 

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/core/bvh2/LeafNode.js

@@ -39,17 +39,6 @@ export class LeafNode extends Node {
         this.y1 = y1;
         this.z1 = z1;
 
-        /**
-         *
-         * @type {boolean}
-         */
-        this.isLeafNode = true;
-        /**
-         * Useful shortcut, to avoid having to distinguish between leaf and intermediate nodes
-         * @readonly
-         * @type {number}
-         */
-        this.leafNodeCount = 1;
     }
 
     /**
@@ -105,6 +94,26 @@ export class LeafNode extends Node {
     }
 }
 
+/**
+ *
+ * @type {boolean}
+ */
+LeafNode.prototype.isLeafNode = true;
+
+/**
+ * Leaf node will have height 0, root node will have height equal to maximum depth of the tree
+ * @type {number}
+ */
+LeafNode.prototype.height = 0;
+
+/**
+ * Useful shortcut, to avoid having to distinguish between leaf and intermediate nodes
+ * @readonly
+ * @deprecated
+ * @type {number}
+ */
+LeafNode.prototype.leafNodeCount = 1;
+
 /**
  *
  * @param {BinaryBuffer} buffer

package/core/bvh2/Node.js

@@ -132,6 +132,7 @@ export class Node extends AABB3 {
         }
 
         node.updateLeafNodeCount();
+        node.updateHeight();
     }
 
     /**

package/core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js

@@ -23,5 +23,5 @@ export function aabb3_computeDistanceAbovePlane(
     const pz = plane_normal_z > 0 ? _z1 : _z0;
 
     // dot(v4,v4) inlined for speed
-    return (plane_normal_x * px + plane_normal_y * py + plane_normal_z * pz) + plane_constant;
+    return plane_constant + plane_normal_x * px + plane_normal_y * py + plane_normal_z * pz;
 }

package/engine/ecs/foliage/InstancedFoliage.js

@@ -176,7 +176,7 @@ export class InstancedFoliage {
         );
 
         //compute bounding box for this instance
-        this.bomputeInstanceBoundsTight(position, rotation, scale, leaf);
+        this.computeInstanceBoundsTight(position, rotation, scale, leaf);
 
         //insert bounding box into the spatial index
         this.bvh.insertNode(leaf);
@@ -218,7 +218,7 @@ export class InstancedFoliage {
      * @param {Quaternion} rotation
      * @param {Vector3} scale
      */
-    bomputeInstanceBoundsTight(position, rotation, scale, result) {
+    computeInstanceBoundsTight(position, rotation, scale, result) {
 
         const vertexData = this.geometry.attributes.position.array;
 

package/engine/ecs/foliage/ViewState.js

@@ -1,6 +1,5 @@
 import { BitSet } from "../../../core/binary/BitSet.js";
 import { InstancedMeshGroup } from "../../graphics/geometry/instancing/InstancedMeshGroup.js";
-import { assert } from "../../../core/assert.js";
 import { queryBinaryNode_FrustumIntersections_Data } from "../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 
@@ -48,30 +47,6 @@ export class ViewState {
         this.instances.dispose();
     }
 
-
-    /**
-     *
-     * @param {number} index
-     * @param {int} ref
-     */
-    __updateVisibility(index, ref) {
-        assert.isNonNegativeInteger(ref, 'ref');
-
-        /**
-         *
-         * @type {BitSet}
-         */
-        const visibleElementSet = this.__visible_set;
-
-        if (!visibleElementSet.get(ref)) {
-            //no longer visible
-            this.__garbage[this.__garbagePointer++] = ref;
-        } else {
-            //visible, and is already in the group, update the set
-            visibleElementSet.set(ref, false);
-        }
-    }
-
     __compute_visibility_update() {
         const instances = this.instances;
 
@@ -127,16 +102,16 @@ export class ViewState {
      */
     update(bvh, data) {
 
+        const visible_instance_set = this.__visible_set;
+
+        const instances = this.instances;
+
         // reset visible set
-        this.__visible_set.reset();
+        visible_instance_set.reset();
 
         //reset garbage pointer
         this.__garbagePointer = 0;
 
-        const instances = this.instances;
-
-        const visible_instance_set = this.__visible_set;
-
 
         // collect visible instances
         const collected_nodes = queryBinaryNode_FrustumIntersections_Data(scratch_array, 0, bvh, this.__view.frustum);

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/ecs/light/binding/three/ThreeLightBinding.js

@@ -44,8 +44,30 @@ function __getDepthMaterial(object) {
  * @return {boolean}
  */
 function scene_object_filter(object3D) {
-    return object3D.castShadow
-        && object3D.visible
+
+    if (object3D.castShadow === false) {
+        return false;
+    }
+
+    if (object3D.visible === false) {
+        return false;
+    }
+
+    if (object3D.isMesh) {
+
+        /**
+         * @type {THREE.Material|null|undefined}
+         */
+        const material = (object3D.customDepthMaterial !== null ? object3D.customDepthMaterial : object3D.material);
+
+        if (material && material.visible === false) {
+            //material's main
+            return false;
+        }
+
+    }
+
+    return true;
 }
 
 export class ThreeLightBinding extends LightBinding {

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -274,7 +274,7 @@ export class InstancedMeshGroup {
         //get index
         const index = this.count;
         //grow
-        this.setCount(this.count + 1);
+        this.setCount(index + 1);
 
         this.indices[reference] = index;
         this.references[index] = reference;

package/engine/graphics/micron/format/MicronGeometryPatch.js

@@ -68,13 +68,6 @@ export class MicronGeometryPatch {
          */
         this.children = [];
 
-        /**
-         * Runtime dependency patches, if this patch is refined at runtime - dependencies must be refined as well
-         * These dependencies allow for more aggressive simplification of topology
-         * @type {number[]}
-         */
-        this.dependencies = [];
-
         /**
          * Level of detail, lower number means more detailed
          * @type {number}

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";
@@ -27,7 +28,9 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
             fragmentShader: SAOShader.fragmentShader,
             vertexShader: SAOShader.vertexShader,
             uniforms: UniformsUtils.clone(SAOShader.uniforms),
-            glslVersion: GLSL3
+            glslVersion: GLSL3,
+            depthWrite: false,
+            depthTest: false
         });
 
         // AO parameters
@@ -89,6 +92,8 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
             magFilter: LinearFilter,
 
             format: RedFormat,
+            type: UnsignedByteType,
+            internalFormat: 'R8',
             depthBuffer: false,
             stencilBuffer: false,
             generateMipmaps: false,
@@ -106,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 });
     }
 
     /**
@@ -302,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,186 +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 ) ) {
-				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 };
+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/engine/plugin/EnginePluginManager.js

@@ -82,6 +82,7 @@ export class EnginePluginManager extends BaseProcess {
         if (state === ProcessState.Initialized || state === ProcessState.Running) {
             const dependencies = plugin.dependencies;
 
+            // resolve dependencies
             for (let i = 0; i < dependencies.length; i++) {
                 const dependency = dependencies[i];
 
@@ -206,7 +207,7 @@ export class EnginePluginManager extends BaseProcess {
     async shutdown() {
         super.shutdown();
 
-        return this.__transition_active_plugins_to(ProcessState.Initialized);
+        return this.__transition_active_plugins_to(ProcessState.Finalized);
     }
 
     /**

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