@gjsify/webgl 0.0.2

package/lib/esm/webgl-shader-precision-format.js

@@ -0,0 +1,11 @@
+class GjsifyWebGLShaderPrecisionFormat {
+  constructor(_) {
+    this.rangeMin = _.rangeMin;
+    this.rangeMax = _.rangeMax;
+    this.precision = _.precision;
+  }
+}
+export {
+  GjsifyWebGLShaderPrecisionFormat,
+  GjsifyWebGLShaderPrecisionFormat as WebGLShaderPrecisionFormat
+};

package/lib/esm/webgl-shader.js

@@ -0,0 +1,23 @@
+import { Linkable } from "./linkable.js";
+class GjsifyWebGLShader extends Linkable {
+  constructor(_, ctx, type) {
+    super(_);
+    this._source = "";
+    this._compileStatus = false;
+    this._compileInfo = "";
+    this._type = type;
+    this._ctx = ctx;
+    this._source = "";
+    this._compileStatus = false;
+    this._compileInfo = "";
+  }
+  _performDelete() {
+    const ctx = this._ctx;
+    delete ctx._shaders[this._ | 0];
+    ctx._native.deleteShader(this._ | 0);
+  }
+}
+export {
+  GjsifyWebGLShader,
+  GjsifyWebGLShader as WebGLShader
+};

package/lib/esm/webgl-texture-unit.js

@@ -0,0 +1,12 @@
+class WebGLTextureUnit {
+  constructor(ctx, idx) {
+    this._mode = 0;
+    this._bind2D = null;
+    this._bindCube = null;
+    this._ctx = ctx;
+    this._idx = idx;
+  }
+}
+export {
+  WebGLTextureUnit
+};

package/lib/esm/webgl-texture.js

@@ -0,0 +1,22 @@
+import { Linkable } from "./linkable.js";
+class GjsifyWebGLTexture extends Linkable {
+  constructor(_, ctx) {
+    super(_);
+    this._binding = 0;
+    this._levelWidth = new Int32Array(32);
+    this._levelHeight = new Int32Array(32);
+    this._format = 0;
+    this._type = 0;
+    this._complete = true;
+    this._ctx = ctx;
+  }
+  _performDelete() {
+    const ctx = this._ctx;
+    delete ctx._textures[this._ | 0];
+    ctx._native.deleteTexture(this._ | 0);
+  }
+}
+export {
+  GjsifyWebGLTexture,
+  GjsifyWebGLTexture as WebGLTexture
+};

package/lib/esm/webgl-uniform-location.js

@@ -0,0 +1,15 @@
+class GjsifyWebGLUniformLocation {
+  constructor(_, program, info) {
+    this._linkCount = 0;
+    this._array = null;
+    this._ = _;
+    this._program = program;
+    this._linkCount = program._linkCount;
+    this._activeInfo = info;
+    this._array = null;
+  }
+}
+export {
+  GjsifyWebGLUniformLocation,
+  GjsifyWebGLUniformLocation as WebGLUniformLocation
+};

package/lib/esm/webgl-vertex-attribute.js

