typegpu 0.11.9 → 0.12.1

package/std/subgroup.js

@@ -1,220 +1,183 @@
+import { dualImpl } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.js";
-import { unify } from "../tgsl/conversion.js";
 import { bool, i32, u32 } from "../data/numeric.js";
 import { vec4u } from "../data/vector.js";
-import { dualImpl } from "../core/function/dualImpl.js";
-
-//#region src/std/subgroup.ts
-const errorMessage = "Subgroup operations can only be used in the GPU context.";
-const subgroupAdd = dualImpl({
-	name: "subgroupAdd",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [arg]) => stitch`subgroupAdd(${arg})`
-});
-const subgroupExclusiveAdd = dualImpl({
-	name: "subgroupExclusiveAdd",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [arg]) => stitch`subgroupExclusiveAdd(${arg})`
-});
-const subgroupInclusiveAdd = dualImpl({
-	name: "subgroupInclusiveAdd",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [arg]) => stitch`subgroupInclusiveAdd(${arg})`
-});
-const subgroupAll = dualImpl({
-	name: "subgroupAll",
-	signature: {
-		argTypes: [bool],
-		returnType: bool
-	},
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e]) => stitch`subgroupAll(${e})`
-});
-const subgroupAnd = dualImpl({
-	name: "subgroupAnd",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e]) => stitch`subgroupAnd(${e})`
-});
-const subgroupAny = dualImpl({
-	name: "subgroupAny",
-	signature: {
-		argTypes: [bool],
-		returnType: bool
-	},
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e]) => stitch`subgroupAny(${e})`
-});
-const subgroupBallot = dualImpl({
-	name: "subgroupBallot",
-	signature: {
-		argTypes: [bool],
-		returnType: vec4u
-	},
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e]) => stitch`subgroupBallot(${e})`
-});
-const subgroupBroadcast = dualImpl({
-	name: "subgroupBroadcast",
-	signature: (...args) => {
-		const id = unify([args[1]], [i32, u32]);
-		if (!id) throw new Error(`subgroupBroadcast's second argument has to be compatible with i32 or u32. Got: ${args[1].type}`);
-		return {
-			argTypes: [args[0], id[0]],
-			returnType: args[0]
-		};
-	},
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e, index]) => stitch`subgroupBroadcast(${e}, ${index})`
-});
-const subgroupBroadcastFirst = dualImpl({
-	name: "subgroupBroadcastFirst",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e]) => stitch`subgroupBroadcastFirst(${e})`
-});
-const subgroupElect = dualImpl({
-	name: "subgroupElect",
-	signature: {
-		argTypes: [],
-		returnType: bool
-	},
-	normalImpl: errorMessage,
-	codegenImpl: () => stitch`subgroupElect()`
-});
-const subgroupMax = dualImpl({
-	name: "subgroupMax",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [arg]) => stitch`subgroupMax(${arg})`
-});
-const subgroupMin = dualImpl({
-	name: "subgroupMin",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [arg]) => stitch`subgroupMin(${arg})`
-});
-const subgroupMul = dualImpl({
-	name: "subgroupMul",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [arg]) => stitch`subgroupMul(${arg})`
-});
-const subgroupExclusiveMul = dualImpl({
-	name: "subgroupExclusiveMul",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [arg]) => stitch`subgroupExclusiveMul(${arg})`
-});
-const subgroupInclusiveMul = dualImpl({
-	name: "subgroupInclusiveMul",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [arg]) => stitch`subgroupInclusiveMul(${arg})`
-});
-const subgroupOr = dualImpl({
-	name: "subgroupOr",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e]) => stitch`subgroupOr(${e})`
-});
-const subgroupShuffle = dualImpl({
-	name: "subgroupShuffle",
-	signature: (...args) => {
-		const id = unify([args[1]], [i32, u32]);
-		if (!id) throw new Error(`subgroupShuffle's second argument has to be compatible with i32 or u32. Got: ${args[1].type}`);
-		return {
-			argTypes: [args[0], id[0]],
-			returnType: args[0]
-		};
-	},
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e, index]) => stitch`subgroupShuffle(${e}, ${index})`
-});
-const subgroupShuffleDown = dualImpl({
-	name: "subgroupShuffleDown",
-	signature: (...args) => {
-		const delta = unify([args[1]], [u32]);
-		if (!delta) throw new Error(`subgroupShuffleDown's second argument has to be compatible with u32. Got: ${args[1].type}`);
-		return {
-			argTypes: [args[0], delta[0]],
-			returnType: args[0]
-		};
-	},
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e, delta]) => stitch`subgroupShuffleDown(${e}, ${delta})`
-});
-const subgroupShuffleUp = dualImpl({
-	name: "subgroupShuffleUp",
-	signature: (...args) => {
-		const delta = unify([args[1]], [u32]);
-		if (!delta) throw new Error(`subgroupShuffleUp's second argument has to be compatible with u32. Got: ${args[1].type}`);
-		return {
-			argTypes: [args[0], delta[0]],
-			returnType: args[0]
-		};
-	},
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e, delta]) => stitch`subgroupShuffleUp(${e}, ${delta})`
-});
-const subgroupShuffleXor = dualImpl({
-	name: "subgroupShuffleXor",
-	signature: (...args) => {
-		const mask = unify([args[1]], [u32]);
-		if (!mask) throw new Error(`subgroupShuffleXor's second argument has to be compatible with u32. Got: ${args[1].type}`);
-		return {
-			argTypes: [args[0], mask[0]],
-			returnType: args[0]
-		};
-	},
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e, mask]) => stitch`subgroupShuffleXor(${e}, ${mask})`
-});
-const subgroupXor = dualImpl({
-	name: "subgroupXor",
-	signature: (arg) => ({
-		argTypes: [arg],
-		returnType: arg
-	}),
-	normalImpl: errorMessage,
-	codegenImpl: (_ctx, [e]) => stitch`subgroupXor(${e})`
-});
-
-//#endregion
-export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };
+import { unify } from "../tgsl/conversion.js";
+const errorMessage = 'Subgroup operations can only be used in the GPU context.';
+export const subgroupAdd = dualImpl({
+    name: 'subgroupAdd',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [arg]) => stitch `subgroupAdd(${arg})`,
+    sideEffects: false,
+});
+export const subgroupExclusiveAdd = dualImpl({
+    name: 'subgroupExclusiveAdd',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [arg]) => stitch `subgroupExclusiveAdd(${arg})`,
+    sideEffects: false,
+});
+export const subgroupInclusiveAdd = dualImpl({
+    name: 'subgroupInclusiveAdd',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [arg]) => stitch `subgroupInclusiveAdd(${arg})`,
+    sideEffects: false,
+});
+export const subgroupAll = dualImpl({
+    name: 'subgroupAll',
+    signature: { argTypes: [bool], returnType: bool },
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `subgroupAll(${e})`,
+    sideEffects: false,
+});
+export const subgroupAnd = dualImpl({
+    name: 'subgroupAnd',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `subgroupAnd(${e})`,
+    sideEffects: false,
+});
+export const subgroupAny = dualImpl({
+    name: 'subgroupAny',
+    signature: { argTypes: [bool], returnType: bool },
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `subgroupAny(${e})`,
+    sideEffects: false,
+});
+export const subgroupBallot = dualImpl({
+    name: 'subgroupBallot',
+    signature: { argTypes: [bool], returnType: vec4u },
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `subgroupBallot(${e})`,
+    sideEffects: false,
+});
+export const subgroupBroadcast = dualImpl({
+    name: 'subgroupBroadcast',
+    signature: (...args) => {
+        const id = unify([args[1]], [i32, u32]);
+        if (!id) {
+            throw new Error(`subgroupBroadcast's second argument has to be compatible with i32 or u32. Got: ${args[1].type}`);
+        }
+        return { argTypes: [args[0], id[0]], returnType: args[0] };
+    },
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e, index]) => stitch `subgroupBroadcast(${e}, ${index})`,
+    sideEffects: false,
+});
+export const subgroupBroadcastFirst = dualImpl({
+    name: 'subgroupBroadcastFirst',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `subgroupBroadcastFirst(${e})`,
+    sideEffects: false,
+});
+export const subgroupElect = dualImpl({
+    name: 'subgroupElect',
+    signature: { argTypes: [], returnType: bool },
+    normalImpl: errorMessage,
+    codegenImpl: () => stitch `subgroupElect()`,
+    sideEffects: false,
+});
+export const subgroupMax = dualImpl({
+    name: 'subgroupMax',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [arg]) => stitch `subgroupMax(${arg})`,
+    sideEffects: false,
+});
+export const subgroupMin = dualImpl({
+    name: 'subgroupMin',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [arg]) => stitch `subgroupMin(${arg})`,
+    sideEffects: false,
+});
+export const subgroupMul = dualImpl({
+    name: 'subgroupMul',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [arg]) => stitch `subgroupMul(${arg})`,
+    sideEffects: false,
+});
+export const subgroupExclusiveMul = dualImpl({
+    name: 'subgroupExclusiveMul',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [arg]) => stitch `subgroupExclusiveMul(${arg})`,
+    sideEffects: false,
+});
+export const subgroupInclusiveMul = dualImpl({
+    name: 'subgroupInclusiveMul',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [arg]) => stitch `subgroupInclusiveMul(${arg})`,
+    sideEffects: false,
+});
+export const subgroupOr = dualImpl({
+    name: 'subgroupOr',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `subgroupOr(${e})`,
+    sideEffects: false,
+});
+export const subgroupShuffle = dualImpl({
+    name: 'subgroupShuffle',
+    signature: (...args) => {
+        const id = unify([args[1]], [i32, u32]);
+        if (!id) {
+            throw new Error(`subgroupShuffle's second argument has to be compatible with i32 or u32. Got: ${args[1].type}`);
+        }
+        return { argTypes: [args[0], id[0]], returnType: args[0] };
+    },
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e, index]) => stitch `subgroupShuffle(${e}, ${index})`,
+    sideEffects: false,
+});
+export const subgroupShuffleDown = dualImpl({
+    name: 'subgroupShuffleDown',
+    signature: (...args) => {
+        const delta = unify([args[1]], [u32]);
+        if (!delta) {
+            throw new Error(`subgroupShuffleDown's second argument has to be compatible with u32. Got: ${args[1].type}`);
+        }
+        return { argTypes: [args[0], delta[0]], returnType: args[0] };
+    },
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e, delta]) => stitch `subgroupShuffleDown(${e}, ${delta})`,
+    sideEffects: false,
+});
+export const subgroupShuffleUp = dualImpl({
+    name: 'subgroupShuffleUp',
+    signature: (...args) => {
+        const delta = unify([args[1]], [u32]);
+        if (!delta) {
+            throw new Error(`subgroupShuffleUp's second argument has to be compatible with u32. Got: ${args[1].type}`);
+        }
+        return { argTypes: [args[0], delta[0]], returnType: args[0] };
+    },
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e, delta]) => stitch `subgroupShuffleUp(${e}, ${delta})`,
+    sideEffects: false,
+});
+export const subgroupShuffleXor = dualImpl({
+    name: 'subgroupShuffleXor',
+    signature: (...args) => {
+        const mask = unify([args[1]], [u32]);
+        if (!mask) {
+            throw new Error(`subgroupShuffleXor's second argument has to be compatible with u32. Got: ${args[1].type}`);
+        }
+        return { argTypes: [args[0], mask[0]], returnType: args[0] };
+    },
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e, mask]) => stitch `subgroupShuffleXor(${e}, ${mask})`,
+    sideEffects: false,
+});
+export const subgroupXor = dualImpl({
+    name: 'subgroupXor',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `subgroupXor(${e})`,
+    sideEffects: false,
+});

