@aethervtt/shard-gpu-webgl2 0.0.0-stage → 0.2.0

package/dist/commands.js

@@ -0,0 +1,391 @@
+import { unsupported } from "./errors.js";
+const OP = {
+  BEGIN_PASS: 1,
+  END_PASS: 2,
+  SET_PIPELINE: 3,
+  SET_BIND_GROUP: 4,
+  SET_VERTEX_BUFFER: 5,
+  SET_INDEX_BUFFER: 6,
+  DRAW: 7,
+  DRAW_INDEXED: 8,
+  VIEWPORT: 9,
+  SCISSOR: 10,
+  STENCIL_REFERENCE: 11,
+  BLEND_CONSTANT: 12,
+  COPY_BUFFER: 13,
+  COPY_BUFFER_TO_TEXTURE: 14,
+  COPY_TEXTURE_TO_BUFFER: 15,
+  COPY_TEXTURE: 16,
+  CLEAR_BUFFER: 17,
+  BEGIN_QUERY: 18,
+  END_QUERY: 19,
+  RESOLVE_QUERIES: 20
+};
+class CommandStream {
+  nums = new Float64Array(1024);
+  n = 0;
+  refs = [];
+  r = 0;
+  num(value) {
+    if (this.n === this.nums.length) {
+      const grown = new Float64Array(this.nums.length * 2);
+      grown.set(this.nums);
+      this.nums = grown;
+    }
+    this.nums[this.n++] = value;
+  }
+  ref(value) {
+    this.refs[this.r++] = value;
+  }
+  /** Empties it, dropping its references so recorded objects can be collected. */
+  reset() {
+    for (let i = 0; i < this.r; i++) this.refs[i] = void 0;
+    this.n = 0;
+    this.r = 0;
+  }
+}
+class Webgl2CommandBuffer {
+  label = "";
+  /** What to replay; undefined once submitted. */
+  stream;
+  /** The encoder that made it, pooled again after the submit. */
+  encoder;
+  constructor(encoder) {
+    this.encoder = encoder;
+  }
+}
+function originOf(o, i) {
+  if (!o) return 0;
+  if (Array.isArray(o)) return o[i] ?? 0;
+  const d = o;
+  return (i === 0 ? d.x : i === 1 ? d.y : d.z) ?? 0;
+}
+function extentOf(e, i) {
+  if (Array.isArray(e)) return e[i] ?? 1;
+  const d = e;
+  return (i === 0 ? d.width : i === 1 ? d.height : d.depthOrArrayLayers) ?? 1;
+}
+function colorOf(c, i) {
+  if (!c) return 0;
+  if (Array.isArray(c)) return c[i] ?? 0;
+  const d = c;
+  return i === 0 ? d.r : i === 1 ? d.g : i === 2 ? d.b : d.a;
+}
+class Webgl2CommandEncoder {
+  label = "";
+  /** @internal The pass being recorded times itself (`timestampWrites`): its end ends the query. */
+  timedPass = false;
+  stream;
+  pass;
+  buffer;
+  constructor() {
+    this.pass = new Webgl2RenderPassEncoder(this);
+    this.buffer = new Webgl2CommandBuffer(this);
+  }
+  /** @internal Starts recording into `stream` (a new or pooled encoder). */
+  begin(stream, label) {
+    this.stream = stream;
+    this.label = label;
+    return this;
+  }
+  /** @internal The stream commands record into. */
+  get recording() {
+    const stream = this.stream;
+    if (!stream) throw new Error(`Command encoder "${this.label}" was already finished`);
+    return stream;
+  }
+  beginRenderPass(d) {
+    const s = this.recording;
+    if (d.occlusionQuerySet) throw unsupported(`run occlusion queries ("${d.label ?? this.label}")`);
+    const writes = d.timestampWrites;
+    const index = writes?.beginningOfPassWriteIndex ?? writes?.endOfPassWriteIndex;
+    this.timedPass = writes !== void 0 && index !== void 0;
+    if (this.timedPass) {
+      s.num(OP.BEGIN_QUERY);
+      s.num(index >> 1);
+      s.ref(writes.querySet);
+    }
+    s.num(OP.BEGIN_PASS);
+    const colors = d.colorAttachments;
+    s.num(colors.length);
+    for (let i = 0; i < colors.length; i++) {
+      const c = colors[i];
+      if (!c) {
+        s.num(0);
+        continue;
+      }
+      s.num(1);
+      s.ref(c.view);
+      s.ref(c.resolveTarget ?? null);
+      s.num(c.loadOp === "clear" ? 1 : 0);
+      s.num(c.storeOp === "discard" ? 1 : 0);
+      s.num(c.depthSlice ?? -1);
+      s.num(colorOf(c.clearValue, 0));
+      s.num(colorOf(c.clearValue, 1));
+      s.num(colorOf(c.clearValue, 2));
+      s.num(colorOf(c.clearValue, 3));
+    }
+    const ds = d.depthStencilAttachment;
+    if (!ds) {
+      s.num(0);
+    } else {
+      s.num(1);
+      s.ref(ds.view);
+      s.num(ds.depthLoadOp === "clear" ? 1 : 0);
+      s.num(ds.depthStoreOp === "discard" ? 1 : 0);
+      s.num(ds.depthClearValue ?? 0);
+      s.num(ds.depthReadOnly ? 1 : 0);
+      s.num(ds.stencilLoadOp === "clear" ? 1 : 0);
+      s.num(ds.stencilStoreOp === "discard" ? 1 : 0);
+      s.num(ds.stencilClearValue ?? 0);
+      s.num(ds.stencilReadOnly ? 1 : 0);
+    }
+    return this.pass;
+  }
+  beginComputePass(d) {
+    throw unsupported(
+      `run the compute pass "${d?.label ?? this.label}"`,
+      'Compute is the full tier: a feature that needs it registers baseline "unsupported" (0064).'
+    );
+  }
+  copyBufferToBuffer(source, a, b, c, d) {
+    const s = this.recording;
+    s.num(OP.COPY_BUFFER);
+    if (typeof a === "number") {
+      const destination = b;
+      s.num(a);
+      s.num(c ?? 0);
+      s.num(d ?? source.size - a);
+      s.ref(source);
+      s.ref(destination);
+    } else {
+      s.num(0);
+      s.num(0);
+      s.num(b ?? source.size);
+      s.ref(source);
+      s.ref(a);
+    }
+  }
+  copyBufferToTexture(source, destination, size) {
+    const s = this.recording;
+    const h = extentOf(size, 1);
+    s.num(OP.COPY_BUFFER_TO_TEXTURE);
+    s.num(source.offset ?? 0);
+    s.num(source.bytesPerRow ?? 0);
+    s.num(source.rowsPerImage ?? h);
+    s.num(destination.mipLevel ?? 0);
+    s.num(originOf(destination.origin, 0));
+    s.num(originOf(destination.origin, 1));
+    s.num(originOf(destination.origin, 2));
+    s.num(extentOf(size, 0));
+    s.num(h);
+    s.num(extentOf(size, 2));
+    s.ref(source.buffer);
+    s.ref(destination.texture);
+  }
+  copyTextureToBuffer(source, destination, size) {
+    const s = this.recording;
+    const h = extentOf(size, 1);
+    s.num(OP.COPY_TEXTURE_TO_BUFFER);
+    s.num(source.mipLevel ?? 0);
+    s.num(originOf(source.origin, 0));
+    s.num(originOf(source.origin, 1));
+    s.num(originOf(source.origin, 2));
+    s.num(destination.offset ?? 0);
+    s.num(destination.bytesPerRow ?? 0);
+    s.num(destination.rowsPerImage ?? h);
+    s.num(extentOf(size, 0));
+    s.num(h);
+    s.num(extentOf(size, 2));
+    s.ref(source.texture);
+    s.ref(destination.buffer);
+  }
+  copyTextureToTexture(source, destination, size) {
+    const s = this.recording;
+    s.num(OP.COPY_TEXTURE);
+    s.num(source.mipLevel ?? 0);
+    s.num(originOf(source.origin, 0));
+    s.num(originOf(source.origin, 1));
+    s.num(originOf(source.origin, 2));
+    s.num(destination.mipLevel ?? 0);
+    s.num(originOf(destination.origin, 0));
+    s.num(originOf(destination.origin, 1));
+    s.num(originOf(destination.origin, 2));
+    s.num(extentOf(size, 0));
+    s.num(extentOf(size, 1));
+    s.num(extentOf(size, 2));
+    s.ref(source.texture);
+    s.ref(destination.texture);
+  }
+  clearBuffer(buffer, offset = 0, size) {
+    const s = this.recording;
+    s.num(OP.CLEAR_BUFFER);
+    s.num(offset);
+    s.num(size ?? buffer.size - offset);
+    s.ref(buffer);
+  }
+  /** Pairs of the set to the buffer: written when the buffer is mapped (queries.ts). */
+  resolveQuerySet(querySet, firstQuery, queryCount, destination, destinationOffset) {
+    const s = this.recording;
+    s.num(OP.RESOLVE_QUERIES);
+    s.num(firstQuery);
+    s.num(queryCount);
+    s.num(destinationOffset);
+    s.ref(querySet);
+    s.ref(destination);
+  }
+  writeTimestamp() {
+    throw unsupported("write timestamps", "WebGL2 times passes (timestampWrites) only.");
+  }
+  pushDebugGroup() {
+  }
+  popDebugGroup() {
+  }
+  insertDebugMarker() {
+  }
+  finish(d) {
+    const buffer = this.buffer;
+    buffer.stream = this.recording;
+    buffer.label = d?.label ?? this.label;
+    this.stream = void 0;
+    return buffer;
+  }
+}
+class Webgl2RenderPassEncoder {
+  label = "";
+  encoder;
+  constructor(encoder) {
+    this.encoder = encoder;
+  }
+  setPipeline(pipeline) {
+    const s = this.encoder.recording;
+    s.num(OP.SET_PIPELINE);
+    s.ref(pipeline);
+  }
+  setBindGroup(index, group, offsets, start = 0, length) {
+    const s = this.encoder.recording;
+    s.num(OP.SET_BIND_GROUP);
+    s.num(index);
+    if (!offsets) {
+      s.num(0);
+    } else if (offsets instanceof Uint32Array) {
+      const n = length ?? offsets.length - start;
+      s.num(n);
+      for (let i = 0; i < n; i++) s.num(offsets[start + i]);
+    } else {
+      const list = Array.isArray(offsets) ? offsets : [...offsets];
+      s.num(list.length);
+      for (let i = 0; i < list.length; i++) s.num(list[i]);
+    }
+    s.ref(group);
+  }
+  setVertexBuffer(slot, buffer, offset = 0, size) {
+    const s = this.encoder.recording;
+    s.num(OP.SET_VERTEX_BUFFER);
+    s.num(slot);
+    s.num(offset);
+    s.num(size ?? (buffer ? buffer.size - offset : 0));
+    s.ref(buffer);
+  }
+  setIndexBuffer(buffer, format, offset = 0, size) {
+    const s = this.encoder.recording;
+    s.num(OP.SET_INDEX_BUFFER);
+    s.num(format === "uint32" ? 4 : 2);
+    s.num(offset);
+    s.num(size ?? buffer.size - offset);
+    s.ref(buffer);
+  }
+  draw(vertexCount, instanceCount = 1, firstVertex = 0, firstInstance = 0) {
+    const s = this.encoder.recording;
+    s.num(OP.DRAW);
+    s.num(vertexCount);
+    s.num(instanceCount);
+    s.num(firstVertex);
+    s.num(firstInstance);
+  }
+  drawIndexed(indexCount, instanceCount = 1, firstIndex = 0, baseVertex = 0, firstInstance = 0) {
+    const s = this.encoder.recording;
+    s.num(OP.DRAW_INDEXED);
+    s.num(indexCount);
+    s.num(instanceCount);
+    s.num(firstIndex);
+    s.num(baseVertex);
+    s.num(firstInstance);
+  }
+  drawIndirect() {
+    throw unsupported("draw indirectly", "The baseline tier culls on the CPU and draws directly.");
+  }
+  drawIndexedIndirect() {
+    throw unsupported("draw indirectly", "The baseline tier culls on the CPU and draws directly.");
+  }
+  setViewport(x, y, width, height, minDepth, maxDepth) {
+    const s = this.encoder.recording;
+    s.num(OP.VIEWPORT);
+    s.num(x);
+    s.num(y);
+    s.num(width);
+    s.num(height);
+    s.num(minDepth);
+    s.num(maxDepth);
+  }
+  setScissorRect(x, y, width, height) {
+    const s = this.encoder.recording;
+    s.num(OP.SCISSOR);
+    s.num(x);
+    s.num(y);
+    s.num(width);
+    s.num(height);
+  }
+  setStencilReference(reference) {
+    const s = this.encoder.recording;
+    s.num(OP.STENCIL_REFERENCE);
+    s.num(reference);
+  }
+  setBlendConstant(color) {
+    const s = this.encoder.recording;
+    s.num(OP.BLEND_CONSTANT);
+    s.num(colorOf(color, 0));
+    s.num(colorOf(color, 1));
+    s.num(colorOf(color, 2));
+    s.num(colorOf(color, 3));
+  }
+  executeBundles() {
+    throw unsupported("execute render bundles");
+  }
+  beginOcclusionQuery() {
+    throw unsupported("run occlusion queries");
+  }
+  endOcclusionQuery() {
+    throw unsupported("run occlusion queries");
+  }
+  pushDebugGroup() {
+  }
+  popDebugGroup() {
+  }
+  insertDebugMarker() {
+  }
+  end() {
+    const s = this.encoder.recording;
+    s.num(OP.END_PASS);
+    if (this.encoder.timedPass) {
+      s.num(OP.END_QUERY);
+      this.encoder.timedPass = false;
+    }
+  }
+}
+function layerOf(view, depthSlice) {
+  if (view.texture.dimension === "3d") return depthSlice < 0 ? 0 : depthSlice;
+  return view.baseArrayLayer;
+}
+function mipSize(size, mip) {
+  return Math.max(1, size >> mip);
+}
+export {
+  CommandStream,
+  OP,
+  Webgl2CommandBuffer,
+  Webgl2CommandEncoder,
+  Webgl2RenderPassEncoder,
+  layerOf,
+  mipSize
+};

