@luma.gl/webgl 8.5.7 → 8.6.0-alpha.1

package/dist/webgl-utils/get-error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/webgl-utils/get-error.ts"],"names":["GL_NO_ERROR","GL_INVALID_ENUM","GL_INVALID_VALUE","GL_INVALID_OPERATION","GL_OUT_OF_MEMORY","GL_CONTEXT_LOST_WEBGL","GL_INVALID_FRAMEBUFFER_OPERATION","GL_ERROR_MESSAGES","glGetErrorMessage","gl","glError","glGetError","errorStack","getError","push","length","Error","join","glCheckError","debug","error"],"mappings":"AAIA,MAAMA,WAAW,GAAG,CAApB;AACA,MAAMC,eAAe,GAAG,MAAxB;AACA,MAAMC,gBAAgB,GAAG,MAAzB;AACA,MAAMC,oBAAoB,GAAG,MAA7B;AACA,MAAMC,gBAAgB,GAAG,MAAzB;AACA,MAAMC,qBAAqB,GAAG,MAA9B;AACA,MAAMC,gCAAgC,GAAG,MAAzC;AAIA,MAAMC,iBAAiB,GAAG;AAIxB,GAACF,qBAAD,GAAyB,oBAJD;AAMxB,GAACJ,eAAD,GAAmB,mCANK;AAQxB,GAACC,gBAAD,GAAoB,qBARI;AAUxB,GAACC,oBAAD,GAAwB,yBAVA;AAaxB,GAACG,gCAAD,GAAoC,qCAbZ;AAexB,GAACF,gBAAD,GAAoB;AAfI,CAA1B;;AAkBA,SAASI,iBAAT,CAA2BC,EAA3B,EAA+BC,OAA/B,EAAwC;AACtC,SAAOH,iBAAiB,CAACG,OAAD,CAAjB,kCAAqDA,OAArD,CAAP;AACD;;AAGD,OAAO,SAASC,UAAT,CAAoBF,EAApB,EAAwB;AAE7B,QAAMG,UAAU,GAAG,EAAnB;AACA,MAAIF,OAAO,GAAGD,EAAE,CAACI,QAAH,EAAd;;AACA,SAAOH,OAAO,KAAKV,WAAnB,EAAgC;AAC9BY,IAAAA,UAAU,CAACE,IAAX,CAAgBN,iBAAiB,CAACC,EAAD,EAAKC,OAAL,CAAjC;AACAA,IAAAA,OAAO,GAAGD,EAAE,CAACI,QAAH,EAAV;AACD;;AACD,SAAOD,UAAU,CAACG,MAAX,GAAoB,IAAIC,KAAJ,CAAUJ,UAAU,CAACK,IAAX,CAAgB,IAAhB,CAAV,CAApB,GAAuD,IAA9D;AACD;AAED,OAAO,SAASC,YAAT,CAAsBT,EAAtB,EAA0B;AAC/B,MAAIA,EAAE,CAACU,KAAP,EAAc;AACZ,UAAMC,KAAK,GAAGT,UAAU,CAACF,EAAD,CAAxB;;AACA,QAAIW,KAAJ,EAAW;AACT,YAAMA,KAAN;AACD;AACF;AACF","sourcesContent":["// Helper definitions for validation of webgl parameters\n/* eslint-disable no-inline-comments, max-len */\n\n// Errors - Constants returned from getError().\nconst GL_NO_ERROR = 0; // Returned from getError.\nconst GL_INVALID_ENUM = 0x0500; //  Returned from getError.\nconst GL_INVALID_VALUE = 0x0501; //  Returned from getError.\nconst GL_INVALID_OPERATION = 0x0502; //  Returned from getError.\nconst GL_OUT_OF_MEMORY = 0x0505; //  Returned from getError.\nconst GL_CONTEXT_LOST_WEBGL = 0x9242; //  Returned from getError.\nconst GL_INVALID_FRAMEBUFFER_OPERATION = 0x0506;\n\n// GL errors\n\nconst GL_ERROR_MESSAGES = {\n  //  If the WebGL context is lost, this error is returned on the\n  // first call to getError. Afterwards and until the context has been\n  // restored, it returns gl.NO_ERROR.\n  [GL_CONTEXT_LOST_WEBGL]: 'WebGL context lost',\n  // An unacceptable value has been specified for an enumerated argument.\n  [GL_INVALID_ENUM]: 'WebGL invalid enumerated argument',\n  // A numeric argument is out of range.\n  [GL_INVALID_VALUE]: 'WebGL invalid value',\n  // The specified command is not allowed for the current state.\n  [GL_INVALID_OPERATION]: 'WebGL invalid operation',\n  // The currently bound framebuffer is not framebuffer complete\n  // when trying to render to or to read from it.\n  [GL_INVALID_FRAMEBUFFER_OPERATION]: 'WebGL invalid framebuffer operation',\n  // Not enough memory is left to execute the command.\n  [GL_OUT_OF_MEMORY]: 'WebGL out of memory'\n};\n\nfunction glGetErrorMessage(gl, glError) {\n  return GL_ERROR_MESSAGES[glError] || `WebGL unknown error ${glError}`;\n}\n\n// Returns an Error representing the Latest webGl error or null\nexport function glGetError(gl) {\n  // Loop to ensure all errors are cleared\n  const errorStack = [];\n  let glError = gl.getError();\n  while (glError !== GL_NO_ERROR) {\n    errorStack.push(glGetErrorMessage(gl, glError));\n    glError = gl.getError();\n  }\n  return errorStack.length ? new Error(errorStack.join('\\n')) : null;\n}\n\nexport function glCheckError(gl) {\n  if (gl.debug) {\n    const error = glGetError(gl);\n    if (error) {\n      throw error;\n    }\n  }\n}\n"],"file":"get-error.js"}

