@haiyue/extensions 0.1.0 → 0.2.0

package/dist/ray-tracing/acceleration/types.d.ts

@@ -0,0 +1,165 @@
+import type { RayMatrix4, RayPrimitiveIdentity, RayVec3 } from '../reference/index.js';
+import type { RaySceneMaterialFacts, RaySceneSnapshot } from '../scene/index.js';
+export type RayAccelerationPhase = 'blas-build' | 'tlas-build' | 'refit' | 'pack' | 'lifecycle';
+export type RayAccelerationSeverity = 'info' | 'warning' | 'error';
+export interface RayAccelerationDiagnostic {
+    readonly phase: RayAccelerationPhase;
+    readonly severity: RayAccelerationSeverity;
+    readonly code: string;
+    readonly message: string;
+    readonly context: Readonly<Record<string, string | number | boolean | null>>;
+}
+export interface RayBounds3 {
+    readonly min: RayVec3;
+    readonly max: RayVec3;
+}
+export interface RayBvhNode {
+    readonly bounds: RayBounds3;
+    readonly leftChild: number;
+    readonly rightChild: number;
+    readonly firstIndex: number;
+    readonly indexCount: number;
+    readonly depth: number;
+}
+export interface RayAccelerationPrimitive {
+    readonly kind: 'triangle' | 'sphere';
+    readonly primitiveIndex: number;
+    readonly bounds: RayBounds3;
+    /** triangle = v0.xyz,v1.xyz,v2.xyz; sphere = center.xyz,radius */
+    readonly data: readonly number[];
+}
+export interface RayBlasStatistics {
+    readonly nodeCount: number;
+    readonly leafCount: number;
+    readonly primitiveCount: number;
+    readonly maxDepth: number;
+    readonly estimatedBytes: number;
+}
+export interface RayBlas {
+    readonly schemaVersion: 1;
+    readonly key: string;
+    readonly geometryId: string;
+    readonly geometryRevision: number;
+    readonly sourceKind: 'triangle-mesh' | 'analytic-sphere';
+    readonly sourceFingerprint: string;
+    readonly fingerprint: string;
+    readonly rootNode: number;
+    readonly bounds: RayBounds3 | null;
+    readonly nodes: readonly RayBvhNode[];
+    readonly primitives: readonly RayAccelerationPrimitive[];
+    /** Leaf ranges address this deterministic primitive-order array. */
+    readonly primitiveIndices: readonly number[];
+    readonly statistics: RayBlasStatistics;
+    readonly diagnostics: readonly RayAccelerationDiagnostic[];
+}
+export interface RayBlasBuildResult {
+    readonly blas: RayBlas | null;
+    readonly diagnostics: readonly RayAccelerationDiagnostic[];
+}
+export interface RayTlasInstance {
+    readonly instanceId: string;
+    readonly entityId: string;
+    readonly geometryId: string;
+    readonly geometryRevision: number;
+    readonly blasKey: string;
+    readonly transform: RayMatrix4;
+    readonly inverseTransform: RayMatrix4;
+    readonly bounds: RayBounds3;
+    readonly material: RaySceneMaterialFacts | null;
+    readonly analyticIdentity: RayPrimitiveIdentity | null;
+}
+export interface RayTlasStatistics {
+    readonly nodeCount: number;
+    readonly leafCount: number;
+    readonly instanceCount: number;
+    readonly maxDepth: number;
+    readonly estimatedBytes: number;
+}
+export interface RayTlas {
+    readonly schemaVersion: 1;
+    readonly sourceFingerprint: string;
+    readonly membershipFingerprint: string;
+    readonly transformFingerprint: string;
+    readonly materialFingerprint: string;
+    readonly fingerprint: string;
+    readonly rootNode: number;
+    readonly bounds: RayBounds3 | null;
+    readonly nodes: readonly RayBvhNode[];
+    readonly instances: readonly RayTlasInstance[];
+    /** Leaf ranges address this deterministic instance-order array. */
+    readonly instanceIndices: readonly number[];
+    readonly statistics: RayTlasStatistics;
+    readonly diagnostics: readonly RayAccelerationDiagnostic[];
+}
+export type RayAccelerationUpdateKind = 'initial-build' | 'unchanged' | 'material-update' | 'transform-refit' | 'membership-rebuild' | 'topology-rebuild';
+export type RayPackedBufferName = 'blasNodes' | 'blasTable' | 'tlasNodes' | 'primitives' | 'instances' | 'materials';
+export interface RayDirtyUploadRange {
+    readonly buffer: RayPackedBufferName;
+    /** replace also carries targetByteLength=0 so removals release stale GPU storage. */
+    readonly mode: 'write' | 'replace';
+    readonly byteOffset: number;
+    readonly byteLength: number;
+    readonly targetByteLength: number;
+}
+export interface RayPackedBuffer {
+    readonly name: RayPackedBufferName;
+    readonly stride: number;
+    readonly count: number;
+    readonly data: ArrayBuffer;
+}
+export interface RayPackedAccelerationMemory {
+    readonly blasNodesBytes: number;
+    readonly blasTableBytes: number;
+    readonly tlasNodesBytes: number;
+    readonly primitivesBytes: number;
+    readonly instancesBytes: number;
+    readonly materialsBytes: number;
+    readonly totalBytes: number;
+}
+export interface RayPackedAcceleration {
+    readonly schemaVersion: 1;
+    readonly abiFingerprint: string;
+    readonly sourceFingerprint: string;
+    readonly fingerprint: string;
+    readonly tlasRootNode: number;
+    readonly buffers: Readonly<Record<RayPackedBufferName, RayPackedBuffer>>;
+    readonly geometryIdentities: readonly string[];
+    readonly instanceIdentities: readonly string[];
+    readonly materialIdentities: readonly string[];
+    readonly memory: RayPackedAccelerationMemory;
+    readonly diagnostics: readonly RayAccelerationDiagnostic[];
+}
+export interface RayPackResult {
+    readonly packed: RayPackedAcceleration | null;
+    readonly diagnostics: readonly RayAccelerationDiagnostic[];
+}
+export interface RayAccelerationSnapshot {
+    readonly source: RaySceneSnapshot;
+    readonly blases: ReadonlyMap<string, RayBlas>;
+    readonly tlas: RayTlas;
+    readonly packed: RayPackedAcceleration;
+    readonly fingerprint: string;
+}
+export interface RayAccelerationUpdate {
+    readonly kind: RayAccelerationUpdateKind;
+    readonly snapshot: RayAccelerationSnapshot | null;
+    readonly dirtyRanges: readonly RayDirtyUploadRange[];
+    readonly diagnostics: readonly RayAccelerationDiagnostic[];
+}
+export interface RayAccelerationRuntimeStatistics {
+    readonly buildCount: number;
+    readonly refitCount: number;
+    readonly materialUpdateCount: number;
+    readonly cacheHitCount: number;
+    readonly currentBytes: number;
+    readonly peakBytes: number;
+    readonly liveBlasCount: number;
+    readonly destroyed: boolean;
+}
+export interface RayAccelerationCandidateQuery {
+    readonly candidates: readonly RayPrimitiveIdentity[];
+    readonly diagnostics: readonly RayAccelerationDiagnostic[];
+    readonly tlasNodeTests: number;
+    readonly blasNodeTests: number;
+    readonly aborted: boolean;
+}

