@woosh/meep-engine 3.17.2 → 3.18.0

package/src/shade/renderer/postprocess/PostProcess.js

@@ -31,6 +31,7 @@ export class PostProcess {
         this.ssr.frame_index = frame_index;
     }
 
-    reset_history() {
+    reset_history() {
+        this.ssr.reset_history = true;
     }
 }

package/src/shade/renderer/postprocess/ssr/REPROJECTION_PROPOSAL.md

@@ -0,0 +1,286 @@
+# SSR reprojection proposal
+
+Status: implemented 2026-09-08, with the limitations below. The unused, invalid
+FidelityFX reprojection translation was removed. This document retains the review
+rationale and test plan, followed by implementation and validation details.
+
+## Objective and order of work
+
+Keep reflection history attached to the reflected image under camera motion, while
+rejecting history whose correspondence cannot be established. Prefer a small,
+testable implementation over completing the abandoned denoiser port.
+
+1. Repair history validity, motion-vector selection, and final blend confidence.
+2. Add virtual-image reprojection for coherent, approximately planar reflections.
+3. Add richer motion handling or temporal statistics only when a reproducible scene
+   demonstrates the need. Profile metadata traffic before committing to its format.
+
+The exact geometric guarantee in step 2 is for a static planar ideal mirror and a
+static reflected point under a perspective camera. Roughness, curvature, mixed
+lighting sources, and moving geometry make this an approximation. They must not
+silently inherit the same confidence guarantee.
+
+## Problems identified in the original implementation
+
+- `ssr_reproject_shader.js` uses the largest 3x3 velocity, whereas depth-clip validates
+  the nearest-depth pixel's velocity. Use `depth_clip_validated_velocity()` for the
+  existing surface candidate. This restores agreement with depth-clip; it does not
+  prove that the selected neighboring surface describes the reflection itself.
+- `SSR.reset_history` is not consumed, and `PostProcess.reset_history()` is empty.
+  Implement explicit validity for first use, reset, resize, and skipped rendering.
+  Publish a history generation only after it has been produced successfully. Keep
+  radiance, metadata, previous geometry, and camera state from the same view and
+  frame. Do not infer availability solely from global frame-number parity.
+- Confidence is currently applied before clamp damping and variance reweighting.
+  Apply it to the final normalized history weight, with current weight equal to
+  one minus that result. Hard invalidation must return the current sample before
+  reading or clipping history. Zero times an invalid value is not a safe reset.
+  Treat velocity magnitude as a tuning heuristic, separate from geometric validity.
+- Define the coordinate contract explicitly: pixel centers, internal resolution,
+  UV Y direction, reverse-Z, and each frame's jitter. GPU camera uniforms include
+  projection offsets, while camera velocity uses the underlying camera matrices.
+  Do not assume the existing velocity and a new matrix lookup address the same
+  history grid. Reconstruct from the current raster grid and project into the
+  previous raster grid, adding jitter conversion exactly once where needed.
+
+## Parallax geometry
+
+For camera position C, reflector point P, and Euclidean reflected-ray length L,
+all in world space:
+
+```text
+V = P + normalize(P - C) * L
+virtualUV = project(previousViewProjection, V)
+```
+
+V is the virtual image point behind the mirror. For an ideal planar reflection it
+also equals `H - 2 * N * dot(H - P, N)`, where H is the physical hit and N is the unit
+mirror normal. Projecting H itself addresses the directly visible object, not its
+reflection. Validate clip W and UV bounds before sampling. Invalid hit metadata
+must disable the virtual candidate; a miss is not a valid zero-distance hit.
+
+Keep surface and virtual candidates separate, including their validation results.
+Choose a supported candidate; do not interpolate UVs across unrelated history.
+Prefer virtual correspondence when the reflection is smooth and coherent. A valid
+surface correspondence is only a fallback heuristic for reflection radiance.
+
+For virtual-candidate reflector validation, reconstruct the previous geometry at
+that candidate and compare it to the reflector's local plane and normal in a common
+coordinate system. The corresponding point on a mirror usually changes between
+frames. Comparing against the old location of the current reflector point, or
+comparing virtual depth with G-buffer surface depth, rejects correct parallax.
+Use roughness/material agreement and identity where available. Plane agreement
+alone cannot distinguish disconnected coplanar surfaces.
+
+Validate the radiance sampling footprint too. A valid center does not make adjacent
+Catmull-Rom taps valid. Start with validated bilinear taps, renormalizing only the
+accepted nonnegative weights and rejecting an empty footprint. Keep higher-order
+reconstruction as a measured quality improvement, not a prerequisite for correctness.
+
+## Metadata must describe the signal being accumulated
+
+Resolve already reconstructs hit positions and reuses neighboring traces. Produce
+full-resolution distance plus support/confidence there, using the same accepted
+contributions as radiance. A neighbor's distance from its original ray origin is
+not the distance from the receiving pixel. Reconstruct that distance when reused.
+
+A simple initial policy is to enable virtual reprojection only for a dominant,
+coherent group of finite SSR hits. A representative distance is acceptable within
+that group; substantial distance disagreement or mixed fallback contributions
+reduces support. Two equally weighted depths must not become a trusted imaginary
+surface at their average. Do not average invalid hits into the estimate.
+
+The spatial filter before temporal reprojection also changes the radiance mixture.
+Its accepted contributions must propagate or conservatively reduce metadata support.
+Keeping center metadata while borrowing unrelated neighboring radiance breaks the
+contract just as it does in resolve. This is part of step 2, not optional cleanup.
+
+SSR/environment/LPV mixtures generally do not share one correspondence. Initially
+disable finite-hit reprojection when its support is insufficient and shorten history
+on source transitions. Separate histories and direction-based distant-environment
+reprojection remain possible later; LPV radiance is not necessarily at infinity.
+
+Do not change the packed trace format first. Although it has spare bits, first prove
+which distance the resolved signal requires. Start with explicit metadata and test
+its semantics. Consider half precision/packing afterward using a screen-error budget,
+finite representable ranges, and real scenes at different world scales. One extra
+RG16F history pair alone costs about 16.6 MB at 1920x1080, before previous geometry
+or other transient metadata. Reuse existing frame resources where lifetimes permit.
+
+## Adversarial assessment
+
+| Challenge | Consequence for the design |
+| --- | --- |
+| Mirror is static but the reflected object moves sideways | Mirror depth, normal, and roughness can all agree while virtual correspondence is wrong. Previous hit distance can also agree. Exact handling requires reflected-object motion/previous hit correspondence; otherwise use radiance disagreement or a reactive signal to shorten history and acknowledge residual ambiguity. |
+| Reflector moves or bends | Extending the current ray and projecting with previous camera matrices is insufficient. Support previous reflector geometry/transforms later; do not claim surface velocity alone solves this. |
+| Rough rays alternate between near and far objects | A single distance and large history weight produce false stability. Reduce support for a broad or inconsistent mixture; do not invent a trusted mean depth. |
+| Two mirrors are coplanar with identical normals | Plane/normal tests cannot establish identity. Use available identity and radiance/support checks; ambiguity must reduce confidence. |
+| Only the bilinear center passes depth validation | Invalid adjacent radiance can still bleed through. Validate the actual taps used to reconstruct history. |
+| Stable shader always rejects history | It avoids trails but fails denoising. Include a positive accumulation control, not just rejection tests. |
+| Large motion with accurate correspondence | A fixed 128-pixel cutoff is resolution dependent and discards valid samples. Keep this heuristic separate and tune using pixel uncertainty/footprint rather than treating speed as proof of invalidity. |
+| New moments and counters hide a wrong lookup | More statistical state cannot repair correspondence. Defer that state until the geometry and support contract pass. |
+
+An ordinary reflection G-buffer cannot completely disambiguate all these scenes.
+The first implementation should improve camera parallax without promising exact
+dynamic-scene reconstruction. If motion support is added later, keep it inside
+candidate construction/validation rather than patching the temporal blend.
+
+## Small test plan using the current software tools
+
+Use Vitest with `ComputeShaderEmulator.fromCodeChunk()` for production math helpers,
+`fromImageShader()` for production fragment passes, and `CPUBitmapData` for fixtures.
+Reuse the patterns in `taa/shader_taa.spec.js` and
+`taa/shader_depth_occlusion_clip.spec.js`. Most fixtures need only 16x16 or 32x16
+textures and a few selected pixels; no scene loader, full renderer, golden images,
+or new test framework is required. Use wider textures only when a motion case needs
+an in-bounds lookup. Test behavioral contracts, not shader source text.
+
+| Test group | Small fixture and independent expectation | Failure it should expose |
+| --- | --- | --- |
+| 1. Planar correspondence | Fix physical hit H and a plane. In JS reflect H across the plane, then intersect the current camera-to-image ray with the plane to obtain P and L. Run the production WGSL candidate helper and compare previous UV to an independently projected mirrored H. Parameterize lateral/forward camera movement, an oblique view, and jitter-only motion. Require subpixel error with a stated tolerance, initially 0.05 pixel for ordinary scales. Include stationary and valid L=0 mathematical controls. | Surface sticking, projecting physical H, wrong matrix order, double jitter, UV sign/half-pixel errors. The oracle must not repeat the implementation's ray-extension formula. |
+| 2. Rejection cannot be undone | Put distinct finite colors in current/history, and give current a varied neighborhood so clipping cannot conceal wrong reuse. Exercise history invalidity, off-screen/behind-camera candidate, and zero confidence. Vary current variance from 0 to 10000 while history variance is 0. Require current output for hard rejection; lowering confidence must not increase history influence when other inputs are fixed. | Blend/variance logic restoring rejected history; reset reading stale data; edge clamping masquerading as a valid lookup. |
+| 3. Validate the location actually used | A depth-clip fixture selects a slow center velocity while another neighbor is faster. Distinct history colors distinguish their destinations. Add one two-surface boundary with invalid bright neighboring taps and one valid tap. Assert selected correspondence and absence of invalid-tap influence. | A second dilation after depth-clip, confidence borrowed from the other candidate, unvalidated filtering footprints. |
+| 4. Support follows resolved radiance | Feed tiny resolve/filter fixtures with all misses, a coherent borrowed hit, and two substantially different hit distances or an SSR/fallback transition. Dispatch the production metadata-producing helpers/passes and the pre-temporal filter. Misses have no virtual support, coherent reuse remains eligible, ambiguous mixtures cannot become highly trusted solely by averaging. | Center-ray metadata attached to borrowed/filtered radiance; invalid zeros contaminating distance; source changes keeping stale confidence. |
+| 5. Useful accumulation and lifecycle | Manually ping-pong tiny textures for 8 deterministic frames of the planar scene with balanced synthetic noise; require lower error than raw input against the analytical signal. Then invalidate history and require the current sample. Separately record the real host path with `SoftwareGPUDevice` across first frame, next frame, reset, resize, and a skipped frame; check generation/validity and resource identity. | An always-reject implementation passing the suite; correct helper behavior never wired into SSR; old metadata paired with new radiance. |
+
+Keep these five groups in at most two shader spec files and one host lifecycle spec.
+Add parameter rows only for a newly observed failure. Compile helpers once per file.
+For hard-rejection tests, compare complete output including variance; for valid
+accumulation use error bounds rather than frozen implementation-specific blend values.
+The dynamic reflected-object counterexample is a documented limitation of the first
+phase, not a test that should bless visibly wrong correspondence as correct forever.
+
+### What the emulator can and cannot establish
+
+- Fragment dispatch, matrix/vector helpers, texture loads, and level-zero filtered
+  sampling already work. Manually writing results into the next `CPUBitmapData` is
+  sufficient for temporal sequences.
+- Mip levels are currently ignored by the emulator texture intrinsics. These tests
+  do not validate HZB traversal or roughness-dependent radiance mip selection. Use
+  synthetic accepted hits and level-zero radiance for reprojection tests.
+- `SoftwareGPURenderPassEncoder` records draws and bindings but does not rasterize
+  or write attachment pixels. Use it for host lifecycle/wiring, not image assertions.
+- Derivatives throw in point-wise fragment emulation; workgroup barriers are no-ops.
+  Keep the initial reprojection pass point-wise and express local consistency using
+  explicit neighboring loads. No workgroup-denoiser emulation is needed.
+- Do not assume all GPU numeric and format behavior is reproduced. The current
+  texture-load intrinsic constructs a Float32Array even for integer-backed textures,
+  which can lose packed-u32 low bits. Exercise codecs as direct helper calls rather
+  than claiming packed-trace integration coverage. Float16Array can model explicit
+  half-precision storage when evaluating a future metadata format.
+- Software success does not establish GPU performance, driver validation, or visual
+  quality on curved/rough materials. A small manual mirror/moving-object scene and
+  actual GPU timing remain useful before shipping; no native GPU is required in CI.
+
+## Adversarial probes performed during the initial review
+
+Three temporary adversarial Vitest probes ran successfully through the existing
+emulator (removed after review; permanent regression coverage is described below):
+
+1. Production SSR at zero velocity confidence returned approximately 1.079, 1.098,
+   and 1.100 for current radiance 1 and history 1.1 as current variance increased
+   from 0 to 10 to 10000. An experimental final-confidence gate returned exactly
+   current radiance and variance in all three cases. This checks the suggested
+   ordering, not a complete implementation of lifecycle or invalid-value handling.
+2. With a depth-clip selection of the center pixel, the old helper returned the
+   neighboring 8-pixel vector while `depth_clip_validated_velocity()` returned the
+   selected 1-pixel vector, including an 8-bit-quantized selection value.
+3. A prototype WGSL virtual-point helper matched independently mirrored hit geometry
+   for three camera positions. Moving only the reflected object by one world unit
+   produced 142.86 pixels of lookup error at focal length 1000 pixels and virtual
+   depth 7, despite unchanged mirror geometry. This falsifies the stronger claim
+   that reflector validation alone establishes dynamic reflection correspondence.
+
+## Implemented design and validation
+
+- Resolve emits radiance and an RG32F distance/support attachment in both IBL and
+  LPV paths. Distances are measured from the receiving pixel. Missing, background,
+  off-screen, non-finite, and zero-length hits cannot supply trusted metadata.
+- The first spatial pass propagates weighted distance moments and suppresses
+  support for broad mixtures. The two post-temporal spatial passes retain their
+  radiance-only interface to avoid unnecessary metadata traffic.
+- Temporal reprojection prefers the virtual image for support at least 0.75 and
+  roughness at most 0.2. Four bilinear taps are individually checked against
+  previous depth, world-space reflector plane/normal, roughness, support, and
+  reflected distance. Confidence includes the accepted footprint weight.
+- Surface fallback uses the existing depth-clip velocity selection and a single
+  previous-minus-current raster jitter correction. A failed smooth finite virtual
+  candidate limits surface confidence to one quarter. Radiance disagreement reduces
+  confidence further. These constants are initial heuristics, not geometric proofs.
+- Reset, resize, missing previous depth, skipped frames, and a different view disable
+  history. Radiance, distance/support, and normal/roughness ping-pong together. A
+  generation is committed only after successful graph execution and command
+  submission; abandoned/failed graphs and intervening resets cannot publish it.
+- Existing chunks supply coordinate reconstruction, NDC/UV conversion, depth and
+  material decoding, plane construction/distance, screen bounds, bilinear weights,
+  finite checks, depth-clip velocity, YCoCg conversion/clipping, and statistics.
+  Three SSR-specific chunks hold metadata moments, candidate math/blending, and
+  validated history sampling. No FidelityFX port or duplicate general math library
+  was introduced; the already-used edge-stopping chunks remain in use.
+
+Persistent overhead is **32 bytes per internal pixel** beyond the existing radiance
+pair: an RG32F metadata pair plus an RGBA16F normal/roughness pair. That is about
+**66.4 MB at 1920x1080** (63.3 MiB). Resolve and pre-temporal filtering also produce
+transient RG32F metadata; two such full-size attachments total another 33.2 MB
+before graph lifetime reuse. Previous depth is borrowed from the existing view
+resources. Reducing formats is deliberately deferred until screen-space error and
+GPU bandwidth are measured; this is a material cost of the initial implementation.
+
+Permanent coverage uses three spec files, with 14 tests organized around the five
+small groups above:
+
+- `ssr_reprojection.spec.js`: independent planar mirror oracle, translation,
+  rotation and jitter, hard reset without bound history textures, final-confidence
+  weighting, validated velocity, invalid bilinear taps, depth/normal/roughness/source
+  rejection, camera parallax, and an eight-frame positive denoising control.
+- `ssr_metadata.spec.js`: actual resolve and spatial fragment emulation, all misses,
+  zero-length self hits, borrowed hit distance, fallback/mixed-distance support,
+  plus WGSL validation for both resolve variants, both spatial variants, and temporal.
+- `SSR.spec.js`: real frame-graph/software-device recording through the final
+  spatial passes, matching radiance/metadata/geometry resource identities, resets,
+  resize, skipped frames, view changes, failed/abandoned graphs, and submission timing.
+
+Validation: all 14 SSR tests pass. Related TAA/depth-clip, normal call-site and plane
+chunk suites pass (38 tests, one existing skipped test). Declaration emission is
+clean and all consumer API pins compile. The repository type-error ratchet remains
+blocked at 899 errors against a budget of 897. An in-memory declaration comparison
+with these SSR-related changes reverted yields exactly the same 899 diagnostics:
+no additional consumer-visible type errors are introduced here. The budget was not
+changed.
+
+The software render device validates host recording, not pixels. Actual pixel
+assertions execute production fragment shaders through the emulator. LPV shader
+composition is validated, but its atlas sampling is not exercised by these fixtures.
+The new SSR reflection lab at `src/shade/playground/ssr_reprojection/` renders the
+production IBL path on a native NVIDIA GPU. All six SSR shader variants compile on
+that GPU. Visual controls for parallax/surface/current-frame comparison, moving
+objects, occlusion, camera cuts, resolution and final TAA were exercised. The SSR-off
+control visibly removes the reflected targets. There is still no isolated GPU timing
+or quantitative native image-quality measurement. The emulator limitations above
+still apply. A moving reflected object or curved reflector still
+requires conservative rejection and may retain residual trails; exact dynamic
+reflection correspondence is outside this first implementation.
+
+## Long-term boundary
+
+Keep geometry/candidate construction, candidate validation, and temporal accumulation
+as small independent production helpers. Their contract is a history location,
+support/confidence, and validity; temporal accumulation should not need to know
+whether a location came from SSR, a later ray tracer, or reflected-object motion.
+Keep history ownership and generation on the host explicit. Preserve independent
+geometric oracles and positive accumulation controls as algorithms evolve.
+
+AMD's [reflection denoiser documentation](https://gpuopen.com/manuals/fidelityfx_sdk/techniques/denoiser/)
+describes separate mirror-parallax and surface reprojection paths. The integration
+choices, limitations, and test strategy above are specific to this engine.
+
+The playground README describes the repeatable visual checks and independent
+planar reflection guides. Its comparison modes share production shader code;
+changing mode invalidates history, and Parallax remains the default.
+
+Follow-up visual validation found that zero resolve variance could make spatial
+denoising nearly inert. The first spatial pass now bootstraps variance from local
+luminance and propagates the resulting uncertainty; later passes only consume it.
+A same-frame GPU probe and a zero-variance noisy-input regression now cover actual
+filter effect, not only graph wiring. See the playground README for measurements
+and the remaining sharpness/noise tradeoff. The SSR suite now contains 16 tests.