package/dist/constants.d.ts

@@ -0,0 +1,41 @@
+export declare const BufferUsage: {
+    readonly MAP_READ: 1;
+    readonly MAP_WRITE: 2;
+    readonly COPY_SRC: 4;
+    readonly COPY_DST: 8;
+    readonly INDEX: 16;
+    readonly VERTEX: 32;
+    readonly UNIFORM: 64;
+    readonly STORAGE: 128;
+    readonly INDIRECT: 256;
+    readonly QUERY_RESOLVE: 512;
+};
+export declare const TextureUsage: {
+    readonly COPY_SRC: 1;
+    readonly COPY_DST: 2;
+    readonly TEXTURE_BINDING: 4;
+    readonly STORAGE_BINDING: 8;
+    readonly RENDER_ATTACHMENT: 16;
+};
+export declare const ShaderStage: {
+    readonly VERTEX: 1;
+    readonly FRAGMENT: 2;
+    readonly COMPUTE: 4;
+};
+export declare const MapMode: {
+    readonly READ: 1;
+    readonly WRITE: 2;
+};
+export declare const ColorWrite: {
+    readonly RED: 1;
+    readonly GREEN: 2;
+    readonly BLUE: 4;
+    readonly ALPHA: 8;
+    readonly ALL: 15;
+};
+/**
+ * Defines `GPUBufferUsage`, `GPUTextureUsage`, `GPUShaderStage`, `GPUMapMode` and `GPUColorWrite`
+ * on globalThis where the browser doesn't. Where it does (WebGPU and WebGL2 in one page), they
+ * stay: the values are the spec's either way.
+ */
+export declare function installGpuConstants(): void;

