@woosh/meep-engine 2.165.6 → 2.166.0

package/src/engine/graphics/particles/particular/engine/utils/volume/AttributeValue.d.ts

@@ -1,16 +1,76 @@
-import Signal from "../../../../../../../core/events/signal/Signal";
-import {ParameterLookupTable} from "../../parameter/ParameterLookupTable";
-
-export class AttributeValue {
-    readonly onValueChange: Signal<void>
-
-    lookup: (ParameterLookupTable | null)
-
-    write_lookup_value(v: number): void
-
-    public lookup_value: number
-
-    write_value(v: number[]): void
-
-    read_value(destination: number[])
-}
+export class AttributeValue {
+    /**
+     * Attribute spec
+     * @type {AttributeSpec}
+     */
+    __spec: AttributeSpec;
+    /**
+     *
+     * @type {number[]}
+     */
+    __value: number[];
+    /**
+     *
+     * @type {ParameterLookupTable}
+     * @private
+     */
+    private __lut;
+    /**
+     *
+     * @type {Signal}
+     */
+    onValueChange: Signal;
+    /**
+     * @param {AttributeSpec} s
+     */
+    set spec(arg: AttributeSpec);
+    /**
+     *
+     * @returns {AttributeSpec}
+     */
+    get spec(): AttributeSpec;
+    /**
+     * Will generate actual typed value storage
+     */
+    init(): void;
+    /**
+     * @param {ParameterLookupTable} v
+     */
+    set lookup(arg: ParameterLookupTable);
+    /**
+     *
+     * @returns {ParameterLookupTable}
+     */
+    get lookup(): ParameterLookupTable;
+    set lookup_value(arg: any);
+    /**
+     *
+     * @param {number} v
+     */
+    write_lookup_value(v: number): void;
+    /**
+     *
+     * @param {number[]} v
+     */
+    write_value_silent(v: number[]): void;
+    /**
+     *
+     * @param {number[]} v
+     */
+    write_value(v: number[]): void;
+    /**
+     *
+     * @param {number[]} destination
+     */
+    read_value(destination: number[]): void;
+    /**
+     *
+     * @param {number[]} [value]
+     * @param {Object} [lookup]
+     * @param {number} [lookup_value]
+     */
+    fromJSON({ value, lookup, lookup_value }?: number[]): void;
+}
+import Signal from "../../../../../../../core/events/signal/Signal.js";
+import { ParameterLookupTable } from "../../parameter/ParameterLookupTable.js";
+//# sourceMappingURL=AttributeValue.d.ts.map

package/src/engine/graphics/particles/particular/engine/utils/volume/SamplingFunctionKind.d.ts

@@ -1,4 +1,6 @@
-export enum SamplingFunctionKind {
-    Random = 0,
-    Grid = 1
-}
+export type SamplingFunctionKind = number;
+export namespace SamplingFunctionKind {
+    let Random: number;
+    let Grid: number;
+}
+//# sourceMappingURL=SamplingFunctionKind.d.ts.map

package/src/engine/graphics/render/buffer/FrameBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FrameBuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/buffer/FrameBuffer.js"],"names":[],"mappings":"AAGA;IAyBI;;;;OAIG;IACH,gBAHW,MAAM,EAWhB;IArCD;;;OAGG;IACH,cAFU,iBAAiB,CAEP;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,EAAE,CAEA;IAElB;;;OAGG;IACH,MAFU,OAAO,CAEQ;IAQrB;;;OAGG;IACH,IAFU,MAAM,CAEJ;IAKhB;;;OAGG;IACH,mBAFa,iBAAiB,+BAA6B,CAI1D;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,wCAEC;IAED;;;;;;OAMG;IACH,4EAFW,WAAW,EAAE,QAYvB;IAED;;;;OAIG;IACH,WAHW,MAAM,KACN,MAAM,QAgBhB;CACJ;kCA1GiC,OAAO;oBACrB,kCAAkC"}
+{"version":3,"file":"FrameBuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/buffer/FrameBuffer.js"],"names":[],"mappings":"AAGA;IAyBI;;;;OAIG;IACH,gBAHW,MAAM,EAWhB;IArCD;;;OAGG;IACH,cAFU,iBAAiB,CAEP;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,EAAE,CAEA;IAElB;;;OAGG;IACH,MAFU,OAAO,CAEQ;IAQrB;;;OAGG;IACH,IAFU,MAAM,CAEJ;IAKhB;;;OAGG;IACH,mBAFa,iBAAiB,+BAA6B,CAI1D;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,wCAEC;IAED;;;;;;OAMG;IACH,4EAFW,WAAW,EAAE,QAYvB;IAED;;;;OAIG;IACH,WAHW,MAAM,KACN,MAAM,QAmBhB;CACJ;kCA7GiC,OAAO;oBACrB,kCAAkC"}

