@gjsify/webgl 0.0.4 → 0.1.0

package/lib/types/index.d.ts

@@ -2,6 +2,7 @@ import '@girs/gjs';
 import '@girs/gio-2.0';
 import '@girs/gtk-4.0';
 export * from './html-canvas-element.js';
+export * from './canvas-webgl-widget.js';
 export * from './webgl-active-info.js';
 export * from './webgl-buffer.js';
 export * from './webgl-context-attributes.js';
@@ -9,8 +10,14 @@ export * from './webgl-drawing-buffer-wrapper.js';
 export * from './webgl-framebuffer.js';
 export * from './webgl-program.js';
 export * from './webgl-renderbuffer.js';
+export * from './webgl-query.js';
 export * from './webgl-rendering-context.js';
+export * from './webgl-sampler.js';
 export * from './webgl-shader-precision-format.js';
+export * from './webgl-sync.js';
+export * from './webgl-transform-feedback.js';
+export * from './webgl-vertex-array-object.js';
+export * from './webgl2-rendering-context.js';
 export * from './webgl-shader.js';
 export * from './webgl-texture-unit.js';
 export * from './webgl-texture.js';

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

@@ -0,0 +1,45 @@
+/** Compile a WebGL shader from source. Does not check compile status. */
+export declare function makeShader(gl: WebGLRenderingContext, type: number, src: string): WebGLShader;
+/**
+ * Link a WebGL program from vertex + fragment source strings.
+ * Binds attribute "position" to location 0 before linking so that drawTriangle() works
+ * without an explicit getAttribLocation() call.
+ * Does not check link status — call getProgramParameter(prog, LINK_STATUS) if needed.
+ */
+export declare function makeProgram(gl: WebGLRenderingContext, vsSrc: string, fsSrc: string): WebGLProgram;
+/**
+ * Draw a fullscreen triangle using attribute location 0.
+ * Covers the entire clip space: vertices at (-2,-2), (-2,4), (4,-2).
+ * The active program must expose a vec2 attribute named "position" at location 0
+ * (ensured by makeProgram's bindAttribLocation call).
+ */
+export declare function drawTriangle(gl: WebGLRenderingContext): void;
+/** Read a single RGBA pixel at (x, y). Defaults to (0, 0). */
+export declare function readPixel(gl: WebGLRenderingContext, x?: number, y?: number): Uint8Array;
+/** Return true if |a[i] - b[i]| <= tolerance for every RGBA component. */
+export declare function pixelClose(a: Uint8Array, b: number[], tolerance?: number): boolean;
+export interface TestFBO {
+    fb: WebGLFramebuffer;
+    colorTex: WebGLTexture;
+    width: number;
+    height: number;
+}
+export interface TestFBOWithDepth extends TestFBO {
+    depthRb: WebGLRenderbuffer;
+}
+/**
+ * Create a w×h RGBA8 FBO and bind it as the current framebuffer.
+ * Also sets the viewport to (0, 0, w, h).
+ * Call destroyTestFBO() when done.
+ */
+export declare function makeTestFBO(gl: WebGLRenderingContext, width?: number, height?: number): TestFBO;
+/**
+ * Create a w×h RGBA8 FBO with a DEPTH_COMPONENT16 renderbuffer and bind it.
+ * Also sets the viewport to (0, 0, w, h).
+ * Call destroyTestFBOWithDepth() when done.
+ */
+export declare function makeTestFBOWithDepth(gl: WebGLRenderingContext, width?: number, height?: number): TestFBOWithDepth;
+/** Unbind the FBO and delete the color texture. */
+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;

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

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

package/lib/types/utils.d.ts

@@ -1,22 +1,21 @@
-/// <reference types="node" resolution-mode="require"/>
 import { WebGLUniformLocation } from './webgl-uniform-location.js';
 import { WebGLProgram } from './webgl-program.js';
 import GLib from '@girs/glib-2.0';
-import { HTMLImageElement as GjsifyHTMLImageElement } from "@gjsify/html-image-element";
+import { HTMLImageElement } from "@gjsify/dom-elements";
 import type Gwebgl from '@girs/gwebgl-0.1';
-import type { GjsifyWebGLRenderingContext } from './webgl-rendering-context.js';
+import type { WebGLRenderingContext } from './webgl-rendering-context.js';
 import type { TypedArray } from './types/index.js';
