@gjsify/webgl 0.3.12 → 0.3.14

package/lib/esm/utils.js

@@ -1,224 +1,201 @@
 import { WebGLUniformLocation } from "./webgl-uniform-location.js";
 import GLib from "@girs/glib-2.0";
+
+//#region src/ts/utils.ts
 function bindPublics(props, wrapper, privateInstance, privateMethods) {
-  for (let i = 0; i < props.length; i++) {
-    const prop = props[i];
-    const value = privateInstance[prop];
-    if (typeof value === "function") {
-      if (privateMethods.indexOf(prop) === -1) {
-        wrapper[prop] = value.bind(privateInstance);
-      }
-    } else {
-      if (prop[0] === "_" || prop[0] === "0" || prop[0] === "1") {
-        continue;
-      }
-      wrapper[prop] = value;
-    }
-  }
+	for (let i = 0; i < props.length; i++) {
+		const prop = props[i];
+		const value = privateInstance[prop];
+		if (typeof value === "function") {
+			if (privateMethods.indexOf(prop) === -1) {
+				wrapper[prop] = value.bind(privateInstance);
+			}
+		} else {
+			if (prop[0] === "_" || prop[0] === "0" || prop[0] === "1") {
+				continue;
+			}
+			wrapper[prop] = value;
+		}
+	}
 }
 function checkObject(object) {
-  return typeof object === "object" || object === void 0;
+	return typeof object === "object" || object === undefined;
 }
 function checkUniform(program, location) {
-  return location instanceof WebGLUniformLocation && location._program === program && location._linkCount === program._linkCount;
+	return location instanceof WebGLUniformLocation && location._program === program && location._linkCount === program._linkCount;
 }
 function isTypedArray(data) {
-  return data instanceof Uint8Array || data instanceof Uint8ClampedArray || data instanceof Int8Array || data instanceof Uint16Array || data instanceof Int16Array || data instanceof Uint32Array || data instanceof Int32Array || data instanceof Float32Array || data instanceof Float64Array;
+	return data instanceof Uint8Array || data instanceof Uint8ClampedArray || data instanceof Int8Array || data instanceof Uint16Array || data instanceof Int16Array || data instanceof Uint32Array || data instanceof Int32Array || data instanceof Float32Array || data instanceof Float64Array;
 }
 function isValidString(str) {
-  const c = str.replace(/(?:\/\*(?:[\s\S]*?)\*\/)|(?:([\s;])+\/\/(?:.*)$)/gm, "");
-  return !/["$`@\\'\0]/.test(c);
+	const c = str.replace(/(?:\/\*(?:[\s\S]*?)\*\/)|(?:([\s;])+\/\/(?:.*)$)/gm, "");
+	return !/["$`@\\'\0]/.test(c);
 }
 function vertexCount(gl, primitive, count) {
-  switch (primitive) {
-    case gl.TRIANGLES:
-      return count - count % 3;
-    case gl.LINES:
-      return count - count % 2;
-    case gl.LINE_LOOP:
-    case gl.POINTS:
-      return count;
-    case gl.TRIANGLE_FAN:
-    case gl.LINE_STRIP:
-      if (count < 2) {
-        return 0;
-      }
-      return count;
-    case gl.TRIANGLE_STRIP:
-      if (count < 3) {
-        return 0;
-      }
-      return count;
-    default:
-      return -1;
-  }
+	switch (primitive) {
+		case gl.TRIANGLES: return count - count % 3;
+		case gl.LINES: return count - count % 2;
+		case gl.LINE_LOOP:
+		case gl.POINTS: return count;
+		case gl.TRIANGLE_FAN:
+		case gl.LINE_STRIP:
+			if (count < 2) {
+				return 0;
+			}
+			return count;
+		case gl.TRIANGLE_STRIP:
+			if (count < 3) {
+				return 0;
+			}
+			return count;
+		default: return -1;
+	}
 }
 function typeSize(gl, type) {
-  switch (type) {
-    case gl.UNSIGNED_BYTE:
-    case gl.BYTE:
-      return 1;
-    case gl.UNSIGNED_SHORT:
-    case gl.SHORT:
-      return 2;
-    case gl.UNSIGNED_INT:
-    case gl.INT:
-    case gl.FLOAT:
-      return 4;
-  }
-  return 0;
+	switch (type) {
+		case gl.UNSIGNED_BYTE:
+		case gl.BYTE: return 1;
+		case gl.UNSIGNED_SHORT:
+		case gl.SHORT: return 2;
+		case gl.UNSIGNED_INT:
+		case gl.INT:
+		case gl.FLOAT: return 4;
+	}
+	return 0;
 }
 function uniformTypeSize(gl, type) {
-  switch (type) {
-    case gl.BOOL_VEC4:
-    case gl.INT_VEC4:
-    case gl.FLOAT_VEC4:
-      return 4;
-    case gl.BOOL_VEC3:
-    case gl.INT_VEC3:
-    case gl.FLOAT_VEC3:
-      return 3;
-    case gl.BOOL_VEC2:
-    case gl.INT_VEC2:
-    case gl.FLOAT_VEC2:
-      return 2;
-    case gl.BOOL:
-    case gl.INT:
-    case gl.FLOAT:
-    case gl.SAMPLER_2D:
-    case gl.SAMPLER_CUBE:
-      return 1;
-    default:
-      return 0;
-  }
+	switch (type) {
+		case gl.BOOL_VEC4:
+		case gl.INT_VEC4:
+		case gl.FLOAT_VEC4: return 4;
+		case gl.BOOL_VEC3:
+		case gl.INT_VEC3:
+		case gl.FLOAT_VEC3: return 3;
+		case gl.BOOL_VEC2:
+		case gl.INT_VEC2:
+		case gl.FLOAT_VEC2: return 2;
+		case gl.BOOL:
+		case gl.INT:
+		case gl.FLOAT:
+		case gl.SAMPLER_2D:
+		case gl.SAMPLER_CUBE: return 1;
+		default: return 0;
+	}
 }
 const listToArray = (values) => {
-  const array = [];
-  for (const value of values.values()) {
-    array.push(value);
-  }
-  return array;
+	const array = [];
+	for (const value of values.values()) {
+		array.push(value);
+	}
+	return array;
 };
 function arrayToUint8Array(array) {
-  if (isTypedArray(array)) {
-    return new Uint8Array(array.buffer).subarray(
-      array.byteOffset,
-      array.byteLength + array.byteOffset
-    );
-  }
-  if (Array.isArray(array) || array instanceof ArrayBuffer) {
-    return new Uint8Array(array);
-  }
-  if (typeof array.values === "function") {
-    return new Uint8Array(listToArray(array));
-  }
-  throw new Error("Can't unpack typed array!");
+	if (isTypedArray(array)) {
+		return new Uint8Array(array.buffer).subarray(array.byteOffset, array.byteLength + array.byteOffset);
+	}
+	if (Array.isArray(array) || array instanceof ArrayBuffer) {
+		return new Uint8Array(array);
+	}
+	if (typeof array.values === "function") {
+		return new Uint8Array(listToArray(array));
+	}
+	throw new Error("Can't unpack typed array!");
 }
 function Uint8ArrayToVariant(array) {
-  const variant = new GLib.Variant("ay", array);
-  return variant;
-}
+	const variant = new GLib.Variant("ay", array);
+	return variant;
+}
+/**
+* Converts an ArrayBufferView to an array of bools. gjs returns
+* Uint8Array, but the elements are actually 4 bytes each.
+* @param array 
+* @returns 
+*/
 function boolArray(array) {
-  return Array.from(new Int32Array(array.buffer)).map(
-    (a) => a ? true : false
-  );
+	return Array.from(new Int32Array(array.buffer)).map((a) => a ? true : false);
 }
 const extractImageData = (pixels) => {
-  const width = pixels.width;
-  const height = pixels.height;
-  if (typeof pixels === "object" && typeof width !== "undefined" && typeof height !== "undefined") {
-    if (typeof pixels.data !== "undefined") {
-      return pixels;
-    }
-    let context = null;
-    if (typeof pixels.getContext === "function") {
-      context = pixels.getContext("2d");
-    } else if (typeof pixels.isPixbuf === "function" && pixels.isPixbuf()) {
-      return pixels.getImageData();
-    } else if (typeof pixels.src !== "undefined" && typeof document === "object" && typeof document.createElement === "function") {
-      const canvas = document.createElement("canvas");
-      if (typeof canvas === "object" && typeof canvas.getContext === "function") {
-        canvas.width = width;
-        canvas.height = height;
-        context = canvas.getContext("2d");
-        if (context !== null) {
-          context.drawImage(pixels, 0, 0);
-        }
-      }
-    }
-    if (context !== null) {
-      return context.getImageData(0, 0, width, height);
-    }
-  }
-  return null;
+	const width = pixels.width;
+	const height = pixels.height;
+	if (typeof pixels === "object" && typeof width !== "undefined" && typeof height !== "undefined") {
+		if (typeof pixels.data !== "undefined") {
+			return pixels;
+		}
+		let context = null;
+		if (typeof pixels.getContext === "function") {
+			context = pixels.getContext("2d");
+		} else if (typeof pixels.isPixbuf === "function" && pixels.isPixbuf()) {
+			return pixels.getImageData();
+		} else if (typeof pixels.src !== "undefined" && typeof document === "object" && typeof document.createElement === "function") {
+			const canvas = document.createElement("canvas");
+			if (typeof canvas === "object" && typeof canvas.getContext === "function") {
+				canvas.width = width;
+				canvas.height = height;
+				context = canvas.getContext("2d");
+				if (context !== null) {
+					context.drawImage(pixels, 0, 0);
+				}
+			}
+		}
+		if (context !== null) {
+			return context.getImageData(0, 0, width, height);
+		}
+	}
+	return null;
 };
 function formatSize(gl, internalFormat) {
-  switch (internalFormat) {
-    case gl.ALPHA:
-    case gl.LUMINANCE:
-      return 1;
-    case gl.LUMINANCE_ALPHA:
-      return 2;
-    case gl.RGB:
-      return 3;
-    case gl.RGBA:
-      return 4;
-  }
-  return 0;
+	switch (internalFormat) {
+		case gl.ALPHA:
+		case gl.LUMINANCE: return 1;
+		case gl.LUMINANCE_ALPHA: return 2;
+		case gl.RGB: return 3;
+		case gl.RGBA: return 4;
+	}
+	return 0;
 }
 function convertPixels(pixels) {
-  if (typeof pixels === "object" && pixels !== null) {
-    if (pixels instanceof ArrayBuffer) {
-      return new Uint8Array(pixels);
-    } else if (pixels instanceof Uint8Array || pixels instanceof Uint16Array || pixels instanceof Uint8ClampedArray || pixels instanceof Float32Array) {
-      return arrayToUint8Array(pixels);
-    } else if (pixels instanceof Buffer) {
-      return new Uint8Array(pixels);
-    }
-  }
-  return null;
+	if (typeof pixels === "object" && pixels !== null) {
+		if (pixels instanceof ArrayBuffer) {
+			return new Uint8Array(pixels);
+		} else if (pixels instanceof Uint8Array || pixels instanceof Uint16Array || pixels instanceof Uint8ClampedArray || pixels instanceof Float32Array) {
+			return arrayToUint8Array(pixels);
+		} else if (pixels instanceof Buffer) {
+			return new Uint8Array(pixels);
+		}
+	}
+	return null;
 }
 function checkFormat(gl, format) {
-  return format === gl.ALPHA || format === gl.LUMINANCE_ALPHA || format === gl.LUMINANCE || format === gl.RGB || format === gl.RGBA;
+	return format === gl.ALPHA || format === gl.LUMINANCE_ALPHA || format === gl.LUMINANCE || format === gl.RGB || format === gl.RGBA;
 }
 function validCubeTarget(gl, target) {
-  return target === gl.TEXTURE_CUBE_MAP_POSITIVE_X || target === gl.TEXTURE_CUBE_MAP_NEGATIVE_X || target === gl.TEXTURE_CUBE_MAP_POSITIVE_Y || target === gl.TEXTURE_CUBE_MAP_NEGATIVE_Y || target === gl.TEXTURE_CUBE_MAP_POSITIVE_Z || target === gl.TEXTURE_CUBE_MAP_NEGATIVE_Z;
+	return target === gl.TEXTURE_CUBE_MAP_POSITIVE_X || target === gl.TEXTURE_CUBE_MAP_NEGATIVE_X || target === gl.TEXTURE_CUBE_MAP_POSITIVE_Y || target === gl.TEXTURE_CUBE_MAP_NEGATIVE_Y || target === gl.TEXTURE_CUBE_MAP_POSITIVE_Z || target === gl.TEXTURE_CUBE_MAP_NEGATIVE_Z;
 }
 function flag(options, name, dflt) {
-  if (!options || !(typeof options === "object") || !(name in options)) {
-    return dflt;
-  }
-  return !!options[name];
-}
+	if (!options || !(typeof options === "object") || !(name in options)) {
+		return dflt;
+	}
+	return !!options[name];
+}
+/**
+* Premultiply RGB channels by the alpha channel (in-place copy).
+* Required when UNPACK_PREMULTIPLY_ALPHA_WEBGL is set.
+* Excalibur uses blendFunc(ONE, ONE_MINUS_SRC_ALPHA) (premultiplied alpha
+* blending), so textures must have RGB already multiplied by alpha before
+* upload. Without this, transparent-background PNGs (alpha=0 but RGB=255)
+* bleed through as white rectangles.
+*/
 function premultiplyAlpha(data) {
-  const out = new Uint8Array(data.length);
-  for (let i = 0; i < data.length; i += 4) {
-    const a = data[i + 3] / 255;
-    out[i] = Math.round(data[i] * a);
-    out[i + 1] = Math.round(data[i + 1] * a);
-    out[i + 2] = Math.round(data[i + 2] * a);
-    out[i + 3] = data[i + 3];
-  }
-  return out;
-}
-export {
-  Uint8ArrayToVariant,
-  arrayToUint8Array,
-  bindPublics,
-  boolArray,
-  checkFormat,
-  checkObject,
-  checkUniform,
-  convertPixels,
-  extractImageData,
-  flag,
-  formatSize,
-  isTypedArray,
-  isValidString,
-  listToArray,
-  premultiplyAlpha,
-  typeSize,
-  uniformTypeSize,
-  validCubeTarget,
-  vertexCount
-};
+	const out = new Uint8Array(data.length);
+	for (let i = 0; i < data.length; i += 4) {
+		const a = data[i + 3] / 255;
+		out[i] = Math.round(data[i] * a);
+		out[i + 1] = Math.round(data[i + 1] * a);
+		out[i + 2] = Math.round(data[i + 2] * a);
+		out[i + 3] = data[i + 3];
+	}
+	return out;
+}
+
+//#endregion
+export { Uint8ArrayToVariant, arrayToUint8Array, bindPublics, boolArray, checkFormat, checkObject, checkUniform, convertPixels, extractImageData, flag, formatSize, isTypedArray, isValidString, listToArray, premultiplyAlpha, typeSize, uniformTypeSize, validCubeTarget, vertexCount };

package/lib/esm/webgl-active-info.js

@@ -1,10 +1,11 @@
-class WebGLActiveInfo {
-  constructor(_) {
-    this.size = _.size;
-    this.type = _.type;
-    this.name = _.name;
-  }
-}
-export {
-  WebGLActiveInfo
+//#region src/ts/webgl-active-info.ts
+var WebGLActiveInfo = class {
+	constructor(_) {
+		this.size = _.size;
+		this.type = _.type;
+		this.name = _.name;
+	}
 };
+
+//#endregion
+export { WebGLActiveInfo };