@zephyr3d/scene 0.9.22 → 0.9.23

package/dist/camera/camera.js

@@ -1,7 +1,8 @@
-import { halton23, Matrix4x4, Vector4, DRef, Vector2, Vector3, Ray, Frustum } from '@zephyr3d/base';
+import { halton23, Matrix4x4, Vector4, DEPTH_CLEAR_VALUE, DRef, Vector2, REVERSE_Z, Vector3, Ray, Frustum } from '@zephyr3d/base';
 import { SceneNode } from '../scene/scene_node.js';
 import { Compositor } from '../posteffect/compositor.js';
 import { TAA } from '../posteffect/taa.js';
+import { SSGI } from '../posteffect/ssgi.js';
 import { SSR } from '../posteffect/ssr.js';
 import { SSS } from '../posteffect/sss.js';
 import { SkinSSS } from '../posteffect/skinsss.js';
@@ -16,7 +17,29 @@ import { ScreenAdapter } from '../app/screen.js';
 import { ABufferOIT } from '../render/abuffer_oit.js';
 import { WeightedBlendedOIT } from '../render/weightedblended_oit.js';
 import { DualDepthPeelingOIT } from '../render/dualdepthpeeling_oit.js';
+import { RGHistoryResources } from '../render/rendergraph/history_resources.js';
+import { calculateEV100, calculatePhysicalExposure } from '../utility/physical.js';
 