package/dist/ray-tracing/denoise/index.d.ts

@@ -0,0 +1,3 @@
+export { RAY_DENOISE_LAYOUT } from './layout.js';
+export { RaySpatialTemporalDenoiser } from './runtime.js';
+export type { RayDenoiseCreateResult, RayDenoiseOptions } from './types.js';

package/dist/ray-tracing/denoise/layout.d.ts

@@ -0,0 +1,9 @@
+export declare const RAY_DENOISE_LAYOUT: Readonly<{
+    artifactHash: "b2e55dafdf2be903e797241d14a98e76bee2c64e95dd889069a27044afe4d1aa";
+    temporalPassId: "ray-denoise-temporal";
+    spatialPassId: "ray-denoise-spatial";
+    parameterBytes: 64;
+    workgroupSizeX: 8;
+    workgroupSizeY: 8;
+}>;
+export declare function createRayDenoiseLayouts(device: GPUDevice): readonly [GPUBindGroupLayout, GPUBindGroupLayout];

package/dist/ray-tracing/denoise/runtime.d.ts

@@ -0,0 +1,23 @@
+import type { RayDenoiseCreateResult, RayDenoiseOptions, RayDenoiseRecordOptions, RayDenoiseRecordResult } from './types.js';
+export declare class RaySpatialTemporalDenoiser {
+    readonly artifactHash: "b2e55dafdf2be903e797241d14a98e76bee2c64e95dd889069a27044afe4d1aa";
+    readonly revision: string;
+    private readonly _device;
+    private readonly _options;
+    private _layouts;
+    private _temporalPipeline;
+    private _spatialPipeline;
+    private _history;
+    private _scratch;
+    private _width;
+    private _height;
+    private _destroyed;
+    private constructor();
+    static create(device: GPUDevice, options?: RayDenoiseOptions): Promise<RayDenoiseCreateResult>;
+    get destroyed(): boolean;
+    get liveResourceCount(): number;
+    get scratchBytes(): number;
+    record(options: RayDenoiseRecordOptions): RayDenoiseRecordResult;
+    destroy(): void;
+    private resize;
+}

