typegpu 0.11.9 → 0.12.1

package/data/texture.js

@@ -1,208 +1,246 @@
 import { $internal, $repr } from "../shared/symbols.js";
 import { f32 } from "./numeric.js";
-
-//#region src/data/texture.ts
-function textureDescriptorToSchema(desc) {
-	if ("multisampled" in desc) {
-		if (desc.multisampled) {
-			if (desc.dimension === "2d") return textureMultisampled2d(desc.sampleType);
-			throw new Error(`Multisampled textures only support '2d' dimension, got '${desc.dimension}'`);
-		}
-		switch (desc.dimension) {
-			case "1d": return texture1d(desc.sampleType);
-			case "2d": return texture2d(desc.sampleType);
-			case "2d-array": return texture2dArray(desc.sampleType);
-			case "3d": return texture3d(desc.sampleType);
-			case "cube": return textureCube(desc.sampleType);
-			case "cube-array": return textureCubeArray(desc.sampleType);
-			default: throw new Error(`Unsupported texture dimension: '${desc.dimension}'`);
-		}
-	}
-	if (!("access" in desc)) throw new Error("Descriptor is neither a sampled nor a storage texture");
-	switch (desc.dimension) {
-		case "1d": return textureStorage1d(desc.format, desc.access);
-		case "2d": return textureStorage2d(desc.format, desc.access);
-		case "2d-array": return textureStorage2dArray(desc.format, desc.access);
-		case "3d": return textureStorage3d(desc.format, desc.access);
-		default: throw new Error(`Unsupported storage texture dimension: '${desc.dimension}'`);
-	}
+export function textureDescriptorToSchema(desc) {
+    if ('multisampled' in desc) {
+        if (desc.multisampled) {
+            if (desc.dimension === '2d') {
+                return textureMultisampled2d(desc.sampleType);
+            }
+            throw new Error(`Multisampled textures only support '2d' dimension, got '${desc.dimension}'`);
+        }
+        switch (desc.dimension) {
+            case '1d':
+                return texture1d(desc.sampleType);
+            case '2d':
+                return texture2d(desc.sampleType);
+            case '2d-array':
+                return texture2dArray(desc.sampleType);
+            case '3d':
+                return texture3d(desc.sampleType);
+            case 'cube':
+                return textureCube(desc.sampleType);
+            case 'cube-array':
+                return textureCubeArray(desc.sampleType);
+            default:
+                throw new Error(
+                // @ts-expect-error
+                `Unsupported texture dimension: '${desc.dimension}'`);
+        }
+    }
+    if (!('access' in desc)) {
+        throw new Error('Descriptor is neither a sampled nor a storage texture');
+    }
+    switch (desc.dimension) {
+        case '1d':
+            return textureStorage1d(desc.format, desc.access);
+        case '2d':
+            return textureStorage2d(desc.format, desc.access);
+        case '2d-array':
+            return textureStorage2dArray(desc.format, desc.access);
+        case '3d':
+            return textureStorage3d(desc.format, desc.access);
+        default:
+            throw new Error(
+            // @ts-expect-error
+            `Unsupported storage texture dimension: '${desc.dimension}'`);
+    }
 }
 function createTexture(type, props) {
-	const sampleTypes = type.startsWith("texture_depth") ? [
-		"depth",
-		"float",
-		"unfilterable-float"
-	] : props.sampleType.type === "i32" ? ["sint"] : props.sampleType.type === "u32" ? ["uint"] : ["float", "unfilterable-float"];
-	return {
-		[$internal]: {},
-		[$repr]: void 0,
-		type,
-		bindingSampleType: sampleTypes,
-		...props
-	};
+    const isDepth = type.startsWith('texture_depth');
+    const sampleTypes = isDepth
+        ? ['depth', 'float', 'unfilterable-float']
+        : props.sampleType.type === 'i32'
+            ? ['sint']
+            : props.sampleType.type === 'u32'
+                ? ['uint']
+                : ['float', 'unfilterable-float'];
+    return {
+        [$internal]: {},
+        [$repr]: undefined,
+        type,
+        bindingSampleType: sampleTypes,
+        ...props,
+    };
 }
 function createStorageTexture(type, props) {
-	return {
-		[$internal]: {},
-		[$repr]: void 0,
-		type,
-		...props
-	};
-}
-const textureCache = /* @__PURE__ */ new Map();
-const accessModeMap = {
-	"write-only": "write",
-	"read-only": "read",
-	"read-write": "read_write"
+    return {
+        [$internal]: {},
+        [$repr]: undefined,
+        type,
+        ...props,
+    };
+}
+const textureCache = new Map();
+export const accessModeMap = {
+    'write-only': 'write',
+    'read-only': 'read',
+    'read-write': 'read_write',
 };
 function getOrCreate(key, factory) {
-	let cached = textureCache.get(key);
-	if (!cached) {
-		cached = factory();
-		textureCache.set(key, cached);
-	}
-	return cached;
-}
-function texture1d(sampleType) {
-	const actualSampleType = sampleType || f32;
-	return getOrCreate(`texture_1d<${actualSampleType.type}>`, () => createTexture("texture_1d", {
-		dimension: "1d",
-		sampleType: actualSampleType,
-		multisampled: false
-	}));
-}
-function texture2d(sampleType) {
-	const actualSampleType = sampleType || f32;
-	return getOrCreate(`texture_2d<${actualSampleType.type}>`, () => createTexture("texture_2d", {
-		dimension: "2d",
-		sampleType: actualSampleType,
-		multisampled: false
-	}));
-}
-function textureMultisampled2d(sampleType) {
-	const actualSampleType = sampleType || f32;
-	return getOrCreate(`texture_multisampled_2d<${actualSampleType.type}>`, () => createTexture("texture_multisampled_2d", {
-		dimension: "2d",
-		sampleType: actualSampleType,
-		multisampled: true
-	}));
-}
-function texture2dArray(sampleType) {
-	const actualSampleType = sampleType || f32;
-	return getOrCreate(`texture_2d_array<${actualSampleType.type}>`, () => createTexture("texture_2d_array", {
-		dimension: "2d-array",
-		sampleType: actualSampleType,
-		multisampled: false
-	}));
-}
-function textureCube(sampleType) {
-	const actualSampleType = sampleType || f32;
-	return getOrCreate(`texture_cube<${actualSampleType.type}>`, () => createTexture("texture_cube", {
-		dimension: "cube",
-		sampleType: actualSampleType,
-		multisampled: false
-	}));
-}
-function textureCubeArray(sampleType) {
-	const actualSampleType = sampleType || f32;
-	return getOrCreate(`texture_cube_array<${actualSampleType.type}>`, () => createTexture("texture_cube_array", {
-		dimension: "cube-array",
-		sampleType: actualSampleType,
-		multisampled: false
-	}));
-}
-function texture3d(sampleType) {
-	const actualSampleType = sampleType || f32;
-	return getOrCreate(`texture_3d<${actualSampleType.type}>`, () => createTexture("texture_3d", {
-		dimension: "3d",
-		sampleType: actualSampleType,
-		multisampled: false
-	}));
-}
-function textureStorage1d(format, access) {
-	const actualAccess = access || "write-only";
-	return getOrCreate(`texture_storage_1d<${format}, ${accessModeMap[actualAccess]}>`, () => createStorageTexture("texture_storage_1d", {
-		dimension: "1d",
-		format,
-		access: actualAccess
-	}));
-}
-function textureStorage2d(format, access) {
-	const actualAccess = access || "write-only";
-	return getOrCreate(`texture_storage_2d<${format}, ${accessModeMap[actualAccess]}>`, () => createStorageTexture("texture_storage_2d", {
-		dimension: "2d",
-		format,
-		access: actualAccess
-	}));
-}
-function textureStorage2dArray(format, access) {
-	const actualAccess = access || "write-only";
-	return getOrCreate(`texture_storage_2d_array<${format}, ${accessModeMap[actualAccess]}>`, () => createStorageTexture("texture_storage_2d_array", {
-		dimension: "2d-array",
-		format,
-		access: actualAccess
-	}));
-}
-function textureStorage3d(format, access) {
-	const actualAccess = access || "write-only";
-	return getOrCreate(`texture_storage_3d<${format}, ${accessModeMap[actualAccess]}>`, () => createStorageTexture("texture_storage_3d", {
-		dimension: "3d",
-		format,
-		access: actualAccess
-	}));
-}
-function textureDepth2d() {
-	return getOrCreate("texture_depth_2d", () => createTexture("texture_depth_2d", {
-		dimension: "2d",
-		sampleType: f32,
-		multisampled: false
-	}));
-}
-function textureDepthMultisampled2d() {
-	return getOrCreate("texture_depth_multisampled_2d", () => createTexture("texture_depth_multisampled_2d", {
-		dimension: "2d",
-		sampleType: f32,
-		multisampled: true
-	}));
-}
-function textureDepth2dArray() {
-	return getOrCreate("texture_depth_2d_array", () => createTexture("texture_depth_2d_array", {
-		dimension: "2d-array",
-		sampleType: f32,
-		multisampled: false
-	}));
-}
-function textureDepthCube() {
-	return getOrCreate("texture_depth_cube", () => createTexture("texture_depth_cube", {
-		dimension: "cube",
-		sampleType: f32,
-		multisampled: false
-	}));
-}
-function textureDepthCubeArray() {
-	return getOrCreate("texture_depth_cube_array", () => createTexture("texture_depth_cube_array", {
-		dimension: "cube-array",
-		sampleType: f32,
-		multisampled: false
-	}));
-}
-function textureExternal() {
-	return getOrCreate("texture_external", () => ({
-		[$internal]: {},
-		[$repr]: void 0,
-		type: "texture_external",
-		dimension: "2d"
-	}));
-}
-function isWgslTexture(value) {
-	return !!value[$internal] && typeof value.multisampled === "boolean";
-}
-function isWgslStorageTexture(value) {
-	return !!value[$internal] && typeof value.format === "string" && typeof value.access === "string";
-}
-function isWgslExternalTexture(value) {
-	return !!value[$internal] && value.type === "texture_external";
-}
-
-//#endregion
-export { accessModeMap, isWgslExternalTexture, isWgslStorageTexture, isWgslTexture, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureDescriptorToSchema, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d };
+    let cached = textureCache.get(key);
+    if (!cached) {
+        cached = factory();
+        textureCache.set(key, cached);
+    }
+    return cached;
+}
+export function texture1d(sampleType) {
+    const actualSampleType = (sampleType || f32);
+    const key = `texture_1d<${actualSampleType.type}>`;
+    return getOrCreate(key, () => createTexture('texture_1d', {
+        dimension: '1d',
+        sampleType: actualSampleType,
+        multisampled: false,
+    }));
+}
+export function texture2d(sampleType) {
+    const actualSampleType = (sampleType || f32);
+    const key = `texture_2d<${actualSampleType.type}>`;
+    return getOrCreate(key, () => createTexture('texture_2d', {
+        dimension: '2d',
+        sampleType: actualSampleType,
+        multisampled: false,
+    }));
+}
+export function textureMultisampled2d(sampleType) {
+    const actualSampleType = (sampleType || f32);
+    const key = `texture_multisampled_2d<${actualSampleType.type}>`;
+    return getOrCreate(key, () => createTexture('texture_multisampled_2d', {
+        dimension: '2d',
+        sampleType: actualSampleType,
+        multisampled: true,
+    }));
+}
+export function texture2dArray(sampleType) {
+    const actualSampleType = (sampleType || f32);
+    const key = `texture_2d_array<${actualSampleType.type}>`;
+    return getOrCreate(key, () => createTexture('texture_2d_array', {
+        dimension: '2d-array',
+        sampleType: actualSampleType,
+        multisampled: false,
+    }));
+}
+export function textureCube(sampleType) {
+    const actualSampleType = (sampleType || f32);
+    const key = `texture_cube<${actualSampleType.type}>`;
+    return getOrCreate(key, () => createTexture('texture_cube', {
+        dimension: 'cube',
+        sampleType: actualSampleType,
+        multisampled: false,
+    }));
+}
+export function textureCubeArray(sampleType) {
+    const actualSampleType = (sampleType || f32);
+    const key = `texture_cube_array<${actualSampleType.type}>`;
+    return getOrCreate(key, () => createTexture('texture_cube_array', {
+        dimension: 'cube-array',
+        sampleType: actualSampleType,
+        multisampled: false,
+    }));
+}
+export function texture3d(sampleType) {
+    const actualSampleType = (sampleType || f32);
+    const key = `texture_3d<${actualSampleType.type}>`;
+    return getOrCreate(key, () => createTexture('texture_3d', {
+        dimension: '3d',
+        sampleType: actualSampleType,
+        multisampled: false,
+    }));
+}
+export function textureStorage1d(format, access) {
+    const actualAccess = (access || 'write-only');
+    const key = `texture_storage_1d<${format}, ${accessModeMap[actualAccess]}>`;
+    return getOrCreate(key, () => createStorageTexture('texture_storage_1d', {
+        dimension: '1d',
+        format,
+        access: actualAccess,
+    }));
+}
+export function textureStorage2d(format, access) {
+    const actualAccess = (access || 'write-only');
+    const key = `texture_storage_2d<${format}, ${accessModeMap[actualAccess]}>`;
+    return getOrCreate(key, () => createStorageTexture('texture_storage_2d', {
+        dimension: '2d',
+        format,
+        access: actualAccess,
+    }));
+}
+export function textureStorage2dArray(format, access) {
+    const actualAccess = (access || 'write-only');
+    const key = `texture_storage_2d_array<${format}, ${accessModeMap[actualAccess]}>`;
+    return getOrCreate(key, () => createStorageTexture('texture_storage_2d_array', {
+        dimension: '2d-array',
+        format,
+        access: actualAccess,
+    }));
+}
+export function textureStorage3d(format, access) {
+    const actualAccess = (access || 'write-only');
+    const key = `texture_storage_3d<${format}, ${accessModeMap[actualAccess]}>`;
+    return getOrCreate(key, () => createStorageTexture('texture_storage_3d', {
+        dimension: '3d',
+        format,
+        access: actualAccess,
+    }));
+}
+export function textureDepth2d() {
+    const key = 'texture_depth_2d';
+    return getOrCreate(key, () => createTexture('texture_depth_2d', {
+        dimension: '2d',
+        sampleType: f32,
+        multisampled: false,
+    }));
+}
+export function textureDepthMultisampled2d() {
+    const key = 'texture_depth_multisampled_2d';
+    return getOrCreate(key, () => createTexture('texture_depth_multisampled_2d', {
+        dimension: '2d',
+        sampleType: f32,
+        multisampled: true,
+    }));
+}
+export function textureDepth2dArray() {
+    const key = 'texture_depth_2d_array';
+    return getOrCreate(key, () => createTexture('texture_depth_2d_array', {
+        dimension: '2d-array',
+        sampleType: f32,
+        multisampled: false,
+    }));
+}
+export function textureDepthCube() {
+    const key = 'texture_depth_cube';
+    return getOrCreate(key, () => createTexture('texture_depth_cube', {
+        dimension: 'cube',
+        sampleType: f32,
+        multisampled: false,
+    }));
+}
+export function textureDepthCubeArray() {
+    const key = 'texture_depth_cube_array';
+    return getOrCreate(key, () => createTexture('texture_depth_cube_array', {
+        dimension: 'cube-array',
+        sampleType: f32,
+        multisampled: false,
+    }));
+}
+export function textureExternal() {
+    const key = 'texture_external';
+    return getOrCreate(key, () => ({
+        [$internal]: {},
+        [$repr]: undefined,
+        type: 'texture_external',
+        dimension: '2d',
+    }));
+}
+export function isWgslTexture(value) {
+    return (!!value[$internal] && typeof value.multisampled === 'boolean');
+}
+export function isWgslStorageTexture(value) {
+    return (!!value[$internal] &&
+        typeof value.format === 'string' &&
+        typeof value.access === 'string');
+}
+export function isWgslExternalTexture(value) {
+    return (!!value[$internal] &&
+        value.type === 'texture_external');
+}