package/dist/constants.js

@@ -0,0 +1,38 @@
+const BufferUsage = {
+  MAP_READ: 1,
+  MAP_WRITE: 2,
+  COPY_SRC: 4,
+  COPY_DST: 8,
+  INDEX: 16,
+  VERTEX: 32,
+  UNIFORM: 64,
+  STORAGE: 128,
+  INDIRECT: 256,
+  QUERY_RESOLVE: 512
+};
+const TextureUsage = {
+  COPY_SRC: 1,
+  COPY_DST: 2,
+  TEXTURE_BINDING: 4,
+  STORAGE_BINDING: 8,
+  RENDER_ATTACHMENT: 16
+};
+const ShaderStage = { VERTEX: 1, FRAGMENT: 2, COMPUTE: 4 };
+const MapMode = { READ: 1, WRITE: 2 };
+const ColorWrite = { RED: 1, GREEN: 2, BLUE: 4, ALPHA: 8, ALL: 15 };
+function installGpuConstants() {
+  const g = globalThis;
+  g.GPUBufferUsage ??= BufferUsage;
+  g.GPUTextureUsage ??= TextureUsage;
+  g.GPUShaderStage ??= ShaderStage;
+  g.GPUMapMode ??= MapMode;
+  g.GPUColorWrite ??= ColorWrite;
+}
+export {
+  BufferUsage,
+  ColorWrite,
+  MapMode,
+  ShaderStage,
+  TextureUsage,
+  installGpuConstants
+};

