@gjsify/webgl 0.0.2

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

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webgl_shader_precision_format_exports = {};
+__export(webgl_shader_precision_format_exports, {
+  GjsifyWebGLShaderPrecisionFormat: () => GjsifyWebGLShaderPrecisionFormat,
+  WebGLShaderPrecisionFormat: () => GjsifyWebGLShaderPrecisionFormat
+});
+module.exports = __toCommonJS(webgl_shader_precision_format_exports);
+class GjsifyWebGLShaderPrecisionFormat {
+  constructor(_) {
+    this.rangeMin = _.rangeMin;
+    this.rangeMax = _.rangeMax;
+    this.precision = _.precision;
+  }
+}

package/lib/cjs/webgl-shader.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webgl_shader_exports = {};
+__export(webgl_shader_exports, {
+  GjsifyWebGLShader: () => GjsifyWebGLShader,
+  WebGLShader: () => GjsifyWebGLShader
+});
+module.exports = __toCommonJS(webgl_shader_exports);
+var import_linkable = require("./linkable.js");
+class GjsifyWebGLShader extends import_linkable.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);
+  }
+}

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

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webgl_texture_unit_exports = {};
+__export(webgl_texture_unit_exports, {
+  WebGLTextureUnit: () => WebGLTextureUnit
+});
+module.exports = __toCommonJS(webgl_texture_unit_exports);
+class WebGLTextureUnit {
+  constructor(ctx, idx) {
+    this._mode = 0;
+    this._bind2D = null;
+    this._bindCube = null;
+    this._ctx = ctx;
+    this._idx = idx;
+  }
+}

package/lib/cjs/webgl-texture.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webgl_texture_exports = {};
+__export(webgl_texture_exports, {
+  GjsifyWebGLTexture: () => GjsifyWebGLTexture,
+  WebGLTexture: () => GjsifyWebGLTexture
+});
+module.exports = __toCommonJS(webgl_texture_exports);
+var import_linkable = require("./linkable.js");
+class GjsifyWebGLTexture extends import_linkable.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);
+  }
+}

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

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webgl_uniform_location_exports = {};
+__export(webgl_uniform_location_exports, {
+  GjsifyWebGLUniformLocation: () => GjsifyWebGLUniformLocation,
+  WebGLUniformLocation: () => GjsifyWebGLUniformLocation
+});
+module.exports = __toCommonJS(webgl_uniform_location_exports);
+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;
+  }
+}

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

@@ -0,0 +1,166 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webgl_vertex_attribute_exports = {};
+__export(webgl_vertex_attribute_exports, {
+  WebGLVertexArrayGlobalAttribute: () => WebGLVertexArrayGlobalAttribute,
+  WebGLVertexArrayGlobalState: () => WebGLVertexArrayGlobalState,
+  WebGLVertexArrayObjectAttribute: () => WebGLVertexArrayObjectAttribute,
+  WebGLVertexArrayObjectState: () => WebGLVertexArrayObjectState
+});
+module.exports = __toCommonJS(webgl_vertex_attribute_exports);
+var import_webgl_buffer = require("./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 import_webgl_buffer.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 import_webgl_buffer.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;
+    }
+  }
+}

package/lib/esm/extensions/ext-blend-minmax.js

@@ -0,0 +1,18 @@
+class EXTBlendMinMax {
+  constructor() {
+    this.MIN_EXT = 32775;
+    this.MAX_EXT = 32776;
+  }
+}
+function getEXTBlendMinMax(context) {
+  let result = null;
+  const exts = context.getSupportedExtensions();
+  if (exts && exts.indexOf("EXT_blend_minmax") >= 0) {
+    result = new EXTBlendMinMax();
+  }
+  return result;
+}
+export {
+  EXTBlendMinMax,
+  getEXTBlendMinMax
+};

package/lib/esm/extensions/ext-texture-filter-anisotropic.js

@@ -0,0 +1,18 @@
+class EXTTextureFilterAnisotropic {
+  constructor() {
+    this.TEXTURE_MAX_ANISOTROPY_EXT = 34046;
+    this.MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047;
+  }
+}
+function getEXTTextureFilterAnisotropic(context) {
+  let result = null;
+  const exts = context.getSupportedExtensions();
+  if (exts && exts.indexOf("EXT_texture_filter_anisotropic") >= 0) {
+    result = new EXTTextureFilterAnisotropic();
+  }
+  return result;
+}
+export {
+  EXTTextureFilterAnisotropic,
+  getEXTTextureFilterAnisotropic
+};

package/lib/esm/extensions/oes-element-index-unit.js

@@ -0,0 +1,14 @@
+class OESElementIndexUint {
+}
+function getOESElementIndexUint(context) {
+  let result = null;
+  const exts = context.getSupportedExtensions();
+  if (exts && exts.indexOf("OES_element_index_uint") >= 0) {
+    result = new OESElementIndexUint();
+  }
+  return result;
+}
+export {
+  OESElementIndexUint,
+  getOESElementIndexUint
+};

