@woosh/meep-engine 2.33.54 → 2.33.58

package/core/geom/3d/shape/AbstractShape3D.js

@@ -62,4 +62,21 @@ export class AbstractShape3D {
     get surface_area() {
         throw new Error('Not Implemented');
     }
+
+    /**
+     * @template {AbstractShape3D} T
+     * @param {T} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.constructor === other.constructor;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    hash() {
+        return 0;
+    }
 }

package/core/geom/3d/shape/TransformedShape3D.js

@@ -1,6 +1,8 @@
 import { mat4, vec3 } from "gl-matrix";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { sign } from "../../../math/sign.js";
+import { isArrayEqualStrict } from "../../../collection/array/isArrayEqualStrict.js";
+import { computeHashFloatArray } from "../../../math/hash/computeHashFloatArray.js";
 
 /**
  *
@@ -140,9 +142,9 @@ export class TransformedShape3D extends AbstractShape3D {
         // normalize gradient
         const gd = distance / Math.hypot(scratch_v3_0[0], scratch_v3_0[1], scratch_v3_0[2]);
 
-        const scaled_dx = scaled_gx * gd ;
-        const scaled_dy = scaled_gy * gd ;
-        const scaled_dz = scaled_gz * gd ;
+        const scaled_dx = scaled_gx * gd;
+        const scaled_dy = scaled_gy * gd;
+        const scaled_dz = scaled_gz * gd;
 
         // determine sign
         const result_sign = sign(distance);
@@ -178,4 +180,27 @@ export class TransformedShape3D extends AbstractShape3D {
         result[1] = scratch_v3_0[1];
         result[2] = scratch_v3_0[2];
     }
+
+    /**
+     *
+     * @param {TransformedShape3D} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return super.equals(other)
+            && this.__subject.equals(other.subject)
+            && isArrayEqualStrict(this.__matrix, other.__matrix)
+            ;
+    }
+
+    hash() {
+        // to avoid recursion, only use matrix for hash
+        return computeHashFloatArray(this.__matrix);
+    }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+TransformedShape3D.isTransformedShape3D = true;

package/core/geom/3d/shape/TransformedShape3D.spec.js

@@ -1,5 +1,6 @@
 import { UnitCubeShape3D } from "./UnitCubeShape3D.js";
 import { TransformedShape3D } from "./TransformedShape3D.js";
+import { UnitSphereShape3D } from "./UnitSphereShape3D.js";
 
 test('signed distance identity transform', () => {
 
@@ -31,3 +32,24 @@ test('signed distance scale', () => {
 
     expect(s.signed_distance_at_point([2, 0, 0])).toBeCloseTo(1);
 });
+
+test('equals', () => {
+
+    const a = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [2, 2, 2]);
+    const b = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [2, 2, 2]);
+
+    expect(a.equals(b)).toBe(true);
+
+    const c = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 1, 0], [2, 2, 2]);
+
+    expect(a.equals(c)).toBe(false);
+
+    const d = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [2, 1, 2]);
+
+    expect(a.equals(d)).toBe(false);
+
+    const e = TransformedShape3D.from_translation_scale(new UnitSphereShape3D(), [0, 0, 0], [2, 2, 2]);
+
+    expect(a.equals(e)).toBe(false);
+
+});

package/core/geom/3d/shape/UnionShape3D.js

@@ -4,6 +4,7 @@ import { binarySearchHighIndex } from "../../../collection/array/binarySearchHig
 import { compareNumbers } from "../../../primitives/numbers/compareNumbers.js";
 import { min2 } from "../../../math/min2.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
+import { isArrayEqual } from "../../../collection/ArrayUtils.js";
 
 /**
  * To avoid severe performance overhead, we limit number of possible rejections
@@ -257,4 +258,27 @@ export class UnionShape3D extends AbstractShape3D {
             break;
         }
     }
+
+    /**
+     *
+     * @param {UnionShape3D} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return super.equals(other)
+            && isArrayEqual(this.children, other.children);
+    }
+
+    hash() {
+        const children = this.children;
+        const child_count = children.length;
+
+        let hash = child_count;
+
+        if (child_count > 0) {
+            hash ^= children[0].hash();
+        }
+
+        return hash;
+    }
 }

package/core/geom/3d/shape/UnitCubeShape3D.js

@@ -98,6 +98,10 @@ export class UnitCubeShape3D extends AbstractShape3D {
     sample_random_point_in_volume(result, result_offset, random) {
         randomPointInBox(random, result, result_offset);
     }
+
+    hash() {
+        return 1;
+    }
 }
 
 UnitCubeShape3D.INSTANCE = new UnitCubeShape3D();

package/core/geom/3d/shape/UnitSphereShape3D.js

@@ -52,6 +52,10 @@ export class UnitSphereShape3D extends AbstractShape3D {
     sample_random_point_in_volume(result, result_offset, random) {
         randomPointInSphere(random, result, result_offset);
     }
+
+    hash() {
+        return 13;
+    }
 }
 
 UnitSphereShape3D.INSTANCE = new UnitSphereShape3D();

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

@@ -0,0 +1,19 @@
+import { type_adapters } from "./type_adapters.js";
+
+/**
+ *
+ * @param {Object} j
+ * @returns {AbstractShape3D}
+ */
+export function shape_from_json(j) {
+    const type = j.type;
+
+    const adapter = type_adapters[type];
+
+    if (adapter === undefined) {
+        throw new Error(`Unsupported shape type '${type}'`);
+    }
+
+    return adapter.read(j);
+}
+

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

@@ -0,0 +1,21 @@
+import { shape_to_type } from "./shape_to_type.js";
+import { type_adapters } from "./type_adapters.js";
+
+/**
+ *
+ * @param {AbstractShape3D} shape
+ * @returns {Object}
+ */
+export function shape_to_json(shape) {
+    const type = shape_to_type(shape);
+
+    const adapter = type_adapters[type];
+
+    if (adapter === undefined) {
+        throw new Error(`Unsupported shape type '${type}'`);
+    }
+
+    const shape_json = adapter.write(shape);
+
+    return Object.assign({ type }, shape_json);
+}

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

@@ -0,0 +1,23 @@
+import { UnionShape3D } from "../UnionShape3D.js";
+import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
+import { UnitSphereShape3D } from "../UnitSphereShape3D.js";
+import { TransformedShape3D } from "../TransformedShape3D.js";
+
+/**
+ *
+ * @param {AbstractShape3D} shape
+ * @returns {string}
+ */
+export function shape_to_type(shape) {
+    if (shape instanceof UnionShape3D) {
+        return 'union';
+    } else if (shape instanceof UnitCubeShape3D) {
+        return 'cube';
+    } else if (shape instanceof UnitSphereShape3D) {
+        return 'sphere';
+    } else if (shape instanceof TransformedShape3D) {
+        return 'transform';
+    } else {
+        throw new Error('Unsupported shape');
+    }
+}

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

@@ -0,0 +1,58 @@
+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_to_json } from "./shape_to_json.js";
+
+export const type_adapters = {
+    'cube': {
+        read() {
+            return UnitCubeShape3D.INSTANCE;
+        },
+        write() {
+            return {};
+        }
+    },
+    'sphere': {
+        read() {
+            return UnitSphereShape3D.INSTANCE;
+        },
+        write() {
+            return {};
+        }
+    },
+    'transform': {
+        read({ transform, subject }) {
+            const subject_shape = shape_from_json(subject);
+
+            return TransformedShape3D.from_m4(subject_shape, transform);
+        },
+        /**
+         *
+         * @param {TransformedShape3D} object
+         */
+        write(object) {
+            return {
+                subject: shape_to_json(object.subject),
+                transform: Array.from(object.transform)
+            };
+        }
+    },
+    'union': {
+        read({ members }) {
+            const member_shapes = members.map(shape_from_json);
+
+            return UnionShape3D.from(member_shapes);
+        },
+        /**
+         *
+         * @param {UnionShape3D} object
+         */
+        write(object) {
+            return {
+                members: object.children.map(shape_to_json)
+            };
+        }
+    }
+};

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);
@@ -128,16 +127,6 @@ test("computeHashFloat", () => {
     expect(computeHashFloat(500)).not.toEqual(computeHashFloat(400))
 });
 