package/dist/webgl-utils/index.d.ts

@@ -0,0 +1,5 @@
+export { requestAnimationFrame, cancelAnimationFrame } from './request-animation-frame';
+export { getGLTypeFromTypedArray, getTypedArrayFromGLType, flipRows, scalePixels } from './typed-array-utils';
+export { getKeyValue, getKey, getKeyType } from './constants-to-keys';
+export { cloneTextureFrom } from './texture-utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/webgl-utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/webgl-utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,qBAAqB,EAAE,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAEtF,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,QAAQ,EACR,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAC,MAAM,qBAAqB,CAAC;AAEpE,OAAO,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC"}

package/dist/webgl-utils/index.js

@@ -0,0 +1,5 @@
+export { requestAnimationFrame, cancelAnimationFrame } from './request-animation-frame';
+export { getGLTypeFromTypedArray, getTypedArrayFromGLType, flipRows, scalePixels } from './typed-array-utils';
+export { getKeyValue, getKey, getKeyType } from './constants-to-keys';
+export { cloneTextureFrom } from './texture-utils';
+//# sourceMappingURL=index.js.map

package/dist/webgl-utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/webgl-utils/index.ts"],"names":["requestAnimationFrame","cancelAnimationFrame","getGLTypeFromTypedArray","getTypedArrayFromGLType","flipRows","scalePixels","getKeyValue","getKey","getKeyType","cloneTextureFrom"],"mappings":"AAAA,SAAQA,qBAAR,EAA+BC,oBAA/B,QAA0D,2BAA1D;AAEA,SACEC,uBADF,EAEEC,uBAFF,EAGEC,QAHF,EAIEC,WAJF,QAKO,qBALP;AAOA,SAAQC,WAAR,EAAqBC,MAArB,EAA6BC,UAA7B,QAA8C,qBAA9C;AAEA,SAAQC,gBAAR,QAA+B,iBAA/B","sourcesContent":["export {requestAnimationFrame, cancelAnimationFrame} from './request-animation-frame';\n\nexport {\n  getGLTypeFromTypedArray,\n  getTypedArrayFromGLType,\n  flipRows,\n  scalePixels\n} from './typed-array-utils';\n\nexport {getKeyValue, getKey, getKeyType} from './constants-to-keys';\n\nexport {cloneTextureFrom} from './texture-utils';\n"],"file":"index.js"}

package/dist/webgl-utils/parse-shader-compiler-log.d.ts

@@ -0,0 +1,8 @@
+import type { CompilerMessage } from '@luma.gl/shadertools';
+/**
+ * Parse a WebGL-format GLSL compilation log into an array of WebGPU style message records.
+ * This follows documented WebGL conventions for compilation logs.
+ * Based on https://github.com/wwwtyro/gl-format-compiler-error (public domain)
+ */
+export declare function parseShaderCompilerLog(errLog: string): readonly CompilerMessage[];
+//# sourceMappingURL=parse-shader-compiler-log.d.ts.map

package/dist/webgl-utils/parse-shader-compiler-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-shader-compiler-log.d.ts","sourceRoot":"","sources":["../../src/webgl-utils/parse-shader-compiler-log.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAI1D;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAI,SAAS,eAAe,EAAE,CAqClF"}

package/dist/webgl-utils/parse-shader-compiler-log.js

@@ -0,0 +1,37 @@
+const MESSAGE_TYPES = ['warning', 'error', 'info'];
+export function parseShaderCompilerLog(errLog) {
+  const lines = errLog.split(/\r?\n/);
+  const messages = [];
+
+  for (const line of lines) {
+    if (line.length <= 1) {
+      continue;
+    }
+
+    const segments = line.split(':');
+    const [messageType, linePosition, lineNumber, ...rest] = segments;
+    let lineNum = parseInt(lineNumber, 10);
+
+    if (isNaN(lineNum)) {
+      lineNum = 0;
+    }
+
+    let linePos = parseInt(linePosition, 10);
+
+    if (isNaN(linePos)) {
+      linePos = 0;
+    }
+
+    const lowerCaseType = messageType.toLowerCase();
+    const type = MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info';
+    messages.push({
+      message: rest.join(':').trim(),
+      type,
+      lineNum,
+      linePos
+    });
+  }
+
+  return messages;
+}
+//# sourceMappingURL=parse-shader-compiler-log.js.map

