@woosh/meep-engine 2.140.0 → 2.142.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.140.0",
+  "version": "2.142.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/geom/3d/quaternion/quat3_multiply.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Hamilton product of two unit quaternions: `out = a ⊗ b`.
+ *
+ * Composition order is the usual rotation convention: the product `a ⊗ b`
+ * applies `b` first, then `a` (i.e. `(a⊗b)·v·(a⊗b)* == a·(b·v·b*)·a*`). So to
+ * rotate a vector by `q1` and then by `q2`, compose `q2 ⊗ q1`.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and
+ * the rest of the `core/geom/3d/quaternion/` family.
+ *
+ * `out` may alias neither `a` nor `b` component-wise (the result is computed
+ * from all eight inputs before any write, so passing the same backing array
+ * via different offsets is safe only if the ranges don't overlap).
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number} ax @param {number} ay @param {number} az @param {number} aw
+ * @param {number} bx @param {number} by @param {number} bz @param {number} bw
+ */
+export function quat3_multiply(out: number[] | Float32Array | Float64Array, out_offset: number, ax: number, ay: number, az: number, aw: number, bx: number, by: number, bz: number, bw: number): void;
+//# sourceMappingURL=quat3_multiply.d.ts.map

package/src/core/geom/3d/quaternion/quat3_multiply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_multiply.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_multiply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,oCALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MAAa,MAAM,MAAa,MAAM,MAAa,MAAM,MAC/D,MAAM,MAAa,MAAM,MAAa,MAAM,MAAa,MAAM,QAOzE"}

package/src/core/geom/3d/quaternion/quat3_multiply.js

@@ -0,0 +1,25 @@
+/**
+ * Hamilton product of two unit quaternions: `out = a ⊗ b`.
+ *
+ * Composition order is the usual rotation convention: the product `a ⊗ b`
+ * applies `b` first, then `a` (i.e. `(a⊗b)·v·(a⊗b)* == a·(b·v·b*)·a*`). So to
+ * rotate a vector by `q1` and then by `q2`, compose `q2 ⊗ q1`.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and
+ * the rest of the `core/geom/3d/quaternion/` family.
+ *
+ * `out` may alias neither `a` nor `b` component-wise (the result is computed
+ * from all eight inputs before any write, so passing the same backing array
+ * via different offsets is safe only if the ranges don't overlap).
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number} ax @param {number} ay @param {number} az @param {number} aw
+ * @param {number} bx @param {number} by @param {number} bz @param {number} bw
+ */
+export function quat3_multiply(out, out_offset, ax, ay, az, aw, bx, by, bz, bw) {
+    out[out_offset]     = aw * bx + ax * bw + ay * bz - az * by;
+    out[out_offset + 1] = aw * by - ax * bz + ay * bw + az * bx;
+    out[out_offset + 2] = aw * bz + ax * by - ay * bx + az * bw;
+    out[out_offset + 3] = aw * bw - ax * bx - ay * by - az * bz;
+}

package/src/engine/control/first-person/prototype_first_person_controller.js

@@ -16,6 +16,9 @@ import { CameraSystem } from "../../graphics/ecs/camera/CameraSystem.js";
 import { ShadedGeometry } from "../../graphics/ecs/mesh-v2/ShadedGeometry.js";
 import { ShadedGeometryFlags } from "../../graphics/ecs/mesh-v2/ShadedGeometryFlags.js";
 import { ShadedGeometrySystem } from "../../graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
+import {
+    AmbientOcclusionPostProcessEffect
+} from "../../graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
 import InputController from "../../input/ecs/components/InputController.js";
 import InputControllerSystem from "../../input/ecs/systems/InputControllerSystem.js";
 import { BodyKind } from "../../physics/ecs/BodyKind.js";
@@ -97,6 +100,8 @@ async function main(engine) {
         sunShadowDistance: 30,
     });
 
