@gjsify/webgl 0.0.4 → 0.1.0

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

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

package/lib/cjs/webgl-shader.js

@@ -1,23 +0,0 @@
-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/cjs/webgl-texture-unit.js

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

package/lib/cjs/webgl-texture.js

@@ -1,22 +0,0 @@
-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/cjs/webgl-uniform-location.js

@@ -1,15 +0,0 @@
-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/cjs/webgl-vertex-attribute.js

@@ -1,147 +0,0 @@
-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/meson.build

@@ -1,39 +0,0 @@
-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/src/test/app.vala

@@ -1,60 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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[];
-}

package/src/ts/extensions/angle-instanced-arrays.ts.off

@@ -1,232 +0,0 @@
-import { gl } from '../native-gl';
-import { vertexCount } from '../utils';
-
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
-
-export class ANGLEInstancedArrays {
-
-  VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE = 0x88fe
-  ctx: GjsifyWebGLRenderingContext;
-
-  _drawArraysInstanced = gl._drawArraysInstanced.bind(ctx)
-  _drawElementsInstanced = gl._drawElementsInstanced.bind(ctx)
-  _vertexAttribDivisor = gl._vertexAttribDivisor.bind(ctx)
-
-  constructor (ctx: GjsifyWebGLRenderingContext) {
-    this.VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE = 0x88fe
-    this.ctx = ctx
-
-    this._drawArraysInstanced = gl._drawArraysInstanced.bind(ctx)
-    this._drawElementsInstanced = gl._drawElementsInstanced.bind(ctx)
-    this._vertexAttribDivisor = gl._vertexAttribDivisor.bind(ctx)
-  }
-
-  drawArraysInstancedANGLE (mode: GLenum, first: GLint, count: GLuint, primCount: GLuint) {
-    const { ctx } = this
-    mode |= 0
-    first |= 0
-    count |= 0
-    primCount |= 0
-    if (first < 0 || count < 0 || primCount < 0) {
-      ctx.setError(gl.INVALID_VALUE)
-      return
-    }
-    if (!ctx._checkStencilState()) {
-      return
-    }
-    const reducedCount = vertexCount(mode, count)
-    if (reducedCount < 0) {
-      ctx.setError(gl.INVALID_ENUM)
-      return
-    }
-    if (!ctx._framebufferOk()) {
-      return
-    }
-    if (count === 0 || primCount === 0) {
-      return
-    }
-    let maxIndex = first
-    if (count > 0) {
-      maxIndex = (count + first - 1) >>> 0
-    }
-    if (this.checkInstancedVertexAttribState(maxIndex, primCount)) {
-      return this._drawArraysInstanced(mode, first, reducedCount, primCount)
-    }
-  }
-
-  drawElementsInstancedANGLE (mode: GLenum, count: GLint, type: GLenum, ioffset: GLint, primCount: GLuint) {
-    const { ctx } = this
-    mode |= 0
-    count |= 0
-    type |= 0
-    ioffset |= 0
-    primCount |= 0
-
-    if (count < 0 || ioffset < 0 || primCount < 0) {
-      ctx.setError(gl.INVALID_VALUE)
-      return
-    }
-
-    if (!ctx._checkStencilState()) {
-      return
-    }
-
-    const elementBuffer = ctx._vertexObjectState._elementArrayBufferBinding
-    if (!elementBuffer) {
-      ctx.setError(gl.INVALID_OPERATION)
-      return
-    }
-
-    // Unpack element data
-    let elementData = null
-    let offset = ioffset
-    if (type === gl.UNSIGNED_SHORT) {
-      if (offset % 2) {
-        ctx.setError(gl.INVALID_OPERATION)
-        return
-      }
-      offset >>= 1
-      elementData = new Uint16Array(elementBuffer._elements.buffer)
-    } else if (ctx._extensions.oes_element_index_uint && type === gl.UNSIGNED_INT) {
-      if (offset % 4) {
-        ctx.setError(gl.INVALID_OPERATION)
-        return
-      }
-      offset >>= 2
-      elementData = new Uint32Array(elementBuffer._elements.buffer)
-    } else if (type === gl.UNSIGNED_BYTE) {
-      elementData = elementBuffer._elements
-    } else {
-      ctx.setError(gl.INVALID_ENUM)
-      return
-    }
-
-    let reducedCount = count
-    switch (mode) {
-      case gl.TRIANGLES:
-        if (count % 3) {
-          reducedCount -= (count % 3)
-        }
-        break
-      case gl.LINES:
-        if (count % 2) {
-          reducedCount -= (count % 2)
-        }
-        break
-      case gl.POINTS:
-        break
-      case gl.LINE_LOOP:
-      case gl.LINE_STRIP:
-        if (count < 2) {
-          ctx.setError(gl.INVALID_OPERATION)
-          return
-        }
-        break
-      case gl.TRIANGLE_FAN:
-      case gl.TRIANGLE_STRIP:
-        if (count < 3) {
-          ctx.setError(gl.INVALID_OPERATION)
-          return
-        }
-        break
-      default:
-        ctx.setError(gl.INVALID_ENUM)
-        return
-    }
-
-    if (!ctx._framebufferOk()) {
-      return
-    }
-
-    if (count === 0 || primCount === 0) {
-      this.checkInstancedVertexAttribState(0, 0)
-      return
-    }
-
-    if ((count + offset) >>> 0 > elementData.length) {
-      ctx.setError(gl.INVALID_OPERATION)
-      return
-    }
-
-    // Compute max index
-    let maxIndex = -1
-    for (let i = offset; i < offset + count; ++i) {
-      maxIndex = Math.max(maxIndex, elementData[i])
-    }
-
-    if (maxIndex < 0) {
-      this.checkInstancedVertexAttribState(0, 0)
-      return
-    }
-
-    if (this.checkInstancedVertexAttribState(maxIndex, primCount)) {
-      if (reducedCount > 0) {
-        this._drawElementsInstanced(mode, reducedCount, type, ioffset, primCount)
-      }
-    }
-  }
-
-  vertexAttribDivisorANGLE (index: GLuint, divisor: GLuint) {
-    const { ctx } = this
-    index |= 0
-    divisor |= 0
-    if (divisor < 0 ||
-      index < 0 || index >= ctx._vertexObjectState._attribs.length) {
-      ctx.setError(gl.INVALID_VALUE)
-      return
-    }
-    const attrib = ctx._vertexObjectState._attribs[index]
-    attrib._divisor = divisor
-    this._vertexAttribDivisor(index, divisor)
-  }
-
-  checkInstancedVertexAttribState (maxIndex: number, primCount: GLuint) {
-    const { ctx } = this
-    const program = ctx._activeProgram
-    if (!program) {
-      ctx.setError(gl.INVALID_OPERATION)
-      return false
-    }
-
-    const attribs = ctx._vertexObjectState._attribs
-    let hasZero = false
-    for (let i = 0; i < attribs.length; ++i) {
-      const attrib = attribs[i]
-      if (attrib._isPointer) {
-        const buffer = attrib._pointerBuffer
-        if (program._attributes.indexOf(i) >= 0) {
-          if (!buffer) {
-            ctx.setError(gl.INVALID_OPERATION)
-            return false
-          }
-          let maxByte = 0
-          if (attrib._divisor === 0) {
-            hasZero = true
-            maxByte = attrib._pointerStride * maxIndex +
-              attrib._pointerSize +
-              attrib._pointerOffset
-          } else {
-            maxByte = attrib._pointerStride * (Math.ceil(primCount / attrib._divisor) - 1) +
-              attrib._pointerSize +
-              attrib._pointerOffset
-          }
-          if (maxByte > buffer._size) {
-            ctx.setError(gl.INVALID_OPERATION)
-            return false
-          }
-        }
-      }
-    }
-
-    if (!hasZero) {
-      ctx.setError(gl.INVALID_OPERATION)
-      return false
-    }
-
-    return true
-  }
-}
-
-export function getANGLEInstancedArrays (ctx: GjsifyWebGLRenderingContext) {
-  return new ANGLEInstancedArrays(ctx)
-}

