typegpu 0.12.4 → 0.12.6

package/std/packing.js

@@ -2,8 +2,25 @@ import * as TB from 'typed-binary';
 import { dualImpl } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { u32 } from "../data/numeric.js";
-import { vec2f, vec4f } from "../data/vector.js";
+import { clampScalar } from "../data/numberOps.js";
+import { vec2f, vec4f, vec4i, vec4u } from "../data/vector.js";
 import { readFloat16, writeFloat16 } from "../data/float16Conversion.js";
+const littleEndian = { endianness: 'little' };
+const packedBuffer = new ArrayBuffer(4);
+const packedWriter = new TB.BufferWriter(packedBuffer, littleEndian);
+const packedReader = new TB.BufferReader(packedBuffer, littleEndian);
+function readPacked(value) {
+    packedWriter.seekTo(0);
+    packedWriter.writeUint32(value);
+    packedReader.seekTo(0);
+    return packedReader;
+}
+function writePacked(write) {
+    packedWriter.seekTo(0);
+    write(packedWriter);
+    packedReader.seekTo(0);
+    return u32(packedReader.readUint32());
+}
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
@@ -11,10 +28,7 @@ import { readFloat16, writeFloat16 } from "../data/float16Conversion.js";
 export const unpack2x16float = dualImpl({
     name: 'unpack2x16float',
     normalImpl: (e) => {
-        const buffer = new ArrayBuffer(4);
-        const writer = new TB.BufferWriter(buffer);
-        writer.writeUint32(e);
-        const reader = new TB.BufferReader(buffer);
+        const reader = readPacked(e);
         return vec2f(readFloat16(reader), readFloat16(reader));
     },
     signature: { argTypes: [u32], returnType: vec2f },
@@ -27,18 +41,50 @@ export const unpack2x16float = dualImpl({
  */
 export const pack2x16float = dualImpl({
     name: 'pack2x16float',
-    normalImpl: (e) => {
-        const buffer = new ArrayBuffer(4);
-        const writer = new TB.BufferWriter(buffer);
+    normalImpl: (e) => writePacked((writer) => {
         writeFloat16(writer, e.x);
         writeFloat16(writer, e.y);
-        const reader = new TB.BufferReader(buffer);
-        return u32(reader.readUint32());
-    },
+    }),
     signature: { argTypes: [vec2f], returnType: u32 },
     codegenImpl: (_ctx, [e]) => stitch `pack2x16float(${e})`,
     sideEffects: false,
 });
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack2x16snorm-builtin
+ */
+export const pack2x16snorm = dualImpl({
+    name: 'pack2x16snorm',
+    normalImpl: (e) => {
+        const x = Math.floor(0.5 + 32767 * clampScalar(e.x, -1, 1));
+        const y = Math.floor(0.5 + 32767 * clampScalar(e.y, -1, 1));
+        return writePacked((writer) => {
+            writer.writeInt16(x);
+            writer.writeInt16(y);
+        });
+    },
+    signature: { argTypes: [vec2f], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack2x16snorm(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack2x16unorm-builtin
+ */
+export const pack2x16unorm = dualImpl({
+    name: 'pack2x16unorm',
+    normalImpl: (e) => {
+        const x = Math.floor(0.5 + 65535 * clampScalar(e.x, 0, 1));
+        const y = Math.floor(0.5 + 65535 * clampScalar(e.y, 0, 1));
+        return writePacked((writer) => {
+            writer.writeUint16(x);
+            writer.writeUint16(y);
+        });
+    },
+    signature: { argTypes: [vec2f], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack2x16unorm(${e})`,
+    sideEffects: false,
+});
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
@@ -46,33 +92,176 @@ export const pack2x16float = dualImpl({
 export const unpack4x8unorm = dualImpl({
     name: 'unpack4x8unorm',
     normalImpl: (e) => {
-        const buffer = new ArrayBuffer(4);
-        const writer = new TB.BufferWriter(buffer);
-        writer.writeUint32(e);
-        const reader = new TB.BufferReader(buffer);
+        const reader = readPacked(e);
         return vec4f(reader.readUint8() / 255, reader.readUint8() / 255, reader.readUint8() / 255, reader.readUint8() / 255);
     },
     signature: { argTypes: [u32], returnType: vec4f },
     codegenImpl: (_ctx, [e]) => stitch `unpack4x8unorm(${e})`,
     sideEffects: false,
 });
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4x8snorm-builtin
+ */
+export const unpack4x8snorm = dualImpl({
+    name: 'unpack4x8snorm',
+    normalImpl: (e) => {
+        const reader = readPacked(e);
+        return vec4f(Math.max(reader.readInt8() / 127, -1), Math.max(reader.readInt8() / 127, -1), Math.max(reader.readInt8() / 127, -1), Math.max(reader.readInt8() / 127, -1));
+    },
+    signature: { argTypes: [u32], returnType: vec4f },
+    codegenImpl: (_ctx, [e]) => stitch `unpack4x8snorm(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4xi8-builtin
+ */
+export const unpack4xI8 = dualImpl({
+    name: 'unpack4xI8',
+    normalImpl: (e) => {
+        const reader = readPacked(e);
+        return vec4i(reader.readInt8(), reader.readInt8(), reader.readInt8(), reader.readInt8());
+    },
+    signature: { argTypes: [u32], returnType: vec4i },
+    codegenImpl: (_ctx, [e]) => stitch `unpack4xI8(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4xu8-builtin
+ */
+export const unpack4xU8 = dualImpl({
+    name: 'unpack4xU8',
+    normalImpl: (e) => {
+        const reader = readPacked(e);
+        return vec4u(reader.readUint8(), reader.readUint8(), reader.readUint8(), reader.readUint8());
+    },
+    signature: { argTypes: [u32], returnType: vec4u },
+    codegenImpl: (_ctx, [e]) => stitch `unpack4xU8(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack2x16snorm-builtin
+ */
+export const unpack2x16snorm = dualImpl({
+    name: 'unpack2x16snorm',
+    normalImpl: (e) => {
+        const reader = readPacked(e);
+        return vec2f(Math.max(reader.readInt16() / 32767, -1), Math.max(reader.readInt16() / 32767, -1));
+    },
+    signature: { argTypes: [u32], returnType: vec2f },
+    codegenImpl: (_ctx, [e]) => stitch `unpack2x16snorm(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack2x16unorm-builtin
+ */
+export const unpack2x16unorm = dualImpl({
+    name: 'unpack2x16unorm',
+    normalImpl: (e) => {
+        const reader = readPacked(e);
+        return vec2f(reader.readUint16() / 65535, reader.readUint16() / 65535);
+    },
+    signature: { argTypes: [u32], returnType: vec2f },
+    codegenImpl: (_ctx, [e]) => stitch `unpack2x16unorm(${e})`,
+    sideEffects: false,
+});
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
  */
 export const pack4x8unorm = dualImpl({
     name: 'pack4x8unorm',
-    normalImpl: (e) => {
-        const buffer = new ArrayBuffer(4);
-        const writer = new TB.BufferWriter(buffer);
-        writer.writeUint8(e.x * 255);
-        writer.writeUint8(e.y * 255);
-        writer.writeUint8(e.z * 255);
-        writer.writeUint8(e.w * 255);
-        const reader = new TB.BufferReader(buffer);
-        return u32(reader.readUint32());
-    },
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeUint8(Math.floor(0.5 + 255 * clampScalar(e.x, 0, 1)));
+        writer.writeUint8(Math.floor(0.5 + 255 * clampScalar(e.y, 0, 1)));
+        writer.writeUint8(Math.floor(0.5 + 255 * clampScalar(e.z, 0, 1)));
+        writer.writeUint8(Math.floor(0.5 + 255 * clampScalar(e.w, 0, 1)));
+    }),
     signature: { argTypes: [vec4f], returnType: u32 },
     codegenImpl: (_ctx, [e]) => stitch `pack4x8unorm(${e})`,
     sideEffects: false,
 });
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4x8snorm-builtin
+ */
+export const pack4x8snorm = dualImpl({
+    name: 'pack4x8snorm',
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeInt8(Math.floor(0.5 + 127 * clampScalar(e.x, -1, 1)));
+        writer.writeInt8(Math.floor(0.5 + 127 * clampScalar(e.y, -1, 1)));
+        writer.writeInt8(Math.floor(0.5 + 127 * clampScalar(e.z, -1, 1)));
+        writer.writeInt8(Math.floor(0.5 + 127 * clampScalar(e.w, -1, 1)));
+    }),
+    signature: { argTypes: [vec4f], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4x8snorm(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xi8-builtin
+ */
+export const pack4xI8 = dualImpl({
+    name: 'pack4xI8',
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeInt8(e.x);
+        writer.writeInt8(e.y);
+        writer.writeInt8(e.z);
+        writer.writeInt8(e.w);
+    }),
+    signature: { argTypes: [vec4i], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4xI8(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xu8-builtin
+ */
+export const pack4xU8 = dualImpl({
+    name: 'pack4xU8',
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeUint8(e.x);
+        writer.writeUint8(e.y);
+        writer.writeUint8(e.z);
+        writer.writeUint8(e.w);
+    }),
+    signature: { argTypes: [vec4u], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4xU8(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xi8clamp-builtin
+ */
+export const pack4xI8Clamp = dualImpl({
+    name: 'pack4xI8Clamp',
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeInt8(clampScalar(e.x, -128, 127));
+        writer.writeInt8(clampScalar(e.y, -128, 127));
+        writer.writeInt8(clampScalar(e.z, -128, 127));
+        writer.writeInt8(clampScalar(e.w, -128, 127));
+    }),
+    signature: { argTypes: [vec4i], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4xI8Clamp(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xu8clamp-builtin
+ */
+export const pack4xU8Clamp = dualImpl({
+    name: 'pack4xU8Clamp',
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeUint8(clampScalar(e.x, 0, 255));
+        writer.writeUint8(clampScalar(e.y, 0, 255));
+        writer.writeUint8(clampScalar(e.z, 0, 255));
+        writer.writeUint8(clampScalar(e.w, 0, 255));
+    }),
+    signature: { argTypes: [vec4u], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4xU8Clamp(${e})`,
+    sideEffects: false,
+});

package/std/subgroup.d.ts

@@ -40,4 +40,8 @@ export declare const subgroupShuffleDown: import("../types.ts").DualFn<IdentityN
 export declare const subgroupShuffleUp: import("../types.ts").DualFn<IdentityNumOrVecWithDelta>;
 export declare const subgroupShuffleXor: import("../types.ts").DualFn<IdentityNumOrVecWithMask>;
 export declare const subgroupXor: import("../types.ts").DualFn<IdentityIntNumOrVec>;
+export declare const quadBroadcast: import("../types.ts").DualFn<IdentityNumOrVecWithIdx>;
+export declare const quadSwapDiagonal: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const quadSwapX: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const quadSwapY: import("../types.ts").DualFn<IdentityNumOrVec>;
 export {};

package/std/subgroup.js

@@ -181,3 +181,37 @@ export const subgroupXor = dualImpl({
     codegenImpl: (_ctx, [e]) => stitch `subgroupXor(${e})`,
     sideEffects: false,
 });
+export const quadBroadcast = dualImpl({
+    name: 'quadBroadcast',
+    signature: (...args) => {
+        const id = unify([args[1]], [i32, u32]);
+        if (!id) {
+            throw new Error(`quadBroadcast'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, id]) => stitch `quadBroadcast(${e}, ${id})`,
+    sideEffects: false,
+});
+export const quadSwapDiagonal = dualImpl({
+    name: 'quadSwapDiagonal',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `quadSwapDiagonal(${e})`,
+    sideEffects: false,
+});
+export const quadSwapX = dualImpl({
+    name: 'quadSwapX',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `quadSwapX(${e})`,
+    sideEffects: false,
+});
+export const quadSwapY = dualImpl({
+    name: 'quadSwapY',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `quadSwapY(${e})`,
+    sideEffects: false,
+});

package/std/texture.d.ts

@@ -66,6 +66,14 @@ declare function textureDimensionsCpu<T extends texture2d | texture2dArray | tex
 declare function textureDimensionsCpu<T extends texture3d | textureStorage3d>(texture: T): v3u;
 declare function textureDimensionsCpu<T extends texture3d>(texture: T, level: number): v3u;
 export declare const textureDimensions: import("../types.ts").DualFn<typeof textureDimensionsCpu>;
+type ArrayTexture = texture2dArray | textureCubeArray | textureDepth2dArray | textureDepthCubeArray | textureStorage2dArray;
+declare function textureNumLayersCpu<T extends ArrayTexture>(_texture: T): number;
+export declare const textureNumLayers: import("../types.ts").DualFn<typeof textureNumLayersCpu>;
+type MipmappedTexture = texture1d | texture2d | texture2dArray | texture3d | textureCube | textureCubeArray | textureDepth2d | textureDepth2dArray | textureDepthCube | textureDepthCubeArray;
+declare function textureNumLevelsCpu<T extends MipmappedTexture>(_texture: T): number;
+export declare const textureNumLevels: import("../types.ts").DualFn<typeof textureNumLevelsCpu>;
+declare function textureNumSamplesCpu<T extends textureMultisampled2d | textureDepthMultisampled2d>(_texture: T): number;
+export declare const textureNumSamples: import("../types.ts").DualFn<typeof textureNumSamplesCpu>;
 type Gather2dArgs<T extends texture2d = texture2d> = [
     component: number,
     texture: T,
@@ -121,6 +129,11 @@ type TextureGatherCpuFn = {
 };
 export declare const textureGatherCpu: TextureGatherCpuFn;
 export declare const textureGather: import("../types.ts").DualFn<TextureGatherCpuFn>;
+declare function textureGatherCompareCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number, offset?: v2i): v4f;
+declare function textureGatherCompareCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number, offset?: v2i): v4f;
+declare function textureGatherCompareCpu<T extends textureDepthCube>(texture: T, sampler: comparisonSampler, coords: v3f, depthRef: number): v4f;
+declare function textureGatherCompareCpu<T extends textureDepthCubeArray>(texture: T, sampler: comparisonSampler, coords: v3f, arrayIndex: number, depthRef: number): v4f;
+export declare const textureGatherCompare: import("../types.ts").DualFn<typeof textureGatherCompareCpu>;
 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;

package/std/texture.js

@@ -129,6 +129,36 @@ export const textureDimensions = dualImpl({
     },
     sideEffects: false,
 });
+function textureNumLayersCpu(_texture) {
+    throw new MissingCpuImplError('`textureNumLayers` relies on GPU resources and cannot be executed outside of a draw call');
+}
+export const textureNumLayers = dualImpl({
+    name: 'textureNumLayers',
+    normalImpl: textureNumLayersCpu,
+    codegenImpl: (_ctx, [texture]) => stitch `textureNumLayers(${texture})`,
+    signature: (texture) => ({ argTypes: [texture], returnType: u32 }),
+    sideEffects: false,
+});
+function textureNumLevelsCpu(_texture) {
+    throw new MissingCpuImplError('`textureNumLevels` relies on GPU resources and cannot be executed outside of a draw call');
+}
+export const textureNumLevels = dualImpl({
+    name: 'textureNumLevels',
+    normalImpl: textureNumLevelsCpu,
+    codegenImpl: (_ctx, [texture]) => stitch `textureNumLevels(${texture})`,
+    signature: (texture) => ({ argTypes: [texture], returnType: u32 }),
+    sideEffects: false,
+});
+function textureNumSamplesCpu(_texture) {
+    throw new MissingCpuImplError('`textureNumSamples` relies on GPU resources and cannot be executed outside of a draw call');
+}
+export const textureNumSamples = dualImpl({
+    name: 'textureNumSamples',
+    normalImpl: textureNumSamplesCpu,
+    codegenImpl: (_ctx, [texture]) => stitch `textureNumSamples(${texture})`,
+    signature: (texture) => ({ argTypes: [texture], returnType: u32 }),
+    sideEffects: false,
+});
 export const textureGatherCpu = (..._args) => {
     throw new Error('Texture gather relies on GPU resources and cannot be executed outside of a draw call');
 };
@@ -162,6 +192,24 @@ export const textureGather = dualImpl({
     },
     sideEffects: false,
 });
+function textureGatherCompareCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
+    throw new MissingCpuImplError('`textureGatherCompare` relies on GPU resources and cannot be executed outside of a draw call');
+}
+export const textureGatherCompare = dualImpl({
+    name: 'textureGatherCompare',
+    normalImpl: textureGatherCompareCpu,
+    codegenImpl: (_ctx, args) => stitch `textureGatherCompare(${args})`,
+    signature: (...args) => {
+        const texture = args[0];
+        const isArrayTexture = texture.type === 'texture_depth_2d_array' || texture.type === 'texture_depth_cube_array';
+        const [tex, sampler, coords, _arrayIndex, ...rest] = args;
+        return {
+            argTypes: isArrayTexture ? [tex, sampler, coords, [u32, i32], ...rest] : args,
+            returnType: vec4f,
+        };
+    },
+    sideEffects: false,
+});
 function textureSampleCompareCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
     throw new MissingCpuImplError('Texture comparison sampling relies on GPU resources and cannot be executed outside of a draw call');
 }

package/tgpuUnstable.d.ts

@@ -1,4 +1,5 @@
 export { declare } from './core/declare/tgpuDeclare.ts';
+export { immediateVar } from './core/immediate/immediateVar.ts';
 export { rawCodeSnippet } from './core/rawCodeSnippet/tgpuRawCodeSnippet.ts';
 export { namespace } from './core/resolve/namespace.ts';
 export { simulate } from './core/simulate/tgpuSimulate.ts';

package/tgpuUnstable.js

@@ -1,5 +1,6 @@
 // NOTE: This is a barrel file, internal files should not import things from this file
 export { declare } from "./core/declare/tgpuDeclare.js";
+export { immediateVar } from "./core/immediate/immediateVar.js";
 export { rawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
 export { namespace } from "./core/resolve/namespace.js";
 export { simulate } from "./core/simulate/tgpuSimulate.js";

package/tgsl/conversion.d.ts

@@ -16,6 +16,7 @@ export type ConversionResult = {
 export declare function getBestConversion(types: BaseData[], targetTypes?: BaseData[]): ConversionResult | undefined;
 /**
  * Unifies input types to a common type.
+ * Ties between equally good `restrictTo` candidates go to the one listed first.
  */
 export declare function unify<T extends (BaseData | UnknownData)[] | []>(inTypes: T, restrictTo?: BaseData[]): {
     [K in keyof T]: BaseData;
@@ -23,6 +24,7 @@ export declare function unify<T extends (BaseData | UnknownData)[] | []>(inTypes
 /**
  * Unifies input types to a common type.
  * Unlike `unify`, it does not allow implicit conversions.
+ * Ties between equally good `restrictTo` candidates go to the one listed first.
  */
 export declare function unifyStrict<T extends (BaseData | UnknownData)[] | []>(inTypes: T, restrictTo?: BaseData[]): {
     [K in keyof T]: BaseData;

package/tgsl/conversion.js

@@ -131,6 +131,7 @@ function findBestType(types, uniqueTypes, allowImplicit) {
                 destType = conversion.targetType;
             }
         }
+        // Ties keep the earlier candidate, so callers order their target types by preference.
         if (sum < (bestResult?.sum ?? Number.POSITIVE_INFINITY)) {
             bestResult = { type: destType, details, sum };
         }
@@ -209,6 +210,7 @@ function applyActionToSnippet(ctx, snippet, action, targetType) {
 }
 /**
  * Unifies input types to a common type.
+ * Ties between equally good `restrictTo` candidates go to the one listed first.
  */
 export function unify(inTypes, restrictTo) {
     if (inTypes.some((type) => type === UnknownData)) {
@@ -223,6 +225,7 @@ export function unify(inTypes, restrictTo) {
 /**
  * Unifies input types to a common type.
  * Unlike `unify`, it does not allow implicit conversions.
+ * Ties between equally good `restrictTo` candidates go to the one listed first.
  */
 export function unifyStrict(inTypes, restrictTo) {
     if (inTypes.some((type) => type === UnknownData)) {

package/tgsl/shaderGenerator.d.ts

@@ -17,7 +17,7 @@ export interface ConstantDefinitionOptions {
     readonly init: Snippet;
 }
 export interface VariableDefinitionOptions {
-    readonly scope: VariableScope | BindableBufferUsage | 'handle';
+    readonly scope: VariableScope | BindableBufferUsage | 'handle' | 'immediate';
     readonly id: string;
     readonly dataType: BaseData;
     readonly init: Snippet | undefined;

package/tgsl/wgslGenerator.d.ts

@@ -19,6 +19,7 @@ export declare class WgslGenerator implements ShaderGenerator {
      */
     protected _emitVarDecl(keyword: 'var' | 'let' | 'const' | `#VAR_${number}#`, name: string, _dataType: wgsl.BaseData, rhsStr: string): string;
     protected _identifier(id: string): Snippet;
+    protected _emitSwitchStatement(discriminantExpr: Snippet, groupedCaseExprs: [tests: Snippet[], consequent: ResolvedStatement[]][]): string;
     protected _callShellless(callee: AnyFn, args: readonly Snippet[]): ResolvedSnippet | undefined;
     /**
      * A wrapper for `generateExpression` that updates `ctx.expectedType`
@@ -51,6 +52,10 @@ export declare class WgslGenerator implements ShaderGenerator {
      */
     protected _aliasConstStatement(rawId: string, eqNode: tinyest.Expression, eq: Snippet): ResolvedStatement;
     protected _statement(statement: tinyest.Statement): ResolvedStatement;
+    /**
+     * Resolves the key of an object property. Handles both computed and non-computed keys.
+     */
+    protected _resolveObjectPropertyKey(property: tinyest.ObjectProperty): string;
     /**
      * Attempts a member access lookup to mark a variable as modified.
      * @example