+    engine.plugins.acquire(AmbientOcclusionPostProcessEffect);
+
     if (em.getSystem(CameraSystem) === null) {
         await em.addSystem(new CameraSystem(engine.graphics));
     }

package/src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AmbientOcclusionPostProcessEffect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js"],"names":[],"mappings":"AAmBA;IAIQ,WAA0C;IAI1C,2BAQE;IA2BF;;;;OAIG;IACH,sBAA0B;IAE1B;;;;OAIG;IACH,2BAA6B;IAG7B;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,wBAA2B;IAE3B,8CAUE;IAEF;;;;OAIG;IACH,uBAAwB;IAExB;;;;OAIG;IACH,eAAgF;IAGpF;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;OAIG;IACH,oBAmBC;IAED,8BAKC;IAED,iBAEC;IAED,2BAuBC;IAED,uBASC;IAED;;;OAGG;IACH,iBAqBC;IAED;;;OAGG;IACH,4BAFW,OAAO,QAiCjB;IAED;;;;OAIG;IACH,gCASC;IAED;;;;OAIG;IACH,mCAUC;IAGD,oCAcC;IAED,wBA2CC;IAED,yBAgBC;CAEJ;6BAtX4B,uCAAuC;+BAD7D,OAAO;6CAAP,OAAO"}
+{"version":3,"file":"AmbientOcclusionPostProcessEffect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js"],"names":[],"mappings":"AAoBA;IAIQ,WAA0C;IAI1C,2BAQE;IAyBF;;;;OAIG;IACH,sBAA0B;IAE1B;;;;OAIG;IACH,2BAA6B;IAG7B;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,wBAA2B;IAE3B,8CAUE;IAEF;;;;OAIG;IACH,uBAAwB;IAExB;;;;;OAKG;IACH,2BASE;IAKF;;;;OAIG;IACH,0BAAwD;IAK5D;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;OAIG;IACH,oBAeC;IAED,iBAEC;IAED,2BAkCC;IAED,uBASC;IAED;;;OAGG;IACH,iBAwBC;IAED;;;OAGG;IACH,4BAFW,OAAO,QAiCjB;IAED;;;;OAIG;IACH,gCASC;IAED;;;;OAIG;IACH,mCAUC;IAGD,oCAcC;IAED,wBA2CC;IAED,yBAiBC;CAEJ;6BA/Y4B,uCAAuC;+BAD7D,OAAO;6CAAP,OAAO"}

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

@@ -14,8 +14,9 @@ import { CompositLayer } from "../../../../composit/CompositLayer.js";
 import { StandardFrameBuffers } from "../../../../StandardFrameBuffers.js";
 import { BlendingType } from "../../../../texture/sampler/BlendingType.js";
 import { renderScreenSpace } from "../../../utils/renderScreenSpace.js";
-import { DepthLimitedBlur } from "../DepthLimitedBlur.js";
+import { generateHilbertNoiseTexture } from "./generateHilbertNoiseTexture.js";
 import { SAOShader } from "./SAOShader.js";