package/dist/copies.d.ts

@@ -0,0 +1,61 @@
+import type { Webgl2Device } from './device.js';
+import type { GlFormat } from './formats.js';
+import { type ReadFormat } from './readback.js';
+import { type Webgl2Buffer, Webgl2Texture } from './resources.js';
+/** A texture read waiting for its buffer to be mapped: where it landed and how to repack it. */
+export interface ReadJob {
+    pack: WebGLBuffer | null;
+    packSize: number;
+    read: ReadFormat;
+    info: GlFormat;
+    width: number;
+    rows: number;
+    layers: number;
+    offset: number;
+    bytesPerRow: number;
+    rowsPerImage: number;
+}
+export declare class Copier {
+    private readonly device;
+    private readonly gl;
+    private readonly read;
+    private readonly draw;
+    private rowLength;
+    private imageHeight;
+    private readonly views;
+    private viewOffset;
+    private zeros;
+    private readonly packs;
+    private depthPrograms;
+    private depthTarget;
+    constructor(device: Webgl2Device);
+    writeTexture(texture: Webgl2Texture, mip: number, x: number, y: number, z: number, data: BufferSource, offset: number, bytesPerRow: number | undefined, rowsPerImage: number | undefined, width: number, height: number, depth: number): void;
+    copyExternal(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, width: number, height: number): void;
+    copyBuffer(src: Webgl2Buffer, srcOffset: number, dst: Webgl2Buffer, dstOffset: number, size: number): void;
+    clearBuffer(buffer: Webgl2Buffer, offset: number, size: number): void;
+    copyBufferToTexture(buffer: Webgl2Buffer, offset: number, bytesPerRow: number, rowsPerImage: number, texture: Webgl2Texture, mip: number, x: number, y: number, z: number, width: number, height: number, depth: number): void;
+    copyTextureToBuffer(texture: Webgl2Texture, mip: number, x: number, y: number, z: number, buffer: Webgl2Buffer, offset: number, bytesPerRow: number, rowsPerImage: number, width: number, height: number, depth: number): void;
+    /** Repacks a finished read into `out`, at the job's offset plus `shift`, and frees its pack buffer. */
+    finishRead(job: ReadJob, out: Uint8Array, shift: number): void;
+    releaseRead(job: ReadJob): void;
+    copyTexture(src: Webgl2Texture, srcMip: number, sx: number, sy: number, sz: number, dst: Webgl2Texture, dstMip: number, dx: number, dy: number, dz: number, width: number, height: number, depth: number): void;
+    /** Binds `texture`'s mip and layer as the read framebuffer. */
+    bindRead(texture: Webgl2Texture, mip: number, layer: number): void;
+    /** Forgets GL objects of a lost or destroyed device. */
+    clear(): void;
+    private unpack;
+    /**
+     * A typed array of the upload type over all of `buffer`, kept while uploads come from the same
+     * buffer; `viewOffset` is where `byteOffset` falls in it, in elements.
+     */
+    private view;
+    private compressed;
+    private compressedAt;
+    private pack;
+    /**
+     * Reads depth (which readPixels can't) by drawing it into an R32F target with texelFetch, then
+     * reading that as floats into the bound pack buffer at `at`.
+     */
+    private readDepth;
+    private depthProgram;
+}