typegpu 0.12.6 → 0.12.8

package/data/snippet.d.ts

@@ -7,25 +7,26 @@ export type Origin = 'uniform' | 'readonly' | 'mutable' | 'workgroup' | 'private
  */
 export declare function fallthroughCopyOrigin(origin: Origin): Origin;
 /**
- * Whether a snippet aliases a value that lives outside the current expression.
+ * Whether a snippet refers to a value already stored in memory.
  *
  * @example
  * ```ts
  * function foo(a: number) {
+ *   'use gpu';
  *   const color = d.vec3f(1, 2, 3);
  *   return color * a;
  * }
  *
- * // References:
+ * // Stored in memory:
  * // -  color
  * // -  a
  * //
- * // Not references:
+ * // Ephemeral values:
  * // - d.vec3f(1, 2, 3)
  * // - color * a
  * ```
  */
-export declare function isAlias(snippet: Snippet): boolean;
+export declare function isStoredInMemory(snippet: Snippet): boolean;
 export declare const originToPtrParams: {
     readonly uniform: {
         readonly space: "uniform";
@@ -61,6 +62,14 @@ export declare const originToPtrParams: {
     };
 };
 export type OriginToPtrParams = typeof originToPtrParams;
+/**
+ * Whether values of this origin can have their address taken.
+ */
+export declare function isAddressableOrigin(origin: Origin): origin is keyof OriginToPtrParams;
+/**
+ * Whether values of this origin can be mutated.
+ */
+export declare function isMutableOrigin(origin: Origin): boolean;
 export interface Snippet {
     readonly value: unknown;
     /**

package/data/snippet.js

@@ -16,25 +16,26 @@ export function fallthroughCopyOrigin(origin) {
     return 'runtime';
 }
 /**
- * Whether a snippet aliases a value that lives outside the current expression.
+ * Whether a snippet refers to a value already stored in memory.
  *
  * @example
  * ```ts
  * function foo(a: number) {
+ *   'use gpu';
  *   const color = d.vec3f(1, 2, 3);
  *   return color * a;
  * }
  *
- * // References:
+ * // Stored in memory:
  * // -  color
  * // -  a
  * //
- * // Not references:
+ * // Ephemeral values:
  * // - d.vec3f(1, 2, 3)
  * // - color * a
  * ```
  */
-export function isAlias(snippet) {
+export function isStoredInMemory(snippet) {
     return !(snippet.origin === 'runtime' || snippet.origin === 'constant');
 }
 export const originToPtrParams = {
@@ -48,6 +49,18 @@ export const originToPtrParams = {
     // Local declarations are also in the `function` address space
     'local-def': { space: 'function', access: 'read-write' },
 };
+/**
+ * Whether values of this origin can have their address taken.
+ */
+export function isAddressableOrigin(origin) {
+    return origin in originToPtrParams;
+}
+/**
+ * Whether values of this origin can be mutated.
+ */
+export function isMutableOrigin(origin) {
+    return isAddressableOrigin(origin) && originToPtrParams[origin].access === 'read-write';
+}
 class SnippetImpl {
     value;
     dataType;

package/data/struct.js

@@ -17,6 +17,9 @@ import { schemaCallWrapper } from "./schemaCallWrapper.js";
  * each entry describing one struct member.
  */
 export function struct(props) {
+    if (Object.keys(props).length === 0) {
+        throw new Error('Cannot create struct schema with no properties.');
+    }
     return INTERNAL_createStruct(props, false);
 }
 export function abstruct(props) {

package/data/wgslTypes.d.ts

@@ -704,11 +704,12 @@ export interface Mat2x2f extends BaseData {
     readonly type: 'mat2x2f';
     readonly primitive: F32;
     readonly [$repr]: m2x2f;
-    readonly [$inRepr]: m2x2f | readonly number[] | Float32Array;
+    readonly [$inRepr]: m2x2f | readonly [number, number, number, number] | Float32Array;
     readonly [$validStorageSchema]: true;
     readonly [$validUniformSchema]: true;
     (...elements: [number, number, number, number]): m2x2f;
     (...columns: [v2f, v2f]): m2x2f;
+    (other: m2x2f): m2x2f;
     (): m2x2f;
     identity(): m2x2f;
 }
@@ -719,11 +720,12 @@ export interface Mat3x3f extends BaseData {
     readonly type: 'mat3x3f';
     readonly primitive: F32;
     readonly [$repr]: m3x3f;
-    readonly [$inRepr]: m3x3f | readonly number[] | Float32Array;
+    readonly [$inRepr]: m3x3f | readonly [number, number, number, number, number, number, number, number, number] | Float32Array;
     readonly [$validStorageSchema]: true;
     readonly [$validUniformSchema]: true;
     (...elements: [number, number, number, number, number, number, number, number, number]): m3x3f;
     (...columns: [v3f, v3f, v3f]): m3x3f;
+    (other: m3x3f): m3x3f;
     (): m3x3f;
     identity(): m3x3f;
 }
@@ -734,11 +736,12 @@ export interface Mat4x4f extends BaseData {
     readonly type: 'mat4x4f';
     readonly primitive: F32;
     readonly [$repr]: m4x4f;
-    readonly [$inRepr]: m4x4f | readonly number[] | Float32Array;
+    readonly [$inRepr]: m4x4f | readonly [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number] | Float32Array;
     readonly [$validStorageSchema]: true;
     readonly [$validUniformSchema]: true;
     (...elements: [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number]): m4x4f;
     (...columns: [v4f, v4f, v4f, v4f]): m4x4f;
+    (other: m4x4f): m4x4f;
     (): m4x4f;
     identity(): m4x4f;
     translation(vec: v3f): m4x4f;

package/internal.d.ts

@@ -13,4 +13,5 @@ export type { RestoreContext } from './serial/types.ts';
 export { deserializeDataSchema, serializeDataSchema, type SerializedDataSchema, } from './serial/schema.ts';
 export type { ResolutionCtx, FunctionArgument } from './types.ts';
 export type { Snippet, ResolvedSnippet, Origin } from './data/snippet.ts';
+export type { AutoStruct } from './data/autoStruct.ts';
 export type { ShaderGenerator, ResolvedStatement, BinaryOperator, ShaderGeneratorClass, FunctionDefinitionOptions, ConstantDefinitionOptions, VariableDefinitionOptions, } from './tgsl/shaderGenerator.ts';

package/nameUtils.d.ts

@@ -1,4 +1,11 @@
 export declare const bannedTokens: Set<string>;
+/**
+ * Predeclared enumerants that appear as template parameters, e.g. `var<storage, read_write>` or
+ * `texture_storage_2d<rgba8unorm, write>`. A module-scope or local declaration with one of these names
+ * would shadow the enumerant, so a template using it would refer to the declaration instead.
+ * Unlike `bannedTokens`, these remain valid as struct member names, which never shadow anything.
+ */
+export declare const templateEnumerants: Set<string>;
 export declare const builtins: Set<string>;
 /**
  * Sanitizes the primer so that it is compliant with WGSL guidelines.

package/nameUtils.js

@@ -178,6 +178,66 @@ export const bannedTokens = new Set([
     'uniform',
     'storage',
 ]);
+/**
+ * Predeclared enumerants that appear as template parameters, e.g. `var<storage, read_write>` or
+ * `texture_storage_2d<rgba8unorm, write>`. A module-scope or local declaration with one of these names
+ * would shadow the enumerant, so a template using it would refer to the declaration instead.
+ * Unlike `bannedTokens`, these remain valid as struct member names, which never shadow anything.
+ */
+export const templateEnumerants = new Set([
+    // address spaces
+    'function',
+    'private',
+    'workgroup',
+    'uniform',
+    'storage',
+    'immediate',
+    // access modes
+    'read',
+    'write',
+    'read_write',
+    // texel formats
+    'rgba8unorm',
+    'rgba8snorm',
+    'rgba8uint',
+    'rgba8sint',
+    'rgba16unorm',
+    'rgba16snorm',
+    'rgba16uint',
+    'rgba16sint',
+    'rgba16float',
+    'rg8unorm',
+    'rg8snorm',
+    'rg8uint',
+    'rg8sint',
+    'rg16unorm',
+    'rg16snorm',
+    'rg16uint',
+    'rg16sint',
+    'rg16float',
+    'r8unorm',
+    'r8snorm',
+    'r8uint',
+    'r8sint',
+    'r16unorm',
+    'r16snorm',
+    'r16uint',
+    'r16sint',
+    'r16float',
+    'r32uint',
+    'r32sint',
+    'r32float',
+    'rg32uint',
+    'rg32sint',
+    'rg32float',
+    'rgba32uint',
+    'rgba32sint',
+    'rgba32float',
+    'bgra8unorm',
+    'rgb10a2unorm',
+    'rgb10a2uint',
+    'rg11b10ufloat',
+]);
 export const builtins = new Set([
     // constructors
     'array',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.12.6",
+  "version": "0.12.8",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "keywords": [
     "compute",

package/resolutionCtx.js

@@ -417,7 +417,7 @@ export class ResolutionCtxImpl {
         return this._indentController.dedent();
     }
     getDedented(code) {
-        return code.replaceAll(`\n${INDENT[1]}`, '\n');
+        return code.replaceAll(`\n${INDENT[1]}`, '\n').replaceAll(new RegExp(`^${INDENT[1]}`, 'g'), '');
     }
     withResetIndentLevel(callback) {
         return this._indentController.withResetLevel(callback);

package/shared/meta.js

@@ -1,4 +1,4 @@
-const version = "0.12.6";
+const version = "0.12.8";
 import { DEV, TEST } from "./env.js";
 import { $getNameForward, $soul, isMarkedInternal } from "./symbols.js";
 import { normalizeMetadata } from "./normalizeMetadata.js";

package/shared/symbols.d.ts

@@ -18,6 +18,11 @@ export declare const $providing: unique symbol;
  * Objects can provide the snippet that represents them.
  */
 export declare const $ownSnippet: unique symbol;
+/**
+ * Objects can provide the value that they represent at comptime (e.g. when passed
+ * into comptime functions), or signal that they are not known at comptime.
+ */
+export declare const $comptimeValueOf: unique symbol;
 export declare const $resolve: unique symbol;
 /**
  * A way for a schema to provide casting behavior, without the need to be explicitly

package/shared/symbols.js

@@ -1,4 +1,4 @@
-const version = "0.12.6";
+const version = "0.12.8";
 export const $internal = Symbol(`typegpu:${version}:$internal`);
 /** A plain record of all definitional state of a resource, surviving transfer between runtimes */
 export const $soul = Symbol(`typegpu:${version}:$soul`);
@@ -19,6 +19,11 @@ export const $providing = Symbol(`typegpu:${version}:$providing`);
  * Objects can provide the snippet that represents them.
  */
 export const $ownSnippet = Symbol(`typegpu:${version}:$ownSnippet`);
+/**
+ * Objects can provide the value that they represent at comptime (e.g. when passed
+ * into comptime functions), or signal that they are not known at comptime.
+ */
+export const $comptimeValueOf = Symbol(`typegpu:${version}:$comptimeValueOf`);
 export const $resolve = Symbol(`typegpu:${version}:$resolve`);
 /**
  * A way for a schema to provide casting behavior, without the need to be explicitly

package/shared/tseynit.js

@@ -2,90 +2,94 @@ import * as tinyest from 'tinyest';
 const { NodeTypeCatalog: NODE } = tinyest;
 export function stringifyNode(node) {
     if (isExpression(node)) {
-        return stringifyExpression(node, '');
+        return stringifyExpression(node);
     }
     return stringifyStatement(node, '');
 }
-function stringifyStatement(node, ident) {
+function stringifyStatement(node, indent) {
     if (isExpression(node)) {
-        return `${ident}${stringifyExpression(node, ident)};`;
+        return `${indent}${stringifyExpression(node)};`;
     }
     if (node[0] === NODE.block) {
-        const statements = node[1].map((n) => stringifyStatement(n, ident + '  '));
-        return `{\n${statements.join('\n')}\n${ident}}`;
+        const statements = node[1].map((n) => stringifyStatement(n, indent + '  '));
+        return `{\n${statements.join('\n')}\n${indent}}`;
     }
     if (node[0] === NODE.return) {
-        const expr = node[1] === undefined ? '' : ` ${stringifyExpression(node[1], '')}`;
-        return `${ident}return${expr};`;
+        const expr = node[1] === undefined ? '' : ` ${stringifyExpression(node[1])}`;
+        return `${indent}return${expr};`;
     }
     if (node[0] === NODE.if) {
-        const cond = stringifyExpression(node[1], ident);
-        const then = stringifyStatement(node[2], ident);
-        const base = `${ident}if (${cond}) ${then}`;
+        const cond = stringifyExpression(node[1]);
+        const then = stringifyStatement(node[2], indent);
+        const base = `${indent}if (${cond}) ${then}`;
         if (node[3] !== undefined) {
-            return `${base} else ${stringifyStatement(node[3], ident)}`;
+            return `${base} else ${stringifyStatement(node[3], indent)}`;
         }
         return base;
     }
     if (node[0] === NODE.let) {
-        const decl = `${ident}let ${stringifyExpression(node[1], ident)}`;
+        const decl = `${indent}let ${stringifyExpression(node[1])}`;
         if (node[2] !== undefined) {
-            return `${decl} = ${stringifyExpression(node[2], ident)};`;
+            return `${decl} = ${stringifyExpression(node[2])};`;
         }
         return `${decl};`;
     }
     if (node[0] === NODE.const) {
-        const decl = `${ident}const ${stringifyExpression(node[1], ident)}`;
+        const decl = `${indent}const ${stringifyExpression(node[1])}`;
         if (node[2] !== undefined) {
-            return `${decl} = ${stringifyExpression(node[2], ident)};`;
+            return `${decl} = ${stringifyExpression(node[2])};`;
         }
         return `${decl};`;
     }
     if (node[0] === NODE.for) {
         const init = node[1] ? stringifyStatement(node[1], '') : ';';
-        const cond = node[2] ? stringifyExpression(node[2], ident) : '';
+        const cond = node[2] ? stringifyExpression(node[2]) : '';
         const update = node[3] ? stringifyStatement(node[3], '') : '';
-        const body = stringifyStatement(node[4], ident);
-        return `${ident}for (${init} ${cond}; ${update.slice(0, -1) /* trim the ';' */}) ${body}`;
+        const body = stringifyStatement(node[4], indent);
+        return `${indent}for (${init} ${cond}; ${update.slice(0, -1) /* trim the ';' */}) ${body}`;
     }
     if (node[0] === NODE.while) {
-        const cond = stringifyExpression(node[1], ident);
-        const body = stringifyStatement(node[2], ident);
-        return `${ident}while (${cond}) ${body}`;
+        const cond = stringifyExpression(node[1]);
+        const body = stringifyStatement(node[2], indent);
+        return `${indent}while (${cond}) ${body}`;
     }
     if (node[0] === NODE.continue) {
-        return `${ident}continue;`;
+        return `${indent}continue;`;
     }
     if (node[0] === NODE.break) {
-        return `${ident}break;`;
+        return `${indent}break;`;
     }
     if (node[0] === NODE.forOf) {
         const leftKind = node[1][0] === NODE.const ? 'const' : 'let';
-        const leftName = stringifyExpression(node[1][1], ident);
-        const right = stringifyExpression(node[2], ident);
-        const body = stringifyStatement(node[3], ident);
-        return `${ident}for (${leftKind} ${leftName} of ${right}) ${body}`;
+        const leftName = stringifyExpression(node[1][1]);
+        const right = stringifyExpression(node[2]);
+        const body = stringifyStatement(node[3], indent);
+        return `${indent}for (${leftKind} ${leftName} of ${right}) ${body}`;
     }
     if (node[0] === NODE.switch) {
-        const discriminant = stringifyExpression(node[1], ident);
+        const discriminant = stringifyExpression(node[1]);
         const cases = node[2].map((c) => {
-            const test = c[0] === null ? 'default' : `case ${stringifyExpression(c[0], ident)}`;
+            const test = c[0] === null ? 'default' : `case ${stringifyExpression(c[0])}`;
             if (c[1].length === 0) {
                 return `${test}:`;
             }
-            const consequents = c[1].map((s) => stringifyStatement(s, ident + '    '));
+            const consequents = c[1].map((s) => stringifyStatement(s, indent + '    '));
             return `${test}:\n${consequents.join('\n')}`;
         });
-        return `${ident}switch (${discriminant}) {\n${cases.map((c) => `${ident + '  '}${c}`).join('\n')}\n${ident}}`;
+        return `${indent}switch (${discriminant}) {\n${cases.map((c) => `${indent + '  '}${c}`).join('\n')}\n${indent}}`;
     }
     assertExhaustive(node);
 }
+const JS_IDENTIFIER = /^[$_\p{ID_Start}][$_\u{200c}\u{200d}\p{ID_Continue}]*$/u;
+function stringifyObjectPropertyKey(key) {
+    return JS_IDENTIFIER.test(key) ? key : JSON.stringify(key);
+}
 export function stringifyObjectProperty([key, value, computed]) {
-    const keyStr = computed ? `[${stringifyExpression(key, '')}]` : stringifyExpression(key, '');
-    const valueStr = stringifyExpression(value, '');
+    const keyStr = computed ? `[${stringifyExpression(key)}]` : stringifyObjectPropertyKey(key);
+    const valueStr = stringifyExpression(value);
     return `${keyStr}: ${valueStr}`;
 }
-function stringifyExpression(node, ident) {
+function stringifyExpression(node) {
     if (typeof node === 'string') {
         return node;
     }
@@ -105,52 +109,52 @@ function stringifyExpression(node, ident) {
         return JSON.stringify(node[1]);
     }
     if (node[0] === NODE.arrayExpr) {
-        const elements = node[1].map((n) => stringifyExpression(n, ident));
+        const elements = node[1].map((n) => stringifyExpression(n));
         return `[${elements.join(', ')}]`;
     }
     if (node[0] === NODE.binaryExpr) {
-        return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
+        return `${wrapIfComplex(node[1])} ${node[2]} ${wrapIfComplex(node[3])}`;
     }
     if (node[0] === NODE.assignmentExpr) {
-        return `${stringifyExpression(node[1], ident)} ${node[2]} ${stringifyExpression(node[3], ident)}`;
+        return `${stringifyExpression(node[1])} ${node[2]} ${stringifyExpression(node[3])}`;
     }
     if (node[0] === NODE.logicalExpr) {
-        return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
+        return `${wrapIfComplex(node[1])} ${node[2]} ${wrapIfComplex(node[3])}`;
     }
     if (node[0] === NODE.unaryExpr) {
         // Unary word operators like void, instanceof and delete require a space
         const sep = node[1].length > 1 ? ' ' : '';
-        return `${node[1]}${sep}${wrapIfComplex(node[2], ident)}`;
+        return `${node[1]}${sep}${wrapIfComplex(node[2])}`;
     }
     if (node[0] === NODE.call) {
-        const callee = wrapIfComplex(node[1], ident);
-        const args = node[2].map((n) => stringifyExpression(n, ident)).join(', ');
+        const callee = wrapIfComplex(node[1]);
+        const args = node[2].map((n) => stringifyExpression(n)).join(', ');
         return `${callee}(${args})`;
     }
     if (node[0] === NODE.memberAccess) {
         if (Array.isArray(node[1]) && node[1][0] === NODE.numericLiteral) {
-            return `(${stringifyExpression(node[1], ident)}).${stringifyExpression(node[2], ident)}`;
+            return `(${stringifyExpression(node[1])}).${stringifyExpression(node[2])}`;
         }
-        return `${wrapIfComplex(node[1], ident)}.${stringifyExpression(node[2], ident)}`;
+        return `${wrapIfComplex(node[1])}.${stringifyExpression(node[2])}`;
     }
     if (node[0] === NODE.indexAccess) {
-        return `${wrapIfComplex(node[1], ident)}[${stringifyExpression(node[2], ident)}]`;
+        return `${wrapIfComplex(node[1])}[${stringifyExpression(node[2])}]`;
     }
     if (node[0] === NODE.preUpdate) {
-        return `${node[1]}${wrapIfComplex(node[2], ident)}`;
+        return `${node[1]}${wrapIfComplex(node[2])}`;
     }
     if (node[0] === NODE.postUpdate) {
-        return `${wrapIfComplex(node[2], ident)}${node[1]}`;
+        return `${wrapIfComplex(node[2])}${node[1]}`;
     }
     if (node[0] === NODE.objectExpr) {
         if (Array.isArray(node[1])) {
             return `{ ${node[1].map(stringifyObjectProperty).join(', ')} }`;
         }
-        const entries = Object.entries(node[1]).map(([key, val]) => `${key}: ${stringifyExpression(val, ident)}`);
+        const entries = Object.entries(node[1]).map(([key, val]) => `${stringifyObjectPropertyKey(key)}: ${stringifyExpression(val)}`);
         return `{ ${entries.join(', ')} }`;
     }
     if (node[0] === NODE.conditionalExpr) {
-        return `${wrapIfComplex(node[1], ident)} ? ${wrapIfComplex(node[2], ident)} : ${wrapIfComplex(node[3], ident)}`;
+        return `${wrapIfComplex(node[1])} ? ${wrapIfComplex(node[2])} : ${wrapIfComplex(node[3])}`;
     }
     if (node[0] === NODE.nullLiteral) {
         return 'null';
@@ -199,8 +203,8 @@ const SIMPLE_NODES = [
 /**
  * Stringifies expression, and wraps it in parentheses if they cannot be trivially omitted
  */
-function wrapIfComplex(node, ident) {
-    const s = stringifyExpression(node, ident);
+function wrapIfComplex(node) {
+    const s = stringifyExpression(node);
     if (typeof node === 'string' || typeof node === 'boolean') {
         return s;
     }

package/std/boolean.js

@@ -9,6 +9,7 @@ import { isBool, isVecBool, isVecInstance, } from "../data/wgslTypes.js";
 import { SignatureNotSupportedError, WgslTypeError } from "../errors.js";
 import { unify } from "../tgsl/conversion.js";
 import { cpuCopy } from "./copy.js";
+import { coerceToSnippet } from "../tgsl/generationHelpers.js";
 function correspondingBooleanVectorSchema(dataType) {
     if (dataType.type.includes('2')) {
         return vec2b;
@@ -30,7 +31,7 @@ export const allEq = dualImpl({
     name: 'allEq',
     signature: (...argTypes) => ({ argTypes, returnType: bool }),
     normalImpl: (lhs, rhs) => cpuAll(cpuEq(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `all(${lhs} == ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => stitch `all(${ctx.gen.emitBinaryOp(lhs, '==', rhs)})`,
     sideEffects: false,
 });
 const cpuEq = (lhs, rhs) => {
@@ -54,7 +55,7 @@ export const eq = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: cpuEq,
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} == ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '==', rhs),
     sideEffects: false,
 });
 /**
@@ -72,7 +73,7 @@ export const ne = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuNot(cpuEq(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} != ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '!=', rhs),
     sideEffects: false,
 });
 const cpuLt = (lhs, rhs) => {
@@ -95,7 +96,7 @@ export const lt = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: cpuLt,
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} < ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '<', rhs),
     sideEffects: false,
 });
 /**
@@ -113,7 +114,7 @@ export const le = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuOr(cpuLt(lhs, rhs), cpuEq(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} <= ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '<=', rhs),
     sideEffects: false,
 });
 /**
@@ -131,7 +132,7 @@ export const gt = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuAnd(cpuNot(cpuLt(lhs, rhs)), cpuNot(cpuEq(lhs, rhs))),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} > ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '>', rhs),
     sideEffects: false,
 });
 /**
@@ -149,7 +150,7 @@ export const ge = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuNot(cpuLt(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} >= ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '>=', rhs),
     sideEffects: false,
 });
 function cpuNot(value) {
@@ -274,9 +275,7 @@ export const isCloseTo = dualImpl({
             return stitch `(abs(f32(${lhs}) - f32(${rhs})) <= ${precision})`;
         }
         if (!isSnippetNumeric(lhs) && !isSnippetNumeric(rhs)) {
-            // https://www.w3.org/TR/WGSL/#vector-multi-component:~:text=Binary%20arithmetic%20expressions%20with%20mixed%20scalar%20and%20vector%20operands
-            // (a-a)+prec creates a vector of a.length elements, all equal to prec
-            return stitch `all(abs(${lhs} - ${rhs}) <= (${lhs} - ${lhs}) + ${precision})`;
+            return stitch `all(abs(${lhs} - ${rhs}) <= ${_ctx.gen.typeInstantiation(lhs.dataType, [coerceToSnippet(precision)])})`;
         }
         return 'false';
     },

package/std/numeric.js

@@ -747,10 +747,7 @@ export const round = dualImpl({
 });
 function cpuSaturate(value) {
     assertKind(value, floatKind);
-    if (typeof value === 'number') {
-        return Math.max(0, Math.min(1, value));
-    }
-    throw new MissingCpuImplError('CPU implementation for saturate on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues');
+    return generalizeFn((value) => clampScalar(value, 0, 1), [value]);
 }
 export const saturate = dualImpl({
     name: 'saturate',

package/std/operators.js

@@ -160,10 +160,15 @@ function cpuNeg(value) {
 }
 export const neg = dualImpl({
     name: 'neg',
-    signature: (arg) => ({
-        argTypes: [arg],
-        returnType: arg,
-    }),
+    signature: (arg) => {
+        if (getPrimitive(arg) === u32) {
+            throw new WgslTypeError(`Unsupported signature. Unary operator - cannot be applied to argument of kind '${arg.type}'.`);
+        }
+        return {
+            argTypes: [arg],
+            returnType: arg,
+        };
+    },
     normalImpl: cpuNeg,
     codegenImpl: (_ctx, [arg]) => stitch `-(${arg})`,
     sideEffects: false,