package/dist/webgl-utils/parse-shader-compiler-log.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/webgl-utils/parse-shader-compiler-log.ts"],"names":["MESSAGE_TYPES","parseShaderCompilerLog","errLog","lines","split","messages","line","length","segments","messageType","linePosition","lineNumber","rest","lineNum","parseInt","isNaN","linePos","lowerCaseType","toLowerCase","type","includes","push","message","join","trim"],"mappings":"AAGA,MAAMA,aAAa,GAAG,CAAC,SAAD,EAAY,OAAZ,EAAqB,MAArB,CAAtB;AAOA,OAAO,SAASC,sBAAT,CAAgCC,MAAhC,EAA6E;AAElF,QAAMC,KAAK,GAAGD,MAAM,CAACE,KAAP,CAAa,OAAb,CAAd;AAEA,QAAMC,QAA2B,GAAG,EAApC;;AAEA,OAAK,MAAMC,IAAX,IAAmBH,KAAnB,EAA0B;AACxB,QAAIG,IAAI,CAACC,MAAL,IAAe,CAAnB,EAAsB;AACpB;AACD;;AAED,UAAMC,QAAkB,GAAGF,IAAI,CAACF,KAAL,CAAW,GAAX,CAA3B;AACA,UAAM,CAACK,WAAD,EAAcC,YAAd,EAA4BC,UAA5B,EAAwC,GAAGC,IAA3C,IAAmDJ,QAAzD;AAEA,QAAIK,OAAO,GAAGC,QAAQ,CAACH,UAAD,EAAa,EAAb,CAAtB;;AACA,QAAII,KAAK,CAACF,OAAD,CAAT,EAAoB;AAClBA,MAAAA,OAAO,GAAG,CAAV;AACD;;AAED,QAAIG,OAAO,GAAGF,QAAQ,CAACJ,YAAD,EAAe,EAAf,CAAtB;;AACA,QAAIK,KAAK,CAACC,OAAD,CAAT,EAAoB;AAClBA,MAAAA,OAAO,GAAG,CAAV;AACD;;AAGD,UAAMC,aAAa,GAAGR,WAAW,CAACS,WAAZ,EAAtB;AACA,UAAMC,IAAI,GAAInB,aAAa,CAACoB,QAAd,CAAuBH,aAAvB,IAAwCA,aAAxC,GAAwD,MAAtE;AAEAZ,IAAAA,QAAQ,CAACgB,IAAT,CAAc;AACZC,MAAAA,OAAO,EAAEV,IAAI,CAACW,IAAL,CAAU,GAAV,EAAeC,IAAf,EADG;AAEZL,MAAAA,IAFY;AAGZN,MAAAA,OAHY;AAIZG,MAAAA;AAJY,KAAd;AAMD;;AAED,SAAOX,QAAP;AACD","sourcesContent":["// luma.gl, MIT license\nimport type {CompilerMessage} from '@luma.gl/shadertools';\n\nconst MESSAGE_TYPES = ['warning', 'error', 'info'];\n\n/**\n * Parse a WebGL-format GLSL compilation log into an array of WebGPU style message records.\n * This follows documented WebGL conventions for compilation logs.\n * Based on https://github.com/wwwtyro/gl-format-compiler-error (public domain)\n */\nexport function parseShaderCompilerLog(errLog: string) : readonly CompilerMessage[] {\n  // Parse the error - note: browser and driver dependent\n  const lines = errLog.split(/\\r?\\n/);\n\n  const messages: CompilerMessage[] = [];\n\n  for (const line of lines) {\n    if (line.length <= 1) {\n      continue;\n    }\n\n    const segments: string[] = line.split(':');\n    const [messageType, linePosition, lineNumber, ...rest] = segments;\n\n    let lineNum = parseInt(lineNumber, 10);\n    if (isNaN(lineNum)) {\n      lineNum = 0;\n    }\n\n    let linePos = parseInt(linePosition, 10);\n    if (isNaN(linePos)) {\n      linePos = 0;\n    }\n\n    // Ensure supported type\n    const lowerCaseType = messageType.toLowerCase();\n    const type = (MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info') as 'warning' | 'error' | 'info';\n\n    messages.push({\n      message: rest.join(':').trim(),\n      type,\n      lineNum,\n      linePos // TODO\n    })\n  }\n\n  return messages;\n}\n"],"file":"parse-shader-compiler-log.js"}

package/dist/webgl-utils/request-animation-frame.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export declare function requestAnimationFrame(callback: any): number | NodeJS.Timeout;
+export declare function cancelAnimationFrame(timerId: any): void;
+//# sourceMappingURL=request-animation-frame.d.ts.map

package/dist/webgl-utils/request-animation-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-animation-frame.d.ts","sourceRoot":"","sources":["../../src/webgl-utils/request-animation-frame.ts"],"names":[],"mappings":";AAGA,wBAAgB,qBAAqB,CAAC,QAAQ,KAAA,GAAG,MAAM,GAAG,MAAM,CAAC,OAAO,CAIvE;AAED,wBAAgB,oBAAoB,CAAC,OAAO,KAAA,GAAG,IAAI,CAIlD"}

package/dist/webgl-utils/request-animation-frame.js

@@ -0,0 +1,7 @@
+export function requestAnimationFrame(callback) {
+  return typeof window !== 'undefined' && window.requestAnimationFrame ? window.requestAnimationFrame(callback) : setTimeout(callback, 1000 / 60);
+}
+export function cancelAnimationFrame(timerId) {
+  return typeof window !== 'undefined' && window.cancelAnimationFrame ? window.cancelAnimationFrame(timerId) : clearTimeout(timerId);
+}
+//# sourceMappingURL=request-animation-frame.js.map

