@gjsify/webgl 0.0.4 → 0.1.0

package/src/ts/extensions/oes-vertex-array-object.ts.off

@@ -1,128 +0,0 @@
-import { Linkable } from '../linkable.js'
-import { gl } from '../native-gl.js'
-import { checkObject } from '../utils.js'
-import { WebGLVertexArrayObjectState } from '../webgl-vertex-attribute.js';
-
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
-
-export class WebGLVertexArrayObjectOES extends Linkable {
-  _ctx: GjsifyWebGLRenderingContext;
-  _ext: OESVertexArrayObject;
-  _vertexState?: WebGLVertexArrayObjectState;
-  constructor (_: number, ctx: GjsifyWebGLRenderingContext, ext: OESVertexArrayObject) {
-    super(_)
-    this._ctx = ctx
-    this._ext = ext
-    this._vertexState = new WebGLVertexArrayObjectState(ctx)
-  }
-
-  _performDelete () {
-    // Clean up the vertex state to release references to buffers.
-    this._vertexState?.cleanUp()
-
-    delete this._vertexState;
-    delete this._ext._vaos[this._]
-    gl.deleteVertexArrayOES.call(this._ctx, this._ | 0)
-  }
-}
-
-export class OESVertexArrayObject {
-  VERTEX_ARRAY_BINDING_OES = 0x85B5;
-  _ctx: GjsifyWebGLRenderingContext;
-  _vaos: Record<number, WebGLVertexArrayObjectOES> = {}
-  _activeVertexArrayObject: WebGLVertexArrayObjectOES | null = null
-
-  constructor (ctx: GjsifyWebGLRenderingContext) {
-    this.VERTEX_ARRAY_BINDING_OES = 0x85B5
-
-    this._ctx = ctx
-  }
-
-  createVertexArrayOES () {
-    const { _ctx: ctx } = this
-    const arrayId = gl.createVertexArrayOES.call(ctx)
-    if (arrayId <= 0) return null
-    const array = new WebGLVertexArrayObjectOES(arrayId, ctx, this)
-    this._vaos[arrayId] = array
-    return array
-  }
-
-  deleteVertexArrayOES (array: WebGLVertexArrayObjectOES | null) {
-    const { _ctx: ctx } = this
-    if (!checkObject(array)) {
-      throw new TypeError('deleteVertexArrayOES(WebGLVertexArrayObjectOES)')
-    }
-
-    if (!(array instanceof WebGLVertexArrayObjectOES &&
-      ctx._checkOwns(array))) {
-      ctx.setError(gl.INVALID_OPERATION)
-      return
-    }
-
-    if (array._pendingDelete) {
-      return
-    }
-
-    if (this._activeVertexArrayObject === array) {
-      this.bindVertexArrayOES(null)
-    }
-
-    array._pendingDelete = true
-    array._checkDelete()
-  }
-
-  bindVertexArrayOES (array: WebGLVertexArrayObjectOES | null) {
-    const { _ctx: ctx, _activeVertexArrayObject: activeVertexArrayObject } = this
-    if (!checkObject(array)) {
-      throw new TypeError('bindVertexArrayOES(WebGLVertexArrayObjectOES)')
-    }
-
-    if (!array) {
-      array = null
-      gl.bindVertexArrayOES.call(ctx, null)
-    } else if (array instanceof WebGLVertexArrayObjectOES &&
-      array._pendingDelete) {
-      ctx.setError(gl.INVALID_OPERATION)
-      return
-    } else if (ctx._checkWrapper(array, WebGLVertexArrayObjectOES)) {
-      gl.bindVertexArrayOES.call(ctx, array._)
-    } else {
-      return
-    }
-
-    if (activeVertexArrayObject !== array) {
-      if (activeVertexArrayObject) {
-        activeVertexArrayObject._refCount -= 1
-        activeVertexArrayObject._checkDelete()
-      }
-      if (array) {
-        array._refCount += 1
-      }
-    }
-
-    if (array === null) {
-      ctx._vertexObjectState = ctx._defaultVertexObjectState
-    } else if(array._vertexState) {
-      ctx._vertexObjectState = array._vertexState
-    }
-
-    // Update the active vertex array object.
-    this._activeVertexArrayObject = array
-  }
-
-  isVertexArrayOES (object: WebGLVertexArrayObjectOES) {
-    const { _ctx: ctx } = this
-    if (!ctx._isObject(object, 'isVertexArrayOES', WebGLVertexArrayObjectOES)) return false
-    return gl.isVertexArrayOES.call(ctx, object._ | 0)
-  }
-}
-
-export function getOESVertexArrayObject (ctx: GjsifyWebGLRenderingContext) {
-  const exts = ctx.getSupportedExtensions()
-
-  if (exts && exts.indexOf('OES_vertex_array_object') >= 0) {
-    return new OESVertexArrayObject(ctx)
-  } else {
-    return null
-  }
-}

