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

package/dist/resources.d.ts

@@ -0,0 +1,96 @@
+import type { ReadJob } from './copies.js';
+import type { Webgl2Device } from './device.js';
+import { type GlFormat } from './formats.js';
+import type { QueryRead } from './queries.js';
+export declare class Webgl2Buffer {
+    readonly id: number;
+    readonly size: number;
+    /**
+     * What GL holds: uniform buffers round up to 16 bytes, so a std140 block (rounded up to 16) can
+     * always be bound over a WGSL struct (which isn't).
+     */
+    readonly allocated: number;
+    readonly usage: number;
+    readonly label: string;
+    readonly gl: WebGLBuffer | null;
+    /** INDEX usage: the GL element buffer, and its bytes on the CPU (the restart check). */
+    readonly index: boolean;
+    shadow: Uint8Array | undefined;
+    /** A uint32 copy of a uint16 index buffer that holds 65535, made when first drawn from. */
+    promoted: WebGLBuffer | null | undefined;
+    /** Whether the CPU copy holds 65535, as of `restartVersion`. */
+    restart: boolean;
+    restartVersion: number;
+    /** Bumped by every write, so derived copies know they're stale. */
+    version: number;
+    mapState: GPUBufferMapState;
+    /** MAP_READ: the bytes a finished map hands out, from `mappedOffset`. */
+    mapped: ArrayBuffer | undefined;
+    mappedOffset: number;
+    /** Texture reads into this buffer, repacked when it's mapped. */
+    readonly reads: ReadJob[];
+    /** Timer queries resolved into this buffer, written when it's mapped (0074). */
+    readonly queryReads: QueryRead[];
+    destroyed: boolean;
+    private readonly device;
+    constructor(device: Webgl2Device, descriptor: GPUBufferDescriptor);
+    /** Where copies read and write this buffer: its own target for index buffers. */
+    get target(): number;
+    /** Writes `data` at `offset`: `dataOffset` and `size` count elements of a typed array (writeBuffer's rule). */
+    write(offset: number, data: BufferSource, dataOffset?: number, size?: number): void;
+    mapAsync(mode: number, offset?: number, size?: number): Promise<undefined>;
+    getMappedRange(offset?: number, size?: number): ArrayBuffer;
+    unmap(): void;
+    destroy(): void;
+}
+export declare class Webgl2Texture {
+    readonly id: number;
+    readonly label: string;
+    readonly width: number;
+    readonly height: number;
+    readonly depthOrArrayLayers: number;
+    readonly mipLevelCount: number;
+    readonly sampleCount: number;
+    readonly dimension: GPUTextureDimension;
+    readonly format: GPUTextureFormat;
+    readonly usage: number;
+    readonly info: GlFormat;
+    /** Its one binding dimension (compatibility mode's `textureBindingViewDimension`). */
+    readonly bindingDimension: GPUTextureViewDimension;
+    readonly target: number;
+    readonly gl: WebGLTexture | null;
+    readonly renderbuffer: WebGLRenderbuffer | null;
+    /** The mip range a view last bound (texture parameters, set when it changes). */
+    baseLevel: number;
+    maxLevel: number;
+    destroyed: boolean;
+    /** A canvas surface's current texture: presented after the submit that draws it. */
+    surface: unknown;
+    private readonly device;
+    constructor(device: Webgl2Device, descriptor: GPUTextureDescriptor);
+    /** The compatibility-mode attribute. */
+    get textureBindingViewDimension(): GPUTextureViewDimension;
+    createView(descriptor?: GPUTextureViewDescriptor): Webgl2TextureView;
+    destroy(): void;
+}
+export declare class Webgl2TextureView {
+    readonly id: number;
+    readonly texture: Webgl2Texture;
+    readonly dimension: GPUTextureViewDimension;
+    readonly baseMipLevel: number;
+    readonly mipLevelCount: number;
+    readonly baseArrayLayer: number;
+    readonly arrayLayerCount: number;
+    readonly label: string;
+    constructor(texture: Webgl2Texture, d: GPUTextureViewDescriptor);
+    /** Whether binding this view reads the texture as its one binding dimension (baseline's rule). */
+    bindable(): boolean;
+}
+export declare const COMPARE: Record<GPUCompareFunction, number>;
+export declare class Webgl2Sampler {
+    readonly id: number;
+    readonly gl: WebGLSampler | null;
+    readonly label: string;
+    readonly compare: boolean;
+    constructor(device: Webgl2Device, d?: GPUSamplerDescriptor);
+}

