@gjsify/webgl 0.3.12 → 0.3.14

package/lib/esm/webgl-rendering-context.js

@@ -1,189 +1,175 @@
-import Gwebgl from "@girs/gwebgl-0.1";
-import { WebGLContextBase } from "./webgl-context-base.js";
 import { Uint8ArrayToVariant, vertexCount } from "./utils.js";
-import { WebGLContextBase as WebGLContextBase2 } from "./webgl-context-base.js";
-class WebGLRenderingContext extends WebGLContextBase {
-  constructor(canvas, options = {}) {
-    super(canvas, options);
-    this._attrib0Buffer = null;
-    this._native = new Gwebgl.WebGLRenderingContext({});
-    this._init();
-    const attrib0Buffer = this.createBuffer();
-    this._attrib0Buffer = attrib0Buffer;
-  }
-  get _gl() {
-    return this._native;
-  }
-  // ─── Attrib0 Hack (WebGL1 / GLES2 only) ─────────────────────────────
-  _beginAttrib0Hack() {
-    this._native.bindBuffer(this.ARRAY_BUFFER, this._attrib0Buffer?._ || 0);
-    const uInt8Data = new Uint8Array(this._vertexGlobalState._attribs[0]._data.buffer);
-    this._native.bufferData(
-      this.ARRAY_BUFFER,
-      Uint8ArrayToVariant(uInt8Data),
-      this.STREAM_DRAW
-    );
-    this._native.enableVertexAttribArray(0);
-    this._native.vertexAttribPointer(0, 4, this.FLOAT, false, 0, 0);
-    this._native._vertexAttribDivisor(0, 1);
-  }
-  _endAttrib0Hack() {
-    const attrib = this._vertexObjectState._attribs[0];
-    if (attrib._pointerBuffer) {
-      this._native.bindBuffer(this.ARRAY_BUFFER, attrib._pointerBuffer._);
-    } else {
-      this._native.bindBuffer(this.ARRAY_BUFFER, 0);
-    }
-    this._native.vertexAttribPointer(
-      0,
-      attrib._inputSize,
-      attrib._pointerType,
-      attrib._pointerNormal,
-      attrib._inputStride,
-      attrib._pointerOffset
-    );
-    this._native._vertexAttribDivisor(0, attrib._divisor);
-    this._native.disableVertexAttribArray(0);
-    if (this._vertexGlobalState._arrayBufferBinding) {
-      this._native.bindBuffer(this.ARRAY_BUFFER, this._vertexGlobalState._arrayBufferBinding._);
-    } else {
-      this._native.bindBuffer(this.ARRAY_BUFFER, 0);
-    }
-  }
-  // ─── drawArrays / drawElements with attrib0 hack ─────────────────────
-  drawArrays(mode = 0, first = 0, count = 0) {
-    if (first < 0 || count < 0) {
-      this.setError(this.INVALID_VALUE);
-      return;
-    }
-    if (!this._checkStencilState()) {
-      return;
-    }
-    const reducedCount = vertexCount(this, mode, count);
-    if (reducedCount < 0) {
-      this.setError(this.INVALID_ENUM);
-      return;
-    }
-    if (!this._framebufferOk()) {
-      return;
-    }
-    if (count === 0) {
-      return;
-    }
-    let maxIndex = first;
-    if (count > 0) {
-      maxIndex = count + first - 1 >>> 0;
-    }
-    if (this._checkVertexAttribState(maxIndex)) {
-      if (this._vertexObjectState._attribs[0]._isPointer || this._extensions.webgl_draw_buffers && this._extensions.webgl_draw_buffers._buffersState && this._extensions.webgl_draw_buffers._buffersState.length > 0) {
-        return this._native.drawArrays(mode, first, reducedCount);
-      } else {
-        this._beginAttrib0Hack();
-        this._native._drawArraysInstanced(mode, first, reducedCount, 1);
-        this._endAttrib0Hack();
-      }
-    }
-  }
-  drawElements(mode = 0, count = 0, type = 0, ioffset = 0) {
-    if (count < 0 || ioffset < 0) {
-      this.setError(this.INVALID_VALUE);
-      return;
-    }
-    if (!this._checkStencilState()) {
-      return;
-    }
-    const elementBuffer = this._vertexObjectState._elementArrayBufferBinding;
-    if (!elementBuffer) {
-      this.setError(this.INVALID_OPERATION);
-      return;
-    }
-    let elementData = null;
-    let offset = ioffset;
-    if (type === this.UNSIGNED_SHORT) {
-      if (offset % 2) {
-        this.setError(this.INVALID_OPERATION);
-        return;
-      }
-      offset >>= 1;
-      elementData = new Uint16Array(elementBuffer._elements.buffer);
-    } else if (this._extensions.oes_element_index_uint && type === this.UNSIGNED_INT) {
-      if (offset % 4) {
-        this.setError(this.INVALID_OPERATION);
-        return;
-      }
-      offset >>= 2;
-      elementData = new Uint32Array(elementBuffer._elements.buffer);
-    } else if (type === this.UNSIGNED_BYTE) {
-      elementData = elementBuffer._elements;
-    } else {
-      this.setError(this.INVALID_ENUM);
-      return;
-    }
-    let reducedCount = count;
-    switch (mode) {
-      case this.TRIANGLES:
-        if (count % 3) {
-          reducedCount -= count % 3;
-        }
-        break;
-      case this.LINES:
-        if (count % 2) {
-          reducedCount -= count % 2;
-        }
-        break;
-      case this.POINTS:
-        break;
-      case this.LINE_LOOP:
-      case this.LINE_STRIP:
-        if (count < 2) {
-          this.setError(this.INVALID_OPERATION);
-          return;
-        }
-        break;
-      case this.TRIANGLE_FAN:
-      case this.TRIANGLE_STRIP:
-        if (count < 3) {
-          this.setError(this.INVALID_OPERATION);
-          return;
-        }
-        break;
-      default:
-        this.setError(this.INVALID_ENUM);
-        return;
-    }
-    if (!this._framebufferOk()) {
-      return;
-    }
-    if (count === 0) {
-      this._checkVertexAttribState(0);
-      return;
-    }
-    if (count + offset >>> 0 > elementData.length) {
-      this.setError(this.INVALID_OPERATION);
-      return;
-    }
-    let maxIndex = -1;
-    for (let i = offset; i < offset + count; ++i) {
-      maxIndex = Math.max(maxIndex, elementData[i]);
-    }
-    if (maxIndex < 0) {
-      this._checkVertexAttribState(0);
-      return;
-    }
-    if (this._checkVertexAttribState(maxIndex)) {
-      if (reducedCount > 0) {
-        if (this._vertexObjectState._attribs[0]._isPointer) {
-          return this._native.drawElements(mode, reducedCount, type, ioffset);
-        } else {
-          this._beginAttrib0Hack();
-          this._native._drawElementsInstanced(mode, reducedCount, type, ioffset, 1);
-          this._endAttrib0Hack();
-        }
-      }
-    }
-  }
-}
-export {
-  WebGLContextBase2 as WebGLContextBase,
-  WebGLRenderingContext
+import { WebGLContextBase } from "./webgl-context-base.js";
+import Gwebgl from "@girs/gwebgl-0.1";
+
+//#region src/ts/webgl-rendering-context.ts
+var WebGLRenderingContext = class extends WebGLContextBase {
+	get _gl() {
+		return this._native;
+	}
+	constructor(canvas, options = {}) {
+		super(canvas, options);
+		this._attrib0Buffer = null;
+		this._native = new Gwebgl.WebGLRenderingContext({});
+		this._init();
+		const attrib0Buffer = this.createBuffer();
+		this._attrib0Buffer = attrib0Buffer;
+	}
+	_beginAttrib0Hack() {
+		this._native.bindBuffer(this.ARRAY_BUFFER, this._attrib0Buffer?._ || 0);
+		const uInt8Data = new Uint8Array(this._vertexGlobalState._attribs[0]._data.buffer);
+		this._native.bufferData(this.ARRAY_BUFFER, Uint8ArrayToVariant(uInt8Data), this.STREAM_DRAW);
+		this._native.enableVertexAttribArray(0);
+		this._native.vertexAttribPointer(0, 4, this.FLOAT, false, 0, 0);
+		this._native._vertexAttribDivisor(0, 1);
+	}
+	_endAttrib0Hack() {
+		const attrib = this._vertexObjectState._attribs[0];
+		if (attrib._pointerBuffer) {
+			this._native.bindBuffer(this.ARRAY_BUFFER, attrib._pointerBuffer._);
+		} else {
+			this._native.bindBuffer(this.ARRAY_BUFFER, 0);
+		}
+		this._native.vertexAttribPointer(0, attrib._inputSize, attrib._pointerType, attrib._pointerNormal, attrib._inputStride, attrib._pointerOffset);
+		this._native._vertexAttribDivisor(0, attrib._divisor);
+		this._native.disableVertexAttribArray(0);
+		if (this._vertexGlobalState._arrayBufferBinding) {
+			this._native.bindBuffer(this.ARRAY_BUFFER, this._vertexGlobalState._arrayBufferBinding._);
+		} else {
+			this._native.bindBuffer(this.ARRAY_BUFFER, 0);
+		}
+	}
+	drawArrays(mode = 0, first = 0, count = 0) {
+		if (first < 0 || count < 0) {
+			this.setError(this.INVALID_VALUE);
+			return;
+		}
+		if (!this._checkStencilState()) {
+			return;
+		}
+		const reducedCount = vertexCount(this, mode, count);
+		if (reducedCount < 0) {
+			this.setError(this.INVALID_ENUM);
+			return;
+		}
+		if (!this._framebufferOk()) {
+			return;
+		}
+		if (count === 0) {
+			return;
+		}
+		let maxIndex = first;
+		if (count > 0) {
+			maxIndex = count + first - 1 >>> 0;
+		}
+		if (this._checkVertexAttribState(maxIndex)) {
+			if (this._vertexObjectState._attribs[0]._isPointer || this._extensions.webgl_draw_buffers && this._extensions.webgl_draw_buffers._buffersState && this._extensions.webgl_draw_buffers._buffersState.length > 0) {
+				return this._native.drawArrays(mode, first, reducedCount);
+			} else {
+				this._beginAttrib0Hack();
+				this._native._drawArraysInstanced(mode, first, reducedCount, 1);
+				this._endAttrib0Hack();
+			}
+		}
+	}
+	drawElements(mode = 0, count = 0, type = 0, ioffset = 0) {
+		if (count < 0 || ioffset < 0) {
+			this.setError(this.INVALID_VALUE);
+			return;
+		}
+		if (!this._checkStencilState()) {
+			return;
+		}
+		const elementBuffer = this._vertexObjectState._elementArrayBufferBinding;
+		if (!elementBuffer) {
+			this.setError(this.INVALID_OPERATION);
+			return;
+		}
+		let elementData = null;
+		let offset = ioffset;
+		if (type === this.UNSIGNED_SHORT) {
+			if (offset % 2) {
+				this.setError(this.INVALID_OPERATION);
+				return;
+			}
+			offset >>= 1;
+			elementData = new Uint16Array(elementBuffer._elements.buffer);
+		} else if (this._extensions.oes_element_index_uint && type === this.UNSIGNED_INT) {
+			if (offset % 4) {
+				this.setError(this.INVALID_OPERATION);
+				return;
+			}
+			offset >>= 2;
+			elementData = new Uint32Array(elementBuffer._elements.buffer);
+		} else if (type === this.UNSIGNED_BYTE) {
+			elementData = elementBuffer._elements;
+		} else {
+			this.setError(this.INVALID_ENUM);
+			return;
+		}
+		let reducedCount = count;
+		switch (mode) {
+			case this.TRIANGLES:
+				if (count % 3) {
+					reducedCount -= count % 3;
+				}
+				break;
+			case this.LINES:
+				if (count % 2) {
+					reducedCount -= count % 2;
+				}
+				break;
+			case this.POINTS: break;
+			case this.LINE_LOOP:
+			case this.LINE_STRIP:
+				if (count < 2) {
+					this.setError(this.INVALID_OPERATION);
+					return;
+				}
+				break;
+			case this.TRIANGLE_FAN:
+			case this.TRIANGLE_STRIP:
+				if (count < 3) {
+					this.setError(this.INVALID_OPERATION);
+					return;
+				}
+				break;
+			default:
+				this.setError(this.INVALID_ENUM);
+				return;
+		}
+		if (!this._framebufferOk()) {
+			return;
+		}
+		if (count === 0) {
+			this._checkVertexAttribState(0);
+			return;
+		}
+		if (count + offset >>> 0 > elementData.length) {
+			this.setError(this.INVALID_OPERATION);
+			return;
+		}
+		let maxIndex = -1;
+		for (let i = offset; i < offset + count; ++i) {
+			maxIndex = Math.max(maxIndex, elementData[i]);
+		}
+		if (maxIndex < 0) {
+			this._checkVertexAttribState(0);
+			return;
+		}
+		if (this._checkVertexAttribState(maxIndex)) {
+			if (reducedCount > 0) {
+				if (this._vertexObjectState._attribs[0]._isPointer) {
+					return this._native.drawElements(mode, reducedCount, type, ioffset);
+				} else {
+					this._beginAttrib0Hack();
+					this._native._drawElementsInstanced(mode, reducedCount, type, ioffset, 1);
+					this._endAttrib0Hack();
+				}
+			}
+		}
+	}
 };
+
+//#endregion
+export { WebGLContextBase, WebGLRenderingContext };

package/lib/esm/webgl-sampler.js

@@ -1,15 +1,17 @@
 import { Linkable } from "./linkable.js";
-class WebGLSampler extends Linkable {
-  constructor(_, ctx) {
-    super(_);
-    this._ctx = ctx;
-  }
-  _performDelete() {
-    const ctx = this._ctx;
-    delete ctx._samplers[this._ | 0];
-    ctx._native2.deleteSampler(this._ | 0);
-  }
-}
-export {
-  WebGLSampler
+
+//#region src/ts/webgl-sampler.ts
+var WebGLSampler = class extends Linkable {
+	constructor(_, ctx) {
+		super(_);
+		this._ctx = ctx;
+	}
+	_performDelete() {
+		const ctx = this._ctx;
+		delete ctx._samplers[this._ | 0];
+		ctx._native2.deleteSampler(this._ | 0);
+	}
 };
+
+//#endregion
+export { WebGLSampler };

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

@@ -1,10 +1,11 @@
-class WebGLShaderPrecisionFormat {
-  constructor(_) {
-    this.rangeMin = _.rangeMin;
-    this.rangeMax = _.rangeMax;
-    this.precision = _.precision;
-  }
-}
-export {
-  WebGLShaderPrecisionFormat
+//#region src/ts/webgl-shader-precision-format.ts
+var WebGLShaderPrecisionFormat = class {
+	constructor(_) {
+		this.rangeMin = _.rangeMin;
+		this.rangeMax = _.rangeMax;
+		this.precision = _.precision;
+	}
 };
+
+//#endregion
+export { WebGLShaderPrecisionFormat };

package/lib/esm/webgl-shader.js

@@ -1,23 +1,25 @@
 import { Linkable } from "./linkable.js";
-class WebGLShader extends Linkable {
-  constructor(_, ctx, type) {
-    super(_);
-    this._source = "";
-    this._compileStatus = false;
-    this._compileInfo = "";
-    this._needsRecompile = false;
-    this._type = type;
-    this._ctx = ctx;
-    this._source = "";
-    this._compileStatus = false;
-    this._compileInfo = "";
-  }
-  _performDelete() {
-    const ctx = this._ctx;
-    delete ctx._shaders[this._ | 0];
-    ctx._gl.deleteShader(this._ | 0);
-  }
-}
-export {
-  WebGLShader
+
+//#region src/ts/webgl-shader.ts
+var WebGLShader = class extends Linkable {
+	constructor(_, ctx, type) {
+		super(_);
+		this._source = "";
+		this._compileStatus = false;
+		this._compileInfo = "";
+		this._needsRecompile = false;
+		this._type = type;
+		this._ctx = ctx;
+		this._source = "";
+		this._compileStatus = false;
+		this._compileInfo = "";
+	}
+	_performDelete() {
+		const ctx = this._ctx;
+		delete ctx._shaders[this._ | 0];
+		ctx._gl.deleteShader(this._ | 0);
+	}
 };
+
+//#endregion
+export { WebGLShader };

package/lib/esm/webgl-sync.js

@@ -1,15 +1,17 @@
 import { Linkable } from "./linkable.js";
-class WebGLSync extends Linkable {
-  constructor(_, ctx) {
-    super(_);
-    this._ctx = ctx;
-  }
-  _performDelete() {
-    const ctx = this._ctx;
-    delete ctx._syncs[this._ | 0];
-    ctx._native2.deleteSync(this._ | 0);
-  }
-}
-export {
-  WebGLSync
+
+//#region src/ts/webgl-sync.ts
+var WebGLSync = class extends Linkable {
+	constructor(_, ctx) {
+		super(_);
+		this._ctx = ctx;
+	}
+	_performDelete() {
+		const ctx = this._ctx;
+		delete ctx._syncs[this._ | 0];
+		ctx._native2.deleteSync(this._ | 0);
+	}
 };
+
+//#endregion
+export { WebGLSync };

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

@@ -1,12 +1,13 @@
-class WebGLTextureUnit {
-  constructor(ctx, idx) {
-    this._mode = 0;
-    this._bind2D = null;
-    this._bindCube = null;
-    this._ctx = ctx;
-    this._idx = idx;
-  }
-}
-export {
-  WebGLTextureUnit
+//#region src/ts/webgl-texture-unit.ts
+var WebGLTextureUnit = class {
+	constructor(ctx, idx) {
+		this._mode = 0;
+		this._bind2D = null;
+		this._bindCube = null;
+		this._ctx = ctx;
+		this._idx = idx;
+	}
 };
+
+//#endregion
+export { WebGLTextureUnit };

package/lib/esm/webgl-texture.js

@@ -1,21 +1,23 @@
 import { Linkable } from "./linkable.js";
-class WebGLTexture 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._gl.deleteTexture(this._ | 0);
-  }
-}
-export {
-  WebGLTexture
+
+//#region src/ts/webgl-texture.ts
+var WebGLTexture = class 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._gl.deleteTexture(this._ | 0);
+	}
 };
+
+//#endregion
+export { WebGLTexture };

package/lib/esm/webgl-transform-feedback.js

@@ -1,15 +1,17 @@
 import { Linkable } from "./linkable.js";
-class WebGLTransformFeedback extends Linkable {
-  constructor(_, ctx) {
-    super(_);
-    this._ctx = ctx;
-  }
-  _performDelete() {
-    const ctx = this._ctx;
-    delete ctx._transformFeedbacks[this._ | 0];
-    ctx._native2.deleteTransformFeedback(this._ | 0);
-  }
-}
-export {
-  WebGLTransformFeedback
+
+//#region src/ts/webgl-transform-feedback.ts
+var WebGLTransformFeedback = class extends Linkable {
+	constructor(_, ctx) {
+		super(_);
+		this._ctx = ctx;
+	}
+	_performDelete() {
+		const ctx = this._ctx;
+		delete ctx._transformFeedbacks[this._ | 0];
+		ctx._native2.deleteTransformFeedback(this._ | 0);
+	}
 };
+
+//#endregion
+export { WebGLTransformFeedback };

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

@@ -1,14 +1,15 @@
-class WebGLUniformLocation {
-  constructor(_, program, info) {
-    this._linkCount = 0;
-    this._array = null;
-    this._ = _;
-    this._program = program;
-    this._linkCount = program._linkCount;
-    this._activeInfo = info;
-    this._array = null;
-  }
-}
-export {
-  WebGLUniformLocation
+//#region src/ts/webgl-uniform-location.ts
+var WebGLUniformLocation = class {
+	constructor(_, program, info) {
+		this._linkCount = 0;
+		this._array = null;
+		this._ = _;
+		this._program = program;
+		this._linkCount = program._linkCount;
+		this._activeInfo = info;
+		this._array = null;
+	}
 };
+
+//#endregion
+export { WebGLUniformLocation };