package/src/engine/graphics/render/buffer/FrameBuffer.js

@@ -92,9 +92,12 @@ export class FrameBuffer {
     setSize(x, y) {
         const size = this.size;
 
+        // a render target is a whole number of texels; WebGL truncates fractional dimensions when it
+        // allocates, so round here too, otherwise `renderTarget.width` reports a size the texture does
+        // not have and any texel math built from it is off by up to a texel
         // clamp to 1: a 0-sized attachment trips GL_INVALID_FRAMEBUFFER_OPERATION on clear/draw
-        const w = Math.max(1, x);
-        const h = Math.max(1, y);
+        const w = Math.max(1, Math.floor(x));
+        const h = Math.max(1, Math.floor(y));
 
         if (w === size.x && h === size.y) {
             // nothing changed

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

@@ -1,8 +1,104 @@
-import {EnginePlugin} from "../../../../../plugin/EnginePlugin";
-
-export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
-    /**
-     * Higher value will make AO appear darker, lower values will make it lighter
-     */
-    public intensity: number
-}
+export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
+    __material: ShaderMaterial;
+    /**
+     * 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
+     * @type {boolean}
+     * @private
+     */
+    private __use_normals;
+    /**
+     * Resolution scale at which AO is to be rendered. Higher scale will lead to sharper and better looking results
+     * @type {number}
+     * @private
+     */
+    private __resolution_scale;
+    /**
+     *
+     * @type {CompositLayer}
+     * @private
+     */
+    private __composit_layer;
+    /**
+     *
+     * @type {Camera|null}
+     * @private
+     */
+    private __render_camera;
+    __render_target: WebGLMultisampleRenderTarget;
+    /**
+     *
+     * @type {FrameBuffer[]}
+     * @private
+     */
+    private __used_buffers;
+    /**
+     * 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
+     */
+    private __upscale_material;
+    /**
+     * Hilbert-index permutation LUT, shared by the AO sampling and upscale dithers.
+     * @type {DataTexture}
+     * @private
+     */
+    private __hilbert_texture;
+    /**
+     * Higher value will make AO appear darker, lower values will make it lighter
+     * @param {number} v
+     */
+    set intensity(arg: number);
+    /**
+     *
+     * @return {number}
+     */
+    get intensity(): number;
+    /**
+     *
+     * @param {Camera} camera
+     * @private
+     */
+    private __setCamera;
+    /**
+     *
+     * @param {GraphicsEngine} graphics
+     * @private
+     */
+    private __prepare_uniforms;
+    __prepare_draw(): void;
+    /**
+     *
+     * @private
+     */
+    private __render;
+    /**
+     *
+     * @param {boolean} value
+     */
+    setNormalBufferUsage(value: boolean): void;
+    /**
+     *
+     * @param {FrameBuffer} buffer
+     * @private
+     */
+    private __add_used_frame_buffer;
+    /**
+     *
+     * @param {FrameBuffer} buffer
+     * @private
+     */
+    private __remove_used_frame_buffer;
+    /**
+     * Give back every frame buffer reference this plugin holds. `__use_normals` is deliberately left
+     * alone, so a subsequent {@link AmbientOcclusionPostProcessEffect#startup} re-acquires the same
+     * buffers through {@link AmbientOcclusionPostProcessEffect#setNormalBufferUsage}.
+     * @private
+     */
+    private __release_used_frame_buffers;
+    __update_render_target_size(): void;
+}
+import { EnginePlugin } from "../../../../../plugin/EnginePlugin.js";
+import { ShaderMaterial } from "three";
+import { WebGLMultisampleRenderTarget } from "three";
+//# sourceMappingURL=AmbientOcclusionPostProcessEffect.d.ts.map

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":"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,oCAiBC;IAED,wBA2CC;IAED,yBAiBC;CAEJ;6BApZ4B,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;IAQQ,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;IAMD;;;;OAIG;IACH,2BA2CC;IAED,uBASC;IAED;;;OAGG;IACH,iBAwBC;IAED;;;OAGG;IACH,4BAFW,OAAO,QAiCjB;IAED;;;;OAIG;IACH,gCASC;IAED;;;;OAIG;IACH,mCAUC;IAED;;;;;OAKG;IACH,qCAQC;IAGD,oCAiBC;CAuEJ;6BArb4B,uCAAuC;+BAD7D,OAAO;6CAAP,OAAO"}

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

@@ -179,7 +179,12 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         super.finalize();
     }
 
