@hology/webgpu-renderer 0.1.18 → 0.1.20

package/README.md

@@ -426,3 +426,52 @@ Natural follow-ups from here:
 - add cascaded directional shadows, light arrays, and shadow atlases
 - add material templates and pipeline caches for larger shader families
 - separate extraction, render graph nodes, and resource registries into dedicated modules
+
+
+### Automatic detail rejection
+
+WebGPU objects default to a conservative minimum bounding-sphere diameter of 2 render pixels, with a separate 2-shadow-texel threshold for directional casters. This rejects detail before vertex processing; it does not generate mesh LODs or change geometry. Long thin objects use their longest extent through the enclosing sphere, and camera/near-plane intersections are retained.
+
+```ts
+import { setObjectDetailCulling } from '@hology/webgpu-renderer';
+
+// Defaults for an entire scene / actor hierarchy; descendants can override fields.
+setObjectDetailCulling(scene, { minScreenSize: 2, shadow: { minScreenSize: 2 } });
+setObjectDetailCulling(importantActor, { enabled: false, shadow: { enabled: false } });
+setObjectDetailCulling(smallProp, { maxDistance: 100, shadow: { minScreenSize: 4, maxDistance: 200 } });
+renderer.createStaticDrawSet(root, { detailCulling: { minScreenSize: 3 } });
+```
+
+Settings are stored in `Object3D.userData.detailCulling` and inherited from parents, field by field. `enabled: false` disables automatic rejection in that domain; an explicit distance still applies. Zero distance disables distance rejection. Distances are measured from the viewer to the sphere surface. Camera and shadow settings are independent. Hology's `RenderingView.setObjectDetailCulling` exposes the same runtime object policy, and `SceneObject.detailCulling` carries it through materialization. Objects with different policies remain separate in materialization and renderer batching.
+
+Static registration freezes settings and bounds. Change policies before registration, or dispose and re-register a static set after changing them. The existing 32-byte GPU instance metadata stores camera threshold and distance in its formerly reserved words. Camera rejection runs in the existing visibility compute kernel, before frustum/Hi-Z work, with no additional compute dispatch or visibility readback. A persistent bit in the visibility mask provides 115% entry / 85% exit hysteresis. Ordinary meshes receive CPU detail decisions before batching, with object history; already-instanced dynamic/resident batches conservatively use their aggregate bounds. Per-instance dynamic/resident compaction is not added here.
+
+Directional shadows use independent light-space sphere tests over the complete cascade camera volume, including off-camera casters. Spatial chunks remain a broad phase. A CPU mirror of the immutable sphere metadata selects contiguous source-instance runs from the resident buffer; pooled draw descriptors avoid per-frame descriptor allocation. Cascade histories use the same hysteresis band. This path adds CPU selection/encoding work in exchange for fewer shadow vertices; it does not reuse the camera's compacted instance list. Point and spot shadow detail policies are not changed.
+
+Profiling now includes per-pass `triangleCount` and `drawCallCount`. Indirect submission counters remain **upper bounds**, since the CPU records registered draw capacity; they include repeated depth/color/shadow submissions. `visibility.visibleTriangles` reads actual index/instance counts from the camera's indirect arguments and represents one GPU-culled camera submission, excluding direct and transparent draws. Directional shadow run counts are exact. GPU profiling readback is diagnostic only, never needed for culling.
+
+
+### Cached directional shadow updates
+
+Temporal shadow scheduling is opt-in. Configure the renderer with `directionalShadowUpdates`, or call `setDirectionalShadowUpdateOptions`. Hology exposes the same method on `RenderingView`.
+
+```ts
+renderingView.setDirectionalShadowUpdateOptions({
+  enabled: true,
+  maxUpdateHz: 60,
+  cascadeUpdateHz: [60, 30, 15, 7.5],
+  maxUpdatesPerFrame: 2,
+  coverageMargin: 0.05,
+  teleportDistance: 10,
+});
+// Call after discontinuous dynamic-caster changes or other external scene edits.
+renderingView.invalidateDirectionalShadows();
+```
+
+Ordinary refreshes use monotonic-time deadlines, independent of render FPS and simulation time. Initial deadlines are staggered; the oldest overdue deadline wins the ordinary per-frame budget. Rates are upper bounds, rather than guaranteed frequencies if the budget cannot sustain the requested workload. Hard invalidation bypasses both the budget and rate cap.
+
+Each retained map keeps its rendered light camera and sampling matrix. Material and volumetric-fog sampling share the renderer's cached light-uniform matrices. Custom graph consumers can use `RendererExtractedLightState.directionals[i].shadowViewProjection` (WebGPU 0�1 depth) rather than reconstructing a matrix from the current scene light. Temporal camera jitter does not invalidate maps. Initialisation, shadow-texture reallocation, light identity/direction, cascade-range changes, FOV/aspect/clip changes, viewer teleports and static draw-set membership/enabled changes force refresh. The complete nominal light volume must fit inside the cached padded volume; coverage loss forces a layer update even before its deadline. Camera turns/translations that remain inside coverage may reuse the map.
+
+Coverage padding adds conservative caster coverage and slightly reduces effective shadow texel density. Lower far-cascade rates introduce bounded temporal lag for moving casters. Use higher rates or disable scheduling where that tradeoff is unsuitable. Static material/uniform edits and discontinuous dynamic-caster edits that are not represented by the tracked scene state should explicitly invalidate shadows. This path does not cache point or spot shadows.
+
+`RendererFrameProfile.directionalShadows` reports updated/reused/forced layer counts and an update bit mask. Per-pass triangle statistics count only newly submitted shadow geometry on refresh frames. Camera visibility remains independent.

