@meimu/mutracer 0.1.5 → 0.3.0

package/lib/renderer/WGPURayTracePass.d.ts

@@ -1,11 +1,14 @@
-import { type SamplingPattern } from './sampling.js';
+import { WGPUAov } from './WGPUAov.js';
+import { type AovKind } from './aov.js';
+import { type MaterialTextureSelection } from './wgpuBindless.js';
+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 type { SceneBackground, SceneLight } from '../scene/Scene.js';
 import Camera from '../scene/Camera.js';
 import Geometry from '../scene/Geometry.js';
 import OpenPBRMaterial from '../scene/OpenPBRMaterial.js';
@@ -25,50 +28,27 @@ export declare function getWebGPUErrorMessage(error: unknown): string;
 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>;
-        environmentRotation: Float32Array<ArrayBuffer>;
-        backgroundMapTransform: Float32Array<ArrayBuffer>;
-    };
-};
+export { makeRayTraceUniform } from './wgpuSceneUniform.js';
 export declare function packAnalyticsLightsToBuffer(lights: AnalyticLight[], texturesIndices: number[], selectionPmfs: number[], iesProfileTexelOffsets?: ArrayLike<number>): Float32Array<ArrayBuffer>;
 declare class WGPURayTracePass {
+    private _textureSelection;
+    private _aovPrimitiveCache;
     private _device;
     private _rayTracePipeline?;
     private _targetAspect;
     private _width;
     private _height;
     private _meshes;
+    private _causticKey;
+    private _photonMapping;
+    private _photonMap?;
+    private _causticLight?;
+    private _causticSettings?;
+    private _causticPerspective;
+    private _causticCameraScale;
+    private _causticBounds;
+    private _transport?;
+    private _lightTracing;
     private _sceneEnvironment;
     private _rectLightTextures;
     private _analyticLights;
@@ -76,6 +56,9 @@ declare class WGPURayTracePass {
     private _materialChanges;
     private _pendingMaterialUpdate?;
     private _materialData;
+    private _bindless?;
+    private _retiredBindless;
+    private _disposed;
     private _maxTextureArrayBytes;
     private _pendingGeometryUpdates;
     private _needsUpdateMeshData;
@@ -118,6 +101,7 @@ declare class WGPURayTracePass {
     private _instancesBuffer?;
     private _emissiveCache;
     private _lightChoices;
+    private _shadowCatcherLightChoices;
     private _lightSamplingData?;
     private _lightSamplingScratch?;
     private _lightSamplingTriangleCount;
@@ -133,20 +117,29 @@ declare class WGPURayTracePass {
     private _envImageSource;
     private _envTex?;
     private _envDistributionTex?;
+    private _envDistribution?;
+    private _skyBaker?;
     private _backgroundImageSource;
     private _backgroundTex?;
-    private _rayTracePipelineLayout?;
     private _rayTraceBindGroups?;
+    private _photonEmissionGroups?;
     private _blasLayoutMask;
-    private _compiledBlasLayoutMask;
-    private _compiledAnisotropyDirections;
-    private _compiledCoatNormals;
-    private _compiledHasAlpha;
-    private _compiledSceneHasAlpha;
     private _alphaBlendStrategy;
     private _constants;
-    private _prevPipelineConstants;
-    private _prevDefinesCode;
+    private _retainedShaderCapabilities?;
+    private _retainedShaderStructure?;
+    private _shaderCapabilities;
+    private _targetTransport;
+    private _traceVariants;
+    private _queuedCompiles;
+    private _activeCompiles;
+    private _traceModules;
+    private _requestedVariant?;
+    private _activeVariant?;
+    private _activeInputs?;
+    private _awaitingRetirement?;
+    private _resourceError;
+    private _aovPipelinesFailed;
     private _hasTransmission;
     private _hasShadowCatcher;
     private _hasDisplacement;
@@ -160,23 +153,23 @@ declare class WGPURayTracePass {
     private _apertureRadius;
     private _focusDistance;
     private _needsUpdateBindGroups;
-    private _computeShaderModule?;
+    private _needsPhotonTargetBindGroups;
+    private _needsUpdateOutputBindGroup;
+    private _aovPipelines;
     private _depthCompute?;
     private _depthTracePipeline?;
     private _depthPipeline?;
     private _shaderCache;
     private _debugBVHBuffer?;
-    private _isCompilingShader;
-    private _shaderCompilationDiagnostics?;
-    private _pipelineError;
     private _bakePipelineConstants;
-    private _failedPipelineSignature?;
-    constructor(device: GPUDevice);
+    constructor(device: GPUDevice, _textureSelection?: MaterialTextureSelection);
     getOutputBuffer(): {
-        color: GPUBuffer;
         normal: GPUBuffer;
         albedo: GPUBuffer;
         shadowCatcher: GPUBuffer;
+        caustic?: GPUBuffer | undefined;
+        wideHdr?: boolean | undefined;
+        color: GPUBuffer;
     };
     private _ensureAdaptiveSamplingTexture;
     /**
@@ -188,18 +181,49 @@ declare class WGPURayTracePass {
     private _createPipelineLayout;
     private _updateGPUBuffer;
     private _uniformBuffer;
-    updatePipeline(): Promise<void>;
+    private _preparePhotonTarget;
+    /**
+     * Prepares the pipeline for the settings currently written to this pass.
+     * Everything except compilation runs synchronously, and compilation only
+     * writes to its own variant. Renders with different settings can therefore
+     * interleave without invalidating each other. Returns a promise while the
+     * requested state waits on the GPU; undefined means nothing is outstanding.
+     */
+    updatePipeline(): Promise<void> | undefined;
+    /** Runs only for a ready variant, without yielding, so tracing can start in this call. */
+    private _installTraceVariant;
+    /** Snapshots everything compilation needs. The task must not read mutable pass state afterwards. */
+    private _startTraceVariant;
+    /** Runs the most recently requested variants first: a dragged slider's last value is the one in use. */
+    private _pumpCompiles;
+    private _requestQueuedCompile;
+    private _prepareAovPipelines;
+    prepareAovs(kinds: readonly AovKind[]): boolean;
+    renderAovs(state: WGPUAov, camera: Camera, samples: number, cap: number, kinds: readonly AovKind[]): boolean;
     readDepthSamples(area: DepthSampleArea, aspect?: number): Promise<Float32Array | undefined>;
+    /** Whether the latest request waits on GPU work that will settle on its own. */
     isCompilingShader(): boolean;
     isPipelineReady(): boolean;
+    /** Failure of the latest request. A failed variant does not affect other renders. */
     getPipelineError(): unknown;
     private _updateBindGroups;
-    createPass(encoder: GPUCommandEncoder, clear: boolean, tiles: [number, number], timing?: WGPURayTraceTimingCapture): void;
+    createPass(encoder: GPUCommandEncoder, clear: boolean, tiles: [number, number], timing?: WGPURayTraceTimingCapture): number;
     getDebugBVHData(): Promise<{
         buffer: ArrayBuffer;
     }>;
     getDiagnostics(): {
-        textureAtlas: import("./MaterialTable.js").TextureAtlasStats | undefined;
+        textureAtlas: import("./textureAtlas.js").TextureAtlasStats | undefined;
+        materialTextures: {
+            metadataBytes: number;
+            resourceTableCapacity: number;
+            retiredBytes: number;
+            textureCount: number;
+            estimatedBytes: number;
+            scale: number;
+            requested: "auto" | "atlas";
+            active: "atlas" | "bindless";
+            fallbackReason: string | undefined;
+        };
         shaderCompilation: ShaderCompilationDiagnostics | undefined;
         lightSampling: {
             emissiveTriangles: number;
@@ -247,7 +271,9 @@ declare class WGPURayTracePass {
         bevel: boolean;
         dispersionWavelengths: 1 | 3;
         directLightCandidates: number;
+        caustics?: import('../Render.js').CausticSettings;
     }): void;
+    private _setCaustics;
     private _setEnvMap;
     setMeshes(meshes: Mesh[], update?: {
         transforms?: readonly Mesh[];
@@ -269,6 +295,7 @@ declare class WGPURayTracePass {
     private _updateMeshMembership;
     private _updateMeshColors;
     private _refitMeshInstances;
+    private _createMaterialData;
     private _updateTextures;
     setLights(lights: SceneLight[]): void;
     private _updateViewProjInv;