typegpu 0.0.0-alpha.4 → 0.0.0-alpha.5

package/index.d.cts

@@ -1,348 +1,76 @@
-import { W as WgslResolvable, a as WgslSlot, E as Eventual, b as Wgsl, I as InlineResolve, c as WgslRenderResource, T as TextureUsage, S as StorageTextureParams, A as AnyWgslTexelFormat, d as SampledTextureParams, e as AnyWgslPrimitive, f as WgslRenderResourceType, g as StorageTextureAccess, R as ResolutionCtx, h as WgslPlum, i as ExtractPlumValue, j as WgslSettable, U as Unsubscribe, k as AnyWgslData, l as WgslAllocatable, B as BufferUsage, m as WgslBindable, n as WgslFnArgument, o as WgslValue, p as WgslIdentifier, q as WgslResolvableSlot, r as plum, s as plumFromEvent } from './types-ENDwr_p9.cjs';
-export { O as AnyWgslPointer, Q as BuiltInPossibleTypes, X as Builtin, w as EventualGetter, x as SlotValuePair, M as WgslData, C as WgslDepthTextureType, F as WgslExternalTextureType, N as WgslPointer, y as WgslSamplerType, D as WgslStorageTextureType, z as WgslTypedTextureType, V as builtin, Y as getBuiltinInfo, Z as getUsedBuiltinsNamed, J as isDepthTextureType, L as isExternalTextureType, P as isPointer, t as isResolvable, G as isSamplerType, v as isSlot, K as isStorageTextureType, H as isTypedTextureType, u as isWgsl } from './types-ENDwr_p9.cjs';
-import { Parsed, AnySchema } from 'typed-binary';
-import { S as SimpleWgslData } from './std140-DRitCcmc.cjs';
+import { Parsed } from 'typed-binary';
+import { A as AnyTgpuData, B as BufferUsage, T as TgpuBindable, a as TgpuAllocatable, b as TgpuNamable, c as TgpuPlum, v as vecBase, d as vec3f, e as vec3i, f as vec3u } from './types-DU0c7BuW.cjs';
+export { h as TexelFormat, g as TgpuData } from './types-DU0c7BuW.cjs';
 
