@motion-core/motion-gpu/dist/core/compute-resources.d.ts

Framework-agnostic WebGPU runtime for fullscreen WGSL shaders with explicit Svelte, React, and Vue adapter entrypoints.

/// <reference types="@webgpu/types" />
import type { ComputeExternalResourceContext, ComputeResourceMap, ComputeResourceVersion, ComputeTextureReference, StorageBufferType } from './types.js';
import { type MotionGPUErrorContext } from './error-report.js';
import type { RuntimeStorageBufferResource, RuntimeTextureResource } from './resource-registry.js';
export interface ComputePingPongResourcePair {
    readAlias: string;
    writeAlias: string;
    texture: ComputeTextureReference;
}
export interface ResolvedTextureSubresourceRange {
    baseMipLevel: number;
    mipLevelCount: number;
    baseArrayLayer: number;
    arrayLayerCount: 1;
}
export type ResolvedComputeResourceSource = 'material' | 'external';
interface ResolvedComputeResourceBase {
    alias: string;
    binding: number;
    logicalId: string | symbol;
    physicalId: object | string | symbol;
    source: ResolvedComputeResourceSource;
    layoutEntry: GPUBindGroupLayoutEntry;
    bindingResource: GPUBindingResource;
    topologyPart: string;
}
export interface ResolvedSampledTextureResource extends ResolvedComputeResourceBase {
    kind: 'sampled-texture';
    access: 'sampled';
    format: GPUTextureFormat;
    scalarType: 'f32' | 'u32' | 'i32';
    sampleType: GPUTextureSampleType;
    version: ComputeResourceVersion;
    pingPong: 'read' | undefined;
    subresource: ResolvedTextureSubresourceRange;
    bindingResource: GPUTextureView;
}
export interface ResolvedStorageTextureResource extends ResolvedComputeResourceBase {
    kind: 'storage-texture';
    access: 'storage-write';
    format: GPUTextureFormat;
    pingPong: 'write' | undefined;
    subresource: ResolvedTextureSubresourceRange;
    bindingResource: GPUTextureView;
}
export interface ResolvedStorageBufferResource extends ResolvedComputeResourceBase {
    kind: 'storage-buffer';
    access: 'storage-read' | 'storage-read-write';
    wgslType: StorageBufferType;
    size: number;
    version: ComputeResourceVersion | undefined;
    bindingResource: GPUBufferBinding;
}
export interface ResolvedSamplerResource extends ResolvedComputeResourceBase {
    kind: 'sampler';
    samplerType: GPUSamplerBindingType;
    bindingResource: GPUSampler;
}
export type ResolvedComputeResource = ResolvedSampledTextureResource | ResolvedStorageTextureResource | ResolvedStorageBufferResource | ResolvedSamplerResource;
export interface ResolvedComputeAccess {
    alias: string;
    resourceKind: 'texture' | 'buffer';
    logicalId: string | symbol;
    physicalId: object | string | symbol;
    mode: 'read' | 'write';
    version: ComputeResourceVersion;
    subresource?: ResolvedTextureSubresourceRange;
}
export interface ResolvedComputePassResources {
    entries: readonly ResolvedComputeResource[];
    reads: readonly ResolvedComputeAccess[];
    writes: readonly ResolvedComputeAccess[];
    topologyKey: string;
    bindingCount: number;
}
export interface ComputeMaterialSamplerResource {
    logicalId: string;
    sampler: GPUSampler;
    type: GPUSamplerBindingType;
    sampleType: GPUTextureSampleType;
}
export interface ComputeResourceResolverLimits {
    maxBindingsPerBindGroup: number;
    maxSampledTexturesPerShaderStage: number;
    maxSamplersPerShaderStage: number;
    maxStorageTexturesPerShaderStage: number;
    maxStorageBuffersPerShaderStage: number;
    maxStorageBufferBindingSize: number;
}
export interface ComputeResourceResolverContext {
    passLabel: string;
    deviceFeatures: ReadonlySet<string>;
    limits: ComputeResourceResolverLimits;
    externalContext: ComputeExternalResourceContext;
    getMaterialTexture: (logicalId: string) => RuntimeTextureResource | undefined;
    getMaterialStorageBuffer: (logicalId: string) => RuntimeStorageBufferResource | undefined;
    getMaterialSampler: (logicalId: string) => ComputeMaterialSamplerResource | undefined;
    createTextureView?: (texture: GPUTexture, descriptor: GPUTextureViewDescriptor) => GPUTextureView;
    pingPong?: boolean;
    externalState?: ComputeExternalResolutionState;
    diagnosticContext?: MotionGPUErrorContext;
}
export interface ResolvedComputeTextureFormat {
    scalarType: 'f32' | 'u32' | 'i32';
    sampleType: GPUTextureSampleType;
}
/**
 * Validates, clones and freezes a deterministic compute resource topology.
 */
export declare function normalizeComputeResourceMap(resources: ComputeResourceMap | undefined): ComputeResourceMap;
/**
 * Returns a deep-enough defensive copy while preserving external GPU handles/providers.
 */
export declare function copyComputeResourceMap(resources: ComputeResourceMap): ComputeResourceMap;
/**
 * Validates and resolves the single read/write pair required by ping-pong compute.
 */
export declare function resolveComputePingPongResourcePair(resources: ComputeResourceMap): ComputePingPongResourcePair;
export interface ComputeExternalResolutionState {
    providerResults: Map<object, object>;
    resourceIdByObject: Map<object, string | symbol>;
    metadataByResourceId: Map<string | symbol, string>;
    textureByResourceId: Map<string | symbol, object>;
    bufferByResourceId: Map<string | symbol, object>;
    samplerByResourceId: Map<string | symbol, object>;
}
export declare function createComputeExternalResolutionState(): ComputeExternalResolutionState;
/**
 * Maps a supported 2D color texture format to its compute sampled contract.
 */
export declare function resolveComputeTextureFormat(format: GPUTextureFormat, deviceFeatures: ReadonlySet<string>): ResolvedComputeTextureFormat;
/**
 * Resolves one immutable public resource map into the single model consumed by
 * shader generation, layouts, bind groups, graph planning, and dispatch.
 */
export declare function resolveComputePassResources(resources: ComputeResourceMap, context: ComputeResourceResolverContext): ResolvedComputePassResources;
export {};
//# sourceMappingURL=compute-resources.d.ts.map