-    __prepare_uniforms() {
+    /**
+     *
+     * @param {GraphicsEngine} graphics
+     * @private
+     */
+    __prepare_uniforms(graphics) {
 
         const material = this.__material;
 
@@ -188,8 +193,14 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         const camera = this.__render_camera;
 
         // 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);
+        // resolution -- all texel math then lands on depth texel centres rather than texel boundaries.
+        // Read it from `output_resolution`, the value the depth frame buffer is itself sized from:
+        // deriving it from any other buffer only holds while that buffer agrees, and a `size` that
+        // disagrees with the depth texture collapses the reconstructed normals (neighbour taps land
+        // inside the centre texel, so every depth delta reads as zero).
+        const output_resolution = graphics.output_resolution;
+
+        uniforms.size.value.copy(output_resolution);
 
         // setup camera
         const near = camera.near;
@@ -205,12 +216,13 @@ 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
+        // upscale runs at full resolution (the composit layer), reading the half-res AO target. `size`
+        // must be the same full-res grid the AO pass used, since the upscale reproduces its depth-texel
+        // snapping to judge each tap
         const upscale = this.__upscale_material;
         const upscaleUniforms = upscale.uniforms;
-        const output = this.__composit_layer.renderTarget;
 
-        upscaleUniforms.size.value.set(output.width, output.height);
+        upscaleUniforms.size.value.copy(output_resolution);
         upscaleUniforms.cameraNear.value = near;
         upscaleUniforms.cameraFar.value = far;
 
@@ -224,7 +236,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
 
         this.__setCamera(camera);
 
-        this.__prepare_uniforms();
+        this.__prepare_uniforms(graphics);
 
     }
 
@@ -328,6 +340,22 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         this.__used_buffers.splice(i, 1);
     }
 
