@woosh/meep-engine 2.33.55 → 2.33.59

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/gui/GUIElement.js

@@ -3,7 +3,6 @@
  */
 import Vector2 from '../../../core/geom/Vector2.js';
 import ObservedBoolean from "../../../core/model/ObservedBoolean.js";
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 import { COMPONENT_SERIALIZATION_TRANSIENT_FIELD } from "../storage/COMPONENT_SERIALIZATION_TRANSIENT_FIELD.js";
 import { assert } from "../../../core/assert.js";
 import { objectDeepEquals } from "../../../core/model/object/objectDeepEquals.js";
@@ -238,108 +237,3 @@ GUIElement.serializable = true;
 export default GUIElement;
 
 
-export class GUIElementSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = GUIElement;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GUIElement} value
-     */
-    serialize(buffer, value) {
-
-        if (!value.getFlag(GUIElementFlag.Managed)) {
-            throw new Error(`Expected 'Managed' flag to be set, instead it was cleared. Cannot serialize un-managed component`);
-        }
-
-        value.anchor.toBinaryBufferFloat32(buffer);
-        buffer.writeUTF8String(value.group);
-
-        buffer.writeUint8(value.visible.getValue() ? 1 : 0);
-
-        buffer.writeUTF8String(value.klass);
-        //write parameters
-
-        const paramKeys = Object.keys(value.parameters);
-
-        const numParamKeys = paramKeys.length;
-        buffer.writeUintVar(numParamKeys);
-
-        for (let i = 0; i < numParamKeys; i++) {
-            const paramKey = paramKeys[i];
-
-            buffer.writeUTF8String(paramKey);
-
-            const parameter = value.parameters[paramKey];
-
-            const paramType = typeof parameter;
-
-            if (paramType === "number") {
-                buffer.writeUint8(1);
-
-                buffer.writeFloat64(parameter);
-            } else if (paramType === "boolean") {
-                buffer.writeUint8(2);
-
-                buffer.writeUint8(parameter ? 1 : 0);
-            } else if (paramType === "string") {
-                buffer.writeUint8(3);
-
-                buffer.writeUTF8String(parameter);
-            } else {
-                throw new TypeError(`Unsupported parameter type ${paramType}`);
-            }
-
-        }
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GUIElement} value
-     */
-    deserialize(buffer, value) {
-        value.anchor.fromBinaryBufferFloat32(buffer);
-
-        value.group = buffer.readUTF8String();
-
-        value.visible.set(buffer.readUint8() !== 0);
-
-        value.klass = buffer.readUTF8String();
-
-        const numParamKeys = buffer.readUintVar();
-
-        const params = {};
-
-        for (let i = 0; i < numParamKeys; i++) {
-            //read key
-            const paramKey = buffer.readUTF8String();
-
-            //read type flag
-            const paramTypeHeader = buffer.readUint8();
-
-            let paramValue;
-            if (paramTypeHeader === 1) {
-                //number
-                paramValue = buffer.readFloat64();
-            } else if (paramTypeHeader === 2) {
-                //boolean
-                paramValue = buffer.readUint8() !== 0;
-            } else if (paramTypeHeader === 3) {
-                //string
-                paramValue = buffer.readUTF8String();
-            } else {
-                throw new TypeError(`Unknown type header value '${paramTypeHeader}' for parameter key '${paramKey}'`);
-            }
-
-            params[paramKey] = paramValue;
-        }
-
-        value.parameters = params;
-    }
-}

package/engine/ecs/gui/GUIElementSerializationAdapter.js

@@ -0,0 +1,108 @@
+import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
+import GUIElement, { GUIElementFlag } from "./GUIElement.js";
+
+export class GUIElementSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = GUIElement;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GUIElement} value
+     */
+    serialize(buffer, value) {
+
+        if (!value.getFlag(GUIElementFlag.Managed)) {
+            throw new Error(`Expected 'Managed' flag to be set, instead it was cleared. Cannot serialize un-managed component`);
+        }
+
+        value.anchor.toBinaryBufferFloat32(buffer);
+        buffer.writeUTF8String(value.group);
+
+        buffer.writeUint8(value.visible.getValue() ? 1 : 0);
+
+        buffer.writeUTF8String(value.klass);
+        //write parameters
+
+        const paramKeys = Object.keys(value.parameters);
+
+        const numParamKeys = paramKeys.length;
+        buffer.writeUintVar(numParamKeys);
+
+        for (let i = 0; i < numParamKeys; i++) {
+            const paramKey = paramKeys[i];
+
+            buffer.writeUTF8String(paramKey);
+
+            const parameter = value.parameters[paramKey];
+
+            const paramType = typeof parameter;
+
+            if (paramType === "number") {
+                buffer.writeUint8(1);
+
+                buffer.writeFloat64(parameter);
+            } else if (paramType === "boolean") {
+                buffer.writeUint8(2);
+
+                buffer.writeUint8(parameter ? 1 : 0);
+            } else if (paramType === "string") {
+                buffer.writeUint8(3);
+
+                buffer.writeUTF8String(parameter);
+            } else {
+                throw new TypeError(`Unsupported parameter type ${paramType}`);
+            }
+
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GUIElement} value
+     */
+    deserialize(buffer, value) {
+        value.anchor.fromBinaryBufferFloat32(buffer);
+
+        value.group = buffer.readUTF8String();
+
+        value.visible.set(buffer.readUint8() !== 0);
+
+        value.klass = buffer.readUTF8String();
+
+        const numParamKeys = buffer.readUintVar();
+
+        const params = {};
+
+        for (let i = 0; i < numParamKeys; i++) {
+            //read key
+            const paramKey = buffer.readUTF8String();
+
+            //read type flag
+            const paramTypeHeader = buffer.readUint8();
+
+            let paramValue;
+            if (paramTypeHeader === 1) {
+                //number
+                paramValue = buffer.readFloat64();
+            } else if (paramTypeHeader === 2) {
+                //boolean
+                paramValue = buffer.readUint8() !== 0;
+            } else if (paramTypeHeader === 3) {
+                //string
+                paramValue = buffer.readUTF8String();
+            } else {
+                throw new TypeError(`Unknown type header value '${paramTypeHeader}' for parameter key '${paramKey}'`);
+            }
+
+            params[paramKey] = paramValue;
+        }
+
+        value.parameters = params;
+    }
+}

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/ecs/camera/topdown/TopDownCameraController.js