package/data/unstruct.d.ts

@@ -1,7 +1,4 @@
-import { AnyData, Unstruct } from "./dataTypes.js";
-
-//#region src/data/unstruct.d.ts
-
+import type { AnyData, Unstruct } from './dataTypes.ts';
 /**
  * Creates a loose struct schema that can be used to construct vertex buffers.
  * Describes structs with members of both loose and non-loose types.
@@ -20,6 +17,4 @@ import { AnyData, Unstruct } from "./dataTypes.js";
  * @param properties Record with `string` keys and `TgpuData` or `TgpuLooseData` values,
  * each entry describing one struct member.
  */
-declare function unstruct<TProps extends Record<string, AnyData>>(properties: TProps): Unstruct<TProps>;
-//#endregion
-export { unstruct };
+export declare function unstruct<TProps extends Record<string, AnyData>>(properties: TProps): Unstruct<TProps>;

package/data/unstruct.js

@@ -1,43 +1,49 @@
-import { $internal } from "../shared/symbols.js";
 import { getName, setName } from "../shared/meta.js";
+import { $internal } from "../shared/symbols.js";
 import { schemaCallWrapper } from "./schemaCallWrapper.js";
-
-//#region src/data/unstruct.ts
+// ----------
+// Public API
+// ----------
 /**
-* Creates a loose struct schema that can be used to construct vertex buffers.
-* Describes structs with members of both loose and non-loose types.
-*
-* The order of members matches the passed in properties object.
-* Members are not aligned in respect to their `byteAlignment`,
-* unless they are explicitly decorated with the custom align attribute
-* via `d.align` function.
-*
-* @example
-* const CircleStruct = d.unstruct({ radius: d.f32, pos: d.vec3f }); // packed struct with no padding
-*
-* @example
-* const CircleStruct = d.unstruct({ radius: d.f32, pos: d.align(16, d.vec3f) });
-*
-* @param properties Record with `string` keys and `TgpuData` or `TgpuLooseData` values,
-* each entry describing one struct member.
-*/
-function unstruct(properties) {
-	const unstructSchema = (instanceProps) => Object.fromEntries(Object.entries(properties).map(([key, schema]) => [key, schemaCallWrapper(schema, instanceProps?.[key])]));
-	Object.setPrototypeOf(unstructSchema, UnstructImpl);
-	unstructSchema.propTypes = properties;
-	return unstructSchema;
+ * Creates a loose struct schema that can be used to construct vertex buffers.
+ * Describes structs with members of both loose and non-loose types.
+ *
+ * The order of members matches the passed in properties object.
+ * Members are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
+ *
+ * @example
+ * const CircleStruct = d.unstruct({ radius: d.f32, pos: d.vec3f }); // packed struct with no padding
+ *
+ * @example
+ * const CircleStruct = d.unstruct({ radius: d.f32, pos: d.align(16, d.vec3f) });
+ *
+ * @param properties Record with `string` keys and `TgpuData` or `TgpuLooseData` values,
+ * each entry describing one struct member.
+ */
+export function unstruct(properties) {
+    // In the schema call, create and return a deep copy
+    // by wrapping all the values in corresponding schema calls.
+    const unstructSchema = (instanceProps) => Object.fromEntries(Object.entries(properties).map(([key, schema]) => [
+        key,
+        schemaCallWrapper(schema, instanceProps?.[key]),
+    ]));
+    Object.setPrototypeOf(unstructSchema, UnstructImpl);
+    unstructSchema.propTypes = properties;
+    return unstructSchema;
 }
+// --------------
+// Implementation
+// --------------
 const UnstructImpl = {
-	[$internal]: true,
-	type: "unstruct",
-	$name(label) {
-		setName(this, label);
-		return this;
-	},
-	toString() {
-		return `unstruct:${getName(this) ?? "<unnamed>"}`;
-	}
+    [$internal]: true,
+    type: 'unstruct',
+    $name(label) {
+        setName(this, label);
+        return this;
+    },
+    toString() {
+        return `unstruct:${getName(this) ?? '<unnamed>'}`;
+    },
 };
-
-//#endregion
-export { unstruct };