typegpu 0.11.8 → 0.12.0

package/data/ref.js

@@ -1,109 +1,139 @@
-import { $gpuCallable, $internal, $ownSnippet, $resolve } from "../shared/symbols.js";
-import { isNaturallyEphemeral, isPtr } from "./wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { WgslTypeError } from "../errors.js";
 import { setName } from "../shared/meta.js";
+import { $gpuCallable, $internal, $ownSnippet, $resolve } from "../shared/symbols.js";
 import { UnknownData } from "./dataTypes.js";
-import { isAlias, snip } from "./snippet.js";
-import { WgslTypeError } from "../errors.js";
-import { stitch } from "../core/resolve/stitch.js";
 import { createPtrFromOrigin, explicitFrom } from "./ptr.js";
-
-//#region src/data/ref.ts
-const _ref = (() => {
-	const impl = ((value) => INTERNAL_createRef(value));
-	setName(impl, "ref");
-	impl.toString = () => "ref";
-	impl[$internal] = true;
-	impl[$gpuCallable] = { call(ctx, [value]) {
-		if (value.origin === "argument") throw new WgslTypeError(stitch`d.ref(${value}) is illegal, cannot take a reference of an argument. Copy the value first, and take a reference of the copy.`);
-		if (value.origin === "constant-immutable-def" || value.origin === "runtime-immutable-def") {
-			const typeStr = ctx.resolve(value.dataType).value;
-			throw new WgslTypeError(stitch`d.ref(${value}) is illegal, cannot take a reference to a constant.
+import { isAlias, snip, withDataType } from "./snippet.js";
+import { isNaturallyEphemeral, isPtr } from "./wgslTypes.js";
+export const _ref = (() => {
+    const impl = ((value) => INTERNAL_createRef(value));
+    setName(impl, 'ref');
+    impl.toString = () => 'ref';
+    impl[$internal] = true;
+    impl[$gpuCallable] = {
+        call(ctx, [value]) {
+            if (value.origin === 'argument') {
+                throw new WgslTypeError(stitch `d.ref(${value}) is illegal, cannot take a reference of an argument. Copy the value first, and take a reference of the copy.`);
+            }
+            if (value.origin === 'constant-immutable-def' || value.origin === 'runtime-immutable-def') {
+                const typeStr = ctx.resolve(value.dataType).value;
+                throw new WgslTypeError(stitch `d.ref(${value}) is illegal, cannot take a reference to a constant.
 -----
 - Try 'd.ref(${typeStr}(${value}));' instead to create a new referencable value.
 -----`);
-		}
-		if (isAlias(value) && isNaturallyEphemeral(value.dataType)) {
-			const typeStr = ctx.resolve(value.dataType).value;
-			throw new WgslTypeError(stitch`d.ref(${value}) is illegal, cannot take a reference to a scalar value.
+            }
+            if (isAlias(value) && isNaturallyEphemeral(value.dataType)) {
+                const typeStr = ctx.resolve(value.dataType).value;
+                throw new WgslTypeError(stitch `d.ref(${value}) is illegal, cannot take a reference to a scalar value.
 -----
 - Try 'd.ref(${typeStr}(${value}));' instead to create a new referencable scalar.
 -----`);
-		}
-		if (isPtr(value.dataType)) return snip(value.value, explicitFrom(value.dataType), value.origin);
-		/**
-		* Pointer type only exists if the ref was created from a reference (buttery-butter).
-		*
-		* @example
-		* ```ts
-		* const life = ref(42); // created from a value
-		* const boid = ref(layout.$.boids[0]); // created from a reference
-		* ```
-		*/
-		const ptrType = createPtrFromOrigin(value.origin, value.dataType);
-		return snip(new RefOperator(value, ptrType), ptrType ?? UnknownData, "runtime");
-	} };
-	return impl;
+            }
+            if (isPtr(value.dataType)) {
+                // This can happen if we take a reference of an *implicit* pointer, one
+                // made by assigning a reference to a `const`.
+                return withDataType(explicitFrom(value.dataType), value);
+            }
+            /**
+             * Pointer type only exists if the ref was created from a reference (buttery-butter).
+             *
+             * @example
+             * ```ts
+             * const life = ref(42); // created from a value
+             * const boid = ref(layout.$.boids[0]); // created from a reference
+             * ```
+             */
+            const ptrType = createPtrFromOrigin(value.origin, value.dataType);
+            return snip(new RefOperator(value, ptrType), ptrType ?? UnknownData, 
+            /* origin */ 'runtime', value.possibleSideEffects);
+        },
+    };
+    return impl;
 })();