package/dist/webgl-utils/request-animation-frame.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/webgl-utils/request-animation-frame.ts"],"names":["requestAnimationFrame","callback","window","setTimeout","cancelAnimationFrame","timerId","clearTimeout"],"mappings":"AAGA,OAAO,SAASA,qBAAT,CAA+BC,QAA/B,EAAkE;AACvE,SAAO,OAAOC,MAAP,KAAkB,WAAlB,IAAiCA,MAAM,CAACF,qBAAxC,GACHE,MAAM,CAACF,qBAAP,CAA6BC,QAA7B,CADG,GAEHE,UAAU,CAACF,QAAD,EAAW,OAAO,EAAlB,CAFd;AAGD;AAED,OAAO,SAASG,oBAAT,CAA8BC,OAA9B,EAA6C;AAClD,SAAO,OAAOH,MAAP,KAAkB,WAAlB,IAAiCA,MAAM,CAACE,oBAAxC,GACHF,MAAM,CAACE,oBAAP,CAA4BC,OAA5B,CADG,GAEHC,YAAY,CAACD,OAAD,CAFhB;AAGD","sourcesContent":["// Node.js polyfills for requestAnimationFrame and cancelAnimationFrame\n// / <reference types=\"@types/node\" />\n\nexport function requestAnimationFrame(callback): number | NodeJS.Timeout {\n  return typeof window !== 'undefined' && window.requestAnimationFrame\n    ? window.requestAnimationFrame(callback)\n    : setTimeout(callback, 1000 / 60);\n}\n\nexport function cancelAnimationFrame(timerId): void {\n  return typeof window !== 'undefined' && window.cancelAnimationFrame\n    ? window.cancelAnimationFrame(timerId)\n    : clearTimeout(timerId);\n}\n"],"file":"request-animation-frame.js"}

package/dist/webgl-utils/texture-utils.d.ts

@@ -0,0 +1,11 @@
+import Texture2D from '../classes/texture-2d';
+import TextureCube from '../classes/texture-cube';
+import Texture3D from '../classes/texture-3d';
+import Texture from '../classes/texture';
+import Framebuffer, {FramebufferProps} from '../classes/framebuffer';
+
+type TextureType = Texture2D | TextureCube | Texture3D;
+
+export function cloneTextureFrom<T extends TextureType>(refTexture: T, overrides?: any): T;
+
+export function toFramebuffer(texture: Texture, opts?: FramebufferProps): Framebuffer;

package/dist/webgl-utils/texture-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture-utils.d.ts","sourceRoot":"","sources":["../../src/webgl-utils/texture-utils.js"],"names":[],"mappings":"AASA,yDAAyD;AACzD,mEA2BC;AAID,sDAAsD;AACtD,mJAcC"}

package/dist/webgl-utils/texture-utils.js

@@ -0,0 +1,48 @@
+import Texture2D from '../classes/texture-2d';
+import TextureCube from '../classes/texture-cube';
+import Texture3D from '../classes/texture-3d';
+import Framebuffer from '../classes/framebuffer';
+import GL from '@luma.gl/constants';
+import { assert } from '../utils';
+export function cloneTextureFrom(refTexture, overrides) {
+  assert(refTexture instanceof Texture2D || refTexture instanceof TextureCube || refTexture instanceof Texture3D);
+  const TextureType = refTexture.constructor;
+  const {
+    gl,
+    width,
+    height,
+    format,
+    type,
+    dataFormat,
+    border,
+    mipmaps
+  } = refTexture;
+  const textureOptions = Object.assign({
+    width,
+    height,
+    format,
+    type,
+    dataFormat,
+    border,
+    mipmaps
+  }, overrides);
+  return new TextureType(gl, textureOptions);
+}
+export function toFramebuffer(texture, opts) {
+  const {
+    gl,
+    width,
+    height,
+    id
+  } = texture;
+  const framebuffer = new Framebuffer(gl, Object.assign({}, opts, {
+    id: "framebuffer-for-".concat(id),
+    width,
+    height,
+    attachments: {
+      [GL.COLOR_ATTACHMENT0]: texture
+    }
+  }));
+  return framebuffer;
+}
+//# sourceMappingURL=texture-utils.js.map

