@woosh/meep-engine 2.141.0 → 2.143.0

package/src/engine/control/first-person/DESIGN_COLLISION.md

@@ -0,0 +1,255 @@
+# Collision handling — construction plan
+
+Companion to DESIGN.md (base controller) and TODO.md. This is the
+roadmap for taking the controller's collision response from the current
+2.5D split to a unified, slope-aware, anti-tunnelling mover modelled on
+the Quake → Source `TryPlayerMove` / `CategorizePosition` lineage —
+using the now-accurate `shapeCast` / `raycast` the physics engine
+gained over the P1–P6 narrowphase work.
+
+Every phase is **guard-test-first**: write the failing spec that pins
+the behaviour, then implement until green, then run the full
+first-person suite. Phases are ordered so the controller stays shippable
+and tested after each one — no flag day.
+
+---
+
+## 1. Goal & non-goals
+
+**Goal.** A single swept move-and-slide that handles walls, floors,
+ceilings, ramps, and getting unstuck — with true surface normals — so
+abilities (Slide, WallRun, Mantle) inherit correct collision for free
+by routing their motion through it.
+
+**Non-goals.**
+- Bunny-hop / strafe-jump emergent acceleration. We deliberately
+  *preserve* momentum (Mirror's Edge / modern-CoD model), not *amplify*
+  it (Quake / Titanfall model). See the momentum note in DESIGN.md.
+- A full dynamics solver for the player. The player stays a
+  `KinematicPosition` body; the controller owns the Transform.
+- Replacing the abilities' bespoke motion models — only giving them a
+  correct shared mover to call.
+
+---
+
+## 2. Current state (one paragraph)
+
+`_integrateVerticalAndResolveGround` does a **2.5D split**: gravity →
+horizontal-only swept slide (`_moveAndSlide`, 4-iteration collide-and-
+slide, `SKIN = 0.005`, `CAST_STEP_HEIGHT = 0.05`) → a *direct* vertical
+position add → a downward-ray ground resolver that snaps a scalar Y.
+The slide projects against true narrowphase normals (good), but: the
+ground resolver discards the surface normal (no slopes), vertical motion
+isn't swept (tunnels through thin floors, no ceiling detection), corners
+re-project planes independently (no crease/dead-stop), and there's no
+depenetration. Full analysis in the review that preceded this doc.
+
+---
+
+## 3. Physics capabilities we can now lean on
+
+The P1–P6 narrowphase + query work made the two primitives we depend on
+narrowphase-exact. This plan is only feasible because of it.
+
+| Capability | Status | Source |
+|---|---|---|
+| `raycast` exact surface **normal** (sphere/box/capsule/mesh/heightmap) | ✅ landed | refine_ray_hit P1–P3 (`6f931b4`, `5cc2e3e`, `1a2a602`, `4c2292c`) |
+| `shapeCast` true contact **normal at TOI** via MPR (not broadphase −dir) | ✅ landed | MPR normal-recovery in `shape_cast.js` |
+| `shapeCast` **start-in-contact** → returns `t=0` + valid normal | ✅ landed | `shape_cast.js:195`, normal probe `:350` |
+| `shapeCast` analytic slab-narrowing (long-sweep accuracy/perf) | ✅ landed | `shape_cast.js:203` |
+| EPA adaptive tolerance (no silent sub-mm failure) | ✅ landed | P2.2 (`8ff15a6`) |
+| MPR fallback when EPA doesn't converge | ✅ landed | P3.1 (`419b94a`) |
+| box-box edge-edge closest-pair (not centre-midpoint) | ✅ landed | P3.2 (`419b94a`) |
+| capsule-vs-triangle closed-form multi-point manifold | ✅ landed | P1.1c (`eaa75fa`) |
+| GJK separating-axis cache (cheap warm casts) | ✅ landed | P2.1 (`60ca759`) |
+| `overlap(shape,pos,rot,out,off,filter)` → body-id list | ✅ landed | `overlap_shape.js` |
+| `compute_penetration(...)` → depth + B→A direction | ⚠️ **internal-only** | `compute_penetration.js` — not on PhysicsSystem |
+
+Query contract notes the plan relies on:
+- `shapeCast` `result.t` is a **world distance** when the ray direction
+  is unit-length and `tMax = sweepLength` (how `_moveAndSlide` already
+  uses it). New casts must keep that convention.
+- `result.position` is the **swept shape centre**, not the surface
+  contact point. We never need the contact point in this plan; flagged
+  in case edge/foot placement ever does.
+- `result.normal` is the **target's outward** surface normal.
+
+---
+
+## 4. Target architecture
+
+Replace the 2.5D split with a **unified swept solve + ground
+categorize**, the Source pattern:
+
+```
+move(dt):
+  applyGravityToVelocity()                       # vy -= g·dt
+  delta = velocity · dt                          # full 3D, gravity folded in
+  collideAndSlide(delta)                          # swept, all axes, crease-aware
+  categorizeGround()                              # short down-probe → grounded + normal
+  if grounded and walkable: stayOnGround()        # snap to surface, zero vy
+```
+
+Three pieces:
+
+1. **`collideAndSlide(delta)`** — the existing 4-iteration loop,
+   generalised to 3D and made crease-aware (two-plane seam projection,
+   three-plane dead-stop). Gravity is part of `delta`, so floors and
+   ceilings are just contact planes — anti-tunnelling falls out.
+
+2. **`categorizeGround()`** — a short **downward `shapeCast`** (the
+   capsule swept down by `SKIN + groundProbeBand`, e.g. ~6 cm). Returns
+   `{grounded, surfaceY, normal}`. Replaces the scalar-Y resolver as the
+   authoritative ground source when physics is present; the host
+   resolver / flat-ground stays as the no-physics fallback, behind one
+   `_probeGround()` function so callers never branch (uniform flow).
+
+3. **`stayOnGround()`** — when categorize says grounded on a walkable
+   plane, snap `position.y` to `surfaceY` and zero `vy`. This is what
+   kills the SKIN-vs-snap **bounce** (the bug we hit earlier): grounded
+   is a *band test + active snap*, not a strict `y <= testY`
+   inequality, so landing at `floor + SKIN` doesn't re-flag airborne.
+
+Walkability gate: `groundNormal.y >= MIN_WALK_NORMAL` (≈0.7, ~45°). On a
+steeper face the player isn't grounded — they slide, because the slope
+is just another clip plane in `collideAndSlide` and gravity carries them
+down it.
+
+---
+
+## 5. Phased plan
+
+### Phase 1 — Ground normal + slope policy
+*Review gap #1. Highest feel/realism leverage; lowest risk.*
+
+- Add `_probeGround(runtime, bodyTransform) → {grounded, surfaceY, normal}`.
+  Physics path: downward `shapeCast` of the capsule, read `hit.normal`.
+  No-physics path: existing resolver / flat-ground, normal = `(0,1,0)`.
+- Write `state.groundNormal`. Add `MIN_WALK_NORMAL` to config.
+- Reproject grounded horizontal velocity onto the ground plane
+  (`v -= (v·n)·n`) so ramps don't launch (downhill) or clip (uphill).
+- Steep face → not grounded → slides under gravity.
+
+**Guard tests** (new `GroundSlope.spec.js`): walk up a 30° ramp keeps
+speed and stays grounded; stand on shallow slope = grounded with correct
+normal; 60° face = not grounded, player slides downhill, not glued.
+
+**Risk:** low. Self-contained; resolver fallback unchanged for existing
+tests.
+
+### Phase 2 — Crease / corner handling
+*Review gap #3. Cheap correctness win in the existing loop.*
+
+- Track planes hit within one `_moveAndSlide` call. On a second plane
+  that re-violates the first, project the residual onto the seam
+  `normalize(n₁ × n₂)`. On a third plane in one frame, zero the residual
+  (and the into-wall velocity) — Quake's dead-stop.
+
+**Guard tests** (extend `MoveAndSlide.spec.js`): oblique (non-axis)
+inside corner stops cleanly with no residual leak and no tick-to-tick
+chatter; narrow wedge dead-stops instead of squirting through.
+
+**Risk:** low–medium. Pure addition to the slide loop; existing
+single-plane tests must stay green.
+
+### Phase 3 — Unify vertical into the swept solve
+*Review gap #2 (anti-tunnel). The structural change; do it after 1 & 2
+so slope + crease are already trustworthy.*
+
+- Fold gravity-driven vertical into the swept `delta`; remove the direct
+  `position.y += vy·dt` add.
+- Replace the strict-inequality resolver snap with
+  `categorizeGround()` + `stayOnGround()` (§4).
+- Route Slide / WallRun vertical through the same mover (TODO's "ability
+  motion routing" — they stop hand-integrating gravity).
+
+**Guard tests** (new `VerticalSweep.spec.js`): drop from height onto a
+thin physics slab — no tunnelling, lands on top; jump straight into a
+ceiling — stops, doesn't pass through; **the stationary-on-floor case
+stays at y≈0 across 120 ticks** (generalise the earlier no-bounce repro,
+now without an escape pass to mask it).
+
+**Risk:** medium–high. Changes the contract `_integrate…` exposes to
+abilities; they're updated in the same phase. This is the phase most
+likely to surface a physics gap (see §6).
+
+### Phase 4 — Depenetration safety net
+*Review gap #4. Minimal, not the rolled-back ring-buffer escape.*
+
+- One bounded nudge: if the capsule starts a tick overlapping (detect
+  via `shapeCast` `t=0`, or `overlap()`), push out along the contact
+  normal by `depth + SKIN`, capped at ~4 iterations. No ring buffer, no
+  teleport, no rescue signal — just don't stay solid.
+- **Blocked on §6 requirement #1** for a clean depth. Without it, the
+  fallback is a fixed-step nudge along the normal (no exact depth),
+  which is cruder but unblocks the phase.
+
+**Guard tests** (new `Depenetration.spec.js`): spawn the player
+straddling a box surface → within a few ticks they're outside; a body
+that spawns on top of a standing player → player ends up clear; deep
+burial terminates (no infinite loop), doesn't teleport.
+
+**Risk:** low if requirement #1 lands; medium otherwise (cruder nudge
+needs more tuning).
+
+### Phase 5 — Real step-up *(optional / deferrable)*
+*Review gap #5.*
+
+- Source-style `raise → move → trace-down` for stairs above the 5 cm
+  implicit step, OR keep stairs as the Mantle ability's job and document
+  the curb ceiling. Likely **defer** — Mantle already covers ledges; a
+  decision, not necessarily code.
+
+---
+
+## 6. Unsatisfied physics requirements
+
+Things I'd want from the physics engine to build §5 cleanly. None block
+Phases 1–3; #1 shapes Phase 4.
+
+1. **Public penetration/contact query — `PhysicsSystem.computePenetration`
+   (or `contact`).** `compute_penetration(out_dir, shapeA, posA, rotA,
+   shapeB, posB, rotB) → depth` already exists and is exactly right, but
+   it's an **internal narrowphase utility, not exposed** on
+   `PhysicsSystem`. Phase 4 depenetration wants `{normal, depth}` for the
+   player capsule vs each overlapping body. Today I can get the *fact* of
+   overlap (`overlap()` → ids) and a *normal* (`shapeCast` `t=0`), but
+   **not the depth** — `shapeCast` discards it at `t=0`. Wiring this
+   through is small (the function is written and tested) and is the
+   single highest-value API add for the controller. **Priority: HIGH.**
+
+2. **`overlap()` that can optionally emit per-body `{normal, depth}`,
+   not just ids.** Subsumed by #1 if I call `computePenetration` per
+   returned id — acceptable. Only worth doing natively if profiling
+   shows the per-body re-query matters. **Priority: LOW** (covered by #1).
+
+3. **Contact *point* (not just swept-centre) from `shapeCast`.** Not
+   needed for this plan, but any future foot-placement / ledge-edge or
+   multi-point ground balancing wants the world contact point.
+   `result.position` is the swept centre today. **Priority: LOW.**
+
+4. **Multi-contact ground manifold from one query.** `shapeCast` returns
+   the single closest-`t` contact. A capsule straddling the seam between
+   two boxes gets one normal, not both — fine for v1 grounded snap, a
+   limitation for precise edge-balancing. **Priority: LOW.**
+
+If only one thing gets built: **#1**. It turns Phase 4 from "tune a
+blind nudge" into "push out by the exact reported depth," and it's
+mostly plumbing over code that already exists and is tested.
+
+---
+
+## 7. Constants (ours ← reference lineage)
+
+| Constant | Plan value | Reference | Note |
+|---|---|---|---|
+| slide iterations | 4 | Quake `numbumps` 4 | unchanged |
+| `SKIN` | 0.005 m | Fauerby `veryCloseDistance` ~0.005 | unchanged |
+| `MIN_WALK_NORMAL` | ~0.7 (≈45°) | Quake3 `MIN_WALK_NORMAL` 0.7 / Source `normal.z ≥ 0.7` | **new, Phase 1** |
+| ground-probe band | ~0.06 m | Source `StayOnGround` ~2 u down-snap | **new, Phase 3** |
+| crease dead-stop | zero on 3rd plane | Quake `SV_FlyMove` | **new, Phase 2** |
+| step height | 0.05 m (implicit) | Source `sv_stepsize` 18 u (~0.34 m) | Phase 5 decision |
+
+Overbounce: we keep the clip at effective `1.0` gated on into-wall
+(`v·n < 0`), relying on `SKIN` for clearance, rather than Quake3's
+`OVERCLIP 1.001` nudge. No change planned — equivalent in practice.

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,2BAoCC;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;6BAjZ4B,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() {
@@ -177,7 +187,9 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
 
         const camera = this.__render_camera;
 
-        uniforms.size.value.set(this.__render_target.width, this.__render_target.height);
+        // AO renders at half-res but samples the full-res depth buffer, so `size` is the full (depth)
+        // resolution -- all texel math then lands on depth texel centres rather than texel boundaries
+        uniforms.size.value.set(this.__composit_layer.renderTarget.width, this.__composit_layer.renderTarget.height);
 
         // setup camera
         const near = camera.near;
@@ -192,6 +204,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 +242,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 +382,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 +402,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"}