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

package/dist/fbo.d.ts

@@ -0,0 +1,30 @@
+import type { Webgl2Texture } from './resources.js';
+/** Attachments to look up: filled in place by a pass, a resolve, a copy or a present. */
+export declare class Attachments {
+    count: number;
+    readonly colors: (Webgl2Texture | null)[];
+    readonly colorMips: number[];
+    /** Array layer, cube face or 3D slice; 0 for a 2D texture. */
+    readonly colorLayers: number[];
+    depth: Webgl2Texture | null;
+    depthMip: number;
+    depthLayer: number;
+    reset(): void;
+    color(index: number, texture: Webgl2Texture | null, mip: number, layer: number): void;
+    setDepth(texture: Webgl2Texture, mip: number, layer: number): void;
+    /** The texture a lookup is filed under: the first attached. */
+    first(): Webgl2Texture | null;
+}
+export declare class FramebufferCache {
+    private readonly gl;
+    private readonly byTexture;
+    /** Framebuffers that failed their completeness check, for the error they raise once. */
+    incomplete: ((status: number) => void) | undefined;
+    constructor(gl: WebGL2RenderingContext);
+    /** The framebuffer for `a`, bound to FRAMEBUFFER (read and draw) when it's new. */
+    get(a: Attachments): WebGLFramebuffer | null;
+    /** Deletes every framebuffer `texture` is attached to. */
+    forget(texture: Webgl2Texture): void;
+    clear(): void;
+    private create;
+}

package/dist/fbo.js