package/dist/ray-tracing/denoise/types.d.ts

@@ -0,0 +1,28 @@
+import type { RayProgressiveDiagnostic } from '../sampling/types.js';
+export interface RayDenoiseOptions {
+    readonly temporalFeedback?: number;
+    readonly phiColor?: number;
+    readonly phiFeature?: number;
+    readonly varianceBoost?: number;
+}
+export interface RayDenoiseCreateResult {
+    readonly denoiser: import('./runtime.js').RaySpatialTemporalDenoiser | null;
+    readonly diagnostics: readonly RayProgressiveDiagnostic[];
+}
+export interface RayDenoiseRecordOptions {
+    readonly encoder: GPUCommandEncoder;
+    readonly accumulation: GPUTexture;
+    readonly moments: GPUTexture;
+    readonly feature: GPUTexture;
+    readonly width: number;
+    readonly height: number;
+    readonly sampleIndex: number;
+    readonly reset: boolean;
+    readonly querySet: GPUQuerySet | null;
+    readonly temporalTimestampStart: number;
+    readonly spatialTimestampStart: number;
+}
+export interface RayDenoiseRecordResult {
+    readonly output: GPUTexture;
+    readonly transientBuffers: readonly GPUBuffer[];
+}

package/dist/ray-tracing/hybrid/contract.d.ts

@@ -0,0 +1,2 @@
+import type { RayHybridFrameContract, RayHybridFrameInputs, RayHybridOptions } from './types.js';
+export declare function createRayHybridFrameContract(inputs: RayHybridFrameInputs, options?: RayHybridOptions): RayHybridFrameContract;

package/dist/ray-tracing/hybrid/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './contract.js';
+export * from './plan.js';
+export * from './layout.js';
+export * from './runtime.js';

package/dist/ray-tracing/hybrid/layout.d.ts

@@ -0,0 +1,17 @@
+import { RAY_HYBRID_SHADER_ARTIFACT } from './shaders/hybrid-artifact.generated.js';
+export declare const RAY_HYBRID_LAYOUT: Readonly<{
+    artifactHash: "4a09990032ae1bfa55cc1f1de81b11e08e2611cb0bf05643f37aa8d179798077";
+    workgroupSize: 8;
+    parameterBytes: 256;
+    compositeParameterBytes: 32;
+    diagnosticBytes: 48;
+    passIds: Readonly<{
+        shadow: "ray-hybrid-shadow";
+        reflection: "ray-hybrid-reflection";
+        ao: "ray-hybrid-ao";
+        composite: "ray-hybrid-composite";
+    }>;
+}>;
+type PassId = keyof typeof RAY_HYBRID_SHADER_ARTIFACT.passes;
+export declare function createRayHybridLayouts(device: GPUDevice): Readonly<Record<PassId, GPUBindGroupLayout>>;
+export {};

package/dist/ray-tracing/hybrid/plan.d.ts

@@ -0,0 +1,2 @@
+import type { RayHybridFrameContract, RayHybridPass } from './types.js';
+export declare function createRayHybridRenderPlan(contract: RayHybridFrameContract): readonly RayHybridPass[];

package/dist/ray-tracing/hybrid/runtime.d.ts

@@ -0,0 +1,31 @@
+import type { RayHybridCreateResult, RayHybridFrameInputs, RayHybridOptions, RayHybridRenderResult } from './types.js';
+export declare class RayHybridRenderer {
+    readonly artifactHash: "4a09990032ae1bfa55cc1f1de81b11e08e2611cb0bf05643f37aa8d179798077";
+    private readonly device;
+    private readonly layouts;
+    private readonly pipelines;
+    private accelerationFingerprint;
+    private buffers;
+    private views;
+    private neutral;
+    private destroyedValue;
+    private generation;
+    private lost;
+    private busy;
+    private uncaptured;
+    private readonly errorHandler;
+    private constructor();
+    static create(device: GPUDevice): Promise<RayHybridCreateResult>;
+    get destroyed(): boolean;
+    get liveResourceCount(): number;
+    get ownedBytes(): number;
+    render(inputs: RayHybridFrameInputs, options?: RayHybridOptions): Promise<RayHybridRenderResult>;
+    destroy(): void;
+    private ensureAcceleration;
+    private ensureNeutral;
+    private ensureView;
+    private ensureEffect;
+    private releaseEffect;
+    private releaseView;
+    private releaseStatic;
+}