@gjsify/webgl 0.1.2 → 0.1.4

package/lib/types/extensions/stackgl-destroy-context.d.ts

@@ -1,6 +1,6 @@
-import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
+import type { WebGLContextBase } from '../webgl-context-base.js';
 export declare class STACKGLDestroyContext {
     destroy: () => void;
-    constructor(ctx: WebGLRenderingContext);
+    constructor(ctx: WebGLContextBase);
 }
-export declare function getSTACKGLDestroyContext(ctx: WebGLRenderingContext): STACKGLDestroyContext;
+export declare function getSTACKGLDestroyContext(ctx: WebGLContextBase): STACKGLDestroyContext;

package/lib/types/extensions/stackgl-resize-drawing-buffer.d.ts

@@ -1,6 +1,6 @@
-import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
+import type { WebGLContextBase } from '../webgl-context-base.js';
 export declare class STACKGLResizeDrawingBuffer {
     resize: (width: number, height: number) => void;
-    constructor(ctx: WebGLRenderingContext);
+    constructor(ctx: WebGLContextBase);
 }
-export declare function getSTACKGLResizeDrawingBuffer(ctx: WebGLRenderingContext): STACKGLResizeDrawingBuffer;
+export declare function getSTACKGLResizeDrawingBuffer(ctx: WebGLContextBase): STACKGLResizeDrawingBuffer;

package/lib/types/index.d.ts

@@ -11,6 +11,7 @@ export * from './webgl-framebuffer.js';
 export * from './webgl-program.js';
 export * from './webgl-renderbuffer.js';
 export * from './webgl-query.js';
+export * from './webgl-context-base.js';
 export * from './webgl-rendering-context.js';
 export * from './webgl-sampler.js';
 export * from './webgl-shader-precision-format.js';

package/lib/types/test-utils.d.ts