package/std/texture.d.ts

@@ -1,11 +1,8 @@
-import { $internal, $repr } from "../shared/symbols.js";
-import { comparisonSampler, sampler } from "../data/sampler.js";
-import { DualFn } from "../types.js";
-import { v2f, v2i, v2u, v3f, v3i, v3u, v4f, v4i, v4u } from "../data/wgslTypes.js";
-import { StorageTextureFormats, TextureFormats } from "../core/texture/textureFormats.js";
-import { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d } from "../data/texture.js";
-
-//#region src/std/texture.d.ts
+import { type v2f, type v2i, type v2u, type v3f, type v3i, type v3u, type v4f, type v4i, type v4u } from '../data/wgslTypes.ts';
+import { type StorageTextureFormats, type TextureFormats } from '../core/texture/textureFormats.ts';
+import type { $internal, $repr } from '../shared/symbols.ts';
+import type { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d } from '../data/texture.ts';
+import type { comparisonSampler, sampler } from '../data/sampler.ts';
 declare function sampleCpu<T extends texture1d>(texture: T, sampler: sampler, coords: number): v4f;
 declare function sampleCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, offset?: v2i): v4f;
 declare function sampleCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, offset?: v2i): v4f;
@@ -15,13 +12,13 @@ declare function sampleCpu<T extends textureCubeArray>(texture: T, sampler: samp
 declare function sampleCpu<T extends textureDepth2d>(texture: T, sampler: sampler, coords: v2f, offset?: v2i): number;
 declare function sampleCpu<T extends textureDepth2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, offset?: v2i): number;
 declare function sampleCpu<T extends textureDepthCube>(texture: T, sampler: sampler, coords: v3f, arrayIndex?: number): number;