package/dist/resources.js

@@ -0,0 +1,355 @@
+import { BufferUsage, TextureUsage } from "./constants.js";
+import { unsupported } from "./errors.js";
+import { formatOf } from "./formats.js";
+import { GL } from "./gl.js";
+let nextId = 1;
+class Webgl2Buffer {
+  id = nextId++;
+  size;
+  /**
+   * What GL holds: uniform buffers round up to 16 bytes, so a std140 block (rounded up to 16) can
+   * always be bound over a WGSL struct (which isn't).
+   */
+  allocated;
+  usage;
+  label;
+  gl;
+  /** INDEX usage: the GL element buffer, and its bytes on the CPU (the restart check). */
+  index;
+  shadow;
+  /** A uint32 copy of a uint16 index buffer that holds 65535, made when first drawn from. */
+  promoted;
+  /** Whether the CPU copy holds 65535, as of `restartVersion`. */
+  restart = false;
+  restartVersion = -1;
+  /** Bumped by every write, so derived copies know they're stale. */
+  version = 0;
+  mapState = "unmapped";
+  /** MAP_READ: the bytes a finished map hands out, from `mappedOffset`. */
+  mapped;
+  mappedOffset = 0;
+  /** Texture reads into this buffer, repacked when it's mapped. */
+  reads = [];
+  /** Timer queries resolved into this buffer, written when it's mapped (0074). */
+  queryReads = [];
+  destroyed = false;
+  device;
+  constructor(device, descriptor) {
+    this.device = device;
+    this.size = descriptor.size;
+    this.allocated = descriptor.usage & BufferUsage.UNIFORM ? Math.ceil(descriptor.size / 16) * 16 : descriptor.size;
+    this.usage = descriptor.usage;
+    this.label = descriptor.label ?? "";
+    this.index = (descriptor.usage & BufferUsage.INDEX) !== 0;
+    const gl = device.gl;
+    this.gl = gl.createBuffer();
+    const target = this.index ? GL.ELEMENT_ARRAY_BUFFER : GL.COPY_WRITE_BUFFER;
+    if (this.index) {
+      this.shadow = new Uint8Array(this.size);
+      device.state.bindVertexArray(null);
+    }
+    gl.bindBuffer(target, this.gl);
+    const hint = descriptor.usage & BufferUsage.MAP_READ ? GL.STREAM_READ : GL.DYNAMIC_DRAW;
+    gl.bufferData(target, this.allocated, hint);
+    gl.bindBuffer(target, null);
+    if (descriptor.mappedAtCreation) {
+      throw unsupported("create a buffer mapped at creation", "Write it with queue.writeBuffer.");
+    }
+  }
+  /** Where copies read and write this buffer: its own target for index buffers. */
+  get target() {
+    return this.index ? GL.ELEMENT_ARRAY_BUFFER : GL.COPY_WRITE_BUFFER;
+  }
+  /** Writes `data` at `offset`: `dataOffset` and `size` count elements of a typed array (writeBuffer's rule). */
+  write(offset, data, dataOffset = 0, size) {
+    const gl = this.device.gl;
+    const target = this.target;
+    const view = ArrayBuffer.isView(data) && !(data instanceof DataView);
+    const unit = view ? data.BYTES_PER_ELEMENT : 1;
+    const total = ArrayBuffer.isView(data) ? data.byteLength / unit : data.byteLength;
+    const count = size ?? total - dataOffset;
+    if (count <= 0) return;
+    if (this.index) this.device.state.bindVertexArray(null);
+    gl.bindBuffer(target, this.gl);
+    if (view) {
+      gl.bufferSubData(target, offset, data, dataOffset, count);
+    } else {
+      gl.bufferSubData(target, offset, bytesOf(data, dataOffset, count));
+    }
+    gl.bindBuffer(target, null);
+    if (this.shadow) {
+      const byteOffset = (ArrayBuffer.isView(data) ? data.byteOffset : 0) + dataOffset * unit;
+      const buffer = ArrayBuffer.isView(data) ? data.buffer : data;
+      this.shadow.set(new Uint8Array(buffer, byteOffset, count * unit), offset);
+    }
+    this.version++;
+  }
+  mapAsync(mode, offset = 0, size) {
+    return this.device.mapBuffer(this, mode, offset, size ?? this.size - offset);
+  }
+  getMappedRange(offset = this.mappedOffset, size) {
+    const mapped = this.mapped;
+    if (!mapped) throw new Error(`Buffer "${this.label}" isn't mapped`);
+    const start = offset - this.mappedOffset;
+    const length = size ?? mapped.byteLength - start;
+    return start === 0 && length === mapped.byteLength ? mapped : mapped.slice(start, start + length);
+  }
+  unmap() {
+    this.mapped = void 0;
+    this.mapState = "unmapped";
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.device.forgetBuffer(this);
+    this.device.gl.deleteBuffer(this.gl);
+    if (this.promoted) this.device.gl.deleteBuffer(this.promoted);
+    this.shadow = void 0;
+    this.mapped = void 0;
+    this.mapState = "unmapped";
+  }
+}
+function bytesOf(data, byteOffset, length) {
+  if (ArrayBuffer.isView(data))
+    return new Uint8Array(data.buffer, data.byteOffset + byteOffset, length);
+  return new Uint8Array(data, byteOffset, length);
+}
+function targetOf(dimension, layers, binding) {
+  if (dimension === "3d") return { target: GL.TEXTURE_3D, view: "3d" };
+  if (dimension === "1d") throw unsupported("make a 1D texture");
+  const view = binding ?? (layers === 1 ? "2d" : layers === 6 ? "2d-array" : "2d-array");
+  if (view === "cube") return { target: GL.TEXTURE_CUBE_MAP, view };
+  if (view === "cube-array") throw unsupported("bind a cube array");
+  if (view === "2d-array") return { target: GL.TEXTURE_2D_ARRAY, view };
+  if (layers > 1) {
+    throw unsupported(
+      `bind a ${layers}-layer texture as '2d'`,
+      "Create it with textureBindingViewDimension '2d-array' (or 'cube')."
+    );
+  }
+  return { target: GL.TEXTURE_2D, view: "2d" };
+}
+class Webgl2Texture {
+  id = nextId++;
+  label;
+  width;
+  height;
+  depthOrArrayLayers;
+  mipLevelCount;
+  sampleCount;
+  dimension;
+  format;
+  usage;
+  info;
+  /** Its one binding dimension (compatibility mode's `textureBindingViewDimension`). */
+  bindingDimension;
+  target;
+  gl;
+  renderbuffer;
+  /** The mip range a view last bound (texture parameters, set when it changes). */
+  baseLevel = -1;
+  maxLevel = -1;
+  destroyed = false;
+  /** A canvas surface's current texture: presented after the submit that draws it. */
+  surface;
+  device;
+  constructor(device, descriptor) {
+    this.device = device;
+    const size = descriptor.size;
+    this.width = Array.isArray(size) ? size[0] : size.width;
+    this.height = (Array.isArray(size) ? size[1] : size.height) ?? 1;
+    this.depthOrArrayLayers = (Array.isArray(size) ? size[2] : size.depthOrArrayLayers) ?? 1;
+    this.mipLevelCount = descriptor.mipLevelCount ?? 1;
+    this.sampleCount = descriptor.sampleCount ?? 1;
+    this.dimension = descriptor.dimension ?? "2d";
+    this.format = descriptor.format;
+    this.usage = descriptor.usage;
+    this.label = descriptor.label ?? "";
+    this.info = formatOf(descriptor.format);
+    if (descriptor.viewFormats?.some((f) => f !== descriptor.format)) {
+      throw unsupported(
+        `view "${this.label}" in another format (${descriptor.viewFormats.join(", ")})`,
+        "Baseline textures have one format: the asset layer makes a twin for the other."
+      );
+    }
+    if (this.usage & TextureUsage.STORAGE_BINDING) {
+      throw unsupported(
+        `make "${this.label}" a storage texture`,
+        "Storage textures are compute: the full tier only."
+      );
+    }
+    const gl = device.gl;
+    const onlyAttachment = (this.usage & ~(TextureUsage.RENDER_ATTACHMENT | TextureUsage.COPY_SRC)) === 0;
+    if (this.sampleCount > 1 || this.info.kind === "stencil" && onlyAttachment) {
+      if (this.usage & TextureUsage.TEXTURE_BINDING) {
+        throw unsupported(
+          `sample the multisampled texture "${this.label}"`,
+          "Resolve it, then sample the resolve target."
+        );
+      }
+      this.renderbuffer = gl.createRenderbuffer();
+      this.gl = null;
+      this.target = GL.RENDERBUFFER;
+      this.bindingDimension = "2d";
+      gl.bindRenderbuffer(GL.RENDERBUFFER, this.renderbuffer);
+      if (this.sampleCount > 1) {
+        const most = device.samplesFor(this.info.internal);
+        if (this.sampleCount > most) {
+          device.raise(
+            "validation",
+            `"${this.label}" asks for ${this.sampleCount} samples of ${this.format}; this device renders at most ${most}`
+          );
+        }
+        gl.renderbufferStorageMultisample(
+          GL.RENDERBUFFER,
+          Math.min(this.sampleCount, most),
+          this.info.internal,
+          this.width,
+          this.height
+        );
+      } else {
+        gl.renderbufferStorage(GL.RENDERBUFFER, this.info.internal, this.width, this.height);
+      }
+      gl.bindRenderbuffer(GL.RENDERBUFFER, null);
+      return;
+    }
+    if (this.info.kind === "stencil")
+      throw unsupported(`sample the stencil texture "${this.label}"`);
+    const t = targetOf(
+      this.dimension,
+      this.depthOrArrayLayers,
+      descriptor.textureBindingViewDimension
+    );
+    this.target = t.target;
+    this.bindingDimension = t.view;
+    this.renderbuffer = null;
+    this.gl = gl.createTexture();
+    device.state.bindTexture(this.target, this.gl);
+    if (this.target === GL.TEXTURE_2D || this.target === GL.TEXTURE_CUBE_MAP) {
+      gl.texStorage2D(this.target, this.mipLevelCount, this.info.internal, this.width, this.height);
+    } else {
+      gl.texStorage3D(
+        this.target,
+        this.mipLevelCount,
+        this.info.internal,
+        this.width,
+        this.height,
+        this.depthOrArrayLayers
+      );
+    }
+    gl.texParameteri(this.target, GL.TEXTURE_MIN_FILTER, GL.NEAREST);
+    gl.texParameteri(this.target, GL.TEXTURE_MAG_FILTER, GL.NEAREST);
+    this.baseLevel = 0;
+    this.maxLevel = this.mipLevelCount - 1;
+    gl.texParameteri(this.target, GL.TEXTURE_BASE_LEVEL, 0);
+    gl.texParameteri(this.target, GL.TEXTURE_MAX_LEVEL, this.maxLevel);
+  }
+  /** The compatibility-mode attribute. */
+  get textureBindingViewDimension() {
+    return this.bindingDimension;
+  }
+  createView(descriptor = {}) {
+    return new Webgl2TextureView(this, descriptor);
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    if (this.gl) this.device.gl.deleteTexture(this.gl);
+    if (this.renderbuffer) this.device.gl.deleteRenderbuffer(this.renderbuffer);
+    this.device.forgetTexture(this);
+  }
+}
+class Webgl2TextureView {
+  id = nextId++;
+  texture;
+  dimension;
+  baseMipLevel;
+  mipLevelCount;
+  baseArrayLayer;
+  arrayLayerCount;
+  label;
+  constructor(texture, d) {
+    this.texture = texture;
+    this.label = d.label ?? texture.label;
+    if (d.format && d.format !== texture.format) {
+      throw unsupported(
+        `view "${texture.label}" (${texture.format}) as ${d.format}`,
+        "Baseline textures have one format: the asset layer makes a twin for the other."
+      );
+    }
+    this.baseMipLevel = d.baseMipLevel ?? 0;
+    this.mipLevelCount = d.mipLevelCount ?? texture.mipLevelCount - this.baseMipLevel;
+    this.baseArrayLayer = d.baseArrayLayer ?? 0;
+    const layers = texture.dimension === "3d" ? 1 : texture.depthOrArrayLayers;
+    this.arrayLayerCount = d.arrayLayerCount ?? layers - this.baseArrayLayer;
+    const whole = this.baseArrayLayer === 0 && this.arrayLayerCount === layers;
+    this.dimension = d.dimension ?? (texture.dimension === "3d" ? "3d" : whole ? texture.bindingDimension : this.arrayLayerCount > 1 ? "2d-array" : "2d");
+  }
+  /** Whether binding this view reads the texture as its one binding dimension (baseline's rule). */
+  bindable() {
+    const t = this.texture;
+    if (t.renderbuffer) return false;
+    if (this.dimension !== t.bindingDimension) return false;
+    const layers = t.dimension === "3d" ? 1 : t.depthOrArrayLayers;
+    return this.baseArrayLayer === 0 && this.arrayLayerCount === layers;
+  }
+}
+const WRAP = {
+  "clamp-to-edge": GL.CLAMP_TO_EDGE,
+  repeat: GL.REPEAT,
+  "mirror-repeat": GL.MIRRORED_REPEAT
+};
+const COMPARE = {
+  never: GL.NEVER,
+  less: GL.LESS,
+  equal: GL.EQUAL,
+  "less-equal": GL.LEQUAL,
+  greater: GL.GREATER,
+  "not-equal": GL.NOTEQUAL,
+  "greater-equal": GL.GEQUAL,
+  always: GL.ALWAYS
+};
+class Webgl2Sampler {
+  id = nextId++;
+  gl;
+  label;
+  compare;
+  constructor(device, d = {}) {
+    const gl = device.gl;
+    this.label = d.label ?? "";
+    this.gl = gl.createSampler();
+    this.compare = d.compare !== void 0;
+    const mip = d.mipmapFilter ?? "nearest";
+    const min = d.minFilter === "linear" ? mip === "linear" ? GL.LINEAR_MIPMAP_LINEAR : GL.LINEAR_MIPMAP_NEAREST : mip === "linear" ? GL.NEAREST_MIPMAP_LINEAR : GL.NEAREST_MIPMAP_NEAREST;
+    gl.samplerParameteri(this.gl, GL.TEXTURE_MIN_FILTER, min);
+    gl.samplerParameteri(
+      this.gl,
+      GL.TEXTURE_MAG_FILTER,
+      d.magFilter === "linear" ? GL.LINEAR : GL.NEAREST
+    );
+    gl.samplerParameteri(this.gl, GL.TEXTURE_WRAP_S, WRAP[d.addressModeU ?? "clamp-to-edge"]);
+    gl.samplerParameteri(this.gl, GL.TEXTURE_WRAP_T, WRAP[d.addressModeV ?? "clamp-to-edge"]);
+    gl.samplerParameteri(this.gl, GL.TEXTURE_WRAP_R, WRAP[d.addressModeW ?? "clamp-to-edge"]);
+    gl.samplerParameterf(this.gl, GL.TEXTURE_MIN_LOD, d.lodMinClamp ?? 0);
+    gl.samplerParameterf(this.gl, GL.TEXTURE_MAX_LOD, d.lodMaxClamp ?? 32);
+    if (d.compare) {
+      gl.samplerParameteri(this.gl, GL.TEXTURE_COMPARE_MODE, GL.COMPARE_REF_TO_TEXTURE);
+      gl.samplerParameteri(this.gl, GL.TEXTURE_COMPARE_FUNC, COMPARE[d.compare]);
+    }
+    const anisotropy = d.maxAnisotropy ?? 1;
+    if (anisotropy > 1 && device.caps.anisotropy > 1) {
+      gl.samplerParameterf(
+        this.gl,
+        GL.TEXTURE_MAX_ANISOTROPY_EXT,
+        Math.min(anisotropy, device.caps.anisotropy)
+      );
+    }
+  }
+}
+export {
+  COMPARE,
+  Webgl2Buffer,
+  Webgl2Sampler,
+  Webgl2Texture,
+  Webgl2TextureView
+};

