@gjsify/webgl 0.0.2

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

@@ -0,0 +1,260 @@
+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 { 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 GjsifyWebGLRenderingContext extends WebGLConstants {
+}
+export declare class GjsifyWebGLRenderingContext implements WebGLRenderingContext {
+    canvas: GjsifyHTMLCanvasElement & HTMLCanvasElement;
+    /** TODO implement this: https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawingBufferColorSpace */
+    drawingBufferColorSpace: PredefinedColorSpace;
+    get drawingBufferHeight(): number;
+    get drawingBufferWidth(): number;
+    DEFAULT_ATTACHMENTS: number[];
+    DEFAULT_COLOR_ATTACHMENTS: number[];
+    /** context counter */
+    _: number;
+    _native: Gwebgl.WebGLRenderingContext;
+    _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;
+    _attrib0Buffer: WebGLBuffer | null;
+    _textureUnits: WebGLTextureUnit[];
+    _drawingBuffer: WebGLDrawingBufferWrapper | null;
+    constructor(canvas: GjsifyHTMLCanvasElement | HTMLCanvasElement | null, options?: Gwebgl.WebGLRenderingContext.ConstructorProperties);
+    _initGLConstants(): void;
+    _getGlslVersion(es: boolean): "100" | "120";
+    _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): 36053 | 36054 | 36055 | 36057 | 36061;
+    _isConstantBlendFunc(factor: GLenum): boolean;
+    _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): boolean;
+    _validBlendMode(mode: GLenum): boolean;
+    _validCubeTarget(target: GLenum): boolean;
+    _validFramebufferAttachment(attachment: GLenum): boolean;
+    _validGLSLIdentifier(str: string): boolean;
+    _validTextureTarget(target: GLenum): boolean;
+    _verifyTextureCompleteness(target: GLenum, pname: GLenum, param: GLenum): void;
+    _wrapShader(_type: GLenum, source: string): string;
+    _beginAttrib0Hack(): void;
+    _endAttrib0Hack(): void;
+    _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: TypedArray | 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;
+}
+export { GjsifyWebGLRenderingContext as WebGLRenderingContext };

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+import { WebGLBuffer } from './webgl-buffer.js';
+import type { GjsifyWebGLRenderingContext } from './webgl-rendering-context.js';
+export declare class WebGLVertexArrayObjectAttribute {
+    _ctx: GjsifyWebGLRenderingContext;
+    _idx: number;
+    _isPointer: boolean;
+    _pointerBuffer: WebGLBuffer | null;
+    _pointerOffset: number;
+    _pointerSize: number;
+    _pointerStride: number;
+    _pointerType: number;
+    _pointerNormal: boolean;
+    _divisor: number;
+    _inputSize: number;
+    _inputStride: number;
+    constructor(ctx: GjsifyWebGLRenderingContext, idx: number);
+    _clear(): void;
+}
+export declare class WebGLVertexArrayGlobalAttribute {
+    _idx: number;
+    _data: Float32Array;
+    constructor(idx: number);
+}
+export declare class WebGLVertexArrayObjectState {
+    _attribs: WebGLVertexArrayObjectAttribute[];
+    _elementArrayBufferBinding: WebGLBuffer | null;
+    constructor(ctx: GjsifyWebGLRenderingContext);
+    setElementArrayBuffer(buffer: WebGLBuffer | null): void;
+    cleanUp(): void;
+    releaseArrayBuffer(buffer: WebGLBuffer): void;
+    setVertexAttribPointer(buffer: WebGLBuffer, index: number, pointerSize: number, pointerOffset: number, pointerStride: number, pointerType: number, pointerNormal: boolean, inputStride: number, inputSize: number): void;
+}
+export declare class WebGLVertexArrayGlobalState {
+    _arrayBufferBinding: WebGLBuffer | null;
+    _attribs: WebGLVertexArrayGlobalAttribute[];
+    constructor(ctx: GjsifyWebGLRenderingContext);
+    setArrayBuffer(buffer: WebGLBuffer | null): void;
+}

package/meson.build

