typegpu 0.12.6 → 0.12.8

package/core/valueProxyUtils.js

@@ -1,8 +1,8 @@
 import { getGPUValue } from "../getGPUValue.js";
-import { $internal, $ownSnippet, $resolve } from "../shared/symbols.js";
+import { $comptimeValueOf, $internal, $ownSnippet, $resolve } from "../shared/symbols.js";
 import { accessIndex } from "../tgsl/accessIndex.js";
 import { accessProp } from "../tgsl/accessProp.js";
-import { getOwnSnippet } from "../types.js";
+import { getOwnSnippet, runtimeOnly, } from "../types.js";
 export const valueProxyHandler = {
     get(target, prop) {
         if (prop in target) {
@@ -26,6 +26,7 @@ export const valueProxyHandler = {
                 [$internal]: true,
                 [$resolve]: (ctx) => ctx.resolveSnippet(accessed),
                 [$ownSnippet]: accessed,
+                [$comptimeValueOf]: runtimeOnly,
                 toString: () => `${String(target)}[${prop}]`,
             }, valueProxyHandler);
         }
@@ -38,6 +39,7 @@ export const valueProxyHandler = {
             [$internal]: true,
             [$resolve]: (ctx) => ctx.resolveSnippet(accessed),
             [$ownSnippet]: accessed,
+            [$comptimeValueOf]: runtimeOnly,
             toString: () => `${String(target)}.${prop}`,
         }, valueProxyHandler);
     },

package/data/autoStruct.d.ts