@@ -0,0 +1,147 @@
+import { WebGLBuffer } from "./webgl-buffer.js";
+class WebGLVertexArrayObjectAttribute {
+  constructor(ctx, idx) {
+    this._isPointer = false;
+    this._pointerBuffer = null;
+    this._pointerOffset = 0;
+    this._pointerSize = 0;
+    this._pointerStride = 0;
+    this._pointerType = 0;
+    this._pointerNormal = false;
+    this._divisor = 0;
+    this._inputSize = 4;
+    this._inputStride = 0;
+    this._ctx = ctx;
+    this._idx = idx;
+    this._pointerType = ctx.FLOAT;
+    this._clear();
+  }
+  _clear() {
+    this._isPointer = false;
+    this._pointerBuffer = null;
+    this._pointerOffset = 0;
+    this._pointerSize = 0;
+    this._pointerStride = 0;
+    this._pointerType = this._ctx.FLOAT;
+    this._pointerNormal = false;
+    this._divisor = 0;
+    this._inputSize = 4;
+    this._inputStride = 0;
+  }
+}
+class WebGLVertexArrayGlobalAttribute {
+  constructor(idx) {
+    this._idx = 0;
+    this._idx = idx;
+    this._data = new Float32Array([0, 0, 0, 1]);
+  }
+}
+class WebGLVertexArrayObjectState {
+  constructor(ctx) {
+    this._elementArrayBufferBinding = null;
+    const numAttribs = ctx.getParameter(ctx.MAX_VERTEX_ATTRIBS);
+    this._attribs = new Array(numAttribs);
+    for (let i = 0; i < numAttribs; ++i) {
+      this._attribs[i] = new WebGLVertexArrayObjectAttribute(ctx, i);
+    }
+    this._elementArrayBufferBinding = null;
+  }
+  setElementArrayBuffer(buffer) {
+    if (buffer !== null && !(buffer instanceof WebGLBuffer)) {
+      throw new TypeError("setElementArrayBuffer(WebGLBuffer?)");
+    }
+    const current = this._elementArrayBufferBinding;
+    if (current !== buffer) {
+      if (current) {
+        current._refCount -= 1;
+        current._checkDelete();
+      }
+      if (buffer) {
+        buffer._refCount += 1;
+      }
+      this._elementArrayBufferBinding = buffer;
+    }
+  }
+  cleanUp() {
+    const elementArrayBuffer = this._elementArrayBufferBinding;
+    if (elementArrayBuffer) {
+      elementArrayBuffer._refCount -= 1;
+      elementArrayBuffer._checkDelete();
+      this._elementArrayBufferBinding = null;
+    }
+    for (let i = 0; i < this._attribs.length; ++i) {
+      const attrib = this._attribs[i];
+      if (attrib._pointerBuffer) {
+        attrib._pointerBuffer._refCount -= 1;
+        attrib._pointerBuffer._checkDelete();
+      }
+      attrib._clear();
+    }
+  }
+  releaseArrayBuffer(buffer) {
+    if (!buffer) {
+      return;
+    }
+    for (let i = 0; i < this._attribs.length; ++i) {
+      const attrib = this._attribs[i];
+      if (attrib._pointerBuffer === buffer) {
+        attrib._pointerBuffer._refCount -= 1;
+        attrib._pointerBuffer._checkDelete();
+        attrib._clear();
+      }
+    }
+  }
+  setVertexAttribPointer(buffer, index, pointerSize, pointerOffset, pointerStride, pointerType, pointerNormal, inputStride, inputSize) {
+    const attrib = this._attribs[index];
+    if (buffer !== attrib._pointerBuffer) {
+      if (attrib._pointerBuffer) {
+        attrib._pointerBuffer._refCount -= 1;
+        attrib._pointerBuffer._checkDelete();
+      }
+      if (buffer) {
+        buffer._refCount += 1;
+      }
+      attrib._pointerBuffer = buffer;
+    }
+    attrib._pointerSize = pointerSize;
+    attrib._pointerOffset = pointerOffset;
+    attrib._pointerStride = pointerStride;
+    attrib._pointerType = pointerType;
+    attrib._pointerNormal = pointerNormal;
+    attrib._inputStride = inputStride;
+    attrib._inputSize = inputSize;
+  }
+}
+class WebGLVertexArrayGlobalState {
+  constructor(ctx) {
+    this._arrayBufferBinding = null;
+    const numAttribs = ctx.getParameter(ctx.MAX_VERTEX_ATTRIBS);
+    this._attribs = new Array(numAttribs);
+    for (let i = 0; i < numAttribs; ++i) {
+      this._attribs[i] = new WebGLVertexArrayGlobalAttribute(i);
+    }
+    this._arrayBufferBinding = null;
+  }
+  setArrayBuffer(buffer) {
+    if (buffer !== null && !(buffer instanceof WebGLBuffer)) {
+      throw new TypeError("setArrayBuffer(WebGLBuffer?)");
+    }
+    const current = this._arrayBufferBinding;
+    if (current !== buffer) {
+      if (current) {
+        current._refCount -= 1;
+        current._checkDelete();
+      }
+      if (buffer) {
+        buffer._refCount += 1;
+      }
+      this._arrayBufferBinding = buffer;
+    }
+  }
+}
+export {
+  WebGLVertexArrayGlobalAttribute,
+  WebGLVertexArrayGlobalState,
+  WebGLVertexArrayObjectAttribute,
+  WebGLVertexArrayObjectState
+};

package/lib/types/extensions/ext-blend-minmax.d.ts

@@ -0,0 +1,7 @@
+import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+export declare class EXTBlendMinMax {
+    MIN_EXT: number;
+    MAX_EXT: number;
+    constructor();
+}
+export declare function getEXTBlendMinMax(context: GjsifyWebGLRenderingContext): any;

package/lib/types/extensions/ext-texture-filter-anisotropic.d.ts

@@ -0,0 +1,7 @@
+import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+export declare class EXTTextureFilterAnisotropic {
+    TEXTURE_MAX_ANISOTROPY_EXT: number;
+    MAX_TEXTURE_MAX_ANISOTROPY_EXT: number;
+    constructor();
+}
+export declare function getEXTTextureFilterAnisotropic(context: GjsifyWebGLRenderingContext): any;

package/lib/types/extensions/oes-element-index-unit.d.ts

@@ -0,0 +1,4 @@
+import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+export declare class OESElementIndexUint {
+}
+export declare function getOESElementIndexUint(context: GjsifyWebGLRenderingContext): any;