@@ -0,0 +1,39 @@
+project('Gwebgl', ['c', 'vala'], version: '0.1')
+
+root_dir = meson.current_source_dir()
+
+vapi_dir = root_dir / 'src/vapi'
+
+add_project_arguments(
+    [
+        '--vapidir', vapi_dir,
+    ],
+    language: 'vala'
+)
+
+dependencies = [ dependency('glib-2.0'), dependency('gobject-2.0'), dependency('gdk-pixbuf-2.0'), dependency('gtk4'), dependency('epoxy')]
+
+sources = files('src/vala/handle-types.vala', 'src/vala/webgl-rendering-context-base.vala', 'src/vala/webgl-rendering-context.vala')
+
+libGwebgl = library('gwebgl', sources,
+    dependencies: dependencies,
+    vala_gir:  meson.project_name() + '-0.1.gir',
+    install: true,
+    install_dir: [true, true, true, true]
+)
+
+g_ir_compiler = find_program('g-ir-compiler')
+
+
+# TODO not working if gwebgl-0.1.gir not exists
+custom_target(meson.project_name() + '-0.1.typelib', command: [g_ir_compiler, '--shared-library', 'libgwebgl.so', '--output', '@OUTPUT@', meson.current_build_dir() / meson.project_name() + '-0.1.gir'],
+              #input: meson.current_build_dir() / meson.project_name() + '-0.1.gir',
+              output: meson.project_name() +'-0.1.typelib',
+              depends: libGwebgl,
+              install: true,
+              install_dir: get_option('libdir') / 'girepository-1.0')
+
+
+# Test app
+test_sources = files('src/vala/handle-types.vala', 'src/vala/webgl-rendering-context-base.vala', 'src/vala/webgl-rendering-context.vala', 'src/test/app.vala')
+executable('gwebgl_vala_app', test_sources, dependencies: dependencies)

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@gjsify/webgl",
+  "version": "0.0.2",
+  "description": "WebGL module for Gjs",
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/esm/index.js"
+      },
+      "require": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/cjs/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tmp build test.gjs.js tsconfig.tsbuildinfo",
+    "print:name": "echo '@gjsify/webgl'",
+    "init:meson": "meson setup build .",
+    "init:meson:wipe": "yarn init:meson --wipe",
+    "build": "yarn print:name && yarn build:meson && yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/ts/**/*.{ts,js}'",
+    "build:meson": "yarn init:meson && meson compile -C build",
+    "build:types": "tsc --project tsconfig.types.json || exit 0",
+    "build:test": "gjsify build src/ts/test.ts --app gjs --outfile test.gjs.js",
+    "test": "yarn print:name && yarn build:gjsify && yarn build:test && yarn test:gjs",
+    "test:gjs": "LD_LIBRARY_PATH=build GI_TYPELIB_PATH=build gjs -m test.gjs.js"
+  },
+  "keywords": [
+    "gjs",
+    "WebGL"
+  ],
+  "devDependencies": {
+    "@gjsify/cli": "^0.0.2",
+    "@gjsify/unit": "^0.0.2",
+    "@types/node": "^20.3.1",
+    "typescript": "^5.1.3"
+  },
+  "dependencies": {
+    "@girs/gio-2.0": "2.76.1-3.1.0",
+    "@girs/gjs": "^3.1.0",
+    "@girs/gtk-4.0": "4.10.4-3.1.0",
+    "@girs/gwebgl-0.1": "^0.1.0-3.1.0",
+    "@gjsify/html-image-element": "^0.0.2",
+    "@gjsify/utils": "^0.0.2",
+    "@types/bit-twiddle": "^1.0.1",
+    "bit-twiddle": "^1.0.2",
+    "glsl-tokenizer": "^2.1.5"
+  }
+}

package/src/test/app.vala

@@ -0,0 +1,60 @@
+using Gtk;
+using Gwebgl;
+
+int main (string[] argv) {
+    WebGLRenderingContext? gl = null;
+    // Create a new application
+    var app = new Gtk.Application ("gjsify.web.webgl.valaapp", GLib.ApplicationFlags.FLAGS_NONE);
+    app.activate.connect (() => {
+        var win = new Gtk.ApplicationWindow (app);
+        win.set_default_size(800, 600);
+        var glarea = new Gtk.GLArea ();
+        glarea.set_use_es(true);
+        glarea.set_required_version(3, 2);
+
+        glarea.realize.connect((widget) => {
+            print("\nrealize");
+            glarea.make_current ();
+
+            var error = glarea.get_error ();
+            if(error != null) {
+                printerr (error.message);
+                return;
+            }
+        });
+
+        glarea.render.connect((context) => {
+            print("\nrender");
+
+            var error = glarea.get_error ();
+            if(error != null) {
+                printerr (error.message);
+                return false;
+            }
+
+            if(gl == null) {
+                int width = glarea.get_width ();
+                int height = glarea.get_height ();
+                gl = new Gwebgl.WebGLRenderingContext (width, height, true, true, false, false, true, false, false, false);
+            }
+            // Set clear color to black, fully opaque
+            gl.clearColor((float) 1.0, (float) 0.0, (float) 0.0, (float) 1.0);
+
+            // GL.glClearColor((GL.GLfloat) 0.0, (GL.GLfloat) 0.0, (GL.GLfloat) 0.0, (GL.GLfloat) 1.0);
+
+            // Clear the color buffer with specified clear color
+            var COLOR_BUFFER_BIT = gl.get_webgl_constants().get ("COLOR_BUFFER_BIT");
+            gl.clear(COLOR_BUFFER_BIT);
+            // GL.glClear(GL.GL_COLOR_BUFFER_BIT);
+            print("GL.GL_COLOR_BUFFER_BIT %i", GL.GL_COLOR_BUFFER_BIT);
+            print("COLOR_BUFFER_BIT %i", COLOR_BUFFER_BIT);
+            return true;
+        });
+
+        win.set_child (glarea);
+        win.present ();
+    });
+
+    app.run (argv);
+    return 0;
+}

package/src/ts/@types/glsl-tokenizer/index.d.ts

@@ -0,0 +1,18 @@
+declare module 'glsl-tokenizer/string' {
+
+    export interface Options {
+        version: '100' | '300 es';
+    }
+
+    export type TokenType = 'block-comment' | 'line-comment' | 'preprocessor' | 'operator' | 'float' | 'ident' | 'builtin' | 'eof' | 'integer' | 'whitespace' | 'keyword';
+
+    export interface Token {
+        type: TokenType;
+        data: string;
+        position: number;
+        line: number;
+        column: number;
+    }
+
+    export default function tokenString(src: string, opt?: Options): Token[];
+}