-declare const textureSample: DualFn<typeof sampleCpu>;
+export declare const textureSample: import("../types.ts").DualFn<typeof sampleCpu>;
 declare function sampleBiasCpu<T extends texture1d>(texture: T, sampler: sampler, coords: number, bias: number): v4f;
 declare function sampleBiasCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, bias: number, offset?: v2i): v4f;
 declare function sampleBiasCpu<T extends texture2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, bias: number, offset?: v2i): v4f;
 declare function sampleBiasCpu<T extends texture3d | textureCube>(texture: T, sampler: sampler, coords: v3f, bias: number, offset?: v3i): v4f;
 declare function sampleBiasCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number, bias: number): v4f;
-declare const textureSampleBias: DualFn<typeof sampleBiasCpu>;
+export declare const textureSampleBias: import("../types.ts").DualFn<typeof sampleBiasCpu>;
 declare function sampleLevelCpu<T extends texture1d>(texture: T, sampler: sampler, coords: number, level: number): v4f;
 declare function sampleLevelCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, level: number): v4f;
 declare function sampleLevelCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, level: number, offset: v2i): v4f;
@@ -36,11 +33,11 @@ declare function sampleLevelCpu<T extends textureDepth2dArray>(texture: T, sampl
 declare function sampleLevelCpu<T extends textureDepth2dArray>(texture: T, sampler: sampler, coords: v2f, arrayIndex: number, level: number, offset: v2i): number;
 declare function sampleLevelCpu<T extends textureDepthCube>(texture: T, sampler: sampler, coords: v3f, level: number): number;
 declare function sampleLevelCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number, level: number): number;
