oria-webgpu 0.1.1

package/dist/index.js

@@ -0,0 +1,623 @@
+class c extends Error {
+  constructor(e) {
+    super(`[oria] ${e}`), this.name = "OriaError";
+  }
+}
+function h(t, e) {
+  if (!t) throw new c(e);
+}
+async function R(t) {
+  if (!("gpu" in navigator) || !navigator.gpu)
+    throw new c(
+      "WebGPU is not supported in this browser. `navigator.gpu` is undefined. oria-webgpu requires a WebGPU-capable browser (Chrome/Edge 113+, or another browser with WebGPU enabled)."
+    );
+  const e = await navigator.gpu.requestAdapter({
+    powerPreference: t.powerPreference,
+    forceFallbackAdapter: t.forceFallbackAdapter
+  });
+  if (!e)
+    throw new c(
+      "No suitable GPUAdapter was found. navigator.gpu.requestAdapter() returned null (no compatible GPU, or the browser denied access)."
+    );
+  let n;
+  try {
+    n = await e.requestDevice({
+      label: t.deviceLabel,
+      requiredFeatures: t.requiredFeatures,
+      requiredLimits: t.requiredLimits
+    });
+  } catch (r) {
+    throw new c(
+      `adapter.requestDevice() failed: ${r instanceof Error ? r.message : String(r)}. Check that requiredFeatures/requiredLimits are actually supported by this adapter (see adapter.features/adapter.limits).`
+    );
+  }
+  return { adapter: e, device: n };
+}
+function $(t, e, n) {
+  const r = t.getContext("webgpu");
+  if (!r)
+    throw new c(
+      "canvas.getContext('webgpu') returned null. Ensure the canvas hasn't already acquired a different context type (e.g. '2d' or 'webgl')."
+    );
+  const i = n.format ?? navigator.gpu.getPreferredCanvasFormat();
+  return r.configure({
+    device: e,
+    format: i,
+    alphaMode: n.alphaMode ?? "opaque"
+  }), { context: r, format: i };
+}
+function T(t, e, n, r = typeof devicePixelRatio == "number" ? devicePixelRatio : 1) {
+  const i = e ?? t.clientWidth, a = n ?? t.clientHeight;
+  t.width = Math.max(1, Math.floor(i * r)), t.height = Math.max(1, Math.floor(a * r));
+}
+function O(t, e) {
+  return Math.ceil(t / e) * e;
+}
+const z = 4;
+function k(t) {
+  return O(t, z);
+}
+function q(t) {
+  return t instanceof ArrayBuffer, t.byteLength;
+}
+function A(t, e) {
+  const { data: n, usage: r, label: i } = e;
+  h(
+    n !== void 0 || e.size !== void 0,
+    "buffer descriptor must provide either `data` or `size`."
+  ), h(
+    e.size === void 0 || e.size > 0,
+    `invalid buffer size ${e.size} — must be greater than 0.`
+  );
+  const a = e.size ?? q(n), o = k(a), s = e.mappedAtCreation ?? n !== void 0, u = t.createBuffer({ label: i, size: o, usage: r, mappedAtCreation: s });
+  if (n !== void 0 && s) {
+    const f = new Uint8Array(u.getMappedRange()), d = n instanceof ArrayBuffer ? new Uint8Array(n) : new Uint8Array(n.buffer, n.byteOffset, n.byteLength);
+    f.set(d), u.unmap();
+  }
+  const l = {
+    raw: u,
+    size: o,
+    usage: r,
+    label: i,
+    write(f, d = 0) {
+      t.queue.writeBuffer(u, d, f instanceof ArrayBuffer ? f : f.buffer, f instanceof ArrayBuffer ? 0 : f.byteOffset, (f instanceof ArrayBuffer, f.byteLength));
+    },
+    destroy() {
+      u.destroy();
+    }
+  };
+  return n !== void 0 && !s && l.write(n), l;
+}
+const N = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC;
+function _(t, e) {
+  return A(t, {
+    label: e.label,
+    data: e.data,
+    size: e.size,
+    mappedAtCreation: e.mappedAtCreation,
+    usage: e.usage ?? N
+  });
+}
+function U(t, e, n, r) {
+  return {
+    raw: t,
+    width: e,
+    height: n,
+    format: r,
+    createView(i) {
+      return t.createView(i);
+    },
+    destroy() {
+      t.destroy();
+    }
+  };
+}
+function w(t, e) {
+  const n = t.createTexture({
+    label: e.label,
+    size: {
+      width: e.width,
+      height: e.height,
+      depthOrArrayLayers: e.depthOrArrayLayers ?? 1
+    },
+    format: e.format,
+    usage: e.usage,
+    mipLevelCount: e.mipLevelCount,
+    sampleCount: e.sampleCount,
+    dimension: e.dimension
+  });
+  return U(n, e.width, e.height, e.format);
+}
+function W(t) {
+  if (typeof HTMLCanvasElement < "u" && t instanceof HTMLCanvasElement)
+    return { width: t.width, height: t.height };
+  if (typeof OffscreenCanvas < "u" && t instanceof OffscreenCanvas)
+    return { width: t.width, height: t.height };
+  const e = t;
+  return { width: e.width, height: e.height };
+}
+function I(t, e) {
+  const { width: n, height: r } = W(e.source), i = e.format ?? "rgba8unorm", a = e.usage ?? GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, o = t.createTexture({
+    label: e.label,
+    size: { width: n, height: r },
+    format: i,
+    usage: a
+  });
+  return t.queue.copyExternalImageToTexture(
+    { source: e.source, flipY: e.flipY },
+    { texture: o, premultipliedAlpha: e.premultipliedAlpha },
+    { width: n, height: r }
+  ), U(o, n, r, i);
+}
+function j(t, e = {}) {
+  return t.createSampler(e);
+}
+async function x(t, e, n) {
+  const r = t.createBuffer({
+    label: e.label ? `${e.label}:readback-staging` : "readback-staging",
+    size: e.size,
+    usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+  }), i = t.createCommandEncoder();
+  i.copyBufferToBuffer(e.raw, 0, r, 0, e.size), t.queue.submit([i.finish()]), await r.mapAsync(GPUMapMode.READ);
+  const a = r.getMappedRange().slice(0);
+  return r.unmap(), r.destroy(), n ? new n(a) : a;
+}
+function m(t, e, n) {
+  const r = t.createShaderModule({ code: e, label: n });
+  return F(r, n), r;
+}
+async function F(t, e) {
+  if (!t.getCompilationInfo) return;
+  const r = (await t.getCompilationInfo()).messages.filter((o) => o.type === "error");
+  if (r.length === 0) return;
+  const i = r.map((o) => `  line ${o.lineNum}:${o.linePos} — ${o.message}`).join(`
+`), a = new c(`WGSL compilation failed${e ? ` in "${e}"` : ""}:
+${i}`);
+  console.error(a.message);
+}
+const V = /((?:@\w+\([^)]*\)\s*)+)var(<[^>]*>)?\s+(\w+)\s*:\s*([^;=]+)[;=]/g, D = /@(\w+)\(([^)]*)\)/g;
+function H(t) {
+  return t.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/.*$/gm, "");
+}
+function Y(t, e) {
+  if (t) {
+    const [r, i] = t.slice(1, -1).split(",").map((a) => a.trim());
+    if (r === "uniform") return "uniform-buffer";
+    if (r === "storage")
+      return i === "read_write" ? "storage-buffer" : "read-only-storage-buffer";
+  }
+  const n = e.trim();
+  return n === "sampler" ? "sampler" : n === "sampler_comparison" ? "comparison-sampler" : n.startsWith("texture_storage_") ? "storage-texture" : n === "texture_external" ? "external-texture" : n.startsWith("texture_") ? "texture" : "uniform-buffer";
+}
+function b(t) {
+  const e = H(t), n = [];
+  for (const r of e.matchAll(V)) {
+    const [, i, a, o, s] = r;
+    let u, l;
+    for (const f of i.matchAll(D)) {
+      const [, d, y] = f;
+      d === "group" && (u = Number(y)), d === "binding" && (l = Number(y));
+    }
+    u === void 0 || l === void 0 || n.push({
+      name: o,
+      group: u,
+      binding: l,
+      resourceType: Y(a, s),
+      wgslType: s.trim()
+    });
+  }
+  return n;
+}
+function J(t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const n of t) {
+    const r = e.get(n.group);
+    r ? r.push(n) : e.set(n.group, [n]);
+  }
+  return e;
+}
+function K(...t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const n of t)
+    for (const r of n)
+      e.set(r.name, r);
+  return [...e.values()];
+}
+function E(t) {
+  return typeof t == "object" && t !== null && "raw" in t && typeof t.write == "function";
+}
+function X(t) {
+  return typeof t == "object" && t !== null && !("raw" in t) && typeof t.destroy == "function" && typeof t.size == "number";
+}
+function v(t) {
+  return E(t) ? t.raw : t;
+}
+function Z(t) {
+  return typeof t == "object" && t !== null && "raw" in t && typeof t.createView == "function";
+}
+function Q(t) {
+  return typeof t == "object" && t !== null && !("raw" in t) && typeof t.createView == "function" && typeof t.destroy == "function";
+}
+function ee(t, e) {
+  const n = e.map((r) => `"${r.name}"`).join(", ");
+  return new c(
+    `Unknown shader binding "${t}" — no @group/@binding declaration for this name was found in the pipeline's WGSL.
+
+Declared bindings: ${n || "(none)"}`
+  );
+}
+function te(t, e) {
+  return new c(
+    `Binding "${t.name}" expected ${e}, based on its WGSL declaration:
+  @group(${t.group}) @binding(${t.binding}) var ... ${t.name}: ${t.wgslType};`
+  );
+}
+function ne(t, e) {
+  switch (t.resourceType) {
+    case "uniform-buffer":
+    case "storage-buffer":
+    case "read-only-storage-buffer": {
+      if (E(e) || X(e))
+        return { buffer: v(e) };
+      if (typeof e == "object" && e !== null && "buffer" in e) {
+        const { buffer: r, offset: i, size: a } = e;
+        return { buffer: v(r), offset: i, size: a };
+      }
+      throw te(t, "a GPUBuffer (or Oria Buffer)");
+    }
+    case "sampler":
+    case "comparison-sampler":
+      return e;
+    case "texture":
+    case "storage-texture":
+      return Z(e) || Q(e) ? e.createView() : e;
+    case "external-texture":
+      return e;
+  }
+}
+class S {
+  constructor(e, n, r) {
+    this.device = e, this.getBindGroupLayout = n, this.byName = new Map(r.map((i) => [i.name, i])), this.byGroup = J(r);
+  }
+  byName;
+  byGroup;
+  resourceCache = /* @__PURE__ */ new Map();
+  groupCache = /* @__PURE__ */ new Map();
+  get boundGroups() {
+    return this.groupCache;
+  }
+  apply(e) {
+    const n = /* @__PURE__ */ new Set();
+    for (const [r, i] of Object.entries(e)) {
+      const a = this.byName.get(r);
+      if (!a) throw ee(r, [...this.byName.values()]);
+      this.resourceCache.set(r, i), n.add(a.group);
+    }
+    for (const r of n) {
+      const i = this.buildGroup(r);
+      i && this.groupCache.set(r, i);
+    }
+  }
+  buildGroup(e) {
+    const n = this.byGroup.get(e) ?? [];
+    if (n.some((i) => !this.resourceCache.has(i.name))) return;
+    const r = n.map((i) => ({
+      binding: i.binding,
+      resource: ne(i, this.resourceCache.get(i.name))
+    }));
+    return this.device.createBindGroup({
+      layout: this.getBindGroupLayout(e),
+      entries: r
+    });
+  }
+}
+function re(t) {
+  return t === null ? null : typeof t == "string" ? { format: t } : t;
+}
+function ie(t, e) {
+  const n = m(
+    t,
+    e.vertex.code,
+    e.label ? `${e.label}:vertex` : void 0
+  ), r = e.fragment ? m(
+    t,
+    e.fragment.code,
+    e.label ? `${e.label}:fragment` : void 0
+  ) : void 0, i = t.createRenderPipeline({
+    label: e.label,
+    layout: e.layout ?? "auto",
+    vertex: {
+      module: n,
+      entryPoint: e.vertex.entryPoint,
+      buffers: e.vertex.buffers,
+      constants: e.vertex.constants
+    },
+    fragment: e.fragment ? {
+      module: r,
+      entryPoint: e.fragment.entryPoint,
+      targets: e.fragment.targets.map(re),
+      constants: e.fragment.constants
+    } : void 0,
+    primitive: e.primitive,
+    depthStencil: e.depthStencil,
+    multisample: e.multisample
+  }), a = K(
+    b(e.vertex.code),
+    e.fragment ? b(e.fragment.code) : []
+  ), o = new S(t, (u) => i.getBindGroupLayout(u), a), s = {
+    raw: i,
+    label: e.label,
+    bindings(u) {
+      return o.apply(u), s;
+    },
+    get boundGroups() {
+      return o.boundGroups;
+    }
+  };
+  return s;
+}
+function ae(t, e) {
+  const n = m(t, e.code, e.label), r = t.createComputePipeline({
+    label: e.label,
+    layout: e.layout ?? "auto",
+    compute: {
+      module: n,
+      entryPoint: e.entryPoint,
+      constants: e.constants
+    }
+  }), i = b(e.code), a = new S(t, (s) => r.getBindGroupLayout(s), i), o = {
+    raw: r,
+    label: e.label,
+    bindings(s) {
+      return a.apply(s), o;
+    },
+    get boundGroups() {
+      return a.boundGroups;
+    }
+  };
+  return o;
+}
+function g(t) {
+  if (t === void 0) return "undefined";
+  if (t === null || typeof t != "object") return JSON.stringify(t);
+  if (Array.isArray(t))
+    return `[${t.map(g).join(",")}]`;
+  const e = t;
+  return `{${Object.keys(e).sort().map((i) => `${JSON.stringify(i)}:${g(e[i])}`).join(",")}}`;
+}
+function L(t) {
+  let e = 2166136261;
+  for (let n = 0; n < t.length; n++)
+    e ^= t.charCodeAt(n), e = Math.imul(e, 16777619);
+  return (e >>> 0).toString(16);
+}
+const P = /* @__PURE__ */ new WeakMap();
+let oe = 0;
+function se(t) {
+  let e = P.get(t);
+  return e === void 0 && (e = `id${oe++}`, P.set(t, e)), e;
+}
+function M(t) {
+  return t === void 0 || t === "auto" ? "auto" : se(t);
+}
+function ue(t) {
+  const e = {
+    vertex: {
+      code: t.vertex.code,
+      entryPoint: t.vertex.entryPoint,
+      buffers: t.vertex.buffers,
+      constants: t.vertex.constants
+    },
+    fragment: t.fragment ? {
+      code: t.fragment.code,
+      entryPoint: t.fragment.entryPoint,
+      targets: t.fragment.targets,
+      constants: t.fragment.constants
+    } : void 0,
+    primitive: t.primitive,
+    depthStencil: t.depthStencil,
+    multisample: t.multisample,
+    layout: M(t.layout)
+  };
+  return L(g(e));
+}
+function fe(t) {
+  const e = {
+    code: t.code,
+    entryPoint: t.entryPoint,
+    constants: t.constants,
+    layout: M(t.layout)
+  };
+  return L(g(e));
+}
+class C {
+  constructor(e, n) {
+    this.keyOf = e, this.create = n;
+  }
+  cache = /* @__PURE__ */ new Map();
+  get(e) {
+    const n = this.keyOf(e);
+    let r = this.cache.get(n);
+    return r || (r = this.create(e), this.cache.set(n, r)), r;
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+function G(t, e) {
+  for (const [n, r] of e.boundGroups)
+    t.setBindGroup(n, r);
+}
+function ce(t) {
+  let e;
+  const n = {
+    raw: t,
+    pipeline(r) {
+      return t.setPipeline(r.raw), e = r, G(t, r), n;
+    },
+    bindings(r) {
+      return h(e !== void 0, "pass.bindings() requires pass.pipeline(...) to be called first."), e.bindings(r), G(t, e), n;
+    },
+    vertexBuffer(r, i, a, o) {
+      return t.setVertexBuffer(r, i.raw, a, o), n;
+    },
+    indexBuffer(r, i, a, o) {
+      return t.setIndexBuffer(r.raw, i, a, o), n;
+    },
+    draw(r, i, a, o) {
+      return t.draw(r, i, a, o), n;
+    },
+    drawIndexed(r, i, a, o, s) {
+      return t.drawIndexed(r, i, a, o, s), n;
+    }
+  };
+  return n;
+}
+function B(t, e) {
+  for (const [n, r] of e.boundGroups)
+    t.setBindGroup(n, r);
+}
+function le(t) {
+  let e;
+  const n = {
+    raw: t,
+    pipeline(r) {
+      return t.setPipeline(r.raw), e = r, B(t, r), n;
+    },
+    bindings(r) {
+      return h(e !== void 0, "pass.bindings() requires pass.pipeline(...) to be called first."), e.bindings(r), B(t, e), n;
+    },
+    dispatch(r, i, a) {
+      return t.dispatchWorkgroups(r, i, a), n;
+    }
+  };
+  return n;
+}
+function p(t, e, n) {
+  const r = t.createCommandEncoder({ label: e });
+  n(r), t.queue.submit([r.finish()]);
+}
+class de {
+  adapter;
+  device;
+  context;
+  format;
+  canvas;
+  options;
+  ownedBuffers = /* @__PURE__ */ new Set();
+  ownedTextures = /* @__PURE__ */ new Set();
+  deviceLostCallback;
+  renderPipelineCache;
+  computePipelineCache;
+  constructor(e, n, r, i, a, o) {
+    this.canvas = e, this.adapter = n, this.device = r, this.context = i, this.format = a, this.options = o, this.renderPipelineCache = new C(
+      ue,
+      (s) => ie(this.device, s)
+    ), this.computePipelineCache = new C(
+      fe,
+      (s) => ae(this.device, s)
+    ), r.lost.then((s) => {
+      this.deviceLostCallback?.(s);
+    });
+  }
+  buffer(e) {
+    const n = A(this.device, e);
+    return this.ownedBuffers.add(n), n;
+  }
+  storageBuffer(e) {
+    const n = _(this.device, e);
+    return this.ownedBuffers.add(n), n;
+  }
+  texture(e) {
+    const n = w(this.device, e);
+    return this.ownedTextures.add(n), n;
+  }
+  textureFromSource(e) {
+    const n = I(this.device, e);
+    return this.ownedTextures.add(n), n;
+  }
+  depthTexture(e = {}) {
+    const n = w(this.device, {
+      label: e.label,
+      width: e.width ?? this.canvas.width,
+      height: e.height ?? this.canvas.height,
+      format: e.format ?? "depth24plus",
+      sampleCount: e.sampleCount,
+      usage: GPUTextureUsage.RENDER_ATTACHMENT
+    });
+    return this.ownedTextures.add(n), n;
+  }
+  sampler(e) {
+    return j(this.device, e);
+  }
+  readBuffer(e, n) {
+    return n ? x(this.device, e, n) : x(this.device, e);
+  }
+  renderPipeline(e) {
+    const n = this.renderPipelineCache.get(e);
+    return e.bindings && n.bindings(e.bindings), n;
+  }
+  computePipeline(e) {
+    const n = this.computePipelineCache.get(e);
+    return e.bindings && n.bindings(e.bindings), n;
+  }
+  clearPipelineCache() {
+    this.renderPipelineCache.clear(), this.computePipelineCache.clear();
+  }
+  render(e, n) {
+    const r = typeof e == "function" ? {} : e, i = typeof e == "function" ? e : n;
+    h(i !== void 0, "render() requires a callback.");
+    const a = r.target ?? this.context.getCurrentTexture();
+    p(this.device, void 0, (o) => {
+      const s = o.beginRenderPass({
+        colorAttachments: [
+          {
+            view: a.createView(),
+            clearValue: r.clearColor ?? { r: 0, g: 0, b: 0, a: 1 },
+            loadOp: r.loadOp ?? "clear",
+            storeOp: r.storeOp ?? "store"
+          }
+        ]
+      });
+      i(ce(s)), s.end();
+    });
+  }
+  compute(e) {
+    p(this.device, void 0, (n) => {
+      const r = n.beginComputePass();
+      e(le(r)), r.end();
+    });
+  }
+  command(e) {
+    p(this.device, void 0, e);
+  }
+  resize(e = {}) {
+    T(
+      this.canvas,
+      e.width,
+      e.height,
+      e.pixelRatio ?? this.options.pixelRatio
+    );
+  }
+  onDeviceLost(e) {
+    this.deviceLostCallback = e;
+  }
+  dispose() {
+    for (const e of this.ownedBuffers) e.destroy();
+    this.ownedBuffers.clear();
+    for (const e of this.ownedTextures) e.destroy();
+    this.ownedTextures.clear(), this.device.destroy();
+  }
+}
+async function he(t, e = {}) {
+  const { adapter: n, device: r } = await R(e), { context: i, format: a } = $(t, r, e);
+  return T(t, void 0, void 0, e.pixelRatio), new de(t, n, r, i, a, e);
+}
+export {
+  c as OriaError,
+  k as alignBufferSize,
+  O as alignTo,
+  he as createGPU,
+  b as reflectWGSLBindings
+};
+//# sourceMappingURL=index.js.map