typegpu 0.12.1 → 0.12.3

package/data/assignInfixOperators.d.ts

@@ -0,0 +1 @@
+export declare function assignInfixOperators(): void;

package/data/assignInfixOperators.js

@@ -0,0 +1,21 @@
+import { Operator } from 'tsover-runtime';
+import { MatBase } from "./matrix.js";
+import { VecBase } from "./vectorImpl.js";
+import { assignInfixOperator } from "../tgsl/infixDispatch.js";
+let infixOperatorsAssigned = false;
+export function assignInfixOperators() {
+    if (infixOperatorsAssigned) {
+        return;
+    }
+    infixOperatorsAssigned = true;
+    assignInfixOperator(VecBase, 'add', Operator.plus);
+    assignInfixOperator(MatBase, 'add', Operator.plus);
+    assignInfixOperator(VecBase, 'sub', Operator.minus);
+    assignInfixOperator(MatBase, 'sub', Operator.minus);
+    assignInfixOperator(VecBase, 'mul', Operator.star);
+    assignInfixOperator(MatBase, 'mul', Operator.star);
+    assignInfixOperator(VecBase, 'div', Operator.slash);
+    assignInfixOperator(VecBase, 'mod', Operator.percent);
+    assignInfixOperator(VecBase, 'bitShiftLeft', Symbol()); // bitShift does not yet have tsover operator symbol
+    assignInfixOperator(VecBase, 'bitShiftRight', Symbol()); // bitShift does not yet have tsover operator symbol
+}

package/data/index.d.ts

@@ -1,6 +1,24 @@
 /**
  * @module typegpu/data
  */
+export declare const vec2b: import("./wgslTypes.ts").Vec2b;
+export declare const vec2f: import("./wgslTypes.ts").Vec2f;
+export declare const vec2h: import("./wgslTypes.ts").Vec2h;
+export declare const vec2i: import("./wgslTypes.ts").Vec2i;
+export declare const vec2u: import("./wgslTypes.ts").Vec2u;
+export declare const vec3b: import("./wgslTypes.ts").Vec3b;
+export declare const vec3f: import("./wgslTypes.ts").Vec3f;
+export declare const vec3h: import("./wgslTypes.ts").Vec3h;
+export declare const vec3i: import("./wgslTypes.ts").Vec3i;
+export declare const vec3u: import("./wgslTypes.ts").Vec3u;
+export declare const vec4b: import("./wgslTypes.ts").Vec4b;
+export declare const vec4f: import("./wgslTypes.ts").Vec4f;
+export declare const vec4h: import("./wgslTypes.ts").Vec4h;
+export declare const vec4i: import("./wgslTypes.ts").Vec4i;
+export declare const vec4u: import("./wgslTypes.ts").Vec4u;
+export declare const mat2x2f: import("./wgslTypes.ts").Mat2x2f;
+export declare const mat3x3f: import("./wgslTypes.ts").Mat3x3f;
+export declare const mat4x4f: import("./wgslTypes.ts").Mat4x4f;
 export { bool, f16, f32, i32, u16, u32 } from './numeric.ts';
 export { isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isInvariantAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, Void, } from './wgslTypes.ts';
 export type { Align, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, atomicI32, atomicU32, BaseData, BaseData as BaseWgslData, Bool, Builtin, Decorated, F16, F32, I32, Interpolate, Invariant, Location, m2x2f, m3x3f, m4x4f, Mat2x2f, Mat3x3f, Mat4x4f, matBase, Ptr, Size, StorableData, U16, U32, v2b, v2f, v2h, v2i, v2u, v3b, v3f, v3h, v3i, v3u, v4b, v4f, v4h, v4i, v4u, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, vecBase, WgslArray, WgslStruct, } from './wgslTypes.ts';
@@ -10,10 +28,9 @@ export { ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup } fr
 export type { AnyData, AnyLooseData, Disarray, LooseDecorated, Unstruct } from './dataTypes.ts';
 export { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, type WgslExternalTexture, type WgslStorageTexture, type WgslStorageTexture1d, type WgslStorageTexture2d, type WgslStorageTexture2dArray, type WgslStorageTexture3d, type WgslStorageTextureProps, type WgslTexture, type WgslTexture1d, type WgslTexture2d, type WgslTexture2dArray, type WgslTexture3d, type WgslTextureCube, type WgslTextureCubeArray, type WgslTextureDepth2d, type WgslTextureDepth2dArray, type WgslTextureDepthCube, type WgslTextureDepthCubeArray, type WgslTextureDepthMultisampled2d, type WgslTextureMultisampled2d, } from './texture.ts';
 export { comparisonSampler, sampler, type WgslComparisonSampler, type WgslSampler, } from './sampler.ts';