-declare const textureSampleLevel: DualFn<typeof sampleLevelCpu>;
+export declare const textureSampleLevel: import("../types.ts").DualFn<typeof sampleLevelCpu>;
 type PrimitiveToLoadedType = {
-  f32: v4f;
-  i32: v4i;
-  u32: v4u;
+    f32: v4f;
+    i32: v4i;
+    u32: v4u;
 };
 type TexelFormatToInstanceType<T extends StorageTextureFormats> = TextureFormats[T]['vectorType'][typeof $repr];
 declare function textureLoadCpu<T extends texture1d>(texture: T, coords: number, level: number): PrimitiveToLoadedType[T[typeof $internal]['type']];
@@ -56,52 +53,88 @@ declare function textureLoadCpu<T extends textureStorage1d>(texture: T, coords:
 declare function textureLoadCpu<T extends textureStorage2d>(texture: T, coords: v2i | v2u): TexelFormatToInstanceType<T[typeof $internal][0]>;
 declare function textureLoadCpu<T extends textureStorage2dArray>(texture: T, coords: v2i | v2u, arrayIndex: number): TexelFormatToInstanceType<T[typeof $internal][0]>;
 declare function textureLoadCpu<T extends textureStorage3d>(texture: T, coords: v3i | v3u): TexelFormatToInstanceType<T[typeof $internal][0]>;
-declare const textureLoad: DualFn<typeof textureLoadCpu>;
+export declare const textureLoad: import("../types.ts").DualFn<typeof textureLoadCpu>;
 declare function textureStoreCpu<T extends textureStorage1d>(texture: T, coords: number, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
 declare function textureStoreCpu<T extends textureStorage2d>(texture: T, coords: v2i | v2u, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
 declare function textureStoreCpu<T extends textureStorage2dArray>(texture: T, coords: v2i | v2u, arrayIndex: number, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
 declare function textureStoreCpu<T extends textureStorage3d>(texture: T, coords: v3i | v3u, value: TexelFormatToInstanceType<T[typeof $internal][0]>): void;
-declare const textureStore: DualFn<typeof textureStoreCpu>;
+export declare const textureStore: import("../types.ts").DualFn<typeof textureStoreCpu>;
 declare function textureDimensionsCpu<T extends texture1d | textureStorage1d>(texture: T): number;
 declare function textureDimensionsCpu<T extends texture1d>(texture: T, level: number): number;
 declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray | textureStorage2d | textureStorage2dArray | textureExternal>(texture: T): v2u;
 declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray>(texture: T, level: number): v2u;
 declare function textureDimensionsCpu<T extends texture3d | textureStorage3d>(texture: T): v3u;
 declare function textureDimensionsCpu<T extends texture3d>(texture: T, level: number): v3u;
-declare const textureDimensions: DualFn<typeof textureDimensionsCpu>;
-type Gather2dArgs<T extends texture2d = texture2d> = [component: number, texture: T, sampler: sampler, coords: v2f, offset?: v2i];
-type Gather2dArrayArgs<T extends texture2dArray = texture2dArray> = [component: number, texture: T, sampler: sampler, coords: v2f, arrayIndex: number, offset?: v2i];
-type GatherCubeArgs<T extends textureCube = textureCube> = [component: number, texture: T, sampler: sampler, coords: v3f];
-type GatherCubeArrayArgs<T extends textureCubeArray = textureCubeArray> = [component: number, texture: T, sampler: sampler, coords: v3f, arrayIndex: number];
+export declare const textureDimensions: import("../types.ts").DualFn<typeof textureDimensionsCpu>;
+type Gather2dArgs<T extends texture2d = texture2d> = [
+    component: number,
+    texture: T,
+    sampler: sampler,
+    coords: v2f,
+    offset?: v2i
+];
+type Gather2dArrayArgs<T extends texture2dArray = texture2dArray> = [
+    component: number,
+    texture: T,
+    sampler: sampler,
+    coords: v2f,
+    arrayIndex: number,
+    offset?: v2i
+];
+type GatherCubeArgs<T extends textureCube = textureCube> = [
+    component: number,
+    texture: T,
+    sampler: sampler,
+    coords: v3f
+];
+type GatherCubeArrayArgs<T extends textureCubeArray = textureCubeArray> = [
+    component: number,
+    texture: T,
+    sampler: sampler,
+    coords: v3f,
+    arrayIndex: number
+];
 type GatherDepth2dArgs = [texture: textureDepth2d, sampler: sampler, coords: v2f, offset?: v2i];
-type GatherDepth2dArrayArgs = [texture: textureDepth2dArray, sampler: sampler, coords: v2f, arrayIndex: number, offset?: v2i];
+type GatherDepth2dArrayArgs = [
+    texture: textureDepth2dArray,
+    sampler: sampler,
+    coords: v2f,
+    arrayIndex: number,
+    offset?: v2i
+];
 type GatherDepthCubeArgs = [texture: textureDepthCube, sampler: sampler, coords: v3f];
-type GatherDepthCubeArrayArgs = [texture: textureDepthCubeArray, sampler: sampler, coords: v3f, arrayIndex: number];
+type GatherDepthCubeArrayArgs = [
+    texture: textureDepthCubeArray,
+    sampler: sampler,
+    coords: v3f,
+    arrayIndex: number
+];
 type TextureGatherCpuFn = {
-  <T extends texture2d>(...args: Gather2dArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
-  <T extends texture2dArray>(...args: Gather2dArrayArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
-  <T extends textureCube>(...args: GatherCubeArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
-  <T extends textureCubeArray>(...args: GatherCubeArrayArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
-  (...args: GatherDepth2dArgs): v4f;
-  (...args: GatherDepth2dArrayArgs): v4f;
-  (...args: GatherDepthCubeArgs): v4f;
-  (...args: GatherDepthCubeArrayArgs): v4f;
+    <T extends texture2d>(...args: Gather2dArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
+    <T extends texture2dArray>(...args: Gather2dArrayArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
+    <T extends textureCube>(...args: GatherCubeArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
+    <T extends textureCubeArray>(...args: GatherCubeArrayArgs<T>): PrimitiveToLoadedType[T[typeof $internal]['type']];
+    (...args: GatherDepth2dArgs): v4f;
+    (...args: GatherDepth2dArrayArgs): v4f;
+    (...args: GatherDepthCubeArgs): v4f;
+    (...args: GatherDepthCubeArrayArgs): v4f;
 };
-declare const textureGather: DualFn<TextureGatherCpuFn>;
+export declare const textureGatherCpu: TextureGatherCpuFn;
+export declare const textureGather: import("../types.ts").DualFn<TextureGatherCpuFn>;
 declare function textureSampleCompareCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number): number;
 declare function textureSampleCompareCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number, offset: v2i): number;
 declare function textureSampleCompareCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number): number;
 declare function textureSampleCompareCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number, offset: v2i): number;
 declare function textureSampleCompareCpu<T extends textureDepthCube>(texture: T, sampler: comparisonSampler, coords: v3f, depthRef: number): number;
 declare function textureSampleCompareCpu<T extends textureDepthCubeArray>(texture: T, sampler: comparisonSampler, coords: v3f, arrayIndex: number, depthRef: number): number;
-declare const textureSampleCompare: DualFn<typeof textureSampleCompareCpu>;
+export declare const textureSampleCompare: import("../types.ts").DualFn<typeof textureSampleCompareCpu>;
 declare function textureSampleCompareLevelCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number): number;
 declare function textureSampleCompareLevelCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number, offset: v2i): number;
 declare function textureSampleCompareLevelCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number): number;
 declare function textureSampleCompareLevelCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number, offset: v2i): number;
 declare function textureSampleCompareLevelCpu<T extends textureDepthCube>(texture: T, sampler: comparisonSampler, coords: v3f, depthRef: number): number;
 declare function textureSampleCompareLevelCpu<T extends textureDepthCubeArray>(texture: T, sampler: comparisonSampler, coords: v3f, arrayIndex: number, depthRef: number): number;
-declare const textureSampleCompareLevel: DualFn<typeof textureSampleCompareLevelCpu>;
+export declare const textureSampleCompareLevel: import("../types.ts").DualFn<typeof textureSampleCompareLevelCpu>;
 declare function textureSampleBaseClampToEdgeCpu<T extends texture2d | textureExternal>(_texture: T, _sampler: sampler, _coords: v2f): v4f;
 declare function sampleGradCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, ddx: v2f, ddy: v2f): v4f;
 declare function sampleGradCpu<T extends texture2d>(texture: T, sampler: sampler, coords: v2f, ddx: v2f, ddy: v2f, offset: v2i): v4f;
@@ -111,7 +144,6 @@ declare function sampleGradCpu<T extends texture3d>(texture: T, sampler: sampler
 declare function sampleGradCpu<T extends texture3d>(texture: T, sampler: sampler, coords: v3f, ddx: v3f, ddy: v3f, offset: v3i): v4f;
 declare function sampleGradCpu<T extends textureCube>(texture: T, sampler: sampler, coords: v3f, ddx: v3f, ddy: v3f): v4f;
 declare function sampleGradCpu<T extends textureCubeArray>(texture: T, sampler: sampler, coords: v3f, arrayIndex: number, ddx: v3f, ddy: v3f): v4f;
-declare const textureSampleGrad: DualFn<typeof sampleGradCpu>;
-declare const textureSampleBaseClampToEdge: DualFn<typeof textureSampleBaseClampToEdgeCpu>;
-//#endregion
-export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore };
+export declare const textureSampleGrad: import("../types.ts").DualFn<typeof sampleGradCpu>;
+export declare const textureSampleBaseClampToEdge: import("../types.ts").DualFn<typeof textureSampleBaseClampToEdgeCpu>;
+export {};