package/dist/state.d.ts

@@ -0,0 +1,43 @@
+import type { Webgl2RenderPipeline } from './pipeline.js';
+export declare class GlState {
+    private readonly gl;
+    private program;
+    private vao;
+    private activeUnit;
+    private readonly textures;
+    private readonly targets;
+    private readonly samplers;
+    private readonly ubo;
+    private readonly uboOffset;
+    private readonly uboSize;
+    private readonly enabled;
+    private pipeline;
+    private stencilRef;
+    /** OES_draw_buffers_indexed: per-target blending, for pipelines whose targets differ. */
+    private readonly indexed;
+    constructor(gl: WebGL2RenderingContext, indexed: OES_draw_buffers_indexed | null);
+    /** After a context loss or anything outside the cache touched the context. */
+    reset(): void;
+    forgetProgram(): void;
+    useProgram(program: WebGLProgram | null): void;
+    bindVertexArray(vao: WebGLVertexArrayObject | null): void;
+    /** The unit uploads and parameter changes bind on. Draws bind their own units over it. */
+    scratchUnit: number;
+    /** Binds on the scratch unit, for uploads and parameters. */
+    bindTexture(target: number, texture: WebGLTexture | null): void;
+    /** Binds `texture` on `unit` and leaves that unit active (texture parameters apply to it). */
+    bindUnit(unit: number, target: number, texture: WebGLTexture | null): void;
+    activate(unit: number): void;
+    /** Forgets a deleted texture wherever it's bound. */
+    forgetTexture(texture: WebGLTexture | null): void;
+    bindSampler(unit: number, sampler: WebGLSampler | null): void;
+    bindUniformBuffer(point: number, buffer: WebGLBuffer | null, offset: number, size: number): void;
+    forgetBuffer(buffer: WebGLBuffer | null): void;
+    enable(cap: number, on: boolean): void;
+    /** A pipeline's fixed-function state: only what differs from the last pipeline's. */
+    applyPipeline(p: Webgl2RenderPipeline): void;
+    /** The stencil reference, for the pipeline's compare functions. */
+    applyStencil(p: Webgl2RenderPipeline, reference: number): void;
+    /** Clears ignore masks and the scissor in GL: open them, and let the next pipeline set them. */
+    prepareClear(): void;
+}