-export { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from './vector.ts';
 export { disarrayOf } from './disarray.ts';
 export { unstruct } from './unstruct.ts';
-export { mat2x2f, mat3x3f, mat4x4f, matToArray } from './matrix.ts';
+export { matToArray } from './matrix.ts';
 export * from './vertexFormatData.ts';
 export { atomic } from './atomic.ts';
 export { _ref as ref } from './ref.ts';

package/data/index.js

@@ -2,20 +2,27 @@
  * @module typegpu/data
  */
 // NOTE: This is a barrel file, internal files should not import things from this file
-import { Operator } from 'tsover-runtime';
-import { MatBase } from "./matrix.js";
-import { VecBase } from "./vectorImpl.js";
-import { assignInfixOperator } from "../tgsl/infixDispatch.js";
-assignInfixOperator(VecBase, 'add', Operator.plus);
-assignInfixOperator(MatBase, 'add', Operator.plus);
-assignInfixOperator(VecBase, 'sub', Operator.minus);
-assignInfixOperator(MatBase, 'sub', Operator.minus);
-assignInfixOperator(VecBase, 'mul', Operator.star);
-assignInfixOperator(MatBase, 'mul', Operator.star);
-assignInfixOperator(VecBase, 'div', Operator.slash);
-assignInfixOperator(VecBase, 'mod', Operator.percent);
-assignInfixOperator(VecBase, 'bitShiftLeft', Symbol()); // bitShift does not yet have tsover operator symbol
-assignInfixOperator(VecBase, 'bitShiftRight', Symbol()); // bitShift does not yet have tsover operator symbol
+import { assignInfixOperators } from "./assignInfixOperators.js";
+import { vec2b as _vec2b, vec2f as _vec2f, vec2h as _vec2h, vec2i as _vec2i, vec2u as _vec2u, vec3b as _vec3b, vec3f as _vec3f, vec3h as _vec3h, vec3i as _vec3i, vec3u as _vec3u, vec4b as _vec4b, vec4f as _vec4f, vec4h as _vec4h, vec4i as _vec4i, vec4u as _vec4u, } from "./vector.js";
+export const vec2b = (() => (assignInfixOperators(), _vec2b))();
+export const vec2f = (() => (assignInfixOperators(), _vec2f))();
+export const vec2h = (() => (assignInfixOperators(), _vec2h))();
+export const vec2i = (() => (assignInfixOperators(), _vec2i))();
+export const vec2u = (() => (assignInfixOperators(), _vec2u))();
+export const vec3b = (() => (assignInfixOperators(), _vec3b))();
+export const vec3f = (() => (assignInfixOperators(), _vec3f))();
+export const vec3h = (() => (assignInfixOperators(), _vec3h))();
+export const vec3i = (() => (assignInfixOperators(), _vec3i))();
+export const vec3u = (() => (assignInfixOperators(), _vec3u))();
+export const vec4b = (() => (assignInfixOperators(), _vec4b))();
+export const vec4f = (() => (assignInfixOperators(), _vec4f))();
+export const vec4h = (() => (assignInfixOperators(), _vec4h))();
+export const vec4i = (() => (assignInfixOperators(), _vec4i))();
+export const vec4u = (() => (assignInfixOperators(), _vec4u))();
+import { mat2x2f as _mat2x2f, mat3x3f as _mat3x3f, mat4x4f as _mat4x4f } from "./matrix.js";
+export const mat2x2f = (() => (assignInfixOperators(), _mat2x2f))();
+export const mat3x3f = (() => (assignInfixOperators(), _mat3x3f))();
+export const mat4x4f = (() => (assignInfixOperators(), _mat4x4f))();
 export { bool, f16, f32, i32, u16, u32 } from "./numeric.js";
 export { isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isInvariantAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, Void, } from "./wgslTypes.js";
 export { struct } from "./struct.js";
@@ -23,10 +30,9 @@ export { arrayOf } from "./array.js";
 export { ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup } from "./ptr.js";
 export { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, } from "./texture.js";
 export { comparisonSampler, sampler, } from "./sampler.js";
-export { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from "./vector.js";
 export { disarrayOf } from "./disarray.js";
 export { unstruct } from "./unstruct.js";
-export { mat2x2f, mat3x3f, mat4x4f, matToArray } from "./matrix.js";
+export { matToArray } from "./matrix.js";
 export * from "./vertexFormatData.js";
 export { atomic } from "./atomic.js";
 export { _ref as ref } from "./ref.js";

package/package.json

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

package/shared/meta.js

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

package/shared/symbols.js

@@ -1,4 +1,4 @@
-const version = "0.12.1";
+const version = "0.12.3";
 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`);

package/std/texture.js

@@ -5,13 +5,16 @@ import { f32, i32, u32 } from "../data/numeric.js";
 import { vec2u, vec3u, vec4f, vec4i, vec4u } from "../data/vector.js";
 import { Void, } from "../data/wgslTypes.js";
 import { getTextureFormatInfo, } from "../core/texture/textureFormats.js";
+function compactSnippetArgs(args) {
+    return args.filter((arg) => arg !== undefined);
+}
 function sampleCpu(_texture, _sampler, _coords, _offsetOrArrayIndex, _maybeOffset) {
     throw new MissingCpuImplError('Texture sampling relies on GPU resources and cannot be executed outside of a draw call');
 }
 export const textureSample = dualImpl({
     name: 'textureSample',
     normalImpl: sampleCpu,
-    codegenImpl: (_ctx, args) => stitch `textureSample(${args})`,
+    codegenImpl: (ctx, args) => ctx.gen.emitCall('textureSample', [], compactSnippetArgs(args)),
     signature: (...args) => {
         const isDepth = args[0].type.startsWith('texture_depth');
         return {
@@ -27,7 +30,7 @@ function sampleBiasCpu(_texture, _sampler, _coords, _biasOrArrayIndex, _biasOrOf
 export const textureSampleBias = dualImpl({
     name: 'textureSampleBias',
     normalImpl: sampleBiasCpu,
-    codegenImpl: (_ctx, args) => stitch `textureSampleBias(${args})`,
+    codegenImpl: (ctx, args) => ctx.gen.emitCall('textureSampleBias', [], compactSnippetArgs(args)),
     signature: (...args) => ({
         argTypes: args,
         returnType: vec4f,
@@ -40,7 +43,7 @@ function sampleLevelCpu(_texture, _sampler, _coords, _level, _offsetOrArrayIndex
 export const textureSampleLevel = dualImpl({
     name: 'textureSampleLevel',
     normalImpl: sampleLevelCpu,
-    codegenImpl: (_ctx, args) => stitch `textureSampleLevel(${args})`,
+    codegenImpl: (ctx, args) => ctx.gen.emitCall('textureSampleLevel', [], compactSnippetArgs(args)),
     signature: (...args) => {
         const isDepth = args[0].type.startsWith('texture_depth');
         return {
@@ -56,7 +59,7 @@ function textureLoadCpu(_texture, _coords, _levelOrArrayIndex) {
 export const textureLoad = dualImpl({
     name: 'textureLoad',
     normalImpl: textureLoadCpu,
-    codegenImpl: (_ctx, args) => stitch `textureLoad(${args})`,
+    codegenImpl: (ctx, args) => ctx.gen.emitCall('textureLoad', [], compactSnippetArgs(args)),
     signature: (...args) => {
         const texture = args[0];
         if (isWgslTexture(texture)) {
@@ -104,7 +107,7 @@ function textureDimensionsCpu(_texture, _level) {
 export const textureDimensions = dualImpl({
     name: 'textureDimensions',
     normalImpl: textureDimensionsCpu,
-    codegenImpl: (_ctx, args) => stitch `textureDimensions(${args})`,
+    codegenImpl: (ctx, args) => ctx.gen.emitCall('textureDimensions', [], compactSnippetArgs(args)),
     signature: (...args) => {
         const dim = args[0].dimension;
         if (dim === '1d') {