@meimu/mutracer 0.0.0-stage → 0.1.1

package/lib/renderer/WGPURayTracePass.d.ts

@@ -0,0 +1,284 @@
+import { type SamplingPattern } from './sampling.js';
+import { type DepthSampleArea } from './depthQuery.js';
+import Mesh from '../scene/Mesh.js';
+import DirectionalLight from '../scene/DirectionalLight.js';
+import SphereLight from '../scene/SphereLight.js';
+import RectLight from '../scene/RectLight.js';
+import SpotLight from '../scene/SpotLight.js';
+import { SceneBackground, SceneLight } from '../scene/Scene.js';
+import Camera from '../scene/Camera.js';
+import Geometry from '../scene/Geometry.js';
+import OpenPBRMaterial from '../scene/OpenPBRMaterial.js';
+import { type AlphaBlendStrategy, type ShaderCompilationDiagnostics } from './RenderingPipeline.js';
+import { type OfflineAdaptiveSamplingOptions, type OfflineAdaptiveSamplingResult } from './OfflineAdaptiveSampling.js';
+type AnalyticLight = DirectionalLight | SphereLight | SpotLight | RectLight;
+export interface WGPURayTraceTimingCapture {
+    querySet: GPUQuerySet;
+}
+/**
+ * WebGPU errors are Web IDL objects and are not required to inherit from the
+ * JavaScript Error class. In particular, GPUValidationError exposes a useful
+ * `message` while String(error) may only return "[object GPUValidationError]".
+ */
+export declare function getWebGPUErrorMessage(error: unknown): string;
+/** Fast diagnostic fingerprint; cache implementations use their own hashes. */
+export declare function shaderSourceFingerprint(source: string): string;
+export declare function isWebGPUPipelineSpecializationFailure(...errors: unknown[]): boolean;
+/** CPU-side views over the `RayTraceUniform` WGSL struct. */
+export declare function makeRayTraceUniform(): {
+    buffer: ArrayBuffer;
+    views: {
+        outputSize: Float32Array<ArrayBuffer>;
+        sampleCount: Float32Array<ArrayBuffer>;
+        scaleOffset: Float32Array<ArrayBuffer>;
+        lightsCount: Int32Array<ArrayBuffer>;
+        transmissiveOutputAlphaMin: Float32Array<ArrayBuffer>;
+        jitter: Float32Array<ArrayBuffer>;
+        backgroundColor: Float32Array<ArrayBuffer>;
+        groundedBackgroundParams: Float32Array<ArrayBuffer>;
+        groundedBackgroundCenter: Float32Array<ArrayBuffer>;
+        blasOffset: Int32Array<ArrayBuffer>;
+        isEmpty: Int32Array<ArrayBuffer>;
+        bevel: Int32Array<ArrayBuffer>;
+        dispersionWavelengths: Int32Array<ArrayBuffer>;
+        envLightPmf: Float32Array<ArrayBuffer>;
+        lightChoiceCount: Int32Array<ArrayBuffer>;
+        lightWeightTotal: Float32Array<ArrayBuffer>;
+        lightSamplingTextureWidth: Int32Array<ArrayBuffer>;
+        lightChoiceTexelOffset: Int32Array<ArrayBuffer>;
+        bounces: Int32Array<ArrayBuffer>;
+        varianceMoments: Int32Array<ArrayBuffer>;
+        adaptiveSampling: Int32Array<ArrayBuffer>;
+        clamping: Float32Array<ArrayBuffer>;
+        directLightCandidates: Int32Array<ArrayBuffer>;
+        backgroundFlags: Int32Array<ArrayBuffer>;
+        loopUnrollGuard: Uint32Array<ArrayBuffer>;
+        sceneFeatureFlags: Uint32Array<ArrayBuffer>;
+        sequenceSeed: Uint32Array<ArrayBuffer>;
+        zSobolLogSPP: Uint32Array<ArrayBuffer>;
+        sampleSequenceOffset: Uint32Array<ArrayBuffer>;
+    };
+};
+export declare function packAnalyticsLightsToBuffer(lights: AnalyticLight[], texturesIndices: number[], selectionPmfs: number[], iesProfileTexelOffsets?: ArrayLike<number>): Float32Array<ArrayBuffer>;
+declare class WGPURayTracePass {
+    private _device;
+    private _rayTracePipeline?;
+    private _targetAspect;
+    private _width;
+    private _height;
+    private _meshes;
+    private _sceneEnvironment;
+    private _rectLightTextures;
+    private _analyticLights;
+    private _iesProfileTexelOffsets;
+    private _materialChanges;
+    private _pendingMaterialUpdate?;
+    private _materialData;
+    private _maxTextureArrayBytes;
+    private _pendingGeometryUpdates;
+    private _needsUpdateMeshData;
+    private _needsUpdateMeshMembership;
+    private _needsRefitTLAS;
+    private _preparedMeshData?;
+    private _membershipCache;
+    private _pendingMembershipData?;
+    private _residentPreparedMeshData?;
+    private _tlas?;
+    private _meshSnapshot;
+    private _snapshotByMesh;
+    private _residentSnapshotByMesh;
+    private _dirtyTransformMeshes;
+    private _dirtyColorMeshes;
+    private _geometriesNeedRefit;
+    private _needsUpdateAnalyticLightsBuffer;
+    private _activeTarget;
+    private _targetOutputs;
+    releaseTarget(target: object): void;
+    getTargetMemoryBytes(target: object): number;
+    useTarget(target: object): void;
+    private _outColorBuffer;
+    private _outNormalBuffer;
+    private _outAlbedoBuffer;
+    private _outShadowCatcherBuffer;
+    private _uniforms;
+    private _rtUniform;
+    private _mapInfoUniform;
+    private _attributeData?;
+    private _attributeStride;
+    private _attributeOffsets;
+    private _attrBuffers?;
+    private _materialsBuffer?;
+    private _lightSamplingTexture?;
+    private _lightSamplingTextureSize;
+    private _lightDomainDiagnostics;
+    private _openPbrEnergyLut;
+    private _bvhBuffer?;
+    private _instancesBuffer?;
+    private _emissiveCache;
+    private _lightChoices;
+    private _lightSamplingData?;
+    private _lightSamplingScratch?;
+    private _lightSamplingTriangleCount;
+    private _emissiveTriangles;
+    private _analyticLightSelectionPmfs;
+    private _needsUpdateLightSamplingData;
+    private _adaptiveSamplingTexture;
+    private _adaptiveSamplingTextureSize;
+    private _offlineAdaptivePipeline?;
+    private _offlineAdaptiveHistory?;
+    private _mapsSampler;
+    private _maps?;
+    private _envImageSource;
+    private _envTex?;
+    private _envDistributionTex?;
+    private _backgroundImageSource;
+    private _backgroundTex?;
+    private _rayTracePipelineLayout?;
+    private _rayTraceBindGroups?;
+    private _blasLayoutMask;
+    private _compiledBlasLayoutMask;
+    private _compiledAnisotropyDirections;
+    private _compiledCoatNormals;
+    private _compiledHasAlpha;
+    private _compiledSceneHasAlpha;
+    private _alphaBlendStrategy;
+    private _constants;
+    private _prevPipelineConstants;
+    private _prevDefinesCode;
+    private _hasTransmission;
+    private _hasShadowCatcher;
+    private _hasDisplacement;
+    private _bounces;
+    private _bevelSamples;
+    private _directLightCandidates;
+    private _clamping?;
+    private _transmissiveAlphaMin;
+    private _viewProjInv;
+    private _cameraWorld;
+    private _apertureRadius;
+    private _focusDistance;
+    private _needsUpdateBindGroups;
+    private _computeShaderModule?;
+    private _depthCompute?;
+    private _depthTracePipeline?;
+    private _depthPipeline?;
+    private _shaderCache;
+    private _debugBVHBuffer?;
+    private _isCompilingShader;
+    private _shaderCompilationDiagnostics?;
+    private _pipelineError;
+    private _bakePipelineConstants;
+    private _failedPipelineSignature?;
+    constructor(device: GPUDevice);
+    getOutputBuffer(): {
+        color: GPUBuffer;
+        normal: GPUBuffer;
+        albedo: GPUBuffer;
+        shadowCatcher: GPUBuffer;
+    };
+    private _ensureAdaptiveSamplingTexture;
+    /**
+     * Reduces pilot moments and expands final sample targets without transferring
+     * full-resolution buffers through JavaScript. Only compact per-tile history
+     * is read back for diagnostics and animation-frame reuse.
+     */
+    prepareOfflineAdaptiveSampling(options: OfflineAdaptiveSamplingOptions): Promise<OfflineAdaptiveSamplingResult | undefined>;
+    private _createPipelineLayout;
+    private _updateGPUBuffer;
+    private _uniformBuffer;
+    updatePipeline(): Promise<void>;
+    readDepthSamples(area: DepthSampleArea, aspect?: number): Promise<Float32Array | undefined>;
+    isCompilingShader(): boolean;
+    isPipelineReady(): boolean;
+    getPipelineError(): unknown;
+    private _updateBindGroups;
+    createPass(encoder: GPUCommandEncoder, clear: boolean, tiles: [number, number], timing?: WGPURayTraceTimingCapture): void;
+    getDebugBVHData(): Promise<{
+        buffer: ArrayBuffer;
+    }>;
+    getDiagnostics(): {
+        textureAtlas: import("./MaterialTable.js").TextureAtlasStats | undefined;
+        shaderCompilation: ShaderCompilationDiagnostics | undefined;
+        lightSampling: {
+            emissiveTriangles: number;
+            activeChoices: number;
+            totalWeight: number;
+            domains: {
+                environment: {
+                    count: number;
+                    weight: number;
+                    pmf: number;
+                };
+                infinite: {
+                    count: number;
+                    weight: number;
+                    pmf: number;
+                };
+                localAndEmissive: {
+                    count: number;
+                    weight: number;
+                    pmf: number;
+                };
+            };
+        };
+        bvh: {
+            tlasTraversalStackSize: number | undefined;
+            blasTraversalStackSize: number | undefined;
+        };
+    };
+    setAlphaBlendStrategy(strategy: AlphaBlendStrategy): boolean;
+    hasDepthOfField(): boolean;
+    setBounce(bounce: number): boolean;
+    setDirectLightCandidates(candidates: number): boolean;
+    setClamping(clamping?: number): boolean;
+    setBevelSamples(samples: number): boolean;
+    setSamplingPattern(pattern: SamplingPattern, maxSamples: number, sequenceSeed?: number): boolean;
+    setSampleSequenceOffset(offset: number): void;
+    setVarianceMoments(enabled: boolean): void;
+    setAdaptiveSamplingTargets(targets?: {
+        width: number;
+        height: number;
+        data: Float32Array;
+    }): void;
+    setQuality(options: {
+        bounces: number;
+        bevel: boolean;
+        dispersionWavelengths: 1 | 3;
+        directLightCandidates: number;
+    }): void;
+    private _setEnvMap;
+    setMeshes(meshes: Mesh[], update?: {
+        transforms?: readonly Mesh[];
+        colors?: readonly Mesh[];
+        geometries?: readonly Geometry[];
+        materials?: readonly OpenPBRMaterial[];
+    }): boolean;
+    setTextureAtlasBudget(maxBytes: number): boolean;
+    setBackground(background?: SceneBackground): void;
+    private _setBackgroundMap;
+    private _updateLightSamplingData;
+    /** Uploads the combined TLAS/BLAS buffer and the instance records. */
+    private _uploadBVH;
+    private _updateMeshData;
+    private _updateMaterialConstants;
+    private _updateGeometryData;
+    private _updateMaterialData;
+    /** Rebuilds only instance acceleration data for a cached mesh subset. */
+    private _updateMeshMembership;
+    private _updateMeshColors;
+    private _refitMeshInstances;
+    private _updateTextures;
+    setLights(lights: SceneLight[]): void;
+    private _updateViewProjInv;
+    setCamera(camera: Camera): void;
+    cameraChanged(camera: Camera): boolean;
+    setSize(width: number, height: number, targetAspect?: number): void;
+    setJitter(x: number, y: number): void;
+    setSampleTiles(columns: number, rows: number, tileX: number, tileY: number): void;
+    setSampleCount(sampleCount: number): void;
+    setTransmissiveOutputAlphaMin(transmissiveAlphaMin: number): boolean;
+    needsDenoiseAlpha(): boolean;
+    hasShadowCatcher(): boolean;
+    dispose(): void;
+}
+export default WGPURayTracePass;