-function isRef(value) {
-	return value?.[$internal]?.type === "ref";
+export function isRef(value) {
+    return value?.[$internal]?.type === 'ref';
 }
-function INTERNAL_createRef(value) {
-	const target = {
-		[$internal]: { type: "ref" },
-		get $() {
-			return value;
-		},
-		set $(newValue) {
-			if (newValue && typeof newValue === "object") for (const key of Object.keys(newValue)) value[key] = newValue[key];
-			else value = newValue;
-		}
-	};
-	if (value === void 0 || value === null) throw new Error("Cannot create a ref from undefined or null");
-	if (typeof value === "object") return new Proxy(target, {
-		get(target$1, prop) {
-			if (prop in target$1) return target$1[prop];
-			return value[prop];
-		},
-		set(_target, prop, propValue) {
-			if (prop === $internal) return false;
-			if (prop === "$") {
-				console.log("Setting ref value:", propValue);
-				return Reflect.set(target, prop, propValue);
-			}
-			return Reflect.set(value, prop, propValue);
-		}
-	});
-	return target;
+// --------------
+// Implementation
+// --------------
+export function INTERNAL_createRef(value) {
+    const target = {
+        [$internal]: { type: 'ref' },
+        get $() {
+            return value;
+        },
+        set $(newValue) {
+            if (newValue && typeof newValue === 'object') {
+                // Setting an object means updating the properties of the original object.
+                // e.g.: foo.$ = Boid();
+                for (const key of Object.keys(newValue)) {
+                    value[key] = newValue[key];
+                }
+            }
+            else {
+                value = newValue;
+            }
+        },
+    };
+    if (value === undefined || value === null) {
+        throw new Error('Cannot create a ref from undefined or null');
+    }
+    if (typeof value === 'object') {
+        return new Proxy(target, {
+            get(target, prop) {
+                if (prop in target) {
+                    return target[prop];
+                }
+                return value[prop];
+            },
+            set(_target, prop, propValue) {
+                if (prop === $internal) {
+                    return false;
+                }
+                if (prop === '$') {
+                    return Reflect.set(target, prop, propValue);
+                }
+                return Reflect.set(value, prop, propValue);
+            },
+        });
+    }
+    return target;
 }
 /**
-* The result of calling `d.ref(...)`. The code responsible for
-* generating shader code can check if the value of a snippet is
-* an instance of `RefOperator`, and act accordingly.
-*/
-var RefOperator = class {
-	[$internal];
-	snippet;
-	#ptrType;
-	constructor(snippet, ptrType) {
-		this[$internal] = true;
-		this.snippet = snippet;
-		this.#ptrType = ptrType;
-	}
-	get [$ownSnippet]() {
-		if (!this.#ptrType) throw new Error(stitch`Cannot take a reference of ${this.snippet}`);
-		return snip(this, this.#ptrType, this.snippet.origin);
-	}
-	[$resolve]() {
-		if (!this.#ptrType) throw new Error(stitch`Cannot take a reference of ${this.snippet}`);
-		return snip(stitch`(&${this.snippet})`, this.#ptrType, this.snippet.origin);
-	}
-};
-function derefSnippet(snippet) {
-	if (!isPtr(snippet.dataType)) return snippet;
-	const innerType = snippet.dataType.inner;
-	if (snippet.value instanceof RefOperator) return snip(stitch`${snippet.value.snippet}`, innerType, snippet.origin);
-	return snip(stitch`(*${snippet})`, innerType, snippet.origin);
+ * The result of calling `d.ref(...)`. The code responsible for
+ * generating shader code can check if the value of a snippet is
+ * an instance of `RefOperator`, and act accordingly.
+ */
+export class RefOperator {
+    [$internal];
+    snippet;
+    #ptrType;
+    constructor(snippet, ptrType) {
+        this[$internal] = true;
+        this.snippet = snippet;
+        this.#ptrType = ptrType;
+    }
+    get [$ownSnippet]() {
+        if (!this.#ptrType) {
+            throw new Error(stitch `Cannot take a reference of ${this.snippet}`);
+        }
+        return snip(this, this.#ptrType, this.snippet.origin, this.snippet.possibleSideEffects);
+    }
+    [$resolve]() {
+        if (!this.#ptrType) {
+            throw new Error(stitch `Cannot take a reference of ${this.snippet}`);
+        }
+        return snip(stitch `(&${this.snippet})`, this.#ptrType, this.snippet.origin, this.snippet.possibleSideEffects);
+    }
+}
+export function derefSnippet(snippet) {
+    if (!isPtr(snippet.dataType)) {
+        return snippet;
+    }
+    const innerType = snippet.dataType.inner;
+    if (snippet.value instanceof RefOperator) {
+        return snip(stitch `${snippet.value.snippet}`, innerType, snippet.origin, snippet.possibleSideEffects);
+    }
+    return snip(stitch `(*${snippet})`, innerType, snippet.origin, snippet.possibleSideEffects);
 }
-
-//#endregion
-export { RefOperator, _ref, derefSnippet, isRef };

package/data/sampler.d.ts

@@ -1,107 +1,105 @@
-import { $internal, $repr } from "../shared/symbols.js";
-import { BaseData } from "./wgslTypes.js";
-
-//#region src/data/sampler.d.ts
-interface WgslSamplerProps {
-  addressModeU?: GPUAddressMode;
-  addressModeV?: GPUAddressMode;
-  /**
-   * Specifies the address modes for the texture width, height, and depth
-   * coordinates, respectively.
-   */
-  addressModeW?: GPUAddressMode;
-  /**
-   * Specifies the sampling behavior when the sample footprint is smaller than or equal to one
-   * texel.
-   */
-  magFilter?: GPUFilterMode;
-  /**
-   * Specifies the sampling behavior when the sample footprint is larger than one texel.
-   */
-  minFilter?: GPUFilterMode;
-  /**
-   * Specifies behavior for sampling between mipmap levels.
-   */
-  mipmapFilter?: GPUMipmapFilterMode;
-  lodMinClamp?: number;
-  /**
-   * Specifies the minimum and maximum levels of detail, respectively, used internally when
-   * sampling a texture.
-   */
-  lodMaxClamp?: number;
-  /**
-   * Specifies the maximum anisotropy value clamp used by the sampler. Anisotropic filtering is
-   * enabled when {@link GPUSamplerDescriptor.maxAnisotropy} is > 1 and the implementation supports it.
-   * Anisotropic filtering improves the image quality of textures sampled at oblique viewing
-   * angles. Higher {@link GPUSamplerDescriptor.maxAnisotropy} values indicate the maximum ratio of
-   * anisotropy supported when filtering.
-   *
-   * Most implementations support {@link GPUSamplerDescriptor.maxAnisotropy} values in range
-   * between 1 and 16, inclusive. The used value of {@link GPUSamplerDescriptor.maxAnisotropy}
-   * will be clamped to the maximum value that the platform supports.
-   * The precise filtering behavior is implementation-dependent.
-   */
-  maxAnisotropy?: number;
+import { $internal, $repr } from '../shared/symbols.ts';
+import type { BaseData } from './wgslTypes.ts';
+export interface WgslSamplerProps {
+    addressModeU?: GPUAddressMode;
+    addressModeV?: GPUAddressMode;
+    /**
+     * Specifies the address modes for the texture width, height, and depth
+     * coordinates, respectively.
+     */
+    addressModeW?: GPUAddressMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is smaller than or equal to one
+     * texel.
+     */
+    magFilter?: GPUFilterMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is larger than one texel.
+     */
+    minFilter?: GPUFilterMode;
+    /**
+     * Specifies behavior for sampling between mipmap levels.
+     */
+    mipmapFilter?: GPUMipmapFilterMode;
+    lodMinClamp?: number;
+    /**
+     * Specifies the minimum and maximum levels of detail, respectively, used internally when
+     * sampling a texture.
+     */
+    lodMaxClamp?: number;
+    /**
+     * Specifies the maximum anisotropy value clamp used by the sampler. Anisotropic filtering is
+     * enabled when {@link GPUSamplerDescriptor.maxAnisotropy} is > 1 and the implementation supports it.
+     * Anisotropic filtering improves the image quality of textures sampled at oblique viewing
+     * angles. Higher {@link GPUSamplerDescriptor.maxAnisotropy} values indicate the maximum ratio of
+     * anisotropy supported when filtering.
+     *
+     * Most implementations support {@link GPUSamplerDescriptor.maxAnisotropy} values in range
+     * between 1 and 16, inclusive. The used value of {@link GPUSamplerDescriptor.maxAnisotropy}
+     * will be clamped to the maximum value that the platform supports.
+     * The precise filtering behavior is implementation-dependent.
+     */
+    maxAnisotropy?: number;
 }
-interface WgslComparisonSamplerProps {
-  compare: GPUCompareFunction;
-  addressModeU?: GPUAddressMode;
-  addressModeV?: GPUAddressMode;
-  /**
-   * Specifies the address modes for the texture width, height, and depth
-   * coordinates, respectively.
-   */
-  addressModeW?: GPUAddressMode;
-  /**
-   * Specifies the sampling behavior when the sample footprint is smaller than or equal to one
-   * texel.
-   */
-  magFilter?: GPUFilterMode;
-  /**
-   * Specifies the sampling behavior when the sample footprint is larger than one texel.
-   */
-  minFilter?: GPUFilterMode;
-  /**
-   * Specifies behavior for sampling between mipmap levels.
-   */
-  mipmapFilter?: GPUMipmapFilterMode;
-  lodMinClamp?: number;
-  /**
-   * Specifies the minimum and maximum levels of detail, respectively, used internally when
-   * sampling a texture.
-   */
-  lodMaxClamp?: number;
-  /**
-   * Specifies the maximum anisotropy value clamp used by the sampler. Anisotropic filtering is
-   * enabled when {@link GPUSamplerDescriptor.maxAnisotropy} is > 1 and the implementation supports it.
-   * Anisotropic filtering improves the image quality of textures sampled at oblique viewing
-   * angles. Higher {@link GPUSamplerDescriptor.maxAnisotropy} values indicate the maximum ratio of
-   * anisotropy supported when filtering.
-   *
-   * Most implementations support {@link GPUSamplerDescriptor.maxAnisotropy} values in range
-   * between 1 and 16, inclusive. The used value of {@link GPUSamplerDescriptor.maxAnisotropy}
-   * will be clamped to the maximum value that the platform supports.
-   * The precise filtering behavior is implementation-dependent.
-   */
-  maxAnisotropy?: number;
+export interface WgslComparisonSamplerProps {
+    compare: GPUCompareFunction;
+    addressModeU?: GPUAddressMode;
+    addressModeV?: GPUAddressMode;
+    /**
+     * Specifies the address modes for the texture width, height, and depth
+     * coordinates, respectively.
+     */
+    addressModeW?: GPUAddressMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is smaller than or equal to one
+     * texel.
+     */
+    magFilter?: GPUFilterMode;
+    /**
+     * Specifies the sampling behavior when the sample footprint is larger than one texel.
+     */
+    minFilter?: GPUFilterMode;
+    /**
+     * Specifies behavior for sampling between mipmap levels.
+     */
+    mipmapFilter?: GPUMipmapFilterMode;
+    lodMinClamp?: number;
+    /**
+     * Specifies the minimum and maximum levels of detail, respectively, used internally when
+     * sampling a texture.
+     */
+    lodMaxClamp?: number;
+    /**
+     * Specifies the maximum anisotropy value clamp used by the sampler. Anisotropic filtering is
+     * enabled when {@link GPUSamplerDescriptor.maxAnisotropy} is > 1 and the implementation supports it.
+     * Anisotropic filtering improves the image quality of textures sampled at oblique viewing
+     * angles. Higher {@link GPUSamplerDescriptor.maxAnisotropy} values indicate the maximum ratio of
+     * anisotropy supported when filtering.
+     *
+     * Most implementations support {@link GPUSamplerDescriptor.maxAnisotropy} values in range
+     * between 1 and 16, inclusive. The used value of {@link GPUSamplerDescriptor.maxAnisotropy}
+     * will be clamped to the maximum value that the platform supports.
+     * The precise filtering behavior is implementation-dependent.
+     */
+    maxAnisotropy?: number;
 }
-interface sampler {
-  [$internal]: true;
-  type: 'sampler';
+export interface sampler {
+    [$internal]: true;
+    type: 'sampler';
 }
-declare function sampler(): WgslSampler;
-interface comparisonSampler {
-  [$internal]: Record<string, never>;
-  type: 'sampler_comparison';
+export declare function sampler(): WgslSampler;
+export interface comparisonSampler {
+    [$internal]: Record<string, never>;
+    type: 'sampler_comparison';
 }
-declare function comparisonSampler(): WgslComparisonSampler;
-interface WgslSampler extends BaseData {
-  readonly [$repr]: sampler;
-  readonly type: 'sampler';
+export declare function comparisonSampler(): WgslComparisonSampler;
+export interface WgslSampler extends BaseData {
+    readonly [$repr]: sampler;
+    readonly type: 'sampler';
 }
-interface WgslComparisonSampler extends BaseData {
-  readonly [$repr]: comparisonSampler;
-  readonly type: 'sampler_comparison';
+export interface WgslComparisonSampler extends BaseData {
+    readonly [$repr]: comparisonSampler;
+    readonly type: 'sampler_comparison';
 }
-//#endregion
-export { WgslComparisonSampler, WgslComparisonSamplerProps, WgslSampler, WgslSamplerProps, comparisonSampler, sampler };
+export declare function isWgslSampler(value: unknown): value is WgslSampler;
+export declare function isWgslComparisonSampler(value: unknown): value is WgslComparisonSampler;

package/data/sampler.js

@@ -1,26 +1,22 @@
 import { $internal, $repr } from "../shared/symbols.js";
-
-//#region src/data/sampler.ts
-function sampler() {
-	return {
-		[$internal]: {},
-		type: "sampler",
-		[$repr]: void 0
-	};
+export function sampler() {
+    return {
+        [$internal]: {},
+        type: 'sampler',
+        [$repr]: undefined,
+    };
 }
-function comparisonSampler() {
-	return {
-		[$internal]: {},
-		type: "sampler_comparison",
-		[$repr]: void 0
-	};
+export function comparisonSampler() {
+    return {
+        [$internal]: {},
+        type: 'sampler_comparison',
+        [$repr]: undefined,
+    };
 }
-function isWgslSampler(value) {
-	return !!value[$internal] && value.type === "sampler";
+export function isWgslSampler(value) {
+    return !!value[$internal] && value.type === 'sampler';
 }
-function isWgslComparisonSampler(value) {
-	return !!value[$internal] && value.type === "sampler_comparison";
+export function isWgslComparisonSampler(value) {
+    return (!!value[$internal] &&
+        value.type === 'sampler_comparison');
 }
-
-//#endregion
-export { comparisonSampler, isWgslComparisonSampler, isWgslSampler, sampler };

package/data/schemaCallWrapper.d.ts

@@ -0,0 +1,19 @@
+import { type ResolutionCtx } from '../types.ts';
+import type { Snippet } from './snippet.ts';
+import type { BaseData } from './wgslTypes.ts';
+/**
+ * A wrapper for `schema(item)` or `schema()` call on JS side.
+ * If the schema is a pointer, returns the value pointed to without copying.
+ * If the schema is a TgpuVertexFormatData, calls the corresponding constructible schema instead.
+ * If the schema is not callable, throws an error.
+ * Otherwise, returns `schema(item)` or `schema()`.
+ */
+export declare function schemaCallWrapper<T>(schema: BaseData, item?: T): T;
+/**
+ * A wrapper for `schema(item)` or `schema()` call on the GPU side.
+ * If the schema is a pointer, returns the value pointed to without copying.
+ * If the schema is a TgpuVertexFormatData, calls the corresponding constructible schema instead.
+ * If the schema is not callable, throws an error.
+ * Otherwise, returns `schema(item)` or `schema()`.
+ */
+export declare function schemaCallWrapperGPU(ctx: ResolutionCtx, schema: BaseData, item?: Snippet): Snippet;

package/data/schemaCallWrapper.js

@@ -1,32 +1,37 @@
 import { $cast, $gpuCallable } from "../shared/symbols.js";
 import { hasCast, isGPUCallable } from "../types.js";
-
-//#region src/data/schemaCallWrapper.ts
 /**
-* A wrapper for `schema(item)` or `schema()` call on JS side.
-* If the schema is a pointer, returns the value pointed to without copying.
-* If the schema is a TgpuVertexFormatData, calls the corresponding constructible schema instead.
-* If the schema is not callable, throws an error.
-* Otherwise, returns `schema(item)` or `schema()`.
-*/
-function schemaCallWrapper(schema, item) {
-	const callSchema = schema;
-	if (hasCast(callSchema)) return callSchema[$cast](item);
-	if (typeof callSchema !== "function") return item;
-	return item === void 0 ? callSchema() : callSchema(item);
+ * A wrapper for `schema(item)` or `schema()` call on JS side.
+ * If the schema is a pointer, returns the value pointed to without copying.
+ * If the schema is a TgpuVertexFormatData, calls the corresponding constructible schema instead.
+ * If the schema is not callable, throws an error.
+ * Otherwise, returns `schema(item)` or `schema()`.
+ */
+export function schemaCallWrapper(schema, item) {
+    const callSchema = schema;
+    if (hasCast(callSchema)) {
+        return callSchema[$cast](item);
+    }
+    if (typeof callSchema !== 'function') {
+        // Not callable
+        return item;
+    }
+    return item === undefined ? callSchema() : callSchema(item);
 }
 /**
-* A wrapper for `schema(item)` or `schema()` call on the GPU side.
-* If the schema is a pointer, returns the value pointed to without copying.
-* If the schema is a TgpuVertexFormatData, calls the corresponding constructible schema instead.
-* If the schema is not callable, throws an error.
-* Otherwise, returns `schema(item)` or `schema()`.
-*/
-function schemaCallWrapperGPU(ctx, schema, item) {
-	if (!isGPUCallable(schema)) return item;
-	const callSchema = schema;
-	return item === void 0 || item.value === void 0 ? callSchema[$gpuCallable].call(ctx, []) : callSchema[$gpuCallable].call(ctx, [item]);
+ * A wrapper for `schema(item)` or `schema()` call on the GPU side.
+ * If the schema is a pointer, returns the value pointed to without copying.
+ * If the schema is a TgpuVertexFormatData, calls the corresponding constructible schema instead.
+ * If the schema is not callable, throws an error.
+ * Otherwise, returns `schema(item)` or `schema()`.
+ */
+export function schemaCallWrapperGPU(ctx, schema, item) {
+    if (!isGPUCallable(schema)) {
+        // Not callable
+        return item;
+    }
+    const callSchema = schema;
+    return item === undefined || item.value === undefined
+        ? callSchema[$gpuCallable].call(ctx, [])
+        : callSchema[$gpuCallable].call(ctx, [item]);
 }
-
-//#endregion
-export { schemaCallWrapper, schemaCallWrapperGPU };

package/data/schemaMemoryLayout.d.ts

@@ -0,0 +1,8 @@
+import type { BaseData } from './wgslTypes.ts';
+interface SchemaMemoryLayout {
+    isContiguous: boolean;
+    size: number;
+    longestContiguousPrefix: number;
+}
+export declare function getLayoutInfo<T extends keyof SchemaMemoryLayout>(schema: BaseData, key: T): SchemaMemoryLayout[T];
+export {};