@@ -12,7 +12,7 @@ export declare class AutoStruct implements BaseData, SelfResolvable {
     [$internal]: Record<string, never>;
     type: 'auto-struct';
     readonly [$repr]: Record<string, unknown>;
-    constructor(validProps: Record<string, BaseData>, typeForExtraProps: BaseData | undefined, locations?: Record<string, number>);
+    constructor(validProps: Record<string, BaseData>, typeForExtraProps: BaseData | undefined, locations?: Record<string, number>, autoInterpolateIntegers?: boolean);
     /**
      * Used for accessing builtins, varying and attributes in code.
      */

package/data/autoStruct.js

@@ -22,11 +22,17 @@ export class AutoStruct {
     #locations;
     #cachedStruct;
     #typeForExtraProps;
-    constructor(validProps, typeForExtraProps, locations) {
+    #autoInterpolateIntegers;
+    static {
+        AutoStruct.prototype[$internal] = {};
+        AutoStruct.prototype.type = 'auto-struct';
+    }
+    constructor(validProps, typeForExtraProps, locations, autoInterpolateIntegers = false) {
         this.#validProps = validProps;
         this.#typeForExtraProps = typeForExtraProps;
         this.#allocated = {};
         this.#locations = locations;
+        this.#autoInterpolateIntegers = autoInterpolateIntegers;
         this.#usedWgslKeys = new Set();
     }
     /**
@@ -67,7 +73,7 @@ export class AutoStruct {
         if (!this.#cachedStruct) {
             this.#cachedStruct = createIoSchema(Object.fromEntries(Object.values(this.#allocated).map((alloc) => {
                 return [alloc.prop, alloc.type];
-            })), this.#locations);
+            })), this.#locations, this.#autoInterpolateIntegers);
             const ownName = getName(this);
             // Passing the given name forward
             if (ownName) {
@@ -83,5 +89,3 @@ export class AutoStruct {
         return `auto-struct:${getName(this) ?? '<unnamed>'}`;
     }
 }
-AutoStruct.prototype[$internal] = {};
-AutoStruct.prototype.type = 'auto-struct';

package/data/compiledIO.js

@@ -1,7 +1,7 @@
 import { roundUp } from "../mathUtils.js";
 import { logger } from "../tgpuLogger.js";
 import { alignmentOf } from "./alignmentOf.js";
-import { isDisarray, isUnstruct } from "./dataTypes.js";
+import { isDisarray, isLooseDecorated, isUnstruct } from "./dataTypes.js";
 import { offsetsForProps } from "./offsets.js";
 import { sizeOf } from "./sizeOf.js";
 import { formatToWGSLType, isPackedData } from "./vertexFormatData.js";
@@ -131,7 +131,7 @@ export function buildWriter(node, offsetExpr, valueExpr, depth = 0, partial = fa
     const emitBlock = (addr, block) => partial ? `if (${addr} < endOffset) {\n${block}}\n` : block;
     function go(node, offsetExpr, valueExpr, depth) {
         const loopVar = ['i', 'j', 'k'][depth] || `i${depth}`;
-        if (wgsl.isAtomic(node) || wgsl.isDecorated(node)) {
+        if (wgsl.isAtomic(node) || wgsl.isDecorated(node) || isLooseDecorated(node)) {
             return go(node.inner, offsetExpr, valueExpr, depth);
         }
         if (wgsl.isWgslStruct(node) || isUnstruct(node)) {
@@ -178,15 +178,18 @@ export function buildWriter(node, offsetExpr, valueExpr, depth = 0, partial = fa
             const primitive = typeToPrimitive[node.type];
             const writeFunc = primitiveToWriteFunction[primitive];
             const matSize = wgsl.isMat2x2f(node) ? 2 : wgsl.isMat3x3f(node) ? 3 : 4;
-            const rowStride = roundUp(matSize * 4, 8);
             const components = ['x', 'y', 'z', 'w'];
-            const wgslElementStride = rowStride / 4;
-            return Array.from({ length: matSize * matSize }, (_, idx) => {
-                const col = Math.floor(idx / matSize);
-                const row = idx % matSize;
+            const wgslElementStride = roundUp(matSize, 2);
+            return Array.from({ length: matSize * wgslElementStride }, (_, idx) => {
+                const col = Math.floor(idx / wgslElementStride);
+                const row = idx % wgslElementStride;
+                const addr = `(${offsetExpr} + ${idx * 4})`;
+                if (row >= matSize) {
+                    // mat3x3f padding
+                    return emitWrite(writeFunc, addr, '0');
+                }
                 const packedIndex = col * matSize + row;
-                const wgslIndex = col * wgslElementStride + row;
-                return emitWrite(writeFunc, `(${offsetExpr} + ${col * rowStride + row * 4})`, `ArrayBuffer.isView(${valueExpr}) ? ${valueExpr}[${wgslIndex}] : Array.isArray(${valueExpr}) ? ${valueExpr}[${packedIndex}] : ${valueExpr}.columns[${col}].${components[row]}`);
+                return emitWrite(writeFunc, addr, `ArrayBuffer.isView(${valueExpr}) ? ${valueExpr}[${idx}] : Array.isArray(${valueExpr}) ? ${valueExpr}[${packedIndex}] : ${valueExpr}.columns[${col}].${components[row]}`);
             }).join('');
         }
         if (isPackedData(node)) {

package/data/dataIO.d.ts

@@ -1,13 +1,17 @@
 import { type ISerialInput, type ISerialOutput } from 'typed-binary';
 import type { Infer, InferInput } from '../shared/repr.ts';
-import type * as wgsl from './wgslTypes.ts';
-import { type BaseData } from './wgslTypes.ts';
+import * as wgsl from './wgslTypes.ts';
 import type { BufferWriteOptions } from '../core/buffer/buffer.ts';
-export declare function writeData<TData extends wgsl.BaseData>(output: ISerialOutput, schema: TData, value: Infer<TData>): void;
+export declare function writeData<TData extends wgsl.BaseData>(output: ISerialOutput, schema: TData, value: InferInput<TData>): void;
 export declare function readData<TData extends wgsl.BaseData>(input: ISerialInput, schema: TData): Infer<TData>;
-export declare function calculateOffsets<T extends BaseData>(options: BufferWriteOptions | undefined, schema: T, data: InferInput<T> | ArrayBuffer | ArrayBufferView): {
+export declare function calculateOffsets<T extends wgsl.BaseData>(options: BufferWriteOptions | undefined, schema: T, data: InferInput<T> | ArrayBuffer | ArrayBufferView): {
     startOffset: number;
     endOffset: number;
 };
-export declare function writeToArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T, data: InferInput<T> | ArrayBuffer | ArrayBufferView, options?: BufferWriteOptions): void;
-export declare function readFromArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T): Infer<T>;
+/**
+ * A function for filling in buffers with data based on TypeGPU schemas.
+ * When schema instances or JS arrays are passed, the padding is applied automatically.
+ * ArrayBuffers are expected to be already padded.
+ */
+export declare function writeToArrayBuffer<T extends wgsl.BaseData>(buffer: ArrayBuffer, schema: T, data: InferInput<T> | ArrayBuffer | ArrayBufferView, options?: BufferWriteOptions): void;
+export declare function readFromArrayBuffer<T extends wgsl.BaseData>(buffer: ArrayBuffer, schema: T): Infer<T>;

package/data/dataIO.js

@@ -4,7 +4,7 @@ import { alignmentOf, customAlignmentOf } from "./alignmentOf.js";
 import { mat2x2f, mat3x3f, mat4x4f } from "./matrix.js";
 import { sizeOf } from "./sizeOf.js";
 import { vec2f, vec2h, vec2i, vec2u, vec3f, vec3h, vec3i, vec3u, vec4f, vec4h, vec4i, vec4u, } from "./vector.js";
-import { isWgslArray } from "./wgslTypes.js";
+import * as wgsl from "./wgslTypes.js";
 import { getCompiledWriter } from "./compiledIO.js";
 import { getName } from "../shared/meta.js";
 import { roundUp } from "../mathUtils.js";
@@ -104,8 +104,18 @@ const dataWriters = {
         }
     },
     mat3x3f(output, _, value) {
-        for (let i = 0; i < value.length; ++i) {
-            output.writeFloat32(value[i]);
+        if (value instanceof Float32Array || wgsl.isMatInstance(value)) {
+            for (let i = 0; i < value.length; ++i) {
+                output.writeFloat32(value[i]);
+            }
+        }
+        else {
+            for (let i = 0; i < 3; ++i) {
+                for (let j = 0; j < 3; ++j) {
+                    output.writeFloat32(value[3 * i + j]);
+                }
+                output.writeFloat32(0);
+            }
         }
     },
     mat4x4f(output, _, value) {
@@ -607,7 +617,7 @@ export function calculateOffsets(options, schema, data) {
     const bufferSize = sizeOf(schema);
     const startOffset = options?.startOffset ?? 0;
     let naturalSize = undefined;
-    if (isWgslArray(schema) && Array.isArray(data)) {
+    if (wgsl.isWgslArray(schema) && Array.isArray(data)) {
         const arrayData = data;
         naturalSize =
             arrayData.length * roundUp(sizeOf(schema.elementType), alignmentOf(schema.elementType));
@@ -619,6 +629,11 @@ export function calculateOffsets(options, schema, data) {
     const endOffset = options?.endOffset ?? naturalEndOffset ?? bufferSize;
     return { startOffset, endOffset };
 }
+/**
+ * A function for filling in buffers with data based on TypeGPU schemas.
+ * When schema instances or JS arrays are passed, the padding is applied automatically.
+ * ArrayBuffers are expected to be already padded.
+ */
 export function writeToArrayBuffer(buffer, schema, data, options) {
     const { startOffset, endOffset } = calculateOffsets(options, schema, data);
     // Fast path: raw byte copy, user guarantees the padded layout

package/data/dataTypes.d.ts

@@ -3,7 +3,6 @@ import type { Infer, InferGPURecord, InferInput, InferInputRecord, InferPatch, I
 import type { $gpuRepr, $inRepr, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $reprPatch, $validVertexSchema } from '../shared/symbols.ts';
 import type { Prettify } from '../shared/utilityTypes.ts';
 import type { WgslExternalTexture, WgslStorageTexture, WgslTexture } from './texture.ts';
-import type { Snippet } from './snippet.ts';
 import type { PackedData } from './vertexFormatData.ts';
 import * as wgsl from './wgslTypes.ts';
 import type { WgslComparisonSampler, WgslSampler } from './sampler.ts';
@@ -130,8 +129,4 @@ export type AnyData = wgsl.AnyWgslData | AnyLooseData;
 export type AnyConcreteData = Exclude<AnyData, wgsl.AbstractInt | wgsl.AbstractFloat | wgsl.Void | WgslTexture | WgslStorageTexture | WgslExternalTexture | WgslSampler | WgslComparisonSampler>;
 export declare const UnknownData: unique symbol;
 export type UnknownData = typeof UnknownData;
-export declare class MatrixColumnsAccess {
-    readonly matrix: Snippet;
-    constructor(matrix: Snippet);
-}
 export {};

package/data/dataTypes.js

@@ -73,9 +73,3 @@ export function isData(value) {
     return wgsl.isWgslData(value) || isLooseData(value);
 }
 export const UnknownData = Symbol('UNKNOWN');
-export class MatrixColumnsAccess {
-    matrix;
-    constructor(matrix) {
-        this.matrix = matrix;
-    }
-}

package/data/deepEqual.js

@@ -1,4 +1,5 @@
 import { isDisarray, isLooseDecorated, isUnstruct } from "./dataTypes.js";
+import { isWgslStorageTexture, isWgslTexture } from "./texture.js";
 import { isAtomic, isDecorated, isPtr, isWgslArray, isWgslStruct } from "./wgslTypes.js";
 /**
  * Performs a deep comparison of two TypeGPU data schemas.
@@ -53,11 +54,20 @@ export function deepEqual(a, b) {
     if (isPtr(a) && isPtr(b)) {
         return (a.addressSpace === b.addressSpace &&
             a.access === b.access &&
+            a.implicit === b.implicit &&
             deepEqual(a.inner, b.inner));
     }
     if (isAtomic(a) && isAtomic(b)) {
         return deepEqual(a.inner, b.inner);
     }
+    if (isWgslTexture(a) && isWgslTexture(b)) {
+        // Dimension and multisampling are already encoded in the type
+        return deepEqual(a.sampleType, b.sampleType);
+    }
+    if (isWgslStorageTexture(a) && isWgslStorageTexture(b)) {
+        // Dimension is already encoded in the type
+        return a.format === b.format && a.access === b.access;
+    }
     if ((isDecorated(a) && isDecorated(b)) || (isLooseDecorated(a) && isLooseDecorated(b))) {
         if (!deepEqual(a.inner, b.inner)) {
             return false;
@@ -65,18 +75,18 @@ export function deepEqual(a, b) {
         if (a.attribs.length !== b.attribs.length) {
             return false;
         }
-        // Create comparable string representations for each attribute
-        const getAttrKey = (attr) => {
-            const anyAttr = attr;
-            return `${anyAttr.type}(${(anyAttr.params ?? []).join(',')})`;
-        };
-        const attrsA = a.attribs.map(getAttrKey);
-        const attrsB = b.attribs.map(getAttrKey);
-        for (let i = 0; i < attrsA.length; i++) {
-            if (attrsA[i] !== attrsB[i]) {
+        for (let i = 0; i < a.attribs.length; i++) {
+            const attrA = a.attribs[i];
+            const attrB = b.attribs[i];
+            const paramsA = attrA.params ?? [];
+            const paramsB = attrB.params ?? [];
+            if (attrA.type !== attrB.type ||
+                paramsA.length !== paramsB.length ||
+                paramsA.some((param, idx) => param !== paramsB[idx])) {
                 return false;
             }
         }
+        return true;
     }
     // All other types have been checked for equality at the start
     return true;

package/data/matrix.js

@@ -8,7 +8,7 @@ import { numericLiteralToSnippet } from "../tgsl/generationHelpers.js";
 import { f32 } from "./numeric.js";
 import {} from "./snippet.js";
 import { vec2f, vec3f, vec4f } from "./vector.js";
-import { isVec, } from "./wgslTypes.js";
+import { isMat, isMatInstance, isVec, } from "./wgslTypes.js";
 export class MatBase {
 }
 function createMatSchema(options) {
@@ -18,7 +18,14 @@ function createMatSchema(options) {
         normalImpl: (...args) => {
             const elements = [];
             for (const arg of args) {
-                if (typeof arg === 'number') {
+                if (isMatInstance(arg)) {
+                    for (const column of arg.columns) {
+                        for (const elem of column) {
+                            elements.push(elem);
+                        }
+                    }
+                }
+                else if (typeof arg === 'number') {
                     elements.push(arg);
                 }
                 else {
@@ -35,7 +42,7 @@ function createMatSchema(options) {
             }
             return new options.MatImpl(...elements);
         },
-        argTypes: (...args) => args.map((arg) => (isVec(arg) ? arg : f32)),
+        argTypes: (...args) => args.map((arg) => (isVec(arg) || isMat(arg) ? arg : f32)),
         codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(schema, args),
     });
     const schema = Object.assign(construct, {

package/data/matrixColumnsAccess.d.ts

@@ -0,0 +1,8 @@
+import { $comptimeValueOf } from '../shared/symbols.ts';
+import { type ComptimeValue, type WithComptimeValue } from '../types.ts';
+import type { Snippet } from './snippet.ts';
+export declare class MatrixColumnsAccess implements WithComptimeValue {
+    readonly matrix: Snippet;
+    constructor(matrix: Snippet);
+    [$comptimeValueOf](): ComptimeValue;
+}

package/data/matrixColumnsAccess.js

@@ -0,0 +1,15 @@
+import { $comptimeValueOf } from "../shared/symbols.js";
+import { asComptime } from "../types.js";
+export class MatrixColumnsAccess {
+    matrix;
+    constructor(matrix) {
+        this.matrix = matrix;
+    }
+    [$comptimeValueOf]() {
+        // Same as accessing `.columns` on a matrix in JS
+        const known = asComptime(this.matrix);
+        return known
+            ? { comptime: true, value: known.value.columns }
+            : { comptime: false };
+    }
+}