@@ -0,0 +1,142 @@
+import { GL } from "./gl.js";
+class Attachments {
+  count = 0;
+  colors = [];
+  colorMips = [];
+  /** Array layer, cube face or 3D slice; 0 for a 2D texture. */
+  colorLayers = [];
+  depth = null;
+  depthMip = 0;
+  depthLayer = 0;
+  reset() {
+    for (let i = 0; i < this.count; i++) this.colors[i] = null;
+    this.count = 0;
+    this.depth = null;
+  }
+  color(index, texture, mip, layer) {
+    while (this.count <= index) {
+      this.colors[this.count] = null;
+      this.colorMips[this.count] = 0;
+      this.colorLayers[this.count] = 0;
+      this.count++;
+    }
+    this.colors[index] = texture;
+    this.colorMips[index] = mip;
+    this.colorLayers[index] = layer;
+  }
+  setDepth(texture, mip, layer) {
+    this.depth = texture;
+    this.depthMip = mip;
+    this.depthLayer = layer;
+  }
+  /** The texture a lookup is filed under: the first attached. */
+  first() {
+    for (let i = 0; i < this.count; i++) if (this.colors[i]) return this.colors[i];
+    return this.depth;
+  }
+}
+function matches(r, a) {
+  if (r.colors.length !== a.count || r.depth !== a.depth) return false;
+  if (a.depth && (r.depthMip !== a.depthMip || r.depthLayer !== a.depthLayer)) return false;
+  for (let i = 0; i < a.count; i++) {
+    if (r.colors[i] !== a.colors[i]) return false;
+    if (a.colors[i] && (r.colorMips[i] !== a.colorMips[i] || r.colorLayers[i] !== a.colorLayers[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+class FramebufferCache {
+  gl;
+  byTexture = /* @__PURE__ */ new Map();
+  /** Framebuffers that failed their completeness check, for the error they raise once. */
+  incomplete;
+  constructor(gl) {
+    this.gl = gl;
+  }
+  /** The framebuffer for `a`, bound to FRAMEBUFFER (read and draw) when it's new. */
+  get(a) {
+    const first = a.first();
+    if (!first) return null;
+    let list = this.byTexture.get(first);
+    if (list) {
+      for (let i = 0; i < list.length; i++) if (matches(list[i], a)) return list[i].fbo;
+    } else {
+      list = [];
+      this.byTexture.set(first, list);
+    }
+    const record = this.create(a);
+    list.push(record);
+    return record.fbo;
+  }
+  /** Deletes every framebuffer `texture` is attached to. */
+  forget(texture) {
+    for (const [key, list] of this.byTexture) {
+      for (let i = list.length - 1; i >= 0; i--) {
+        const r = list[i];
+        if (key === texture || r.depth === texture || r.colors.includes(texture)) {
+          this.gl.deleteFramebuffer(r.fbo);
+          list.splice(i, 1);
+        }
+      }
+      if (list.length === 0) this.byTexture.delete(key);
+    }
+  }
+  clear() {
+    for (const list of this.byTexture.values())
+      for (const r of list) this.gl.deleteFramebuffer(r.fbo);
+    this.byTexture.clear();
+  }
+  create(a) {
+    const gl = this.gl;
+    const fbo = gl.createFramebuffer();
+    gl.bindFramebuffer(GL.FRAMEBUFFER, fbo);
+    const buffers = [];
+    for (let i = 0; i < a.count; i++) {
+      const t = a.colors[i];
+      if (t) attach(gl, GL.COLOR_ATTACHMENT0 + i, t, a.colorMips[i], a.colorLayers[i]);
+      buffers.push(t ? GL.COLOR_ATTACHMENT0 + i : GL.NONE);
+    }
+    if (a.depth) {
+      const info = a.depth.info;
+      const point = info.depth && info.stencil ? GL.DEPTH_STENCIL_ATTACHMENT : info.depth ? GL.DEPTH_ATTACHMENT : GL.STENCIL_ATTACHMENT;
+      attach(gl, point, a.depth, a.depthMip, a.depthLayer);
+    }
+    gl.drawBuffers(buffers);
+    if (a.count === 0) gl.readBuffer(GL.NONE);
+    if (this.incomplete) {
+      const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER);
+      if (status !== GL.FRAMEBUFFER_COMPLETE) this.incomplete(status);
+    }
+    return {
+      fbo,
+      colors: a.colors.slice(0, a.count),
+      colorMips: a.colorMips.slice(0, a.count),
+      colorLayers: a.colorLayers.slice(0, a.count),
+      depth: a.depth,
+      depthMip: a.depthMip,
+      depthLayer: a.depthLayer
+    };
+  }
+}
+function attach(gl, point, t, mip, layer) {
+  if (t.renderbuffer) {
+    gl.framebufferRenderbuffer(GL.FRAMEBUFFER, point, GL.RENDERBUFFER, t.renderbuffer);
+  } else if (t.target === GL.TEXTURE_2D) {
+    gl.framebufferTexture2D(GL.FRAMEBUFFER, point, GL.TEXTURE_2D, t.gl, mip);
+  } else if (t.target === GL.TEXTURE_CUBE_MAP) {
+    gl.framebufferTexture2D(
+      GL.FRAMEBUFFER,
+      point,
+      GL.TEXTURE_CUBE_MAP_POSITIVE_X + layer,
+      t.gl,
+      mip
+    );
+  } else {
+    gl.framebufferTextureLayer(GL.FRAMEBUFFER, point, t.gl, mip, layer);
+  }
+}
+export {
+  Attachments,
+  FramebufferCache
+};

package/dist/formats.d.ts

@@ -0,0 +1,25 @@
+export type FormatKind = 'float' | 'unfilterable-float' | 'uint' | 'sint' | 'depth' | 'stencil';
+export interface GlFormat {
+    internal: number;
+    /** Pixel format and type for uploads and reads (uncompressed). */
+    format: number;
+    type: number;
+    /** Bytes per texel, or per 4×4 block when compressed. */
+    bytes: number;
+    /** Texels a block covers per side (4 when compressed). */
+    block: number;
+    kind: FormatKind;
+    /** Renderable without extensions (true), with EXT_color_buffer_float ('float'), or never. */
+    renderable: boolean | 'float';
+    /** Linear filtering needs OES_texture_float_linear. */
+    float32?: boolean;
+    depth?: boolean;
+    stencil?: boolean;
+    srgb?: boolean;
+    /** Components: 1 to 4. */
+    components: number;
+    compressed?: 'bc' | 'astc' | 'etc2';
+}
+export declare const FORMATS: Readonly<Record<string, GlFormat>>;
+/** The format, or an error naming it: the shim only has what the engine uses. */
+export declare function formatOf(name: string): GlFormat;

package/dist/formats.js

@@ -0,0 +1,106 @@
+import { GL } from "./gl.js";
+const f = (internal, format, type, bytes, kind, renderable, components, extra = {}) => ({ internal, format, type, bytes, block: 1, kind, renderable, components, ...extra });
+const compressed = (internal, family, extra = {}) => ({
+  internal,
+  format: 0,
+  type: 0,
+  bytes: 16,
+  block: 4,
+  kind: "float",
+  renderable: false,
+  components: 4,
+  compressed: family,
+  ...extra
+});
+const FORMATS = {
+  r8unorm: f(GL.R8, GL.RED, GL.UNSIGNED_BYTE, 1, "float", true, 1),
+  rg8unorm: f(GL.RG8, GL.RG, GL.UNSIGNED_BYTE, 2, "float", true, 2),
+  rgba8unorm: f(GL.RGBA8, GL.RGBA, GL.UNSIGNED_BYTE, 4, "float", true, 4),
+  "rgba8unorm-srgb": f(GL.SRGB8_ALPHA8, GL.RGBA, GL.UNSIGNED_BYTE, 4, "float", true, 4, {
+    srgb: true
+  }),
+  rgb10a2unorm: f(GL.RGB10_A2, GL.RGBA, GL.UNSIGNED_INT_2_10_10_10_REV, 4, "float", true, 4),
+  r16float: f(GL.R16F, GL.RED, GL.HALF_FLOAT, 2, "float", "float", 1),
+  rg16float: f(GL.RG16F, GL.RG, GL.HALF_FLOAT, 4, "float", "float", 2),
+  rgba16float: f(GL.RGBA16F, GL.RGBA, GL.HALF_FLOAT, 8, "float", "float", 4),
+  r32float: f(GL.R32F, GL.RED, GL.FLOAT, 4, "unfilterable-float", "float", 1, { float32: true }),
+  rg32float: f(GL.RG32F, GL.RG, GL.FLOAT, 8, "unfilterable-float", "float", 2, { float32: true }),
+  rgba32float: f(GL.RGBA32F, GL.RGBA, GL.FLOAT, 16, "unfilterable-float", "float", 4, {
+    float32: true
+  }),
+  rg11b10ufloat: f(
+    GL.R11F_G11F_B10F,
+    GL.RGB,
+    GL.UNSIGNED_INT_10F_11F_11F_REV,
+    4,
+    "float",
+    "float",
+    3
+  ),
+  r8uint: f(GL.R8UI, GL.RED_INTEGER, GL.UNSIGNED_BYTE, 1, "uint", true, 1),
+  rgba8uint: f(GL.RGBA8UI, GL.RGBA_INTEGER, GL.UNSIGNED_BYTE, 4, "uint", true, 4),
+  r16uint: f(GL.R16UI, GL.RED_INTEGER, GL.UNSIGNED_SHORT, 2, "uint", true, 1),
+  r32uint: f(GL.R32UI, GL.RED_INTEGER, GL.UNSIGNED_INT, 4, "uint", true, 1),
+  rg32uint: f(GL.RG32UI, GL.RG_INTEGER, GL.UNSIGNED_INT, 8, "uint", true, 2),
+  rgba32uint: f(GL.RGBA32UI, GL.RGBA_INTEGER, GL.UNSIGNED_INT, 16, "uint", true, 4),
+  depth16unorm: f(
+    GL.DEPTH_COMPONENT16,
+    GL.DEPTH_COMPONENT,
+    GL.UNSIGNED_SHORT,
+    2,
+    "depth",
+    true,
+    1,
+    {
+      depth: true
+    }
+  ),
+  depth24plus: f(GL.DEPTH_COMPONENT24, GL.DEPTH_COMPONENT, GL.UNSIGNED_INT, 4, "depth", true, 1, {
+    depth: true
+  }),
+  depth32float: f(GL.DEPTH_COMPONENT32F, GL.DEPTH_COMPONENT, GL.FLOAT, 4, "depth", true, 1, {
+    depth: true
+  }),
+  "depth24plus-stencil8": f(
+    GL.DEPTH24_STENCIL8,
+    GL.DEPTH_STENCIL,
+    GL.UNSIGNED_INT_24_8,
+    4,
+    "depth",
+    true,
+    1,
+    {
+      depth: true,
+      stencil: true
+    }
+  ),
+  "depth32float-stencil8": f(
+    GL.DEPTH32F_STENCIL8,
+    GL.DEPTH_STENCIL,
+    GL.FLOAT_32_UNSIGNED_INT_24_8_REV,
+    8,
+    "depth",
+    true,
+    1,
+    { depth: true, stencil: true }
+  ),
+  // Only as an attachment (a renderbuffer): WebGL2 can't sample stencil.
+  stencil8: f(GL.STENCIL_INDEX8, 0, 0, 1, "stencil", true, 1, { stencil: true }),
+  "bc5-rg-unorm": compressed(36285, "bc", { components: 2 }),
+  "bc7-rgba-unorm": compressed(36492, "bc"),
+  "bc7-rgba-unorm-srgb": compressed(36493, "bc", { srgb: true }),
+  "astc-4x4-unorm": compressed(37808, "astc"),
+  "astc-4x4-unorm-srgb": compressed(37840, "astc", { srgb: true }),
+  "etc2-rgba8unorm": compressed(37496, "etc2"),
+  "etc2-rgba8unorm-srgb": compressed(37497, "etc2", { srgb: true }),
+  "eac-rg11unorm": compressed(37490, "etc2", { components: 2 })
+};
+function formatOf(name) {
+  const format = FORMATS[name];
+  if (!format) throw new Error(`gpu-webgl2/unsupported: the texture format "${name}"`);
+  return format;
+}
+export {
+  FORMATS,
+  formatOf
+};

package/dist/gl.d.ts

@@ -0,0 +1,216 @@
+export declare const GL: {
+    readonly ARRAY_BUFFER: 34962;
+    readonly ELEMENT_ARRAY_BUFFER: 34963;
+    readonly UNIFORM_BUFFER: 35345;
+    readonly COPY_READ_BUFFER: 36662;
+    readonly COPY_WRITE_BUFFER: 36663;
+    readonly PIXEL_PACK_BUFFER: 35051;
+    readonly PIXEL_UNPACK_BUFFER: 35052;
+    readonly STATIC_DRAW: 35044;
+    readonly DYNAMIC_DRAW: 35048;
+    readonly STREAM_READ: 35041;
+    readonly DYNAMIC_READ: 35049;
+    readonly BYTE: 5120;
+    readonly UNSIGNED_BYTE: 5121;
+    readonly SHORT: 5122;
+    readonly UNSIGNED_SHORT: 5123;
+    readonly INT: 5124;
+    readonly UNSIGNED_INT: 5125;
+    readonly FLOAT: 5126;
+    readonly HALF_FLOAT: 5131;
+    readonly UNSIGNED_INT_2_10_10_10_REV: 33640;
+    readonly UNSIGNED_INT_10F_11F_11F_REV: 35899;
+    readonly UNSIGNED_INT_24_8: 34042;
+    readonly FLOAT_32_UNSIGNED_INT_24_8_REV: 36269;
+    readonly RED: 6403;
+    readonly RG: 33319;
+    readonly RGB: 6407;
+    readonly RGBA: 6408;
+    readonly RED_INTEGER: 36244;
+    readonly RG_INTEGER: 33320;
+    readonly RGBA_INTEGER: 36249;
+    readonly DEPTH_COMPONENT: 6402;
+    readonly DEPTH_STENCIL: 34041;
+    readonly STENCIL_INDEX8: 36168;
+    readonly R8: 33321;
+    readonly RG8: 33323;
+    readonly RGBA8: 32856;
+    readonly SRGB8_ALPHA8: 35907;
+    readonly RGB10_A2: 32857;
+    readonly R16F: 33325;
+    readonly RG16F: 33327;
+    readonly RGBA16F: 34842;
+    readonly R32F: 33326;
+    readonly RG32F: 33328;
+    readonly RGBA32F: 34836;
+    readonly R11F_G11F_B10F: 35898;
+    readonly R8UI: 33330;
+    readonly RGBA8UI: 36220;
+    readonly R16UI: 33332;
+    readonly R32UI: 33334;
+    readonly RG32UI: 33340;
+    readonly RGBA32UI: 36208;
+    readonly DEPTH_COMPONENT16: 33189;
+    readonly DEPTH_COMPONENT24: 33190;
+    readonly DEPTH_COMPONENT32F: 36012;
+    readonly DEPTH24_STENCIL8: 35056;
+    readonly DEPTH32F_STENCIL8: 36013;
+    readonly TEXTURE_2D: 3553;
+    readonly TEXTURE_2D_ARRAY: 35866;
+    readonly TEXTURE_3D: 32879;
+    readonly TEXTURE_CUBE_MAP: 34067;
+    readonly TEXTURE_CUBE_MAP_POSITIVE_X: 34069;
+    readonly TEXTURE0: 33984;
+    readonly TEXTURE_BASE_LEVEL: 33084;
+    readonly TEXTURE_MAX_LEVEL: 33085;
+    readonly TEXTURE_MIN_FILTER: 10241;
+    readonly TEXTURE_MAG_FILTER: 10240;
+    readonly TEXTURE_WRAP_S: 10242;
+    readonly TEXTURE_WRAP_T: 10243;
+    readonly TEXTURE_WRAP_R: 32882;
+    readonly TEXTURE_MIN_LOD: 33082;
+    readonly TEXTURE_MAX_LOD: 33083;
+    readonly TEXTURE_COMPARE_MODE: 34892;
+    readonly TEXTURE_COMPARE_FUNC: 34893;
+    readonly COMPARE_REF_TO_TEXTURE: 34894;
+    readonly NONE: 0;
+    readonly NEAREST: 9728;
+    readonly LINEAR: 9729;
+    readonly NEAREST_MIPMAP_NEAREST: 9984;
+    readonly LINEAR_MIPMAP_NEAREST: 9985;
+    readonly NEAREST_MIPMAP_LINEAR: 9986;
+    readonly LINEAR_MIPMAP_LINEAR: 9987;
+    readonly REPEAT: 10497;
+    readonly CLAMP_TO_EDGE: 33071;
+    readonly MIRRORED_REPEAT: 33648;
+    readonly TEXTURE_MAX_ANISOTROPY_EXT: 34046;
+    readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: 34047;
+    readonly UNPACK_ALIGNMENT: 3317;
+    readonly PACK_ALIGNMENT: 3333;
+    readonly UNPACK_ROW_LENGTH: 3314;
+    readonly UNPACK_IMAGE_HEIGHT: 32878;
+    readonly UNPACK_SKIP_ROWS: 3315;
+    readonly UNPACK_SKIP_PIXELS: 3316;
+    readonly UNPACK_SKIP_IMAGES: 32877;
+    readonly UNPACK_FLIP_Y_WEBGL: 37440;
+    readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441;
+    readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443;
+    readonly PACK_ROW_LENGTH: 3330;
+    readonly FRAMEBUFFER: 36160;
+    readonly READ_FRAMEBUFFER: 36008;
+    readonly DRAW_FRAMEBUFFER: 36009;
+    readonly RENDERBUFFER: 36161;
+    readonly COLOR_ATTACHMENT0: 36064;
+    readonly DEPTH_ATTACHMENT: 36096;
+    readonly STENCIL_ATTACHMENT: 36128;
+    readonly DEPTH_STENCIL_ATTACHMENT: 33306;
+    readonly FRAMEBUFFER_COMPLETE: 36053;
+    readonly COLOR_BUFFER_BIT: 16384;
+    readonly DEPTH_BUFFER_BIT: 256;
+    readonly STENCIL_BUFFER_BIT: 1024;
+    readonly COLOR: 6144;
+    readonly DEPTH: 6145;
+    readonly STENCIL: 6146;
+    readonly BACK: 1029;
+    readonly SAMPLES: 32937;
+    readonly BLEND: 3042;
+    readonly DITHER: 3024;
+    readonly CULL_FACE: 2884;
+    readonly DEPTH_TEST: 2929;
+    readonly STENCIL_TEST: 2960;
+    readonly SCISSOR_TEST: 3089;
+    readonly POLYGON_OFFSET_FILL: 32823;
+    readonly RASTERIZER_DISCARD: 35977;
+    readonly FRONT: 1028;
+    readonly FRONT_AND_BACK: 1032;
+    readonly CW: 2304;
+    readonly CCW: 2305;
+    readonly NEVER: 512;
+    readonly LESS: 513;
+    readonly EQUAL: 514;
+    readonly LEQUAL: 515;
+    readonly GREATER: 516;
+    readonly NOTEQUAL: 517;
+    readonly GEQUAL: 518;
+    readonly ALWAYS: 519;
+    readonly KEEP: 7680;
+    readonly ZERO: 0;
+    readonly ONE: 1;
+    readonly REPLACE: 7681;
+    readonly INCR: 7682;
+    readonly DECR: 7683;
+    readonly INVERT: 5386;
+    readonly INCR_WRAP: 34055;
+    readonly DECR_WRAP: 34056;
+    readonly SRC_COLOR: 768;
+    readonly ONE_MINUS_SRC_COLOR: 769;
+    readonly SRC_ALPHA: 770;
+    readonly ONE_MINUS_SRC_ALPHA: 771;
+    readonly DST_ALPHA: 772;
+    readonly ONE_MINUS_DST_ALPHA: 773;
+    readonly DST_COLOR: 774;
+    readonly ONE_MINUS_DST_COLOR: 775;
+    readonly SRC_ALPHA_SATURATE: 776;
+    readonly CONSTANT_COLOR: 32769;
+    readonly ONE_MINUS_CONSTANT_COLOR: 32770;
+    readonly FUNC_ADD: 32774;
+    readonly FUNC_SUBTRACT: 32778;
+    readonly FUNC_REVERSE_SUBTRACT: 32779;
+    readonly MIN: 32775;
+    readonly MAX: 32776;
+    readonly TRIANGLES: 4;
+    readonly TRIANGLE_STRIP: 5;
+    readonly LINES: 1;
+    readonly LINE_STRIP: 3;
+    readonly POINTS: 0;
+    readonly VERTEX_SHADER: 35633;
+    readonly FRAGMENT_SHADER: 35632;
+    readonly COMPILE_STATUS: 35713;
+    readonly LINK_STATUS: 35714;
+    readonly UNIFORM_BLOCK_DATA_SIZE: 35392;
+    readonly COMPLETION_STATUS_KHR: 37297;
+    readonly SYNC_GPU_COMMANDS_COMPLETE: 37143;
+    readonly SYNC_STATUS: 37140;
+    readonly SIGNALED: 37145;
+    readonly ALREADY_SIGNALED: 37146;
+    readonly CONDITION_SATISFIED: 37148;
+    readonly TIMEOUT_EXPIRED: 37147;
+    readonly WAIT_FAILED: 37149;
+    readonly MAX_TEXTURE_SIZE: 3379;
+    readonly MAX_3D_TEXTURE_SIZE: 32883;
+    readonly MAX_ARRAY_TEXTURE_LAYERS: 35071;
+    readonly MAX_CUBE_MAP_TEXTURE_SIZE: 34076;
+    readonly MAX_TEXTURE_IMAGE_UNITS: 34930;
+    readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660;
+    readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661;
+    readonly MAX_UNIFORM_BLOCK_SIZE: 35376;
+    readonly MAX_VERTEX_UNIFORM_BLOCKS: 35371;
+    readonly MAX_FRAGMENT_UNIFORM_BLOCKS: 35373;
+    readonly MAX_COMBINED_UNIFORM_BLOCKS: 35374;
+    readonly MAX_UNIFORM_BUFFER_BINDINGS: 35375;
+    readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380;
+    readonly MAX_DRAW_BUFFERS: 34852;
+    readonly MAX_COLOR_ATTACHMENTS: 36063;
+    readonly MAX_VERTEX_ATTRIBS: 34921;
+    readonly MAX_VARYING_COMPONENTS: 35659;
+    readonly MAX_SAMPLES: 36183;
+    readonly MAX_RENDERBUFFER_SIZE: 34024;
+    readonly MAX_VERTEX_UNIFORM_VECTORS: 36347;
+    readonly MAX_ELEMENT_INDEX: 36203;
+    readonly NO_ERROR: 0;
+    readonly INVALID_ENUM: 1280;
+    readonly INVALID_VALUE: 1281;
+    readonly INVALID_OPERATION: 1282;
+    readonly OUT_OF_MEMORY: 1285;
+    readonly INVALID_FRAMEBUFFER_OPERATION: 1286;
+    readonly CONTEXT_LOST_WEBGL: 37442;
+    readonly UNMASKED_VENDOR_WEBGL: 37445;
+    readonly UNMASKED_RENDERER_WEBGL: 37446;
+    readonly VENDOR: 7936;
+    readonly RENDERER: 7937;
+};
+/** EXT_clip_control, when present. */
+export declare const CLIP: {
+    readonly LOWER_LEFT_EXT: 36001;
+    readonly ZERO_TO_ONE_EXT: 37727;
+};