@tapez/core 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/index.js

@@ -1,31 +1,557 @@
-/**
- * @tapez/core — Typed GPU schema system for WebGPU.
- *
- * Usage:
- *   import * as tapez from '@tapez/core'
- *
- *   const MyConfig = tapez.struct('MyConfig', {
- *     midPrice: tapez.f32,
- *     decimals: tapez.u32,
- *     color: tapez.vec4f,
- *   })
- */
-// Scalars
-export { f32, u32, i32, atomic } from './types';
-// Vectors
-export { vec2f, vec3f, vec4f, vec2u, vec3u, vec4u, vec2i, vec3i, vec4i } from './vectors';
-// Matrices
-export { mat2x2f, mat3x3f, mat4x4f } from './matrix';
-// Structs
-export { struct } from './struct';
-// Arrays
-export { arrayOf } from './array';
-// Constants
-export { constant as const } from './const';
-// Typed buffer
-export { TypedBuffer } from './typed-buffer';
-// Bind group helpers
-export { uniformEntry, storageEntry, bufferEntry } from './bind-helpers';
-// Layout utilities (for advanced use)
-export { roundUp, computeStructLayout } from './layout';
+// src/types.ts
+function scalar(wgslType, arrayKind) {
+  return Object.freeze({ kind: "scalar", wgslType, byteSize: 4, alignment: 4, arrayKind });
+}
+var f32 = scalar("f32", "f32");
+var u32 = scalar("u32", "u32");
+var i32 = scalar("i32", "i32");
+function atomic(inner) {
+  return Object.freeze({
+    kind: "atomic",
+    wgslType: `atomic<${inner.wgslType}>`,
+    byteSize: inner.byteSize,
+    alignment: inner.alignment,
+    inner,
+    arrayKind: inner.arrayKind
+  });
+}
+
+// src/vectors.ts
+function vec(components, componentType) {
+  const suffix = componentType.wgslType[0];
+  const wgslType = `vec${components}<${componentType.wgslType}>`;
+  let byteSize;
+  let alignment;
+  switch (components) {
+    case 2:
+      byteSize = 8;
+      alignment = 8;
+      break;
+    case 3:
+      byteSize = 12;
+      alignment = 16;
+      break;
+    case 4:
+      byteSize = 16;
+      alignment = 16;
+      break;
+  }
+  return Object.freeze({ kind: "vector", wgslType, byteSize, alignment, components, componentType });
+}
+var vec2f = vec(2, f32);
+var vec3f = vec(3, f32);
+var vec4f = vec(4, f32);
+var vec2u = vec(2, u32);
+var vec3u = vec(3, u32);
+var vec4u = vec(4, u32);
+var vec2i = vec(2, i32);
+var vec3i = vec(3, i32);
+var vec4i = vec(4, i32);
+
+// src/matrix.ts
+function mat(cols, rows, byteSize, alignment) {
+  return Object.freeze({
+    kind: "matrix",
+    wgslType: `mat${cols}x${rows}<f32>`,
+    byteSize,
+    alignment,
+    columns: cols,
+    rows
+  });
+}
+var mat2x2f = mat(2, 2, 16, 8);
+var mat3x3f = mat(3, 3, 48, 16);
+var mat4x4f = mat(4, 4, 64, 16);
+
+// src/layout.ts
+function roundUp(alignment, offset) {
+  return Math.ceil(offset / alignment) * alignment;
+}
+function computeStructLayout(fields) {
+  const layouts = [];
+  const offsets = {};
+  let offset = 0;
+  let maxAlignment = 1;
+  for (const { name, type } of fields) {
+    offset = roundUp(type.alignment, offset);
+    layouts.push({ name, type, offset });
+    offsets[name] = offset;
+    offset += type.byteSize;
+    if (type.alignment > maxAlignment) {
+      maxAlignment = type.alignment;
+    }
+  }
+  const byteSize = roundUp(maxAlignment, offset);
+  return { fields: layouts, byteSize, alignment: maxAlignment, offsets };
+}
+
+// src/struct.ts
+function struct(name, fields) {
+  const fieldOrder = Object.keys(fields);
+  const fieldEntries = fieldOrder.map((k) => {
+    const t = fields[k];
+    if (!t) throw new Error(`struct ${name}: missing field type for "${k}"`);
+    return { name: k, type: t };
+  });
+  const layout = computeStructLayout(fieldEntries);
+  const offsets = {};
+  for (const k of fieldOrder) {
+    const off = layout.offsets[k];
+    if (off === void 0) throw new Error(`struct ${name}: missing offset for "${k}"`);
+    offsets[k] = off;
+  }
+  const result = {
+    kind: "struct",
+    wgslType: name,
+    name,
+    byteSize: layout.byteSize,
+    alignment: layout.alignment,
+    fields,
+    offsets,
+    fieldOrder,
+    layout,
+    toWGSL() {
+      return structToWGSL(result);
+    },
+    withAtomics(atomicName, atomicFields) {
+      const atomicSet = new Set(atomicFields);
+      const newFields = {};
+      for (const k of fieldOrder) {
+        const fieldType = fields[k];
+        if (!fieldType) throw new Error(`withAtomics: missing field "${k}"`);
+        if (atomicSet.has(k)) {
+          if (fieldType.kind !== "scalar") {
+            throw new Error(`withAtomics: field "${k}" is not a scalar (got ${fieldType.kind})`);
+          }
+          newFields[k] = atomic(fieldType);
+        } else {
+          newFields[k] = fieldType;
+        }
+      }
+      return struct(atomicName, newFields);
+    }
+  };
+  return Object.freeze(result);
+}
+function structToWGSL(s) {
+  const lines = s.layout.fields.map((f) => `  ${f.name}: ${f.type.wgslType},`);
+  return `struct ${s.name} {
+${lines.join("\n")}
+}`;
+}
+
+// src/array.ts
+function arrayOf(elementType, count) {
+  const stride = roundUp(elementType.alignment, elementType.byteSize);
+  const byteSize = count * stride;
+  const alignment = elementType.alignment;
+  return Object.freeze({
+    kind: "array",
+    wgslType: `array<${elementType.wgslType}, ${count}>`,
+    byteSize,
+    alignment,
+    elementType,
+    count,
+    stride
+  });
+}
+
+// src/const.ts
+function constant(name, type, value) {
+  return Object.freeze({
+    kind: "const",
+    name,
+    type,
+    value,
+    toWGSL() {
+      return constToWGSL(name, type, value);
+    }
+  });
+}
+function constToWGSL(name, type, value) {
+  let literal;
+  switch (type.arrayKind) {
+    case "f32":
+      literal = Number.isInteger(value) ? `${value}.0` : `${value}`;
+      break;
+    case "u32":
+      literal = `${value >>> 0}u`;
+      break;
+    case "i32":
+      literal = `${value | 0}i`;
+      break;
+  }
+  return `const ${name}: ${type.wgslType} = ${literal};`;
+}
+
+// src/gpu-buffer-utils.ts
+var ZERO_U32_4_BUFFER = new ArrayBuffer(16);
+var INDIRECT_INIT_6_BUFFER = new ArrayBuffer(16);
+new Uint32Array(INDIRECT_INIT_6_BUFFER).set([6, 0, 0, 0]);
+var UniformBuffer = class {
+  buffer;
+  scratch;
+  u32;
+  i32;
+  f32;
+  byteSize;
+  constructor(device, label, byteSize, usage) {
+    if (byteSize <= 0) {
+      throw new Error(`UniformBuffer size must be positive, got ${byteSize}`);
+    }
+    if (byteSize % 4 !== 0) {
+      throw new Error(`UniformBuffer size must be 4-byte aligned, got ${byteSize}`);
+    }
+    this.byteSize = byteSize;
+    this.buffer = device.createBuffer({
+      label,
+      size: byteSize,
+      usage: usage ?? GPUBufferUsage.UNIFORM | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    this.scratch = new ArrayBuffer(byteSize);
+    this.u32 = new Uint32Array(this.scratch);
+    this.i32 = new Int32Array(this.scratch);
+    this.f32 = new Float32Array(this.scratch);
+  }
+  write(queue, offsetBytes = 0) {
+    queue.writeBuffer(this.buffer, offsetBytes, this.scratch);
+  }
+  destroy() {
+    this.buffer.destroy();
+  }
+};
+var DirtyUniformBuffer = class extends UniformBuffer {
+  _dirty = true;
+  /** Set a u32 value at index, marks dirty only if value changed */
+  setU32(i, v) {
+    if (this.u32[i] !== v) {
+      this.u32[i] = v;
+      this._dirty = true;
+    }
+  }
+  /** Set an i32 value at index, marks dirty only if value changed */
+  setI32(i, v) {
+    if (this.i32[i] !== v) {
+      this.i32[i] = v;
+      this._dirty = true;
+    }
+  }
+  /** Set an f32 value at index, marks dirty only if value changed */
+  setF32(i, v) {
+    if (this.f32[i] !== v) {
+      this.f32[i] = v;
+      this._dirty = true;
+    }
+  }
+  /** Force dirty state (use when external factors require re-upload) */
+  markDirty() {
+    this._dirty = true;
+  }
+  /** Returns true if any values have changed since last write */
+  get isDirty() {
+    return this._dirty;
+  }
+  /** Upload to GPU only if dirty, then clear dirty flag */
+  writeIfDirty(queue, offsetBytes = 0) {
+    if (!this._dirty) return;
+    this.write(queue, offsetBytes);
+    this._dirty = false;
+  }
+};
+
+// src/typed-buffer.ts
+var TypedBuffer = class _TypedBuffer {
+  /** The underlying DirtyUniformBuffer (provides typed array views: .f32, .u32, .i32) */
+  raw;
+  /** The tapez type this buffer was created from */
+  type;
+  /**
+   * Named field setters. Only available for struct types.
+   * For non-struct buffers this is an empty object.
+   */
+  set;
+  /**
+   * Named field getters. Only available for struct types.
+   * For non-struct buffers this is an empty object.
+   */
+  get;
+  constructor(raw, type) {
+    this.raw = raw;
+    this.type = type;
+    if (type.kind === "struct") {
+      const struct2 = type;
+      this.set = buildSetters(raw, struct2);
+      this.get = buildGetters(raw, struct2);
+    } else {
+      this.set = {};
+      this.get = {};
+    }
+  }
+  /** The raw GPUBuffer — for texture/sampler bind group entries only */
+  get buffer() {
+    return this.raw.buffer;
+  }
+  /** Total byte size of the buffer */
+  get byteSize() {
+    return this.raw.byteSize;
+  }
+  /** Whether any values have changed since last write */
+  get isDirty() {
+    return this.raw.isDirty;
+  }
+  /** Force dirty state (for external invalidation) */
+  markDirty() {
+    this.raw.markDirty();
+  }
+  /** Upload to GPU only if dirty, then clear dirty flag */
+  writeIfDirty(queue) {
+    this.raw.writeIfDirty(queue);
+  }
+  /** Upload to GPU unconditionally */
+  write(queue) {
+    this.raw.write(queue);
+  }
+  /**
+   * Bulk set multiple struct fields at once.
+   * Only available for struct-typed buffers.
+   */
+  writeFields(values) {
+    for (const key in values) {
+      if (Object.prototype.hasOwnProperty.call(values, key)) {
+        const setter = this.set[key];
+        if (setter) setter(values[key]);
+      }
+    }
+  }
+  /** Destroy the underlying GPU buffer */
+  destroy() {
+    this.raw.destroy();
+  }
+  // ---------------------------------------------------------------------------
+  // WebGPU API wrappers — so entity code never touches .buffer directly
+  // ---------------------------------------------------------------------------
+  /** Write raw data to this buffer via queue.writeBuffer */
+  writeRaw(queue, data, bufferOffset = 0, dataOffset, size) {
+    queue.writeBuffer(this.raw.buffer, bufferOffset, data, dataOffset, size);
+  }
+  /** Copy data from this buffer to another TypedBuffer */
+  copyTo(encoder, dest, srcOffset = 0, dstOffset = 0, size) {
+    encoder.copyBufferToBuffer(this.raw.buffer, srcOffset, dest.raw.buffer, dstOffset, size ?? this.raw.byteSize);
+  }
+  /** Copy data from another TypedBuffer into this buffer */
+  copyFrom(encoder, src, srcOffset = 0, dstOffset = 0, size) {
+    encoder.copyBufferToBuffer(src.raw.buffer, srcOffset, this.raw.buffer, dstOffset, size ?? src.raw.byteSize);
+  }
+  /** Use this buffer for drawIndirect */
+  drawIndirect(pass, offset = 0) {
+    pass.drawIndirect(this.raw.buffer, offset);
+  }
+  /** Use this buffer for dispatchWorkgroupsIndirect */
+  dispatchIndirect(pass, offset = 0) {
+    pass.dispatchWorkgroupsIndirect(this.raw.buffer, offset);
+  }
+  /** Map buffer for reading (for readback buffers). Returns the mapped ArrayBuffer. */
+  async mapRead() {
+    await this.raw.buffer.mapAsync(GPUMapMode.READ);
+    return this.raw.buffer.getMappedRange();
+  }
+  /** Unmap a previously mapped buffer */
+  unmap() {
+    this.raw.buffer.unmap();
+  }
+  // ---------------------------------------------------------------------------
+  // Factory methods
+  // ---------------------------------------------------------------------------
+  /** Create a buffer with explicit usage flags. Accepts any TapezType. */
+  static create(device, type, label, usage) {
+    const raw = new DirtyUniformBuffer(device, label, type.byteSize, usage | GPUBufferUsage.COPY_DST);
+    return new _TypedBuffer(raw, type);
+  }
+  /** Create a uniform buffer (UNIFORM | STORAGE | COPY_DST) */
+  static createUniform(device, type, label) {
+    return _TypedBuffer.create(
+      device,
+      type,
+      label,
+      GPUBufferUsage.UNIFORM | GPUBufferUsage.STORAGE
+    );
+  }
+  /** Create a storage buffer (STORAGE | COPY_DST). Pass extraFlags for COPY_SRC etc. */
+  static createStorage(device, type, label, extraFlags = 0) {
+    return _TypedBuffer.create(
+      device,
+      type,
+      label,
+      GPUBufferUsage.STORAGE | extraFlags
+    );
+  }
+  /** Create an indirect draw/dispatch buffer (INDIRECT | STORAGE | COPY_DST) */
+  static createIndirect(device, type, label) {
+    return _TypedBuffer.create(
+      device,
+      type,
+      label,
+      GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE
+    );
+  }
+  /** Create a readback buffer (MAP_READ | COPY_DST). For GPU→CPU data transfer. */
+  static createReadback(device, type, label) {
+    return _TypedBuffer.create(
+      device,
+      type,
+      label,
+      GPUBufferUsage.MAP_READ
+    );
+  }
+};
+function buildSetters(raw, schema) {
+  const setters = {};
+  for (const field of schema.layout.fields) {
+    setters[field.name] = createSetter(raw, field);
+  }
+  return setters;
+}
+function buildGetters(raw, schema) {
+  const getters = {};
+  for (const field of schema.layout.fields) {
+    getters[field.name] = createGetter(raw, field);
+  }
+  return getters;
+}
+function createSetter(raw, field) {
+  const type = field.type;
+  const byteOffset = field.offset;
+  switch (type.kind) {
+    case "scalar":
+    case "atomic": {
+      const index = byteOffset / 4;
+      const arrayKind = type.kind === "atomic" ? type.arrayKind : type.arrayKind;
+      switch (arrayKind) {
+        case "f32":
+          return (v) => raw.setF32(index, v);
+        case "u32":
+          return (v) => raw.setU32(index, v);
+        case "i32":
+          return (v) => raw.setI32(index, v);
+      }
+      break;
+    }
+    case "vector": {
+      const vec2 = type;
+      const startIndex = byteOffset / 4;
+      const count = vec2.components;
+      const arrayKind = vec2.componentType.arrayKind;
+      switch (arrayKind) {
+        case "f32":
+          return (v) => {
+            const arr = v;
+            for (let i = 0; i < count; i++) raw.setF32(startIndex + i, arr[i]);
+          };
+        case "u32":
+          return (v) => {
+            const arr = v;
+            for (let i = 0; i < count; i++) raw.setU32(startIndex + i, arr[i]);
+          };
+        case "i32":
+          return (v) => {
+            const arr = v;
+            for (let i = 0; i < count; i++) raw.setI32(startIndex + i, arr[i]);
+          };
+      }
+      break;
+    }
+    case "matrix": {
+      const startIndex = byteOffset / 4;
+      const floatCount = type.byteSize / 4;
+      return (v) => {
+        const arr = v;
+        for (let i = 0; i < floatCount; i++) raw.setF32(startIndex + i, arr[i]);
+      };
+    }
+    default:
+      return () => {
+      };
+  }
+}
+function createGetter(raw, field) {
+  const type = field.type;
+  const byteOffset = field.offset;
+  switch (type.kind) {
+    case "scalar":
+    case "atomic": {
+      const index = byteOffset / 4;
+      const arrayKind = type.kind === "atomic" ? type.arrayKind : type.arrayKind;
+      switch (arrayKind) {
+        case "f32":
+          return () => raw.f32[index];
+        case "u32":
+          return () => raw.u32[index];
+        case "i32":
+          return () => raw.i32[index];
+      }
+      break;
+    }
+    case "vector": {
+      const vec2 = type;
+      const startIndex = byteOffset / 4;
+      const count = vec2.components;
+      const arrayKind = vec2.componentType.arrayKind;
+      switch (arrayKind) {
+        case "f32":
+          return () => Array.from(raw.f32.subarray(startIndex, startIndex + count));
+        case "u32":
+          return () => Array.from(raw.u32.subarray(startIndex, startIndex + count));
+        case "i32":
+          return () => Array.from(raw.i32.subarray(startIndex, startIndex + count));
+      }
+      break;
+    }
+    case "matrix": {
+      const startIndex = byteOffset / 4;
+      const floatCount = type.byteSize / 4;
+      return () => Array.from(raw.f32.subarray(startIndex, startIndex + floatCount));
+    }
+    default:
+      return () => void 0;
+  }
+}
+
+// src/bind-helpers.ts
+function uniformEntry(binding, visibility) {
+  return { binding, visibility, buffer: { type: "uniform" } };
+}
+function storageEntry(binding, visibility, type = "storage") {
+  return { binding, visibility, buffer: { type } };
+}
+function bufferEntry(binding, buf) {
+  const gpuBuffer = "buffer" in buf && typeof buf.byteSize === "number" ? buf.buffer : buf;
+  return { binding, resource: { buffer: gpuBuffer } };
+}
+export {
+  TypedBuffer,
+  arrayOf,
+  atomic,
+  bufferEntry,
+  computeStructLayout,
+  constant as const,
+  f32,
+  i32,
+  mat2x2f,
+  mat3x3f,
+  mat4x4f,
+  roundUp,
+  storageEntry,
+  struct,
+  u32,
+  uniformEntry,
+  vec2f,
+  vec2i,
+  vec2u,
+  vec3f,
+  vec3i,
+  vec3u,
+  vec4f,
+  vec4i,
+  vec4u
+};
 //# sourceMappingURL=index.js.map