typegpu 0.9.0 → 0.10.0

package/builtin-ClEnM-Ye.js

@@ -0,0 +1,818 @@
+import { An as isAlignAttrib, At as stitch, B as vec2h, Bn as isNaturallyEphemeral, Cn as isDisarray, Dn as undecorate, En as isUnstruct, G as vec3h, H as vec2u, Hn as isSizeAttrib, J as vec4b, Jn as isWgslData, K as vec3i, Kn as isVoid, L as isValidProp, Ln as isMat, M as INTERNAL_createStruct, Mn as isBuiltinAttrib, Nn as isDecorated, O as coerceToSnippet, Q as vec4u, R as vec2b, Sn as isData, Tn as isLooseDecorated, U as vec3b, Un as isVec, V as vec2i, Vn as isPtr, W as vec3f, Wt as isKnownAtComptime, X as vec4h, Y as vec4f, Yn as isWgslStruct, Z as vec4i, _n as MatrixColumnsAccess, _t as schemaCallWrapperGPU, at as i32, bn as getCustomLocation, bt as derefSnippet, cr as $internal, dn as isEphemeralSnippet, er as getName, fr as $resolve, gn as InfixDispatch, gt as schemaCallWrapper, ht as safeStringify, i as mul, ir as $cast, it as f32, mn as snip, n as div, nt as bool, o as sub, or as $gpuCallable, pr as isMarkedInternal, q as vec3u, qn as isWgslArray, r as mod, rr as setName, rt as f16, st as u32, t as add, tt as abstractInt, vn as UnknownData, w as comptime, wn as isLooseData, xn as getCustomSize, yn as getCustomAlignment, z as vec2f } from "./operators-HTxa_0k9.js";
+
+//#region src/data/vertexFormatData.ts
+var TgpuVertexFormatDataImpl = class {
+	[$internal] = {};
+	[$gpuCallable];
+	constructor(type) {
+		this.type = type;
+		this[$gpuCallable] = { call: (ctx, [v]) => {
+			return schemaCallWrapperGPU(ctx, formatToWGSLType[this.type], v);
+		} };
+	}
+	[$cast](v) {
+		return schemaCallWrapper(formatToWGSLType[this.type], v);
+	}
+};
+const formatToWGSLType = {
+	uint8: u32,
+	uint8x2: vec2u,
+	uint8x4: vec4u,
+	sint8: i32,
+	sint8x2: vec2i,
+	sint8x4: vec4i,
+	unorm8: f32,
+	unorm8x2: vec2f,
+	unorm8x4: vec4f,
+	snorm8: f32,
+	snorm8x2: vec2f,
+	snorm8x4: vec4f,
+	uint16: u32,
+	uint16x2: vec2u,
+	uint16x4: vec4u,
+	sint16: i32,
+	sint16x2: vec2i,
+	sint16x4: vec4i,
+	unorm16: f32,
+	unorm16x2: vec2f,
+	unorm16x4: vec4f,
+	snorm16: f32,
+	snorm16x2: vec2f,
+	snorm16x4: vec4f,
+	float16: f32,
+	float16x2: vec2f,
+	float16x4: vec4f,
+	float32: f32,
+	float32x2: vec2f,
+	float32x3: vec3f,
+	float32x4: vec4f,
+	uint32: u32,
+	uint32x2: vec2u,
+	uint32x3: vec3u,
+	uint32x4: vec4u,
+	sint32: i32,
+	sint32x2: vec2i,
+	sint32x3: vec3i,
+	sint32x4: vec4i,
+	"unorm10-10-10-2": vec4f,
+	"unorm8x4-bgra": vec4f
+};
+const packedFormats = new Set(Object.keys(formatToWGSLType));
+const uint8 = new TgpuVertexFormatDataImpl("uint8");
+const uint8x2 = new TgpuVertexFormatDataImpl("uint8x2");
+const uint8x4 = new TgpuVertexFormatDataImpl("uint8x4");
+const sint8 = new TgpuVertexFormatDataImpl("sint8");
+const sint8x2 = new TgpuVertexFormatDataImpl("sint8x2");
+const sint8x4 = new TgpuVertexFormatDataImpl("sint8x4");
+const unorm8 = new TgpuVertexFormatDataImpl("unorm8");
+const unorm8x2 = new TgpuVertexFormatDataImpl("unorm8x2");
+const unorm8x4 = new TgpuVertexFormatDataImpl("unorm8x4");
+const snorm8 = new TgpuVertexFormatDataImpl("snorm8");
+const snorm8x2 = new TgpuVertexFormatDataImpl("snorm8x2");
+const snorm8x4 = new TgpuVertexFormatDataImpl("snorm8x4");
+const uint16 = new TgpuVertexFormatDataImpl("uint16");
+const uint16x2 = new TgpuVertexFormatDataImpl("uint16x2");
+const uint16x4 = new TgpuVertexFormatDataImpl("uint16x4");
+const sint16 = new TgpuVertexFormatDataImpl("sint16");
+const sint16x2 = new TgpuVertexFormatDataImpl("sint16x2");
+const sint16x4 = new TgpuVertexFormatDataImpl("sint16x4");
+const unorm16 = new TgpuVertexFormatDataImpl("unorm16");
+const unorm16x2 = new TgpuVertexFormatDataImpl("unorm16x2");
+const unorm16x4 = new TgpuVertexFormatDataImpl("unorm16x4");
+const snorm16 = new TgpuVertexFormatDataImpl("snorm16");
+const snorm16x2 = new TgpuVertexFormatDataImpl("snorm16x2");
+const snorm16x4 = new TgpuVertexFormatDataImpl("snorm16x4");
+const float16 = new TgpuVertexFormatDataImpl("float16");
+const float16x2 = new TgpuVertexFormatDataImpl("float16x2");
+const float16x4 = new TgpuVertexFormatDataImpl("float16x4");
+const float32 = new TgpuVertexFormatDataImpl("float32");
+const float32x2 = new TgpuVertexFormatDataImpl("float32x2");
+const float32x3 = new TgpuVertexFormatDataImpl("float32x3");
+const float32x4 = new TgpuVertexFormatDataImpl("float32x4");
+const uint32 = new TgpuVertexFormatDataImpl("uint32");
+const uint32x2 = new TgpuVertexFormatDataImpl("uint32x2");
+const uint32x3 = new TgpuVertexFormatDataImpl("uint32x3");
+const uint32x4 = new TgpuVertexFormatDataImpl("uint32x4");
+const sint32 = new TgpuVertexFormatDataImpl("sint32");
+const sint32x2 = new TgpuVertexFormatDataImpl("sint32x2");
+const sint32x3 = new TgpuVertexFormatDataImpl("sint32x3");
+const sint32x4 = new TgpuVertexFormatDataImpl("sint32x4");
+const unorm10_10_10_2 = new TgpuVertexFormatDataImpl("unorm10-10-10-2");
+const unorm8x4_bgra = new TgpuVertexFormatDataImpl("unorm8x4-bgra");
+function isPackedData(value) {
+	return isMarkedInternal(value) && packedFormats.has(value?.type);
+}
+
+//#endregion
+//#region src/data/alignmentOf.ts
+const knownAlignmentMap = {
+	f32: 4,
+	f16: 2,
+	i32: 4,
+	u32: 4,
+	bool: 4,
+	u16: 2,
+	vec2f: 8,
+	vec2h: 4,
+	vec2i: 8,
+	vec2u: 8,
+	"vec2<bool>": 8,
+	vec3f: 16,
+	vec3h: 8,
+	vec3i: 16,
+	vec3u: 16,
+	"vec3<bool>": 16,
+	vec4f: 16,
+	vec4h: 8,
+	vec4i: 16,
+	vec4u: 16,
+	"vec4<bool>": 16,
+	mat2x2f: 8,
+	mat3x3f: 16,
+	mat4x4f: 16,
+	atomic: 4
+};
+function computeAlignment(data) {
+	const dataType = data?.type;
+	const knownAlignment = knownAlignmentMap[dataType];
+	if (knownAlignment !== void 0) return knownAlignment;
+	if (isWgslStruct(data)) return Object.values(data.propTypes).map(alignmentOf).reduce((a, b) => a > b ? a : b);
+	if (isWgslArray(data)) return alignmentOf(data.elementType);
+	if (isUnstruct(data)) {
+		const firstProp = Object.values(data.propTypes)[0];
+		return firstProp ? getCustomAlignment(firstProp) ?? 1 : 1;
+	}
+	if (isDisarray(data)) return getCustomAlignment(data.elementType) ?? 1;
+	if (isDecorated(data) || isLooseDecorated(data)) return getCustomAlignment(data) ?? alignmentOf(data.inner);
+	if (packedFormats.has(dataType)) return 1;
+	throw new Error(`Cannot determine alignment of data: ${safeStringify(data)}`);
+}
+function computeCustomAlignment(data) {
+	if (isUnstruct(data)) {
+		const firstProp = Object.values(data.propTypes)[0];
+		return firstProp ? customAlignmentOf(firstProp) : 1;
+	}
+	if (isDisarray(data)) return customAlignmentOf(data.elementType);
+	if (isLooseDecorated(data)) return getCustomAlignment(data) ?? customAlignmentOf(data.inner);
+	return getCustomAlignment(data) ?? 1;
+}
+/**
+* Since alignments can be inferred from data types, they are not stored on them.
+* Instead, this weak map acts as an extended property of those data types.
+*/
+const cachedAlignments = /* @__PURE__ */ new WeakMap();
+const cachedCustomAlignments = /* @__PURE__ */ new WeakMap();
+function alignmentOf(data) {
+	let alignment = cachedAlignments.get(data);
+	if (alignment === void 0) {
+		alignment = computeAlignment(data);
+		cachedAlignments.set(data, alignment);
+	}
+	return alignment;
+}
+function customAlignmentOf(data) {
+	let alignment = cachedCustomAlignments.get(data);
+	if (alignment === void 0) {
+		alignment = computeCustomAlignment(data);
+		cachedCustomAlignments.set(data, alignment);
+	}
+	return alignment;
+}
+/**
+* Returns the alignment (in bytes) of data represented by the `schema`.
+*/
+function PUBLIC_alignmentOf(schema) {
+	return alignmentOf(schema);
+}
+
+//#endregion
+//#region src/mathUtils.ts
+/**
+* @param value
+* @param modulo has to be power of 2
+*/
+const roundUp = (value, modulo) => {
+	const bitMask = modulo - 1;
+	const invBitMask = ~bitMask;
+	return (value & bitMask) === 0 ? value : (value & invBitMask) + modulo;
+};
+
+//#endregion
+//#region src/data/schemaMemoryLayout.ts
+const knownSizesMap = {
+	bool: 4,
+	f32: 4,
+	f16: 2,
+	i32: 4,
+	u32: 4,
+	u16: 2,
+	vec2f: 8,
+	vec2h: 4,
+	vec2i: 8,
+	vec2u: 8,
+	"vec2<bool>": 8,
+	vec3f: 12,
+	vec3h: 6,
+	vec3i: 12,
+	vec3u: 12,
+	"vec3<bool>": 12,
+	vec4f: 16,
+	vec4h: 8,
+	vec4i: 16,
+	vec4u: 16,
+	"vec4<bool>": 16,
+	mat2x2f: 16,
+	mat3x3f: 48,
+	mat4x4f: 64,
+	uint8: 1,
+	uint8x2: 2,
+	uint8x4: 4,
+	sint8: 1,
+	sint8x2: 2,
+	sint8x4: 4,
+	unorm8: 1,
+	unorm8x2: 2,
+	unorm8x4: 4,
+	snorm8: 1,
+	snorm8x2: 2,
+	snorm8x4: 4,
+	uint16: 2,
+	uint16x2: 4,
+	uint16x4: 8,
+	sint16: 2,
+	sint16x2: 4,
+	sint16x4: 8,
+	unorm16: 2,
+	unorm16x2: 4,
+	unorm16x4: 8,
+	snorm16: 2,
+	snorm16x2: 4,
+	snorm16x4: 8,
+	float16: 2,
+	float16x2: 4,
+	float16x4: 8,
+	float32: 4,
+	float32x2: 8,
+	float32x3: 12,
+	float32x4: 16,
+	uint32: 4,
+	uint32x2: 8,
+	uint32x3: 12,
+	uint32x4: 16,
+	sint32: 4,
+	sint32x2: 8,
+	sint32x3: 12,
+	sint32x4: 16,
+	"unorm10-10-10-2": 4,
+	"unorm8x4-bgra": 4,
+	atomic: 4
+};
+function computeMLOfStruct(struct) {
+	let size = 0;
+	let longestContiguousPrefix = 0;
+	let isContiguous = true;
+	let prefixEnd = false;
+	for (const property of Object.values(struct.propTypes)) {
+		if (Number.isNaN(size)) throw new Error("Only the last property of a struct can be unbounded");
+		const prevSize = size;
+		size = roundUp(size, alignmentOf(property));
+		const hasPadding = prevSize !== size;
+		const propLayout = computeMemoryLayout(property);
+		size += propLayout.size;
+		if (Number.isNaN(size) && property.type !== "array") throw new Error("Cannot nest unbounded struct within another struct");
+		if (prefixEnd) continue;
+		if (!hasPadding && propLayout.isContiguous) longestContiguousPrefix += propLayout.size;
+		else {
+			prefixEnd = true;
+			isContiguous = false;
+			if (!hasPadding) longestContiguousPrefix += propLayout.longestContiguousPrefix;
+		}
+	}
+	const trueSize = roundUp(size, alignmentOf(struct));
+	return {
+		isContiguous: size === trueSize && isContiguous,
+		size: trueSize,
+		longestContiguousPrefix
+	};
+}
+function computeMLOfUnstruct(data) {
+	let size = 0;
+	let longestContiguousPrefix = 0;
+	let isContiguous = true;
+	let prefixEnd = false;
+	for (const property of Object.values(data.propTypes)) {
+		const alignment = customAlignmentOf(property);
+		const prevSize = size;
+		size = roundUp(size, alignment);
+		const hasPadding = prevSize !== size;
+		if (hasPadding) isContiguous = false;
+		const propLayout = computeMemoryLayout(property);
+		size += propLayout.size;
+		if (prefixEnd) continue;
+		if (!hasPadding && propLayout.isContiguous) longestContiguousPrefix += propLayout.size;
+		else {
+			prefixEnd = true;
+			isContiguous = false;
+			if (!hasPadding) longestContiguousPrefix += propLayout.longestContiguousPrefix;
+		}
+	}
+	return {
+		isContiguous,
+		size,
+		longestContiguousPrefix
+	};
+}
+function computeMLOfWgslArray(data) {
+	const elementType = data.elementType;
+	const elementMemoryLayout = computeMemoryLayout(elementType);
+	const elementSize = elementMemoryLayout.size;
+	const stride = roundUp(elementSize, alignmentOf(elementType));
+	const isContiguous = !(stride > elementSize) && elementMemoryLayout.isContiguous;
+	const size = data.elementCount === 0 ? NaN : data.elementCount * stride;
+	let longestContiguousPrefix;
+	if (isContiguous) longestContiguousPrefix = size;
+	else longestContiguousPrefix = elementMemoryLayout.longestContiguousPrefix;
+	return {
+		size,
+		isContiguous,
+		longestContiguousPrefix
+	};
+}
+function computeMLOfDisarray(data) {
+	const elementType = data.elementType;
+	const elementMemoryLayout = computeMemoryLayout(elementType);
+	const elementSize = elementMemoryLayout.size;
+	const stride = roundUp(elementSize, customAlignmentOf(elementType));
+	const isContiguous = !(stride > elementSize) && elementMemoryLayout.isContiguous;
+	const size = data.elementCount * stride;
+	let longestContiguousPrefix;
+	if (isContiguous) longestContiguousPrefix = size;
+	else longestContiguousPrefix = elementMemoryLayout.longestContiguousPrefix;
+	return {
+		size,
+		isContiguous,
+		longestContiguousPrefix
+	};
+}
+function computeMemoryLayout(data) {
+	const knownSize = knownSizesMap[data.type];
+	if (knownSize !== void 0) return {
+		isContiguous: data.type !== "mat3x3f",
+		size: knownSize,
+		longestContiguousPrefix: data.type === "mat3x3f" ? 12 : knownSize
+	};
+	if (isWgslStruct(data)) return computeMLOfStruct(data);
+	if (isUnstruct(data)) return computeMLOfUnstruct(data);
+	if (isWgslArray(data)) return computeMLOfWgslArray(data);
+	if (isDisarray(data)) return computeMLOfDisarray(data);
+	if (isDecorated(data) || isLooseDecorated(data)) {
+		const size = getCustomSize(data);
+		const undecoratedLayout = computeMemoryLayout(undecorate(data));
+		if (size) return {
+			isContiguous: size === undecoratedLayout.size && undecoratedLayout.isContiguous,
+			size,
+			longestContiguousPrefix: undecoratedLayout.longestContiguousPrefix
+		};
+		return computeMemoryLayout(data.inner);
+	}
+	throw new Error(`Cannot determine memory layout of data: ${data}`);
+}
+/**
+* Since memory layout can be inferred from data types, they are not stored on them.
+* Instead, this weak map acts as an extended property of those data types.
+*/
+const cachedLayouts = /* @__PURE__ */ new WeakMap();
+function getLayoutInfo(schema, key) {
+	let layout = cachedLayouts.get(schema);
+	if (layout === void 0) {
+		layout = computeMemoryLayout(schema);
+		cachedLayouts.set(schema, layout);
+	}
+	return layout[key];
+}
+
+//#endregion
+//#region src/data/sizeOf.ts
+function sizeOf(schema) {
+	return getLayoutInfo(schema, "size");
+}
+/**
+* Returns the size (in bytes) of data represented by the `schema`.
+*/
+function PUBLIC_sizeOf(schema) {
+	return sizeOf(schema);
+}
+
+//#endregion
+//#region src/data/attributes.ts
+function attribute(data, attrib) {
+	if (isDecorated(data)) return new DecoratedImpl(data.inner, [attrib, ...data.attribs]);
+	if (isLooseDecorated(data)) return new LooseDecoratedImpl(data.inner, [attrib, ...data.attribs]);
+	if (isLooseData(data)) return new LooseDecoratedImpl(data, [attrib]);
+	return new DecoratedImpl(data, [attrib]);
+}
+/**
+* Gives the wrapped data-type a custom byte alignment. Useful in order to
+* fulfill uniform alignment requirements.
+*
+* @example
+* const Data = d.struct({
+*   a: u32, // takes up 4 bytes
+*   // 12 bytes of padding, because `b` is custom aligned to multiples of 16 bytes
+*   b: d.align(16, u32),
+* });
+*
+* @param alignment The multiple of bytes this data should align itself to.
+* @param data The data-type to align.
+*/
+function align(alignment, data) {
+	return attribute(data, {
+		[$internal]: true,
+		type: "@align",
+		params: [alignment]
+	});
+}
+/**
+* Adds padding bytes after the wrapped data-type, until the whole value takes up `size` bytes.
+*
+* @example
+* const Data = d.struct({
+*   a: d.size(16, u32), // takes up 16 bytes, instead of 4
+*   b: u32, // starts at byte 16, because `a` has a custom size
+* });
+*
+* @param size The amount of bytes that should be reserved for this data-type.
+* @param data The data-type to wrap.
+*/
+function size(size, data) {
+	return attribute(data, {
+		[$internal]: true,
+		type: "@size",
+		params: [size]
+	});
+}
+/**
+* Assigns an explicit numeric location to a struct member or a parameter that has this type.
+*
+* @example
+* const VertexOutput = {
+*   a: d.u32, // has implicit location 0
+*   b: d.location(5, d.u32),
+*   c: d.u32, // has implicit location 6
+* };
+*
+* @param location The explicit numeric location.
+* @param data The data-type to wrap.
+*/
+function location(location, data) {
+	return attribute(data, {
+		[$internal]: true,
+		type: "@location",
+		params: [location]
+	});
+}
+function interpolate(interpolationType, data) {
+	return attribute(data, {
+		[$internal]: true,
+		type: "@interpolate",
+		params: [interpolationType]
+	});
+}
+/**
+* Marks a position built-in output value as invariant in vertex shaders.
+* If the data and control flow match for two position outputs in different
+* entry points, then the result values are guaranteed to be the same.
+*
+* Must only be applied to the position built-in value.
+*
+* @example
+* const VertexOutput = {
+*   pos: d.invariant(d.builtin.position),
+* };
+*
+* @param data The position built-in data-type to mark as invariant.
+*/
+function invariant(data) {
+	if (!isBuiltin(data)) throw new Error("The @invariant attribute must only be applied to the position built-in value.");
+	const builtinAttrib = isDecorated(data) || isLooseDecorated(data) ? data.attribs.find(isBuiltinAttrib) : void 0;
+	if (!builtinAttrib || builtinAttrib.params[0] !== "position") throw new Error("The @invariant attribute must only be applied to the position built-in value.");
+	return attribute(data, {
+		[$internal]: true,
+		type: "@invariant",
+		params: []
+	});
+}
+function isBuiltin(value) {
+	return (isDecorated(value) || isLooseDecorated(value)) && value.attribs.find(isBuiltinAttrib) !== void 0;
+}
+function getAttributesString(field) {
+	if (!isDecorated(field) && !isLooseDecorated(field)) return "";
+	return field.attribs.map((attrib) => {
+		if (attrib.params.length === 0) return `${attrib.type} `;
+		return `${attrib.type}(${attrib.params.join(", ")}) `;
+	}).join("");
+}
+var BaseDecoratedImpl = class {
+	[$internal] = {};
+	constructor(inner, attribs) {
+		this.inner = inner;
+		this.attribs = attribs;
+		const alignAttrib = attribs.find(isAlignAttrib)?.params[0];
+		const sizeAttrib = attribs.find(isSizeAttrib)?.params[0];
+		if (alignAttrib !== void 0) {
+			if (alignAttrib <= 0) throw new Error(`Custom data alignment must be a positive number, got: ${alignAttrib}.`);
+			if (Math.log2(alignAttrib) % 1 !== 0) throw new Error(`Alignment has to be a power of 2, got: ${alignAttrib}.`);
+			if (isWgslData(this.inner)) {
+				if (alignAttrib % alignmentOf(this.inner) !== 0) throw new Error(`Custom alignment has to be a multiple of the standard data alignment. Got: ${alignAttrib}, expected multiple of: ${alignmentOf(this.inner)}.`);
+			}
+		}
+		if (sizeAttrib !== void 0) {
+			if (sizeAttrib < sizeOf(this.inner)) throw new Error(`Custom data size cannot be smaller then the standard data size. Got: ${sizeAttrib}, expected at least: ${sizeOf(this.inner)}.`);
+			if (sizeAttrib <= 0) throw new Error(`Custom data size must be a positive number. Got: ${sizeAttrib}.`);
+		}
+	}
+};
+var DecoratedImpl = class extends BaseDecoratedImpl {
+	[$internal] = {};
+	type = "decorated";
+};
+var LooseDecoratedImpl = class extends BaseDecoratedImpl {
+	[$internal] = {};
+	type = "loose-decorated";
+};
+
+//#endregion
+//#region src/core/function/ioSchema.ts
+function withLocations(members, locations = {}) {
+	let nextLocation = 0;
+	const usedCustomLocations = /* @__PURE__ */ new Set();
+	return Object.fromEntries(Object.entries(members ?? {}).map(([key, member]) => {
+		const customLocation = getCustomLocation(member);
+		if (customLocation !== void 0) {
+			if (usedCustomLocations.has(customLocation)) throw new Error("Duplicate custom location attributes found");
+			usedCustomLocations.add(customLocation);
+		}
+		return [key, member];
+	}).map(([key, member]) => {
+		if (isBuiltin(member)) return [key, member];
+		if (getCustomLocation(member) !== void 0) return [key, member];
+		if (locations[key]) return [key, location(locations[key], member)];
+		while (usedCustomLocations.has(nextLocation)) nextLocation++;
+		return [key, location(nextLocation++, member)];
+	}));
+}
+function createIoSchema(layout, locations = {}) {
+	return isData(layout) ? isVoid(layout) ? layout : isBuiltin(layout) ? layout : getCustomLocation(layout) !== void 0 ? layout : location(0, layout) : INTERNAL_createStruct(withLocations(layout, locations), false);
+}
+
+//#endregion
+//#region src/data/autoStruct.ts
+/**
+* A requirement for the generated struct is that non-builtin properties need to
+* have the same name in WGSL as they do in JS. This allows locations to be properly
+* matched between the Vertex output and Fragment input.
+*/
+var AutoStruct = class {
+	/**
+	* js key -> data type
+	*/
+	#validProps;
+	/**
+	* js key -> { prop: 'wgsl key', type: ... }
+	* @example '$position' -> { prop: 'position', type: ... }
+	*/
+	#allocated;
+	#usedWgslKeys;
+	#locations;
+	#cachedStruct;
+	#typeForExtraProps;
+	constructor(validProps, typeForExtraProps, locations) {
+		this.#validProps = validProps;
+		this.#typeForExtraProps = typeForExtraProps;
+		this.#allocated = {};
+		this.#locations = locations;
+		this.#usedWgslKeys = /* @__PURE__ */ new Set();
+	}
+	/**
+	* Used for accessing builtins, varying and attributes in code.
+	*/
+	accessProp(key) {
+		const dataType = this.#validProps[key] ?? this.#typeForExtraProps;
+		if (!dataType) return;
+		return this.provideProp(key, dataType);
+	}
+	/**
+	* Used for providing new varyings.
+	*
+	* @privateRemarks
+	* Internally used by `accessProp`.
+	*/
+	provideProp(key, dataType) {
+		let alloc = this.#allocated[key];
+		if (!alloc) {
+			const wgslKey = key.replaceAll("$", "");
+			if (this.#usedWgslKeys.has(wgslKey)) throw new Error(`Property name '${wgslKey}' causes naming clashes. Choose a different name.`);
+			if (!isValidProp(wgslKey)) throw new Error(`Property key '${key}' is a reserved WGSL word. Choose a different name.`);
+			this.#usedWgslKeys.add(wgslKey);
+			alloc = {
+				prop: wgslKey,
+				type: dataType
+			};
+			this.#allocated[key] = alloc;
+		}
+		return alloc;
+	}
+	get completeStruct() {
+		if (!this.#cachedStruct) {
+			this.#cachedStruct = createIoSchema(Object.fromEntries(Object.values(this.#allocated).map((alloc) => {
+				return [alloc.prop, alloc.type];
+			})), this.#locations);
+			const ownName = getName(this);
+			if (ownName) setName(this.#cachedStruct, ownName);
+		}
+		return this.#cachedStruct;
+	}
+	[$resolve](ctx) {
+		return ctx.resolve(this.completeStruct);
+	}
+	toString() {
+		return `auto-struct:${getName(this) ?? "<unnamed>"}`;
+	}
+};
+AutoStruct.prototype[$internal] = {};
+AutoStruct.prototype.type = "auto-struct";
+
+//#endregion
+//#region src/tgsl/accessProp.ts
+const infixKinds = [
+	"vec2f",
+	"vec3f",
+	"vec4f",
+	"vec2h",
+	"vec3h",
+	"vec4h",
+	"vec2i",
+	"vec3i",
+	"vec4i",
+	"vec2u",
+	"vec3u",
+	"vec4u",
+	"mat2x2f",
+	"mat3x3f",
+	"mat4x4f"
+];
+const infixOperators = {
+	add,
+	sub,
+	mul,
+	div,
+	mod
+};
+const swizzleLenToType = {
+	f: {
+		1: f32,
+		2: vec2f,
+		3: vec3f,
+		4: vec4f
+	},
+	h: {
+		1: f16,
+		2: vec2h,
+		3: vec3h,
+		4: vec4h
+	},
+	i: {
+		1: i32,
+		2: vec2i,
+		3: vec3i,
+		4: vec4i
+	},
+	u: {
+		1: u32,
+		2: vec2u,
+		3: vec3u,
+		4: vec4u
+	},
+	b: {
+		1: bool,
+		2: vec2b,
+		3: vec3b,
+		4: vec4b
+	}
+};
+function accessProp(target, propName) {
+	if (infixKinds.includes(target.dataType.type) && propName in infixOperators) {
+		const operator = infixOperators[propName];
+		return snip(new InfixDispatch(propName, target, operator[$gpuCallable].call.bind(operator)), UnknownData, target.origin);
+	}
+	if (isWgslArray(target.dataType) && propName === "length") {
+		if (target.dataType.elementCount === 0) return snip(stitch`arrayLength(&${target})`, u32, "runtime");
+		return snip(target.dataType.elementCount, abstractInt, "constant");
+	}
+	if (isMat(target.dataType) && propName === "columns") return snip(new MatrixColumnsAccess(target), UnknownData, target.origin);
+	if (isWgslStruct(target.dataType) || isUnstruct(target.dataType)) {
+		let propType = target.dataType.propTypes[propName];
+		if (!propType) return;
+		propType = undecorate(propType);
+		return snip(stitch`${target}.${propName}`, propType, target.origin === "argument" ? "argument" : !isEphemeralSnippet(target) && !isNaturallyEphemeral(propType) ? target.origin : target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+	}
+	if (target.dataType instanceof AutoStruct) {
+		const result = target.dataType.accessProp(propName);
+		if (!result) return;
+		return snip(stitch`${target}.${result.prop}`, result.type, "argument");
+	}
+	if (isPtr(target.dataType)) {
+		const derefed = derefSnippet(target);
+		if (propName === "$") return derefed;
+		return accessProp(derefed, propName);
+	}
+	if (isVec(target.dataType)) {
+		if (propName === "kind") return snip(target.dataType.type, UnknownData, "constant");
+	}
+	const propLength = propName.length;
+	if (isVec(target.dataType) && propLength >= 1 && propLength <= 4) {
+		const isXYZW = /^[xyzw]+$/.test(propName);
+		const isRGBA = /^[rgba]+$/.test(propName);
+		if (!isXYZW && !isRGBA) return;
+		const swizzleType = swizzleLenToType[target.dataType.type.includes("bool") ? "b" : target.dataType.type[4]][propLength];
+		if (!swizzleType) return;
+		return snip(isKnownAtComptime(target) ? target.value[propName] : stitch`${target}.${propName}`, swizzleType, target.origin === "argument" && propLength === 1 ? "argument" : target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+	}
+	if (isKnownAtComptime(target) || target.dataType === UnknownData) return coerceToSnippet(target.value[propName]);
+}
+
+//#endregion
+//#region src/data/array.ts
+/**
+* Creates an array schema that can be used to construct gpu buffers.
+* Describes arrays with fixed-size length, storing elements of the same type.
+*
+* @example
+* const LENGTH = 3;
+* const array = d.arrayOf(d.u32, LENGTH);
+*
+* If `elementCount` is not specified, a partially applied function is returned.
+* @example
+* const array = d.arrayOf(d.vec3f);
+* //    ^? (n: number) => WgslArray<d.Vec3f>
+*
+* @param elementType The type of elements in the array.
+* @param elementCount The number of elements in the array.
+*/
+const arrayOf = comptime(((elementType, elementCount) => {
+	if (elementCount === void 0) return comptime((count) => cpu_arrayOf(elementType, count));
+	return cpu_arrayOf(elementType, elementCount);
+})).$name("arrayOf");
+function cpu_arrayOf(elementType, elementCount) {
+	const arraySchema = (elements) => {
+		if (elements && elements.length !== elementCount) throw new Error(`Array schema of ${elementCount} elements of type ${elementType.type} called with ${elements.length} argument(s).`);
+		return Array.from({ length: elementCount }, (_, i) => schemaCallWrapper(elementType, elements?.[i]));
+	};
+	Object.setPrototypeOf(arraySchema, WgslArrayImpl);
+	if (Number.isNaN(sizeOf(elementType))) throw new Error("Cannot nest runtime sized arrays.");
+	arraySchema.elementType = elementType;
+	if (!Number.isInteger(elementCount) || elementCount < 0) throw new Error(`Cannot create array schema with invalid element count: ${elementCount}.`);
+	arraySchema.elementCount = elementCount;
+	return arraySchema;
+}
+const WgslArrayImpl = {
+	[$internal]: true,
+	type: "array",
+	toString() {
+		return `arrayOf(${this.elementType}, ${this.elementCount})`;
+	}
+};
+
+//#endregion
+//#region src/builtin.ts
+function defineBuiltin(dataType, value) {
+	return attribute(dataType, {
+		[$internal]: true,
+		type: "@builtin",
+		params: [value]
+	});
+}
+const builtin = {
+	vertexIndex: defineBuiltin(u32, "vertex_index"),
+	instanceIndex: defineBuiltin(u32, "instance_index"),
+	clipDistances: defineBuiltin(arrayOf(u32, 8), "clip_distances"),
+	position: defineBuiltin(vec4f, "position"),
+	frontFacing: defineBuiltin(bool, "front_facing"),
+	fragDepth: defineBuiltin(f32, "frag_depth"),
+	primitiveIndex: defineBuiltin(u32, "primitive_index"),
+	sampleIndex: defineBuiltin(u32, "sample_index"),
+	sampleMask: defineBuiltin(u32, "sample_mask"),
+	localInvocationId: defineBuiltin(vec3u, "local_invocation_id"),
+	localInvocationIndex: defineBuiltin(u32, "local_invocation_index"),
+	globalInvocationId: defineBuiltin(vec3u, "global_invocation_id"),
+	workgroupId: defineBuiltin(vec3u, "workgroup_id"),
+	numWorkgroups: defineBuiltin(vec3u, "num_workgroups"),
+	subgroupInvocationId: defineBuiltin(u32, "subgroup_invocation_id"),
+	subgroupSize: defineBuiltin(u32, "subgroup_size"),
+	subgroupId: defineBuiltin(u32, "subgroup_id"),
+	numSubgroups: defineBuiltin(u32, "num_subgroups")
+};
+
+//#endregion
+export { uint32x4 as $, packedFormats as A, sint8x4 as B, float16x4 as C, float32x4 as D, float32x3 as E, sint32x2 as F, snorm8x2 as G, snorm16x2 as H, sint32x3 as I, uint16x2 as J, snorm8x4 as K, sint32x4 as L, sint16x2 as M, sint16x4 as N, formatToWGSLType as O, sint32 as P, uint32x3 as Q, sint8 as R, float16x2 as S, float32x2 as T, snorm16x4 as U, snorm16 as V, snorm8 as W, uint32 as X, uint16x4 as Y, uint32x2 as Z, roundUp as _, AutoStruct as a, unorm16x2 as at, customAlignmentOf as b, getAttributesString as c, unorm8x2 as ct, isBuiltin as d, uint8 as et, location as f, getLayoutInfo as g, sizeOf as h, infixOperators as i, unorm16 as it, sint16 as j, isPackedData as k, interpolate as l, unorm8x4 as lt, PUBLIC_sizeOf as m, arrayOf as n, uint8x4 as nt, createIoSchema as o, unorm16x4 as ot, size as p, uint16 as q, accessProp as r, unorm10_10_10_2 as rt, align as s, unorm8 as st, builtin as t, uint8x2 as tt, invariant as u, unorm8x4_bgra as ut, PUBLIC_alignmentOf as v, float32 as w, float16 as x, alignmentOf as y, sint8x2 as z };
+//# sourceMappingURL=builtin-ClEnM-Ye.js.map