package/dist/webgl-utils/texture-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/webgl-utils/texture-utils.js"],"names":["Texture2D","TextureCube","Texture3D","Framebuffer","GL","assert","cloneTextureFrom","refTexture","overrides","TextureType","constructor","gl","width","height","format","type","dataFormat","border","mipmaps","textureOptions","Object","assign","toFramebuffer","texture","opts","id","framebuffer","attachments","COLOR_ATTACHMENT0"],"mappings":"AACA,OAAOA,SAAP,MAAsB,uBAAtB;AACA,OAAOC,WAAP,MAAwB,yBAAxB;AACA,OAAOC,SAAP,MAAsB,uBAAtB;AACA,OAAOC,WAAP,MAAwB,wBAAxB;AACA,OAAOC,EAAP,MAAe,oBAAf;AACA,SAAQC,MAAR,QAAqB,UAArB;AAIA,OAAO,SAASC,gBAAT,CAA0BC,UAA1B,EAAsCC,SAAtC,EAAiD;AACtDH,EAAAA,MAAM,CACJE,UAAU,YAAYP,SAAtB,IACEO,UAAU,YAAYN,WADxB,IAEEM,UAAU,YAAYL,SAHpB,CAAN;AAMA,QAAMO,WAAW,GAAGF,UAAU,CAACG,WAA/B;AAEA,QAAM;AAACC,IAAAA,EAAD;AAAKC,IAAAA,KAAL;AAAYC,IAAAA,MAAZ;AAAoBC,IAAAA,MAApB;AAA4BC,IAAAA,IAA5B;AAAkCC,IAAAA,UAAlC;AAA8CC,IAAAA,MAA9C;AAAsDC,IAAAA;AAAtD,MAAiEX,UAAvE;AAEA,QAAMY,cAAc,GAAGC,MAAM,CAACC,MAAP,CACrB;AACET,IAAAA,KADF;AAEEC,IAAAA,MAFF;AAGEC,IAAAA,MAHF;AAIEC,IAAAA,IAJF;AAKEC,IAAAA,UALF;AAMEC,IAAAA,MANF;AAOEC,IAAAA;AAPF,GADqB,EAUrBV,SAVqB,CAAvB;AAeA,SAAO,IAAIC,WAAJ,CAAgBE,EAAhB,EAAoBQ,cAApB,CAAP;AACD;AAKD,OAAO,SAASG,aAAT,CAAuBC,OAAvB,EAAgCC,IAAhC,EAAsC;AAC3C,QAAM;AAACb,IAAAA,EAAD;AAAKC,IAAAA,KAAL;AAAYC,IAAAA,MAAZ;AAAoBY,IAAAA;AAApB,MAA0BF,OAAhC;AACA,QAAMG,WAAW,GAAG,IAAIvB,WAAJ,CAClBQ,EADkB,EAElBS,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkBG,IAAlB,EAAwB;AACtBC,IAAAA,EAAE,4BAAqBA,EAArB,CADoB;AAEtBb,IAAAA,KAFsB;AAGtBC,IAAAA,MAHsB;AAItBc,IAAAA,WAAW,EAAE;AACX,OAACvB,EAAE,CAACwB,iBAAJ,GAAwBL;AADb;AAJS,GAAxB,CAFkB,CAApB;AAWA,SAAOG,WAAP;AACD","sourcesContent":["// TODO: Two subdirectories must not depend on each other (classes vs utils)!\nimport Texture2D from '../classes/texture-2d';\nimport TextureCube from '../classes/texture-cube';\nimport Texture3D from '../classes/texture-3d';\nimport Framebuffer from '../classes/framebuffer';\nimport GL from '@luma.gl/constants';\nimport {assert} from '../utils';\n\n// Clone a new texture object from a reference texture object.\n/** @type {import('./texture-utils').cloneTextureFrom} */\nexport function cloneTextureFrom(refTexture, overrides) {\n  assert(\n    refTexture instanceof Texture2D ||\n      refTexture instanceof TextureCube ||\n      refTexture instanceof Texture3D\n  );\n\n  const TextureType = refTexture.constructor;\n\n  const {gl, width, height, format, type, dataFormat, border, mipmaps} = refTexture;\n\n  const textureOptions = Object.assign(\n    {\n      width,\n      height,\n      format,\n      type,\n      dataFormat,\n      border,\n      mipmaps\n    },\n    overrides\n  );\n\n  // TODO: move this to `Texture` class as instance method and use this.constructor\n  // @ts-expect-error\n  return new TextureType(gl, textureOptions);\n}\n\n// Wraps a given texture into a framebuffer object, that can be further used\n// to read data from the texture object.\n/** @type {import('./texture-utils').toFramebuffer} */\nexport function toFramebuffer(texture, opts) {\n  const {gl, width, height, id} = texture;\n  const framebuffer = new Framebuffer(\n    gl,\n    Object.assign({}, opts, {\n      id: `framebuffer-for-${id}`,\n      width,\n      height,\n      attachments: {\n        [GL.COLOR_ATTACHMENT0]: texture\n      }\n    })\n  );\n  return framebuffer;\n}\n"],"file":"texture-utils.js"}

package/dist/webgl-utils/typed-array-utils.d.ts

@@ -0,0 +1,36 @@
+type TypedArrayConstructor =
+  | Float32ArrayConstructor
+  | Uint16ArrayConstructor
+  | Uint32ArrayConstructor
+  | Uint8ArrayConstructor
+  | Uint8ClampedArrayConstructor
+  | Int8ArrayConstructor
+  | Int16ArrayConstructor
+  | Int32ArrayConstructor;
+
+export function getGLTypeFromTypedArray(arrayOrType: any): any;
+
+export function getTypedArrayFromGLType(
+  glType: any,
+  options?: {
+    clamped?: boolean;
+  }
+): TypedArrayConstructor;
+
+export function flipRows(options: {
+  data: any;
+  width: any;
+  height: any;
+  bytesPerPixel?: number;
+  temp?: any;
+}): void;
+
+export function scalePixels(options: {
+  data: any;
+  width: any;
+  height: any;
+}): {
+  data: Uint8Array;
+  width: number;
+  height: number;
+};

package/dist/webgl-utils/typed-array-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-array-utils.d.ts","sourceRoot":"","sources":["../../src/webgl-utils/typed-array-utils.js"],"names":[],"mappings":"AAMA,2JAuBC;AAMD;;4MAuBC;AAMD;;;;;;SAeC;AAED;;;;;;;;EAYC"}

package/dist/webgl-utils/typed-array-utils.js