-export declare function bindPublics(props: Array<keyof GjsifyWebGLRenderingContext>, wrapper: GjsifyWebGLRenderingContext, privateInstance: GjsifyWebGLRenderingContext, privateMethods: string[]): void;
+export declare function bindPublics(props: Array<keyof WebGLRenderingContext>, wrapper: WebGLRenderingContext, privateInstance: WebGLRenderingContext, 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): 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: GjsifyWebGLRenderingContext, primitive: GLenum, count: number): number;
-export declare function typeSize(gl: GjsifyWebGLRenderingContext, type: GLenum): 0 | 1 | 2 | 4;
-export declare function uniformTypeSize(gl: GjsifyWebGLRenderingContext, type: GLenum): 0 | 1 | 2 | 3 | 4;
+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 const listToArray: (values: Float32List) => number[];
-export declare function arrayToUint8Array(array: TypedArray | Float32List | Array<number> | ArrayBuffer | DataView): Uint8Array;
-export declare function Uint8ArrayToVariant(array: Uint8Array | null): GLib.Variant;
+export declare function arrayToUint8Array(array: TypedArray | Float32List | Array<number> | ArrayBuffer | DataView): Uint8Array<ArrayBufferLike>;
+export declare function Uint8ArrayToVariant(array: Uint8Array | null): GLib.Variant<"ay">;
 /**
  * Converts an ArrayBufferView to an array of bools. gjs returns
  * Uint8Array, but the elements are actually 4 bytes each.
@@ -24,9 +23,9 @@ export declare function Uint8ArrayToVariant(array: Uint8Array | null): GLib.Vari
  * @returns
  */
 export declare function boolArray(array: ArrayBufferView): boolean[];
-export declare const extractImageData: (pixels: TexImageSource | GjsifyHTMLImageElement) => ImageData | null;
-export declare function formatSize(gl: GjsifyWebGLRenderingContext, internalFormat: number): 0 | 1 | 2 | 3 | 4;
-export declare function convertPixels(pixels: ArrayBuffer | Uint8Array | Uint16Array | Uint8ClampedArray | Float32Array | Buffer | ArrayBufferView | null): Uint8Array;
-export declare function checkFormat(gl: GjsifyWebGLRenderingContext, format: GLenum): boolean;
-export declare function validCubeTarget(gl: GjsifyWebGLRenderingContext, target: GLenum): 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 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 = Gwebgl.WebGLRenderingContext.ConstructorProperties>(options: T, name: keyof T, dflt: boolean): boolean;

package/lib/types/webgl-active-info.d.ts

