tgpu

const tgpu: object

Defined in: packages/typegpu/src/index.ts:22

Type declaration

~unstable

~unstable: object

~unstable.accessor()

accessor: <T>(schema, defaultValue?) => TgpuAccessor<T>

Type Parameters

• T extends AnyWgslData

Parameters

schema

T

defaultValue?

TgpuFn<() => T> | TgpuBufferUsage<T, BindableBufferUsage> | Infer<T>

Returns

TgpuAccessor<T>

~unstable.comparisonSampler()

comparisonSampler: (props) => TgpuFixedComparisonSampler

Parameters

props

ComparisonSamplerProps

Returns

TgpuFixedComparisonSampler

~unstable.computeFn()

computeFn: (options) => TgpuComputeFnShell<{}><ComputeIn>(options) => TgpuComputeFnShell<ComputeIn>

Parameters

options

workgroupSize

number[]

Returns

TgpuComputeFnShell<{}>

Type Parameters

• ComputeIn extends IORecord<AnyComputeBuiltin>

Parameters

options

in

ComputeIn

workgroupSize

number[]

Returns

TgpuComputeFnShell<ComputeIn>

~unstable.const()

const: <TDataType>(dataType, value) => TgpuConst<TDataType> = constant

Creates a module constant with specified value.

Type Parameters

• TDataType extends AnyWgslData

Parameters

dataType

TDataType

value

InferGPU<TDataType>

Returns

TgpuConst<TDataType>

~unstable.declare()

declare: (declaration) => TgpuDeclare

Allows defining extra declarations that shall be included in the final WGSL code, when resolving objects that use them.

Using this API is generally discouraged, as it shouldn’t be necessary in any common scenario. It was developed to ensure full compatibility of TypeGPU programs with current and future versions of WGSL.

Parameters

declaration

string

Returns

TgpuDeclare

~unstable.derived()

derived: <T>(compute) => TgpuDerived<T>

Type Parameters

• T

Parameters

compute

() => T

Returns

TgpuDerived<T>

~unstable.fn()

fn: <Args>(argTypes, returnType?) => TgpuFnShell<Args, Void><Args, Return>(argTypes, returnType) => TgpuFnShell<Args, Return>

Type Parameters

• Args extends [] | AnyData[]

Parameters

argTypes

Args

returnType?

undefined

Returns

TgpuFnShell<Args, Void>

Type Parameters

• Args extends [] | AnyData[]

• Return extends AnyData

Parameters

argTypes

Args

returnType

Return

Returns

TgpuFnShell<Args, Return>

~unstable.fragmentFn()

fragmentFn: <FragmentOut>(options) => TgpuFragmentFnShell<{}, FragmentOut><FragmentIn, FragmentOut>(options) => TgpuFragmentFnShell<FragmentIn, FragmentOut>

Type Parameters

• FragmentOut extends FragmentOutConstrained

Parameters

options

out

FragmentOut

Returns

TgpuFragmentFnShell<{}, FragmentOut>

Type Parameters

• FragmentIn extends FragmentInConstrained

• FragmentOut extends FragmentOutConstrained

Parameters

options

in

FragmentIn

out

FragmentOut

Returns

TgpuFragmentFnShell<FragmentIn, FragmentOut>

~unstable.privateVar()

privateVar: <TDataType>(dataType, initialValue?) => TgpuVar<"private", TDataType>

Defines a variable scoped to each entry function (private).

Type Parameters

• TDataType extends AnyData

Parameters

dataType

TDataType

The schema of the held data’s type

initialValue?

InferGPU<TDataType>

If not provided, the variable will be initialized to the dataType’s “zero-value”.

Returns

TgpuVar<"private", TDataType>

~unstable.sampler()

sampler: (props) => TgpuFixedSampler

Parameters

props

SamplerProps

Returns

TgpuFixedSampler

~unstable.simulate()

simulate: <T>(callback) => SimulationResult<T>

Runs the provided callback in a simulated environment, giving it access to buffers and variables as if it were running on the GPU.

The result of the simulation is returned, and does not affect the actual GPU state, nor does it carry over to other simulations.

Type Parameters

• T

Parameters

callback

() => T

The callback to run in the simulated environment.

Returns

SimulationResult<T>

An object containing the result of the simulation, and the final state of the environment.

Example

const counter = tgpu.privateVar(d.u32);

const result = tgpu.simulate(() => {
 counter.$ += 1;
 counter.$ += 2;
 return counter.$;
});

console.log(result.value); // 3

~unstable.slot()

slot: <T>(defaultValue?) => TgpuSlot<T>

Type Parameters

• T

Parameters

defaultValue?

T

Returns

TgpuSlot<T>

~unstable.vertexFn()

vertexFn: <VertexOut>(options) => TgpuVertexFnShell<{}, VertexOut><VertexIn, VertexOut>(options) => TgpuVertexFnShell<VertexIn, VertexOut>

Type Parameters

• VertexOut extends VertexOutConstrained

Parameters

options

out

VertexOut

Returns

TgpuVertexFnShell<{}, VertexOut>

Type Parameters