@@ -43,3 +43,27 @@ export declare function makeTestFBOWithDepth(gl: WebGLRenderingContext, width?:
 export declare function destroyTestFBO(gl: WebGLRenderingContext, fbo: TestFBO): void;
 /** Unbind the FBO and delete both the color texture and depth renderbuffer. */
 export declare function destroyTestFBOWithDepth(gl: WebGLRenderingContext, fbo: TestFBOWithDepth): void;
+export interface TestFBOFloat {
+    fb: WebGLFramebuffer;
+    colorTex: WebGLTexture;
+    width: number;
+    height: number;
+}
+/**
+ * Create a w×h RGBA16F FBO (half-float color texture) and bind it.
+ * Used for testing Three.js post-processing render target patterns.
+ */
+export declare function makeTestFBOFloat(gl: WebGL2RenderingContext, width?: number, height?: number): TestFBOFloat;
+export interface TestFBOWithDepthTexture extends TestFBO {
+    depthTex: WebGLTexture;
+}
+/**
+ * Create a w×h RGBA8 FBO with a DEPTH_COMPONENT24 texture attachment.
+ * Three.js uses depth textures (not renderbuffers) for RenderPixelatedPass.
+ */
+export declare function makeTestFBOWithDepthTexture(gl: WebGL2RenderingContext, width?: number, height?: number): TestFBOWithDepthTexture;
+/** WebGL2 passthrough texture shader (samples texture at UV and outputs it). */
+export declare const TEXTURE_VS_300 = "#version 300 es\nin vec2 position;\nout vec2 vUv;\nvoid main() {\n    vUv = position * 0.5 + 0.5;\n    gl_Position = vec4(position, 0.0, 1.0);\n}";
+export declare const TEXTURE_FS_300 = "#version 300 es\nprecision mediump float;\nuniform sampler2D uTexture;\nin vec2 vUv;\nout vec4 fragColor;\nvoid main() {\n    fragColor = texture(uTexture, vUv);\n}";
+/** WebGL2 cubemap sampling shader. */
+export declare const CUBEMAP_FS_300 = "#version 300 es\nprecision mediump float;\nuniform samplerCube uCubemap;\nuniform vec3 uDirection;\nout vec4 fragColor;\nvoid main() {\n    fragColor = texture(uCubemap, uDirection);\n}";

package/lib/types/types/extension.d.ts

@@ -1,2 +1,2 @@
-import type { WebGLRenderingContext } from '../webgl-rendering-context.js';
-export type ExtensionFactory = (context: WebGLRenderingContext) => any | null;
+import type { WebGLContextBase } from '../webgl-context-base.js';
+export type ExtensionFactory = (context: WebGLContextBase) => any | null;

package/lib/types/utils.d.ts

@@ -2,17 +2,16 @@ import { WebGLUniformLocation } from './webgl-uniform-location.js';
 import { WebGLProgram } from './webgl-program.js';
 import GLib from '@girs/glib-2.0';
 import { HTMLImageElement } from "@gjsify/dom-elements";
-import type Gwebgl from '@girs/gwebgl-0.1';
-import type { WebGLRenderingContext } from './webgl-rendering-context.js';
+import type { WebGLContextBase } from './webgl-context-base.js';
 import type { TypedArray } from './types/index.js';
-export declare function bindPublics(props: Array<keyof WebGLRenderingContext>, wrapper: WebGLRenderingContext, privateInstance: WebGLRenderingContext, privateMethods: string[]): void;
+export declare function bindPublics(props: Array<keyof WebGLContextBase>, wrapper: WebGLContextBase, privateInstance: WebGLContextBase, privateMethods: string[]): void;
 export declare function checkObject(object: any): boolean;
 export declare function checkUniform(program: WebGLProgram, location: WebGLUniformLocation): boolean;
 export declare function isTypedArray(data: TypedArray): data is Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int8Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>;
 export declare function isValidString(str: string): boolean;
-export declare function vertexCount(gl: WebGLRenderingContext, primitive: GLenum, count: number): number;
-export declare function typeSize(gl: WebGLRenderingContext, type: GLenum): 0 | 1 | 2 | 4;
-export declare function uniformTypeSize(gl: WebGLRenderingContext, type: GLenum): 0 | 1 | 2 | 3 | 4;
+export declare function vertexCount(gl: WebGLContextBase, primitive: GLenum, count: number): number;
+export declare function typeSize(gl: WebGLContextBase, type: GLenum): 0 | 1 | 2 | 4;
+export declare function uniformTypeSize(gl: WebGLContextBase, type: GLenum): 0 | 1 | 2 | 3 | 4;
 export declare const listToArray: (values: Float32List) => number[];
 export declare function arrayToUint8Array(array: TypedArray | Float32List | Array<number> | ArrayBuffer | DataView): Uint8Array<ArrayBufferLike>;
 export declare function Uint8ArrayToVariant(array: Uint8Array | null): GLib.Variant<"ay">;
@@ -24,8 +23,8 @@ export declare function Uint8ArrayToVariant(array: Uint8Array | null): GLib.Vari
  */
 export declare function boolArray(array: ArrayBufferView): boolean[];
 export declare const extractImageData: (pixels: TexImageSource | HTMLImageElement) => ImageData | null;
-export declare function formatSize(gl: WebGLRenderingContext, internalFormat: number): 0 | 1 | 2 | 3 | 4;
+export declare function formatSize(gl: WebGLContextBase, internalFormat: number): 0 | 1 | 2 | 3 | 4;
 export declare function convertPixels(pixels: ArrayBuffer | Uint8Array | Uint16Array | Uint8ClampedArray | Float32Array | Buffer | ArrayBufferView | null): Uint8Array<ArrayBufferLike>;
-export declare function checkFormat(gl: WebGLRenderingContext, format: GLenum): format is 6406 | 6407 | 6408 | 6409 | 6410;
-export declare function validCubeTarget(gl: WebGLRenderingContext, target: GLenum): target is 34069 | 34070 | 34071 | 34072 | 34073 | 34074;
-export declare function flag<T = Partial<Gwebgl.WebGLRenderingContext.ConstructorProps>>(options: T, name: keyof T, dflt: boolean): boolean;
+export declare function checkFormat(gl: WebGLContextBase, format: GLenum): format is 6406 | 6407 | 6408 | 6409 | 6410;
+export declare function validCubeTarget(gl: WebGLContextBase, target: GLenum): target is 34069 | 34070 | 34071 | 34072 | 34073 | 34074;
+export declare function flag<T = Record<string, any>>(options: T, name: keyof T, dflt: boolean): boolean;

package/lib/types/webgl-buffer.d.ts

@@ -1,9 +1,9 @@
 import { Linkable } from './linkable.js';
-import type { WebGLRenderingContext } from './webgl-rendering-context.js';
+import type { WebGLContextBase } from './webgl-context-base.js';
 export declare class WebGLBuffer extends Linkable implements WebGLBuffer {
-    _ctx: WebGLRenderingContext;
+    _ctx: WebGLContextBase;
     _size: number;
     _elements: Uint8Array<ArrayBuffer>;
-    constructor(_: number, ctx: WebGLRenderingContext);
+    constructor(_: number, ctx: WebGLContextBase);
     _performDelete(): void;
 }

package/lib/types/webgl-context-base.d.ts

@@ -0,0 +1,267 @@
+import '@girs/gdkpixbuf-2.0';
+import Gwebgl from '@girs/gwebgl-0.1';
+import GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+import { WebGLContextAttributes } from './webgl-context-attributes.js';
+import { HTMLCanvasElement } from './html-canvas-element.js';
+import { WebGLActiveInfo } from './webgl-active-info.js';
+import { WebGLFramebuffer } from './webgl-framebuffer.js';
+import { WebGLBuffer } from './webgl-buffer.js';
+import { WebGLDrawingBufferWrapper } from './webgl-drawing-buffer-wrapper.js';
+import { WebGLProgram } from './webgl-program.js';
+import { WebGLRenderbuffer } from './webgl-renderbuffer.js';
+import { WebGLShader } from './webgl-shader.js';
+import { WebGLShaderPrecisionFormat } from './webgl-shader-precision-format.js';
+import { WebGLTextureUnit } from './webgl-texture-unit.js';
+import { WebGLTexture } from './webgl-texture.js';
+import { WebGLUniformLocation } from './webgl-uniform-location.js';
+import { WebGLVertexArrayObjectState, WebGLVertexArrayGlobalState } from './webgl-vertex-attribute.js';
+import type { TypedArray, WebGLConstants } from './types/index.js';
+export interface WebGLContextBase extends WebGLConstants {
+}
+export declare abstract class WebGLContextBase {
+    canvas: HTMLCanvasElement;
+    /** TODO implement this: https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawingBufferColorSpace */
+    drawingBufferColorSpace: PredefinedColorSpace;
+    unpackColorSpace: PredefinedColorSpace;
+    readonly RGBA8: 32856;
+    get drawingBufferHeight(): number;
+    get drawingBufferWidth(): number;
+    DEFAULT_ATTACHMENTS: number[];
+    DEFAULT_COLOR_ATTACHMENTS: number[];
+    /** context counter */
+    _: number;
+    abstract get _gl(): Gwebgl.WebGLRenderingContextBase;
+    _contextAttributes: WebGLContextAttributes;
+    _extensions: Record<string, any>;
+    _programs: Record<number, WebGLProgram>;
+    _shaders: Record<number, WebGLShader>;
+    _textures: Record<number, WebGLTexture>;
+    _framebuffers: Record<number, WebGLFramebuffer>;
+    _renderbuffers: Record<number, WebGLRenderbuffer>;
+    _buffers: Record<number, WebGLBuffer>;
+    _activeProgram: WebGLProgram | null;
+    _activeFramebuffer: WebGLFramebuffer | null;
+    _activeRenderbuffer: WebGLRenderbuffer | null;
+    _checkStencil: boolean;
+    _stencilState: boolean;
+    _activeTextureUnit: number;
+    _errorStack: GLenum[];
+    _defaultVertexObjectState: WebGLVertexArrayObjectState;
+    _vertexObjectState: WebGLVertexArrayObjectState;
+    _vertexGlobalState: WebGLVertexArrayGlobalState;
+    _maxTextureSize: number;
+    _maxTextureLevel: number;
+    _maxCubeMapSize: number;
+    _maxCubeMapLevel: number;
+    _unpackAlignment: number;
+    _packAlignment: number;
+    _unpackFlipY: boolean;
+    _viewport: Int32Array;
+    _scissorBox: Int32Array;
+    _gtkFboId: number;
+    _textureUnits: WebGLTextureUnit[];
+    _drawingBuffer: WebGLDrawingBufferWrapper | null;
+    protected constructor(canvas: HTMLCanvasElement | null, options?: Record<string, any>);
+    /**
+     * Must be called by subclass constructors AFTER setting up the native GL object
+     * so that `this._gl` is available for GL-dependent initialization.
+     */
+    protected _init(): void;
+    _initGLConstants(): void;
+    _getGlslVersion(es: boolean): string;
+    _checkDimensions(target: GLenum, width: GLsizei, height: GLsizei, level: number): boolean;
+    _checkLocation(location: WebGLUniformLocation | null): boolean;
+    _checkLocationActive(location: WebGLUniformLocation | null): boolean;
+    _checkOwns(object: any): boolean;
+    _checkShaderSource(shader: WebGLShader): boolean;
+    _checkStencilState(): boolean;
+    _checkTextureTarget(target: GLenum): boolean;
+    _checkWrapper(object: any, Wrapper: any): boolean;
+    _checkValid(object: any, Type: any): boolean;
+    _checkVertexAttribState(maxIndex: number): boolean;
+    _checkVertexIndex(index: number): boolean;
+    _computePixelSize(type: GLenum, internalFormat: GLenum): 0 | 1 | 2 | 3 | 4;
+    _computeRowStride(width: number, pixelSize: number): number;
+    _fixupLink(program: WebGLProgram): boolean;
+    _framebufferOk(): boolean;
+    _getActiveBuffer(target: GLenum): WebGLBuffer;
+    _getActiveTextureUnit(): WebGLTextureUnit;
+    _getActiveTexture(target: GLenum): WebGLTexture;
+    _getAttachments(): any;
+    _getColorAttachments(): any;
+    _getParameterDirect(pname: GLenum): any;
+    _getTexImage(target: GLenum): WebGLTexture;
+    _preCheckFramebufferStatus(framebuffer: WebGLFramebuffer): GLenum;
+    _isConstantBlendFunc(factor: GLenum): factor is 32769 | 32770 | 32771 | 32772;
+    _isObject(object: any, method: any, Wrapper: any): boolean;
+    _resizeDrawingBuffer(width: number, height: number): void;
+    _restoreError(lastError: GLenum): void;
+    _saveError(): void;
+    _switchActiveProgram(active: WebGLProgram | null): void;
+    _tryDetachFramebuffer(framebuffer: WebGLFramebuffer | null, renderbuffer: WebGLRenderbuffer): void;
+    _updateFramebufferAttachments(framebuffer: WebGLFramebuffer | null): void;
+    _validBlendFunc(factor: GLenum): factor is 0 | 1 | 768 | 769 | 770 | 771 | 772 | 773 | 774 | 775 | 776 | 32769 | 32770 | 32771 | 32772;
+    _validBlendMode(mode: GLenum): boolean;
+    _validCubeTarget(target: GLenum): target is 34069 | 34070 | 34071 | 34072 | 34073 | 34074;
+    _validFramebufferAttachment(attachment: GLenum): boolean;
+    _validGLSLIdentifier(str: string): boolean;
+    _validTextureTarget(target: GLenum): target is 3553 | 34067;
+    _verifyTextureCompleteness(target: GLenum, pname: GLenum, param: GLenum): void;
+    _wrapShader(_type: GLenum, source: string): string;
+    _allocateDrawingBuffer(width: number, height: number): void;
+    /**
+     * The `WebGLRenderingContext.getContextAttributes()` method returns a `WebGLContextAttributes` object that contains the actual context parameters.
+     * Might return `null`, if the context is lost.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getContextAttributes
+     * @returns A `WebGLContextAttributes` object that contains the actual context parameters, or `null` if the context is lost.
+     */
+    getContextAttributes(): WebGLContextAttributes | null;
+    getExtension(name: string): any;
+    bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
+    bufferData(target: GLenum, data: BufferSource | null, usage: GLenum): void;
+    bufferSubData(target: GLenum, offset: GLintptr, data: BufferSource): void;
+    compressedTexImage2D(target: GLenum, level: GLint, internalFormat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: TypedArray): void;
+    compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: TypedArray): void;
+    readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: TypedArray | null): void;
+    texImage2D(target: GLenum, level: GLint, internalFormat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
+    texImage2D(target: GLenum, level: GLint, internalFormat: GLint, format: GLenum, type: GLenum, source: TexImageSource | GdkPixbuf.Pixbuf): void;
+    texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
+    texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource | GdkPixbuf.Pixbuf): void;
+    _checkUniformValid(location: WebGLUniformLocation | null, v0: GLfloat, name: string, count: number, type: string): boolean;
+    _checkUniformValueValid(location: WebGLUniformLocation | null, value: Float32List | Int32List, name: string, count: number, _type: string): boolean;
+    uniform1fv(location: WebGLUniformLocation | null, value: Float32List | Int32List): void;
+    uniform1iv(location: WebGLUniformLocation | null, v: Int32List): void;
+    uniform2fv(location: WebGLUniformLocation | null, v: Float32List): void;
+    uniform2iv(location: WebGLUniformLocation | null, v: Int32List): void;
+    uniform3fv(location: WebGLUniformLocation | null, v: Float32List): void;
+    uniform3iv(location: WebGLUniformLocation | null, v: Int32List): void;
+    uniform4fv(location: WebGLUniformLocation | null, v: Float32List): void;
+    uniform4iv(location: WebGLUniformLocation | null, v: Int32List): void;
+    _checkUniformMatrix(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List, name: string, count: number): boolean;
+    uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
+    uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
+    uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Float32List): void;
+    activeTexture(texture?: GLenum): void;
+    attachShader(program: WebGLProgram, shader: WebGLShader): void;
+    bindAttribLocation(program: WebGLProgram, index: GLuint, name: string): void;
+    bindBuffer(target: GLenum, buffer: WebGLBuffer | null): void;
+    bindFramebuffer(target: GLenum, framebuffer: WebGLFramebuffer | null): void;
+    bindRenderbuffer(target: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
+    bindTexture(target: GLenum, texture: WebGLTexture | null): void;
+    blendColor(red?: GLclampf, green?: GLclampf, blue?: GLclampf, alpha?: GLclampf): void;
+    blendEquation(mode?: GLenum): void;
+    blendEquationSeparate(modeRGB?: GLenum, modeAlpha?: GLenum): void;
+    blendFunc(sfactor?: GLenum, dfactor?: GLenum): void;
+    blendFuncSeparate(srcRGB?: GLenum, dstRGB?: GLenum, srcAlpha?: GLenum, dstAlpha?: GLenum): void;
+    checkFramebufferStatus(target: GLenum): GLenum;
+    clear(mask?: GLbitfield): void;
+    clearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
+    clearDepth(depth: GLclampf): void;
+    clearStencil(s?: GLint): void;
+    colorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean): void;
+    compileShader(shader: WebGLShader): void;
+    copyTexImage2D(target?: GLenum, level?: GLint, internalFormat?: GLenum, x?: GLint, y?: GLint, width?: GLsizei, height?: GLsizei, border?: GLint): void;
+    copyTexSubImage2D(target?: GLenum, level?: GLint, xoffset?: GLint, yoffset?: GLint, x?: GLint, y?: GLint, width?: GLsizei, height?: GLsizei): void;
+    createBuffer(): WebGLBuffer | null;
+    createFramebuffer(): WebGLFramebuffer | null;
+    createProgram(): WebGLProgram | null;
+    createRenderbuffer(): WebGLRenderbuffer | null;
+    createShader(type?: GLenum): WebGLShader | null;
+    createTexture(): WebGLTexture | null;
+    cullFace(mode: GLenum): void;
+    deleteBuffer(buffer: WebGLBuffer | null): void;
+    deleteFramebuffer(framebuffer: WebGLFramebuffer | null): void;
+    _deleteLinkable(name: 'deleteProgram', object: WebGLProgram | null, Type: typeof WebGLProgram): void;
+    _deleteLinkable(name: 'deleteShader', object: WebGLShader | null, Type: typeof WebGLShader): void;
+    deleteProgram(program: WebGLProgram | null): void;
+    deleteRenderbuffer(renderbuffer: WebGLRenderbuffer | null): void;
+    deleteShader(shader: WebGLShader | null): void;
+    deleteTexture(texture: WebGLTexture | null): void;
+    depthFunc(func: GLenum): void;
+    depthMask(flag: GLboolean): void;
+    depthRange(zNear: GLclampf, zFar: GLclampf): void;
+    destroy(): void;
+    detachShader(program: WebGLProgram, shader: WebGLShader): void;
+    disable(cap?: GLenum): void;
+    disableVertexAttribArray(index?: GLuint): void;
+    drawArrays(mode?: GLenum, first?: GLint, count?: GLsizei): void;
+    drawElements(mode?: GLenum, count?: GLsizei, type?: GLenum, ioffset?: GLintptr): void;
+    enable(cap?: GLenum): void;
+    enableVertexAttribArray(index: GLuint): void;
+    finish(): void;
+    flush(): void;
+    framebufferRenderbuffer(target: GLenum, attachment: GLenum, renderbufferTarget: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
+    framebufferTexture2D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: WebGLTexture | null, level?: GLint): void;
+    frontFace(mode?: GLenum): void;
+    generateMipmap(target?: GLenum): void;
+    getActiveAttrib(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
+    getActiveUniform(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
+    getAttachedShaders(program: WebGLProgram): WebGLShader[] | null;
+    getAttribLocation(program: WebGLProgram, name: string): GLint;
+    getBufferParameter(target?: GLenum, pname?: GLenum): any;
+    getError(): GLenum;
+    setError(error: GLenum): void;
+    getFramebufferAttachmentParameter(target?: GLenum, attachment?: GLenum, pname?: GLenum): any;
+    getParameter(pname?: GLenum): any;
+    getProgramInfoLog(program: WebGLProgram): string | null;
+    getProgramParameter(program: WebGLProgram, pname?: GLenum): any;
+    getRenderbufferParameter(target?: GLenum, pname?: GLenum): any;
+    getShaderInfoLog(shader: WebGLShader): string | null;
+    getShaderParameter(shader: WebGLShader, pname?: GLenum): any;
+    getShaderPrecisionFormat(shaderType?: GLenum, precisionType?: GLenum): WebGLShaderPrecisionFormat | null;
+    getShaderSource(shader: WebGLShader): string | null;
+    getSupportedExtensions(): string[];
+    _getTexParameterDirect(target?: GLenum, pname?: GLenum): unknown;
+    getTexParameter(target?: GLenum, pname?: GLenum): any;
+    getUniform(program: WebGLProgram, location: WebGLUniformLocation): any;
+    getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation | null;
+    getVertexAttrib(index?: GLuint, pname?: GLenum): any;
+    getVertexAttribOffset(index?: GLuint, pname?: GLenum): GLintptr;
+    hint(target?: GLenum, mode?: GLenum): void;
+    isBuffer(buffer: WebGLBuffer): GLboolean;
+    isContextLost(): boolean;
+    isEnabled(cap?: GLenum): GLboolean;
+    isFramebuffer(framebuffer: WebGLShader): GLboolean;
+    isProgram(program: WebGLProgram): GLboolean;
+    isRenderbuffer(renderbuffer: WebGLRenderbuffer): GLboolean;
+    isShader(shader: WebGLShader): GLboolean;
+    isTexture(texture: WebGLTexture): GLboolean;
+    lineWidth(width: GLfloat): void;
+    linkProgram(program: WebGLProgram): void;
+    /** The `WebGLRenderingContext.pixelStorei()` method of the WebGL API specifies the pixel storage modes. */
+    pixelStorei(pname?: GLenum, param?: GLint | GLboolean): void;
+    polygonOffset(factor: GLfloat, units: GLfloat): void;
+    renderbufferStorage(target?: GLenum, internalFormat?: GLenum, width?: GLsizei, height?: GLsizei): void;
+    resize(width?: number, height?: number): void;
+    sampleCoverage(value: GLclampf, invert: GLboolean): void;
+    scissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
+    shaderSource(shader: WebGLShader, source: string): void;
+    stencilFunc(func: GLenum, ref: GLint, mask: GLuint): void;
+    stencilFuncSeparate(face: GLenum, func: GLenum, ref: GLint, mask: GLuint): void;
+    stencilMask(mask: GLuint): void;
+    stencilMaskSeparate(face: GLenum, mask: GLuint): void;
+    stencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum): void;
+    stencilOpSeparate(face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum): void;
+    texParameterf(target: GLenum, pname: GLenum, param: GLfloat): void;
+    texParameteri(target?: GLenum, pname?: GLenum, param?: GLint): void;
+    uniform1f(location: WebGLUniformLocation | null, x: GLfloat): void;
+    uniform1i(location: WebGLUniformLocation | null, x: GLint): void;
+    uniform2f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat): void;
+    uniform2i(location: WebGLUniformLocation | null, x: GLint, y: GLint): void;
+    uniform3f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat): void;
+    uniform3i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint): void;
+    uniform4f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
+    uniform4i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint, w: GLint): void;
+    useProgram(program: WebGLProgram): void;
+    validateProgram(program: WebGLProgram): void;
+    vertexAttrib1f(index: GLuint, x: GLfloat): void;
+    vertexAttrib1fv(index: GLuint, values: Float32List): void;
+    vertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat): void;
+    vertexAttrib2fv(index: GLuint, values: Float32List): void;
+    vertexAttrib3f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat): void;
+    vertexAttrib3fv(index: GLuint, values: Float32List): void;
+    vertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
+    vertexAttrib4fv(index: GLuint, values: Float32List): void;
+    vertexAttribPointer(index?: GLuint, size?: GLint, type?: GLenum, normalized?: GLboolean, stride?: GLsizei, offset?: GLintptr): void;
+    viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
+}

