@hology/webgpu-renderer 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1262 @@
+import * as three from 'three';
+import { Color, Vector2, Vector3, Vector4, Matrix3, Matrix4, Material, Texture, MaterialParameters, Object3D, PerspectiveCamera, OrthographicCamera, Scene, DirectionalLight } 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 {
+    label?: string;
+    code: string;
+    entryPoint?: string;
+    bindGroupLayoutEntries: GPUBindGroupLayoutEntry[];
+}
+declare class ComputeKernel {
+    readonly layout: GPUBindGroupLayout;
+    readonly pipeline: GPUComputePipeline;
+    constructor(device: GPUDevice, descriptor: ComputeKernelDescriptor);
+    createBindGroup(device: GPUDevice, entries: GPUBindGroupEntry[], label?: string): GPUBindGroup;
+}
+
+type ShaderDefineValue = string | number | boolean;
+type ShaderDefines = Record<string, ShaderDefineValue | null | undefined>;
+
+type UniformType = "f32" | "i32" | "u32" | "vec2<f32>" | "vec3<f32>" | "vec4<f32>" | "mat3x3<f32>" | "mat4x4<f32>";
+type UniformValue = number | boolean | readonly number[] | Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4;
+interface UniformDefinition {
+    type: UniformType;
+    value: UniformValue;
+}
+interface UniformLayoutEntry {
+    name: string;
+    offset: number;
+    type: UniformType;
+}
+interface UniformLayout {
+    byteLength: number;
+    entries: UniformLayoutEntry[];
+}
+
+type WGSLStorageBufferVisibility = "vertex" | "fragment" | "vertex-fragment";
+type WGSLSupportedVertexFormat = "float32" | "float32x2" | "float32x3" | "float32x4" | "uint32" | "uint32x2" | "uint32x3" | "uint32x4" | "sint32" | "sint32x2" | "sint32x3" | "sint32x4";
+interface WGSLVertexAttributeBinding {
+    name: string;
+    shaderLocation: number;
+    format: WGSLSupportedVertexFormat;
+    stepMode?: GPUVertexStepMode;
+    defaultValue?: readonly number[];
+}
+declare const DEFAULT_WGSL_VERTEX_ATTRIBUTES: readonly WGSLVertexAttributeBinding[];
+interface WGSLStorageBufferBinding {
+    buffer: GPUBuffer;
+    type: string;
+    visibility?: WGSLStorageBufferVisibility;
+}
+type WGSLSceneTextureSemantic = "sceneColor" | "sceneDepth";
+type WGSLGraphTextureDimension = "2d" | "depth-2d" | "3d";
+interface WGSLGraphTextureInput {
+    resource: string;
+    dimension: WGSLGraphTextureDimension;
+    sampleType?: "float" | "unfilterable-float" | "depth";
+    sampler?: "filtering" | "non-filtering" | "comparison";
+    requiresLatePass?: boolean;
+}
+interface WGSLShaderMaterialUniform {
+    type?: UniformType;
+    value: UniformValue | Texture;
+}
+type WGSLShaderMaterialUniformInput = UniformDefinition | WGSLShaderMaterialUniform | UniformValue | Texture;
+interface WGSLShaderMaterialParameters extends MaterialParameters {
+    vertexShader: string;
+    fragmentShader: string;
+    depthVertexShader?: string | null;
+    depthFragmentShader?: string | null;
+    pointShadowVertexShader?: string | null;
+    pointShadowFragmentShader?: string | null;
+    defines?: ShaderDefines;
+    uniforms?: Record<string, WGSLShaderMaterialUniformInput>;
+    textures?: Record<string, Texture>;
+    sceneTextures?: Record<string, WGSLSceneTextureSemantic>;
+    graphTextures?: Record<string, WGSLGraphTextureInput>;
+    storageBuffers?: Record<string, WGSLStorageBufferBinding>;
+    vertexAttributes?: readonly WGSLVertexAttributeBinding[];
+    primitiveTopology?: GPUPrimitiveTopology;
+    /** Render triangle meshes as one-pixel triangle edges, matching Three.js wireframe materials. */
+    wireframe?: boolean;
+}
+declare class WGSLShaderMaterial extends Material {
+    readonly isWGSLShaderMaterial = true;
+    type: "WGSLShaderMaterial";
+    vertexShader: string;
+    fragmentShader: string;
+    depthVertexShader: string | null;
+    depthFragmentShader: string | null;
+    pointShadowVertexShader: string | null;
+    pointShadowFragmentShader: string | null;
+    defines: ShaderDefines;
+    uniforms: Record<string, UniformDefinition>;
+    textures: Record<string, Texture>;
+    sceneTextures: Record<string, WGSLSceneTextureSemantic>;
+    graphTextures: Record<string, WGSLGraphTextureInput>;
+    storageBuffers: Record<string, WGSLStorageBufferBinding>;
+    vertexAttributes: WGSLVertexAttributeBinding[];
+    primitiveTopology: GPUPrimitiveTopology;
+    wireframe: boolean;
+    private uniformLayoutCache;
+    private programCacheKeyCache;
+    private textureListCache;
+    private textureVersionsCache;
+    private textureVersionHashCache;
+    private storageBufferBindingListCache;
+    private storageBufferListCache;
+    private textureLayoutKeyDeviceCache;
+    private textureLayoutKeyCache;
+    constructor(parameters: WGSLShaderMaterialParameters);
+    getUniformLayout(): UniformLayout;
+    setUniform(name: string, definition: WGSLShaderMaterialUniformInput): this;
+    setDefine(name: string, value?: string | number | boolean): this;
+    deleteDefine(name: string): this;
+    setTexture(name: string, texture: Texture): this;
+    setStorageBuffer(name: string, binding: WGSLStorageBufferBinding): this;
+    setVertexAttributes(attributes: readonly WGSLVertexAttributeBinding[]): this;
+    copy(source: this): this;
+    /** Three's default clone path cannot call this material's required constructor. */
+    clone(): this;
+    customProgramCacheKey(): string;
+    getTexturesList(): readonly Texture[];
+    usesSceneTextures(): boolean;
+    getGraphTextureInputs(): Record<string, WGSLGraphTextureInput>;
+    requiresLatePass(): boolean;
+    getUniformValueHash(): number;
+    getTextureVersionsList(): readonly number[];
+    getTextureVersionHash(): number;
+    getStorageBufferBindingList(): readonly WGSLStorageBufferBinding[];
+    getStorageBufferList(): readonly GPUBuffer[];
+    getTextureLayoutKey(device: GPUDevice): string;
+    private invalidateProgramStructureCache;
+    private invalidateBindingCache;
+}
+
+interface RenderGraphContext {
+    readonly device: GPUDevice;
+    readonly encoder: GPUCommandEncoder;
+}
+interface RenderGraphExecutionObserver {
+    begin?(passes: readonly RenderGraphPass[], context: RenderGraphContext): void;
+    beforePass?(pass: RenderGraphPass, index: number, context: RenderGraphContext): void;
+    afterPass?(pass: RenderGraphPass, index: number, cpuTimeMs: number, context: RenderGraphContext): void;
+    end?(passes: readonly RenderGraphPass[], totalCpuTimeMs: number, context: RenderGraphContext): void;
+}
+interface RenderGraphPass {
+    readonly name: string;
+    readonly reads?: readonly string[];
+    readonly writes?: readonly string[];
+    readonly dependsOn?: readonly string[];
+    prepare?(context: RenderGraphContext): Promise<void> | void;
+    execute(context: RenderGraphContext): void;
+}
+
+declare class RenderGraph {
+    private readonly passes;
+    addPass(pass: RenderGraphPass): void;
+    executeAsync(context: RenderGraphContext, observer?: RenderGraphExecutionObserver): Promise<void>;
+    execute(context: RenderGraphContext, observer?: RenderGraphExecutionObserver): void;
+    reset(): void;
+    private resolveExecutionOrder;
+}
+
+/**
+ * Resolves a scene-authored Three material to a renderer-native WGSL material
+ * without mutating the scene's material slots. Return `undefined` to use the
+ * renderer fallback material, or `null` to intentionally skip the draw.
+ */
+type RendererMaterialResolver = (material: Material, pass?: 'opaque' | 'late') => WGSLShaderMaterial | null | undefined;
+interface RendererOptions {
+    canvas: HTMLCanvasElement;
+    /** Linear-sRGB clear color. Presentation converts it to display sRGB. */
+    clearColor?: readonly [number, number, number, number];
+    powerPreference?: GPUPowerPreference;
+    shadowMapSize?: number;
+    pointShadowMapSize?: number;
+    sampleCount?: number;
+    hiZOcclusionCulling?: boolean;
+    /**
+     * Uses Chromium's experimental multi-draw-indirect command for GPU-culled
+     * static draw sets when the adapter supports it. Defaults to true.
+     */
+    multiDrawIndirect?: boolean;
+    /** Merge compatible ordinary meshes into instanced draws each frame. Defaults to true. */
+    dynamicBatching?: boolean;
+    renderGraphProfiling?: boolean;
+    /** Internal scene resolution relative to the presentation resolution. Defaults to 1. */
+    renderScale?: number;
+    /** Material used when a mesh does not already use WGSLShaderMaterial. */
+    fallbackMaterial?: WGSLShaderMaterial;
+    /** Optional bridge for graph/material systems layered on top of Three. */
+    materialResolver?: RendererMaterialResolver;
+    /**
+     * Material used for a SkinnedMesh whose source material is not skin-aware.
+     * Defaults to the renderer's built-in lit skinned fallback.
+     */
+    fallbackSkinnedMaterial?: WGSLShaderMaterial;
+    /** Defaults to true. Disable when callbacks expect THREE.WebGLRenderer. */
+    invokeObjectRenderCallbacks?: boolean;
+}
+interface StaticDrawSetOptions {
+    label?: string;
+    onUnsupported?: "throw" | "skip";
+}
+interface StaticDrawSet {
+    readonly label: string;
+    readonly drawCount: number;
+    readonly instanceCount: number;
+    enabled: boolean;
+    dispose(): void;
+}
+interface RendererGraphBuilderContext {
+    addDirectionalShadowPass(): void;
+    addPointShadowPass(): void;
+    addSpotShadowPass(): void;
+    addDepthPrepass(): void;
+    addHiZPasses(): void;
+    addVisibilityPass(): void;
+    defineColorTarget(name: string, descriptor?: RendererColorTargetDescriptor): void;
+    defineTextureTarget(name: string, descriptor?: RendererTextureTargetDescriptor): void;
+    addForwardPass(output?: string): void;
+    addOpaquePass(output?: string): void;
+    addSceneTextureCopyPass(source?: string): void;
+    addLatePass(output?: string): void;
+    addHiZHistoryPass(dependsOn?: string): void;
+    addMaterialPass(descriptor?: RendererMaterialPassDescriptor): void;
+    addCustomPass(descriptor: RendererCustomPassDescriptor): void;
+    addPresentPass(source?: string): void;
+}
+type RendererGraphBuilder = (graph: RenderGraph, context: RendererGraphBuilderContext) => void;
+interface RendererColorTargetDescriptor {
+    readonly format?: GPUTextureFormat;
+    readonly scale?: number;
+    /** Base dimensions used by `scale`. Defaults to the internal render resolution. */
+    readonly resolution?: "render" | "presentation";
+}
+interface RendererTextureTargetDescriptor extends RendererColorTargetDescriptor {
+    readonly dimension?: "2d" | "3d";
+    readonly depthOrArrayLayers?: number;
+    readonly usage?: GPUTextureUsageFlags;
+}
+interface RendererMaterialPassDescriptor {
+    readonly name?: string;
+    readonly outputs?: string | readonly string[];
+    /** Selects which extracted scene draws are submitted. Defaults to all draws. */
+    readonly drawStage?: "all" | "opaque" | "late";
+    /** Preserve existing attachment contents instead of clearing them. */
+    readonly loadColor?: boolean;
+    /** Preserve depth written by an earlier pass. Defaults to clear. */
+    readonly loadDepth?: boolean;
+    /** Draw only objects accepted by this predicate. Intended for selection/mask passes. */
+    readonly objectFilter?: (object: Object3D | null) => boolean;
+    /** Replace each accepted draw's material while preserving its geometry and instance data. */
+    readonly overrideMaterial?: WGSLShaderMaterial | ((source: WGSLShaderMaterial, skinned: boolean) => WGSLShaderMaterial);
+}
+interface RendererShadowMapDebugTextureInfo {
+    readonly view: GPUTextureView | null;
+    readonly size: number;
+    readonly layerCount: number;
+    readonly activeLightCount: number;
+    readonly activeLayerCount: number;
+}
+interface RendererShadowMapDebugInfo {
+    readonly directional: RendererShadowMapDebugTextureInfo;
+    readonly point: RendererShadowMapDebugTextureInfo;
+    readonly spot: RendererShadowMapDebugTextureInfo;
+}
+interface RendererCustomPassContext {
+    readonly device: GPUDevice;
+    readonly camera: PerspectiveCamera | OrthographicCamera;
+    readonly encoder: GPUCommandEncoder;
+    readonly sceneColorView: GPUTextureView;
+    readonly postProcessColorView: GPUTextureView;
+    readonly presentationColorView: GPUTextureView;
+    readonly depthView: GPUTextureView | null;
+    readonly colorFormat: GPUTextureFormat;
+    readonly width: number;
+    readonly height: number;
+    readonly presentationWidth: number;
+    readonly presentationHeight: number;
+    readonly linearClampSampler: GPUSampler;
+    readonly nearestClampSampler: GPUSampler;
+    readonly comparisonSampler: GPUSampler;
+    getColorView(name: string): GPUTextureView;
+    getTextureView(name: string): GPUTextureView;
+    /** Uploads (or retrieves) a Three texture through the renderer texture cache. */
+    getExternalTexture(texture: Texture): {
+        view: GPUTextureView;
+        sampler: GPUSampler;
+    };
+    getColorFormat(name: string): GPUTextureFormat;
+    getShadowMapDebugInfo(): RendererShadowMapDebugInfo;
+    /** Shared light uniforms and shadow arrays used by the forward renderer. */
+    getSceneLightingResources(): RendererSceneLightingResources;
+}
+interface RendererSceneLightingResources {
+    readonly lightBuffer: GPUBuffer;
+    readonly directionalShadowView: GPUTextureView;
+    readonly pointShadowView: GPUTextureView;
+    readonly spotShadowView: GPUTextureView;
+}
+interface RendererCustomPassDescriptor {
+    readonly name: string;
+    readonly reads?: readonly string[];
+    readonly writes?: readonly string[];
+    readonly dependsOn?: readonly string[];
+    execute(context: RendererCustomPassContext): void;
+}
+interface RendererPassProfile {
+    name: string;
+    cpuTimeMs: number;
+    gpuTimeMs: number | null;
+}
+interface RendererVisibilityProfile {
+    totalInstances: number;
+    visibleInstances: number;
+    culledInstances: number;
+    dynamicTotalInstances: number;
+    dynamicVisibleInstances: number;
+    staticTotalInstances: number;
+    staticVisibleInstances: number;
+}
+interface RendererFrameProfile {
+    frameIndex: number;
+    cpuTimeMs: number;
+    gpuTimeMs: number | null;
+    drawCallCount: number;
+    triangleCount: number;
+    cpuPhases: {
+        extractSceneMs: number;
+        uploadMs: number;
+        renderGraphMs: number;
+    };
+    passes: RendererPassProfile[];
+    timestampQuerySupported: boolean;
+    timestampQueryActive: boolean;
+    gpuProfilingReason: string | null;
+    hiZOcclusionCullingEnabled: boolean;
+    hiZOcclusionCullingActive: boolean;
+    /** Delayed GPU readback of the indirect instance counts produced by visibility culling. */
+    visibility: RendererVisibilityProfile | null;
+}
+
+type FrameGraphTextureHandle = string;
+interface FrameGraphPassDescriptor {
+    readonly name: string;
+    readonly inputs?: Record<string, FrameGraphTextureHandle>;
+    readonly outputs?: FrameGraphTextureHandle | readonly FrameGraphTextureHandle[];
+    readonly dependsOn?: readonly string[];
+    execute(context: RendererCustomPassContext): void;
+}
+interface FrameGraphFullscreenPassDescriptor {
+    readonly name: string;
+    readonly inputs: Record<string, FrameGraphTextureHandle>;
+    /** Dimensionality override for non-2D graph inputs such as froxel volumes. */
+    readonly inputDimensions?: Record<string, "2d" | "3d">;
+    readonly outputs: FrameGraphTextureHandle | readonly FrameGraphTextureHandle[];
+    readonly fragmentShader: string;
+    /**
+     * Standalone Three textures bound as `<name>Texture` and `<name>Sampler`.
+     * Use this for lookup/noise/LUT textures that are not frame-graph targets.
+     */
+    readonly textures?: Record<string, Texture>;
+    readonly sampler?: "linear" | "nearest";
+    readonly uniformBufferSize?: number;
+    readonly updateUniforms?: (context: RendererCustomPassContext) => ArrayBufferView | null;
+}
+/** Structural contract returned by three-shader-graph's fullscreen compiler. */
+interface CompiledNodeFullscreenShader {
+    readonly fragmentShader: string;
+    readonly uniforms: Record<string, UniformDefinition>;
+    /** Standalone Three textures collected from nodes such as textureSampler2d(). */
+    readonly textures?: Record<string, Texture>;
+    readonly graphTextures: Record<string, WGSLGraphTextureInput>;
+    /** Legacy semantic bindings emitted by existing node-material adapters. */
+    readonly sceneTextures?: Record<string, "sceneColor" | "sceneDepth">;
+    syncLiveUniforms(uniforms: Record<string, {
+        value: UniformValue;
+    }>): void;
+}
+interface FrameGraphNodeFullscreenPassDescriptor {
+    readonly name: string;
+    readonly shader: CompiledNodeFullscreenShader;
+    /** Overrides frame-graph resources for named compiled graph/scene texture bindings. */
+    readonly inputOverrides?: Record<string, FrameGraphTextureHandle>;
+    readonly outputs: FrameGraphTextureHandle | readonly FrameGraphTextureHandle[];
+}
+interface FrameGraphMaterialPassDescriptor {
+    readonly name?: string;
+    readonly outputs?: FrameGraphTextureHandle | readonly FrameGraphTextureHandle[];
+    readonly drawStage?: "all" | "opaque" | "late";
+    readonly loadColor?: boolean;
+    readonly loadDepth?: boolean;
+    readonly objectFilter?: (object: Object3D | null) => boolean;
+    readonly overrideMaterial?: WGSLShaderMaterial | ((source: WGSLShaderMaterial, skinned: boolean) => WGSLShaderMaterial);
+}
+declare class FrameGraphBuilder {
+    private readonly context;
+    readonly sceneColor = "sceneColor";
+    readonly mainDepth = "mainDepth";
+    readonly postProcessColor = "postProcessColor";
+    constructor(context: RendererGraphBuilderContext);
+    createColorTarget(name: string, descriptor?: RendererColorTargetDescriptor): FrameGraphTextureHandle;
+    createTextureTarget(name: string, descriptor?: RendererTextureTargetDescriptor): FrameGraphTextureHandle;
+    addStandardScenePasses(forwardOutput?: FrameGraphTextureHandle): void;
+    addDirectionalShadowPass(): void;
+    addPointShadowPass(): void;
+    addSpotShadowPass(): void;
+    addDepthPrepass(): void;
+    addHiZPasses(): void;
+    addVisibilityPass(): void;
+    addForwardPass(output?: FrameGraphTextureHandle): void;
+    addOpaquePass(output?: FrameGraphTextureHandle): void;
+    addSceneTextureCopyPass(source?: FrameGraphTextureHandle): void;
+    addLatePass(output?: FrameGraphTextureHandle): void;
+    addHiZHistoryPass(dependsOn?: string): void;
+    addMaterialPass(descriptor?: FrameGraphMaterialPassDescriptor): void;
+    addPass(descriptor: FrameGraphPassDescriptor): void;
+    addFullscreenPass(descriptor: FrameGraphFullscreenPassDescriptor): void;
+    addNodeFullscreenPass(descriptor: FrameGraphNodeFullscreenPassDescriptor): void;
+    present(source?: FrameGraphTextureHandle): void;
+}
+
+type VolumetricFogScatteringMode = "volumetric" | "lightShaft";
+/** Kept structurally compatible with Hology's legacy FogVolumeSettings. */
+interface VolumetricFogVolumeSettings {
+    readonly object: Object3D;
+    baseDensity: number;
+    heightFalloff: number;
+    heightOffset: number;
+    startDistance?: number;
+    scatteringDistribution: number;
+    albedo: Color;
+    emissive: Color;
+    ambientIntensity?: number;
+    scatteringMode: VolumetricFogScatteringMode;
+}
+/** Scene marker compatible with legacy objects through `isFogVolumeObject`. */
+declare class VolumetricFogVolumeObject extends Object3D {
+    readonly volume: VolumetricFogVolumeSettings;
+    readonly isFogVolumeObject = true;
+    constructor(volume: VolumetricFogVolumeSettings);
+}
+interface VolumetricFogOptions {
+    /** Froxel width/height in pixels. 8 is a good desktop default. */
+    readonly froxelPixelSize?: number;
+    /** Logarithmically distributed depth slices. */
+    readonly depthSlices?: number;
+    /** Deterministic integration samples within each depth slice. */
+    readonly integrationSubsteps?: 1 | 2 | 4;
+    readonly maxDistance?: number;
+    readonly targetPrefix?: string;
+    readonly maxVolumes?: number;
+    readonly maxDirectionalLights?: number;
+    readonly maxPointLights?: number;
+    readonly maxSpotLights?: number;
+    /** Used when the scene has no ambient or hemisphere light. */
+    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. */
+    readonly temporalJitter?: boolean;
+    /** Stable per-ray depth jitter. Breaks slice bands without animated noise. */
+    readonly spatialJitter?: boolean;
+    /** Final fog-gradient dithering in approximate 8-bit code values. */
+    readonly fogDitherStrength?: number;
+    /** Artistic multiplier for direct in-scattering. Does not change extinction. */
+    readonly scatteringIntensity?: number;
+    /** Optional separable, depth-aware blur of the resolved fog buffer. */
+    readonly blur?: false | VolumetricFogBlurOptions;
+}
+interface VolumetricFogBlurOptions {
+    /** Resolution relative to the render target. Defaults to 0.5. */
+    readonly scale?: number;
+    /** Kernel radius per direction, from 1 to 12. Defaults to 5. */
+    readonly radius?: number;
+    /** Log-depth rejection sigma. 0.05 allows about 5% relative depth variation. */
+    readonly depthSigma?: number;
+    /** Gaussian spatial sigma in fog-buffer pixels. */
+    readonly spatialSigma?: number;
+    /** Preserve depth discontinuities during the final upsample. Costs extra depth reads. Defaults to true. */
+    readonly depthAwareUpsample?: boolean;
+}
+interface VolumetricFogInputs {
+    readonly sceneColor: FrameGraphTextureHandle;
+    readonly depth: FrameGraphTextureHandle;
+    /** Explicit volumes can be mixed with compatible scene marker objects. */
+    readonly volumes?: readonly VolumetricFogVolumeSettings[];
+}
+/**
+ * Compute-driven froxel fog. Add it after opaque rendering and before the late
+ * transparent pass. Existing content can use the composite output; transparent
+ * materials can sample `integratedVolume` with configureVolumetricFogMaterial.
+ */
+declare class VolumetricFogEffect {
+    private scene;
+    readonly integratedVolume: FrameGraphTextureHandle;
+    readonly columnDepthBounds: FrameGraphTextureHandle;
+    private readonly options;
+    private readonly resources;
+    private readonly uniformStorage;
+    private readonly uniforms;
+    private readonly uniformIntegers;
+    private readonly volumeData;
+    private readonly lightData;
+    private readonly projectionInverse;
+    private readonly viewProjectionInverse;
+    private explicitVolumes;
+    private cascadeDirectionalLights;
+    private compositePass;
+    private readonly blurPassCache;
+    private frameIndex;
+    constructor(scene?: Scene, options?: VolumetricFogOptions);
+    /** Updates the scene traversed for compatible volumes and lights. */
+    setScene(scene: Scene): 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;
+    dispose(): void;
+    private executeFroxels;
+    private collectSceneData;
+    private writeVolume;
+    private lightColor;
+    private writeDirectional;
+    private writePoint;
+    private writeSpot;
+    private getResources;
+}
+/** WGSL appended to a material that calls rendererApplyVolumetricFog(). */
+declare const VOLUMETRIC_FOG_MATERIAL_WGSL = "\nfn rendererSampleIntegratedFog(uv: vec2<f32>, normalizedDepth: f32) -> vec4<f32> {\n  let sliceCount = f32(textureDimensions(volumetricFogTexture).z);\n  let slicePosition = clamp(normalizedDepth, 0.0, 1.0) * sliceCount;\n  let textureZ = clamp((slicePosition - 0.5) / sliceCount, 0.0, 1.0);\n  let integrated = textureSampleLevel(volumetricFogTexture, volumetricFogSampler, vec3<f32>(uv, textureZ), 0.0);\n  // The volume stores slice endpoints but has no texel for the near-plane\n  // identity value. Reconstruct that missing endpoint for the first slice.\n  return mix(vec4<f32>(0.0, 0.0, 0.0, 1.0), integrated, min(slicePosition, 1.0));\n}\nfn rendererApplyVolumetricFog(color: vec4<f32>, worldPosition: vec3<f32>) -> vec4<f32> {\n  let clip = rendererCamera.viewProj * vec4<f32>(worldPosition, 1.0);\n  let uv = clip.xy / clip.w * vec2<f32>(0.5, -0.5) + vec2<f32>(0.5);\n  let distance = length(worldPosition - rendererCamera.cameraPosition.xyz);\n  let bounds = textureSampleLevel(volumetricFogBoundsTexture, volumetricFogBoundsSampler, uv, 0.0).rg;\n  let z = clamp((distance - bounds.x) / max(bounds.y - bounds.x, 0.001), 0.0, 1.0);\n  let fog = rendererSampleIntegratedFog(uv, z);\n  return vec4<f32>(fog.rgb + color.rgb * fog.a, color.a);\n}";
+/** Adds the froxel input; append VOLUMETRIC_FOG_MATERIAL_WGSL and call its helper in fsMain. */
+declare function configureVolumetricFogMaterial(material: WGSLShaderMaterial, resource?: string, boundsResource?: string): WGSLShaderMaterial;
+
+interface TextureResource {
+    version: number;
+    width: number;
+    height: number;
+    depthOrArrayLayers: number;
+    format: GPUTextureFormat;
+    textureDimension: GPUTextureDimension;
+    viewDimension: GPUTextureViewDimension;
+    sampleType: GPUTextureSampleType;
+    samplerBindingType: GPUSamplerBindingType;
+    mipLevelCount: number;
+    texture: GPUTexture;
+    view: GPUTextureView;
+    sampler: GPUSampler;
+}
+
+interface WebGpuPMREMGeneratorContext {
+    device: GPUDevice;
+    getTextureResource(texture: Texture): TextureResource;
+    registerTextureResource(texture: Texture, resource: TextureResource): void;
+}
+/** Native WebGPU implementation of Three's equirectangular CubeUV PMREM path. */
+declare class WebGpuPMREMGenerator {
+    private readonly context;
+    private readonly equirectPipeline;
+    private readonly blurPipeline;
+    private readonly equirectBindGroupLayout;
+    private readonly blurBindGroupLayout;
+    private readonly maxBlurSamples;
+    constructor(context: WebGpuPMREMGeneratorContext, maxBlurSamples?: number);
+    fromEquirectangular(source: Texture): {
+        texture: Texture;
+        dispose(): void;
+    };
+    private encodeBlurPass;
+}
+
+/** Compatible with the legacy OutlineEffect material.userData contract. */
+type ToonOutlineParameters = {
+    /** View-distance-scaled normal extrusion. Defaults to 0.003. */
+    thickness?: number;
+    /** Linear RGB outline color. Defaults to black. */
+    color?: readonly [number, number, number] | readonly number[];
+    /** Defaults to the source material's opacity. */
+    alpha?: number;
+    /** Set to false to suppress the otherwise enabled outline. */
+    visible?: boolean;
+};
+declare class WebGpuRenderer {
+    readonly canvas: HTMLCanvasElement;
+    private readonly clearColor;
+    private readonly powerPreference;
+    private readonly shadowMapSize;
+    private readonly pointShadowMapSize;
+    private readonly fallbackMaterial;
+    private readonly materialResolver;
+    private readonly toonOutlineMaterialCache;
+    private readonly fallbackSkinnedMaterial;
+    private readonly invokeObjectRenderCallbacks;
+    private sampleCount;
+    private renderScale;
+    private hiZOcclusionCullingEnabled;
+    private multiDrawIndirectEnabled;
+    private dynamicBatchingEnabled;
+    private multiDrawIndirectSupported;
+    private renderGraphProfilingEnabled;
+    private indirectFirstInstanceSupported;
+    private timestampQuerySupported;
+    private readonly geometryCache;
+    private readonly skinnedGeometryCache;
+    private readonly skinPaletteCache;
+    private readonly skinPaletteResources;
+    private readonly meshExtractionCache;
+    /**
+     * Material resolvers may synchronise live graph uniforms or replace the
+     * generated WGSL material. Resolve each source material once per extraction
+     * so regular meshes see that change without paying resolver work per mesh.
+     */
+    private readonly resolvedMaterialFrameCache;
+    private readonly instancedMeshExtractionCache;
+    private readonly batchedMeshExtractionCache;
+    private readonly materialCache;
+    private readonly skinnedMaterialCache;
+    private readonly materialCacheVisible;
+    private readonly materialCacheDirect;
+    private readonly materialNoReceiveShadowCache;
+    private readonly skinnedMaterialNoReceiveShadowCache;
+    private readonly materialNoReceiveShadowCacheVisible;
+    private readonly materialNoReceiveShadowCacheDirect;
+    private readonly depthPrepassMaterialCache;
+    private readonly directionalShadowMaterialCache;
+    private readonly skinnedDirectionalShadowMaterialCache;
+    private readonly directionalShadowMaterialCacheDirect;
+    private readonly lineMaterialCache;
+    private readonly lineBasicMaterialCache;
+    private readonly lineProxyCache;
+    private readonly spriteProxyCache;
+    private readonly depthMaterialFrameCache;
+    /**
+     * Common scene/depth variants can be resolved without rebuilding their full
+     * shader cache key. Material.version and the texture-version hash provide
+     * the same cheap validity gate already used by draw-local resource caching.
+     */
+    private readonly forwardMaterialFastCache;
+    /** Fast variants for MRT/non-default target format combinations. */
+    private readonly forwardMaterialTargetFastCache;
+    private readonly forwardMaterialFrameCache;
+    private readonly depthMaterialFastCache;
+    private readonly sharedForwardPipelineCache;
+    private readonly sharedForwardPipelinePromiseCache;
+    private readonly sharedDepthPipelineCache;
+    private readonly sharedDepthPipelinePromiseCache;
+    private readonly state;
+    private readonly textureCache;
+    private readonly graphTextureBindGroupCache;
+    private readonly materialGraphTextureReadCache;
+    /**
+     * A custom instanced attribute is indexed by WebGPU's global
+     * `instance_index`. Keep shared default buffers large enough for the packed
+     * renderer instance range instead of binding one value at index zero.
+     */
+    private readonly defaultInstanceAttributeBuffers;
+    private readonly textureManager;
+    private readonly renderGraph;
+    private readonly directionalShadowCameras;
+    private readonly pointShadowCameras;
+    private readonly spotShadowCameras;
+    private readonly colorTargetCache;
+    private readonly msaaColorTargetCache;
+    private readonly msaaDepthTargetCache;
+    private readonly sourceInstanceDataScratch;
+    private readonly opaqueInstanceDataScratch;
+    private readonly finalInstanceDataScratch;
+    private readonly residentInstanceUploadsScratch;
+    private readonly gpuOpaqueDrawsScratch;
+    private readonly directOpaqueDrawsScratch;
+    private readonly stagedOpaqueDrawsScratch;
+    private readonly residentOpaqueDrawsScratch;
+    private readonly retiredGeometryResources;
+    private readonly retiredGeometryBuffers;
+    private readonly vertexAttributeBufferKeyCache;
+    private readonly standardVertexAttributeCache;
+    private readonly geometryVertexBufferFastCache;
+    private readonly vertexAttributeGroupCache;
+    private readonly vertexAttributeGroupBufferKeyCache;
+    private readonly compileDrawScratch;
+    private readonly indirectSubmissionStreamsScratch;
+    private readonly renderBundleScratch;
+    private readonly directBundleDrawStatsScratch;
+    private readonly sortedOpaqueBatchesScratch;
+    private readonly opaqueBatchPool;
+    private opaqueBatchPoolCount;
+    private readonly drawCallPool;
+    private drawCallPoolCount;
+    private readonly staticDrawSets;
+    private materialPassStaticBundleCache;
+    private readonly staticDrawSetManager;
+    private staticFrameToken;
+    private hizResourceVersion;
+    private graphTextureResourceVersion;
+    private readonly visibilityParamsUpload;
+    private drawMetadataUpload;
+    private indirectDrawUpload;
+    private readonly extractedAmbientScratch;
+    private readonly extractedHemisphereScratch;
+    private readonly extractedBoundsMinScratch;
+    private readonly extractedBoundsMaxScratch;
+    private readonly extractedDirectionalLightsScratch;
+    private readonly extractedPointLightsScratch;
+    private readonly extractedSpotLightsScratch;
+    private readonly activeDirectionalLightsScratch;
+    private readonly activePointLightsScratch;
+    private readonly activeSpotLightsScratch;
+    private readonly resolvedMeshMaterialsScratch;
+    private readonly extractedLightsScratch;
+    private readonly extractedFrameScratch;
+    private readonly cameraUniformScratch;
+    private readonly temporalVisibilityUniformScratch;
+    private readonly lightUniformScratch;
+    private readonly csmCascadeRanges;
+    private csmCascadeCount;
+    private csmCascadeLights;
+    private readonly shadowCameraUniformScratch;
+    private readonly cameraViewProjScratch;
+    private readonly cameraProjectionScratch;
+    private readonly projectionJitterPixels;
+    private readonly temporalVisibilityCurrentViewProj;
+    private readonly temporalVisibilityPreviousViewProj;
+    private readonly cameraFrustumPlanesScratch;
+    private readonly objectTraversalStackScratch;
+    private readonly isSphereVisibleScratch;
+    private readonly updateExtractedBoundsFromMatrixScratch;
+    private readonly transparentSortCameraPositionScratch;
+    private readonly transparentSortCameraForwardScratch;
+    private readonly temporalVisibilityCurrentCameraPosition;
+    private readonly temporalVisibilityPreviousCameraPosition;
+    private readonly shadowViewProjScratch;
+    private extractionVersion;
+    private graphBuilder;
+    private createExtractedDirectionalLightScratch;
+    private createExtractedHemisphereLightScratch;
+    private createExtractedPointLightScratch;
+    private createExtractedSpotLightScratch;
+    constructor(options: RendererOptions);
+    private resolveMaterial;
+    private resolveLineMaterial;
+    private resolveLineBasicMaterial;
+    private resolveSkinnedMaterial;
+    private hasRenderCallbacks;
+    initialize(): Promise<void>;
+    createComputeKernel(descriptor: ComputeKernelDescriptor): ComputeKernel;
+    setRenderGraphBuilder(builder: RendererGraphBuilder): void;
+    /**
+     * Associates the first directional shadow layers with cascaded-shadow-map
+     * depth intervals. Submit the same normalized pairs returned by Hology's
+     * CSM#getExtendedBreaks(); the matching directional lights remain ordinary
+     * scene lights and are rendered through the existing shadow passes.
+     */
+    setCascadedShadowRanges(ranges: readonly {
+        readonly x: number;
+        readonly y: number;
+    }[], lights?: readonly DirectionalLight[]): void;
+    setRenderGraphProfilingEnabled(enabled: boolean): void;
+    getRenderGraphProfilingEnabled(): boolean;
+    getTimestampQuerySupported(): boolean;
+    getSampleCount(): number;
+    setSampleCount(sampleCount: number): void;
+    /** Sets the internal scene resolution while preserving presentation size. */
+    setRenderScale(renderScale: number): void;
+    getRenderScale(): number;
+    /**
+     * Offsets the GPU raster projection in internal-render-resolution pixels.
+     * The authored camera remains unchanged, so controls, culling, and raycasts
+     * continue to use its stable projection.
+     */
+    setProjectionJitter(x: number, y: number): void;
+    clearProjectionJitter(): void;
+    getLastFrameProfile(): RendererFrameProfile | null;
+    setHiZOcclusionCullingEnabled(enabled: boolean): void;
+    getHiZOcclusionCullingEnabled(): boolean;
+    getHiZOcclusionCullingActive(): boolean;
+    setMultiDrawIndirectEnabled(enabled: boolean): void;
+    getMultiDrawIndirectEnabled(): boolean;
+    setDynamicBatchingEnabled(enabled: boolean): void;
+    getDynamicBatchingEnabled(): boolean;
+    getMultiDrawIndirectSupported(): boolean;
+    getMultiDrawIndirectActive(): boolean;
+    setSize(width: number, height: number, pixelRatio?: number): void;
+    setClearColor(color: readonly [number, number, number, number]): void;
+    render(scene: Scene, camera: PerspectiveCamera | OrthographicCamera, timeSeconds?: number): void;
+    renderAsync(scene: Scene, camera: PerspectiveCamera | OrthographicCamera, timeSeconds?: number): Promise<void>;
+    compile(scene: Scene, camera: PerspectiveCamera | OrthographicCamera): void;
+    compileAsync(scene: Scene, camera: PerspectiveCamera | OrthographicCamera): Promise<void>;
+    /**
+     * Creates a Three-compatible CubeUV PMREM generator. Its output is a
+     * HalfFloat Texture and can be assigned directly to a graph material's
+     * `envMap` uniform or to `scene.environment` before material resolution.
+     */
+    createPMREMGenerator(maxBlurSamples?: number): WebGpuPMREMGenerator;
+    /**
+     * Creates and uploads a texture resource immediately instead of waiting for
+     * the texture to be encountered while building a material bind group.
+     *
+     * Repeated calls reuse the cached resource while the Three.js texture
+     * version and GPU binding descriptor are unchanged.
+     */
+    initTexture(texture: Texture): void;
+    createStaticDrawSet(root: Object3D, options?: StaticDrawSetOptions): StaticDrawSet;
+    private disposeStaticDrawSetResource;
+    private renderFrame;
+    destroy(): void;
+    private createStaticPipelines;
+    private recreateShadowResources;
+    private ensureShadowTextureSizes;
+    private ensureColorTarget;
+    private ensureMsaaColorTarget;
+    private ensureMsaaDepthTarget;
+    private destroyMsaaResources;
+    private getColorTargetView;
+    private ensureTextureTarget;
+    private getColorTargetTexture;
+    private getColorTargetDimensions;
+    private getColorTargetFormat;
+    private getMaterialGraphTextureReads;
+    private createGraphBuilderContext;
+    private transparentDraws;
+    private opaqueBatches;
+    private acquireDrawCall;
+    private acquireOpaqueBatchBuilder;
+    private populateDrawCall;
+    private populateDynamicDrawCall;
+    private pushOpaqueDrawTemplate;
+    private pushDraw;
+    private getToonOutlineParameters;
+    private getToonOutlineMaterial;
+    private pushToonOutlineDraw;
+    private updateTransparentDrawSortDepths;
+    private extractScene;
+    private collectLine;
+    /**
+     * Three.js sprites carry a shared quad geometry but are Object3Ds rather
+     * than Meshes. Adapt them to the ordinary draw path; the material's vertex
+     * shader is responsible for billboard orientation. Sprite.center is an
+     * object property, so bake its offset into a private quad instead of putting
+     * it on the (potentially shared) material.
+     */
+    private collectSprite;
+    private hasExtractedDirectionalLight;
+    private collectMesh;
+    private prepareSceneForCompilation;
+    private collectInstancedMesh;
+    private collectSkinnedMesh;
+    private collectBatchedMesh;
+    private uploadInstanceData;
+    private uploadResidentInstanceData;
+    private clearIndirectBundleCache;
+    private clearStaticDrawSetBundleCaches;
+    /**
+     * Three addon objects (notably Line2/LineSegments2) query this from their
+     * onBeforeRender hook to keep their source material's resolution current.
+     * The renderer's line shader uses the same physical-pixel dimensions.
+     */
+    getViewport(target: Vector4): Vector4;
+    private getSharedSceneBindGroup;
+    private getSharedShadowBindGroup;
+    private getShadowCameraBuffer;
+    private getSharedShadowBindGroupForCameraBuffer;
+    private buildIndirectSubmissionStreams;
+    private getOrCreateStaticIndirectSubmissionStreams;
+    private getOrCreateIndirectForwardBundle;
+    private getDirectForwardBundleKey;
+    private getOrCreateDirectForwardBundle;
+    private getOrCreateStaticMaterialBundle;
+    private resolveSceneBindGroupForDraw;
+    private resolveShadowBindGroupForDraw;
+    private uploadDrawMetadata;
+    private recordDraw;
+    private executeVisibilityPass;
+    private executeStaticVisibilityPasses;
+    private getOrCreateStaticVisibilityBindGroup;
+    private executeDirectionalShadowPass;
+    private executePointShadowPass;
+    private executeSpotShadowPass;
+    private executeDepthPrepass;
+    private executeStaticDepthPrepass;
+    private executeStaticTemporalDepthResolvePass;
+    private getOrCreateStaticDepthPrepassBundle;
+    private executeHiZPasses;
+    private getOrCreateStaticVisibleSceneBindGroup;
+    private getOrCreateStaticVisibleDepthSceneBindGroup;
+    private executeMaterialPass;
+    private executeForwardPass;
+    private executeStaticForwardPass;
+    private getOrCreateStaticDirectForwardBundle;
+    private refreshStaticDrawMaterialResources;
+    private syncStaticVisibleMaterialBindingCaches;
+    private recordStaticDrawStats;
+    private hasEnabledStaticDrawSets;
+    private executePresentPass;
+    private clearDirectionalShadow;
+    private clearPointShadow;
+    private clearSpotShadow;
+    private drawDepthLike;
+    private getGeometryResource;
+    private getSkinnedGeometryResource;
+    private getSkinningPalette;
+    private refreshSkinningPalette;
+    private refreshSkinningBindMatrices;
+    private uploadSkinningResources;
+    private createSkinningBoneBounds;
+    private updateSkinnedBounds;
+    private createGeometryBuffers;
+    private createVertexBufferLayouts;
+    /**
+     * A shader location is not a GPU vertex-buffer slot. Keep the simple
+     * one-attribute-per-buffer path while it fits, then interleave attributes
+     * with the same step mode so optional material attributes cannot exceed the
+     * device's vertex-buffer limit.
+     */
+    private getVertexAttributeGroups;
+    private getGeometryAttributeBufferKey;
+    private getGeometryAttributeGroupBufferKey;
+    private getMaterialVertexAttributes;
+    private getGeometryVertexBuffer;
+    private cacheGeometryVertexBufferFast;
+    private getInterleavedGeometryVertexBuffer;
+    private ensureWireframeIndex;
+    private bindGeometryVertexBuffers;
+    private getDefaultInstanceAttributeBuffer;
+    private getMeshExtractionCacheEntry;
+    private getInstancedMeshExtractionCacheEntry;
+    private getBatchedMeshExtractionCacheEntry;
+    private batchedGeometryIdsMatchSnapshot;
+    private destroyGeometryResource;
+    private retireGeometryResource;
+    private releaseRetiredGeometryResourcesAfterSubmit;
+    private destroyTextureResource;
+    private createTextureSampler;
+    private uploadDataTextureResource;
+    private uploadCompressedTextureResource;
+    private uploadExternalTextureResource;
+    private uploadTextureResource;
+    private getTextureResource;
+    private updateMaterialUniformBuffer;
+    private materialResourceMatches;
+    private destroyMaterialResource;
+    private createMaterialBindGroupData;
+    private createGraphTextureBindGroupLayout;
+    private createGraphTextureBindGroup;
+    private getGraphTextureView;
+    private compileDrawMaterials;
+    private compileDrawMaterialsAsync;
+    private compileStaticDrawMaterialsAsync;
+    private getDepthPassMaterialKey;
+    private getForwardMaterialKey;
+    private getInstanceAccessModeIndex;
+    private getForwardMaterialFastCacheIndex;
+    private getDepthMaterialFastCacheIndex;
+    private fastMaterialResourceMatches;
+    private setForwardMaterialFastCache;
+    private getForwardMaterialTargetFastCacheKey;
+    private setForwardMaterialTargetFastCache;
+    private setForwardMaterialFrameCache;
+    private setDepthMaterialFastCache;
+    private getDrawInstanceAccessMode;
+    private drawUsesBatching;
+    private buildMaterialShaderCode;
+    private createMaterialPreprocessorDefines;
+    private createTexturePreprocessorDefines;
+    private shouldInvalidateDrawMaterialResource;
+    private cachedDrawMaterialResourceMatches;
+    private getMaterialResourceForDraw;
+    private getMaterialResourceAsyncForDraw;
+    private resolveForwardMaterialResources;
+    private getDepthPassMaterialResourceForDraw;
+    private getDepthPassMaterialResourceAsyncForDraw;
+    private getOrCreateSharedDepthPipeline;
+    private getOrCreateSharedDepthPipelineAsync;
+    private getOrCreateSharedForwardPipeline;
+    private getOrCreateSharedForwardPipelineAsync;
+    private getDepthPassMaterialResource;
+    private setDepthMaterialFrameCache;
+    private getDepthPassMaterialResourceAsync;
+    private getMaterialResource;
+    private getMaterialResourceAsync;
+    private updateCameraUniforms;
+    private updateTemporalVisibilityUniforms;
+    private commitTemporalHiZHistory;
+    private updateLightUniforms;
+    private writeShadowCameraBuffer;
+}
+
+interface GTAODenoiseOptions {
+    readonly radius?: number;
+    readonly depthPhi?: number;
+    readonly normalPhi?: number;
+    readonly lumaPhi?: number;
+}
+interface GTAOOptions {
+    /** Resolution relative to the render target. Defaults to 1. */
+    readonly resolutionScale?: number;
+    readonly radius?: number;
+    readonly thickness?: number;
+    readonly distanceExponent?: number;
+    readonly distanceFalloff?: number;
+    readonly directions?: number;
+    readonly steps?: number;
+    /** Space used by the encoded normal input. Defaults to world. */
+    readonly normalSpace?: "world" | "view";
+    readonly denoise?: false | GTAODenoiseOptions;
+    readonly targetPrefix?: string;
+}
+interface GTAOInputs {
+    readonly depth: FrameGraphTextureHandle;
+    readonly normal: FrameGraphTextureHandle;
+}
+interface GTAOCompositeOptions {
+    readonly intensity?: number;
+    readonly power?: number;
+    readonly output?: FrameGraphTextureHandle;
+}
+/** Reusable GTAO pass pair. The caller controls where AO is composited. */
+declare class GTAOEffect {
+    private readonly options;
+    private readonly noiseTexture;
+    private readonly gtaoPasses;
+    private readonly denoisePasses;
+    private readonly compositePasses;
+    constructor(options?: GTAOOptions);
+    addPasses(graph: FrameGraphBuilder, inputs: GTAOInputs): FrameGraphTextureHandle;
+    addCompositePass(graph: FrameGraphBuilder, sceneColor: FrameGraphTextureHandle, ambientOcclusion: FrameGraphTextureHandle, options?: GTAOCompositeOptions): FrameGraphTextureHandle;
+    dispose(): void;
+}
+
+interface SSROptions {
+    /** Resolution relative to the main render target. Defaults to 0.5. */
+    readonly resolutionScale?: number;
+    /** Maximum ray length in view-space units. */
+    readonly maxDistance?: number;
+    /** Maximum separation between the ray and the depth buffer at a hit. */
+    readonly thickness?: number;
+    readonly intensity?: number;
+    /** Fade reflections with ray distance. Uses a squared falloff by default. */
+    readonly distanceAttenuation?: boolean;
+    /** Surfaces at or above this roughness do not receive SSR. */
+    readonly maxRoughness?: number;
+    readonly steps?: number;
+    /** Screen pixels advanced per ray step. One preserves reference quality. */
+    readonly pixelStride?: number;
+    /** Space used by the encoded normal input. Defaults to world. */
+    readonly normalSpace?: "world" | "view";
+    readonly blur?: boolean;
+    /** Maximum rough-reflection blur radius in reflection-target pixels. */
+    readonly blurRadius?: number;
+    readonly targetPrefix?: string;
+}
+interface SSRInputs {
+    readonly sceneColor: FrameGraphTextureHandle;
+    readonly depth: FrameGraphTextureHandle;
+    /** RGB contains an encoded normal, alpha contains perceptual roughness. */
+    readonly normalRoughness: FrameGraphTextureHandle;
+}
+/** Screen-space reflections with an edge-aware spatial resolve. */
+declare class SSREffect {
+    private readonly options;
+    private readonly passes;
+    constructor(options?: SSROptions);
+    addPasses(graph: FrameGraphBuilder, inputs: SSRInputs): FrameGraphTextureHandle;
+}
+
+interface TemporalAAOptions {
+    /** Internal render resolution relative to presentation. Defaults to 1. */
+    readonly renderScale?: number;
+    /** Number of Halton samples before the sequence repeats. Defaults to 32. */
+    readonly sampleCount?: number;
+    /** Current-frame contribution for static pixels. Defaults to 0.06. */
+    readonly minCurrentWeight?: number;
+    /** Motion in pixels that reaches full current-frame weight. Defaults to 24. */
+    readonly motionWeightScale?: number;
+    /** Absolute depth rejection threshold. Defaults to 0.001. */
+    readonly depthThreshold?: number;
+    /** Relative depth rejection threshold. Defaults to 0.002. */
+    readonly relativeDepthThreshold?: number;
+    readonly targetPrefix?: string;
+}
+declare class TemporalAAEffect {
+    readonly renderScale: number;
+    private readonly sampleCount;
+    private readonly minCurrentWeight;
+    private readonly motionWeightScale;
+    private readonly depthThreshold;
+    private readonly relativeDepthThreshold;
+    private readonly targetPrefix;
+    private writeIndex;
+    private historyValid;
+    private frameIndex;
+    private renderWidth;
+    private renderHeight;
+    private outputWidth;
+    private outputHeight;
+    private readonly jitter;
+    private readonly unjitteredProjection;
+    private readonly previousJitterUv;
+    readonly currentJitterUv: Vector2;
+    readonly previousViewProjection: Matrix4;
+    private readonly resolvePasses;
+    constructor(options?: TemporalAAOptions);
+    /** Apply one non-accumulating sub-pixel jitter immediately before rendering. */
+    prepareCamera(camera: {
+        projectionMatrix: Matrix4;
+        projectionMatrixInverse?: Matrix4;
+        updateProjectionMatrix(): void;
+    }, presentationWidth: number, presentationHeight: number): void;
+    /** Restore the unjittered projection after rendering for non-render systems. */
+    finishCamera(camera: {
+        projectionMatrix: Matrix4;
+        projectionMatrixInverse?: Matrix4;
+    }): void;
+    addPass(graph: FrameGraphBuilder, currentColor: FrameGraphTextureHandle, currentDepth?: FrameGraphTextureHandle): FrameGraphTextureHandle;
+    reset(): void;
+    private setSize;
+    updateResolveUniforms(uniforms: Float32Array, currentViewProjection: Matrix4, currentViewProjectionInverse: Matrix4, context: RendererCustomPassContext): void;
+}
+
+interface FXAAOptions {
+    /** Minimum local luminance contrast treated as an edge. Defaults to 0.0312. */
+    readonly contrastThreshold?: number;
+    /** Edge threshold relative to the brightest local sample. Defaults to 0.063. */
+    readonly relativeThreshold?: number;
+    /** Low-contrast subpixel aliasing removal strength, from 0 to 1. Defaults to 0.75. */
+    readonly subpixelBlending?: number;
+    readonly targetPrefix?: string;
+}
+interface FXAACompositeOptions {
+    readonly output?: FrameGraphTextureHandle;
+}
+/** Fast, single-pass post-process antialiasing based on NVIDIA FXAA 3.11. */
+declare class FXAAEffect {
+    contrastThreshold: number;
+    relativeThreshold: number;
+    subpixelBlending: number;
+    private readonly targetPrefix;
+    private readonly passes;
+    constructor(options?: FXAAOptions);
+    addPass(graph: FrameGraphBuilder, source: FrameGraphTextureHandle, options?: FXAACompositeOptions): FrameGraphTextureHandle;
+}
+
+interface BloomOptions {
+    /** Overall bloom contribution. Defaults to 0.9. */
+    readonly strength?: number;
+    /** Bright-pass threshold in linear HDR units. Defaults to 1. */
+    readonly threshold?: number;
+    /** Width of the soft transition around the threshold. Defaults to 0.1. */
+    readonly knee?: number;
+    /** Bias toward wider mip levels, from 0 to 1. Defaults to 0.2. */
+    readonly radius?: number;
+    /** Number of progressively downsampled blur levels. Defaults to 5. */
+    readonly levels?: number;
+    readonly targetPrefix?: string;
+}
+interface BloomCompositeOptions {
+    readonly output?: FrameGraphTextureHandle;
+}
+/** HDR bloom using a soft bright pass and a progressively downsampled Gaussian pyramid. */
+declare class BloomEffect {
+    strength: number;
+    threshold: number;
+    knee: number;
+    radius: number;
+    private readonly levels;
+    private readonly targetPrefix;
+    private readonly passes;
+    constructor(options?: BloomOptions);
+    addPass(graph: FrameGraphBuilder, source: FrameGraphTextureHandle, options?: BloomCompositeOptions): FrameGraphTextureHandle;
+}
+
+type ColorGradingVector = readonly [number, number, number];
+type ToneMappingMode = "none" | "linear" | "reinhard" | "cineon" | "aces" | "agx" | "neutral";
+interface ColorGradingRange {
+    saturation?: ColorGradingVector;
+    contrast?: ColorGradingVector;
+    gamma?: ColorGradingVector;
+    gain?: ColorGradingVector;
+    offset?: ColorGradingVector;
+}
+interface ColorGradingOptions extends ColorGradingRange {
+    enabled?: boolean;
+    exposure?: number;
+    toneMapping?: ToneMappingMode;
+    vignetteIntensity?: number;
+    whiteBalance?: ColorGradingVector;
+    tint?: ColorGradingVector;
+    tintIntensity?: number;
+    shadows?: ColorGradingRange;
+    midtones?: ColorGradingRange;
+    highlights?: ColorGradingRange;
+    shadowsMax?: number;
+    highlightsMin?: number;
+    targetPrefix?: string;
+}
+/** HDR color correction, three-way grading, vignette, and final display tone mapping. */
+declare class ColorGradingEffect {
+    readonly options: ColorGradingOptions;
+    private readonly passes;
+    private readonly targetPrefix;
+    constructor(options?: ColorGradingOptions);
+    addPass(graph: FrameGraphBuilder, source: FrameGraphTextureHandle): FrameGraphTextureHandle;
+}
+
+interface DepthOfFieldOptions {
+    enabled?: boolean;
+    focus?: number;
+    aperture?: number;
+    maxBlur?: number;
+    targetPrefix?: string;
+}
+/** Depth-aware lens blur. Values follow Three's BokehPass focus/aperture/maxblur convention. */
+declare class DepthOfFieldEffect {
+    readonly options: DepthOfFieldOptions;
+    private readonly passes;
+    private readonly targetPrefix;
+    constructor(options?: DepthOfFieldOptions);
+    addPass(graph: FrameGraphBuilder, source: FrameGraphTextureHandle, depth: FrameGraphTextureHandle): FrameGraphTextureHandle;
+}
+
+interface OutlineOptions {
+    readonly enabled?: boolean;
+    readonly visibleEdgeColor?: readonly [number, number, number];
+    readonly edgeStrength?: number;
+    /** Outline radius in physical render pixels. */
+    readonly edgeThickness?: number;
+    readonly targetPrefix?: string;
+}
+interface OutlineInputs {
+    readonly sceneColor: FrameGraphTextureHandle;
+    /** Selected roots. Descendants are selected automatically. */
+    readonly selectedObjects: ReadonlySet<Object3D>;
+}
+interface OutlineInstanceSelection {
+    readonly object: Object3D;
+    /** InstancedMesh instance index or BatchedMesh geometry/batching id. */
+    readonly instanceIndex: number;
+}
+/**
+ * Selection outline for the frame graph. The mask is rendered with the same
+ * geometry, skinning, instancing and batching paths as the main scene.
+ */
+declare class OutlineEffect {
+    enabled: boolean;
+    visibleEdgeColor: [number, number, number];
+    edgeStrength: number;
+    edgeThickness: number;
+    readonly selectedObjects: Set<Object3D<three.Object3DEventMap>>;
+    readonly selectedInstances: OutlineInstanceSelection[];
+    private readonly targetPrefix;
+    private readonly maskMaterial;
+    private readonly skinnedMaskMaterial;
+    private readonly instanceMaskMaterials;
+    private readonly passes;
+    constructor(options?: OutlineOptions);
+    setSelectedObjects(objects: Iterable<Object3D>): void;
+    setSelectedInstances(selections: Iterable<OutlineInstanceSelection>): void;
+    addPass(graph: FrameGraphBuilder, source: FrameGraphTextureHandle): FrameGraphTextureHandle;
+    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, 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 };