package/dist/state.js

@@ -0,0 +1,169 @@
+import { GL } from "./gl.js";
+class GlState {
+  gl;
+  program = null;
+  vao = void 0;
+  activeUnit = -1;
+  textures = [];
+  targets = [];
+  samplers = [];
+  ubo = [];
+  uboOffset = [];
+  uboSize = [];
+  enabled = /* @__PURE__ */ new Map();
+  pipeline;
+  stencilRef = -1;
+  /** OES_draw_buffers_indexed: per-target blending, for pipelines whose targets differ. */
+  indexed;
+  constructor(gl, indexed) {
+    this.gl = gl;
+    this.indexed = indexed;
+  }
+  /** After a context loss or anything outside the cache touched the context. */
+  reset() {
+    this.program = null;
+    this.vao = void 0;
+    this.activeUnit = -1;
+    this.textures.length = 0;
+    this.targets.length = 0;
+    this.samplers.length = 0;
+    this.ubo.length = 0;
+    this.uboOffset.length = 0;
+    this.uboSize.length = 0;
+    this.enabled.clear();
+    this.pipeline = void 0;
+    this.stencilRef = -1;
+  }
+  forgetProgram() {
+    this.program = null;
+    this.pipeline = void 0;
+  }
+  useProgram(program) {
+    if (this.program === program) return;
+    this.program = program;
+    this.gl.useProgram(program);
+  }
+  bindVertexArray(vao) {
+    if (this.vao === vao) return;
+    this.vao = vao;
+    this.gl.bindVertexArray(vao);
+  }
+  /** The unit uploads and parameter changes bind on. Draws bind their own units over it. */
+  scratchUnit = 15;
+  /** Binds on the scratch unit, for uploads and parameters. */
+  bindTexture(target, texture) {
+    this.bindUnit(this.scratchUnit, target, texture);
+  }
+  /** Binds `texture` on `unit` and leaves that unit active (texture parameters apply to it). */
+  bindUnit(unit, target, texture) {
+    this.activate(unit);
+    if (this.textures[unit] === texture && this.targets[unit] === target) return;
+    const old = this.targets[unit];
+    if (old !== void 0 && old !== target && this.textures[unit]) this.gl.bindTexture(old, null);
+    this.gl.bindTexture(target, texture);
+    this.textures[unit] = texture;
+    this.targets[unit] = target;
+  }
+  activate(unit) {
+    if (this.activeUnit === unit) return;
+    this.activeUnit = unit;
+    this.gl.activeTexture(GL.TEXTURE0 + unit);
+  }
+  /** Forgets a deleted texture wherever it's bound. */
+  forgetTexture(texture) {
+    for (let i = 0; i < this.textures.length; i++)
+      if (this.textures[i] === texture) this.textures[i] = null;
+  }
+  bindSampler(unit, sampler) {
+    if (this.samplers[unit] === sampler) return;
+    this.samplers[unit] = sampler;
+    this.gl.bindSampler(unit, sampler);
+  }
+  bindUniformBuffer(point, buffer, offset, size) {
+    if (this.ubo[point] === buffer && this.uboOffset[point] === offset && this.uboSize[point] === size)
+      return;
+    this.ubo[point] = buffer;
+    this.uboOffset[point] = offset;
+    this.uboSize[point] = size;
+    this.gl.bindBufferRange(GL.UNIFORM_BUFFER, point, buffer, offset, size);
+  }
+  forgetBuffer(buffer) {
+    for (let i = 0; i < this.ubo.length; i++) if (this.ubo[i] === buffer) this.ubo[i] = null;
+  }
+  enable(cap, on) {
+    if (this.enabled.get(cap) === on) return;
+    this.enabled.set(cap, on);
+    if (on) this.gl.enable(cap);
+    else this.gl.disable(cap);
+  }
+  /** A pipeline's fixed-function state: only what differs from the last pipeline's. */
+  applyPipeline(p) {
+    this.useProgram(p.program);
+    const last = this.pipeline;
+    if (last === p) return;
+    this.pipeline = p;
+    const gl = this.gl;
+    this.enable(GL.CULL_FACE, p.cull !== 0);
+    if (p.cull !== 0 && (!last || last.cull !== p.cull)) gl.cullFace(p.cull);
+    if (!last || last.frontFace !== p.frontFace) gl.frontFace(p.frontFace);
+    this.enable(GL.DEPTH_TEST, p.depthTest);
+    if (p.depthTest) {
+      gl.depthFunc(p.depthFunc);
+      gl.depthMask(p.depthWrite);
+    }
+    const bias = p.depthBias !== 0 || p.depthSlope !== 0;
+    this.enable(GL.POLYGON_OFFSET_FILL, bias);
+    if (bias) gl.polygonOffset(p.depthSlope, p.depthBias);
+    this.enable(GL.STENCIL_TEST, p.stencil);
+    if (p.stencil) {
+      gl.stencilOpSeparate(GL.FRONT, p.stencilFront[1], p.stencilFront[2], p.stencilFront[3]);
+      gl.stencilOpSeparate(GL.BACK, p.stencilBack[1], p.stencilBack[2], p.stencilBack[3]);
+      gl.stencilMask(p.stencilWriteMask);
+      this.stencilRef = -1;
+    }
+    const x = this.indexed;
+    if (p.uniformTargets || !x) {
+      const blend = p.blends[0];
+      this.enable(GL.BLEND, blend?.enabled === true);
+      if (blend?.enabled) {
+        gl.blendEquationSeparate(blend.colorOp, blend.alphaOp);
+        gl.blendFuncSeparate(blend.colorSrc, blend.colorDst, blend.alphaSrc, blend.alphaDst);
+      }
+      const m = p.masks[0] ?? 15;
+      gl.colorMask((m & 1) !== 0, (m & 2) !== 0, (m & 4) !== 0, (m & 8) !== 0);
+      return;
+    }
+    this.enabled.delete(GL.BLEND);
+    for (let i = 0; i < p.blends.length; i++) {
+      const b = p.blends[i];
+      if (b.enabled) {
+        x.enableiOES(GL.BLEND, i);
+        x.blendEquationSeparateiOES(i, b.colorOp, b.alphaOp);
+        x.blendFuncSeparateiOES(i, b.colorSrc, b.colorDst, b.alphaSrc, b.alphaDst);
+      } else {
+        x.disableiOES(GL.BLEND, i);
+      }
+      const m = p.masks[i];
+      x.colorMaskiOES(i, (m & 1) !== 0, (m & 2) !== 0, (m & 4) !== 0, (m & 8) !== 0);
+    }
+  }
+  /** The stencil reference, for the pipeline's compare functions. */
+  applyStencil(p, reference) {
+    if (!p.stencil || this.stencilRef === reference) return;
+    this.stencilRef = reference;
+    this.gl.stencilFuncSeparate(GL.FRONT, p.stencilFront[0], reference, p.stencilReadMask);
+    this.gl.stencilFuncSeparate(GL.BACK, p.stencilBack[0], reference, p.stencilReadMask);
+  }
+  /** Clears ignore masks and the scissor in GL: open them, and let the next pipeline set them. */
+  prepareClear() {
+    const gl = this.gl;
+    this.enable(GL.SCISSOR_TEST, false);
+    gl.colorMask(true, true, true, true);
+    gl.depthMask(true);
+    gl.stencilMask(255);
+    this.pipeline = void 0;
+  }
+}
+export {
+  GlState
+};