typegpu 0.3.1 → 0.3.3

package/chunk-2ZAQFPSX.js

@@ -0,0 +1,1266 @@
+import {
+  __publicField,
+  inGPUMode,
+  vec2f,
+  vec2i,
+  vec2u,
+  vec3f,
+  vec3i,
+  vec3u,
+  vec4f,
+  vec4i,
+  vec4u
+} from "./chunk-DDEF2Y4S.js";
+
+// src/data/numeric.ts
+import bin from "typed-binary";
+var bool = {
+  type: "bool"
+};
+var u32Cast = (v) => {
+  if (inGPUMode()) {
+    return `u32(${v})`;
+  }
+  if (typeof v === "boolean") {
+    return v ? 1 : 0;
+  }
+  if (Number.isInteger(v)) {
+    if (v < 0 || v > 4294967295) {
+      console.warn(`u32 value ${v} overflowed`);
+    }
+    const value = v & 4294967295;
+    return value >>> 0;
+  }
+  return Math.max(0, Math.min(4294967295, Math.floor(v)));
+};
+var u32 = Object.assign(u32Cast, {
+  type: "u32"
+});
+var i32Cast = (v) => {
+  if (inGPUMode()) {
+    return `i32(${v})`;
+  }
+  if (typeof v === "boolean") {
+    return v ? 1 : 0;
+  }
+  if (Number.isInteger(v)) {
+    if (v < -2147483648 || v > 2147483647) {
+      console.warn(`i32 value ${v} overflowed`);
+    }
+    const value2 = v | 0;
+    return value2 & 4294967295;
+  }
+  const value = v < 0 ? Math.ceil(v) : Math.floor(v);
+  return Math.max(-2147483648, Math.min(2147483647, value));
+};
+var i32 = Object.assign(i32Cast, {
+  type: "i32"
+});
+var f32Cast = (v) => {
+  if (inGPUMode()) {
+    return `f32(${v})`;
+  }
+  if (typeof v === "boolean") {
+    return v ? 1 : 0;
+  }
+  const arr = new Float32Array(1);
+  arr[0] = v;
+  return arr[0];
+};
+var f32 = Object.assign(f32Cast, {
+  type: "f32"
+});
+var f16Cast = (v) => {
+  if (inGPUMode()) {
+    return `f16(${v})`;
+  }
+  if (typeof v === "boolean") {
+    return v ? 1 : 0;
+  }
+  const arr = new ArrayBuffer(2);
+  bin.f16.write(new bin.BufferWriter(arr), v);
+  return bin.f16.read(new bin.BufferReader(arr));
+};
+var f16 = Object.assign(f16Cast, {
+  type: "f16"
+});
+
+// src/data/wgslTypes.ts
+var wgslTypeLiterals = [
+  "bool",
+  "f32",
+  "f16",
+  "i32",
+  "u32",
+  "vec2f",
+  "vec2h",
+  "vec2i",
+  "vec2u",
+  "vec3f",
+  "vec3h",
+  "vec3i",
+  "vec3u",
+  "vec4f",
+  "vec4h",
+  "vec4i",
+  "vec4u",
+  "mat2x2f",
+  "mat3x3f",
+  "mat4x4f",
+  "struct",
+  "array",
+  "ptrFn",
+  "atomic",
+  "decorated"
+];
+function isWgslData(value) {
+  return wgslTypeLiterals.includes(value == null ? void 0 : value.type);
+}
+function isWgslArray(schema) {
+  return (schema == null ? void 0 : schema.type) === "array";
+}
+function isWgslStruct(schema) {
+  return (schema == null ? void 0 : schema.type) === "struct";
+}
+function isPtrFn(schema) {
+  return (schema == null ? void 0 : schema.type) === "ptrFn";
+}
+function isAtomic(schema) {
+  return (schema == null ? void 0 : schema.type) === "atomic";
+}
+function isAlignAttrib(value) {
+  return (value == null ? void 0 : value.type) === "@align";
+}
+function isSizeAttrib(value) {
+  return (value == null ? void 0 : value.type) === "@size";
+}
+function isLocationAttrib(value) {
+  return (value == null ? void 0 : value.type) === "@location";
+}
+function isInterpolateAttrib(value) {
+  return (value == null ? void 0 : value.type) === "@interpolate";
+}
+function isBuiltinAttrib(value) {
+  return (value == null ? void 0 : value.type) === "@builtin";
+}
+function isDecorated(value) {
+  return (value == null ? void 0 : value.type) === "decorated";
+}
+
+// src/data/struct.ts
+var struct = (props) => {
+  const struct2 = (props2) => props2;
+  Object.setPrototypeOf(struct2, TgpuStructImpl);
+  struct2.propTypes = props;
+  return struct2;
+};
+var TgpuStructImpl = {
+  type: "struct",
+  _label: void 0,
+  get label() {
+    return this._label;
+  },
+  $name(label) {
+    this._label = label;
+    return this;
+  },
+  toString() {
+    var _a;
+    return `struct:${(_a = this.label) != null ? _a : "<unnamed>"}`;
+  }
+};
+
+// src/mathUtils.ts
+var roundUp = (value, modulo) => {
+  const bitMask = modulo - 1;
+  const invBitMask = ~bitMask;
+  return (value & bitMask) === 0 ? value : (value & invBitMask) + modulo;
+};
+
+// src/shared/vertexFormat.ts
+var vertexFormats = [
+  "uint8",
+  "uint8x2",
+  "uint8x4",
+  "sint8",
+  "sint8x2",
+  "sint8x4",
+  "unorm8",
+  "unorm8x2",
+  "unorm8x4",
+  "snorm8",
+  "snorm8x2",
+  "snorm8x4",
+  "uint16",
+  "uint16x2",
+  "uint16x4",
+  "sint16",
+  "sint16x2",
+  "sint16x4",
+  "unorm16",
+  "unorm16x2",
+  "unorm16x4",
+  "snorm16",
+  "snorm16x2",
+  "snorm16x4",
+  "float16",
+  "float16x2",
+  "float16x4",
+  "float32",
+  "float32x2",
+  "float32x3",
+  "float32x4",
+  "uint32",
+  "uint32x2",
+  "uint32x3",
+  "uint32x4",
+  "sint32",
+  "sint32x2",
+  "sint32x3",
+  "sint32x4",
+  "unorm10-10-10-2",
+  "unorm8x4-bgra"
+];
+var kindToDefaultFormatMap = {
+  f32: "float32",
+  vec2f: "float32x2",
+  vec3f: "float32x3",
+  vec4f: "float32x4",
+  f16: "float16",
+  vec2h: "float16x2",
+  // vec3h has no direct equivalent in the spec
+  vec4h: "float16x4",
+  u32: "uint32",
+  vec2u: "uint32x2",
+  vec3u: "uint32x3",
+  vec4u: "uint32x4",
+  i32: "sint32",
+  vec2i: "sint32x2",
+  vec3i: "sint32x3",
+  vec4i: "sint32x4"
+};
+
+// src/data/dataTypes.ts
+var looseTypeLiterals = [
+  "unstruct",
+  "disarray",
+  "loose-decorated",
+  ...vertexFormats
+];
+function isLooseData(data) {
+  return looseTypeLiterals.includes(data == null ? void 0 : data.type);
+}
+function isDisarray(schema) {
+  return (schema == null ? void 0 : schema.type) === "disarray";
+}
+function isUnstruct(schema) {
+  return (schema == null ? void 0 : schema.type) === "unstruct";
+}
+function isLooseDecorated(value) {
+  return (value == null ? void 0 : value.type) === "loose-decorated";
+}
+function getCustomAlignment(data) {
+  var _a, _b;
+  return (_b = (_a = data.attribs) == null ? void 0 : _a.find(
+    isAlignAttrib
+  )) == null ? void 0 : _b.value;
+}
+function getCustomSize(data) {
+  var _a, _b;
+  return (_b = (_a = data.attribs) == null ? void 0 : _a.find(
+    isSizeAttrib
+  )) == null ? void 0 : _b.value;
+}
+function getCustomLocation(data) {
+  var _a, _b;
+  return (_b = (_a = data.attribs) == null ? void 0 : _a.find(
+    isLocationAttrib
+  )) == null ? void 0 : _b.value;
+}
+function isData(value) {
+  return isWgslData(value) || isLooseData(value);
+}
+
+// src/data/vertexFormatData.ts
+var TgpuVertexFormatDataImpl = class {
+  constructor(type) {
+    this.type = type;
+    /** Used as a type-token for the `Infer<T>` functionality. */
+    __publicField(this, "~repr");
+  }
+};
+var 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
+};
+var packedFormats = Object.keys(formatToWGSLType);
+var uint8 = new TgpuVertexFormatDataImpl("uint8");
+var uint8x2 = new TgpuVertexFormatDataImpl("uint8x2");
+var uint8x4 = new TgpuVertexFormatDataImpl("uint8x4");
+var sint8 = new TgpuVertexFormatDataImpl("sint8");
+var sint8x2 = new TgpuVertexFormatDataImpl("sint8x2");
+var sint8x4 = new TgpuVertexFormatDataImpl("sint8x4");
+var unorm8 = new TgpuVertexFormatDataImpl("unorm8");
+var unorm8x2 = new TgpuVertexFormatDataImpl("unorm8x2");
+var unorm8x4 = new TgpuVertexFormatDataImpl("unorm8x4");
+var snorm8 = new TgpuVertexFormatDataImpl("snorm8");
+var snorm8x2 = new TgpuVertexFormatDataImpl("snorm8x2");
+var snorm8x4 = new TgpuVertexFormatDataImpl("snorm8x4");
+var uint16 = new TgpuVertexFormatDataImpl("uint16");
+var uint16x2 = new TgpuVertexFormatDataImpl("uint16x2");
+var uint16x4 = new TgpuVertexFormatDataImpl("uint16x4");
+var sint16 = new TgpuVertexFormatDataImpl("sint16");
+var sint16x2 = new TgpuVertexFormatDataImpl("sint16x2");
+var sint16x4 = new TgpuVertexFormatDataImpl("sint16x4");
+var unorm16 = new TgpuVertexFormatDataImpl("unorm16");
+var unorm16x2 = new TgpuVertexFormatDataImpl("unorm16x2");
+var unorm16x4 = new TgpuVertexFormatDataImpl("unorm16x4");
+var snorm16 = new TgpuVertexFormatDataImpl("snorm16");
+var snorm16x2 = new TgpuVertexFormatDataImpl("snorm16x2");
+var snorm16x4 = new TgpuVertexFormatDataImpl("snorm16x4");
+var float16 = new TgpuVertexFormatDataImpl("float16");
+var float16x2 = new TgpuVertexFormatDataImpl("float16x2");
+var float16x4 = new TgpuVertexFormatDataImpl("float16x4");
+var float32 = new TgpuVertexFormatDataImpl("float32");
+var float32x2 = new TgpuVertexFormatDataImpl("float32x2");
+var float32x3 = new TgpuVertexFormatDataImpl("float32x3");
+var float32x4 = new TgpuVertexFormatDataImpl("float32x4");
+var uint32 = new TgpuVertexFormatDataImpl("uint32");
+var uint32x2 = new TgpuVertexFormatDataImpl("uint32x2");
+var uint32x3 = new TgpuVertexFormatDataImpl("uint32x3");
+var uint32x4 = new TgpuVertexFormatDataImpl("uint32x4");
+var sint32 = new TgpuVertexFormatDataImpl("sint32");
+var sint32x2 = new TgpuVertexFormatDataImpl("sint32x2");
+var sint32x3 = new TgpuVertexFormatDataImpl("sint32x3");
+var sint32x4 = new TgpuVertexFormatDataImpl("sint32x4");
+var unorm10_10_10_2 = new TgpuVertexFormatDataImpl(
+  "unorm10-10-10-2"
+);
+var unorm8x4_bgra = new TgpuVertexFormatDataImpl(
+  "unorm8x4-bgra"
+);
+
+// src/data/alignmentOf.ts
+var knownAlignmentMap = {
+  bool: 4,
+  f32: 4,
+  f16: 2,
+  i32: 4,
+  u32: 4,
+  vec2f: 8,
+  vec2h: 4,
+  vec2i: 8,
+  vec2u: 8,
+  vec3f: 16,
+  vec3h: 8,
+  vec3i: 16,
+  vec3u: 16,
+  vec4f: 16,
+  vec4h: 8,
+  vec4i: 16,
+  vec4u: 16,
+  mat2x2f: 8,
+  mat3x3f: 16,
+  mat4x4f: 16
+};
+function computeAlignment(data) {
+  var _a, _b, _c;
+  const dataType = data == null ? void 0 : 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 ? (_a = getCustomAlignment(firstProp)) != null ? _a : 1 : 1;
+  }
+  if (isDisarray(data)) {
+    return (_b = getCustomAlignment(data.elementType)) != null ? _b : 1;
+  }
+  if (isDecorated(data) || isLooseDecorated(data)) {
+    return (_c = getCustomAlignment(data)) != null ? _c : alignmentOf(data.inner);
+  }
+  if (packedFormats.includes(dataType)) {
+    return 1;
+  }
+  throw new Error(
+    `Cannot determine alignment of data: ${JSON.stringify(data)}`
+  );
+}
+function computeCustomAlignment(data) {
+  var _a, _b;
+  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 (_a = getCustomAlignment(data)) != null ? _a : customAlignmentOf(data.inner);
+  }
+  return (_b = getCustomAlignment(data)) != null ? _b : 1;
+}
+var cachedAlignments = /* @__PURE__ */ new WeakMap();
+var 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;
+}
+function PUBLIC_alignmentOf(schema) {
+  return alignmentOf(schema);
+}
+
+// src/data/sizeOf.ts
+var knownSizesMap = {
+  bool: 4,
+  f32: 4,
+  f16: 2,
+  i32: 4,
+  u32: 4,
+  vec2f: 8,
+  vec2h: 4,
+  vec2i: 8,
+  vec2u: 8,
+  vec3f: 12,
+  vec3h: 6,
+  vec3i: 12,
+  vec3u: 12,
+  vec4f: 16,
+  vec4h: 8,
+  vec4i: 16,
+  vec4u: 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
+};
+function sizeOfStruct(struct2) {
+  let size2 = 0;
+  for (const property of Object.values(struct2.propTypes)) {
+    if (Number.isNaN(size2)) {
+      throw new Error("Only the last property of a struct can be unbounded");
+    }
+    size2 = roundUp(size2, alignmentOf(property));
+    size2 += sizeOf(property);
+    if (Number.isNaN(size2) && property.type !== "array") {
+      throw new Error("Cannot nest unbounded struct within another struct");
+    }
+  }
+  return roundUp(size2, alignmentOf(struct2));
+}
+function sizeOfUnstruct(data) {
+  let size2 = 0;
+  for (const property of Object.values(data.propTypes)) {
+    const alignment = customAlignmentOf(property);
+    size2 = roundUp(size2, alignment);
+    size2 += sizeOf(property);
+  }
+  return size2;
+}
+function computeSize(data) {
+  var _a;
+  const knownSize = knownSizesMap[data == null ? void 0 : data.type];
+  if (knownSize !== void 0) {
+    return knownSize;
+  }
+  if (isWgslStruct(data)) {
+    return sizeOfStruct(data);
+  }
+  if (isUnstruct(data)) {
+    return sizeOfUnstruct(data);
+  }
+  if (isWgslArray(data)) {
+    if (data.elementCount === 0) {
+      return Number.NaN;
+    }
+    const alignment = alignmentOf(data.elementType);
+    const stride = roundUp(sizeOf(data.elementType), alignment);
+    return stride * data.elementCount;
+  }
+  if (isDisarray(data)) {
+    const alignment = customAlignmentOf(data.elementType);
+    const stride = roundUp(sizeOf(data.elementType), alignment);
+    return stride * data.elementCount;
+  }
+  if (isDecorated(data) || isLooseDecorated(data)) {
+    return (_a = getCustomSize(data)) != null ? _a : sizeOf(data.inner);
+  }
+  throw new Error(`Cannot determine size of data: ${data}`);
+}
+var cachedSizes = /* @__PURE__ */ new WeakMap();
+function sizeOf(schema) {
+  let size2 = cachedSizes.get(schema);
+  if (size2 === void 0) {
+    size2 = computeSize(schema);
+    cachedSizes.set(schema, size2);
+  }
+  return size2;
+}
+function PUBLIC_sizeOf(schema) {
+  return sizeOf(schema);
+}
+
+// src/data/array.ts
+var arrayOf = (elementType, elementCount) => new TgpuArrayImpl(elementType, elementCount);
+var TgpuArrayImpl = class {
+  constructor(elementType, elementCount) {
+    this.elementType = elementType;
+    this.elementCount = elementCount;
+    __publicField(this, "type", "array");
+    /** Type-token, not available at runtime */
+    __publicField(this, "~repr");
+    /** Type-token, not available at runtime */
+    __publicField(this, "~exotic");
+    if (Number.isNaN(sizeOf(elementType))) {
+      throw new Error("Cannot nest runtime sized arrays.");
+    }
+  }
+  toString() {
+    return `arrayOf(${this.elementType})`;
+  }
+};
+
+// src/data/ptr.ts
+function ptrFn(inner) {
+  return {
+    type: "ptrFn",
+    inner
+  };
+}
+
+// src/data/disarray.ts
+var disarrayOf = (elementType, count) => new DisarrayImpl(elementType, count);
+var DisarrayImpl = class {
+  constructor(elementType, elementCount) {
+    this.elementType = elementType;
+    this.elementCount = elementCount;
+    __publicField(this, "type", "disarray");
+    /** Type-token, not available at runtime */
+    __publicField(this, "~repr");
+  }
+};
+
+// src/data/unstruct.ts
+var unstruct = (properties) => new UnstructImpl(properties);
+var UnstructImpl = class {
+  constructor(propTypes) {
+    this.propTypes = propTypes;
+    __publicField(this, "type", "unstruct");
+    /** Type-token, not available at runtime */
+    __publicField(this, "~repr");
+  }
+};
+
+// src/data/matrix.ts
+function createMatSchema(options) {
+  const MatSchema = {
+    /** Type-token, not available at runtime */
+    "~repr": void 0,
+    type: options.type,
+    label: options.type
+  };
+  const construct = (...args) => {
+    if (inGPUMode()) {
+      return `${MatSchema.type}(${args.join(", ")})`;
+    }
+    const elements = [];
+    for (const arg of args) {
+      if (typeof arg === "number") {
+        elements.push(arg);
+      } else {
+        for (let i = 0; i < arg.length; ++i) {
+          elements.push(arg[i]);
+        }
+      }
+    }
+    for (let i = elements.length; i < options.columns * options.rows; ++i) {
+      elements.push(0);
+    }
+    return options.makeFromElements(...elements);
+  };
+  return Object.assign(construct, MatSchema);
+}
+var mat2x2Impl = class {
+  constructor(...elements) {
+    __publicField(this, "columns");
+    __publicField(this, "length", 4);
+    this.columns = [
+      this.makeColumn(elements[0], elements[1]),
+      this.makeColumn(elements[2], elements[3])
+    ];
+  }
+  get [0]() {
+    return this.columns[0].x;
+  }
+  get [1]() {
+    return this.columns[0].y;
+  }
+  get [2]() {
+    return this.columns[1].x;
+  }
+  get [3]() {
+    return this.columns[1].y;
+  }
+  set [0](value) {
+    this.columns[0].x = value;
+  }
+  set [1](value) {
+    this.columns[0].y = value;
+  }
+  set [2](value) {
+    this.columns[1].x = value;
+  }
+  set [3](value) {
+    this.columns[1].y = value;
+  }
+  "~resolve"() {
+    return `${this.kind}(${Array.from({ length: this.length }).map((_, i) => this[i]).join(", ")})`;
+  }
+};
+var mat2x2fImpl = class extends mat2x2Impl {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "kind", "mat2x2f");
+  }
+  makeColumn(e0, e1) {
+    return vec2f(e0, e1);
+  }
+};
+var mat3x3Impl = class {
+  constructor(...elements) {
+    __publicField(this, "columns");
+    __publicField(this, "length", 12);
+    this.columns = [
+      this.makeColumn(
+        elements[0],
+        elements[1],
+        elements[2]
+      ),
+      this.makeColumn(
+        elements[3],
+        elements[4],
+        elements[5]
+      ),
+      this.makeColumn(
+        elements[6],
+        elements[7],
+        elements[8]
+      )
+    ];
+  }
+  get [0]() {
+    return this.columns[0].x;
+  }
+  get [1]() {
+    return this.columns[0].y;
+  }
+  get [2]() {
+    return this.columns[0].z;
+  }
+  get [3]() {
+    return 0;
+  }
+  get [4]() {
+    return this.columns[1].x;
+  }
+  get [5]() {
+    return this.columns[1].y;
+  }
+  get [6]() {
+    return this.columns[1].z;
+  }
+  get [7]() {
+    return 0;
+  }
+  get [8]() {
+    return this.columns[2].x;
+  }
+  get [9]() {
+    return this.columns[2].y;
+  }
+  get [10]() {
+    return this.columns[2].z;
+  }
+  get [11]() {
+    return 0;
+  }
+  set [0](value) {
+    this.columns[0].x = value;
+  }
+  set [1](value) {
+    this.columns[0].y = value;
+  }
+  set [2](value) {
+    this.columns[0].z = value;
+  }
+  set [3](_) {
+  }
+  set [4](value) {
+    this.columns[1].x = value;
+  }
+  set [5](value) {
+    this.columns[1].y = value;
+  }
+  set [6](value) {
+    this.columns[1].z = value;
+  }
+  set [7](_) {
+  }
+  set [8](value) {
+    this.columns[2].x = value;
+  }
+  set [9](value) {
+    this.columns[2].y = value;
+  }
+  set [10](value) {
+    this.columns[2].z = value;
+  }
+  set [11](_) {
+  }
+  "~resolve"() {
+    return `${this.kind}(${this[0]}, ${this[1]}, ${this[2]}, ${this[4]}, ${this[5]}, ${this[6]}, ${this[8]}, ${this[9]}, ${this[10]})`;
+  }
+};
+var mat3x3fImpl = class extends mat3x3Impl {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "kind", "mat3x3f");
+  }
+  makeColumn(x, y, z) {
+    return vec3f(x, y, z);
+  }
+};
+var mat4x4Impl = class {
+  constructor(...elements) {
+    __publicField(this, "columns");
+    __publicField(this, "length", 16);
+    this.columns = [
+      this.makeColumn(
+        elements[0],
+        elements[1],
+        elements[2],
+        elements[3]
+      ),
+      this.makeColumn(
+        elements[4],
+        elements[5],
+        elements[6],
+        elements[7]
+      ),
+      this.makeColumn(
+        elements[8],
+        elements[9],
+        elements[10],
+        elements[11]
+      ),
+      this.makeColumn(
+        elements[12],
+        elements[13],
+        elements[14],
+        elements[15]
+      )
+    ];
+  }
+  get [0]() {
+    return this.columns[0].x;
+  }
+  get [1]() {
+    return this.columns[0].y;
+  }
+  get [2]() {
+    return this.columns[0].z;
+  }
+  get [3]() {
+    return this.columns[0].w;
+  }
+  get [4]() {
+    return this.columns[1].x;
+  }
+  get [5]() {
+    return this.columns[1].y;
+  }
+  get [6]() {
+    return this.columns[1].z;
+  }
+  get [7]() {
+    return this.columns[1].w;
+  }
+  get [8]() {
+    return this.columns[2].x;
+  }
+  get [9]() {
+    return this.columns[2].y;
+  }
+  get [10]() {
+    return this.columns[2].z;
+  }
+  get [11]() {
+    return this.columns[2].w;
+  }
+  get [12]() {
+    return this.columns[3].x;
+  }
+  get [13]() {
+    return this.columns[3].y;
+  }
+  get [14]() {
+    return this.columns[3].z;
+  }
+  get [15]() {
+    return this.columns[3].w;
+  }
+  set [0](value) {
+    this.columns[0].x = value;
+  }
+  set [1](value) {
+    this.columns[0].y = value;
+  }
+  set [2](value) {
+    this.columns[0].z = value;
+  }
+  set [3](value) {
+    this.columns[0].w = value;
+  }
+  set [4](value) {
+    this.columns[1].x = value;
+  }
+  set [5](value) {
+    this.columns[1].y = value;
+  }
+  set [6](value) {
+    this.columns[1].z = value;
+  }
+  set [7](value) {
+    this.columns[1].w = value;
+  }
+  set [8](value) {
+    this.columns[2].x = value;
+  }
+  set [9](value) {
+    this.columns[2].y = value;
+  }
+  set [10](value) {
+    this.columns[2].z = value;
+  }
+  set [11](value) {
+    this.columns[2].w = value;
+  }
+  set [12](value) {
+    this.columns[3].x = value;
+  }
+  set [13](value) {
+    this.columns[3].y = value;
+  }
+  set [14](value) {
+    this.columns[3].z = value;
+  }
+  set [15](value) {
+    this.columns[3].w = value;
+  }
+  "~resolve"() {
+    return `${this.kind}(${Array.from({ length: this.length }).map((_, i) => this[i]).join(", ")})`;
+  }
+};
+var mat4x4fImpl = class extends mat4x4Impl {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "kind", "mat4x4f");
+  }
+  makeColumn(x, y, z, w) {
+    return vec4f(x, y, z, w);
+  }
+};
+var mat2x2f = createMatSchema({
+  type: "mat2x2f",
+  rows: 2,
+  columns: 2,
+  makeFromElements: (...elements) => new mat2x2fImpl(...elements)
+});
+var mat3x3f = createMatSchema({
+  type: "mat3x3f",
+  rows: 3,
+  columns: 3,
+  makeFromElements: (...elements) => new mat3x3fImpl(...elements)
+});
+var mat4x4f = createMatSchema({
+  type: "mat4x4f",
+  rows: 4,
+  columns: 4,
+  makeFromElements: (...elements) => new mat4x4fImpl(...elements)
+});
+function matToArray(mat) {
+  if (mat.kind === "mat3x3f") {
+    return [
+      mat[0],
+      mat[1],
+      mat[2],
+      mat[4],
+      mat[5],
+      mat[6],
+      mat[8],
+      mat[9],
+      mat[10]
+    ];
+  }
+  return Array.from({ length: mat.length }).map((_, idx) => mat[idx]);
+}
+
+// src/data/atomic.ts
+function atomic(data) {
+  return new AtomicImpl(data);
+}
+var AtomicImpl = class {
+  constructor(inner) {
+    this.inner = inner;
+    __publicField(this, "type", "atomic");
+    /** Type-token, not available at runtime */
+    __publicField(this, "~repr");
+  }
+};
+
+// 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]);
+}
+function align(alignment, data) {
+  return attribute(data, { type: "@align", value: alignment });
+}
+function size(size2, data) {
+  return attribute(data, { type: "@size", value: size2 });
+}
+function location(location2, data) {
+  return attribute(data, { type: "@location", value: location2 });
+}
+function interpolate(interpolationType, data) {
+  return attribute(data, {
+    type: "@interpolate",
+    value: interpolationType
+    // biome-ignore lint/suspicious/noExplicitAny: <tired of lying to types>
+  });
+}
+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) => `${attrib.type}(${attrib.value}) `).join("");
+}
+var BaseDecoratedImpl = class {
+  constructor(inner, attribs) {
+    this.inner = inner;
+    this.attribs = attribs;
+    // Type-token, not available at runtime
+    __publicField(this, "~repr");
+    var _a, _b;
+    const alignAttrib = (_a = attribs.find(isAlignAttrib)) == null ? void 0 : _a.value;
+    const sizeAttrib = (_b = attribs.find(isSizeAttrib)) == null ? void 0 : _b.value;
+    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 {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "type", "decorated");
+  }
+};
+var LooseDecoratedImpl = class extends BaseDecoratedImpl {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "type", "loose-decorated");
+  }
+};
+
+// src/builtin.ts
+var builtin = {
+  vertexIndex: attribute(u32, {
+    type: "@builtin",
+    value: "vertex_index"
+  }),
+  instanceIndex: attribute(u32, {
+    type: "@builtin",
+    value: "instance_index"
+  }),
+  position: attribute(vec4f, {
+    type: "@builtin",
+    value: "position"
+  }),
+  clipDistances: attribute(arrayOf(u32, 8), {
+    type: "@builtin",
+    value: "clip_distances"
+  }),
+  frontFacing: attribute(f32, {
+    type: "@builtin",
+    value: "front_facing"
+  }),
+  fragDepth: attribute(f32, {
+    type: "@builtin",
+    value: "frag_depth"
+  }),
+  sampleIndex: attribute(u32, {
+    type: "@builtin",
+    value: "sample_index"
+  }),
+  sampleMask: attribute(u32, {
+    type: "@builtin",
+    value: "sample_mask"
+  }),
+  localInvocationId: attribute(vec3u, {
+    type: "@builtin",
+    value: "local_invocation_id"
+  }),
+  localInvocationIndex: attribute(u32, {
+    type: "@builtin",
+    value: "local_invocation_index"
+  }),
+  globalInvocationId: attribute(vec3u, {
+    type: "@builtin",
+    value: "global_invocation_id"
+  }),
+  workgroupId: attribute(vec3u, {
+    type: "@builtin",
+    value: "workgroup_id"
+  }),
+  numWorkgroups: attribute(vec3u, {
+    type: "@builtin",
+    value: "num_workgroups"
+  })
+};
+
+export {
+  isWgslData,
+  isWgslArray,
+  isWgslStruct,
+  isPtrFn,
+  isAtomic,
+  isAlignAttrib,
+  isSizeAttrib,
+  isLocationAttrib,
+  isInterpolateAttrib,
+  isBuiltinAttrib,
+  isDecorated,
+  bool,
+  u32,
+  i32,
+  f32,
+  f16,
+  struct,
+  roundUp,
+  vertexFormats,
+  kindToDefaultFormatMap,
+  isLooseData,
+  isDisarray,
+  isUnstruct,
+  isLooseDecorated,
+  getCustomLocation,
+  isData,
+  packedFormats,
+  uint8,
+  uint8x2,
+  uint8x4,
+  sint8,
+  sint8x2,
+  sint8x4,
+  unorm8,
+  unorm8x2,
+  unorm8x4,
+  snorm8,
+  snorm8x2,
+  snorm8x4,
+  uint16,
+  uint16x2,
+  uint16x4,
+  sint16,
+  sint16x2,
+  sint16x4,
+  unorm16,
+  unorm16x2,
+  unorm16x4,
+  snorm16,
+  snorm16x2,
+  snorm16x4,
+  float16,
+  float16x2,
+  float16x4,
+  float32,
+  float32x2,
+  float32x3,
+  float32x4,
+  uint32,
+  uint32x2,
+  uint32x3,
+  uint32x4,
+  sint32,
+  sint32x2,
+  sint32x3,
+  sint32x4,
+  unorm10_10_10_2,
+  unorm8x4_bgra,
+  alignmentOf,
+  customAlignmentOf,
+  PUBLIC_alignmentOf,
+  sizeOf,
+  PUBLIC_sizeOf,
+  arrayOf,
+  ptrFn,
+  disarrayOf,
+  unstruct,
+  mat2x2f,
+  mat3x3f,
+  mat4x4f,
+  matToArray,
+  atomic,
+  attribute,
+  align,
+  size,
+  location,
+  interpolate,
+  isBuiltin,
+  getAttributesString,
+  builtin
+};
+//# sourceMappingURL=chunk-2ZAQFPSX.js.map