+const SSGI_QUALITY_PRESET_SETTINGS = {
+    quality: {
+        halfRes: false,
+        raysPerPixel: 2,
+        maxSteps: 64,
+        denoisePasses: 4
+    },
+    balanced: {
+        halfRes: true,
+        raysPerPixel: 1,
+        maxSteps: 48,
+        denoisePasses: 4
+    },
+    performance: {
+        halfRes: true,
+        raysPerPixel: 1,
+        maxSteps: 24,
+        denoisePasses: 4
+    }
+};
 const SSS_DEFAULT_SETTINGS = {
     blurScale: 11,
     strength: 0.65,
@@ -103,6 +126,11 @@ const SSS_QUALITY_PRESET_SETTINGS = {
     /** @internal Tonemap enable flag (via post effect). */ _toneMap;
     /** @internal Tonemap post effect reference. */ _postEffectTonemap;
     /** @internal Tonemap exposure. */ _tonemapExposure;
+    /** @internal Lens aperture expressed as an f-number. */ _aperture;
+    /** @internal Shutter-open time in seconds. */ _shutterSpeed;
+    /** @internal Sensor sensitivity. */ _ISO;
+    /** @internal Exposure compensation in stops. */ _exposureCompensation;
+    /** @internal Lighting mode currently reflected by the post effect ordering. */ _postProcessingLightingMode;
     /** @internal Motion blur enable flag (via post effect). */ _motionBlur;
     /** @internal Motion blur post effect reference. */ _postEffectMotionBlur;
     /** @internal Motion blur strength. */ _motionBlurStrength;
@@ -138,6 +166,22 @@ const SSS_QUALITY_PRESET_SETTINGS = {
     /** @internal SSR Gaussian blur standard deviation. */ _ssrBlurStdDev;
     /** @internal Whether SSR temporal accumulation is enabled. */ _ssrTemporal;
     /** @internal SSR temporal blending weight in [0, 1]. */ _ssrTemporalWeight;
+    /** @internal SSGI enable flag (via post effect). */ _SSGI;
+    /** @internal SSGI post effect reference. */ _postEffectSSGI;
+    /** @internal SSGI quality preset. */ _ssgiQualityPreset;
+    /** @internal Resolved SSGI trace/denoise settings. */ _ssgiResolvedSettings;
+    /** @internal SSGI irradiance composite strength. */ _ssgiIntensity;
+    /** @internal Strength of the ambient occlusion traced alongside SSGI. */ _ssgiAOIntensity;
+    /** @internal Contrast curve of the SSGI ambient occlusion. */ _ssgiAOPower;
+    /** @internal Fraction of environment irradiance removed by an occluding hit. */ _ssgiSkyOcclusion;
+    /** @internal Maximum view-space ray distance. */ _ssgiMaxDistance;
+    /** @internal Ray hit thickness. */ _ssgiThickness;
+    /** @internal Linear trace stride. */ _ssgiStride;
+    /** @internal Firefly clamp applied to sampled radiance. */ _ssgiMaxRayIntensity;
+    /** @internal Whether SSGI temporal accumulation is enabled. */ _ssgiTemporal;
+    /** @internal Weight of valid reprojected irradiance. */ _ssgiTemporalWeight;
+    /** @internal Maximum linear-depth delta in scene units accepted by reprojection. */ _ssgiDepthReject;
+    /** @internal Minimum normal dot product accepted by reprojection. */ _ssgiNormalReject;
     /** @internal SSS enable flag (via post effect). */ _SSS;
     /** @internal SSS post effect reference. */ _postEffectSSS;
     /** @internal SSS blur scale in pixels per authored width unit. */ _sssBlurScale;
@@ -194,7 +238,7 @@ const SSS_QUALITY_PRESET_SETTINGS = {
         this._invViewProjMatrix = Matrix4x4.identity();
         this._clipPlane = null;
         this._clearColor = new Vector4(0, 0, 0, 1);
-        this._clearDepth = 1;
+        this._clearDepth = DEPTH_CLEAR_VALUE;
         this._clearStencil = 0;
         this._dirty = true;
         this._controller = null;
@@ -220,6 +264,11 @@ const SSS_QUALITY_PRESET_SETTINGS = {
         this._toneMap = true;
         this._postEffectTonemap = new DRef();
         this._tonemapExposure = 1;
+        this._aperture = 16;
+        this._shutterSpeed = 1 / 125;
+        this._ISO = 100;
+        this._exposureCompensation = 0;
+        this._postProcessingLightingMode = null;
         this._motionBlur = false;
         this._postEffectMotionBlur = new DRef();
         this._motionBlurStrength = 1;
@@ -255,6 +304,25 @@ const SSS_QUALITY_PRESET_SETTINGS = {
         this._ssrBlurStdDev = 4;
         this._ssrTemporal = true;
         this._ssrTemporalWeight = 0.85;
+        this._SSGI = false;
+        this._postEffectSSGI = new DRef();
+        this._ssgiQualityPreset = 'quality';
+        const defaultSSGIQualityPreset = SSGI_QUALITY_PRESET_SETTINGS.quality;
+        this._ssgiResolvedSettings = {
+            ...defaultSSGIQualityPreset
+        };
+        this._ssgiIntensity = 0.7;
+        this._ssgiAOIntensity = 0.8;
+        this._ssgiAOPower = 1;
+        this._ssgiSkyOcclusion = 1;
+        this._ssgiMaxDistance = 32;
+        this._ssgiThickness = 0.5;
+        this._ssgiStride = 1;
+        this._ssgiMaxRayIntensity = 10;
+        this._ssgiTemporal = true;
+        this._ssgiTemporalWeight = 0.94;
+        this._ssgiDepthReject = 0.5;
+        this._ssgiNormalReject = 0.75;
         this._SSS = false;
         this._postEffectSSS = new DRef();
         this._sssBlurScale = SSS_DEFAULT_SETTINGS.blurScale;
@@ -530,10 +598,39 @@ const SSS_QUALITY_PRESET_SETTINGS = {
         return this._tonemapExposure;
     }
     set toneMapExposure(val) {
+        // syncPostProcessingMode() re-uploads the resolved exposure every frame, so this only needs to
+        // record the authored value. Legacy scenes read it back verbatim; physical scenes ignore it.
         this._tonemapExposure = val;
-        if (this._postEffectTonemap.get()) {
-            this._postEffectTonemap.get().exposure = val;
-        }
+    }
+    /** Lens aperture as an f-number. */ get aperture() {
+        return this._aperture;
+    }
+    set aperture(val) {
+        this._aperture = Math.max(0.0001, val);
+    }
+    /** Shutter-open time in seconds. */ get shutterSpeed() {
+        return this._shutterSpeed;
+    }
+    set shutterSpeed(val) {
+        this._shutterSpeed = Math.max(0.000001, val);
+    }
+    /** Sensor sensitivity in ISO units. */ get ISO() {
+        return this._ISO;
+    }
+    set ISO(val) {
+        this._ISO = Math.max(0.0001, val);
+    }
+    /** Exposure compensation in stops (EV). */ get exposureCompensation() {
+        return this._exposureCompensation;
+    }
+    set exposureCompensation(val) {
+        this._exposureCompensation = val;
+    }
+    /** Photographic EV100 calculated from aperture, shutter time and ISO. */ get EV100() {
+        return calculateEV100(this._aperture, this._shutterSpeed, this._ISO);
+    }
+    /** Scene-linear physical exposure multiplier, including exposure compensation. */ get exposure() {
+        return calculatePhysicalExposure(this._aperture, this._shutterSpeed, this._ISO, this._exposureCompensation);
     }
     /**
    * Gets whether TAA is enabled.
@@ -567,6 +664,195 @@ const SSS_QUALITY_PRESET_SETTINGS = {
     set SSR(val) {
         this._postEffectSSR.get().enabled = !!val;
     }
+    /** Gets whether Screen Space Global Illumination is enabled for this camera. */ get SSGI() {
+        return this._postEffectSSGI.get().enabled;
+    }
+    set SSGI(val) {
+        const next = !!val;
+        if (next !== this._postEffectSSGI.get().enabled) {
+            this._postEffectSSGI.get().enabled = next;
+            this.invalidateSSGIHistory();
+        }
+    }
+    /** High-level SSGI trace and denoise quality preset. */ get ssgiQualityPreset() {
+        return this._ssgiQualityPreset;
+    }
+    set ssgiQualityPreset(val) {
+        const next = Camera.resolveSSGIQualityPreset(val);
+        if (next !== this._ssgiQualityPreset) {
+            this._ssgiQualityPreset = next;
+            if (next !== 'custom') {
+                this._ssgiResolvedSettings = {
+                    ...SSGI_QUALITY_PRESET_SETTINGS[next]
+                };
+            }
+            this.invalidateSSGIHistory();
+        }
+    }
+    /** Resolved trace and denoise settings for the current SSGI preset. */ get ssgiResolvedSettings() {
+        return this._ssgiResolvedSettings;
+    }
+    /** Whether the custom SSGI trace runs at half resolution. */ get ssgiHalfResolution() {
+        return this._ssgiResolvedSettings.halfRes;
+    }
+    set ssgiHalfResolution(val) {
+        this.updateSSGICustomSettings({
+            halfRes: !!val
+        });
+    }
+    /** Number of diffuse rays traced per pixel by the custom SSGI preset. */ get ssgiRaysPerPixel() {
+        return this._ssgiResolvedSettings.raysPerPixel;
+    }
+    set ssgiRaysPerPixel(val) {
+        this.updateSSGICustomSettings({
+            raysPerPixel: Math.max(1, Math.min(4, Math.round(val ?? 1)))
+        });
+    }
+    /** Maximum screen-space ray-march iterations used by the custom SSGI preset. */ get ssgiMaxSteps() {
+        return this._ssgiResolvedSettings.maxSteps;
+    }
+    set ssgiMaxSteps(val) {
+        this.updateSSGICustomSettings({
+            maxSteps: Math.max(1, Math.min(256, Math.round(val ?? 1)))
+        });
+    }
+    /** Number of cross-bilateral a-trous passes used by the custom SSGI preset. */ get ssgiDenoisePasses() {
+        return this._ssgiResolvedSettings.denoisePasses;
+    }
+    set ssgiDenoisePasses(val) {
+        this.updateSSGICustomSettings({
+            denoisePasses: Math.max(0, Math.min(5, Math.round(val ?? 0)))
+        });
+    }
+    /** SSGI diffuse irradiance multiplier. */ get ssgiIntensity() {
+        return this._ssgiIntensity;
+    }
+    set ssgiIntensity(val) {
+        const next = Math.max(0, val ?? 0);
+        if (next !== this._ssgiIntensity) {
+            this._ssgiIntensity = next;
+            this.invalidateSSGIHistory();
+        }
+    }
+    /**
+   * How much environment irradiance an occluding hit removes, in [0, 1].
+   *
+   * A screen-space ray that hits geometry blocks the sky for that direction. At 1
+   * the environment contribution is removed in full, which is what produces sky
+   * occlusion in interiors and corners; lower values dim the sky less than the
+   * geometry implies, for art direction or to compensate for the hemisphere a
+   * screen-space trace cannot see. Only the removal is scaled — bounce light
+   * measured at the hit is always kept, so lowering this brightens without ever
+   * discarding indirect light. {@link Camera.ssgiIntensity} still bounds how dark
+   * the result can get, so full occlusion also needs an intensity of 1.
+   */ get ssgiSkyOcclusion() {
+        return this._ssgiSkyOcclusion;
+    }
+    set ssgiSkyOcclusion(val) {
+        const next = Math.max(0, Math.min(1, val ?? 0));
+        if (next !== this._ssgiSkyOcclusion) {
+            this._ssgiSkyOcclusion = next;
+            this.invalidateSSGIHistory();
+        }
+    }
+    /**
+   * How strongly the ambient occlusion traced alongside SSGI darkens the scene,
+   * in [0, 1]. 0 disables the composite entirely.
+   *
+   * The occlusion comes from the same rays that produce the irradiance, at no
+   * extra trace cost, and is multiplied into the final opaque color — the same
+   * semantics the standalone {@link SAO} post effect applies. **Enabling both at
+   * once therefore darkens twice.** Its range is the SSGI trace range
+   * ({@link Camera.ssgiMaxDistance}), so this is long-range occlusion rather than
+   * the small-radius contact darkening a dedicated AO pass produces.
+   *
+   * Defaults to 0.8 rather than 1: SSGI irradiance already has sky occlusion
+   * subtracted, so diffuse is partly occluded before this multiply is applied.
+   */ get ssgiAOIntensity() {
+        return this._ssgiAOIntensity;
+    }
+    set ssgiAOIntensity(val) {
+        this._ssgiAOIntensity = Math.max(0, Math.min(1, val ?? 0));
+    }
+    /**
+   * Contrast curve applied to the SSGI ambient occlusion before it is composited.
+   *
+   * Values above 1 deepen the occluded regions, below 1 lift them. Purely an art
+   * direction control on an already-traced quantity.
+   */ get ssgiAOPower() {
+        return this._ssgiAOPower;
+    }
+    set ssgiAOPower(val) {
+        this._ssgiAOPower = Math.max(0.01, val ?? 1);
+    }
+    /** Maximum SSGI ray length in view-space units. */ get ssgiMaxDistance() {
+        return this._ssgiMaxDistance;
+    }
+    set ssgiMaxDistance(val) {
+        const next = Math.max(0, val ?? 0);
+        if (next !== this._ssgiMaxDistance) {
+            this._ssgiMaxDistance = next;
+            this.invalidateSSGIHistory();
+        }
+    }
+    /** Depth thickness used by screen-space ray intersection tests. */ get ssgiThickness() {
+        return this._ssgiThickness;
+    }
+    set ssgiThickness(val) {
+        const next = Math.max(0.0001, val ?? 0.0001);
+        if (next !== this._ssgiThickness) {
+            this._ssgiThickness = next;
+            this.invalidateSSGIHistory();
+        }
+    }
+    /** Pixel stride used by the WebGL linear ray marcher. */ get ssgiStride() {
+        return this._ssgiStride;
+    }
+    set ssgiStride(val) {
+        const next = Math.max(1, Math.round(val ?? 1));
+        if (next !== this._ssgiStride) {
+            this._ssgiStride = next;
+            this.invalidateSSGIHistory();
+        }
+    }
+    /** Maximum per-ray radiance before temporal accumulation (firefly clamp). */ get ssgiMaxRayIntensity() {
+        return this._ssgiMaxRayIntensity;
+    }
+    set ssgiMaxRayIntensity(val) {
+        const next = Math.max(0, val ?? 0);
+        if (next !== this._ssgiMaxRayIntensity) {
+            this._ssgiMaxRayIntensity = next;
+            this.invalidateSSGIHistory();
+        }
+    }
+    /** Whether WebGPU SSGI temporal accumulation is enabled. */ get ssgiTemporal() {
+        return this._ssgiTemporal;
+    }
+    set ssgiTemporal(val) {
+        const next = !!val;
+        if (next !== this._ssgiTemporal) {
+            this._ssgiTemporal = next;
+            this.invalidateSSGIHistory();
+        }
+    }
+    /** Weight assigned to valid reprojected SSGI history. */ get ssgiTemporalWeight() {
+        return this._ssgiTemporalWeight;
+    }
+    set ssgiTemporalWeight(val) {
+        this._ssgiTemporalWeight = Math.max(0, Math.min(1, val ?? 0));
+    }
+    /** Relative linear-depth rejection threshold for SSGI reprojection. */ get ssgiDepthReject() {
+        return this._ssgiDepthReject;
+    }
+    set ssgiDepthReject(val) {
+        this._ssgiDepthReject = Math.max(0, val ?? 0);
+    }
+    /** Minimum world-normal dot product accepted by SSGI reprojection. */ get ssgiNormalReject() {
+        return this._ssgiNormalReject;
+    }
+    set ssgiNormalReject(val) {
+        this._ssgiNormalReject = Math.max(-1, Math.min(1, val ?? 0));
+    }
     /**
    * Gets the maximum roughness value for screen space reflections.
    * Controls the cutoff point where surfaces are considered too rough for SSR.
@@ -1019,8 +1305,8 @@ const SSS_QUALITY_PRESET_SETTINGS = {
         const height = this.viewport ? this.viewport[3] : getDevice().getViewport().height;
         const ndcX = 2 * x / width - 1;
         const ndcY = 1 - 2 * y / height;
-        const nearClip = new Vector4(ndcX, ndcY, -1, 1);
-        const farClip = new Vector4(ndcX, ndcY, 1, 1);
+        const nearClip = new Vector4(ndcX, ndcY, REVERSE_Z ? 1 : -1, 1);
+        const farClip = new Vector4(ndcX, ndcY, REVERSE_Z ? 0 : 1, 1);
         const nearWorld = this.invViewProjectionMatrix.transform(nearClip);
         const farWorld = this.invViewProjectionMatrix.transform(farClip);
         if (this.isPerspective()) {
@@ -1235,6 +1521,13 @@ const SSS_QUALITY_PRESET_SETTINGS = {
     }
     /** @internal */ updatePostProcessing() {
         this._compositor.clear();
+        if (!this._postEffectSSGI.get()) {
+            const ssgi = new SSGI();
+            ssgi.enabled = false;
+            this._postEffectSSGI.set(ssgi);
+            // SSGI resolves opaque linear HDR before SSR, transparency and AA.
+            this._compositor.appendPostEffect(ssgi);
+        }
         if (!this._postEffectSSR.get()) {
             const ssr = new SSR();
             ssr.enabled = false;
@@ -1317,6 +1610,25 @@ const SSS_QUALITY_PRESET_SETTINGS = {
             this._compositor.appendPostEffect(bloom);
         }
     }
+    /** @internal */ syncPostProcessingMode(scene) {
+        const tonemap = this._postEffectTonemap.get();
+        // Physical lighting pre-exposes every light quantity on the CPU (see ShaderHelper.getPreExposure),
+        // so the HDR buffer already sits near 1.0 and tonemapping only applies the ACES curve. Legacy
+        // keeps its plain exposure multiplier.
+        const usePhysicalExposure = scene.lightingMode === 'physical';
+        tonemap.exposure = usePhysicalExposure ? 1 : this._tonemapExposure;
+        const bloom = this._postEffectBloom.get();
+        if (this._postProcessingLightingMode !== scene.lightingMode) {
+            // SSGI histories contain scene-linear radiance. Never reuse them across lighting unit models.
+            this.invalidateSSGIHistory();
+            if (scene.lightingMode === 'physical') {
+                this._compositor.movePostEffectBefore(bloom, tonemap);
+            } else {
+                this._compositor.movePostEffectAfter(bloom, this._postEffectFXAA.get());
+            }
+            this._postProcessingLightingMode = scene.lightingMode;
+        }
+    }
     static resolveSSSQualityPreset(val) {
         switch(val){
             case 'quality':
@@ -1327,6 +1639,36 @@ const SSS_QUALITY_PRESET_SETTINGS = {
                 return 'balanced';
         }
     }
+    static resolveSSGIQualityPreset(val) {
+        switch(val){
+            case 'quality':
+            case 'balanced':
+            case 'performance':
+            case 'custom':
+                return val;
+            default:
+                return 'quality';
+        }
+    }
+    updateSSGICustomSettings(settings) {
+        const next = {
+            ...this._ssgiResolvedSettings,
+            ...settings
+        };
+        if (this._ssgiQualityPreset !== 'custom' || next.halfRes !== this._ssgiResolvedSettings.halfRes || next.raysPerPixel !== this._ssgiResolvedSettings.raysPerPixel || next.maxSteps !== this._ssgiResolvedSettings.maxSteps || next.denoisePasses !== this._ssgiResolvedSettings.denoisePasses) {
+            this._ssgiQualityPreset = 'custom';
+            this._ssgiResolvedSettings = next;
+            this.invalidateSSGIHistory();
+        }
+    }
+    /** @internal Invalidate only the histories owned by SSGI. */ invalidateSSGIHistory() {
+        const history = Camera._historyResourceManager.get(this);
+        history?.invalidate(RGHistoryResources.SSGI_SCENE_COLOR);
+        history?.invalidate(RGHistoryResources.SSGI_IRRADIANCE);
+        history?.invalidate(RGHistoryResources.SSGI_SURFACE);
+        history?.invalidate(RGHistoryResources.SSGI_MOMENTS);
+        history?.invalidate(RGHistoryResources.SSGI_AO);
+    }
     updateSSSResolvedSettings() {
         const source = SSS_QUALITY_PRESET_SETTINGS[this._sssQualityPreset];
         this._sssResolvedSettings.halfRes = source.halfRes;
@@ -1341,53 +1683,51 @@ const SSS_QUALITY_PRESET_SETTINGS = {
    * @param compositor - Compositor instance that will be used to apply postprocess effects
    */ render(scene) {
         const device = getDevice();
-        //this.updatePostProcessing(device);
-        const useMotionVector = (this.TAA || this.motionBlur || this.SSR && this.ssrTemporal) && device.type !== 'webgl';
-        const useTAA = useMotionVector && this.TAA;
+        this.syncPostProcessingMode(scene);
         scene.dispatchEvent('startrender', scene, this, this._compositor);
-        if (useMotionVector) {
-            const width = device.getDrawingBufferWidth();
-            const height = device.getDrawingBufferHeight();
-            if (useTAA) {
-                const halton = Camera._halton23[device.frameInfo.frameCounter % Camera._halton23.length];
-                this._jitterValue.setXY(halton[0] * 2 / width, halton[1] * 2 / height);
-            } else {
-                this._jitterValue.setXY(0, 0);
-            }
-            this._jitteredVPMatrix.set(this.getProjectionMatrix());
-            this._jitteredVPMatrix[8] += this._jitterValue.x;
-            this._jitteredVPMatrix[9] += this._jitterValue.y;
-            this._jitteredVPMatrix.multiplyRight(this.viewMatrix);
-            Matrix4x4.invert(this._jitteredVPMatrix, this._jitteredInvVPMatrix);
-            if (!this._prevJitteredVPMatrix) {
-                this._prevJitteredVPMatrix = new Matrix4x4();
-                this._prevJitteredVPMatrix.set(this._jitteredVPMatrix);
-                this._prevJitterValue = new Vector2(this._jitterValue);
-            }
-            if (!this._prevVPMatrix) {
-                this._prevVPMatrix = new Matrix4x4();
-                this._prevVPMatrix.set(this.viewProjectionMatrix);
-                this._prevPosition = this.getWorldPosition();
-            }
-        } else {
-            this._jitterValue.setXY(0, 0);
-            this._prevVPMatrix = null;
-            this._prevPosition = null;
-            this._prevJitteredVPMatrix = null;
-            this._prevJitterValue = null;
-            this._jitteredInvVPMatrix.set(this.invViewProjectionMatrix);
-        }
         device.pushDeviceStates();
         device.reverseVertexWindingOrder(false);
         scene.getRenderer().renderScene(scene, this);
         device.popDeviceStates();
-        if (useMotionVector) {
+        scene.dispatchEvent('endrender', scene, this, this._compositor);
+    }
+    /** Prepare current/previous camera transforms used by a motion-vector pass. @internal */ prepareMotionVectorFrame(useTAA, width, height) {
+        const device = getDevice();
+        if (useTAA) {
+            const halton = Camera._halton23[device.frameInfo.frameCounter % Camera._halton23.length];
+            this._jitterValue.setXY(halton[0] * 2 / width, halton[1] * 2 / height);
+        } else {
+            this._jitterValue.setXY(0, 0);
+        }
+        this._jitteredVPMatrix.set(this.getProjectionMatrix());
+        this._jitteredVPMatrix[8] += this._jitterValue.x;
+        this._jitteredVPMatrix[9] += this._jitterValue.y;
+        this._jitteredVPMatrix.multiplyRight(this.viewMatrix);
+        Matrix4x4.invert(this._jitteredVPMatrix, this._jitteredInvVPMatrix);
+        if (!this._prevJitteredVPMatrix) {
+            this._prevJitteredVPMatrix = new Matrix4x4();
             this._prevJitteredVPMatrix.set(this._jitteredVPMatrix);
-            this._prevJitterValue.set(this._jitterValue);
+            this._prevJitterValue = new Vector2(this._jitterValue);
+        }
+        if (!this._prevVPMatrix) {
+            this._prevVPMatrix = new Matrix4x4();
             this._prevVPMatrix.set(this.viewProjectionMatrix);
             this._prevPosition = this.getWorldPosition();
         }
-        scene.dispatchEvent('endrender', scene, this, this._compositor);
+    }
+    /** Commit camera transforms after a motion-vector frame completes. @internal */ commitMotionVectorFrame() {
+        this._prevJitteredVPMatrix.set(this._jitteredVPMatrix);
+        this._prevJitterValue.set(this._jitterValue);
+        this._prevVPMatrix.set(this.viewProjectionMatrix);
+        this._prevPosition = this.getWorldPosition();
+    }
+    /** Clear temporal camera transforms when motion vectors are not in use. @internal */ clearMotionVectorFrame() {
+        this._jitterValue.setXY(0, 0);
+        this._prevVPMatrix = null;
+        this._prevPosition = null;
+        this._prevJitteredVPMatrix = null;
+        this._prevJitterValue = null;
+        this._jitteredInvVPMatrix.set(this.invViewProjectionMatrix);
     }
     async pickAsync(posX, posY) {
         this._pickPosX = posX;
@@ -1459,6 +1799,18 @@ const SSS_QUALITY_PRESET_SETTINGS = {
         }
         Camera._historyResourceManager.set(this, manager);
     }
+    /** @internal */ _renderPipeline = null;
+    /**
+   * The render pipeline that assembles this camera's frame graph. When null
+   * (the default), the shared default Forward+ pipeline is used. Assign a
+   * customized pipeline to override rendering for this camera only, e.g.
+   * `camera.renderPipeline = createForwardPlusPipeline().insertAfter('SkyPass', myModule)`.
+   */ get renderPipeline() {
+        return this._renderPipeline;
+    }
+    set renderPipeline(pipeline) {
+        this._renderPipeline = pipeline;
+    }
     /** @internal */ setController(controller) {
         if (this._controller !== controller) {
             if (controller && controller._getCamera() && controller._getCamera() !== this) {
@@ -1502,6 +1854,7 @@ const SSS_QUALITY_PRESET_SETTINGS = {
         this._postEffectSSAO.dispose();
         this._postEffectSSS.dispose();
         this._postEffectSkinSSS.dispose();
+        this._postEffectSSGI.dispose();
         this._postEffectSSR.dispose();
         this._postEffectTAA.dispose();
         this._postEffectTonemap.dispose();