• VertexIn extends VertexInConstrained

• VertexOut extends VertexOutConstrained

Parameters

options

in

VertexIn

out

VertexOut

Returns

TgpuVertexFnShell<VertexIn, VertexOut>

~unstable.vertexLayout()

vertexLayout: <TData>(schemaForCount, stepMode) => TgpuVertexLayout<TData>

Type Parameters

• TData extends WgslArray<BaseData> | Disarray<BaseData>

Parameters

schemaForCount

(count) => TData

stepMode

"vertex" | "instance"

Returns

TgpuVertexLayout<TData>

~unstable.workgroupVar()

workgroupVar: <TDataType>(dataType) => TgpuVar<"workgroup", TDataType>

Defines a variable scoped to the whole workgroup, shared between entry functions of the same invocation.

Type Parameters

• TDataType extends AnyData

Parameters

dataType

TDataType

The schema of the held data’s type

Returns

TgpuVar<"workgroup", TDataType>

bindGroupLayout()

bindGroupLayout: <Entries>(entries) => TgpuBindGroupLayout<{ [K in string | number | symbol]: Entries[K] }>

Type Parameters

• Entries extends Record<string, null | TgpuLayoutEntry>

Parameters

entries

Entries

Returns

TgpuBindGroupLayout<{ [K in string | number | symbol]: Entries[K] }>

fn()

fn: <Args>(argTypes, returnType?) => TgpuFnShell<Args, Void><Args, Return>(argTypes, returnType) => TgpuFnShell<Args, Return>

Type Parameters

• Args extends [] | AnyData[]

Parameters

argTypes

Args

returnType?

undefined

Returns

TgpuFnShell<Args, Void>

Type Parameters

• Args extends [] | AnyData[]

• Return extends AnyData

Parameters

argTypes

Args

returnType

Return

Returns

TgpuFnShell<Args, Return>

init()

init: (options?) => Promise<TgpuRoot>

Requests a new GPU device and creates a root around it. If a specific device should be used instead, use

Parameters

options?

InitOptions

Returns

Promise<TgpuRoot>

See

initFromDevice.

Examples

When given no options, the function will ask the browser for a suitable GPU device.

const root = await tgpu.init();

If there are specific options that should be used when requesting a device, you can pass those in.

const adapterOptions: GPURequestAdapterOptions = ...;
const deviceDescriptor: GPUDeviceDescriptor = ...;
const root = await tgpu.init({ adapter: adapterOptions, device: deviceDescriptor });

initFromDevice()

initFromDevice: (options) => TgpuRoot

Creates a root from the given device, instead of requesting it like

Parameters

options

InitFromDeviceOptions

Returns

TgpuRoot

See

init.

Example

const device: GPUDevice = ...;
const root = tgpu.initFromDevice({ device });

resolve()

resolve: (options) => string

Resolves a template with external values. Each external will get resolved to a code string and replaced in the template. Any dependencies of the externals will also be resolved and included in the output.

Parameters

options

TgpuResolveOptions

The options for the resolution.

Returns

string

The resolved code.

Example

const Gradient = d.struct({
  from: d.vec3f,
  to: d.vec3f,
});

const resolved = tgpu.resolve({
  template: `
    fn getGradientAngle(gradient: Gradient) -> f32 {
      return atan(gradient.to.y - gradient.from.y, gradient.to.x - gradient.from.x);
    }
  `,
  externals: {
    Gradient,
  },
});

console.log(resolved);
// struct Gradient_0 {
//   from: vec3f,
//   to: vec3f,
// }
// fn getGradientAngle(gradient: Gradient_0) -> f32 {
//   return atan(gradient.to.y - gradient.from.y, gradient.to.x - gradient.from.x);
// }

resolveWithContext()

resolveWithContext: (options) => ResolutionResult

Parameters

options

TgpuResolveOptions

The options for the resolution.

Returns

ResolutionResult

Example

const Gradient = d.struct({
  from: d.vec3f,
  to: d.vec3f,
});

const { code, usedBindGroupLayouts, catchall } = tgpu.resolveWithContext({
  template: `
    fn getGradientAngle(gradient: Gradient) -> f32 {
      return atan(gradient.to.y - gradient.from.y, gradient.to.x - gradient.from.x);
    }
  `,
  externals: {
    Gradient,
  },
});

console.log(code);
// struct Gradient_0 {
//   from: vec3f,
//   to: vec3f,
// }
// fn getGradientAngle(gradient: Gradient_0) -> f32 {
//   return atan(gradient.to.y - gradient.from.y, gradient.to.x - gradient.from.x);
// }

slot()

slot: <T>(defaultValue?) => TgpuSlot<T>

Type Parameters

• T

Parameters

defaultValue?

T

Returns

TgpuSlot<T>

vertexLayout()

vertexLayout: <TData>(schemaForCount, stepMode) => TgpuVertexLayout<TData>

Type Parameters

• TData extends WgslArray<BaseData> | Disarray<BaseData>

Parameters

schemaForCount

(count) => TData

stepMode

"vertex" | "instance"

Returns

TgpuVertexLayout<TData>