typegpu 0.11.9 → 0.12.1

package/std/packing.js

@@ -1,86 +1,78 @@
+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 { dualImpl } from "../core/function/dualImpl.js";
-import * as TB from "typed-binary";
-
-//#region src/std/packing.ts
+import { readFloat16, writeFloat16 } from "../data/float16Conversion.js";
 /**
-* @privateRemarks
-* https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
-*/
-const unpack2x16float = dualImpl({
-	name: "unpack2x16float",
-	normalImpl: (e) => {
-		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
-		new TB.BufferWriter(buffer).writeUint32(e);
-		const reader = new TB.BufferReader(buffer);
-		return vec2f(reader.readFloat16(), reader.readFloat16());
-	},
-	signature: {
-		argTypes: [u32],
-		returnType: vec2f
-	},
-	codegenImpl: (_ctx, [e]) => stitch`unpack2x16float(${e})`
+ * @privateRemarks
+ * https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
+ */
+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);
+        return vec2f(readFloat16(reader), readFloat16(reader));
+    },
+    signature: { argTypes: [u32], returnType: vec2f },
+    codegenImpl: (_ctx, [e]) => stitch `unpack2x16float(${e})`,
+    sideEffects: false,
 });
 /**
-* @privateRemarks
-* https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
-*/
-const pack2x16float = dualImpl({
-	name: "pack2x16float",
-	normalImpl: (e) => {
-		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
-		const writer = new TB.BufferWriter(buffer);
-		writer.writeFloat16(e.x);
-		writer.writeFloat16(e.y);
-		return u32(new TB.BufferReader(buffer).readUint32());
-	},
-	signature: {
-		argTypes: [vec2f],
-		returnType: u32
-	},
-	codegenImpl: (_ctx, [e]) => stitch`pack2x16float(${e})`
+ * @privateRemarks
+ * https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
+ */
+export const pack2x16float = dualImpl({
+    name: 'pack2x16float',
+    normalImpl: (e) => {
+        const buffer = new ArrayBuffer(4);
+        const writer = new TB.BufferWriter(buffer);
+        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://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
-*/
-const unpack4x8unorm = dualImpl({
-	name: "unpack4x8unorm",
-	normalImpl: (e) => {
-		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
-		new TB.BufferWriter(buffer).writeUint32(e);
-		const reader = new TB.BufferReader(buffer);
-		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})`
+ * @privateRemarks
+ * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
+ */
+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);
+        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://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
-*/
-const pack4x8unorm = dualImpl({
-	name: "pack4x8unorm",
-	normalImpl: (e) => {
-		const buffer = /* @__PURE__ */ 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);
-		return u32(new TB.BufferReader(buffer).readUint32());
-	},
-	signature: {
-		argTypes: [vec4f],
-		returnType: u32
-	},
-	codegenImpl: (_ctx, [e]) => stitch`pack4x8unorm(${e})`
+ * @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());
+    },
+    signature: { argTypes: [vec4f], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4x8unorm(${e})`,
+    sideEffects: false,
 });
-
-//#endregion
-export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };

package/std/range.d.ts

@@ -1,11 +1,7 @@
-import { TgpuComptime } from "../core/function/comptime.js";
-import "../indexNamedExports.js";
-
-//#region src/std/range.d.ts
-interface TgpuRange extends Array<number> {
-  start: number;
-  end: number;
-  step: number;
+export interface TgpuRange extends Array<number> {
+    start: number;
+    end: number;
+    step: number;
 }
 /**
  * Returns an array of values between `start` (inclusive) and `end` (exclusive) with the given `step`.
@@ -21,6 +17,5 @@ interface TgpuRange extends Array<number> {
  *
  * Can also be combined with `tgpu.unroll` to unroll a specific number of iterations.
  */
-declare const range: TgpuComptime<((end: number) => TgpuRange) & ((start: number, end?: number, step?: number) => TgpuRange)>;
-//#endregion
-export { range };
+export declare const range: import("../indexNamedExports.ts").TgpuComptime<((end: number) => TgpuRange) & ((start: number, end?: number, step?: number) => TgpuRange)>;
+export declare function isTgpuRange(value: unknown): value is TgpuRange;

package/std/range.js

@@ -1,40 +1,52 @@
 import { comptime } from "../core/function/comptime.js";
-
-//#region src/std/range.ts
 /**
-* Returns an array of values between `start` (inclusive) and `end` (exclusive) with the given `step`.
-*
-* If only one argument is provided, it is interpreted as `end`, with `start=0` and `step=1`.
-*
-* ```ts
-* let result = d.f32(1);
-* for (const i of std.range(5)) {
-*   result *= i + 1;
-* }
-* ```
-*
-* Can also be combined with `tgpu.unroll` to unroll a specific number of iterations.
-*/
-const range = comptime((start, end, step = 1) => {
-	if (end === void 0) {
-		end = start;
-		start = 0;
-	}
-	if (!Number.isInteger(start)) throw new Error(`'start' must be an integer, got ${start}`);
-	if (!Number.isInteger(end)) throw new Error(`'end' must be an integer, got ${end}`);
-	if (!Number.isInteger(step) || step === 0) throw new Error(`'step' must be a non-zero integer, got ${step}`);
-	const result = [];
-	result.start = start;
-	result.end = end;
-	result.step = step;
-	if (Math.sign(step) !== Math.sign(end - start)) return result;
-	if (step > 0) for (let i = start; i < end; i += step) result.push(i);
-	if (step < 0) for (let i = start; i > end; i += step) result.push(i);
-	return result;
+ * Returns an array of values between `start` (inclusive) and `end` (exclusive) with the given `step`.
+ *
+ * If only one argument is provided, it is interpreted as `end`, with `start=0` and `step=1`.
+ *
+ * ```ts
+ * let result = d.f32(1);
+ * for (const i of std.range(5)) {
+ *   result *= i + 1;
+ * }
+ * ```
+ *
+ * Can also be combined with `tgpu.unroll` to unroll a specific number of iterations.
+ */
+export const range = comptime((start, end, step = 1) => {
+    if (end === undefined) {
+        // range(n)
+        end = start;
+        start = 0;
+    }
+    if (!Number.isInteger(start)) {
+        throw new Error(`'start' must be an integer, got ${start}`);
+    }
+    if (!Number.isInteger(end)) {
+        throw new Error(`'end' must be an integer, got ${end}`);
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`'step' must be a non-zero integer, got ${step}`);
+    }
+    const result = [];
+    result.start = start;
+    result.end = end;
+    result.step = step;
+    if (Math.sign(step) !== Math.sign(end - start)) {
+        return result;
+    }
+    if (step > 0) {
+        for (let i = start; i < end; i += step) {
+            result.push(i);
+        }
+    }
+    if (step < 0) {
+        for (let i = start; i > end; i += step) {
+            result.push(i);
+        }
+    }
+    return result;
 });
-function isTgpuRange(value) {
-	return Array.isArray(value) && "start" in value && "end" in value && "step" in value;
+export function isTgpuRange(value) {
+    return Array.isArray(value) && 'start' in value && 'end' in value && 'step' in value;
 }
-
-//#endregion
-export { isTgpuRange, range };

package/std/subgroup.d.ts

@@ -1,47 +1,43 @@
-import { DualFn } from "../types.js";
-import { AnyIntegerVecInstance, AnyNumericVecInstance, v4u } from "../data/wgslTypes.js";
-
-//#region src/std/subgroup.d.ts
+import type { AnyIntegerVecInstance, AnyNumericVecInstance, v4u } from '../data/wgslTypes.ts';
 interface IdentityNumOrVec {
-  (e: number): number;
-  <T extends AnyNumericVecInstance>(e: T): T;
+    (e: number): number;
+    <T extends AnyNumericVecInstance>(e: T): T;
 }
 interface IdentityIntNumOrVec {
-  (e: number): number;
-  <T extends AnyIntegerVecInstance>(e: T): T;
+    (e: number): number;
+    <T extends AnyIntegerVecInstance>(e: T): T;
 }
 interface IdentityNumOrVecWithIdx {
-  (e: number, index: number): number;
-  <T extends AnyNumericVecInstance>(e: T, index: number): T;
+    (e: number, index: number): number;
+    <T extends AnyNumericVecInstance>(e: T, index: number): T;
 }
 interface IdentityNumOrVecWithDelta {
-  (e: number, delta: number): number;
-  <T extends AnyNumericVecInstance>(e: T, delta: number): T;
+    (e: number, delta: number): number;
+    <T extends AnyNumericVecInstance>(e: T, delta: number): T;
 }
 interface IdentityNumOrVecWithMask {
-  (e: number, mask: number): number;
-  <T extends AnyNumericVecInstance>(e: T, mask: number): T;
+    (e: number, mask: number): number;
+    <T extends AnyNumericVecInstance>(e: T, mask: number): T;
 }
-declare const subgroupAdd: DualFn<IdentityNumOrVec>;
-declare const subgroupExclusiveAdd: DualFn<IdentityNumOrVec>;
-declare const subgroupInclusiveAdd: DualFn<IdentityNumOrVec>;
-declare const subgroupAll: DualFn<(e: boolean) => boolean>;
-declare const subgroupAnd: DualFn<IdentityIntNumOrVec>;
-declare const subgroupAny: DualFn<(e: boolean) => boolean>;
-declare const subgroupBallot: DualFn<(e: boolean) => v4u>;
-declare const subgroupBroadcast: DualFn<IdentityNumOrVecWithIdx>;
-declare const subgroupBroadcastFirst: DualFn<IdentityNumOrVec>;
-declare const subgroupElect: DualFn<() => boolean>;
-declare const subgroupMax: DualFn<IdentityNumOrVec>;
-declare const subgroupMin: DualFn<IdentityNumOrVec>;
-declare const subgroupMul: DualFn<IdentityNumOrVec>;
-declare const subgroupExclusiveMul: DualFn<IdentityNumOrVec>;
-declare const subgroupInclusiveMul: DualFn<IdentityNumOrVec>;
-declare const subgroupOr: DualFn<IdentityIntNumOrVec>;
-declare const subgroupShuffle: DualFn<IdentityNumOrVecWithIdx>;
-declare const subgroupShuffleDown: DualFn<IdentityNumOrVecWithDelta>;
-declare const subgroupShuffleUp: DualFn<IdentityNumOrVecWithDelta>;
-declare const subgroupShuffleXor: DualFn<IdentityNumOrVecWithMask>;
-declare const subgroupXor: DualFn<IdentityIntNumOrVec>;
-//#endregion
-export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };
+export declare const subgroupAdd: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const subgroupExclusiveAdd: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const subgroupInclusiveAdd: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const subgroupAll: import("../types.ts").DualFn<(e: boolean) => boolean>;
+export declare const subgroupAnd: import("../types.ts").DualFn<IdentityIntNumOrVec>;
+export declare const subgroupAny: import("../types.ts").DualFn<(e: boolean) => boolean>;
+export declare const subgroupBallot: import("../types.ts").DualFn<(e: boolean) => v4u>;
+export declare const subgroupBroadcast: import("../types.ts").DualFn<IdentityNumOrVecWithIdx>;
+export declare const subgroupBroadcastFirst: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const subgroupElect: import("../types.ts").DualFn<() => boolean>;
+export declare const subgroupMax: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const subgroupMin: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const subgroupMul: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const subgroupExclusiveMul: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const subgroupInclusiveMul: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const subgroupOr: import("../types.ts").DualFn<IdentityIntNumOrVec>;
+export declare const subgroupShuffle: import("../types.ts").DualFn<IdentityNumOrVecWithIdx>;
+export declare const subgroupShuffleDown: import("../types.ts").DualFn<IdentityNumOrVecWithDelta>;
+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 {};