package/lib/esm/extensions/oes-standard-derivatives.js

@@ -0,0 +1,17 @@
+class OESStandardDerivatives {
+  constructor() {
+    this.FRAGMENT_SHADER_DERIVATIVE_HINT_OES = 35723;
+  }
+}
+function getOESStandardDerivatives(context) {
+  let result = null;
+  const exts = context.getSupportedExtensions();
+  if (exts && exts.indexOf("OES_standard_derivatives") >= 0) {
+    result = new OESStandardDerivatives();
+  }
+  return result;
+}
+export {
+  OESStandardDerivatives,
+  getOESStandardDerivatives
+};

package/lib/esm/extensions/oes-texture-float-linear.js

@@ -0,0 +1,14 @@
+class OESTextureFloatLinear {
+}
+function getOESTextureFloatLinear(context) {
+  let result = null;
+  const exts = context.getSupportedExtensions();
+  if (exts && exts.indexOf("OES_texture_float_linear") >= 0) {
+    result = new OESTextureFloatLinear();
+  }
+  return result;
+}
+export {
+  OESTextureFloatLinear,
+  getOESTextureFloatLinear
+};

package/lib/esm/extensions/oes-texture-float.js

@@ -0,0 +1,14 @@
+class OESTextureFloat {
+}
+function getOESTextureFloat(context) {
+  let result = null;
+  const exts = context.getSupportedExtensions();
+  if (exts && exts.indexOf("OES_texture_float") >= 0) {
+    result = new OESTextureFloat();
+  }
+  return result;
+}
+export {
+  OESTextureFloat,
+  getOESTextureFloat
+};

package/lib/esm/extensions/stackgl-destroy-context.js

@@ -0,0 +1,12 @@
+class STACKGLDestroyContext {
+  constructor(ctx) {
+    this.destroy = ctx.destroy.bind(ctx);
+  }
+}
+function getSTACKGLDestroyContext(ctx) {
+  return new STACKGLDestroyContext(ctx);
+}
+export {
+  STACKGLDestroyContext,
+  getSTACKGLDestroyContext
+};

package/lib/esm/extensions/stackgl-resize-drawing-buffer.js

@@ -0,0 +1,12 @@
+class STACKGLResizeDrawingBuffer {
+  constructor(ctx) {
+    this.resize = ctx.resize.bind(ctx);
+  }
+}
+function getSTACKGLResizeDrawingBuffer(ctx) {
+  return new STACKGLResizeDrawingBuffer(ctx);
+}
+export {
+  STACKGLResizeDrawingBuffer,
+  getSTACKGLResizeDrawingBuffer
+};

package/lib/esm/html-canvas-element.js

@@ -0,0 +1,70 @@
+import { warnNotImplemented, notImplemented } from "@gjsify/utils";
+import { GjsifyWebGLRenderingContext } from "./webgl-rendering-context.js";
+class GjsifyHTMLCanvasElement {
+  constructor(gtkGlArea) {
+    this.gtkGlArea = gtkGlArea;
+  }
+  _getGlArea() {
+    return this.gtkGlArea;
+  }
+  /** Gets the height of a canvas element on a document. */
+  get height() {
+    return this.gtkGlArea.get_allocated_height();
+  }
+  get clientHeight() {
+    return this.height;
+  }
+  /** Sets the height of a canvas element on a document. */
+  set height(_height) {
+    warnNotImplemented("GjsifyHTMLCanvasElement.set_height");
+  }
+  /** Gets the width of a canvas element on a document. */
+  get width() {
+    return this.gtkGlArea.get_allocated_width();
+  }
+  /** Sets the width of a canvas element on a document. */
+  set width(_width) {
+    warnNotImplemented("GjsifyHTMLCanvasElement.set_width");
+  }
+  get clientWidth() {
+    return this.width;
+  }
+  captureStream(_frameRequestRate) {
+    notImplemented("HTMLCanvasElement.captureStream");
+    return new MediaStream();
+  }
+  getContext(contextId, options) {
+    switch (contextId) {
+      case "webgl":
+        if (this._webgl) {
+          return this._webgl;
+        }
+        this._webgl = new GjsifyWebGLRenderingContext(this, options);
+        return this._webgl;
+      default:
+        warnNotImplemented(`GjsifyHTMLCanvasElement.getContext("${contextId}")`);
+    }
+    return null;
+  }
+  toBlob(_callback, _type, _quality) {
+    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, _quality) {
+    notImplemented("HTMLCanvasElement.toDataURL");
+    return "";
+  }
+  addEventListener(_type, _listener, _options) {
+    notImplemented("HTMLCanvasElement.addEventListener");
+  }
+  removeEventListener(_type, _listener, _options) {
+    notImplemented("HTMLCanvasElement.removeEventListener");
+  }
+}
+export {
+  GjsifyHTMLCanvasElement,
+  GjsifyHTMLCanvasElement as HTMLCanvasElement
+};

package/lib/esm/index.js

@@ -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";