package/lib/types/extensions/oes-standard-derivatives.d.ts

@@ -0,0 +1,6 @@
+import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+export declare class OESStandardDerivatives {
+    FRAGMENT_SHADER_DERIVATIVE_HINT_OES: number;
+    constructor();
+}
+export declare function getOESStandardDerivatives(context: GjsifyWebGLRenderingContext): any;

package/lib/types/extensions/oes-texture-float-linear.d.ts

@@ -0,0 +1,4 @@
+import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+export declare class OESTextureFloatLinear {
+}
+export declare function getOESTextureFloatLinear(context: GjsifyWebGLRenderingContext): any;

package/lib/types/extensions/oes-texture-float.d.ts

@@ -0,0 +1,4 @@
+import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
+export declare class OESTextureFloat {
+}
+export declare function getOESTextureFloat(context: GjsifyWebGLRenderingContext): any;

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

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

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

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

package/lib/types/html-canvas-element.d.ts

@@ -0,0 +1,38 @@
+import Gtk from 'gi://Gtk?version=4.0';
+import { GjsifyWebGLRenderingContext } from './webgl-rendering-context.js';
+export interface GjsifyHTMLCanvasElement extends HTMLCanvasElement {
+}
+export declare class GjsifyHTMLCanvasElement implements HTMLCanvasElement {
+    protected readonly gtkGlArea: Gtk.GLArea;
+    _webgl?: WebGLRenderingContext & GjsifyWebGLRenderingContext;
+    _getGlArea(): Gtk.GLArea;
+    constructor(gtkGlArea: Gtk.GLArea);
+    /** Gets the height of a canvas element on a document. */
+    get height(): number;
+    get clientHeight(): number;
+    /** Sets the height of a canvas element on a document. */
+    set height(_height: number);
+    /** Gets the width of a canvas element on a document. */
+    get width(): number;
+    /** Sets the width of a canvas element on a document. */
+    set width(_width: number);
+    get clientWidth(): number;
+    captureStream(_frameRequestRate?: number): MediaStream;
+    /**
+     * Returns an object that provides methods and properties for drawing and manipulating images and graphics on a canvas element in a document. A context object includes information about colors, line widths, fonts, and other graphic parameters that can be drawn on a canvas.
+     * @param contextId The identifier (ID) of the type of canvas to create. Internet Explorer 9 and Internet Explorer 10 support only a 2-D context using canvas.getContext("2d"); IE11 Preview also supports 3-D or WebGL context using canvas.getContext("experimental-webgl");
+     */
+    getContext(contextId: "2d", options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
+    getContext(contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
+    getContext(contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext & GjsifyWebGLRenderingContext | null;
+    getContext(contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
+    toBlob(_callback: BlobCallback, _type?: string, _quality?: any): void;
+    /**
+     * Returns the content of the current canvas as an image that you can use as a source for another canvas or an HTML element.
+     * @param _type The standard MIME type for the image format to return. If you do not specify this parameter, the default value is a PNG format image.
+     */
+    toDataURL(_type?: string, _quality?: any): string;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+}
+export { GjsifyHTMLCanvasElement as HTMLCanvasElement };

package/lib/types/index.d.ts

@@ -0,0 +1,18 @@
+import '@girs/gjs';
+import '@girs/gio-2.0';
+import '@girs/gtk-4.0';
+export * from './html-canvas-element.js';
+export * from './webgl-active-info.js';
+export * from './webgl-buffer.js';
+export * from './webgl-context-attributes.js';
+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-rendering-context.js';
+export * from './webgl-shader-precision-format.js';
+export * from './webgl-shader.js';
+export * from './webgl-texture-unit.js';
+export * from './webgl-texture.js';
+export * from './webgl-uniform-location.js';
+export * from './webgl-vertex-attribute.js';

package/lib/types/linkable.d.ts

@@ -0,0 +1,13 @@
+export declare class Linkable {
+    _: number;
+    _references: any[];
+    _refCount: number;
+    _pendingDelete: boolean;
+    _binding: number;
+    constructor(_: number);
+    _link(b: any): boolean;
+    _unlink(b: any): boolean;
+    _linked(b: any): boolean;
+    _checkDelete(): void;
+    _performDelete(): void;
+}

package/lib/types/types/constructor.d.ts

@@ -0,0 +1,3 @@
+export interface Constructor<T> {
+    new (): T;
+}

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

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

package/lib/types/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constructor.js';
+export * from './extension.js';
+export * from './typed-array.js';
+export * from './webgl-constants.js';
+export * from './webgl-context-attribute-options.js';

package/lib/types/types/typed-array.d.ts

@@ -0,0 +1 @@
+export type TypedArray = ArrayBufferView | Uint8Array | Uint8ClampedArray | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array;