package/src/shade/renderer/postprocess/ssr/SSR.d.ts

@@ -1,16 +1,23 @@
 export class SSR {
     /**
      *
-     * @param {GraphicsContext} graphics
+     * @param {import("../../GraphicsContext.js").GraphicsContext} graphics
      */
-    constructor(graphics: GraphicsContext);
+    constructor(graphics: import("../../GraphicsContext.js").GraphicsContext);
     frame_index: number;
+    set spatial_denoising_enabled(arg: boolean);
+    /** Toggle the three spatial passes independently of temporal reprojection. @returns {boolean} */
+    get spatial_denoising_enabled(): boolean;
+    set reset_history(arg: boolean);
     /**
      * When set, will disregard history buffer
      * Useful for camera cuts and large scene changes such as scene load
      * @type {boolean}
      */
-    reset_history: boolean;
+    get reset_history(): boolean;
+    set reprojection_mode(arg: number);
+    /** @returns {SSRReprojectionMode} */
+    get reprojection_mode(): number;
     /**
      *
      * @param {number} x
@@ -18,30 +25,59 @@ export class SSR {
      */
     resize(x: number, y: number): void;
     /**
-     *
-     * @param {FrameGraph} graph
-     * @param {number} input_depth
-     * @param {number} input_hzb
-     * @param {number} input_scene_color
-     * @param {number} input_albedo
-     * @param {number} input_pbr
-     * @param {number} input_normal
-     * @param {number} input_velocity
-     * @param {number} input_occlusion
-     * @param {number[]} resolution
-     * @param {number} camera_current
-     * @param {number} camera_previous
-     * @param {GPULightProbeVolume} [lpv]
-     * @param {GPUViewContext} view_ctx
-     * @param {number} [mip] higher mip = lower resolution trace
-     * @returns {{final:number, trace:number, reflections:number, denoised: number}}
+     * Records SSR for one view; history becomes available after successful submission.
+     * @param {object} options
+     * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+     * @param {number} options.input_depth
+     * @param {number} [options.input_depth_previous] Same view and frame as camera_previous
+     * @param {number} options.input_hzb
+     * @param {number} options.input_scene_color
+     * @param {number} options.input_albedo
+     * @param {number} options.input_pbr
+     * @param {number} options.input_normal
+     * @param {number} options.input_velocity
+     * @param {number} options.input_occlusion
+     * @param {number} [options.input_environment]
+     * @param {ArrayLike<number>} options.resolution
+     * @param {number} options.camera_current
+     * @param {number} options.camera_previous
+     * @param {ShadeIndirectLightingMode} [options.indirect_lighting_mode] Explicit GI fallback selection
+     * @param {import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4]
+     * @param {import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv]
+     * @param {import("../../view/GPUViewContext.js").GPUViewContext} [options.view_ctx]
+     * @param {ArrayLike<number>} [options.jitter] Raster jitter in internal pixels
+     * @param {number} [options.mip] Higher mip = lower resolution trace
+     * @returns {{final:number, trace:number, reflections:number, denoised:number, denoised_1:number}}
      */
-    graph_pass({ graph, input_depth, input_hzb, input_scene_color, input_pbr, input_normal, input_velocity, input_occlusion, input_albedo, resolution, camera_current, camera_previous, input_environment, lpv, mip, }: FrameGraph): {
+    graph_pass({ graph, input_depth, input_depth_previous, view_ctx, jitter, input_hzb, input_scene_color, input_pbr, input_normal, input_velocity, input_occlusion, input_albedo, resolution, camera_current, camera_previous, input_environment, indirect_lighting_mode, lpv, brick4, mip, }: {
+        graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+        input_depth: number;
+        input_depth_previous?: number;
+        input_hzb: number;
+        input_scene_color: number;
+        input_albedo: number;
+        input_pbr: number;
+        input_normal: number;
+        input_velocity: number;
+        input_occlusion: number;
+        input_environment?: number;
+        resolution: ArrayLike<number>;
+        camera_current: number;
+        camera_previous: number;
+        indirect_lighting_mode?: ShadeIndirectLightingMode;
+        brick4?: import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap;
+        lpv?: import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume;
+        view_ctx?: import("../../view/GPUViewContext.js").GPUViewContext;
+        jitter?: ArrayLike<number>;
+        mip?: number;
+    }): {
         final: number;
         trace: number;
         reflections: number;
         denoised: number;
+        denoised_1: number;
     };
     #private;
 }
+import { ShadeIndirectLightingMode } from "../../ShadeIndirectLightingMode.js";
 //# sourceMappingURL=SSR.d.ts.map

package/src/shade/renderer/postprocess/ssr/SSR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAcA;IAiBI;;;OAGG;IACH,uCAUC;IAvBD,oBAAgB;IAEhB;;;;OAIG;IACH,eAFU,OAAO,CAEK;IAkBtB;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;eAFoB,MAAM;eAAQ,MAAM;qBAAc,MAAM;kBAAY,MAAM;MAwN7E;;CACJ"}
+{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAiBA;IAyDI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAiB5D;IA1DD,oBAAgB;IAMhB,4CAOC;IATD,iGAAiG;IACjG,yCAA2E;IA0B3E,gCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAbnD,mCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA4C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;QAtBsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QAC8B,sBAAsB,GAA1D,yBAAyB;QAC6D,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAClB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;;eACG,MAAM;eAAQ,MAAM;qBAAc,MAAM;kBAAW,MAAM;oBAAa,MAAM;MAkQ/F;;CACJ;0CAxYyC,oCAAoC"}