package/src/ts/extensions/stackgl-destroy-context.ts

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

package/src/ts/extensions/stackgl-resize-drawing-buffer.ts

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

package/src/ts/extensions/webgl-draw-buffers.ts.off

@@ -1,107 +0,0 @@
-import { gl } from '../native-gl.js';
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
-
-export class WebGLDrawBuffers {
-  ctx: GjsifyWebGLRenderingContext;
-  _buffersState: number[] = [];
-  _maxDrawBuffers = 0;
-  _ALL_ATTACHMENTS: GLenum[] = []
-  _ALL_COLOR_ATTACHMENTS: GLenum[] = []
-
-  MAX_DRAW_BUFFERS_WEBGL = 0;
-  COLOR_ATTACHMENT0_WEBGL = 0;
-  COLOR_ATTACHMENT1_WEBGL = 0;
-  COLOR_ATTACHMENT2_WEBGL = 0;
-  COLOR_ATTACHMENT3_WEBGL = 0;
-  COLOR_ATTACHMENT4_WEBGL = 0;
-  COLOR_ATTACHMENT5_WEBGL = 0;
-  COLOR_ATTACHMENT6_WEBGL = 0;
-  COLOR_ATTACHMENT7_WEBGL = 0;
-  COLOR_ATTACHMENT8_WEBGL = 0;
-  COLOR_ATTACHMENT9_WEBGL = 0;
-  COLOR_ATTACHMENT10_WEBGL = 0;
-  COLOR_ATTACHMENT11_WEBGL = 0;
-  COLOR_ATTACHMENT12_WEBGL = 0;
-  COLOR_ATTACHMENT13_WEBGL = 0;
-  COLOR_ATTACHMENT14_WEBGL = 0;
-  COLOR_ATTACHMENT15_WEBGL = 0;
-
-  constructor (ctx: GjsifyWebGLRenderingContext) {
-    this.ctx = ctx
-    const exts = ctx.getSupportedExtensions()
-
-    if (exts && exts.indexOf('WEBGL_draw_buffers') >= 0) {
-      Object.assign(this, ctx.extWEBGL_draw_buffers())
-      this._buffersState = [ctx.BACK]
-      this._maxDrawBuffers = ctx._getParameterDirect(this.MAX_DRAW_BUFFERS_WEBGL) as number;
-      this._ALL_ATTACHMENTS = []
-      this._ALL_COLOR_ATTACHMENTS = []
-      const allColorAttachments = [
-        this.COLOR_ATTACHMENT0_WEBGL,
-        this.COLOR_ATTACHMENT1_WEBGL,
-        this.COLOR_ATTACHMENT2_WEBGL,
-        this.COLOR_ATTACHMENT3_WEBGL,
-        this.COLOR_ATTACHMENT4_WEBGL,
-        this.COLOR_ATTACHMENT5_WEBGL,
-        this.COLOR_ATTACHMENT6_WEBGL,
-        this.COLOR_ATTACHMENT7_WEBGL,
-        this.COLOR_ATTACHMENT8_WEBGL,
-        this.COLOR_ATTACHMENT9_WEBGL,
-        this.COLOR_ATTACHMENT10_WEBGL,
-        this.COLOR_ATTACHMENT11_WEBGL,
-        this.COLOR_ATTACHMENT12_WEBGL,
-        this.COLOR_ATTACHMENT13_WEBGL,
-        this.COLOR_ATTACHMENT14_WEBGL,
-        this.COLOR_ATTACHMENT15_WEBGL
-      ]
-      while (this._ALL_ATTACHMENTS.length < this._maxDrawBuffers) {
-        const colorAttachment = allColorAttachments.shift()
-        if(colorAttachment) {
-          this._ALL_ATTACHMENTS.push(colorAttachment)
-          this._ALL_COLOR_ATTACHMENTS.push(colorAttachment)
-        }
-      }
-      this._ALL_ATTACHMENTS.push(
-        gl.DEPTH_ATTACHMENT,
-        gl.STENCIL_ATTACHMENT,
-        gl.DEPTH_STENCIL_ATTACHMENT
-      )
-    }
-  }
-
-  drawBuffersWEBGL (buffers: GLenum[]) {
-    const { ctx } = this
-    if (buffers.length < 1) {
-      ctx.setError(gl.INVALID_OPERATION)
-      return
-    }
-    if (buffers.length === 1 && buffers[0] === gl.BACK) {
-      this._buffersState = buffers
-      ctx.drawBuffersWEBGL([this.COLOR_ATTACHMENT0_WEBGL])
-      return
-    } else if (!ctx._activeFramebuffer) {
-      if (buffers.length > 1) {
-        ctx.setError(gl.INVALID_OPERATION)
-        return
-      }
-      for (let i = 0; i < buffers.length; i++) {
-        if (buffers[i] > gl.NONE) {
-          ctx.setError(gl.INVALID_OPERATION)
-          return
-        }
-      }
-    }
-    this._buffersState = buffers
-    ctx.drawBuffersWEBGL(buffers)
-  }
-}
-
-export function getWebGLDrawBuffers (ctx: GjsifyWebGLRenderingContext) {
-  const exts = ctx.getSupportedExtensions()
-
-  if (exts && exts.indexOf('WEBGL_draw_buffers') >= 0) {
-    return new WebGLDrawBuffers(ctx)
-  } else {
-    return null
-  }
-}