package/dist/index.d.ts

@@ -1,19 +1,36 @@
 import * as three from 'three';
-import { Color, Vector2, Vector3, Vector4, Matrix3, Matrix4, Material, Texture, MaterialParameters, DirectionalLight, PointLight, SpotLight, Object3D, PerspectiveCamera, OrthographicCamera, BufferGeometry, Scene } from 'three';
+import { Object3D, Color, Vector2, Vector3, Vector4, Matrix3, Matrix4, Material, Texture, MaterialParameters, PerspectiveCamera, OrthographicCamera, BufferGeometry, DirectionalLight, PointLight, SpotLight, 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 {
-    label?: string;
-    code: string;
-    entryPoint?: string;
-    bindGroupLayoutEntries: GPUBindGroupLayoutEntry[];
+interface PipelineDiagnosticOrigin {
+    key: string;
+    [detail: string]: unknown;
 }
-declare class ComputeKernel {
-    readonly layout: GPUBindGroupLayout;
-    readonly pipeline: GPUComputePipeline;
-    constructor(device: GPUDevice, descriptor: ComputeKernelDescriptor);
-    createBindGroup(device: GPUDevice, entries: GPUBindGroupEntry[], label?: string): GPUBindGroup;
+declare function setPipelineDiagnosticLoading(device: GPUDevice, loading: boolean, phase: string): void;
+declare function registerPipelineDiagnosticOrigin(device: GPUDevice, label: string, origin: PipelineDiagnosticOrigin): void;
+
+/** Detail rejection, not mesh simplification. Diameters are measured in render pixels / shadow texels. */
+interface DetailCullingSettings {
+    /** Disable automatic camera detail rejection; explicit maxDistance still applies. */
+    enabled?: boolean;
+    minScreenSize?: number;
+    /** Distance to the bounding sphere surface in world units. Zero disables. */
+    maxDistance?: number;
+    shadow?: {
+        enabled?: boolean;
+        minScreenSize?: number;
+        maxDistance?: number;
+    };
 }
+interface ResolvedDetailCulling {
+    minScreenSize: number;
+    maxDistance: number;
+    shadowMinScreenSize: number;
+    shadowMaxDistance: number;
+}
+/** Serialized in Object3D.userData, inherited through parents, and usable by runtime-created objects. */
+declare function setObjectDetailCulling(object: Object3D, settings: DetailCullingSettings): void;
+declare function resolveDetailCulling(object: Object3D | null, registration?: DetailCullingSettings): ResolvedDetailCulling;
 
 type ShaderDefineValue = string | number | boolean;
 type ShaderDefines = Record<string, ShaderDefineValue | null | undefined>;
@@ -151,6 +168,9 @@ declare class WGSLShaderMaterial extends Material {
     private invalidateBindingCache;
 }
 
+/** Shared renderer lighting ABI for procedural particle geometry. */
+declare function buildParticleLightingShaderHeader(receiveShadow?: boolean, modelMatrixBody?: string): string;
+
 interface RenderGraphContext {
     readonly device: GPUDevice;
     readonly encoder: GPUCommandEncoder;
@@ -179,102 +199,6 @@ 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;
-    height: number;
-    depthOrArrayLayers: number;
-    format: GPUTextureFormat;
-    textureDimension: GPUTextureDimension;
-    viewDimension: GPUTextureViewDimension;
-    sampleType: GPUTextureSampleType;
-    samplerBindingType: GPUSamplerBindingType;
-    mipLevelCount: number;
-    texture: GPUTexture;
-    view: GPUTextureView;
-    sampler: GPUSampler;
-}
-interface ExtractedLightState {
-    ambient: Vector4;
-    hemisphere: ExtractedHemisphereLight | null;
-    directionals: ExtractedDirectionalLight[];
-    points: ExtractedPointLight[];
-    spots: ExtractedSpotLight[];
-    directional: ExtractedDirectionalLight | null;
-    point: ExtractedPointLight | null;
-    spot: ExtractedSpotLight | null;
-}
-interface ExtractedHemisphereLight {
-    direction: Vector3;
-    skyColor: Vector3;
-    groundColor: Vector3;
-    intensity: number;
-}
-interface ExtractedDirectionalLight {
-    sourceLight: DirectionalLight | null;
-    position: Vector3;
-    target: Vector3;
-    direction: Vector3;
-    color: Vector3;
-    intensity: number;
-    volumetricIntensity: number;
-    castShadow: boolean;
-    shadowBias: number;
-    shadowNormalBias: number;
-    shadowRadius: number;
-    shadowIntensity: number;
-    shadowMapSize: number;
-    shadowCameraLeft: number;
-    shadowCameraRight: number;
-    shadowCameraTop: number;
-    shadowCameraBottom: number;
-    shadowCameraNear: number;
-    shadowCameraFar: number;
-}
-interface ExtractedPointLight {
-    sourceLight: PointLight;
-    position: Vector3;
-    color: Vector3;
-    intensity: number;
-    volumetricIntensity: number;
-    distance: number;
-    range: number;
-    decay: number;
-    castShadow: boolean;
-    shadowBias: number;
-    shadowNormalBias: number;
-    shadowRadius: number;
-    shadowIntensity: number;
-    shadowMapSize: number;
-    shadowCameraNear: number;
-    shadowCameraFar: number;
-}
-interface ExtractedSpotLight {
-    sourceLight: SpotLight;
-    position: Vector3;
-    direction: Vector3;
-    color: Vector3;
-    intensity: number;
-    volumetricIntensity: number;
-    range: number;
-    angle: number;
-    penumbra: number;
-    decay: number;
-    castShadow: boolean;
-    shadowBias: number;
-    shadowNormalBias: number;
-    shadowRadius: number;
-    shadowIntensity: number;
-    shadowMapSize: number;
-    shadowCameraNear: number;
-    shadowCameraFar: number;
-    shadowCameraFov: number;
-    map: Texture | null;
-}
-
 /** Camera-visible lights collected during the renderer's scene extraction. */
 type RendererExtractedLightState = ExtractedLightState;
 /**
@@ -289,6 +213,7 @@ interface RendererOptions {
     clearColor?: readonly [number, number, number, number];
     powerPreference?: GPUPowerPreference;
     shadowMapSize?: number;
+    directionalShadowUpdates?: DirectionalShadowUpdateOptions;
     pointShadowMapSize?: number;
     sampleCount?: number;
     hiZOcclusionCulling?: boolean;
@@ -338,6 +263,8 @@ interface RendererOptions {
     invokeObjectRenderCallbacks?: boolean;
 }
 interface StaticDrawSetOptions {
+    /** Defaults inherited by objects without overrides. Frozen at registration. */
+    detailCulling?: DetailCullingSettings;
     label?: string;
     onUnsupported?: "throw" | "skip";
     /**
@@ -475,11 +402,16 @@ interface RendererCustomPassDescriptor {
     execute(context: RendererCustomPassContext): void;
 }
 interface RendererPassProfile {
+    /** Submission upper bound for GPU-indirect draws; exact for direct draws. */
+    triangleCount?: number;
+    drawCallCount?: number;
     name: string;
     cpuTimeMs: number;
     gpuTimeMs: number | null;
 }
 interface RendererVisibilityProfile {
+    /** Actual triangles in GPU camera-visible indirect arguments (one color submission). */
+    visibleTriangles?: number;
     totalInstances: number;
     visibleInstances: number;
     culledInstances: number;
@@ -489,10 +421,17 @@ interface RendererVisibilityProfile {
     staticVisibleInstances: number;
 }
 interface RendererFrameProfile {
+    directionalShadows?: {
+        updatedLayers: number;
+        reusedLayers: number;
+        forcedLayers: number;
+        updateMask: number;
+    };
     frameIndex: number;
     cpuTimeMs: number;
     gpuTimeMs: number | null;
     drawCallCount: number;
+    /** Counts repeated passes; upper bound for GPU-indirect draws, not unique visible geometry. */
     triangleCount: number;
     cpuPhases: {
         extractSceneMs: number;
@@ -513,6 +452,141 @@ interface RendererFrameProfile {
     visibility: RendererVisibilityProfile | null;
 }
 
+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 ExtractedLightState {
+    ambient: Vector4;
+    hemisphere: ExtractedHemisphereLight | null;
+    directionals: ExtractedDirectionalLight[];
+    points: ExtractedPointLight[];
+    spots: ExtractedSpotLight[];
+    directional: ExtractedDirectionalLight | null;
+    point: ExtractedPointLight | null;
+    spot: ExtractedSpotLight | null;
+}
+interface ExtractedHemisphereLight {
+    direction: Vector3;
+    skyColor: Vector3;
+    groundColor: Vector3;
+    intensity: number;
+}
+interface ExtractedDirectionalLight {
+    /** Actual WebGPU (0..1 depth) projection of this frame's retained shadow layer. */
+    shadowViewProjection?: Matrix4;
+    sourceLight: DirectionalLight | null;
+    position: Vector3;
+    target: Vector3;
+    direction: Vector3;
+    color: Vector3;
+    intensity: number;
+    volumetricIntensity: number;
+    castShadow: boolean;
+    shadowBias: number;
+    shadowNormalBias: number;
+    shadowRadius: number;
+    shadowIntensity: number;
+    shadowMapSize: number;
+    shadowCameraLeft: number;
+    shadowCameraRight: number;
+    shadowCameraTop: number;
+    shadowCameraBottom: number;
+    shadowCameraNear: number;
+    shadowCameraFar: number;
+}
+interface ExtractedPointLight {
+    sourceLight: PointLight;
+    position: Vector3;
+    color: Vector3;
+    intensity: number;
+    volumetricIntensity: number;
+    distance: number;
+    range: number;
+    decay: number;
+    castShadow: boolean;
+    shadowBias: number;
+    shadowNormalBias: number;
+    shadowRadius: number;
+    shadowIntensity: number;
+    shadowMapSize: number;
+    shadowCameraNear: number;
+    shadowCameraFar: number;
+}
+interface ExtractedSpotLight {
+    sourceLight: SpotLight;
+    position: Vector3;
+    direction: Vector3;
+    color: Vector3;
+    intensity: number;
+    volumetricIntensity: number;
+    range: number;
+    angle: number;
+    penumbra: number;
+    decay: number;
+    castShadow: boolean;
+    shadowBias: number;
+    shadowNormalBias: number;
+    shadowRadius: number;
+    shadowIntensity: number;
+    shadowMapSize: number;
+    shadowCameraNear: number;
+    shadowCameraFar: number;
+    shadowCameraFov: number;
+    map: Texture | null;
+}
+
+/** Opt-in temporal caching for directional shadow maps, independent of render FPS. */
+interface DirectionalShadowUpdateOptions {
+    enabled?: boolean;
+    /** Upper limit for ordinary layer refreshes, in updates/second. Default 60. */
+    maxUpdateHz?: number;
+    /** Near-to-far maximum rates. Default [60, 30, 15, 7.5]. */
+    cascadeUpdateHz?: readonly number[];
+    /** Ordinary refresh budget. Hard invalidations bypass it. Default 2. */
+    maxUpdatesPerFrame?: number;
+    /** Extra light-space coverage per side, as a fraction of nominal extent. Default .05. */
+    coverageMargin?: number;
+    /** Viewer displacement in one frame that invalidates all layers. Default 10 world units. */
+    teleportDistance?: number;
+}
+
+/**
+ * Lighting and post-processing stay in linear HDR until the present pass.
+ * The canvas format is intentionally kept separate because it is a display
+ * target, not an intermediate scene-color target.
+ */
+declare const SCENE_COLOR_FORMAT: GPUTextureFormat;
+
+declare function createRenderPipelineAsync(device: GPUDevice, descriptor: GPURenderPipelineDescriptor): Promise<GPURenderPipeline>;
+declare function createComputePipelineAsync(device: GPUDevice, descriptor: GPUComputePipelineDescriptor): Promise<GPUComputePipeline>;
+
+interface ComputeKernelDescriptor {
+    label?: string;
+    code: string;
+    entryPoint?: string;
+    bindGroupLayoutEntries: GPUBindGroupLayoutEntry[];
+}
+declare class ComputeKernel {
+    readonly layout: GPUBindGroupLayout;
+    readonly pipeline: GPUComputePipeline;
+    static createAsync(device: GPUDevice, descriptor: ComputeKernelDescriptor): Promise<ComputeKernel>;
+    /** The optional pipeline allows adopting an already compiled kernel. */
+    constructor(device: GPUDevice, descriptor: ComputeKernelDescriptor, pipeline?: GPUComputePipeline);
+    createBindGroup(device: GPUDevice, entries: GPUBindGroupEntry[], label?: string): GPUBindGroup;
+}
+
 type FrameGraphTextureHandle = string;
 interface FrameGraphPassDescriptor {
     readonly name: string;
@@ -551,6 +625,7 @@ interface CompiledNodeFullscreenShader {
     }>): void;
 }
 interface FrameGraphNodeFullscreenPassDescriptor {
+    readonly diagnosticOrigin?: PipelineDiagnosticOrigin;
     readonly name: string;
     readonly shader: CompiledNodeFullscreenShader;
     /** Overrides frame-graph resources for named compiled graph/scene texture bindings. */
@@ -854,6 +929,8 @@ declare class WebGpuRenderer {
      * so regular meshes see that change without paying resolver work per mesh.
      */
     private readonly resolvedMaterialFrameCache;
+    private readonly repeatedMeshInstances;
+    private readonly repeatedInstanceResources;
     private readonly instancedMeshExtractionCache;
     private readonly batchedMeshExtractionCache;
     private readonly materialCache;
@@ -909,6 +986,7 @@ declare class WebGpuRenderer {
     private readonly presentationOverlay;
     private readonly presentationOverlayContext;
     private readonly directionalShadowCameras;
+    private readonly directionalShadowScheduler;
     private readonly pointShadowCameras;
     private readonly spotShadowCameras;
     private readonly colorTargetCache;
@@ -930,6 +1008,7 @@ declare class WebGpuRenderer {
     private readonly vertexAttributeGroupCache;
     private readonly materialVertexAttributeCache;
     private readonly vertexBufferBindingPlanCache;
+    private readonly preparedVertexBufferCache;
     private readonly vertexAttributeGroupBufferKeyCache;
     private readonly compileDrawScratch;
     private readonly dynamicIndirectSubmissionCache;
@@ -953,6 +1032,14 @@ declare class WebGpuRenderer {
     private staticFrameToken;
     private hizResourceVersion;
     private graphTextureResourceVersion;
+    private transmissionSnapshotTexture;
+    private transmissionSnapshotView;
+    private transmissionSnapshotSize;
+    private transmissionMipViews;
+    private transmissionMipBindGroups;
+    private transmissionSourceBindGroups;
+    private transmissionSnapshotPipeline;
+    private transmissionSampler;
     private readonly visibilityParamsUpload;
     private drawMetadataUpload;
     private indirectDrawUpload;
@@ -996,6 +1083,9 @@ declare class WebGpuRenderer {
     private readonly objectMotionHistory;
     private readonly cameraFrustumPlanesScratch;
     private readonly objectTraversalStackScratch;
+    private readonly shadowDrawsScratch;
+    private extractingCaster;
+    private readonly cameraDetailHistory;
     private readonly isSphereVisibleScratch;
     private readonly isSphereVisibleForCompilationScratch;
     private readonly updateExtractedBoundsFromMatrixScratch;
@@ -1042,6 +1132,9 @@ declare class WebGpuRenderer {
     }[], lights?: readonly DirectionalLight[]): void;
     /** Sets the base resolution used by directional shadow-map array layers. */
     setDirectionalShadowMapSize(size: number): void;
+    setDirectionalShadowUpdateOptions(options: DirectionalShadowUpdateOptions): void;
+    /** Invalidate retained maps after discontinuous caster/scene changes. */
+    invalidateDirectionalShadows(): void;
     setDirectionalShadowsEnabled(enabled: boolean): void;
     setRenderGraphProfilingEnabled(enabled: boolean): void;
     getRenderGraphProfilingEnabled(): boolean;
@@ -1108,6 +1201,8 @@ declare class WebGpuRenderer {
     private recordPresentationOverlay;
     destroy(): void;
     private createStaticPipelines;
+    private ensureTransmissionSnapshot;
+    private copyTransmissionSnapshot;
     private recreateShadowResources;
     private recreateDirectionalShadowResources;
     private ensureShadowTextureSizes;
@@ -1235,6 +1330,7 @@ declare class WebGpuRenderer {
     private getInterleavedGeometryVertexBuffer;
     private ensureWireframeIndex;
     private bindGeometryVertexBuffers;
+    private prepareGeometryVertexBuffers;
     private getStandardVertexAttribute;
     private prepareDrawGeometryVertexBuffers;
     private getDefaultInstanceAttributeBuffer;
@@ -1320,6 +1416,10 @@ interface GTAOTemporalOptions {
     readonly neighborhoodClamp?: boolean;
 }
 interface GTAOOptions {
+    /** Strength used by addCompositePass unless explicitly overridden. Defaults to 0.6. */
+    readonly intensity?: number;
+    /** Visibility exponent used by addCompositePass. Defaults to 1. */
+    readonly power?: number;
     readonly enabled?: boolean;
     /** Resolution relative to the render target. Defaults to 1. */
     readonly resolutionScale?: number;
@@ -1743,4 +1843,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, 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 };
+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 DetailCullingSettings, type DirectionalShadowUpdateOptions, 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, type PipelineDiagnosticOrigin, 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, SCENE_COLOR_FORMAT, 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, createComputePipelineAsync, createRenderPipelineAsync, registerPipelineDiagnosticOrigin, resolveDetailCulling, setObjectDetailCulling, setPipelineDiagnosticLoading };