@hology/webgpu-renderer 0.1.5 → 0.1.7

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as three from 'three';
-import { Color, Vector2, Vector3, Vector4, Matrix3, Matrix4, Material, Texture, MaterialParameters, DirectionalLight, Object3D, PerspectiveCamera, OrthographicCamera, Scene } from 'three';
+import { Color, Vector2, Vector3, Vector4, Matrix3, Matrix4, Material, Texture, MaterialParameters, DirectionalLight, PointLight, SpotLight, Object3D, PerspectiveCamera, OrthographicCamera, Scene } from 'three';
 export { AmbientLight, BackSide, BatchedMesh, Bone, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, Color, CompressedArrayTexture, CompressedCubeTexture, CompressedTexture, CompressedArrayTexture as CompressedTextureArray, CubeTexture, Data3DTexture, DataArrayTexture, DataTexture, DepthTexture, DirectionalLight, DoubleSide, FrontSide, Group, HemisphereLight, InstancedMesh, MathUtils, Matrix4, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, PlaneGeometry, PointLight, RepeatWrapping, Scene, Skeleton, SkinnedMesh, SphereGeometry, SpotLight, Texture, Vector2, Vector3, Vector4 } from 'three';
 
 interface ComputeKernelDescriptor {
@@ -137,6 +137,8 @@ declare class WGSLShaderMaterial extends Material {
     customProgramCacheKey(): string;
     getTexturesList(): readonly Texture[];
     usesSceneTextures(): boolean;
+    usesSceneColor(): boolean;
+    usesSceneDepth(): boolean;
     getGraphTextureInputs(): Record<string, WGSLGraphTextureInput>;
     requiresLatePass(): boolean;
     getUniformValueHash(): number;
@@ -177,6 +179,9 @@ declare class RenderGraph {
     private resolveExecutionOrder;
 }
 
+/** Shared renderer lighting ABI for procedural particle geometry. */
+declare function buildParticleLightingShaderHeader(receiveShadow?: boolean, modelMatrixBody?: string): string;
+
 interface TextureResource {
     version: number;
     width: number;
@@ -230,10 +235,12 @@ interface ExtractedDirectionalLight {
     shadowCameraFar: number;
 }
 interface ExtractedPointLight {
+    sourceLight: PointLight;
     position: Vector3;
     color: Vector3;
     intensity: number;
     volumetricIntensity: number;
+    distance: number;
     range: number;
     decay: number;
     castShadow: boolean;
@@ -246,6 +253,7 @@ interface ExtractedPointLight {
     shadowCameraFar: number;
 }
 interface ExtractedSpotLight {
+    sourceLight: SpotLight;
     position: Vector3;
     direction: Vector3;
     color: Vector3;
@@ -308,6 +316,12 @@ interface RendererOptions {
 interface StaticDrawSetOptions {
     label?: string;
     onUnsupported?: "throw" | "skip";
+    /**
+     * Admit transparent and scene-texture materials and render them, in their
+     * stable recorded order, during the late pass. No camera-depth sorting is
+     * performed inside the set.
+     */
+    allowUnsortedLateDraws?: boolean;
 }
 interface StaticDrawSet {
     readonly label: string;
@@ -337,7 +351,10 @@ interface RendererGraphBuilderContext {
     defineTextureTarget(name: string, descriptor?: RendererTextureTargetDescriptor): void;
     addForwardPass(output?: string): void;
     addOpaquePass(output?: string): void;
-    addSceneTextureCopyPass(source?: string): void;
+    addSceneTextureCopyPass(source?: string, requirements?: {
+        readonly sceneColor?: boolean;
+        readonly sceneDepth?: boolean;
+    }): void;
     addLatePass(output?: string): void;
     addHiZHistoryPass(dependsOn?: string): void;
     addMaterialPass(descriptor?: RendererMaterialPassDescriptor): void;
@@ -411,7 +428,10 @@ interface RendererCustomPassContext {
     getSceneLightingResources(): RendererSceneLightingResources;
 }
 interface RendererSceneLightingResources {
+    readonly cameraBuffer: GPUBuffer;
     readonly lightBuffer: GPUBuffer;
+    readonly shadowSampler: GPUSampler;
+    readonly linearSampler: GPUSampler;
     readonly directionalShadowView: GPUTextureView;
     readonly pointShadowView: GPUTextureView;
     readonly spotShadowView: GPUTextureView;
@@ -528,7 +548,10 @@ declare class FrameGraphBuilder {
     addVisibilityPass(): void;
     addForwardPass(output?: FrameGraphTextureHandle): void;
     addOpaquePass(output?: FrameGraphTextureHandle): void;
-    addSceneTextureCopyPass(source?: FrameGraphTextureHandle): void;
+    addSceneTextureCopyPass(source?: FrameGraphTextureHandle, requirements?: {
+        readonly sceneColor?: boolean;
+        readonly sceneDepth?: boolean;
+    }): void;
     addLatePass(output?: FrameGraphTextureHandle): void;
     addHiZHistoryPass(dependsOn?: string): void;
     addMaterialPass(descriptor?: FrameGraphMaterialPassDescriptor): void;
@@ -539,6 +562,15 @@ declare class FrameGraphBuilder {
 }
 
 type VolumetricFogScatteringMode = "volumetric" | "lightShaft";
+type VolumetricFogQuality = "low" | "medium" | "high";
+interface VolumetricFogTemporalOptions {
+    /** Previous-frame contribution for stable fog. Defaults to 0.92. */
+    readonly historyWeight?: number;
+    /** Relative view-depth difference that rejects history. Defaults to 0.04. */
+    readonly depthRejection?: number;
+    /** Clamp reprojected history to the current 3x3 fog neighborhood. */
+    readonly neighborhoodClamp?: boolean;
+}
 /** Kept structurally compatible with Hology's legacy FogVolumeSettings. */
 interface VolumetricFogVolumeSettings {
     readonly object: Object3D;
@@ -559,6 +591,7 @@ declare class VolumetricFogVolumeObject extends Object3D {
     constructor(volume: VolumetricFogVolumeSettings);
 }
 interface VolumetricFogOptions {
+    readonly enabled?: boolean;
     /** Froxel width/height in pixels. 8 is a good desktop default. */
     readonly froxelPixelSize?: number;
     /** Logarithmically distributed depth slices. */
@@ -575,8 +608,13 @@ interface VolumetricFogOptions {
     readonly ambientColor?: Color;
     /** Rotating shadow taps per froxel. 4 removes block patterns at modest cost. */
     readonly shadowFilterTaps?: 1 | 4;
-    /** Temporal sub-froxel jitter, intended to be accumulated by TAA. */
+    /** Temporal sub-froxel jitter accumulated by fog history and optionally TAA. */
     readonly temporalJitter?: boolean;
+    /**
+     * Fog-local temporal reconstruction. Unlike temporalJitter, this retains a
+     * resolved fog history and permits cheaper current-frame sampling.
+     */
+    readonly temporal?: false | VolumetricFogTemporalOptions;
     /** Stable per-ray depth jitter. Breaks slice bands without animated noise. */
     readonly spatialJitter?: boolean;
     /** Final fog-gradient dithering in approximate 8-bit code values. */
@@ -601,6 +639,8 @@ interface VolumetricFogBlurOptions {
 interface VolumetricFogInputs {
     readonly sceneColor: FrameGraphTextureHandle;
     readonly depth: FrameGraphTextureHandle;
+    /** Raw unjittered previous-to-current UV velocity from the opaque MRT. */
+    readonly velocity?: FrameGraphTextureHandle;
     /** Explicit volumes can be mixed with compatible scene marker objects. */
     readonly volumes?: readonly VolumetricFogVolumeSettings[];
     /**
@@ -614,6 +654,7 @@ interface VolumetricFogInputs {
      */
     readonly lights?: RendererExtractedLightState;
 }
+declare const VOLUMETRIC_FOG_PRESETS: Readonly<Record<VolumetricFogQuality, VolumetricFogOptions>>;
 /**
  * Compute-driven froxel fog. Add it after opaque rendering and before the late
  * transparent pass. Existing content can use the composite output; transparent
@@ -630,27 +671,56 @@ declare class VolumetricFogEffect {
     private readonly uniformIntegers;
     private readonly volumeData;
     private readonly lightData;
+    private readonly selectedPointIndices;
+    private readonly selectedPointScores;
+    private readonly selectedSpotIndices;
+    private readonly selectedSpotScores;
+    private readonly collectedVolumes;
+    private readonly collectedDirectionals;
+    private readonly collectedPoints;
+    private readonly collectedSpots;
+    private volumeCount;
+    private directionalCount;
+    private pointCount;
+    private spotCount;
+    private collectionCamera;
+    private readonly collectVolumeObject;
+    private readonly collectLightObject;
+    private readonly executeFroxelPass;
     private readonly projectionInverse;
     private readonly viewProjectionInverse;
+    private readonly previousTemporalViewProjection;
     private explicitVolumes;
     private volumeObjects;
     private extractedLights;
     private cascadeDirectionalLights;
     private compositePass;
     private readonly blurPassCache;
+    private readonly temporalPassCache;
+    private temporalWriteIndex;
+    private temporalHistoryValid;
+    private activeLastFrame;
     private frameIndex;
     constructor(scene?: Scene, options?: VolumetricFogOptions);
     /** Updates the scene traversed for compatible volumes and lights. */
     setScene(scene: Scene): void;
+    get enabled(): boolean;
+    setOptions(options: VolumetricFogOptions): void;
+    applyPreset(quality: VolumetricFogQuality): void;
+    reset(): void;
     /** Keeps CSM light data in the same near-to-far order as shadow-array layers. */
     setCascadedDirectionalLights(lights: readonly DirectionalLight[]): void;
     addPasses(graph: FrameGraphBuilder, inputs: VolumetricFogInputs): FrameGraphTextureHandle;
     private addBlurredComposite;
+    private addTemporalPass;
+    consumeTemporalHistoryValid(): boolean;
+    updateTemporalUniforms(uniforms: Float32Array, currentViewProjection: Matrix4, currentViewProjectionInverse: Matrix4, temporal: Required<VolumetricFogTemporalOptions>, context: RendererCustomPassContext): void;
     dispose(): void;
     private executeFroxels;
     private collectSceneData;
+    /** Selects the nearest local lights without depending on camera rotation. */
+    private selectClosestLights;
     private writeVolume;
-    private lightColor;
     private writeDirectional;
     private writeExtractedDirectional;
     private writePoint;
@@ -798,6 +868,8 @@ declare class WebGpuRenderer {
     private readonly standardVertexAttributeCache;
     private readonly geometryVertexBufferFastCache;
     private readonly vertexAttributeGroupCache;
+    private readonly materialVertexAttributeCache;
+    private readonly vertexBufferBindingPlanCache;
     private readonly vertexAttributeGroupBufferKeyCache;
     private readonly compileDrawScratch;
     private readonly dynamicIndirectSubmissionCache;
@@ -850,6 +922,14 @@ declare class WebGpuRenderer {
     private readonly projectionJitterPixels;
     private readonly temporalVisibilityCurrentViewProj;
     private readonly temporalVisibilityPreviousViewProj;
+    private readonly motionVectorProjection;
+    private readonly motionVectorCurrentViewProj;
+    private readonly motionVectorPreviousViewProj;
+    private motionVectorProjectionPending;
+    private motionVectorHistoryValid;
+    private motionVectorHistoryGeneration;
+    private lastMotionVectorTimeSeconds;
+    private readonly objectMotionHistory;
     private readonly cameraFrustumPlanesScratch;
     private readonly objectTraversalStackScratch;
     private readonly isSphereVisibleScratch;
@@ -873,6 +953,7 @@ declare class WebGpuRenderer {
     private hasRenderCallbacks;
     initialize(): Promise<void>;
     createComputeKernel(descriptor: ComputeKernelDescriptor): ComputeKernel;
+    getDevice(): GPUDevice | null;
     setRenderGraphBuilder(builder: RendererGraphBuilder): void;
     /**
      * Associates the first directional shadow layers with cascaded-shadow-map
@@ -899,6 +980,13 @@ declare class WebGpuRenderer {
      */
     setProjectionJitter(x: number, y: number): void;
     clearProjectionJitter(): void;
+    /**
+     * Supplies the unjittered projection used by motion vectors for the next
+     * render. The backend calls this before TAA temporarily jitters the camera.
+     */
+    setMotionVectorProjection(projection: Matrix4): void;
+    /** Suppresses object velocity for one frame without discarding GPU caches. */
+    invalidateObjectMotion(object: Object3D): void;
     getLastFrameProfile(): RendererFrameProfile | null;
     /**
      * Invalidates temporal data when this renderer starts presenting a
@@ -975,6 +1063,8 @@ declare class WebGpuRenderer {
      */
     private collectSprite;
     private hasExtractedDirectionalLight;
+    private getObjectMotionHistory;
+    private commitObjectMotionHistory;
     private collectMesh;
     private prepareSceneForCompilation;
     private collectInstancedMesh;
@@ -1060,6 +1150,8 @@ declare class WebGpuRenderer {
     private getInterleavedGeometryVertexBuffer;
     private ensureWireframeIndex;
     private bindGeometryVertexBuffers;
+    private getStandardVertexAttribute;
+    private prepareDrawGeometryVertexBuffers;
     private getDefaultInstanceAttributeBuffer;
     private getMeshExtractionCacheEntry;
     private getInstancedMeshExtractionCacheEntry;
@@ -1126,11 +1218,22 @@ declare class WebGpuRenderer {
 
 interface GTAODenoiseOptions {
     readonly radius?: number;
+    /** Fixed bilateral tap count. Normalized to 4, 8, 12, or 16. */
+    readonly samples?: number;
     readonly depthPhi?: number;
     readonly normalPhi?: number;
     readonly lumaPhi?: number;
 }
+interface GTAOTemporalOptions {
+    /** Previous-frame contribution for accepted history. Defaults to 0.9. */
+    readonly historyWeight?: number;
+    /** Relative linear view-depth rejection threshold. Defaults to 0.08. */
+    readonly depthRejection?: number;
+    /** Clamp history to the current AO cross-neighborhood. Defaults to true. */
+    readonly neighborhoodClamp?: boolean;
+}
 interface GTAOOptions {
+    readonly enabled?: boolean;
     /** Resolution relative to the render target. Defaults to 1. */
     readonly resolutionScale?: number;
     readonly radius?: number;
@@ -1142,28 +1245,43 @@ interface GTAOOptions {
     /** Space used by the encoded normal input. Defaults to world. */
     readonly normalSpace?: "world" | "view";
     readonly denoise?: false | GTAODenoiseOptions;
+    /** Velocity-reprojected accumulation. Requires a velocity input. */
+    readonly temporal?: false | GTAOTemporalOptions;
     readonly targetPrefix?: string;
 }
 interface GTAOInputs {
     readonly depth: FrameGraphTextureHandle;
     readonly normal: FrameGraphTextureHandle;
+    readonly velocity?: FrameGraphTextureHandle;
 }
 interface GTAOCompositeOptions {
     readonly intensity?: number;
     readonly power?: number;
     readonly output?: FrameGraphTextureHandle;
 }
-/** Reusable GTAO pass pair. The caller controls where AO is composited. */
+type GTAOQuality = "off" | "low" | "medium" | "high";
+declare const GTAO_PRESETS: Readonly<Record<GTAOQuality, Readonly<GTAOOptions>>>;
+/** Reusable GTAO pass chain. The caller controls where AO is composited. */
 declare class GTAOEffect {
     private readonly options;
     private readonly noiseTexture;
     private readonly gtaoPasses;
+    private readonly temporalPasses;
     private readonly denoisePasses;
     private readonly compositePasses;
+    private writeIndex;
+    private frameIndex;
+    private historyValid;
     constructor(options?: GTAOOptions);
+    get enabled(): boolean;
+    get temporalEnabled(): boolean;
+    setOptions(options: GTAOOptions): void;
+    applyPreset(quality: GTAOQuality): void;
+    reset(): void;
     addPasses(graph: FrameGraphBuilder, inputs: GTAOInputs): FrameGraphTextureHandle;
     addCompositePass(graph: FrameGraphBuilder, sceneColor: FrameGraphTextureHandle, ambientOcclusion: FrameGraphTextureHandle, options?: GTAOCompositeOptions): FrameGraphTextureHandle;
     dispose(): void;
+    consumeHistoryValid(): boolean;
 }
 
 interface SSROptions {
@@ -1218,7 +1336,7 @@ interface TemporalAAOptions {
     readonly targetPrefix?: string;
 }
 declare class TemporalAAEffect {
-    readonly renderScale: number;
+    renderScale: number;
     private readonly sampleCount;
     private readonly minCurrentWeight;
     private readonly motionWeightScale;
@@ -1250,8 +1368,14 @@ declare class TemporalAAEffect {
         projectionMatrix: Matrix4;
         projectionMatrixInverse?: Matrix4;
     }): void;
-    addPass(graph: FrameGraphBuilder, currentColor: FrameGraphTextureHandle, currentDepth?: FrameGraphTextureHandle): FrameGraphTextureHandle;
+    addPass(graph: FrameGraphBuilder, currentColor: FrameGraphTextureHandle, currentDepth?: FrameGraphTextureHandle, velocity?: FrameGraphTextureHandle): FrameGraphTextureHandle;
     reset(): void;
+    /**
+     * Updates the internal scene scale used to convert the presentation-space
+     * jitter into internal-render pixels. TAA histories remain at presentation
+     * resolution and therefore act as the temporal upscaling target.
+     */
+    setRenderScale(renderScale: number): void;
     private setSize;
     updateResolveUniforms(uniforms: Float32Array, currentViewProjection: Matrix4, currentViewProjectionInverse: Matrix4, context: RendererCustomPassContext): void;
 }
@@ -1400,6 +1524,93 @@ declare class DepthOfFieldEffect {
     addPass(graph: FrameGraphBuilder, source: FrameGraphTextureHandle, depth: FrameGraphTextureHandle): FrameGraphTextureHandle;
 }
 
+declare enum MotionBlurMode {
+    Disabled = 0,
+    CameraOnly = 1,
+    ObjectAndCamera = 2,
+    ForceObjectBlur = 3
+}
+type MotionBlurQuality = "off" | "low" | "medium" | "high";
+interface MotionBlurOptions {
+    enabled?: boolean;
+    sampleCount?: number;
+    shutterScale?: number;
+    maxBlurPixels?: number;
+    cameraBlurScale?: number;
+    objectBlurScale?: number;
+    depthRejectionStrength?: number;
+    velocityThresholdPixels?: number;
+    dilation?: boolean;
+    debugVelocity?: boolean;
+    targetFrameRate?: number;
+    maxFrameTime?: number;
+    cameraCutDistance?: number;
+    cameraCutRotationThreshold?: number;
+    projectionCutThreshold?: number;
+    targetPrefix?: string;
+}
+interface MotionBlurOverride extends Partial<MotionBlurOptions> {
+    duration: number;
+}
+interface MotionBlurOverrideHandle {
+    readonly id: number;
+    cancel(): void;
+}
+declare const MOTION_BLUR_PRESETS: Readonly<Record<MotionBlurQuality, Readonly<MotionBlurOptions>>>;
+/**
+ * HDR, depth-aware motion-blur resolve.
+ *
+ * Velocity convention:
+ * - RG points from the previous position to the current position.
+ * - Units are texture UV displacement per rendered frame.
+ * - Y is texture-space down; the node compiler flips WebGPU's Y-up NDC.
+ * - Current/previous matrices are unjittered, so TAA jitter is excluded.
+ * - B stores MotionBlurMode and A stores the authored object scale.
+ */
+declare class MotionBlurEffect {
+    readonly options: Required<Omit<MotionBlurOptions, "targetPrefix">>;
+    private readonly targetPrefix;
+    private readonly currentViewProjection;
+    private readonly currentInverseViewProjection;
+    private readonly currentInverseProjection;
+    private readonly previousViewProjection;
+    private readonly pendingViewProjection;
+    private readonly previousProjection;
+    private readonly previousCameraWorld;
+    private readonly previousCameraPosition;
+    private readonly currentCameraPosition;
+    private readonly currentJitterUv;
+    private historyValid;
+    private pendingCamera;
+    private width;
+    private height;
+    private timeSeconds;
+    private frameDuration;
+    private previousTimeSeconds;
+    private nextOverrideId;
+    private readonly overrides;
+    private readonly passes;
+    constructor(options?: MotionBlurOptions);
+    applyPreset(quality: MotionBlurQuality): void;
+    prepareCamera(camera: PerspectiveCamera | OrthographicCamera, width: number, height: number, timeSeconds: number): void;
+    commitCamera(): void;
+    setJitterUv(x: number, y: number): void;
+    reset(): void;
+    requiresRendererHistoryReset(): boolean;
+    pushOverride(override: MotionBlurOverride): MotionBlurOverrideHandle;
+    addPass(graph: FrameGraphBuilder, sceneColor: FrameGraphTextureHandle, velocity: FrameGraphTextureHandle, depth?: FrameGraphTextureHandle): FrameGraphTextureHandle;
+    dispose(): void;
+    getTemporalMatrices(): {
+        readonly currentInverseViewProjection: Matrix4;
+        readonly currentInverseProjection: Matrix4;
+        readonly previousViewProjection: Matrix4;
+    };
+    getFrameDuration(): number;
+    getJitterUv(): Vector2;
+    private pruneOverrides;
+    private getResolvedSettings;
+}
+
 interface OutlineOptions {
     readonly enabled?: boolean;
     readonly visibleEdgeColor?: readonly [number, number, number];
@@ -1441,4 +1652,4 @@ declare class OutlineEffect {
     dispose(): void;
 }
 
-export { type BloomCompositeOptions, BloomEffect, type BloomOptions, ColorGradingEffect, type ColorGradingOptions, type ColorGradingRange, type ColorGradingVector, type CompiledNodeFullscreenShader, ComputeKernel, type ComputeKernelDescriptor, DEFAULT_WGSL_VERTEX_ATTRIBUTES, DepthOfFieldEffect, type DepthOfFieldOptions, type FXAACompositeOptions, FXAAEffect, type FXAAOptions, FrameGraphBuilder, type FrameGraphFullscreenPassDescriptor, type FrameGraphMaterialPassDescriptor, type FrameGraphNodeFullscreenPassDescriptor, type FrameGraphPassDescriptor, type FrameGraphTextureHandle, type GTAOCompositeOptions, type GTAODenoiseOptions, GTAOEffect, type GTAOInputs, type GTAOOptions, OutlineEffect, type OutlineInputs, type OutlineInstanceSelection, type OutlineOptions, RenderGraph, type RenderGraphContext, type RenderGraphExecutionObserver, type RenderGraphPass, type RendererColorTargetDescriptor, type RendererCustomPassContext, type RendererCustomPassDescriptor, type RendererFrameProfile, type RendererGraphBuilder, type RendererGraphBuilderContext, type RendererMaterialPassDescriptor, type RendererMaterialResolver, type RendererOptions, type RendererPassProfile, type RendererShadowMapDebugInfo, type RendererShadowMapDebugTextureInfo, type RendererTextureTargetDescriptor, type RendererVisibilityProfile, type SMAACompositeOptions, type SMAAEdgeDetectionMode, SMAAEffect, type SMAAOptions, type SMAAQualityPreset, SSREffect, type SSRInputs, type SSROptions, type ShaderDefineValue, type ShaderDefines, type StaticDrawSet, type StaticDrawSetOptions, TemporalAAEffect, type TemporalAAOptions, type ToneMappingMode, type ToonOutlineParameters, type UniformDefinition, type UniformType, type UniformValue, VOLUMETRIC_FOG_MATERIAL_WGSL, type VolumetricFogBlurOptions, VolumetricFogEffect, type VolumetricFogInputs, type VolumetricFogOptions, type VolumetricFogScatteringMode, VolumetricFogVolumeObject, type VolumetricFogVolumeSettings, type WGSLGraphTextureDimension, type WGSLGraphTextureInput, type WGSLSceneTextureSemantic, WGSLShaderMaterial, type WGSLShaderMaterialParameters, type WGSLShaderMaterialUniform, type WGSLShaderMaterialUniformInput, type WGSLStorageBufferBinding, type WGSLStorageBufferVisibility, type WGSLSupportedVertexFormat, type WGSLVertexAttributeBinding, WebGpuPMREMGenerator, WebGpuRenderer, configureVolumetricFogMaterial };
+export { type BloomCompositeOptions, BloomEffect, type BloomOptions, ColorGradingEffect, type ColorGradingOptions, type ColorGradingRange, type ColorGradingVector, type CompiledNodeFullscreenShader, ComputeKernel, type ComputeKernelDescriptor, DEFAULT_WGSL_VERTEX_ATTRIBUTES, DepthOfFieldEffect, type DepthOfFieldOptions, type FXAACompositeOptions, FXAAEffect, type FXAAOptions, FrameGraphBuilder, type FrameGraphFullscreenPassDescriptor, type FrameGraphMaterialPassDescriptor, type FrameGraphNodeFullscreenPassDescriptor, type FrameGraphPassDescriptor, type FrameGraphTextureHandle, type GTAOCompositeOptions, type GTAODenoiseOptions, GTAOEffect, type GTAOInputs, type GTAOOptions, type GTAOQuality, type GTAOTemporalOptions, GTAO_PRESETS, MOTION_BLUR_PRESETS, MotionBlurEffect, MotionBlurMode, type MotionBlurOptions, type MotionBlurOverride, type MotionBlurOverrideHandle, type MotionBlurQuality, OutlineEffect, type OutlineInputs, type OutlineInstanceSelection, type OutlineOptions, RenderGraph, type RenderGraphContext, type RenderGraphExecutionObserver, type RenderGraphPass, type RendererColorTargetDescriptor, type RendererCustomPassContext, type RendererCustomPassDescriptor, type RendererFrameProfile, type RendererGraphBuilder, type RendererGraphBuilderContext, type RendererMaterialPassDescriptor, type RendererMaterialResolver, type RendererOptions, type RendererPassProfile, type RendererShadowMapDebugInfo, type RendererShadowMapDebugTextureInfo, type RendererTextureTargetDescriptor, type RendererVisibilityProfile, type SMAACompositeOptions, type SMAAEdgeDetectionMode, SMAAEffect, type SMAAOptions, type SMAAQualityPreset, SSREffect, type SSRInputs, type SSROptions, type ShaderDefineValue, type ShaderDefines, type StaticDrawSet, type StaticDrawSetOptions, TemporalAAEffect, type TemporalAAOptions, type ToneMappingMode, type ToonOutlineParameters, type UniformDefinition, type UniformType, type UniformValue, VOLUMETRIC_FOG_MATERIAL_WGSL, VOLUMETRIC_FOG_PRESETS, type VolumetricFogBlurOptions, VolumetricFogEffect, type VolumetricFogInputs, type VolumetricFogOptions, type VolumetricFogQuality, type VolumetricFogScatteringMode, type VolumetricFogTemporalOptions, VolumetricFogVolumeObject, type VolumetricFogVolumeSettings, type WGSLGraphTextureDimension, type WGSLGraphTextureInput, type WGSLSceneTextureSemantic, WGSLShaderMaterial, type WGSLShaderMaterialParameters, type WGSLShaderMaterialUniform, type WGSLShaderMaterialUniformInput, type WGSLStorageBufferBinding, type WGSLStorageBufferVisibility, type WGSLSupportedVertexFormat, type WGSLVertexAttributeBinding, WebGpuPMREMGenerator, WebGpuRenderer, buildParticleLightingShaderHeader, configureVolumetricFogMaterial };