+    /**
+     * Give back every frame buffer reference this plugin holds. `__use_normals` is deliberately left
+     * alone, so a subsequent {@link AmbientOcclusionPostProcessEffect#startup} re-acquires the same
+     * buffers through {@link AmbientOcclusionPostProcessEffect#setNormalBufferUsage}.
+     * @private
+     */
+    __release_used_frame_buffers() {
+        const buffers = this.__used_buffers;
+
+        for (const buffer of buffers) {
+            buffer.referenceCount--;
+        }
+
+        buffers.length = 0;
+    }
+
 
     __update_render_target_size() {
         const engine = this.engine;
@@ -404,7 +432,12 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         this.__composit_layer.on.preRender.remove(this.__render, this);
         graphics.output_resolution.onChanged.remove(this.__update_render_target_size, this);
 
+        // hand back the frame buffers we pinned, otherwise FrameBufferManager keeps rendering them
+        // for a plugin that is no longer there
+        this.__release_used_frame_buffers();
+
         // release memory
+        this.__material.dispose();
         this.__upscale_material.dispose();
         this.__hilbert_texture.dispose();
         this.__render_target.dispose();

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

@@ -1,17 +1,29 @@
 import { Vector2 } from 'three';
 
 /**
- * Edge-aware upscale + denoise for the half-resolution SAO buffer.
+ * Depth-aware upscale + denoise for the half-resolution SAO buffer.
  *
- * A single non-separable pass (separable bilateral filters leak across diagonal silhouettes). Each
- * tap is weighted by its distance to the *plane* of the centre pixel, modelled from the screen-space
- * depth gradient (ReBLUR-style): slanted surfaces are predicted correctly, so only genuine depth
- * discontinuities are rejected -- no normal buffer and no hand-tuned raw-depth tolerance. The
- * geometry tolerance is intentionally tight so background occlusion never bleeds into the foreground
- * or vice versa.
+ * A single non-separable pass (separable bilateral filters leak across diagonal silhouettes),
+ * reworked 2026-07-22 into a nearest-depth-style upsample. The previous version sampled tAO
+ * BILINEARLY (an unconditional weight-1 centre tap plus bilinear disk taps): at a geometry
+ * silhouette the hardware bilinear mixes AO texels from both sides of the depth step inside a
+ * single fetch, which no downstream weight can undo -- and silhouettes are exactly where the disk
+ * taps get depth-rejected, degenerating the output to that contaminated centre tap: a staircase
+ * tracing the half-res texel grid. Low-contrast AO mostly hides this; a high-contrast consumer of
+ * the same recipe (nekomancer's ground fog, bright fog behind dark props) made it plainly visible.
  *
- * Taps follow a Vogel disk rotated per pixel by an R2 blue-noise angle, which both spreads the
- * gather as a dithered (non-grid) pattern and pairs with the R2-rotated sampling kernel in SAOShader.
+ * Now every tap (centre included) SNAPS to an AO texel, texelFetches it unfiltered, and is
+ * weighted by its screen distance AND by comparing the depth THAT TEXEL'S AO PASS ACTUALLY USED
+ * (SAOShader snaps its centre to the containing full-res depth texel; reproduced here) against
+ * the *plane* of the centre pixel, modelled from the clamped screen-space depth gradient
+ * (ReBLUR-style): slanted surfaces are predicted correctly, only genuine depth discontinuities
+ * are rejected -- no normal buffer and no hand-tuned raw-depth tolerance -- and the AO edge lands
+ * on the full-res geometry edge. A nearest-in-depth fallback covers pixels whose depth no AO
+ * texel sampled (thin silhouettes).
+ *
+ * Taps follow a Vogel disk rotated per pixel by an R2 blue-noise angle, which spreads the gather
+ * as a dithered (non-grid) pattern, pairs with the R2-rotated sampling kernel in SAOShader, and
+ * dithers away the tap-to-texel snapping.
  */
 
 const SAOUpscaleShader = {
@@ -96,15 +108,21 @@ const SAOUpscaleShader = {
 
 			float zc = getViewZ( centerDepth );
 
+			// plane-distance tolerance scales with view depth (footprint and depth precision grow with
+			// distance); smaller depthSigma = tighter fg/bg separation
+			float tol = max( EPSILON, depthSigma * abs( zc ) );
+			float invSigma = 1.0 / tol;
+
 			// screen-space depth gradient defines the centre pixel's plane; predicting a tap's depth
-			// from it means slanted surfaces are not rejected, only true discontinuities are
-			vec2 dz = vec2( dFdx( zc ), dFdy( zc ) );
+			// from it means slanted surfaces are not rejected, only true discontinuities are. The slope
+			// is CLAMPED to the depth tolerance per pixel: at a silhouette the quad derivative spans
+			// the whole fg/bg depth gap, and an unclamped plane would "predict" that gap as legitimate
+			// slant, re-admitting cross-edge taps.
+			vec2 dz = clamp( vec2( dFdx( zc ), dFdy( zc ) ), - tol, tol );
 
 			vec2 texel = 1.0 / size;
-
-			// plane-distance tolerance scales with view depth (footprint and depth precision grow with
-			// distance); smaller depthSigma = tighter fg/bg separation
-			float invSigma = 1.0 / max( EPSILON, depthSigma * abs( zc ) );
+			vec2 aoSize = vec2( textureSize( tAO, 0 ) );
+			ivec2 aoMax = ivec2( aoSize ) - 1;
 
 			// per-pixel rotation of the Vogel tap set -> dithered, non-separable gather. Hilbert-curve
 			// permutation index through Marty's R2 sequence (matches the AO sampling dither).
@@ -114,36 +132,59 @@ const SAOUpscaleShader = {
 			float spatialSigma = blurRadius * 0.5;
 			float invSpatial2 = 1.0 / ( 2.0 * spatialSigma * spatialSigma );
 
-			// centre tap
-			float sum = texture2D( tAO, vUv ).x;
-			float wsum = 1.0;
-
-			for ( int i = 0; i < NUM_TAPS; i ++ ) {
-				// Vogel-disk offset in output pixels, rotated per pixel
-				float fi = float( i ) + 0.5;
-				float r = sqrt( fi / float( NUM_TAPS ) ) * blurRadius;
-				float theta = fi * 2.39996323 + rot;       // golden angle
-				vec2 o = r * vec2( cos( theta ), sin( theta ) );
-
-				vec2 tapUv = vUv + o * texel;
-
-				if ( tapUv.x < 0.0 || tapUv.x > 1.0 || tapUv.y < 0.0 || tapUv.y > 1.0 ) continue;
-
-				float zt = getViewZ( getDepth( tapUv ) );
-
-				// distance from the tap to the centre pixel's plane
-				float planeDist = abs( zt - ( zc + dot( dz, o ) ) );
+			float sum = 0.0;
+			float wsum = 0.0;
+
+			// nearest-in-depth tap: fallback when every tap rejects (a pixel whose depth no AO texel
+			// sampled, e.g. a thin silhouette)
+			float nearestAO = 1.0;
+			float nearestDist = 1e30;
+
+			for ( int i = 0; i <= NUM_TAPS; i ++ ) {
+				// tap 0 is the pixel's own containing AO texel; 1..NUM_TAPS are the Vogel disk,
+				// offset in output pixels, rotated per pixel
+				vec2 o = vec2( 0.0 );
+				if ( i != 0 ) {
+					float fi = float( i ) - 0.5;
+					float r = sqrt( fi / float( NUM_TAPS ) ) * blurRadius;
+					float theta = fi * 2.39996323 + rot;       // golden angle
+					o = r * vec2( cos( theta ), sin( theta ) );
+				}
+
+				// SNAP to an AO texel and fetch it UNFILTERED -- hardware bilinear would mix occlusion
+				// across the fg/bg step inside a single fetch, which no weight can undo. Clamping to
+				// the buffer edge extends border texels instead of dropping the tap.
+				ivec2 tc = clamp( ivec2( ( vUv + o * texel ) * aoSize ), ivec2( 0 ), aoMax );
+				vec2 tapUv = ( vec2( tc ) + 0.5 ) / aoSize;
+
+				// the depth THE AO PASS USED for this texel: SAOShader snaps its centre to the
+				// containing full-res depth texel (its centerUv), reproduced here so the weight judges
+				// the tap by the geometry its occlusion was actually computed for
+				vec2 marchUv = ( floor( tapUv * size ) + 0.5 ) * texel;
+				float zt = getViewZ( getDepth( marchUv ) );
+
+				// distance from that depth to the centre pixel's plane; the offset is re-derived from
+				// the snapped texel centre so both weights match the texel actually fetched
+				vec2 oPx = ( tapUv - vUv ) * size;
+				float planeDist = abs( zt - ( zc + dot( dz, oPx ) ) );
 
 				float wGeom = exp( - planeDist * planeDist * invSigma * invSigma );
-				float wSpatial = exp( - dot( o, o ) * invSpatial2 );
+				float wSpatial = exp( - dot( oPx, oPx ) * invSpatial2 );
 
 				float w = wGeom * wSpatial;
 
-				sum += w * texture2D( tAO, tapUv ).x;
+				float ao = texelFetch( tAO, tc, 0 ).x;
+				sum += w * ao;
 				wsum += w;
+
+				if ( planeDist < nearestDist ) {
+					nearestDist = planeDist;
+					nearestAO = ao;
+				}
 			}
 
-			out_occlusion = sum / wsum;
+			// every tap rejected -> take the closest-in-depth texel rather than a contaminated blend
+			out_occlusion = wsum > 1e-4 ? sum / wsum : nearestAO;
 		}`
 
 };

package/src/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.d.ts

@@ -17,9 +17,6 @@ export class TemporalSupersamplingRenderPlugin extends EnginePlugin {
     };
     __hook_post_render(): void;
     initialize(engine: any): void;
-    finalize(): void;
-    startup(): Promise<any>;
-    shutdown(): Promise<any>;
 }
 import { EnginePlugin } from "../../../../../plugin/EnginePlugin.js";
 //# sourceMappingURL=TemporalSupersamplingRenderPlugin.d.ts.map

package/src/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TemporalSupersamplingRenderPlugin.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.js"],"names":[],"mappings":"AAIA;IAIQ;;;;OAIG;IACH,sBAAsB;IAEtB,uBAAwB;IACxB,8BAAkE;IAGlE;QACI;;;;WAIG;2BAFQ,MAAM,EAAE,UACR,MAAM,EAAE;MAkBtB;IAGL,2BAIC;IAED,8BAEC;IAED,iBAEC;IAED,wBAWC;IAED,yBAKC;CACJ;6BA3E4B,uCAAuC"}
+{"version":3,"file":"TemporalSupersamplingRenderPlugin.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.js"],"names":[],"mappings":"AAIA;IAIQ;;;;OAIG;IACH,sBAAsB;IAEtB,uBAAwB;IACxB,8BAAkE;IAGlE;QACI;;;;WAIG;2BAFQ,MAAM,EAAE,UACR,MAAM,EAAE;MAwBtB;IAGL,2BAIC;IAED,8BAEC;CAyBJ;6BAjF4B,uCAAuC"}

package/src/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.js

@@ -25,8 +25,14 @@ export class TemporalSupersamplingRenderPlugin extends EnginePlugin {
              */
             transform: (input, output) => {
 
-                const viewport_width = this.engine.graphics.viewport.size.x;
-                const viewport_height = this.engine.graphics.viewport.size.y;
+                // device pixels, not CSS pixels: the whole point of the jitter is to move the sample
+                // by a fraction of a texel of the buffer being accumulated, and that buffer is sized
+                // from `output_resolution`. Dividing by the CSS size would scale the jitter by the
+                // pixel ratio -- over a texel wide above 1, and too small to resolve anything below it
+                const output_resolution = this.engine.graphics.output_resolution;
+
+                const render_width = output_resolution.x;
+                const render_height = output_resolution.y;
 
                 // apply jitter to projection matrix
                 const jitter_index = this.__frame_index % this.__sample_count;
@@ -36,8 +42,8 @@ export class TemporalSupersamplingRenderPlugin extends EnginePlugin {
 
                 array_copy(input, 0, output, 0, 16);
 
-                output[8] = jitter_offset_x / viewport_width;
-                output[9] = jitter_offset_y / viewport_height;
+                output[8] = jitter_offset_x / render_width;
+                output[9] = jitter_offset_y / render_height;
             }
         };
     }

package/src/engine/graphics/render/forward_plus/LightManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/forward_plus/LightManager.js"],"names":[],"mappings":"AAoIA;IAiBQ;;;;OAIG;IACH,2BAAgD;IAEhD,oCAAoC;IACpC,yCAA4C;IAE5C;;;;;;;;OAQG;IACH,0BAKC;IAaD;;;;;OAKG;IACH,+BAAoD;IAMpD;;;;;OAKG;IACH,8BAAmD;IAMnD;;;;OAIG;IACH,uCAAiF;IAWjF;;;;;OAKG;IACH,+BAEE;IAEF;;;;OAIG;IACH,iCAA8E;IAE9E;;;;OAIG;IACH,2BAAmC;IAEnC;;;;;OAKG;IACH,kCAAoE;IACpE;;;;;OAKG;IACH,kCAAoE;IAEpE;;;;OAIG;IACH,gCAAiC;IAEjC;;;;OAIG;IACH,6BAAiD;IACjD;;;;OAIG;IACH,6BAAiD;IAEjD;;;;OAIG;IACH,uBAAmC;IAEnC;;;;OAIG;IACH,8BAAiD;IAEjD;;;;OAIG;IACH,4BAA+C;IAG/C;;;;OAIG;IACH,yBAA2C;IAE3C;;;;OAIG;IACH,iCAAmD;IAUnD;;;;;OAKG;IACH,kCAAqC;IAErC;;;;OAIG;IACH,mCAAsC;IAK1C,0BAEC;IAED;;;;;;OAMG;IACH,0CAQC;IAED;;;OAGG;IACH,uCAEC;IAED,qCAQC;IAED;;;;;;OAMG;IACH,4CAgBC;IAED,iCAIC;IAED,gCA6BC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;OAGG;IACH,oBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,kBAFa,WAAW,CAIvB;IAED;;OAEG;IACH,sBAFa,aAAa,CAIzB;IAED;;OAEG;IACH,wBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,iBAFa,SAAS,OAAO,CAAC,CAI7B;IAED;;;OAGG;IACH,yCAKC;IAED;;;OAGG;IACH,yCAGC;IAED;;;;OAIG;IACH,qCAyBC;IAED;;;;OAIG;IACH,uCA8BC;IAED;;;;OAIG;IACH,qCAOC;IAED;;;;OAIG;IACH,uCAMC;IAED;;;;;OAKG;IACH,4CAJW,mBAAmB,GACjB,MAAM,CAalB;IAED;;;;;;OAMG;IACH,+BAgCC;IAED;;;OAGG;IACH,6BAoBC;IAED,6BAYC;IAGD;;;;OAIG;IACH,6BAMC;IAED,mCA0EC;IAED,mCAgFC;IAED;;;OAGG;IACH,oCA+IC;IAED;;;OAGG;IACH,uCAUC;IAED;;;OAGG;IACH,oCAOC;IAED;;;OAGG;IACH,uCAWC;IAED;;;OAGG;IACH,mBAFW,SAAO,MAAM,iBAAiB,QAmDxC;IAED,gBAKC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,KACN,MAAM,QA2ChB;IAED;;;;OAIG;IACH,gCAFa,OAAO,CAInB;IAED;;;OAGG;IACH,qCAMC;IAED;;;;OAIG;IACH,mCAFa,OAAO,CAiBnB;;CACJ;4BAlsCM,OAAO;8BAAP,OAAO;oBAkBM,kCAAkC;oCAiBlB,0BAA0B"}
+{"version":3,"file":"LightManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/forward_plus/LightManager.js"],"names":[],"mappings":"AAoIA;IAiBQ;;;;OAIG;IACH,2BAAgD;IAEhD,oCAAoC;IACpC,yCAA4C;IAE5C;;;;;;;;OAQG;IACH,0BAKC;IAaD;;;;;OAKG;IACH,+BAAoD;IAMpD;;;;;OAKG;IACH,8BAAmD;IAMnD;;;;OAIG;IACH,uCAAiF;IAWjF;;;;;OAKG;IACH,+BAEE;IAEF;;;;OAIG;IACH,iCAA8E;IAE9E;;;;OAIG;IACH,2BAAmC;IAEnC;;;;;OAKG;IACH,kCAAoE;IACpE;;;;;OAKG;IACH,kCAAoE;IAEpE;;;;OAIG;IACH,gCAAiC;IAEjC;;;;OAIG;IACH,6BAAiD;IACjD;;;;OAIG;IACH,6BAAiD;IAEjD;;;;OAIG;IACH,uBAAmC;IAEnC;;;;OAIG;IACH,8BAAiD;IAEjD;;;;OAIG;IACH,4BAA+C;IAG/C;;;;OAIG;IACH,yBAA2C;IAE3C;;;;OAIG;IACH,iCAAmD;IAUnD;;;;;OAKG;IACH,kCAAqC;IAErC;;;;OAIG;IACH,mCAAsC;IAK1C,0BAEC;IAED;;;;;;OAMG;IACH,0CAQC;IAED;;;OAGG;IACH,uCAEC;IAED,qCAQC;IAED;;;;;;OAMG;IACH,4CAgBC;IAED,iCAIC;IAED,gCA6BC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;OAGG;IACH,oBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,kBAFa,WAAW,CAIvB;IAED;;OAEG;IACH,sBAFa,aAAa,CAIzB;IAED;;OAEG;IACH,wBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,iBAFa,SAAS,OAAO,CAAC,CAI7B;IAED;;;OAGG;IACH,yCAKC;IAED;;;OAGG;IACH,yCAGC;IAED;;;;OAIG;IACH,qCAyBC;IAED;;;;OAIG;IACH,uCA8BC;IAED;;;;OAIG;IACH,qCAOC;IAED;;;;OAIG;IACH,uCAMC;IAED;;;;;OAKG;IACH,4CAJW,mBAAmB,GACjB,MAAM,CAalB;IAED;;;;;;OAMG;IACH,+BAgCC;IAED;;;OAGG;IACH,6BAuBC;IAED,6BAYC;IAGD;;;;OAIG;IACH,6BAMC;IAED,mCA0EC;IAED,mCAgFC;IAED;;;OAGG;IACH,oCA+IC;IAED;;;OAGG;IACH,uCAUC;IAED;;;OAGG;IACH,oCAOC;IAED;;;OAGG;IACH,uCAWC;IAED;;;OAGG;IACH,mBAFW,SAAO,MAAM,iBAAiB,QAmDxC;IAED,gBAKC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,KACN,MAAM,QA2ChB;IAED;;;;OAIG;IACH,gCAFa,OAAO,CAInB;IAED;;;OAGG;IACH,qCAMC;IAED;;;;OAIG;IACH,mCAFa,OAAO,CAiBnB;;CACJ;4BArsCM,OAAO;8BAAP,OAAO;oBAkBM,kCAAkC;oCAiBlB,0BAA0B"}