-/**
- * An error that happens during resolution of WGSL code.
- * Contains a trace of all ancestor resolvables in
- * which this error originated.
- *
- * @category Errors
- */
-declare class ResolutionError extends Error {
-    readonly cause: unknown;
-    readonly trace: WgslResolvable[];
-    constructor(cause: unknown, trace: WgslResolvable[]);
-    appendToTrace(ancestor: WgslResolvable): ResolutionError;
-}
-/**
- * @category Errors
- */
-declare class MissingSlotValueError extends Error {
-    readonly slot: WgslSlot<unknown>;
-    constructor(slot: WgslSlot<unknown>);
-}
-/**
- * @category Errors
- */
-declare class RecursiveDataTypeError extends Error {
-    constructor();
-}
-
-declare abstract class Callable<TArgs extends [...any[]], TReturn> extends Function {
-    _bound: Callable<TArgs, TReturn>;
-    constructor();
-    abstract _call(...args: TArgs): TReturn;
-}
-type ICallable<TArgs extends [...any[]], TReturn> = (...args: TArgs) => TReturn;
-type AsCallable<T, TArgs extends [...any[]], TReturn> = T & ICallable<TArgs, TReturn>;
-
-type PlumListener<T> = (newValue: T) => unknown;
-
-interface WgslCode extends WgslResolvable {
-    $name(label?: string | undefined): WgslCode;
-    with<T>(slot: WgslSlot<T>, value: Eventual<T>): BoundWgslCode;
+interface TgpuBufferUsage<TData extends AnyTgpuData, TUsage extends BufferUsage = BufferUsage> extends TgpuBindable<TData, TUsage> {
 }
-type BoundWgslCode = Omit<WgslCode, '$name'>;
-declare function code(strings: TemplateStringsArray, ...params: (Wgsl | Wgsl[] | InlineResolve)[]): WgslCode;
 
-interface WgslSampler extends WgslRenderResource {
-    readonly descriptor: GPUSamplerDescriptor;
-    $name(label: string): WgslSampler;
-}
-declare function sampler(descriptor: GPUSamplerDescriptor): WgslSampler;
-
-interface WgslAnyTextureView extends WgslRenderResource {
-    readonly descriptor: GPUTextureViewDescriptor;
-    readonly texture: WgslAnyTexture;
-    readonly dataType: AnyWgslPrimitive | AnyWgslTexelFormat;
-    readonly access: StorageTextureAccess | undefined;
-}
-interface WgslAnyTexture {
-    readonly descriptor: Omit<GPUTextureDescriptor, 'usage'>;
-    get flags(): GPUTextureUsageFlags;
-}
-interface WgslTexture<TAllows extends TextureUsage = never> {
-    readonly descriptor: Omit<GPUTextureDescriptor, 'usage'>;
-    get label(): string | undefined;
-    get flags(): GPUTextureUsageFlags;
-    $name(label: string): WgslTexture<TAllows>;
-    $allowSampled(): WgslTexture<TAllows | 'sampled'>;
-    $allowStorage(): WgslTexture<TAllows | 'storage'>;
-    asStorage(params: StorageTextureParams): 'storage' extends TAllows ? WgslTextureView<AnyWgslTexelFormat, 'storage'> : null;
-    asSampled(params: SampledTextureParams): 'sampled' extends TAllows ? WgslTextureView<typeof params.dataType, 'sampled'> : null;
-}
-interface WgslTextureView<TData extends AnyWgslPrimitive | AnyWgslTexelFormat, TUsage extends TextureUsage> extends WgslRenderResource {
-    readonly texture: WgslTexture<TUsage>;
-    readonly descriptor: Omit<GPUTextureViewDescriptor, 'usage'>;
-    readonly type: WgslRenderResourceType;
-    readonly dataType: TData;
-    readonly access: StorageTextureAccess | undefined;
-    $name(label: string): WgslTextureView<TData, TUsage>;
-}
-interface WgslTextureExternal extends WgslRenderResource {
-    readonly descriptor: GPUExternalTextureDescriptor;
-}
-declare function texture<TUsage extends TextureUsage = never>(descriptor: Omit<GPUTextureDescriptor, 'usage'>): WgslTexture<TUsage>;
-declare function textureExternal(descriptor: GPUExternalTextureDescriptor): WgslTextureExternalImpl;
-declare class WgslTextureExternalImpl implements WgslTextureExternal {
-    readonly descriptor: GPUExternalTextureDescriptor;
-    private _label;
-    readonly type = "texture_external";
-    constructor(descriptor: GPUExternalTextureDescriptor);
-    get label(): string | undefined;
-    $name(label: string | undefined): this;
-    resolve(ctx: ResolutionCtx): string;
-}
-
-type SetPlumAction<T> = T | ((prev: T) => T);
-interface TypeGpuRuntime {
+interface Unmanaged {
     readonly device: GPUDevice;
-    /**
-     * The current command encoder. This property will
-     * hold the same value until `flush()` is called.
-     */
-    readonly commandEncoder: GPUCommandEncoder;
-    readPlum<TPlum extends WgslPlum>(plum: TPlum): ExtractPlumValue<TPlum>;
-    setPlum<TPlum extends WgslPlum & WgslSettable>(plum: TPlum, value: SetPlumAction<ExtractPlumValue<TPlum>>): void;
-    onPlumChange<TValue>(plum: WgslPlum<TValue>, listener: PlumListener<TValue>): Unsubscribe;
-    writeBuffer<TValue extends AnyWgslData>(allocatable: WgslAllocatable<TValue>, data: Parsed<TValue>): void;
-    readBuffer<TData extends AnyWgslData>(allocatable: WgslAllocatable<TData>): Promise<Parsed<TData>>;
-    bufferFor(allocatable: WgslAllocatable): GPUBuffer;
-    textureFor(view: WgslAnyTexture | WgslAnyTextureView): GPUTexture;
-    viewFor(view: WgslAnyTextureView): GPUTextureView;
-    externalTextureFor(texture: WgslTextureExternal): GPUExternalTexture;
-    samplerFor(sampler: WgslSampler): GPUSampler;
-    dispose(): void;
-    /**
-     * Causes all commands enqueued by pipelines to be
-     * submitted to the GPU.
-     */
-    flush(): void;
-    makeRenderPipeline(options: RenderPipelineOptions): RenderPipelineExecutor;
-    makeComputePipeline(options: ComputePipelineOptions): ComputePipelineExecutor;
-}
-interface RenderPipelineOptions {
-    vertex: {
-        code: WgslCode | BoundWgslCode;
-        output: {
-            [K in symbol]: string;
-        } & {
-            [K in string]: AnyWgslData;
-        };
-    };
-    fragment: {
-        code: WgslCode | BoundWgslCode;
-        target: Iterable<GPUColorTargetState | null>;
-    };
-    primitive: GPUPrimitiveState;
-    externalLayouts?: GPUBindGroupLayout[];
-    label?: string;
-}
-interface ComputePipelineOptions {
-    code: WgslCode | BoundWgslCode;
-    workgroupSize?: readonly [number, number?, number?];
-    externalLayouts?: GPUBindGroupLayout[];
-    label?: string;
+    readonly buffer: GPUBuffer;
 }
-type RenderPipelineExecutorOptions = GPURenderPassDescriptor & {
-    vertexCount: number;
-    instanceCount?: number;
-    firstVertex?: number;
-    firstInstance?: number;
-    externalBindGroups?: GPUBindGroup[];
-};
-interface RenderPipelineExecutor {
-    execute(options: RenderPipelineExecutorOptions): void;
-}
-type ComputePipelineExecutorOptions = {
-    workgroups?: readonly [number, number?, number?];
-    externalBindGroups?: GPUBindGroup[];
-};
-interface ComputePipelineExecutor {
-    execute(options?: ComputePipelineExecutorOptions): void;
+interface AllowUniform {
+    uniformAllowed: true;
 }
-declare function deriveVertexFormat<TData extends SimpleWgslData<AnySchema>>(typeSchema: TData): GPUVertexFormat;
-
-interface NameRegistry {
-    nameFor(item: WgslResolvable): string;
+interface AllowReadonly {
+    readonlyAllowed: true;
 }
-declare class RandomNameRegistry implements NameRegistry {
-    private lastUniqueId;
-    private names;
-    nameFor(item: WgslResolvable): string;
+interface AllowMutable {
+    mutableAllowed: true;
 }
-declare class StrictNameRegistry implements NameRegistry {
-    /**
-     * Allows to provide a good fallback for instances of the
-     * same function that are bound to different slot values.
-     */
-    private readonly _usedNames;
-    private readonly _assignedNames;
-    nameFor(item: WgslResolvable): string;
+interface AllowVertex {
+    vertexAllowed: true;
 }
-
-type Program = {
-    readonly bindGroupLayout: GPUBindGroupLayout;
-    readonly bindGroup: GPUBindGroup;
-    readonly code: string;
+type AllowedUsages<TData extends AnyTgpuData> = {
+    uniform: TgpuBufferUsage<TData, 'uniform'> | null;
+    mutable: TgpuBufferUsage<TData, 'mutable'> | null;
+    readonly: TgpuBufferUsage<TData, 'readonly'> | null;
+    vertex: TgpuBufferUsage<TData, 'vertex'> | null;
 };
-type BuildOptions = {
-    shaderStage: number;
-    bindingGroup: number;
-    nameRegistry?: NameRegistry;
+interface TgpuBuffer<TData extends AnyTgpuData> extends TgpuAllocatable<TData>, TgpuNamable {
+    $allowUniform(): this & AllowUniform;
+    $allowReadonly(): this & AllowReadonly;
+    $allowMutable(): this & AllowMutable;
+    $allowVertex(stepMode: 'vertex' | 'instance'): this & AllowVertex;
+    $addFlags(flags: GPUBufferUsageFlags): this;
+    $device(device: GPUDevice): this & Unmanaged;
+    _usages: AllowedUsages<TData>;
+    readonly label: string | undefined;
+}
+declare function buffer<TData extends AnyTgpuData>(typeSchema: TData, initial?: Parsed<TData> | TgpuPlum<Parsed<TData>> | undefined): TgpuBuffer<TData>;
+declare function buffer<TData extends AnyTgpuData>(typeSchema: TData, gpuBuffer: GPUBuffer): TgpuBuffer<TData>;
+
+declare function write<TData extends AnyTgpuData>(buffer: TgpuBuffer<TData> & Unmanaged, data: Parsed<TData>): void;
+declare function read<TData extends AnyTgpuData>(buffer: TgpuBuffer<TData> & Unmanaged): Promise<Parsed<TData>>;
+
+declare const tgpu: {
+    createBuffer: typeof buffer;
+    read: typeof read;
+    write: typeof write;
 };
-declare class ProgramBuilder {
-    private runtime;
-    private root;
-    constructor(runtime: TypeGpuRuntime, root: WgslResolvable);
-    build(options: BuildOptions): Program;
-}
-
-type VariableScope = 'private' | 'workgroup';
-interface WgslVar<TDataType extends AnyWgslData> extends WgslResolvable {
-    $name(label: string): WgslVar<TDataType>;
-}
 
-interface WgslBufferUsage<TData extends AnyWgslData, TUsage extends BufferUsage = BufferUsage> extends WgslBindable<TData, TUsage> {
-    $name(label: string): WgslBufferUsage<TData, TUsage>;
-}
-
-type UsageGuard<TUsage extends BufferUsage, TData extends AnyWgslData, TAllows> = TUsage extends TAllows ? WgslBufferUsage<TData, TUsage> : null;
-interface WgslBuffer<TData extends AnyWgslData, TAllows extends BufferUsage = never> extends WgslAllocatable<TData> {
-    $name(label: string): WgslBuffer<TData, TAllows>;
-    $allowUniform(): WgslBuffer<TData, TAllows | 'uniform'>;
-    $allowReadonly(): WgslBuffer<TData, TAllows | 'readonly'>;
-    $allowMutable(): WgslBuffer<TData, TAllows | 'mutable'>;
-    $allowVertex(stepMode: 'vertex' | 'instance'): WgslBuffer<TData, TAllows | 'vertex'>;
-    $addFlags(flags: GPUBufferUsageFlags): WgslBuffer<TData, TAllows>;
-    asUniform(): UsageGuard<'uniform', TData, TAllows>;
-    asMutable(): UsageGuard<'mutable', TData, TAllows>;
-    asReadonly(): UsageGuard<'readonly', TData, TAllows>;
-    asVertex(): UsageGuard<'vertex', TData, TAllows>;
-}
-declare function buffer<TData extends AnyWgslData, TUsage extends BufferUsage = never>(typeSchema: TData, initial?: Parsed<TData> | WgslPlum<Parsed<TData>> | undefined): WgslBuffer<TData, TUsage>;
-
-interface WgslConst extends WgslResolvable {
-    $name(label: string): WgslConst;
-}
 /**
- * Creates a constant is computed at shader initialization according
- * to the passed in expression.
+ * @category Errors
  */
-declare function constant(expr: Wgsl): WgslConst;
-
-interface WgslDeclare extends WgslResolvable {
-}
-declare function declare(strings: TemplateStringsArray, ...params: (Wgsl | Wgsl[] | InlineResolve)[]): WgslDeclare;
-
-interface WgslFn$1 extends WgslResolvable {
-    $name(label: string): WgslFn$1;
-    with<T>(slot: WgslSlot<T>, value: Eventual<T>): BoundWgslFn;
-}
-type BoundWgslFn = Omit<WgslFn$1, '$name'>;
-declare function fn$1(strings: TemplateStringsArray, ...params: (Wgsl | InlineResolve)[]): WgslFn$1;
-
-interface WgslFn<TArgTypes extends [WgslFnArgument, ...WgslFnArgument[]] | [], TReturn extends AnyWgslData | undefined = undefined> extends WgslResolvable, Callable<SegmentsFromTypes<TArgTypes>, WgslFunctionCall<TArgTypes, TReturn>> {
-}
-declare function fn<TArgTypes extends [WgslFnArgument, ...WgslFnArgument[]] | [], TReturn extends AnyWgslData | undefined = undefined>(argTypes: TArgTypes, returnType?: TReturn): (bodyProducer: (...args: ValuesFromTypes<TArgTypes>) => Wgsl) => AsCallable<WgslFnImpl<TArgTypes, TReturn>, SegmentsFromTypes<TArgTypes>, WgslFunctionCall<TArgTypes>>;
-type ValuesFromTypes<TArgTypes extends WgslFnArgument[]> = {
-    [K in keyof TArgTypes]: WgslValue<TArgTypes[K]> & WgslIdentifier;
-};
-type PairsFromTypes<TArgTypes extends WgslFnArgument[]> = {
-    [K in keyof TArgTypes]: readonly [WgslIdentifier, TArgTypes[K]];
-};
-type SegmentsFromTypes<TArgTypes extends WgslFnArgument[]> = {
-    [K in keyof TArgTypes]: Wgsl;
-};
-declare class WgslFunctionCall<TArgTypes extends [WgslFnArgument, ...WgslFnArgument[]] | [], TReturn extends AnyWgslData | undefined = undefined> implements WgslResolvable {
-    private usedFn;
-    private readonly args;
-    constructor(usedFn: WgslFn<TArgTypes, TReturn>, args: SegmentsFromTypes<TArgTypes>);
-    resolve(ctx: ResolutionCtx): string;
-    toString(): string;
-}
-declare class WgslFnImpl<TArgTypes extends [WgslFnArgument, ...WgslFnArgument[]] | [], TReturn extends AnyWgslData | undefined = undefined> extends Callable<SegmentsFromTypes<TArgTypes>, WgslFunctionCall<TArgTypes, TReturn>> implements WgslFn<TArgTypes, TReturn> {
-    private argPairs;
-    private returnType;
-    private readonly body;
-    private _label;
-    constructor(argPairs: PairsFromTypes<TArgTypes>, returnType: TReturn | undefined, body: Wgsl);
-    get label(): string | undefined;
-    $name(label: string): this;
-    resolve(ctx: ResolutionCtx): string;
-    _call(...args: SegmentsFromTypes<TArgTypes>): WgslFunctionCall<TArgTypes, TReturn>;
-    toString(): string;
+declare class RecursiveDataTypeError extends Error {
+    constructor();
 }
 
-declare function slot<T extends Wgsl>(defaultValue?: T): WgslResolvableSlot<T>;
-declare function slot<T>(defaultValue?: T): WgslSlot<T>;
-
-declare const _default: typeof code & {
-    code: typeof code;
-    fn: typeof fn$1;
-    fun: typeof fn;
-    buffer: typeof buffer;
-    plum: typeof plum;
-    plumFromEvent: typeof plumFromEvent;
-    slot: typeof slot;
-    constant: typeof constant;
-    declare: typeof declare;
-    var: <TDataType extends AnyWgslData>(dataType: TDataType, initialValue?: Wgsl, scope?: VariableScope) => WgslVar<TDataType>;
-    sampler: typeof sampler;
-    texture: typeof texture;
-    textureExternal: typeof textureExternal;
-    builtin: {
-        readonly vertexIndex: symbol;
-        readonly instanceIndex: symbol;
-        readonly position: symbol;
-        readonly clipDistances: symbol;
-        readonly frontFacing: symbol;
-        readonly fragDepth: symbol;
-        readonly sampleIndex: symbol;
-        readonly sampleMask: symbol;
-        readonly fragment: symbol;
-        readonly localInvocationId: symbol;
-        readonly localInvocationIndex: symbol;
-        readonly globalInvocationId: symbol;
-        readonly workgroupId: symbol;
-        readonly numWorkgroups: symbol;
-    };
+declare const std: {
+    add: <T extends vecBase>(lhs: T, rhs: T) => T;
+    sub: <T extends vecBase>(lhs: T, rhs: T) => T;
+    mul: <T extends vecBase>(s: number, v: T) => T;
+    dot: <T extends vecBase>(lhs: T, rhs: T) => number;
+    normalize: <T extends vecBase>(v: T) => T;
+    cross: <T extends vec3f | vec3i | vec3u>(a: T, b: T) => T;
+    fract: (a: number) => number;
+    length: <T extends vecBase>(vector: T) => number;
+    sin: (x: number) => number;
+    cos: (x: number) => number;
 };
 
 /**
- * Options passed into {@link createRuntime}.
- */
-type CreateRuntimeOptions = {
-    adapter: GPURequestAdapterOptions | undefined;
-    device: GPUDeviceDescriptor | undefined;
-};
-/**
- * @param options
- * @returns
- *
- * @example
- * When given no options, the function will ask the browser for a suitable GPU device.
- * ```ts
- * createRuntime();
- * ```
- *
- * @example
- * If there are specific options that should be used when requesting a device, you can pass those in.
- * ```ts
- * const adapterOptions: GPURequestAdapterOptions = ...;
- * const deviceDescriptor: GPUDeviceDescriptor = ...;
- * createRuntime({ adapter: adapterOptions, device: deviceDescriptor });
- * ```
- *
- * @example
- * If a specific device should be used instead, it can be passed in as a parameter.
- * ```ts
- * const device: GPUDevice = ...;
- * createRuntime(device);
- * ```
+ * @module typegpu
  */
-declare function createRuntime(options?: CreateRuntimeOptions | GPUDevice): Promise<TypeGpuRuntime>;
 
-export { AnyWgslData, AnyWgslPrimitive, AnyWgslTexelFormat, type AsCallable, BufferUsage, type ComputePipelineExecutor, type ComputePipelineExecutorOptions, type ComputePipelineOptions, type CreateRuntimeOptions, Eventual, type ICallable, InlineResolve, MissingSlotValueError, type Program, ProgramBuilder, RandomNameRegistry, RecursiveDataTypeError, type RenderPipelineExecutor, type RenderPipelineExecutorOptions, type RenderPipelineOptions, ResolutionCtx, ResolutionError, SampledTextureParams, type SetPlumAction, StorageTextureAccess, StorageTextureParams, StrictNameRegistry, TextureUsage, type TypeGpuRuntime, Wgsl, WgslAllocatable, WgslBindable, type WgslBuffer, type WgslBufferUsage, type WgslCode, type WgslConst, type WgslFn$1 as WgslFn, WgslFnArgument, type WgslFn as WgslFnExperimental, WgslPlum, WgslRenderResource, WgslRenderResourceType, WgslResolvable, WgslResolvableSlot, type WgslSampler, WgslSettable, WgslSlot, type WgslTexture, type WgslTextureView, WgslValue, type WgslVar, createRuntime, deriveVertexFormat, _default as wgsl };
+export { AnyTgpuData, RecursiveDataTypeError, type TgpuBuffer, tgpu as default, std };