@@ -0,0 +1,108 @@
+import GL from '@luma.gl/constants';
+const ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';
+export function getGLTypeFromTypedArray(arrayOrType) {
+  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+
+  switch (type) {
+    case Float32Array:
+      return GL.FLOAT;
+
+    case Uint16Array:
+      return GL.UNSIGNED_SHORT;
+
+    case Uint32Array:
+      return GL.UNSIGNED_INT;
+
+    case Uint8Array:
+      return GL.UNSIGNED_BYTE;
+
+    case Uint8ClampedArray:
+      return GL.UNSIGNED_BYTE;
+
+    case Int8Array:
+      return GL.BYTE;
+
+    case Int16Array:
+      return GL.SHORT;
+
+    case Int32Array:
+      return GL.INT;
+
+    default:
+      throw new Error(ERR_TYPE_DEDUCTION);
+  }
+}
+export function getTypedArrayFromGLType(glType, {
+  clamped = true
+} = {}) {
+  switch (glType) {
+    case GL.FLOAT:
+      return Float32Array;
+
+    case GL.UNSIGNED_SHORT:
+    case GL.UNSIGNED_SHORT_5_6_5:
+    case GL.UNSIGNED_SHORT_4_4_4_4:
+    case GL.UNSIGNED_SHORT_5_5_5_1:
+      return Uint16Array;
+
+    case GL.UNSIGNED_INT:
+      return Uint32Array;
+
+    case GL.UNSIGNED_BYTE:
+      return clamped ? Uint8ClampedArray : Uint8Array;
+
+    case GL.BYTE:
+      return Int8Array;
+
+    case GL.SHORT:
+      return Int16Array;
+
+    case GL.INT:
+      return Int32Array;
+
+    default:
+      throw new Error('Failed to deduce typed array type from GL constant');
+  }
+}
+export function flipRows({
+  data,
+  width,
+  height,
+  bytesPerPixel = 4,
+  temp
+}) {
+  const bytesPerRow = width * bytesPerPixel;
+  temp = temp || new Uint8Array(bytesPerRow);
+
+  for (let y = 0; y < height / 2; ++y) {
+    const topOffset = y * bytesPerRow;
+    const bottomOffset = (height - y - 1) * bytesPerRow;
+    temp.set(data.subarray(topOffset, topOffset + bytesPerRow));
+    data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);
+    data.set(temp, bottomOffset);
+  }
+}
+export function scalePixels({
+  data,
+  width,
+  height
+}) {
+  const newWidth = Math.round(width / 2);
+  const newHeight = Math.round(height / 2);
+  const newData = new Uint8Array(newWidth * newHeight * 4);
+
+  for (let y = 0; y < newHeight; y++) {
+    for (let x = 0; x < newWidth; x++) {
+      for (let c = 0; c < 4; c++) {
+        newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];
+      }
+    }
+  }
+
+  return {
+    data: newData,
+    width: newWidth,
+    height: newHeight
+  };
+}
+//# sourceMappingURL=typed-array-utils.js.map

package/dist/webgl-utils/typed-array-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/webgl-utils/typed-array-utils.js"],"names":["GL","ERR_TYPE_DEDUCTION","getGLTypeFromTypedArray","arrayOrType","type","ArrayBuffer","isView","constructor","Float32Array","FLOAT","Uint16Array","UNSIGNED_SHORT","Uint32Array","UNSIGNED_INT","Uint8Array","UNSIGNED_BYTE","Uint8ClampedArray","Int8Array","BYTE","Int16Array","SHORT","Int32Array","INT","Error","getTypedArrayFromGLType","glType","clamped","UNSIGNED_SHORT_5_6_5","UNSIGNED_SHORT_4_4_4_4","UNSIGNED_SHORT_5_5_5_1","flipRows","data","width","height","bytesPerPixel","temp","bytesPerRow","y","topOffset","bottomOffset","set","subarray","copyWithin","scalePixels","newWidth","Math","round","newHeight","newData","x","c"],"mappings":"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","sourcesContent":["import GL from '@luma.gl/constants';\n\nconst ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';\n\n// Converts TYPED ARRAYS to corresponding GL constant\n// Used to auto deduce gl parameter types\nexport function getGLTypeFromTypedArray(arrayOrType) {\n  // If typed array, look up constructor\n  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;\n  switch (type) {\n    case Float32Array:\n      return GL.FLOAT;\n    case Uint16Array:\n      return GL.UNSIGNED_SHORT;\n    case Uint32Array:\n      return GL.UNSIGNED_INT;\n    case Uint8Array:\n      return GL.UNSIGNED_BYTE;\n    case Uint8ClampedArray:\n      return GL.UNSIGNED_BYTE;\n    case Int8Array:\n      return GL.BYTE;\n    case Int16Array:\n      return GL.SHORT;\n    case Int32Array:\n      return GL.INT;\n    default:\n      throw new Error(ERR_TYPE_DEDUCTION);\n  }\n}\n\n// Converts GL constant to corresponding TYPED ARRAY\n// Used to auto deduce gl parameter types\n\n/* eslint-disable complexity */\nexport function getTypedArrayFromGLType(glType, {clamped = true} = {}) {\n  // Sorted in some order of likelihood to reduce amount of comparisons\n  switch (glType) {\n    case GL.FLOAT:\n      return Float32Array;\n    case GL.UNSIGNED_SHORT:\n    case GL.UNSIGNED_SHORT_5_6_5:\n    case GL.UNSIGNED_SHORT_4_4_4_4:\n    case GL.UNSIGNED_SHORT_5_5_5_1:\n      return Uint16Array;\n    case GL.UNSIGNED_INT:\n      return Uint32Array;\n    case GL.UNSIGNED_BYTE:\n      return clamped ? Uint8ClampedArray : Uint8Array;\n    case GL.BYTE:\n      return Int8Array;\n    case GL.SHORT:\n      return Int16Array;\n    case GL.INT:\n      return Int32Array;\n    default:\n      throw new Error('Failed to deduce typed array type from GL constant');\n  }\n}\n/* eslint-enable complexity */\n\n// Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)\n// https://stackoverflow.com/questions/41969562/\n// how-can-i-flip-the-result-of-webglrenderingcontext-readpixels\nexport function flipRows({data, width, height, bytesPerPixel = 4, temp}) {\n  const bytesPerRow = width * bytesPerPixel;\n\n  // make a temp buffer to hold one row\n  temp = temp || new Uint8Array(bytesPerRow);\n  for (let y = 0; y < height / 2; ++y) {\n    const topOffset = y * bytesPerRow;\n    const bottomOffset = (height - y - 1) * bytesPerRow;\n    // make copy of a row on the top half\n    temp.set(data.subarray(topOffset, topOffset + bytesPerRow));\n    // copy a row from the bottom half to the top\n    data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);\n    // copy the copy of the top half row to the bottom half\n    data.set(temp, bottomOffset);\n  }\n}\n\nexport function scalePixels({data, width, height}) {\n  const newWidth = Math.round(width / 2);\n  const newHeight = Math.round(height / 2);\n  const newData = new Uint8Array(newWidth * newHeight * 4);\n  for (let y = 0; y < newHeight; y++) {\n    for (let x = 0; x < newWidth; x++) {\n      for (let c = 0; c < 4; c++) {\n        newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];\n      }\n    }\n  }\n  return {data: newData, width: newWidth, height: newHeight};\n}\n"],"file":"typed-array-utils.js"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/webgl",
-  "version": "8.5.7",
+  "version": "8.6.0-alpha.1",
   "description": "WebGL2 Classes",
   "license": "MIT",
   "publishConfig": {
@@ -16,9 +16,9 @@
     "animation",
     "3d"
   ],