package/src/ts/extensions/ext-blend-minmax.ts

@@ -1,18 +0,0 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
-
-export class EXTBlendMinMax {
-  MIN_EXT = 0x8007
-  MAX_EXT = 0x8008
-  constructor () {}
-}
-
-export function getEXTBlendMinMax (context: GjsifyWebGLRenderingContext) {
-  let result = null
-  const exts = context.getSupportedExtensions()
-
-  if (exts && exts.indexOf('EXT_blend_minmax') >= 0) {
-    result = new EXTBlendMinMax()
-  }
-
-  return result
-}

package/src/ts/extensions/ext-texture-filter-anisotropic.ts

@@ -1,18 +0,0 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
-
-export class EXTTextureFilterAnisotropic {
-  TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE
-  MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF
-  constructor () {}
-}
-
-export function getEXTTextureFilterAnisotropic (context: GjsifyWebGLRenderingContext) {
-  let result = null
-  const exts = context.getSupportedExtensions()
-
-  if (exts && exts.indexOf('EXT_texture_filter_anisotropic') >= 0) {
-    result = new EXTTextureFilterAnisotropic()
-  }
-
-  return result
-}

package/src/ts/extensions/oes-element-index-unit.ts

@@ -1,14 +0,0 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
-
-export class OESElementIndexUint {}
-
-export function getOESElementIndexUint (context: GjsifyWebGLRenderingContext) {
-  let result = null
-  const exts = context.getSupportedExtensions()
-
-  if (exts && exts.indexOf('OES_element_index_uint') >= 0) {
-    result = new OESElementIndexUint()
-  }
-
-  return result
-}

package/src/ts/extensions/oes-standard-derivatives.ts

@@ -1,17 +0,0 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
-
-export class OESStandardDerivatives {
-  FRAGMENT_SHADER_DERIVATIVE_HINT_OES = 0x8B8B
-  constructor () {}
-}
-
-export function getOESStandardDerivatives (context: GjsifyWebGLRenderingContext) {
-  let result = null
-  const exts = context.getSupportedExtensions()
-
-  if (exts && exts.indexOf('OES_standard_derivatives') >= 0) {
-    result = new OESStandardDerivatives()
-  }
-
-  return result
-}

package/src/ts/extensions/oes-texture-float-linear.ts

@@ -1,14 +0,0 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
-
-export class OESTextureFloatLinear {}
-
-export function getOESTextureFloatLinear (context: GjsifyWebGLRenderingContext) {
-  let result = null
-  const exts = context.getSupportedExtensions()
-
-  if (exts && exts.indexOf('OES_texture_float_linear') >= 0) {
-    result = new OESTextureFloatLinear()
-  }
-
-  return result
-}

package/src/ts/extensions/oes-texture-float.ts

@@ -1,14 +0,0 @@
-import type { GjsifyWebGLRenderingContext } from '../webgl-rendering-context.js';
-
-export class OESTextureFloat {}
-
-export function getOESTextureFloat (context: GjsifyWebGLRenderingContext) {
-  let result = null
-  const exts = context.getSupportedExtensions()
-
-  if (exts && exts.indexOf('OES_texture_float') >= 0) {
-    result = new OESTextureFloat()
-  }
-
-  return result
-}