@@ -11,7 +11,6 @@ import { PI2 } from "../../../../../core/math/MathUtils.js";
 
 const m4 = new Matrix4();
 const euler = new Euler();
-const scratch_vector3 = new Vector3();
 
 const panOffset = new Vector3();
 

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.spec.js

@@ -3,6 +3,14 @@ import Vector3 from "../../../../../core/geom/Vector3.js";
 import { computeTopDownTransform } from "./TopDownCameraControllerSystem.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 
+test('setFromEyeAndTarget does not introduce roll when UP is aligned with +Y', () => {
+    const ut = new TopDownCameraController();
+
+    ut.setFromEyeAndTarget(new Vector3(0, 1, -1), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
+
+    expect(ut.roll).toBe(0);
+});
+
 test('setFromEyeAndTarget results in roll respecting UP vector', () => {
     const eye = new Vector3();
     const target = new Vector3();

package/engine/graphics/ecs/path/PathDisplaySystem.d.ts

@@ -1,5 +1,7 @@
 import Engine from "../../../Engine";
+import {System} from "../../../ecs/System";
+import {PathDisplay} from "./PathDisplay";
 
-export class PathDisplaySystem {
+export class PathDisplaySystem extends System<PathDisplay> {
     constructor(engine: Engine)
 }

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.d.ts

@@ -19,6 +19,8 @@ export class ParticleVolume {
 
     from(args?: Args): void
 
+    fromJSON(json: any): void
+
     build(): void
 
     readonly attributes: Attributes

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, radius = 8 }) {
 
         /**
          *
@@ -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({
@@ -41,7 +41,7 @@ export class DepthLimitedBlur {
 
         this.__depth_cutoff = 0.01;
 
-        this.__blur_radius = 8;
+        this.__blur_radius = radius;
         this.__blur_std_dev = 4;
     }
 
@@ -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 = 2;
+
+        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

@@ -16,7 +16,6 @@ const SAOShader = {
     uniforms: {
 
         'tDepth': { value: null },
-        'tDiffuse': { value: null },
         'tNormal': { value: null },
         'size': { value: new Vector2(512, 512) },
 
@@ -25,7 +24,6 @@ const SAOShader = {
         'cameraProjectionMatrix': { value: new Matrix4() },
         'cameraInverseProjectionMatrix': { value: new Matrix4() },
 
-        'scale': { value: 1.0 },
         'intensity': { value: 0.1 },
         'bias': { value: 0.5 },
 
@@ -48,10 +46,6 @@ const SAOShader = {
 
 		varying vec2 vUv;
 
-		#if DIFFUSE_TEXTURE == 1
-		uniform sampler2D tDiffuse;
-		#endif
-
 		uniform sampler2D tDepth;
 
 		#if NORMAL_TEXTURE == 1
@@ -63,7 +57,6 @@ const SAOShader = {
 		uniform mat4 cameraProjectionMatrix;
 		uniform mat4 cameraInverseProjectionMatrix;
 
-		uniform float scale;
 		uniform float intensity;
 		uniform float bias;
 		uniform float kernelRadius;
@@ -74,14 +67,8 @@ const SAOShader = {
 		// RGBA depth
 
 		#include <packing>
-
-		vec4 getDefaultColor( const in vec2 screenPosition ) {
-			#if DIFFUSE_TEXTURE == 1
-			    return texture2D( tDiffuse, vUv );
-			#else
-			    return vec4( 1.0 );
-			#endif
-		}
+		
+		out float out_occlusion;
 
 		float getDepth( const in vec2 screenPosition ) {
 			#if DEPTH_PACKING == 1
@@ -114,16 +101,26 @@ const SAOShader = {
 			return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );
 			#endif
 		}
-
-		float scaleDividedByCameraFar;
+		
+		// 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 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 +129,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;
+			float angle = hash12( 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 +177,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/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -83,6 +83,7 @@ import { ShadedGeometrySystem } from "../../../ecs/mesh-v2/ShadedGeometrySystem.
 import { FogOfWar } from "../../../../ecs/fow/FogOfWar.js";
 import { FogOfWarRevealer } from "../../../../ecs/fow/FogOfWarRevealer.js";
 import Team from "../../../../../../model/game/ecs/component/Team.js";
+import { AmbientOcclusionPostProcessEffect } from "../../buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
 
 const geo_light_center_octahedron = new BoxBufferGeometry(0.1, 0.1, 0.1);
 const engineHarness = new EngineHarness();
@@ -163,6 +164,7 @@ function makeConfig(engine) {
 
     // Plugins
     config.addPlugin(ForwardPlusRenderingPlugin);
+    config.addPlugin(AmbientOcclusionPostProcessEffect);
     // config.addPlugin(MicronRenderPlugin);
 
     // Knowledge

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