-  "types": "src/index.d.ts",
-  "main": "dist/es5/index.js",
-  "module": "dist/esm/index.js",
+  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
   "files": [
     "src",
     "dist",
@@ -30,14 +30,15 @@
     "gl/wrap": false
   },
   "scripts": {
-    "pre-build": "npm run build-bundle && npm run build-bundle -- --env.dev",
+    "pre-build": "npm run build-bundle",
     "build-bundle": "webpack --display=minimal --config ../../scripts/bundle.config.js"
   },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "@luma.gl/constants": "8.5.7",
-    "@luma.gl/gltools": "8.5.7",
+    "@luma.gl/api": "8.6.0-alpha.1",
+    "@luma.gl/constants": "8.6.0-alpha.1",
+    "@luma.gl/gltools": "8.6.0-alpha.1",
     "probe.gl": "^3.4.0"
   },
-  "gitHead": "c97d3ae06b77c35fd3a40ca980028c31d09c149e"
+  "gitHead": "e3895ce8a6dd376394c6662bb8cf0e1ad1f233f3"
 }

package/src/bundle.ts

@@ -0,0 +1,4 @@
+// @ts-nocheck
+const moduleExports = require('./index');
+globalThis.luma = globalThis.luma || {};
+module.exports = Object.assign(globalThis.luma, moduleExports);

package/src/classes/accessor.js

@@ -1,7 +1,6 @@
 import GL from '@luma.gl/constants';