package/src/ts/html-canvas-element.ts

@@ -1,98 +0,0 @@
-import { warnNotImplemented, notImplemented } from '@gjsify/utils'
-import Gtk from 'gi://Gtk?version=4.0';
-import { GjsifyWebGLRenderingContext } from './webgl-rendering-context.js';
-
-// TODO this fakes the implementation of HTMLCanvasElement, create a new package for a real implementation based on https://github.com/capricorn86/happy-dom/tree/master/packages/happy-dom/src/nodes/html-element
-export interface GjsifyHTMLCanvasElement extends HTMLCanvasElement {}
-
-export class GjsifyHTMLCanvasElement implements HTMLCanvasElement {
-
-    _webgl?: WebGLRenderingContext & GjsifyWebGLRenderingContext
-
-    _getGlArea() {
-        return this.gtkGlArea;
-    }
-
-    constructor(protected readonly gtkGlArea: Gtk.GLArea) {
-
-    }
-
-    /** Gets the height of a canvas element on a document. */
-    get height() {
-        return this.gtkGlArea.get_allocated_height()
-        // return this.gtkGlArea.get_height()
-    }
-
-    get clientHeight() {
-        return this.height;
-    }
-    
-    /** Sets the height of a canvas element on a document. */
-    set height(_height: number) {
-        warnNotImplemented('GjsifyHTMLCanvasElement.set_height');
-    }
-
-    /** Gets the width of a canvas element on a document. */
-    get width() {
-        return this.gtkGlArea.get_allocated_width()
-        // return this.gtkGlArea.get_width()
-    }
-
-    /** Sets the width of a canvas element on a document. */
-    set width(_width: number) {
-        warnNotImplemented('GjsifyHTMLCanvasElement.set_width');
-    }
-
-    get clientWidth() {
-        return this.width;
-    }
-
-    captureStream(_frameRequestRate?: number): MediaStream {
-        notImplemented('HTMLCanvasElement.captureStream');
-        return new 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;
-    getContext(contextId: string, options?: any): RenderingContext | null {
-        switch (contextId) {
-            case "webgl":
-                if(this._webgl) {
-                    return this._webgl;
-                }
-                this._webgl = new GjsifyWebGLRenderingContext(this, options) as WebGLRenderingContext & GjsifyWebGLRenderingContext;
-                return this._webgl;
-            default:
-                warnNotImplemented(`GjsifyHTMLCanvasElement.getContext("${contextId}")`);
-        }
-        return null;
-    }
-
-    toBlob(_callback: BlobCallback, _type?: string, _quality?: any): void {
-        notImplemented('HTMLCanvasElement.toBlob');
-    }
-    /**
-     * 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 {
-        notImplemented('HTMLCanvasElement.toDataURL');
-        return '';
-    }
-    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-    addEventListener(_type: string, _listener: EventListenerOrEventListenerObject, _options?: boolean | AddEventListenerOptions): void {
-        notImplemented('HTMLCanvasElement.addEventListener');
-    }
-    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-    removeEventListener(_type: string, _listener: EventListenerOrEventListenerObject, _options?: boolean | EventListenerOptions): void {
-        notImplemented('HTMLCanvasElement.removeEventListener');
-    }
-}
-
-export { GjsifyHTMLCanvasElement as HTMLCanvasElement }

package/src/ts/index.spec.ts

@@ -1,186 +0,0 @@
-import { describe, it, expect } from '@gjsify/unit';
-
-import { GjsifyWebGLRenderingContext, HTMLCanvasElement } from '@gjsify/webgl';
-import GLib from '@girs/glib-2.0';
-import Gtk from '@girs/gtk-4.0';
-import Gio from '@girs/gio-2.0';
-
-const GL_CONSTANT_NAMES = ['ACTIVE_ATTRIBUTES', 'ACTIVE_TEXTURE', 'ACTIVE_UNIFORMS', 'ALIASED_LINE_WIDTH_RANGE', 'ALIASED_POINT_SIZE_RANGE', 'ALPHA', 'ALPHA_BITS', 'ALWAYS', 'ARRAY_BUFFER', 'ARRAY_BUFFER_BINDING', 'ATTACHED_SHADERS', 'BACK', 'BLEND', 'BLEND_COLOR', 'BLEND_DST_ALPHA', 'BLEND_DST_RGB', 'BLEND_EQUATION', 'BLEND_EQUATION_ALPHA', 'BLEND_EQUATION_RGB', 'BLEND_SRC_ALPHA', 'BLEND_SRC_RGB', 'BLUE_BITS', 'BOOL', 'BOOL_VEC2', 'BOOL_VEC3', 'BOOL_VEC4', 'BROWSER_DEFAULT_WEBGL', 'BUFFER_SIZE', 'BUFFER_USAGE', 'BYTE', 'CCW', 'CLAMP_TO_EDGE', 'COLOR_ATTACHMENT0', 'COLOR_BUFFER_BIT', 'COLOR_CLEAR_VALUE', 'COLOR_WRITEMASK', 'COMPILE_STATUS', 'COMPRESSED_TEXTURE_FORMATS', 'CONSTANT_ALPHA', 'CONSTANT_COLOR', 'CONTEXT_LOST_WEBGL', 'CULL_FACE', 'CULL_FACE_MODE', 'CURRENT_PROGRAM', 'CURRENT_VERTEX_ATTRIB', 'CW', 'DECR', 'DECR_WRAP', 'DELETE_STATUS', 'DEPTH_ATTACHMENT', 'DEPTH_BITS', 'DEPTH_BUFFER_BIT', 'DEPTH_CLEAR_VALUE', 'DEPTH_COMPONENT', 'DEPTH_COMPONENT16', 'DEPTH_FUNC', 'DEPTH_RANGE', 'DEPTH_STENCIL', 'DEPTH_STENCIL_ATTACHMENT', 'DEPTH_TEST', 'DEPTH_WRITEMASK', 'DITHER', 'DONT_CARE', 'DST_ALPHA', 'DST_COLOR', 'DYNAMIC_DRAW', 'ELEMENT_ARRAY_BUFFER', 'ELEMENT_ARRAY_BUFFER_BINDING', 'EQUAL', 'FASTEST', 'FLOAT', 'FLOAT_MAT2', 'FLOAT_MAT3', 'FLOAT_MAT4', 'FLOAT_VEC2', 'FLOAT_VEC3', 'FLOAT_VEC4', 'FRAGMENT_SHADER', 'FRAMEBUFFER', 'FRAMEBUFFER_ATTACHMENT_OBJECT_NAME', 'FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE', 'FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE', 'FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL', 'FRAMEBUFFER_BINDING', 'FRAMEBUFFER_COMPLETE', 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT', 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS', 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT', 'FRAMEBUFFER_UNSUPPORTED', 'FRONT', 'FRONT_AND_BACK', 'FRONT_FACE', 'FUNC_ADD', 'FUNC_REVERSE_SUBTRACT', 'FUNC_SUBTRACT', 'GENERATE_MIPMAP_HINT', 'GEQUAL', 'GREATER', 'GREEN_BITS', 'HIGH_FLOAT', 'HIGH_INT', 'IMPLEMENTATION_COLOR_READ_FORMAT', 'IMPLEMENTATION_COLOR_READ_TYPE', 'INCR', 'INCR_WRAP', 'INT', 'INT_VEC2', 'INT_VEC3', 'INT_VEC4', 'INVALID_ENUM', 'INVALID_FRAMEBUFFER_OPERATION', 'INVALID_OPERATION', 'INVALID_VALUE', 'INVERT', 'KEEP', 'LEQUAL', 'LESS', 'LINEAR', 'LINEAR_MIPMAP_LINEAR', 'LINEAR_MIPMAP_NEAREST', 'LINES', 'LINE_LOOP', 'LINE_STRIP', 'LINE_WIDTH', 'LINK_STATUS', 'LOW_FLOAT', 'LOW_INT', 'LUMINANCE', 'LUMINANCE_ALPHA', 'MAX_COMBINED_TEXTURE_IMAGE_UNITS', 'MAX_CUBE_MAP_TEXTURE_SIZE', 'MAX_FRAGMENT_UNIFORM_VECTORS', 'MAX_RENDERBUFFER_SIZE', 'MAX_TEXTURE_IMAGE_UNITS', 'MAX_TEXTURE_SIZE', 'MAX_VARYING_VECTORS', 'MAX_VERTEX_ATTRIBS', 'MAX_VERTEX_TEXTURE_IMAGE_UNITS', 'MAX_VERTEX_UNIFORM_VECTORS', 'MAX_VIEWPORT_DIMS', 'MEDIUM_FLOAT', 'MEDIUM_INT', 'MIRRORED_REPEAT', 'NEAREST', 'NEAREST_MIPMAP_LINEAR', 'NEAREST_MIPMAP_NEAREST', 'NEVER', 'NICEST', 'NONE', 'NOTEQUAL', 'NO_ERROR', 'ONE', 'ONE_MINUS_CONSTANT_ALPHA', 'ONE_MINUS_CONSTANT_COLOR', 'ONE_MINUS_DST_ALPHA', 'ONE_MINUS_DST_COLOR', 'ONE_MINUS_SRC_ALPHA', 'ONE_MINUS_SRC_COLOR', 'OUT_OF_MEMORY', 'PACK_ALIGNMENT', 'POINTS', 'POLYGON_OFFSET_FACTOR', 'POLYGON_OFFSET_FILL', 'POLYGON_OFFSET_UNITS', 'RED_BITS', 'RENDERBUFFER', 'RENDERBUFFER_ALPHA_SIZE', 'RENDERBUFFER_BINDING', 'RENDERBUFFER_BLUE_SIZE', 'RENDERBUFFER_DEPTH_SIZE', 'RENDERBUFFER_GREEN_SIZE', 'RENDERBUFFER_HEIGHT', 'RENDERBUFFER_INTERNAL_FORMAT', 'RENDERBUFFER_RED_SIZE', 'RENDERBUFFER_STENCIL_SIZE', 'RENDERBUFFER_WIDTH', 'RENDERER', 'REPEAT', 'REPLACE', 'RGB', 'RGB565', 'RGB5_A1', 'RGBA', 'RGBA4', 'SAMPLER_2D', 'SAMPLER_CUBE', 'SAMPLES', 'SAMPLE_ALPHA_TO_COVERAGE', 'SAMPLE_BUFFERS', 'SAMPLE_COVERAGE', 'SAMPLE_COVERAGE_INVERT', 'SAMPLE_COVERAGE_VALUE', 'SCISSOR_BOX', 'SCISSOR_TEST', 'SHADER_TYPE', 'SHADING_LANGUAGE_VERSION', 'SHORT', 'SRC_ALPHA', 'SRC_ALPHA_SATURATE', 'SRC_COLOR', 'STATIC_DRAW', 'STENCIL_ATTACHMENT', 'STENCIL_BACK_FAIL', 'STENCIL_BACK_FUNC', 'STENCIL_BACK_PASS_DEPTH_FAIL', 'STENCIL_BACK_PASS_DEPTH_PASS', 'STENCIL_BACK_REF', 'STENCIL_BACK_VALUE_MASK', 'STENCIL_BACK_WRITEMASK', 'STENCIL_BITS', 'STENCIL_BUFFER_BIT', 'STENCIL_CLEAR_VALUE', 'STENCIL_FAIL', 'STENCIL_FUNC', 'STENCIL_INDEX8', 'STENCIL_PASS_DEPTH_FAIL', 'STENCIL_PASS_DEPTH_PASS', 'STENCIL_REF', 'STENCIL_TEST', 'STENCIL_VALUE_MASK', 'STENCIL_WRITEMASK', 'STREAM_DRAW', 'SUBPIXEL_BITS', 'TEXTURE', 'TEXTURE0', 'TEXTURE1', 'TEXTURE10', 'TEXTURE11', 'TEXTURE12', 'TEXTURE13', 'TEXTURE14', 'TEXTURE15', 'TEXTURE16', 'TEXTURE17', 'TEXTURE18', 'TEXTURE19', 'TEXTURE2', 'TEXTURE20', 'TEXTURE21', 'TEXTURE22', 'TEXTURE23', 'TEXTURE24', 'TEXTURE25', 'TEXTURE26', 'TEXTURE27', 'TEXTURE28', 'TEXTURE29', 'TEXTURE3', 'TEXTURE30', 'TEXTURE31', 'TEXTURE4', 'TEXTURE5', 'TEXTURE6', 'TEXTURE7', 'TEXTURE8', 'TEXTURE9', 'TEXTURE_2D', 'TEXTURE_BINDING_2D', 'TEXTURE_BINDING_CUBE_MAP', 'TEXTURE_CUBE_MAP', 'TEXTURE_CUBE_MAP_NEGATIVE_X', 'TEXTURE_CUBE_MAP_NEGATIVE_Y', 'TEXTURE_CUBE_MAP_NEGATIVE_Z', 'TEXTURE_CUBE_MAP_POSITIVE_X', 'TEXTURE_CUBE_MAP_POSITIVE_Y', 'TEXTURE_CUBE_MAP_POSITIVE_Z', 'TEXTURE_MAG_FILTER', 'TEXTURE_MIN_FILTER', 'TEXTURE_WRAP_S', 'TEXTURE_WRAP_T', 'TRIANGLES', 'TRIANGLE_FAN', 'TRIANGLE_STRIP', 'UNPACK_ALIGNMENT', 'UNPACK_COLORSPACE_CONVERSION_WEBGL', 'UNPACK_FLIP_Y_WEBGL', 'UNPACK_PREMULTIPLY_ALPHA_WEBGL', 'UNSIGNED_BYTE', 'UNSIGNED_INT', 'UNSIGNED_SHORT', 'UNSIGNED_SHORT_4_4_4_4', 'UNSIGNED_SHORT_5_5_5_1', 'UNSIGNED_SHORT_5_6_5', 'VALIDATE_STATUS', 'VENDOR', 'VERSION', 'VERTEX_ATTRIB_ARRAY_BUFFER_BINDING', 'VERTEX_ATTRIB_ARRAY_ENABLED', 'VERTEX_ATTRIB_ARRAY_NORMALIZED', 'VERTEX_ATTRIB_ARRAY_POINTER', 'VERTEX_ATTRIB_ARRAY_SIZE', 'VERTEX_ATTRIB_ARRAY_STRIDE', 'VERTEX_ATTRIB_ARRAY_TYPE', 'VERTEX_SHADER', 'VIEWPORT', 'ZERO'];
-
-export default async () => {
-
-	let app: Gtk.Application;
-	let win: Gtk.ApplicationWindow;
-	let glArea: Gtk.GLArea;
-	let canvas: HTMLCanvasElement;
-	let ctx: GjsifyWebGLRenderingContext | null;
-
-	// Skip tests on CI
-	if(GLib.getenv('CI') || GLib.getenv('GITHUB_ACTIONS') || GLib.getenv('TRAVIS') || GLib.getenv('CIRCLECI') || GLib.getenv('GITLAB_CI')) {
-		console.info('Skipping webgl tests on CI');
-		return;
-	}
-
-	const initApp = async () => {
-		Gtk.init();
-	
-		app = new Gtk.Application({
-			application_id: 'gjsify.webgl.index.spec.ts',
-			flags: Gio.ApplicationFlags.FLAGS_NONE,
-		});
-
-		const p = new Promise<Gtk.Application>((resolve) => {
-			app.connect('activate', () => {
-				resolve(app);
-			});
-		});
-	
-		win = new Gtk.ApplicationWindow(app);
-		win.set_default_size(800, 600);
-
-		app.run([]);
-
-		return p;
-	}
-
-	const initGLArea = async () => {
-		glArea = new Gtk.GLArea({});
-
-		const p = new Promise<Gtk.GLArea>((resolve, reject) => {
-			glArea.connect('realize', () => {
-				glArea.make_current();
-				const error = glArea.get_error();
-				if (error) {
-					reject(error);
-				}
-				resolve(glArea);
-			});
-		});
-
-		glArea.set_use_es(true);
-		glArea.set_has_depth_buffer(true);
-		glArea.set_has_stencil_buffer(true);
-		glArea.set_required_version(3, 2);
-		
-		win.set_child(glArea);
-		win.present();
-
-		return p;
-	}
-
-	await describe('Gtk.ApplicationWindow', async () => {
-		await it('should be able to create a new instance', async () => {
-			app = await initApp();
-			expect(app).toBeDefined();
-		});
-	})
-
-	await describe('Gtk.GLArea', async () => {
-		await it('should be able to create a new instance', async () => {
-			glArea = await initGLArea();
-			expect(glArea).toBeDefined();
-		});
-	})
-
-	await describe('HTMLCanvasElement', async () => {
-		await it('should be defined', async () => {
-			expect(HTMLCanvasElement).toBeDefined();
-		});
-
-		await it('should be able to create a new instance', async () => {
-			
-			expect(() => {
-				canvas = new HTMLCanvasElement(glArea);
-			}).not.toThrow();
-
-			expect(canvas).toBeDefined();
-		});
-
-		await it('should be able to get a webgl context', async () => {
-			expect(() => {
-				ctx = canvas.getContext("webgl");
-			}).not.toThrow();
-
-			expect(ctx).toBeDefined();
-		});
-	});
-
-	await describe('WebGLRenderingContext', async () => {
-		await it('should have defined WebGL constants', async () => {
-
-			for (const GL_CONSTANT_NAME of GL_CONSTANT_NAMES) {
-				const constant = ctx?.[GL_CONSTANT_NAME];
-				console.log(GL_CONSTANT_NAME, constant)
-				expect(typeof constant).toBe("number");
-				if(GL_CONSTANT_NAME === 'NONE' || GL_CONSTANT_NAME === 'ZERO' || GL_CONSTANT_NAME === 'NO_ERROR' || GL_CONSTANT_NAME === 'POINTS') {
-					expect(constant === 0).toBeTruthy();
-				} else {
-					expect(constant > 0).toBeTruthy();
-				}
-			}
-		});
-	});
-
-	await describe('Gwebgl.WebGLRenderingContext', async () => {
-		await it('getParameterb should return a boolean', async () => {
-			const res = ctx?._native.getParameterb(ctx?.BLEND)
-			console.log("res", res);
-			expect(typeof res).toBe("boolean");
-		});
-
-		await it('getParameterbv should return an array of boolean', async () => {
-			const results = ctx?._native.getParameterbv(ctx?.COLOR_WRITEMASK, 16)
-			console.log("results", results);
-
-			expect(Array.isArray(results)).toBeTruthy();
-
-			if(Array.isArray(results)) {
-				for (const res of results) {
-					expect(typeof res).toBe("boolean");
-				}
-			}
-		});
-
-		await it('getParameterf should return a float number', async () => {
-			const result = ctx?._native.getParameterf(ctx?.SAMPLE_COVERAGE_VALUE)
-			console.log("result", result);
-			
-			expect(typeof result).toBe("number");
-		});
-
-		await it('getParameterfv should return an array of float numbers', async () => {
-			const results = ctx?._native.getParameterfv(ctx?.DEPTH_RANGE, 8)
-			console.log("results", results);
-			
-			expect(Array.isArray(results)).toBeTruthy();
-
-			if(Array.isArray(results)) {
-				for (const res of results) {
-					expect(typeof res).toBe("number");
-				}
-			}
-		});
-
-		await it('getParameteri should return a integer number', async () => {
-			const result = ctx?._native.getParameteri(ctx?.ARRAY_BUFFER_BINDING)
-			console.log("result", result);
-			
-			expect(typeof result).toBe("number");
-		});
-
-		await it('getParameteriv should return an array of integer numbers', async () => {
-			const results = ctx?._native.getParameteriv(ctx?.MAX_VIEWPORT_DIMS, 8)
-			console.log("results", results, typeof (results));
-			
-			expect(Array.isArray(results)).toBeTruthy();
-
-			if(Array.isArray(results)) {
-				for (const res of results) {
-					expect(typeof res).toBe("number");
-				}
-			}
-		});
-	});
-
-
-}

package/src/ts/index.ts

@@ -1,21 +0,0 @@
-import '@girs/gjs';
-import '@girs/gio-2.0';
-import '@girs/gtk-4.0';
-
-export * from './html-canvas-element.js';
-// export * from './linkable.js';
-// export * from './utils.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/src/ts/linkable.ts

@@ -1,55 +0,0 @@
-export class Linkable {
-
-    _: number = 0;
-    _references: any[] = []
-    _refCount = 0
-    _pendingDelete = false
-    _binding = 0
-
-    constructor(_: number ) {
-        this._ = _
-        this._references = []
-        this._refCount = 0
-        this._pendingDelete = false
-        this._binding = 0
-    }
-
-    _link(b: any) {
-        this._references.push(b)
-        b._refCount += 1
-        return true
-    }
-
-    _unlink(b: any) {
-        let idx = this._references.indexOf(b)
-        if (idx < 0) {
-            return false
-        }
-        while (idx >= 0) {
-            this._references[idx] = this._references[this._references.length - 1]
-            this._references.pop()
-            b._refCount -= 1
-            b._checkDelete()
-            idx = this._references.indexOf(b)
-        }
-        return true
-    }
-
-    _linked(b: any) {
-        return this._references.indexOf(b) >= 0
-    }
-
-    _checkDelete() {
-        if (this._refCount <= 0 &&
-            this._pendingDelete &&
-            this._ !== 0) {
-            while (this._references.length > 0) {
-                this._unlink(this._references[0])
-            }
-            this._performDelete()
-            this._ = 0
-        }
-    }
-
-    _performDelete() { }
-}

package/src/ts/test.ts

@@ -1,6 +0,0 @@
-
-import { run } from '@gjsify/unit';
-
-import testSuite from './index.spec.js';
-
-run({testSuite});

package/src/ts/types/constructor.ts

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

package/src/ts/types/extension.ts

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

package/src/ts/types/index.ts

@@ -1,26 +0,0 @@
-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';
-
-// type GjsifyWebGLProgram = Gwebgl.WebGLProgram & WebGLProgram & number;
-// type GjsifyWebGLShader = Gwebgl.WebGLShader & WebGLShader & number;
-// type GjsifyWebGLBuffer = Gwebgl.WebGLBuffer & WebGLBuffer & number;
-// type GjsifyWebGLRenderbuffer = Gwebgl.WebGLRenderbuffer & WebGLRenderbuffer & number;
-// type GjsifyWebGLTexture = Gwebgl.WebGLTexture & WebGLTexture & number;
-// type GjsifyWebGLUniformLocation = Gwebgl.WebGLUniformLocation & WebGLUniformLocation & number;
-
-// type GjsifyWebGLActiveInfo = Gwebgl.WebGLActiveInfo & WebGLActiveInfo;
-// type GjsifyWebGLShaderPrecisionFormat = Gwebgl.WebGLShaderPrecisionFormat & WebGLShaderPrecisionFormat;
-
-// export {
-//     GjsifyWebGLProgram as WebGLProgram,
-//     GjsifyWebGLShader as WebGLShader,
-//     GjsifyWebGLBuffer as WebGLBuffer,
-//     GjsifyWebGLRenderbuffer as WebGLRenderbuffer,
-//     GjsifyWebGLTexture as WebGLTexture,
-//     GjsifyWebGLUniformLocation as WebGLUniformLocation,
-//     GjsifyWebGLActiveInfo as WebGLActiveInfo,
-//     GjsifyWebGLShaderPrecisionFormat as WebGLShaderPrecisionFormat
-// }