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

package/dist/fake-gl.js

@@ -0,0 +1,949 @@
+import { GL } from "./gl.js";
+const COMPONENTS = {
+  [GL.R8]: [1, "unorm"],
+  [GL.RG8]: [2, "unorm"],
+  [GL.RGBA8]: [4, "unorm"],
+  [GL.SRGB8_ALPHA8]: [4, "unorm"],
+  [GL.RGB10_A2]: [4, "unorm"],
+  [GL.R16F]: [1, "float"],
+  [GL.RG16F]: [2, "float"],
+  [GL.RGBA16F]: [4, "float"],
+  [GL.R32F]: [1, "float"],
+  [GL.RG32F]: [2, "float"],
+  [GL.RGBA32F]: [4, "float"],
+  [GL.R11F_G11F_B10F]: [3, "float"],
+  [GL.R8UI]: [1, "uint"],
+  [GL.RGBA8UI]: [4, "uint"],
+  [GL.R16UI]: [1, "uint"],
+  [GL.R32UI]: [1, "uint"],
+  [GL.RG32UI]: [2, "uint"],
+  [GL.RGBA32UI]: [4, "uint"],
+  [GL.DEPTH_COMPONENT16]: [1, "depth"],
+  [GL.DEPTH_COMPONENT24]: [1, "depth"],
+  [GL.DEPTH_COMPONENT32F]: [1, "depth"],
+  [GL.DEPTH24_STENCIL8]: [1, "depth"],
+  [GL.DEPTH32F_STENCIL8]: [1, "depth"],
+  [GL.STENCIL_INDEX8]: [1, "stencil"]
+};
+function formatComponents(format) {
+  switch (format) {
+    case GL.RED:
+    case GL.RED_INTEGER:
+    case GL.DEPTH_COMPONENT:
+      return 1;
+    case GL.RG:
+    case GL.RG_INTEGER:
+      return 2;
+    case GL.RGB:
+      return 3;
+    default:
+      return 4;
+  }
+}
+function typeSize(type) {
+  switch (type) {
+    case GL.UNSIGNED_BYTE:
+    case GL.BYTE:
+      return 1;
+    case GL.UNSIGNED_SHORT:
+    case GL.SHORT:
+    case GL.HALF_FLOAT:
+      return 2;
+    default:
+      return 4;
+  }
+}
+const packed = (type) => type === GL.UNSIGNED_INT_10F_11F_11F_REV || type === GL.UNSIGNED_INT_2_10_10_10_REV || type === GL.UNSIGNED_INT_24_8;
+function halfToFloat(h) {
+  const s = h & 32768 ? -1 : 1;
+  const e = h >> 10 & 31;
+  const m = h & 1023;
+  if (e === 0) return s * m * 2 ** -24;
+  if (e === 31) return m ? Number.NaN : s * Number.POSITIVE_INFINITY;
+  return s * (1 + m / 1024) * 2 ** (e - 15);
+}
+function ufloat(bits, mantissa) {
+  const e = bits >>> mantissa;
+  const m = bits & (1 << mantissa) - 1;
+  if (e === 0) return m / (1 << mantissa) * 2 ** -14;
+  if (e === 31) return m ? Number.NaN : Number.POSITIVE_INFINITY;
+  return (1 + m / (1 << mantissa)) * 2 ** (e - 15);
+}
+class FakeGl {
+  canvas;
+  /** Method names, in call order. */
+  calls = [];
+  draws = [];
+  /** Whether draws are recorded (off for allocation checks: a record is an allocation). */
+  recordDraws = true;
+  /** GL errors to hand out from getError. */
+  errors = [];
+  /** The default framebuffer's texels (the canvas), 4 components each. */
+  backbuffer;
+  lost = false;
+  /** Calls made on extensions, by name. */
+  extensionCalls = [];
+  options;
+  next = 1;
+  extensions = /* @__PURE__ */ new Map();
+  bound = /* @__PURE__ */ new Map();
+  ranges = [];
+  defaultVao;
+  vao;
+  program = null;
+  active = 0;
+  units = [];
+  samplers = [];
+  drawFb = null;
+  readFb = null;
+  renderbuffer = null;
+  enabled = /* @__PURE__ */ new Set();
+  pixel = /* @__PURE__ */ new Map();
+  viewport_ = [0, 0, 300, 150];
+  scissor_ = [0, 0, 300, 150];
+  colorMask_ = [true, true, true, true];
+  depthMask_ = true;
+  depthFunc_ = GL.LESS;
+  frontFace_ = GL.CCW;
+  cullFace_ = GL.BACK;
+  blend_ = [GL.FUNC_ADD, GL.FUNC_ADD, GL.ONE, GL.ZERO, GL.ONE, GL.ZERO];
+  clearColor_ = [0, 0, 0, 0];
+  pendingLinks = 0;
+  constructor(options = {}) {
+    this.options = options;
+    const listeners = /* @__PURE__ */ new Map();
+    this.canvas = {
+      width: 300,
+      height: 150,
+      listeners,
+      addEventListener: (type, l) => listeners.set(type, [...listeners.get(type) ?? [], l]),
+      removeEventListener: (type, l) => listeners.set(
+        type,
+        (listeners.get(type) ?? []).filter((x) => x !== l)
+      ),
+      dispatch: (type) => {
+        const event = { type, defaultPrevented: false, preventDefault() {
+        } };
+        for (const l of listeners.get(type) ?? []) l(event);
+      }
+    };
+    this.backbuffer = new Float64Array(300 * 150 * 4);
+    this.defaultVao = { kind: "vao", id: 0, element: null, attribs: [] };
+    this.vao = this.defaultVao;
+    const fn = (name) => () => this.extensionCalls.push(name);
+    const all = {
+      EXT_color_buffer_float: {},
+      EXT_float_blend: {},
+      OES_texture_float_linear: {},
+      EXT_texture_filter_anisotropic: {},
+      KHR_parallel_shader_compile: {},
+      EXT_clip_control: { clipControlEXT: fn("clipControlEXT") },
+      OES_draw_buffers_indexed: {
+        enableiOES: fn("enableiOES"),
+        disableiOES: fn("disableiOES"),
+        blendEquationSeparateiOES: fn("blendEquationSeparateiOES"),
+        blendFuncSeparateiOES: fn("blendFuncSeparateiOES"),
+        colorMaskiOES: fn("colorMaskiOES")
+      },
+      WEBGL_lose_context: {
+        loseContext: () => {
+          this.extensionCalls.push("loseContext");
+          this.lost = true;
+        },
+        restoreContext: () => {
+          this.lost = false;
+        }
+      }
+    };
+    for (const [name, ext] of Object.entries(all)) {
+      if (!options.without?.includes(name)) this.extensions.set(name, ext);
+    }
+  }
+  /** The fake as the context type the shim takes, logging every call. */
+  get context() {
+    return new Proxy(this, {
+      get: (target, key) => {
+        const value = Reflect.get(target, key);
+        if (typeof value !== "function") return value;
+        return (...args) => {
+          target.calls.push(String(key));
+          return value.apply(target, args);
+        };
+      }
+    });
+  }
+  /** Calls since `mark` (an index into `calls`), by name. */
+  callsSince(mark) {
+    return this.calls.slice(mark);
+  }
+  /** Texel `(x, y)` of `texture`'s level and layer, 4 components. */
+  texel(texture, x, y, level = 0, layer = 0) {
+    const [image, w, h] = this.image(texture, level);
+    const i = ((layer * h + y) * w + x) * 4;
+    return [image[i], image[i + 1], image[i + 2], image[i + 3]];
+  }
+  // --- context state -----------------------------------------------------------------
+  isContextLost() {
+    return this.lost;
+  }
+  getExtension(name) {
+    return this.extensions.get(name) ?? null;
+  }
+  getParameter(p) {
+    const o = this.options.parameters?.[p];
+    if (o !== void 0) return o;
+    switch (p) {
+      case GL.MAX_TEXTURE_SIZE:
+      case GL.MAX_CUBE_MAP_TEXTURE_SIZE:
+        return 8192;
+      case GL.MAX_3D_TEXTURE_SIZE:
+        return 2048;
+      case GL.MAX_ARRAY_TEXTURE_LAYERS:
+        return 2048;
+      case GL.MAX_TEXTURE_IMAGE_UNITS:
+      case GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+        return 16;
+      case GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS:
+        return 32;
+      case GL.MAX_DRAW_BUFFERS:
+      case GL.MAX_COLOR_ATTACHMENTS:
+        return 8;
+      case GL.MAX_VERTEX_ATTRIBS:
+        return 16;
+      case GL.MAX_VARYING_COMPONENTS:
+        return 120;
+      case GL.MAX_UNIFORM_BLOCK_SIZE:
+        return 65536;
+      case GL.MAX_VERTEX_UNIFORM_BLOCKS:
+      case GL.MAX_FRAGMENT_UNIFORM_BLOCKS:
+        return 14;
+      case GL.MAX_UNIFORM_BUFFER_BINDINGS:
+        return 72;
+      case GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT:
+        return 256;
+      case GL.MAX_SAMPLES:
+        return 8;
+      case GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT:
+        return 16;
+      case GL.VENDOR:
+      case GL.UNMASKED_VENDOR_WEBGL:
+        return "Shard";
+      case GL.RENDERER:
+      case GL.UNMASKED_RENDERER_WEBGL:
+        return "Fake WebGL2";
+      default:
+        return 0;
+    }
+  }
+  getInternalformatParameter(_target, internal, _p) {
+    return new Int32Array(this.options.samples?.[internal] ?? [8, 4, 2]);
+  }
+  getError() {
+    return this.errors.shift() ?? GL.NO_ERROR;
+  }
+  enable(cap) {
+    this.enabled.add(cap);
+  }
+  disable(cap) {
+    this.enabled.delete(cap);
+  }
+  pixelStorei(p, v) {
+    this.pixel.set(p, v);
+  }
+  viewport(x, y, w, h) {
+    const v = this.viewport_;
+    v[0] = x;
+    v[1] = y;
+    v[2] = w;
+    v[3] = h;
+  }
+  scissor(x, y, w, h) {
+    const v = this.scissor_;
+    v[0] = x;
+    v[1] = y;
+    v[2] = w;
+    v[3] = h;
+  }
+  depthRange() {
+  }
+  colorMask(r, g, b, a) {
+    const m = this.colorMask_;
+    m[0] = r;
+    m[1] = g;
+    m[2] = b;
+    m[3] = a;
+  }
+  depthMask(on) {
+    this.depthMask_ = on;
+  }
+  depthFunc(f) {
+    this.depthFunc_ = f;
+  }
+  frontFace(f) {
+    this.frontFace_ = f;
+  }
+  cullFace(f) {
+    this.cullFace_ = f;
+  }
+  blendEquationSeparate(c, a) {
+    this.blend_[0] = c;
+    this.blend_[1] = a;
+  }
+  blendFuncSeparate(cs, cd, as, ad) {
+    this.blend_[2] = cs;
+    this.blend_[3] = cd;
+    this.blend_[4] = as;
+    this.blend_[5] = ad;
+  }
+  blendColor() {
+  }
+  polygonOffset() {
+  }
+  stencilOpSeparate() {
+  }
+  stencilFuncSeparate() {
+  }
+  stencilMask() {
+  }
+  clearColor(r, g, b, a) {
+    this.clearColor_ = [r, g, b, a];
+  }
+  flush() {
+  }
+  hint() {
+  }
+  // --- buffers --------------------------------------------------------------------
+  createBuffer() {
+    return { kind: "buffer", id: this.next++, data: new Uint8Array(0), deleted: false };
+  }
+  deleteBuffer(b) {
+    if (b) b.deleted = true;
+  }
+  bindBuffer(target, b) {
+    if (target === GL.ELEMENT_ARRAY_BUFFER) this.vao.element = b;
+    else this.bound.set(target, b);
+  }
+  buffer(target) {
+    const b = target === GL.ELEMENT_ARRAY_BUFFER ? this.vao.element : this.bound.get(target);
+    if (!b) throw new Error(`Fake GL: no buffer bound to 0x${target.toString(16)}`);
+    return b;
+  }
+  bufferData(target, sizeOrData) {
+    const b = this.buffer(target);
+    b.data = typeof sizeOrData === "number" ? new Uint8Array(sizeOrData) : new Uint8Array(
+      sizeOrData.buffer.slice(
+        sizeOrData.byteOffset,
+        sizeOrData.byteOffset + sizeOrData.byteLength
+      )
+    );
+  }
+  bufferSubData(target, offset, src, srcOffset = 0, length = 0) {
+    const b = this.buffer(target);
+    const view = ArrayBuffer.isView(src) ? src : new Uint8Array(src);
+    const unit = view.BYTES_PER_ELEMENT ?? 1;
+    const count = length || view.byteLength / unit - srcOffset;
+    const bytes = new Uint8Array(view.buffer, view.byteOffset + srcOffset * unit, count * unit);
+    if (offset + bytes.length > b.data.length)
+      throw new Error("Fake GL: bufferSubData out of range");
+    b.data.set(bytes, offset);
+  }
+  copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size) {
+    const from = this.buffer(readTarget);
+    const to = this.buffer(writeTarget);
+    to.data.set(from.data.slice(readOffset, readOffset + size), writeOffset);
+  }
+  getBufferSubData(target, offset, dst, dstOffset = 0, length = 0) {
+    const b = this.buffer(target);
+    const unit = dst.BYTES_PER_ELEMENT ?? 1;
+    const count = (length || dst.byteLength / unit - dstOffset) * unit;
+    new Uint8Array(dst.buffer, dst.byteOffset + dstOffset * unit, count).set(
+      b.data.subarray(offset, offset + count)
+    );
+  }
+  bindBufferRange(_target, point, b, offset, size) {
+    let r = this.ranges[point];
+    if (!r) {
+      r = { buffer: null, offset: 0, size: 0 };
+      this.ranges[point] = r;
+    }
+    r.buffer = b;
+    r.offset = offset;
+    r.size = size;
+  }
+  // --- textures -------------------------------------------------------------------
+  createTexture() {
+    return {
+      kind: "texture",
+      id: this.next++,
+      target: 0,
+      internal: 0,
+      width: 0,
+      height: 0,
+      depth: 0,
+      levels: 0,
+      images: [],
+      params: /* @__PURE__ */ new Map(),
+      deleted: false
+    };
+  }
+  deleteTexture(t) {
+    if (t) t.deleted = true;
+  }
+  activeTexture(unit) {
+    this.active = unit - GL.TEXTURE0;
+  }
+  bindTexture(target, t) {
+    let unit = this.units[this.active];
+    if (!unit) {
+      unit = /* @__PURE__ */ new Map();
+      this.units[this.active] = unit;
+    }
+    unit.set(target, t);
+    if (t && !t.target) t.target = target;
+  }
+  boundTexture(target) {
+    const base = target >= GL.TEXTURE_CUBE_MAP_POSITIVE_X && target < GL.TEXTURE_CUBE_MAP_POSITIVE_X + 6;
+    const t = this.units[this.active]?.get(base ? GL.TEXTURE_CUBE_MAP : target);
+    if (!t) throw new Error(`Fake GL: no texture bound to 0x${target.toString(16)}`);
+    return t;
+  }
+  texStorage2D(target, levels, internal, w, h) {
+    this.storage(
+      this.boundTexture(target),
+      levels,
+      internal,
+      w,
+      h,
+      target === GL.TEXTURE_CUBE_MAP ? 6 : 1
+    );
+  }
+  texStorage3D(target, levels, internal, w, h, d) {
+    this.storage(this.boundTexture(target), levels, internal, w, h, d);
+  }
+  storage(t, levels, internal, w, h, d) {
+    t.internal = internal;
+    t.width = w;
+    t.height = h;
+    t.depth = d;
+    t.levels = levels;
+    for (let l = 0; l < levels; l++) {
+      const layers = t.target === GL.TEXTURE_3D ? Math.max(1, d >> l) : d;
+      t.images.push(new Float64Array(Math.max(1, w >> l) * Math.max(1, h >> l) * layers * 4));
+    }
+  }
+  texParameteri(target, p, v) {
+    this.boundTexture(target).params.set(p, v);
+  }
+  texSubImage2D(target, level, x, y, w, h, format, type, src, srcOffset = 0) {
+    const t = this.boundTexture(target);
+    const face = target === GL.TEXTURE_2D ? 0 : target - GL.TEXTURE_CUBE_MAP_POSITIVE_X;
+    this.upload(t, level, x, y, face, w, h, 1, format, type, src, srcOffset);
+  }
+  texSubImage3D(target, level, x, y, z, w, h, d, format, type, src, srcOffset = 0) {
+    this.upload(this.boundTexture(target), level, x, y, z, w, h, d, format, type, src, srcOffset);
+  }
+  compressedTexSubImage2D() {
+  }
+  compressedTexSubImage3D() {
+  }
+  upload(t, level, x, y, z, w, h, d, format, type, src, srcOffset) {
+    let bytes;
+    let start;
+    if (typeof src === "number") {
+      bytes = this.buffer(GL.PIXEL_UNPACK_BUFFER).data;
+      start = src;
+    } else if (src && ArrayBuffer.isView(src)) {
+      bytes = new Uint8Array(src.buffer, src.byteOffset, src.byteLength);
+      start = srcOffset * (src.BYTES_PER_ELEMENT ?? 1);
+    } else {
+      return;
+    }
+    const comps = formatComponents(format);
+    const size = typeSize(type);
+    const texelBytes = packed(type) ? 4 : comps * size;
+    const rowLength = this.pixel.get(GL.UNPACK_ROW_LENGTH) || w;
+    const imageHeight = this.pixel.get(GL.UNPACK_IMAGE_HEIGHT) || h;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const [image, iw, ih] = this.image(t, level);
+    const integer = COMPONENTS[t.internal]?.[1] === "uint";
+    for (let k = 0; k < d; k++) {
+      for (let r = 0; r < h; r++) {
+        for (let c = 0; c < w; c++) {
+          const at = start + ((k * imageHeight + r) * rowLength + c) * texelBytes;
+          const o = (((z + k) * ih + y + r) * iw + x + c) * 4;
+          const values = decode(view, at, comps, type, integer);
+          for (let i = 0; i < 4; i++) image[o + i] = values[i];
+        }
+      }
+    }
+  }
+  image(t, level) {
+    if (t.kind === "renderbuffer") return [t.image, t.width, t.height];
+    return [t.images[level], Math.max(1, t.width >> level), Math.max(1, t.height >> level)];
+  }
+  // --- samplers -----------------------------------------------------------------------
+  createSampler() {
+    return { kind: "sampler", id: this.next++, params: /* @__PURE__ */ new Map() };
+  }
+  samplerParameteri(s, p, v) {
+    s.params.set(p, v);
+  }
+  samplerParameterf(s, p, v) {
+    s.params.set(p, v);
+  }
+  bindSampler(unit, s) {
+    this.samplers[unit] = s;
+  }
+  // --- framebuffers -------------------------------------------------------------------
+  createRenderbuffer() {
+    return {
+      kind: "renderbuffer",
+      id: this.next++,
+      internal: 0,
+      width: 0,
+      height: 0,
+      samples: 0,
+      image: new Float64Array(0),
+      deleted: false
+    };
+  }
+  deleteRenderbuffer(r) {
+    if (r) r.deleted = true;
+  }
+  bindRenderbuffer(_target, r) {
+    this.renderbuffer = r;
+  }
+  renderbufferStorage(_target, internal, w, h) {
+    this.renderbufferStorageMultisample(_target, 0, internal, w, h);
+  }
+  renderbufferStorageMultisample(_target, samples, internal, w, h) {
+    const r = this.renderbuffer;
+    r.samples = samples;
+    r.internal = internal;
+    r.width = w;
+    r.height = h;
+    r.image = new Float64Array(w * h * 4);
+  }
+  createFramebuffer() {
+    return {
+      kind: "framebuffer",
+      id: this.next++,
+      attachments: /* @__PURE__ */ new Map(),
+      drawBuffers: [GL.COLOR_ATTACHMENT0],
+      readBuffer: GL.COLOR_ATTACHMENT0,
+      deleted: false
+    };
+  }
+  deleteFramebuffer(f) {
+    if (f) f.deleted = true;
+  }
+  bindFramebuffer(target, f) {
+    if (target === GL.FRAMEBUFFER || target === GL.DRAW_FRAMEBUFFER) this.drawFb = f;
+    if (target === GL.FRAMEBUFFER || target === GL.READ_FRAMEBUFFER) this.readFb = f;
+  }
+  framebufferTexture2D(_target, point, texTarget, t, level) {
+    const face = texTarget === GL.TEXTURE_2D ? 0 : texTarget - GL.TEXTURE_CUBE_MAP_POSITIVE_X;
+    if (t) this.drawFb.attachments.set(point, { object: t, level, layer: face });
+  }
+  framebufferTextureLayer(_target, point, t, level, layer) {
+    if (t) this.drawFb.attachments.set(point, { object: t, level, layer });
+  }
+  framebufferRenderbuffer(_target, point, _rt, r) {
+    if (r) this.drawFb.attachments.set(point, { object: r, level: 0, layer: 0 });
+  }
+  drawBuffers(buffers) {
+    this.drawFb.drawBuffers = [...buffers];
+  }
+  readBuffer(b) {
+    this.readFb.readBuffer = b;
+  }
+  checkFramebufferStatus() {
+    return GL.FRAMEBUFFER_COMPLETE;
+  }
+  invalidateFramebuffer() {
+  }
+  /** The attachment a color draw buffer writes, or the depth/stencil one. */
+  attachment(fb, point) {
+    if (point === GL.DEPTH_ATTACHMENT || point === GL.STENCIL_ATTACHMENT) {
+      return fb.attachments.get(point) ?? fb.attachments.get(GL.DEPTH_STENCIL_ATTACHMENT);
+    }
+    return fb.attachments.get(point);
+  }
+  fill(a, values, mask) {
+    if (!a) return;
+    const o = a.object;
+    const image = o.kind === "renderbuffer" ? o.image : o.images[a.level];
+    const w = o.kind === "renderbuffer" ? o.width : Math.max(1, o.width >> a.level);
+    const h = o.kind === "renderbuffer" ? o.height : Math.max(1, o.height >> a.level);
+    const scissor = this.enabled.has(GL.SCISSOR_TEST);
+    const [sx, sy, sw, sh] = this.scissor_;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        if (scissor && (x < sx || y < sy || x >= sx + sw || y >= sy + sh)) continue;
+        const at = ((a.layer * h + y) * w + x) * 4;
+        for (let i = 0; i < 4; i++) if (mask[i] && i < values.length) image[at + i] = values[i];
+      }
+    }
+  }
+  clearBufferfv(buffer, drawBuffer, values) {
+    const fb = this.drawFb;
+    if (!fb) return;
+    if (buffer === GL.DEPTH)
+      this.fill(this.attachment(fb, GL.DEPTH_ATTACHMENT), [values[0]], [this.depthMask_]);
+    else
+      this.fill(this.attachment(fb, fb.drawBuffers[drawBuffer] ?? GL.NONE), values, this.colorMask_);
+  }
+  clearBufferuiv(_buffer, drawBuffer, values) {
+    const fb = this.drawFb;
+    if (fb)
+      this.fill(this.attachment(fb, fb.drawBuffers[drawBuffer] ?? GL.NONE), values, this.colorMask_);
+  }
+  clearBufferiv(buffer, drawBuffer, values) {
+    const fb = this.drawFb;
+    if (!fb || buffer === GL.STENCIL) return;
+    this.fill(this.attachment(fb, fb.drawBuffers[drawBuffer] ?? GL.NONE), values, this.colorMask_);
+  }
+  clearBufferfi(_buffer, _drawBuffer, depth) {
+    const fb = this.drawFb;
+    if (fb) this.fill(this.attachment(fb, GL.DEPTH_ATTACHMENT), [depth], [this.depthMask_]);
+  }
+  clear(mask) {
+    if (mask & GL.COLOR_BUFFER_BIT && !this.drawFb) {
+      const c = this.clearColor_;
+      for (let i = 0; i < this.backbuffer.length; i += 4) {
+        for (let k = 0; k < 4; k++) if (this.colorMask_[k]) this.backbuffer[i + k] = c[k];
+      }
+    }
+  }
+  blitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, mask) {
+    const read = this.readFb;
+    const draw = this.drawFb;
+    if (!read) throw new Error("Fake GL: blit without a read framebuffer");
+    const color = (mask & GL.COLOR_BUFFER_BIT) !== 0;
+    const from = this.attachment(read, color ? read.readBuffer : GL.DEPTH_ATTACHMENT);
+    if (!from) throw new Error("Fake GL: blit from nothing");
+    const [src, sw, sh] = this.image(from.object, from.level);
+    const targets = [];
+    if (!draw) {
+      targets.push({
+        image: this.backbuffer,
+        w: this.canvas.width,
+        h: this.canvas.height,
+        layer: 0
+      });
+    } else if (color) {
+      for (const b of draw.drawBuffers) {
+        const a = this.attachment(draw, b);
+        if (a) {
+          const [image, w, h] = this.image(a.object, a.level);
+          targets.push({ image, w, h, layer: a.layer });
+        }
+      }
+    } else {
+      const a = this.attachment(draw, GL.DEPTH_ATTACHMENT);
+      if (a) {
+        const [image, w, h] = this.image(a.object, a.level);
+        targets.push({ image, w, h, layer: a.layer });
+      }
+    }
+    const width = Math.abs(dx1 - dx0);
+    const height = Math.abs(dy1 - dy0);
+    for (const t of targets) {
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const tx = dx1 > dx0 ? dx0 + x : dx0 - 1 - x;
+          const ty = dy1 > dy0 ? dy0 + y : dy0 - 1 - y;
+          const fx = sx0 + Math.floor((x + 0.5) * (sx1 - sx0) / width);
+          const fy = sy0 + Math.floor((y + 0.5) * (sy1 - sy0) / height);
+          if (tx < 0 || ty < 0 || tx >= t.w || ty >= t.h || fx >= sw || fy >= sh) continue;
+          const i = ((from.layer * sh + fy) * sw + fx) * 4;
+          const o = ((t.layer * t.h + ty) * t.w + tx) * 4;
+          for (let k = 0; k < 4; k++) t.image[o + k] = src[i + k];
+        }
+      }
+    }
+  }
+  readPixels(x, y, w, h, format, type, dst, dstOffset = 0) {
+    const fb = this.readFb;
+    if (!fb) throw new Error("Fake GL: readPixels from the canvas");
+    const a = this.attachment(fb, fb.readBuffer);
+    if (!a) throw new Error("Fake GL: readPixels from no attachment");
+    const [image, iw, ih] = this.image(a.object, a.level);
+    let bytes;
+    let start;
+    if (typeof dst === "number") {
+      bytes = this.buffer(GL.PIXEL_PACK_BUFFER).data;
+      start = dst;
+    } else {
+      bytes = new Uint8Array(dst.buffer, dst.byteOffset, dst.byteLength);
+      start = dstOffset * (dst.BYTES_PER_ELEMENT ?? 1);
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const comps = formatComponents(format);
+    const size = typeSize(type);
+    const rowLength = this.pixel.get(GL.PACK_ROW_LENGTH) || w;
+    for (let r = 0; r < h; r++) {
+      for (let c = 0; c < w; c++) {
+        const i = ((a.layer * ih + y + r) * iw + x + c) * 4;
+        const at = start + (r * rowLength + c) * comps * size;
+        for (let k = 0; k < comps; k++) {
+          const v = image[i + k];
+          if (type === GL.UNSIGNED_BYTE)
+            view.setUint8(at + k, Math.round(Math.min(1, Math.max(0, v)) * 255));
+          else if (type === GL.FLOAT) view.setFloat32(at + k * 4, v, true);
+          else if (type === GL.INT) view.setInt32(at + k * 4, v, true);
+          else view.setUint32(at + k * 4, v >>> 0, true);
+        }
+      }
+    }
+  }
+  // --- programs -----------------------------------------------------------------------
+  createShader(type) {
+    return { kind: "shader", type, source: "" };
+  }
+  shaderSource(s, source) {
+    s.source = source;
+  }
+  compileShader() {
+  }
+  deleteShader() {
+  }
+  getShaderInfoLog(s) {
+    return s.source.includes("FAIL_LINK") ? "fake: FAIL_LINK" : "";
+  }
+  createProgram() {
+    return {
+      kind: "program",
+      id: this.next++,
+      sources: [],
+      linked: false,
+      blockIndices: /* @__PURE__ */ new Map(),
+      blockPoints: /* @__PURE__ */ new Map(),
+      uniforms: /* @__PURE__ */ new Map(),
+      deleted: false
+    };
+  }
+  attachShader(p, s) {
+    p.sources.push(s.source);
+  }
+  linkProgram(p) {
+    p.linked = !p.sources.some((s) => s.includes("FAIL_LINK"));
+    this.pendingLinks = this.options.linkPolls ?? 0;
+  }
+  getProgramParameter(p, which) {
+    if (which === GL.COMPLETION_STATUS_KHR) {
+      if (this.pendingLinks > 0) {
+        this.pendingLinks--;
+        return false;
+      }
+      return true;
+    }
+    return p.linked;
+  }
+  getProgramInfoLog(p) {
+    return p.linked ? "" : "fake: the program did not link";
+  }
+  deleteProgram(p) {
+    if (p) p.deleted = true;
+  }
+  useProgram(p) {
+    this.program = p;
+  }
+  getUniformBlockIndex(p, name) {
+    if (!p.sources.some((s) => new RegExp(`uniform\\s+${name}\\b`).test(s))) return 4294967295;
+    let index = p.blockIndices.get(name);
+    if (index === void 0) {
+      index = p.blockIndices.size;
+      p.blockIndices.set(name, index);
+    }
+    return index;
+  }
+  getActiveUniformBlockParameter(p, index) {
+    for (const [name, i] of p.blockIndices) {
+      if (i !== index) continue;
+      for (const [prefix, size] of Object.entries(this.options.blockSizes ?? {})) {
+        if (name.startsWith(prefix)) return size;
+      }
+    }
+    return 0;
+  }
+  uniformBlockBinding(p, index, point) {
+    p.blockPoints.set(index, point);
+  }
+  getUniformLocation(p, name) {
+    return p.sources.some((s) => new RegExp(`\\b${name}\\b`).test(s)) ? { program: p, name } : null;
+  }
+  setUniform(l, value) {
+    if (!l) return;
+    if (l.program !== this.program) throw new Error("Fake GL: uniform set on a program not in use");
+    l.program.uniforms.set(l.name, value);
+  }
+  uniform1i(l, v) {
+    this.setUniform(l, v);
+  }
+  uniform1ui(l, v) {
+    this.setUniform(l, v);
+  }
+  uniform3i(l, x, y, z) {
+    this.setUniform(l, [x, y, z]);
+  }
+  // --- vertex arrays and draws ---------------------------------------------------------
+  createVertexArray() {
+    return { kind: "vao", id: this.next++, element: null, attribs: [] };
+  }
+  bindVertexArray(v) {
+    this.vao = v ?? this.defaultVao;
+  }
+  attrib(loc) {
+    const known = this.vao.attribs[loc];
+    if (known) return known;
+    const made = {
+      enabled: false,
+      buffer: null,
+      size: 4,
+      type: GL.FLOAT,
+      normalized: false,
+      integer: false,
+      stride: 0,
+      offset: 0,
+      divisor: 0
+    };
+    this.vao.attribs[loc] = made;
+    return made;
+  }
+  enableVertexAttribArray(loc) {
+    this.attrib(loc).enabled = true;
+  }
+  disableVertexAttribArray(loc) {
+    this.attrib(loc).enabled = false;
+  }
+  vertexAttribPointer(loc, size, type, normalized, stride, offset) {
+    this.point(loc, size, type, normalized, false, stride, offset);
+  }
+  vertexAttribIPointer(loc, size, type, stride, offset) {
+    this.point(loc, size, type, false, true, stride, offset);
+  }
+  point(loc, size, type, normalized, integer, stride, offset) {
+    const a = this.attrib(loc);
+    a.buffer = this.bound.get(GL.ARRAY_BUFFER) ?? null;
+    a.size = size;
+    a.type = type;
+    a.normalized = normalized;
+    a.integer = integer;
+    a.stride = stride;
+    a.offset = offset;
+  }
+  vertexAttribDivisor(loc, divisor) {
+    this.attrib(loc).divisor = divisor;
+  }
+  drawArrays(mode, first, count) {
+    this.record("drawArrays", mode, first, count, 0, 0, 1);
+  }
+  drawArraysInstanced(mode, first, count, instances) {
+    this.record("drawArrays", mode, first, count, 0, 0, instances);
+  }
+  drawElementsInstanced(mode, count, type, offset, instances) {
+    this.record("drawElements", mode, 0, count, type, offset, instances);
+  }
+  record(call, mode, first, count, type, offset, instances) {
+    const program = this.program;
+    if (!program?.linked) throw new Error("Fake GL: draw without a linked program");
+    if (!this.recordDraws) return;
+    const blocks = /* @__PURE__ */ new Map();
+    for (const point of program.blockPoints.values()) {
+      const r = this.ranges[point];
+      blocks.set(point, { buffer: r?.buffer ?? null, offset: r?.offset ?? 0, size: r?.size ?? 0 });
+    }
+    const units = /* @__PURE__ */ new Map();
+    for (const [name, v] of program.uniforms) {
+      if (typeof v !== "number" || name === "naga_vs_first_instance") continue;
+      const unit = this.units[v];
+      let texture = null;
+      for (const t of unit?.values() ?? []) if (t) texture = t;
+      units.set(v, {
+        texture,
+        sampler: this.samplers[v] ?? null,
+        base: texture?.params.get(GL.TEXTURE_BASE_LEVEL) ?? 0,
+        max: texture?.params.get(GL.TEXTURE_MAX_LEVEL) ?? 1e3
+      });
+    }
+    this.draws.push({
+      call,
+      mode,
+      first,
+      count,
+      type,
+      offset,
+      instances,
+      program,
+      framebuffer: this.drawFb,
+      viewport: [...this.viewport_],
+      blocks,
+      units,
+      attribs: this.vao.attribs.flatMap((a, location) => a?.enabled ? [{ ...a, location }] : []),
+      element: this.vao.element,
+      uniforms: new Map(program.uniforms),
+      enabled: new Set(this.enabled),
+      colorMask: [...this.colorMask_],
+      depthMask: this.depthMask_,
+      depthFunc: this.depthFunc_,
+      frontFace: this.frontFace_,
+      cullFace: this.cullFace_,
+      blend: [...this.blend_]
+    });
+  }
+  // --- sync -----------------------------------------------------------------------------
+  fenceSync() {
+    return { kind: "sync", id: this.next++ };
+  }
+  getSyncParameter() {
+    return GL.SIGNALED;
+  }
+  deleteSync() {
+  }
+}
+function decode(view, at, comps, type, integer) {
+  const out = [0, 0, 0, 1];
+  if (type === GL.UNSIGNED_INT_10F_11F_11F_REV) {
+    const v = view.getUint32(at, true);
+    return [ufloat(v & 2047, 6), ufloat(v >>> 11 & 2047, 6), ufloat(v >>> 22 & 1023, 5), 1];
+  }
+  if (type === GL.UNSIGNED_INT_2_10_10_10_REV) {
+    const v = view.getUint32(at, true);
+    return [
+      (v & 1023) / 1023,
+      (v >>> 10 & 1023) / 1023,
+      (v >>> 20 & 1023) / 1023,
+      (v >>> 30) / 3
+    ];
+  }
+  for (let i = 0; i < comps; i++) {
+    switch (type) {
+      case GL.UNSIGNED_BYTE: {
+        const b = view.getUint8(at + i);
+        out[i] = integer ? b : b / 255;
+        break;
+      }
+      case GL.HALF_FLOAT:
+        out[i] = halfToFloat(view.getUint16(at + i * 2, true));
+        break;
+      case GL.FLOAT:
+        out[i] = view.getFloat32(at + i * 4, true);
+        break;
+      case GL.UNSIGNED_SHORT: {
+        const s = view.getUint16(at + i * 2, true);
+        out[i] = integer ? s : s / 65535;
+        break;
+      }
+      case GL.INT:
+        out[i] = view.getInt32(at + i * 4, true);
+        break;
+      default:
+        out[i] = view.getUint32(at + i * 4, true);
+    }
+  }
+  return out;
+}
+export {
+  FakeGl
+};