-test("computeHashFloatArray", () => {
-    expect(computeHashFloatArray([1, 2, 1.5], 1, 2)).toEqual(computeHashFloatArray([1, 2, 1.5], 1, 2));
-
-    expect(computeHashFloatArray([1, 2, 1.5], 1, 3)).not.toEqual(computeHashFloatArray([1, 2, 1.5], 1, 2));
-
-    expect(computeHashFloatArray([1, 2, 1.5], 2, 3)).not.toEqual(computeHashFloatArray([1, 2, 1.5], 1, 3));
-
-    expect(computeHashFloatArray([1, 2, 3], 1, 3)).not.toEqual(computeHashFloatArray([1, 2, 1.5], 1, 3));
-});
-
 
 test('sign', () => {
     expect(sign(1)).toBe(1);

package/core/math/hash/computeHashFloatArray.js

@@ -3,28 +3,17 @@ import { computeHashFloat } from "./computeHashFloat.js";
 /**
  *
  * @param {number[]|Float32Array|Float64Array} values
- * @param {number} min
- * @param {number} max
  */
-export function computeHashFloatArray(values, min, max) {
+export function computeHashFloatArray(values) {
     const dataLength = values.length;
 
-    const dataRange = max - min;
-
-    /*
-     hash min and max
-     */
-    const minHash = computeHashFloat(min);
-    const maxHash = computeHashFloat(min);
-
-    let hash = ((minHash << 5) - minHash) + maxHash;
+    let hash = dataLength;
 
     for (let i = 0; i < dataLength; i++) {
         const singleValue = values[i];
-        //normalize value
-        const valueNormalized = (singleValue - min) / dataRange;
+
         //scale value to integer range
-        const integerValue = valueNormalized * 4294967295;
+        const integerValue = computeHashFloat(singleValue);
 
         hash = ((hash << 5) - hash) + integerValue;
         hash |= 0; // Convert to 32bit integer

package/core/math/hash/computeHashFloatArray.spec.js

@@ -0,0 +1,11 @@
+import { computeHashFloatArray } from "./computeHashFloatArray.js";
+
+test("computeHashFloatArray", () => {
+    expect(computeHashFloatArray([1, 2, 1.5])).toEqual(computeHashFloatArray([1, 2, 1.5]));
+
+    expect(computeHashFloatArray([1, 2, 1.5])).not.toEqual(computeHashFloatArray([1, 3, 1.5]));
+
+    expect(computeHashFloatArray([1, 2, 1.5])).not.toEqual(computeHashFloatArray([1, 2, 2.5]));
+
+    expect(computeHashFloatArray([1, 2, 3])).not.toEqual(computeHashFloatArray([1, 2, 1.5]));
+});

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/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/parameter/ParameterLookupTable.js

@@ -296,8 +296,8 @@ export class ParameterLookupTable {
             //special case, all values are the same
             return computeHashIntegerArray(valueMin);
         } else {
-            const dataHash = computeHashFloatArray(this.data, valueMin, valueMax);
-            const positionHash = computeHashFloatArray(this.positions, 0, 1);
+            const dataHash = computeHashFloatArray(this.data);
+            const positionHash = computeHashFloatArray(this.positions);
 
             return computeHashIntegerArray(dataHash, positionHash, this.itemSize);
         }

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

@@ -3,6 +3,7 @@ import { DataType2TypedArrayConstructorMapping } from "../../../../../../../core
 import { array_copy } from "../../../../../../../core/collection/array/copyArray.js";
 import { min2 } from "../../../../../../../core/math/min2.js";
 import { assert } from "../../../../../../../core/assert.js";
+import { ParameterLookupTable } from "../../parameter/ParameterLookupTable.js";
 
 export class AttributeValue {
     constructor() {
@@ -142,4 +143,57 @@ export class AttributeValue {
     read_value(destination) {
         array_copy(this.__value, 0, destination, 0, this.spec.itemSize);
     }
+
+    /**
+     *
+     * @param {number[]} [value]
+     * @param {Object} [lookup]
+     * @param {number} [lookup_value]
+     */
+    fromJSON({
+                 value,
+                 lookup,
+                 lookup_value
+             }) {
+
+        if (value !== undefined) {
+            if (Array.isArray(value)) {
+
+                if (lookup !== undefined) {
+                    console.warn("Both 'lookup' and 'value' were specified, expected one or the other. Ignoring the value attribute.");
+                } else {
+                    this.write_value(value);
+                }
+
+            } else {
+                throw new Error(`Expected 'value' to be an array, instead got something else (=${value})`);
+            }
+        } else {
+            // retain current value
+        }
+
+        if (lookup !== undefined) {
+            const lut = new ParameterLookupTable();
+
+            lut.fromJSON(lookup);
+
+            this.lookup = lut;
+        } else {
+            this.lookup = null;
+        }
+
+        if (lookup_value !== undefined) {
+            assert.isNumber(lookup_value, 'lookup_value');
+            assert.isFiniteNumber(lookup_value, 'lookup_value');
+
+            if (lookup === undefined) {
+                console.warn("found 'lookup_value' attribute, but no 'lookup' table. Ignoring lookup value");
+            } else {
+                this.lookup_value = lookup_value;
+            }
+        } else if (lookup !== undefined) {
+            // supply a default lookup value
+            this.lookup_value = 0;
+        }
+    }
 }

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

@@ -12,6 +12,7 @@ import { AttributeValue } from "./AttributeValue.js";
 import { PARTICULAR_PARTICLE_SPECIFICATION } from "../../emitter/PARTICULAR_PARTICLE_SPECIFICATION.js";
 import { SerializationMetadata } from "../../../../../../ecs/components/SerializationMetadata.js";
 import { UnitCubeShape3D } from "../../../../../../../core/geom/3d/shape/UnitCubeShape3D.js";
+import { shape_from_json } from "../../../../../../../core/geom/3d/shape/json/shape_from_json.js";
 
 /**
  *
@@ -256,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;
@@ -299,6 +302,7 @@ export class ParticleVolume {
      * @param {number} [particle_size]
      * @param {AbstractShape3D} [shape]
      * @param {boolean} sort
+     * @param {boolean} lighting
      * @param {string} [sprite]
      */
     from({
@@ -306,20 +310,73 @@ 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;
 
         attributes.size.write_value_silent([particle_size]);
     }
 
+    /**
+     *
+     * @param {number} density
+     * @param {boolean} [is_density_size_adjusted]
+     * @param {number} [particle_size]
+     * @param {Object} shape
+     * @param {boolean} [is_sorted]
+     * @param {boolean} [is_lit]
+     * @param {string} sprite
+     * @param {Object<Object>} [attributes]
+     */
+    fromJSON({
+                 density,
+                 is_density_size_adjusted = true,
+                 particle_size = 1,
+                 shape,
+                 is_sorted = true,
+                 is_lit = true,
+                 sprite,
+                 attributes = {}
+             }) {
+
+        const shape_object = shape_from_json(shape);
+
+        const actual_density = is_density_size_adjusted ? density / particle_size : density;
+
+        this.from({
+            density: actual_density,
+            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];
+
+            if (attribute_object === undefined) {
+                console.warn(`No '${attributesKey}' attribute, skipping`);
+            }
+
+            const attribute_json = attributes[attributesKey];
+            attribute_object.fromJSON(attribute_json);
+        }
+    }
+
     /**
      *
      * @private
@@ -352,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);
@@ -369,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/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -328,9 +328,8 @@ async function sample_scene_0(engine) {
         ecd: ecd,
         lut: heatmap_lut_0,
         shape: UnionShape3D.from([
-            TransformedShape3D.from_m4(new UnitCubeShape3D(), [14.980091485108495, 0, 0, 0, 0, 2.812495250139616, 0, 0, 0, 0, 7.469446746375293, 0, 54.83080514238756, 1.568241402881399, 92.51937192481576, 1]),
-            TransformedShape3D.from_m4(new UnitCubeShape3D(), [6.644515553810907, 0, 0, 0, 0, 2.812495250139616, 0, 0, 0, 0, 5.507507223409315, 0, 46.95032009188344, 1.568241402881399, 95.54148649329517, 1]),
-            TransformedShape3D.from_m4(new UnitCubeShape3D(), [23.762890107594952, 0, 0, 0, 0, 2.812495250139616, 0, 0, 0, 0, 34.57956316503163, 0, 55.436098243647756, 1.568241402881399, 113.46988143189215, 1])
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), mat_from_aabb3(new AABB3(67.73, 0, 89, 115.84, 3, 118.34))),
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), mat_from_aabb3(new AABB3(98, 0, 76.5, 109.5, 3, 89)))
         ]),
         particle_size: 2,
         density: 1,

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