+import { SAOUpscaleShader } from "./SAOUpscaleShader.js";
 
 export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
     constructor() {
@@ -37,11 +38,12 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
 
         // AO parameters
         const uniforms = this.__material.uniforms;
-        uniforms.bias.value = 0.5;
-        uniforms.intensity.value = 2;
 
-        uniforms.kernelRadius.value = 30;
-        uniforms.minResolution.value = 0;
+        // artistic darkening control; 1.0 == physically plausible
+        uniforms.intensity.value = 1.0;
+
+        // sampling hemisphere radius (also the max occluder distance), in world units (scene dependent)
+        uniforms.kernelRadius.value = 0.5;
 
         this.__material.blending = NoBlending;
 
@@ -55,10 +57,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         defines.PERSPECTIVE_CAMERA = 1;
 
         // More samples = better quality
-        defines.NUM_SAMPLES = 13;
-
-        // More rings = better quality
-        defines.NUM_RINGS = 5;
+        defines.NUM_SAMPLES = 24;
 
         /**
          * 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
@@ -109,11 +108,33 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         this.__used_buffers = [];
 
         /**
-         *
-         * @type {DepthLimitedBlur}
+         * Edge-aware upscale + denoise: a single non-separable pass that resolves the half-res AO
+         * into the full-res composit layer using plane-distance weights.
+         * @type {ShaderMaterial}
+         * @private
+         */
+        this.__upscale_material = new ShaderMaterial({
+            defines: Object.assign({}, SAOUpscaleShader.defines),
+            fragmentShader: SAOUpscaleShader.fragmentShader,
+            vertexShader: SAOUpscaleShader.vertexShader,
+            uniforms: UniformsUtils.clone(SAOUpscaleShader.uniforms),
+            glslVersion: GLSL3,
+            depthWrite: false,
+            depthTest: false,
+            blending: NoBlending
+        });
+        this.__upscale_material.extensions.derivatives = true;
+        // depth is stored unpacked, matching the AO material
+        this.__upscale_material.defines.DEPTH_PACKING = 0;
+
+        /**
+         * Hilbert-index permutation LUT, shared by the AO sampling and upscale dithers.
+         * @type {DataTexture}
          * @private
          */
-        this.__blur = new DepthLimitedBlur({ format: RedFormat, clear_color: 0xFFFFFF });
+        this.__hilbert_texture = generateHilbertNoiseTexture(64);
+        this.__material.uniforms.tHilbert.value = this.__hilbert_texture;
+        this.__upscale_material.uniforms.tHilbert.value = this.__hilbert_texture;
     }
 
     /**
@@ -140,29 +161,18 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
     __setCamera(camera) {
         this.__render_camera = camera;
 
-        const material = this.__material;
-        const defines = material.defines;
-
-        if (camera.isPerspectiveCamera === true && defines.PERSPECTIVE_CAMERA !== 1) {
-            defines.PERSPECTIVE_CAMERA = 1;
+        const desired = camera.isPerspectiveCamera === true ? 1 : 0;
 
-            // material has changed and will need to be re-compiled
-            material.needsUpdate = true;
-        } else if (camera.isPerspectiveCamera !== true && defines.PERSPECTIVE_CAMERA !== 0) {
-            defines.PERSPECTIVE_CAMERA = 0;
+        // the AO and upscale materials both reconstruct view-Z, so both track the projection type
+        const materials = [this.__material, this.__upscale_material];
+        for (const material of materials) {
+            if (material.defines.PERSPECTIVE_CAMERA !== desired) {
+                material.defines.PERSPECTIVE_CAMERA = desired;
 
-            // material has changed and will need to be re-compiled
-            material.needsUpdate = true;
+                // material has changed and will need to be re-compiled
+                material.needsUpdate = true;
+            }
         }
-
-        this.__blur.setRenderCamera(camera);
-    }
-
-    initialize(engine) {
-
-        this.__blur.configureMaterials();
-
-        super.initialize(engine);
     }
 
     finalize() {
@@ -192,6 +202,17 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
 
         // trigger uniform update
         material.uniformsNeedUpdate = true;
+
+        // upscale runs at full resolution (the composit layer), reading the half-res AO target
+        const upscale = this.__upscale_material;
+        const upscaleUniforms = upscale.uniforms;
+        const output = this.__composit_layer.renderTarget;
+
+        upscaleUniforms.size.value.set(output.width, output.height);
+        upscaleUniforms.cameraNear.value = near;
+        upscaleUniforms.cameraFar.value = far;
+
+        upscale.uniformsNeedUpdate = true;
     }
 
     __prepare_draw() {
@@ -219,17 +240,20 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
 
         const __old_state_rt = renderer.getRenderTarget();
 
-        // do draw
+        // render AO at half resolution
         renderer.setRenderTarget(this.__render_target);
         renderer.clearColor();
 
         renderScreenSpace(renderer, this.__material);
 
-        //restore rt
-        renderer.setRenderTarget(__old_state_rt);
+        // edge-aware upscale + denoise into the full-res composit layer (single non-separable pass;
+        // the fullscreen draw writes every pixel, so no clear is required)
+        renderer.setRenderTarget(this.__composit_layer.renderTarget);
+
+        renderScreenSpace(renderer, this.__upscale_material);
 
-        // do blur
-        this.__blur.execute(renderer);
+        // restore rt
+        renderer.setRenderTarget(__old_state_rt);
     }
 
     /**
@@ -356,10 +380,10 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
 
         this.__update_render_target_size();
 
-        // configure blur
-        this.__blur.setDepthBuffer(depthTexture);
-        this.__blur.setInput(this.__render_target);
-        this.__blur.setOutput(this.__composit_layer.renderTarget);
+        // bind upscale inputs: half-res AO target + full-res depth
+        const upscaleUniforms = this.__upscale_material.uniforms;
+        upscaleUniforms.tAO.value = this.__render_target.texture;
+        upscaleUniforms.tDepth.value = depthTexture;
 
         return super.startup();
     }
@@ -376,7 +400,8 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         graphics.viewport.size.onChanged.add(this.__update_render_target_size, this);
 
         // release memory
-        this.__blur.dispose();
+        this.__upscale_material.dispose();
+        this.__hilbert_texture.dispose();
         this.__render_target.dispose();
 
         return super.shutdown();

package/src/engine/graphics/render/buffer/simple-fx/ao/SAOShader.d.ts

@@ -1,9 +1,7 @@
 export namespace SAOShader {
     namespace defines {
         let NUM_SAMPLES: number;
-        let NUM_RINGS: number;
         let NORMAL_TEXTURE: number;
-        let DIFFUSE_TEXTURE: number;
         let DEPTH_PACKING: number;
         let PERSPECTIVE_CAMERA: number;
     }
@@ -15,46 +13,38 @@ export namespace SAOShader {
             let value_1: any;
             export { value_1 as value };
         }
-        namespace size {
-            let value_2: Vector2;
+        namespace tHilbert {
+            let value_2: any;
             export { value_2 as value };
         }
-        namespace cameraNear {
-            let value_3: number;
+        namespace size {
+            let value_3: Vector2;
             export { value_3 as value };
         }
-        namespace cameraFar {
+        namespace cameraNear {
             let value_4: number;
             export { value_4 as value };
         }
-        namespace cameraProjectionMatrix {
-            let value_5: Matrix4;
+        namespace cameraFar {
+            let value_5: number;
             export { value_5 as value };
         }
-        namespace cameraInverseProjectionMatrix {
+        namespace cameraProjectionMatrix {
             let value_6: Matrix4;
             export { value_6 as value };
         }
-        namespace intensity {
-            let value_7: number;
+        namespace cameraInverseProjectionMatrix {
+            let value_7: Matrix4;
             export { value_7 as value };
         }
-        namespace bias {
+        namespace intensity {
             let value_8: number;
             export { value_8 as value };
         }
-        namespace minResolution {
+        namespace kernelRadius {
             let value_9: number;
             export { value_9 as value };
         }
-        namespace kernelRadius {
-            let value_10: number;
-            export { value_10 as value };
-        }
-        namespace randomSeed {
-            let value_11: number;
-            export { value_11 as value };
-        }
     }
     let vertexShader: string;
     let fragmentShader: string;

package/src/engine/graphics/render/buffer/simple-fx/ao/SAOShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SAOShader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/ao/SAOShader.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAiC,OAAO;wBAAP,OAAO"}
+{"version":3,"file":"SAOShader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/ao/SAOShader.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAiC,OAAO;wBAAP,OAAO"}