@@ -1,7 +1,6 @@
-declare class GjsifyWebGLActiveInfo implements WebGLActiveInfo {
+export declare class WebGLActiveInfo implements WebGLActiveInfo {
     size: GLsizei;
     type: GLenum;
     name: string;
     constructor(_: WebGLActiveInfo);
 }
-export { GjsifyWebGLActiveInfo as WebGLActiveInfo };

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

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

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

@@ -1,4 +1,4 @@
-export declare class GjsifyWebGLContextAttributes implements WebGLContextAttributes {
+export declare class WebGLContextAttributes implements WebGLContextAttributes {
     alpha?: boolean;
     depth?: boolean;
     stencil?: boolean;
@@ -11,4 +11,3 @@ export declare class GjsifyWebGLContextAttributes implements WebGLContextAttribu
     powerPreference?: WebGLPowerPreference;
     constructor(alpha?: boolean, depth?: boolean, stencil?: boolean, antialias?: boolean, premultipliedAlpha?: boolean, preserveDrawingBuffer?: boolean, preferLowPowerToHighPerformance?: boolean, failIfMajorPerformanceCaveat?: boolean);
 }
-export { GjsifyWebGLContextAttributes as WebGLContextAttributes };

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { Linkable } from './linkable.js';
+import type { WebGL2RenderingContext } from './webgl2-rendering-context.js';
+export declare class WebGLQuery extends Linkable implements WebGLQuery {
+    _ctx: WebGL2RenderingContext;
+    constructor(_: number, ctx: WebGL2RenderingContext);
+    _performDelete(): void;
+}

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

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

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

@@ -1,9 +1,8 @@
-/// <reference types="@girs/gdkpixbuf-2.0/ambient" />
 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 { GjsifyHTMLCanvasElement } from './html-canvas-element.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';
@@ -17,12 +16,14 @@ 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 GjsifyWebGLRenderingContext extends WebGLConstants {
+export interface WebGLRenderingContext extends WebGLConstants {
 }
-export declare class GjsifyWebGLRenderingContext implements WebGLRenderingContext {
-    canvas: GjsifyHTMLCanvasElement & HTMLCanvasElement;
+export declare class WebGLRenderingContext implements WebGLRenderingContext {
+    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[];
@@ -54,12 +55,14 @@ export declare class GjsifyWebGLRenderingContext implements WebGLRenderingContex
     _maxCubeMapLevel: number;
     _unpackAlignment: number;
     _packAlignment: number;
+    _viewport: Int32Array;
+    _scissorBox: Int32Array;
     _attrib0Buffer: WebGLBuffer | null;
     _textureUnits: WebGLTextureUnit[];
     _drawingBuffer: WebGLDrawingBufferWrapper | null;
-    constructor(canvas: GjsifyHTMLCanvasElement | HTMLCanvasElement | null, options?: Gwebgl.WebGLRenderingContext.ConstructorProperties);
+    constructor(canvas: HTMLCanvasElement | null, options?: Gwebgl.WebGLRenderingContext.ConstructorProperties);
     _initGLConstants(): void;
-    _getGlslVersion(es: boolean): "100" | "120";
+    _getGlslVersion(es: boolean): string;
     _checkDimensions(target: GLenum, width: GLsizei, height: GLsizei, level: number): boolean;
     _checkLocation(location: WebGLUniformLocation | null): boolean;
     _checkLocationActive(location: WebGLUniformLocation | null): boolean;
@@ -83,7 +86,7 @@ export declare class GjsifyWebGLRenderingContext implements WebGLRenderingContex
     _getParameterDirect(pname: GLenum): any;
     _getTexImage(target: GLenum): WebGLTexture;
     _preCheckFramebufferStatus(framebuffer: WebGLFramebuffer): 36053 | 36054 | 36055 | 36057 | 36061;
-    _isConstantBlendFunc(factor: GLenum): boolean;
+    _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;
@@ -91,12 +94,12 @@ export declare class GjsifyWebGLRenderingContext implements WebGLRenderingContex
     _switchActiveProgram(active: WebGLProgram | null): void;
     _tryDetachFramebuffer(framebuffer: WebGLFramebuffer | null, renderbuffer: WebGLRenderbuffer): void;
     _updateFramebufferAttachments(framebuffer: WebGLFramebuffer | null): void;
-    _validBlendFunc(factor: GLenum): boolean;
+    _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): boolean;
+    _validCubeTarget(target: GLenum): target is 34069 | 34070 | 34071 | 34072 | 34073 | 34074;
     _validFramebufferAttachment(attachment: GLenum): boolean;
     _validGLSLIdentifier(str: string): boolean;
-    _validTextureTarget(target: GLenum): boolean;
+    _validTextureTarget(target: GLenum): target is 3553 | 34067;
     _verifyTextureCompleteness(target: GLenum, pname: GLenum, param: GLenum): void;
     _wrapShader(_type: GLenum, source: string): string;
     _beginAttrib0Hack(): void;
@@ -111,7 +114,7 @@ export declare class GjsifyWebGLRenderingContext implements WebGLRenderingContex
     getContextAttributes(): WebGLContextAttributes | null;
     getExtension(name: string): any;
     bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
-    bufferData(target: GLenum, data: TypedArray | BufferSource | null, 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;
@@ -258,4 +261,3 @@ export declare class GjsifyWebGLRenderingContext implements WebGLRenderingContex
     vertexAttribPointer(index?: GLuint, size?: GLint, type?: GLenum, normalized?: GLboolean, stride?: GLsizei, offset?: GLintptr): void;
     viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
 }
-export { GjsifyWebGLRenderingContext as WebGLRenderingContext };

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

@@ -0,0 +1,7 @@
+import { Linkable } from './linkable.js';
+import type { WebGL2RenderingContext } from './webgl2-rendering-context.js';
+export declare class WebGLSampler extends Linkable implements WebGLSampler {
+    _ctx: WebGL2RenderingContext;
+    constructor(_: number, ctx: WebGL2RenderingContext);
+    _performDelete(): void;
+}

package/lib/types/webgl-shader-precision-format.d.ts

@@ -1,7 +1,6 @@
-export declare class GjsifyWebGLShaderPrecisionFormat implements WebGLShaderPrecisionFormat {
+export declare class WebGLShaderPrecisionFormat implements WebGLShaderPrecisionFormat {
     rangeMin: number;
     rangeMax: number;
     precision: number;
     constructor(_: WebGLShaderPrecisionFormat);
 }
-export { GjsifyWebGLShaderPrecisionFormat as WebGLShaderPrecisionFormat };

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

@@ -1,12 +1,11 @@
 import { Linkable } from './linkable.js';
-import type { GjsifyWebGLRenderingContext } from './webgl-rendering-context.js';
-export declare class GjsifyWebGLShader extends Linkable implements WebGLShader {
+import type { WebGLRenderingContext } from './webgl-rendering-context.js';
+export declare class WebGLShader extends Linkable implements WebGLShader {
     _type: GLenum;
-    _ctx: GjsifyWebGLRenderingContext;
+    _ctx: WebGLRenderingContext;
     _source: string;
     _compileStatus: boolean;
     _compileInfo: string;
-    constructor(_: WebGLShader & number, ctx: GjsifyWebGLRenderingContext, type: GLenum);
+    constructor(_: number, ctx: WebGLRenderingContext, type: GLenum);
     _performDelete(): void;
 }
-export { GjsifyWebGLShader as WebGLShader };

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

@@ -0,0 +1,7 @@
+import { Linkable } from './linkable.js';
+import type { WebGL2RenderingContext } from './webgl2-rendering-context.js';
+export declare class WebGLSync extends Linkable implements WebGLSync {
+    _ctx: WebGL2RenderingContext;
+    constructor(_: number, ctx: WebGL2RenderingContext);
+    _performDelete(): void;
+}

package/lib/types/webgl-texture-unit.d.ts

@@ -1,10 +1,10 @@
-import type { GjsifyWebGLRenderingContext } from './webgl-rendering-context.js';
+import type { WebGLRenderingContext } from './webgl-rendering-context.js';
 import type { WebGLTexture } from './webgl-texture.js';
 export declare class WebGLTextureUnit {
-    _ctx: GjsifyWebGLRenderingContext;
+    _ctx: WebGLRenderingContext;
     _idx: number;
     _mode: number;
     _bind2D: WebGLTexture | null;
     _bindCube: WebGLTexture | null;
-    constructor(ctx: GjsifyWebGLRenderingContext, idx: number);
+    constructor(ctx: WebGLRenderingContext, idx: number);
 }

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

@@ -1,14 +1,13 @@
 import { Linkable } from './linkable.js';
-import type { GjsifyWebGLRenderingContext } from './webgl-rendering-context.js';
-export declare class GjsifyWebGLTexture extends Linkable implements WebGLTexture {
-    _ctx: GjsifyWebGLRenderingContext;
+import type { WebGLRenderingContext } from './webgl-rendering-context.js';
+export declare class WebGLTexture extends Linkable implements WebGLTexture {
+    _ctx: WebGLRenderingContext;
     _binding: number;
-    _levelWidth: Int32Array;
-    _levelHeight: Int32Array;
+    _levelWidth: Int32Array<ArrayBuffer>;
+    _levelHeight: Int32Array<ArrayBuffer>;
     _format: number;
     _type: number;
     _complete: boolean;
-    constructor(_: WebGLTexture & number, ctx: GjsifyWebGLRenderingContext);
+    constructor(_: number, ctx: WebGLRenderingContext);
     _performDelete(): void;
 }
-export { GjsifyWebGLTexture as WebGLTexture };

package/lib/types/webgl-transform-feedback.d.ts

@@ -0,0 +1,7 @@
+import { Linkable } from './linkable.js';
+import type { WebGL2RenderingContext } from './webgl2-rendering-context.js';
+export declare class WebGLTransformFeedback extends Linkable implements WebGLTransformFeedback {
+    _ctx: WebGL2RenderingContext;
+    constructor(_: number, ctx: WebGL2RenderingContext);
+    _performDelete(): void;
+}

package/lib/types/webgl-uniform-location.d.ts

@@ -1,6 +1,6 @@
 import type { WebGLProgram } from './webgl-program.js';
-export declare class GjsifyWebGLUniformLocation implements WebGLUniformLocation {
-    _: WebGLUniformLocation & number;
+export declare class WebGLUniformLocation implements WebGLUniformLocation {
+    _: number;
     _program: WebGLProgram;
     _linkCount: number;
     _activeInfo: {
@@ -9,10 +9,9 @@ export declare class GjsifyWebGLUniformLocation implements WebGLUniformLocation
         name: string;
     };
     _array: Array<number | null> | null;
-    constructor(_: WebGLUniformLocation & number, program: WebGLProgram, info: {
+    constructor(_: number, program: WebGLProgram, info: {
         size: GLsizei;
         type: GLenum;
         name: string;
     });
 }
-export { GjsifyWebGLUniformLocation as WebGLUniformLocation };

package/lib/types/webgl-vertex-array-object.d.ts

@@ -0,0 +1,9 @@
+import { Linkable } from './linkable.js';
+import { WebGLVertexArrayObjectState } from './webgl-vertex-attribute.js';
+import type { WebGL2RenderingContext } from './webgl2-rendering-context.js';
+export declare class WebGLVertexArrayObject extends Linkable implements WebGLVertexArrayObject {
+    _ctx: WebGL2RenderingContext;
+    _objectState: WebGLVertexArrayObjectState;
+    constructor(_: number, ctx: WebGL2RenderingContext);
+    _performDelete(): void;
+}

package/lib/types/webgl-vertex-attribute.d.ts

@@ -1,7 +1,7 @@
 import { WebGLBuffer } from './webgl-buffer.js';
-import type { GjsifyWebGLRenderingContext } from './webgl-rendering-context.js';
+import type { WebGLRenderingContext } from './webgl-rendering-context.js';
 export declare class WebGLVertexArrayObjectAttribute {
-    _ctx: GjsifyWebGLRenderingContext;
+    _ctx: WebGLRenderingContext;
     _idx: number;
     _isPointer: boolean;
     _pointerBuffer: WebGLBuffer | null;
@@ -13,7 +13,7 @@ export declare class WebGLVertexArrayObjectAttribute {
     _divisor: number;
     _inputSize: number;
     _inputStride: number;
-    constructor(ctx: GjsifyWebGLRenderingContext, idx: number);
+    constructor(ctx: WebGLRenderingContext, idx: number);
     _clear(): void;
 }
 export declare class WebGLVertexArrayGlobalAttribute {
@@ -24,7 +24,7 @@ export declare class WebGLVertexArrayGlobalAttribute {
 export declare class WebGLVertexArrayObjectState {
     _attribs: WebGLVertexArrayObjectAttribute[];
     _elementArrayBufferBinding: WebGLBuffer | null;
-    constructor(ctx: GjsifyWebGLRenderingContext);
+    constructor(ctx: WebGLRenderingContext);
     setElementArrayBuffer(buffer: WebGLBuffer | null): void;
     cleanUp(): void;
     releaseArrayBuffer(buffer: WebGLBuffer): void;
@@ -33,6 +33,6 @@ export declare class WebGLVertexArrayObjectState {
 export declare class WebGLVertexArrayGlobalState {
     _arrayBufferBinding: WebGLBuffer | null;
     _attribs: WebGLVertexArrayGlobalAttribute[];
-    constructor(ctx: GjsifyWebGLRenderingContext);
+    constructor(ctx: WebGLRenderingContext);
     setArrayBuffer(buffer: WebGLBuffer | null): void;
 }

package/lib/types/webgl2-rendering-context.d.ts

@@ -0,0 +1,124 @@
+import Gwebgl from '@girs/gwebgl-0.1';
+import { WebGLRenderingContext } from './webgl-rendering-context.js';
+import { HTMLCanvasElement } from './html-canvas-element.js';
+import { WebGLQuery } from './webgl-query.js';
+import { WebGLSampler } from './webgl-sampler.js';
+import { WebGLSync } from './webgl-sync.js';
+import { WebGLTransformFeedback } from './webgl-transform-feedback.js';
+import { WebGLVertexArrayObject } from './webgl-vertex-array-object.js';
+import { WebGLUniformLocation } from './webgl-uniform-location.js';
+import { WebGLActiveInfo } from './webgl-active-info.js';
+import { WebGLTexture } from './webgl-texture.js';
+export declare class WebGL2RenderingContext extends WebGLRenderingContext implements WebGL2RenderingContext {
+    _native2: Gwebgl.WebGL2RenderingContext;
+    _queries: Record<number, WebGLQuery>;
+    _samplers: Record<number, WebGLSampler>;
+    _transformFeedbacks: Record<number, WebGLTransformFeedback>;
+    _vertexArrayObjects: Record<number, WebGLVertexArrayObject>;
+    _syncs: Record<number, WebGLSync>;
+    constructor(canvas: HTMLCanvasElement | null, options?: Gwebgl.WebGL2RenderingContext.ConstructorProperties);
+    _getGlslVersion(es: boolean): string;
+    /** WebGL2 allows COLOR_ATTACHMENT1–15 as framebuffer attachment points. */
+    _validFramebufferAttachment(attachment: GLenum): boolean;
+    /**
+     * Apply COLOR_ATTACHMENT1–15 to the native GL FBO when they have attachments.
+     * The base class only knows about CA0, DEPTH, STENCIL, DEPTH_STENCIL.
+     */
+    _updateFramebufferAttachments(framebuffer: any): void;
+    /** WebGL2 adds UNIFORM_BUFFER, TRANSFORM_FEEDBACK_BUFFER, etc. targets. */
+    bindBuffer(target: GLenum, buffer: WebGLBuffer | null): void;
+    /** WebGL2 adds READ/COPY buffer usages and additional buffer targets. */
+    bufferData(target: GLenum, dataOrSize: GLsizeiptr | BufferSource | null, usage: GLenum): void;
+    /** WebGL2 adds TEXTURE_3D and TEXTURE_2D_ARRAY target support. */
+    bindTexture(target: GLenum, texture: WebGLTexture | null): void;
+    /** WebGL2 adds TEXTURE_3D/TEXTURE_2D_ARRAY targets and TEXTURE_WRAP_R pname. */
+    texParameteri(target: GLenum, pname: GLenum, param: GLint): void;
+    /**
+     * In WebGL2/GLES3 the attribute-0 requirement from WebGL1 does not apply.
+     * Override drawArrays to skip the attrib0 hack and call glDrawArrays directly.
+     */
+    drawArrays(mode: GLenum, first: GLint, count: GLsizei): void;
+    createVertexArray(): WebGLVertexArrayObject | null;
+    deleteVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
+    isVertexArray(vertexArray: WebGLVertexArrayObject | null): GLboolean;
+    bindVertexArray(array: WebGLVertexArrayObject | null): void;
+    createQuery(): WebGLQuery | null;
+    deleteQuery(query: WebGLQuery | null): void;
+    isQuery(query: WebGLQuery | null): GLboolean;
+    beginQuery(target: GLenum, query: WebGLQuery): void;
+    endQuery(target: GLenum): void;
+    getQuery(_target: GLenum, _pname: GLenum): WebGLQuery | null;
+    getQueryParameter(query: WebGLQuery, pname: GLenum): any;
+    createSampler(): WebGLSampler | null;
+    deleteSampler(sampler: WebGLSampler | null): void;
+    isSampler(sampler: WebGLSampler | null): GLboolean;
+    bindSampler(unit: GLuint, sampler: WebGLSampler | null): void;
+    samplerParameteri(sampler: WebGLSampler, pname: GLenum, param: GLint): void;
+    samplerParameterf(sampler: WebGLSampler, pname: GLenum, param: GLfloat): void;
+    getSamplerParameter(sampler: WebGLSampler, pname: GLenum): any;
+    fenceSync(condition: GLenum, flags: GLbitfield): WebGLSync | null;
+    isSync(sync: WebGLSync | null): GLboolean;
+    deleteSync(sync: WebGLSync | null): void;
+    clientWaitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLuint64): GLenum;
+    waitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLint64): void;
+    getSyncParameter(sync: WebGLSync, pname: GLenum): any;
+    createTransformFeedback(): WebGLTransformFeedback | null;
+    deleteTransformFeedback(tf: WebGLTransformFeedback | null): void;
+    isTransformFeedback(tf: WebGLTransformFeedback | null): GLboolean;
+    bindTransformFeedback(target: GLenum, tf: WebGLTransformFeedback | null): void;
+    beginTransformFeedback(primitiveMode: GLenum): void;
+    endTransformFeedback(): void;
+    pauseTransformFeedback(): void;
+    resumeTransformFeedback(): void;
+    transformFeedbackVaryings(program: WebGLProgram, varyings: string[], bufferMode: GLenum): void;
+    getTransformFeedbackVarying(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
+    bindBufferBase(target: GLenum, index: GLuint, buffer: WebGLBuffer | null): void;
+    bindBufferRange(target: GLenum, index: GLuint, buffer: WebGLBuffer | null, offset: GLintptr, size: GLsizeiptr): void;
+    copyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr): void;
+    getBufferSubData(target: GLenum, srcByteOffset: GLintptr, dstBuffer: ArrayBufferView, dstOffset?: GLuint, length?: GLuint): void;
+    texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
+    texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
+    compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, _imageSize: GLsizei, data: ArrayBufferView): void;
+    compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, _imageSize: GLsizei, data: ArrayBufferView): void;
+    copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
+    texStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
+    texStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei): void;
+    framebufferTextureLayer(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, layer: GLint): void;
+    drawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei): void;
+    drawElementsInstanced(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei): void;
+    vertexAttribDivisor(index: GLuint, divisor: GLuint): void;
+    vertexAttribIPointer(index: GLuint, size: GLint, type: GLenum, stride: GLsizei, offset: GLintptr): void;
+    drawBuffers(buffers: GLenum[]): void;
+    drawRangeElements(mode: GLenum, start: GLuint, end: GLuint, count: GLsizei, type: GLenum, offset: GLintptr): void;
+    blitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum): void;
+    invalidateFramebuffer(target: GLenum, attachments: GLenum[]): void;
+    invalidateSubFramebuffer(target: GLenum, attachments: GLenum[], x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
+    readBuffer(src: GLenum): void;
+    renderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
+    uniform1ui(location: WebGLUniformLocation | null, v0: GLuint): void;
+    uniform2ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint): void;
+    uniform3ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint): void;
+    uniform4ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint): void;
+    uniform1uiv(location: WebGLUniformLocation | null, data: Uint32List, _srcOffset?: GLuint, _srcLength?: GLuint): void;
+    uniform2uiv(location: WebGLUniformLocation | null, data: Uint32List, _srcOffset?: GLuint, _srcLength?: GLuint): void;
+    uniform3uiv(location: WebGLUniformLocation | null, data: Uint32List, _srcOffset?: GLuint, _srcLength?: GLuint): void;
+    uniform4uiv(location: WebGLUniformLocation | null, data: Uint32List, _srcOffset?: GLuint, _srcLength?: GLuint): void;
+    uniformMatrix2x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, _srcOffset?: GLuint, _srcLength?: GLuint): void;
+    uniformMatrix3x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, _srcOffset?: GLuint, _srcLength?: GLuint): void;
+    uniformMatrix2x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, _srcOffset?: GLuint, _srcLength?: GLuint): void;
+    uniformMatrix4x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, _srcOffset?: GLuint, _srcLength?: GLuint): void;
+    uniformMatrix3x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, _srcOffset?: GLuint, _srcLength?: GLuint): void;
+    uniformMatrix4x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, _srcOffset?: GLuint, _srcLength?: GLuint): void;
+    /** WebGL1 getUniform falls to default:null for UNSIGNED_INT types. Handle them here. */
+    getUniform(program: WebGLProgram, location: WebGLUniformLocation): any;
+    getUniformBlockIndex(program: WebGLProgram, uniformBlockName: string): GLuint;
+    uniformBlockBinding(program: WebGLProgram, uniformBlockIndex: GLuint, uniformBlockBinding: GLuint): void;
+    getActiveUniformBlockName(program: WebGLProgram, uniformBlockIndex: GLuint): string | null;
+    getActiveUniformBlockParameter(program: WebGLProgram, uniformBlockIndex: GLuint, pname: GLenum): any;
+    getActiveUniforms(program: WebGLProgram, uniformIndices: GLuint[], pname: GLenum): any;
+    getFragDataLocation(program: WebGLProgram, name: string): GLint;
+    getIndexedParameter(target: GLenum, index: GLuint): any;
+    getInternalformatParameter(target: GLenum, internalformat: GLenum, pname: GLenum): any;
+    getParameter(pname: GLenum): any;
+    getStringi(name: GLenum, index: GLuint): string | null;
+}