package/lib/types/webgl-framebuffer.d.ts

@@ -1,7 +1,7 @@
 import { Linkable } from './linkable.js';
-import type { WebGLRenderingContext } from './webgl-rendering-context.js';
+import type { WebGLContextBase } from './webgl-context-base.js';
 export declare class WebGLFramebuffer extends Linkable implements WebGLFramebuffer {
-    _ctx: WebGLRenderingContext;
+    _ctx: WebGLContextBase;
     _binding: number;
     _width: number;
     _height: number;
@@ -9,7 +9,7 @@ export declare class WebGLFramebuffer extends Linkable implements WebGLFramebuff
     _attachments: Record<GLenum, WebGLTexture | WebGLRenderbuffer | null>;
     _attachmentLevel: Record<GLenum, number | null>;
     _attachmentFace: Record<GLenum, number | null>;
-    constructor(_: number, ctx: WebGLRenderingContext);
+    constructor(_: number, ctx: WebGLContextBase);
     _clearAttachment(attachment: GLenum): void;
     _setAttachment(object: WebGLTexture | WebGLRenderbuffer | null, attachment: GLenum): void;
     _performDelete(): void;

package/lib/types/webgl-program.d.ts

@@ -1,13 +1,13 @@
 import { Linkable } from './linkable.js';
 import { WebGLActiveInfo } from './webgl-active-info.js';
-import type { WebGLRenderingContext } from './webgl-rendering-context.js';
+import type { WebGLContextBase } from './webgl-context-base.js';
 export declare class WebGLProgram extends Linkable implements WebGLProgram {
-    _ctx: WebGLRenderingContext;
+    _ctx: WebGLContextBase;
     _linkCount: number;
     _linkStatus: boolean;
     _linkInfoLog: string | null;
     _attributes: number[];
     _uniforms: WebGLActiveInfo[];
-    constructor(_: number, ctx: WebGLRenderingContext);
+    constructor(_: number, ctx: WebGLContextBase);
     _performDelete(): void;
 }

package/lib/types/webgl-renderbuffer.d.ts

@@ -1,11 +1,11 @@
 import { Linkable } from './linkable.js';
-import type { WebGLRenderingContext } from './webgl-rendering-context.js';
+import type { WebGLContextBase } from './webgl-context-base.js';
 export declare class WebGLRenderbuffer extends Linkable implements WebGLRenderbuffer {
-    _ctx: WebGLRenderingContext;
+    _ctx: WebGLContextBase;
     _binding: number;
     _width: number;
     _height: number;
     _format: number;
-    constructor(_: number, ctx: WebGLRenderingContext);
+    constructor(_: number, ctx: WebGLContextBase);
     _performDelete(): void;
 }