-import {getTypedArrayFromGLType} from '../webgl-utils/typed-array-utils';
-import {assert} from '../utils/assert';
-import {checkProps} from '../utils/check-props';
+import {getTypedArrayFromGLType} from '../webgl-utils';
+import {checkProps, assert} from '../utils';
 
 const DEFAULT_ACCESSOR_VALUES = {
   offset: 0,
@@ -45,7 +44,7 @@ export default class Accessor {
   }
 
   constructor(...accessors) {
-    accessors.forEach(accessor => this._assign(accessor)); // Merge in sequence
+    accessors.forEach((accessor) => this._assign(accessor)); // Merge in sequence
     Object.freeze(this);
   }
 

package/src/classes/accessor.ts.disabled

@@ -0,0 +1,159 @@
+import GL from '@luma.gl/constants';
+import {getTypedArrayFromGLType} from '../webgl-utils';
+import {checkProps, assert} from '../utils';
+import {Buffer} from '@luma.gl/core/';
+
+export interface AccessorObject {
+  buffer?: Buffer;
+  offset?: number;
+  stride?: number;
+  type?: number;
+  size?: number;
+  divisor?: number;
+  normalized?: boolean;
+  integer?: boolean;
+  index?: number;
+  /** @deprecated Use .divisor */
+  instanced?: boolean;
+  /** @deprecated Use .divisor */
+  isInstanced?: boolean;
+}
+
+const DEFAULT_ACCESSOR_VALUES = {
+  offset: 0,
+  stride: 0,
+  type: GL.FLOAT,
+  size: 1,
+  divisor: 0,
+  normalized: false,
+  integer: false
+};
+
+const PROP_CHECKS = {
+  deprecatedProps: {
+    instanced: 'divisor',
+    isInstanced: 'divisor'
+  }
+};
+
+
+// @ts-nocheck members are added dynamically
+export default class Accessor {
+  // buffer: Buffer | undefined = undefined;
+  // index: number;
+
+  // offset: number;
+  // stride: number;
+  // type: number;
+  // size: number;
+  // divisor: number;
+  // normalized: boolean;
+  // integer: boolean;
+
+  static getBytesPerElement(accessor): number {
+    // TODO: using `FLOAT` when type is not specified,
+    // ensure this assumption is valid or force API to specify type.
+    const ArrayType = getTypedArrayFromGLType(accessor.type || GL.FLOAT);
+    return ArrayType.BYTES_PER_ELEMENT;
+  }
+
+  static getBytesPerVertex(accessor): number {
+    assert(accessor.size);
+    // TODO: using `FLOAT` when type is not specified,
+    // ensure this assumption is valid or force API to specify type.
+    const ArrayType = getTypedArrayFromGLType(accessor.type || GL.FLOAT);
+    return ArrayType.BYTES_PER_ELEMENT * accessor.size;
+  }
+
+  // Combines (merges) a list of accessors. On top of default values
+  // Usually [programAccessor, bufferAccessor, appAccessor]
+  // All props will be set in the returned object.
+  // TODO check for conflicts between values in the supplied accessors
+  static resolve(...accessors): Accessor {
+    return new Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]); // Default values
+  }
+
+  constructor(...accessors: any[]) {
+    accessors.forEach((accessor) => this._assign(accessor)); // Merge in sequence
+    Object.freeze(this);
+  }
+
+  toString(): string {
+    return JSON.stringify(this);
+  }
+
+  // ACCESSORS
+
+  // TODO - remove>
+  get BYTES_PER_ELEMENT(): number {
+    return Accessor.getBytesPerElement(this);
+  }
+
+  get BYTES_PER_VERTEX(): number {
+    return Accessor.getBytesPerVertex(this);
+  }
+
+  // PRIVATE
+
+  // eslint-disable-next-line complexity, max-statements
+  _assign(props: AccessorObject = {}) {
+    props = checkProps('Accessor', props, PROP_CHECKS);
+
+    if (props.type !== undefined) {
+      this.type = props.type;
+
+      // Auto-deduce integer type?
+      if (props.type === GL.INT || props.type === GL.UNSIGNED_INT) {
+        this.integer = true;
+      }
+    }
+    if (props.size !== undefined) {
+      this.size = props.size;
+    }
+    if (props.offset !== undefined) {
+      this.offset = props.offset;
+    }
+    if (props.stride !== undefined) {
+      this.stride = props.stride;
+    }
+    if (props.normalized !== undefined) {
+      this.normalized = props.normalized;
+    }
+    if (props.integer !== undefined) {
+      this.integer = props.integer;
+    }
+
+    // INSTANCE DIVISOR
+    if (props.divisor !== undefined) {
+      this.divisor = props.divisor;
+    }
+
+    // Buffer is optional
+    if (props.buffer !== undefined) {
+      this.buffer = props.buffer;
+    }
+
+    // The binding index (for binding e.g. Transform feedbacks and Uniform buffers)
+    // TODO - should this be part of accessor?
+    if (props.index !== undefined) {
+      if (typeof props.index === 'boolean') {
+        this.index = props.index ? 1 : 0;
+      } else {
+        this.index = props.index;
+      }
+    }
+
+    // DEPRECATED
+    if (props.instanced !== undefined) {
+      this.divisor = props.instanced ? 1 : 0;
+    }
+    if (props.isInstanced !== undefined) {
+      this.divisor = props.isInstanced ? 1 : 0;
+    }
+
+    return this;
+  }
+}
+
+// TEST EXPORTS
+export {DEFAULT_ACCESSOR_VALUES};

package/src/classes/{clear.js → clear.ts}

@@ -1,5 +1,6 @@
 import {assertWebGL2Context, withParameters} from '@luma.gl/gltools';
-import {assert} from '../utils/assert';
+import {assert} from '../utils';
+import Framebuffer from './framebuffer';
 
 // Should collapse during minification
 const GL_DEPTH_BUFFER_BIT = 0x00000100;
@@ -14,10 +15,13 @@ const GL_DEPTH_STENCIL = 0x84f9;
 // Should disappear if asserts are removed
 const ERR_ARGUMENTS = 'clear: bad arguments';
 
-// Optionally clears depth, color and stencil buffers
-/** @type {import('./clear').clear} */
-export function clear(gl, {framebuffer = null, color = null, depth = null, stencil = null} = {}) {
-  const parameters = {};
+/** Optionally clears depth, color and stencil buffers */
+export function clear(
+  gl: WebGLRenderingContext,
+  options?: {framebuffer?: Framebuffer; color?: any; depth?: any; stencil?: any}
+): void {
+  const {framebuffer = null, color = null, depth = null, stencil = null} = options || {};
+  const parameters: any = {};
 
   if (framebuffer) {
     parameters.framebuffer = framebuffer;
@@ -54,14 +58,14 @@ export function clear(gl, {framebuffer = null, color = null, depth = null, stenc
   });
 }
 
-// WebGL2 - clear a specific drawing buffer
-/** @type {import('./clear').clearBuffer} */
+/** WebGL2 - clear a specific drawing buffer */
 export function clearBuffer(
-  gl,
-  {framebuffer = null, buffer = GL_COLOR, drawBuffer = 0, value = [0, 0, 0, 0]} = {}
+  gl: any,
+  options?: {framebuffer?: Framebuffer; buffer?: any; drawBuffer?: any; value?: any}
 ) {
   assertWebGL2Context(gl);
 
+  const {framebuffer = null, buffer = GL_COLOR, drawBuffer = 0, value = [0, 0, 0, 0]} = options || {};
   withParameters(gl, {framebuffer}, () => {
     // Method selection per OpenGL ES 3 docs
     switch (buffer) {