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

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

@@ -5,61 +5,61 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "requestAnimationFrame", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _requestAnimationFrame.requestAnimationFrame;
   }
 });
 Object.defineProperty(exports, "cancelAnimationFrame", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _requestAnimationFrame.cancelAnimationFrame;
   }
 });
 Object.defineProperty(exports, "getGLTypeFromTypedArray", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _typedArrayUtils.getGLTypeFromTypedArray;
   }
 });
 Object.defineProperty(exports, "getTypedArrayFromGLType", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _typedArrayUtils.getTypedArrayFromGLType;
   }
 });
 Object.defineProperty(exports, "flipRows", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _typedArrayUtils.flipRows;
   }
 });
 Object.defineProperty(exports, "scalePixels", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _typedArrayUtils.scalePixels;
   }
 });
 Object.defineProperty(exports, "getKeyValue", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _constantsToKeys.getKeyValue;
   }
 });
 Object.defineProperty(exports, "getKey", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _constantsToKeys.getKey;
   }
 });
 Object.defineProperty(exports, "getKeyType", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _constantsToKeys.getKeyType;
   }
 });
 Object.defineProperty(exports, "cloneTextureFrom", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _textureUtils.cloneTextureFrom;
   }
 });

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

@@ -1,42 +1,70 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parseShaderCompilerLog = parseShaderCompilerLog;
-const MESSAGE_TYPES = ['warning', 'error', 'info'];
+
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var MESSAGE_TYPES = ['warning', 'error', 'info'];
 
 function parseShaderCompilerLog(errLog) {
-  const lines = errLog.split(/\r?\n/);
-  const messages = [];
+  var lines = errLog.split(/\r?\n/);
+  var messages = [];
 
-  for (const line of lines) {
-    if (line.length <= 1) {
-      continue;
-    }
+  var _iterator = _createForOfIteratorHelper(lines),
+      _step;
 
-    const segments = line.split(':');
-    const [messageType, linePosition, lineNumber, ...rest] = segments;
-    let lineNum = parseInt(lineNumber, 10);
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var line = _step.value;
 
-    if (isNaN(lineNum)) {
-      lineNum = 0;
-    }
+      if (line.length <= 1) {
+        continue;
+      }
 
-    let linePos = parseInt(linePosition, 10);
+      var segments = line.split(':');
 
-    if (isNaN(linePos)) {
-      linePos = 0;
-    }
+      var _segments = (0, _toArray2.default)(segments),
+          messageType = _segments[0],
+          linePosition = _segments[1],
+          lineNumber = _segments[2],
+          rest = _segments.slice(3);
+
+      var lineNum = parseInt(lineNumber, 10);
+
+      if (isNaN(lineNum)) {
+        lineNum = 0;
+      }
 
-    const lowerCaseType = messageType.toLowerCase();
-    const type = MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info';
-    messages.push({
-      message: rest.join(':').trim(),
-      type,
-      lineNum,
-      linePos
-    });
+      var linePos = parseInt(linePosition, 10);
+
+      if (isNaN(linePos)) {
+        linePos = 0;
+      }
+
+      var lowerCaseType = messageType.toLowerCase();
+      var type = MESSAGE_TYPES.includes(lowerCaseType) ? lowerCaseType : 'info';
+      messages.push({
+        message: rest.join(':').trim(),
+        type: type,
+        lineNum: lineNum,
+        linePos: linePos
+      });
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
 
   return messages;

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

@@ -1 +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;;AAOO,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"}
+{"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,IAAMA,aAAa,GAAG,CAAC,SAAD,EAAY,OAAZ,EAAqB,MAArB,CAAtB;;AAOO,SAASC,sBAAT,CAAgCC,MAAhC,EAA6E;AAElF,MAAMC,KAAK,GAAGD,MAAM,CAACE,KAAP,CAAa,OAAb,CAAd;AAEA,MAAMC,QAA2B,GAAG,EAApC;;AAJkF,6CAM/DF,KAN+D;AAAA;;AAAA;AAMlF,wDAA0B;AAAA,UAAfG,IAAe;;AACxB,UAAIA,IAAI,CAACC,MAAL,IAAe,CAAnB,EAAsB;AACpB;AACD;;AAED,UAAMC,QAAkB,GAAGF,IAAI,CAACF,KAAL,CAAW,GAAX,CAA3B;;AACA,6CAAyDI,QAAzD;AAAA,UAAOC,WAAP;AAAA,UAAoBC,YAApB;AAAA,UAAkCC,UAAlC;AAAA,UAAiDC,IAAjD;;AAEA,UAAIC,OAAO,GAAGC,QAAQ,CAACH,UAAD,EAAa,EAAb,CAAtB;;AACA,UAAII,KAAK,CAACF,OAAD,CAAT,EAAoB;AAClBA,QAAAA,OAAO,GAAG,CAAV;AACD;;AAED,UAAIG,OAAO,GAAGF,QAAQ,CAACJ,YAAD,EAAe,EAAf,CAAtB;;AACA,UAAIK,KAAK,CAACC,OAAD,CAAT,EAAoB;AAClBA,QAAAA,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,MAAAA,QAAQ,CAACgB,IAAT,CAAc;AACZC,QAAAA,OAAO,EAAEV,IAAI,CAACW,IAAL,CAAU,GAAV,EAAeC,IAAf,EADG;AAEZL,QAAAA,IAAI,EAAJA,IAFY;AAGZN,QAAAA,OAAO,EAAPA,OAHY;AAIZG,QAAAA,OAAO,EAAPA;AAJY,OAAd;AAMD;AAlCiF;AAAA;AAAA;AAAA;AAAA;;AAoClF,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/es5/webgl-utils/texture-utils.js

@@ -8,6 +8,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.cloneTextureFrom = cloneTextureFrom;
 exports.toFramebuffer = toFramebuffer;
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _api = require("@luma.gl/api");
+
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+
 var _texture2d = _interopRequireDefault(require("../classes/texture-2d"));
 
 var _textureCube = _interopRequireDefault(require("../classes/texture-cube"));
@@ -16,49 +22,39 @@ var _texture3d = _interopRequireDefault(require("../classes/texture-3d"));
 
 var _framebuffer = _interopRequireDefault(require("../classes/framebuffer"));
 
-var _constants = _interopRequireDefault(require("@luma.gl/constants"));
-
-var _utils = require("../utils");
-
 function cloneTextureFrom(refTexture, overrides) {
-  (0, _utils.assert)(refTexture instanceof _texture2d.default || refTexture instanceof _textureCube.default || refTexture instanceof _texture3d.default);
-  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
+  (0, _api.assert)(refTexture instanceof _texture2d.default || refTexture instanceof _textureCube.default || refTexture instanceof _texture3d.default);
+  var TextureType = refTexture.constructor;
+  var gl = refTexture.gl,
+      width = refTexture.width,
+      height = refTexture.height,
+      format = refTexture.format,
+      type = refTexture.type,
+      dataFormat = refTexture.dataFormat,
+      border = refTexture.border,
+      mipmaps = refTexture.mipmaps;
+  var textureOptions = Object.assign({
+    width: width,
+    height: height,
+    format: format,
+    type: type,
+    dataFormat: dataFormat,
+    border: border,
+    mipmaps: mipmaps
   }, overrides);
   return new TextureType(gl, textureOptions);
 }
 
 function toFramebuffer(texture, opts) {
-  const {
-    gl,
-    width,
-    height,
-    id
-  } = texture;
-  const framebuffer = new _framebuffer.default(gl, Object.assign({}, opts, {
+  var gl = texture.gl,
+      width = texture.width,
+      height = texture.height,
+      id = texture.id;
+  var framebuffer = new _framebuffer.default(gl, Object.assign({}, opts, {
     id: "framebuffer-for-".concat(id),
-    width,
-    height,
-    attachments: {
-      [_constants.default.COLOR_ATTACHMENT0]: texture
-    }
+    width: width,
+    height: height,
+    attachments: (0, _defineProperty2.default)({}, _constants.default.COLOR_ATTACHMENT0, texture)
   }));
   return framebuffer;
 }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/webgl-utils/texture-utils.js"],"names":["cloneTextureFrom","refTexture","overrides","Texture2D","TextureCube","Texture3D","TextureType","constructor","gl","width","height","format","type","dataFormat","border","mipmaps","textureOptions","Object","assign","toFramebuffer","texture","opts","id","framebuffer","Framebuffer","attachments","GL","COLOR_ATTACHMENT0"],"mappings":";;;;;;;;;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAIO,SAASA,gBAAT,CAA0BC,UAA1B,EAAsCC,SAAtC,EAAiD;AACtD,qBACED,UAAU,YAAYE,kBAAtB,IACEF,UAAU,YAAYG,oBADxB,IAEEH,UAAU,YAAYI,kBAH1B;AAMA,QAAMC,WAAW,GAAGL,UAAU,CAACM,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,MAAiEd,UAAvE;AAEA,QAAMe,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,EAUrBb,SAVqB,CAAvB;AAeA,SAAO,IAAII,WAAJ,CAAgBE,EAAhB,EAAoBQ,cAApB,CAAP;AACD;;AAKM,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,IAAIC,oBAAJ,CAClBhB,EADkB,EAElBS,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkBG,IAAlB,EAAwB;AACtBC,IAAAA,EAAE,4BAAqBA,EAArB,CADoB;AAEtBb,IAAAA,KAFsB;AAGtBC,IAAAA,MAHsB;AAItBe,IAAAA,WAAW,EAAE;AACX,OAACC,mBAAGC,iBAAJ,GAAwBP;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"}
+{"version":3,"sources":["../../../src/webgl-utils/texture-utils.ts"],"names":["cloneTextureFrom","refTexture","overrides","Texture2D","TextureCube","Texture3D","TextureType","constructor","gl","width","height","format","type","dataFormat","border","mipmaps","textureOptions","Object","assign","toFramebuffer","texture","opts","id","framebuffer","Framebuffer","attachments","GL","COLOR_ATTACHMENT0"],"mappings":";;;;;;;;;;;;AACA;;AACA;;AAEA;;AACA;;AACA;;AACA;;AAKO,SAASA,gBAAT,CAAiDC,UAAjD,EAAgEC,SAAhE,EAAoF;AACzF,mBACED,UAAU,YAAYE,kBAAtB,IACEF,UAAU,YAAYG,oBADxB,IAEEH,UAAU,YAAYI,kBAH1B;AAMA,MAAMC,WAAW,GAAGL,UAAU,CAACM,WAA/B;AAEA,MAAOC,EAAP,GAAuEP,UAAvE,CAAOO,EAAP;AAAA,MAAWC,KAAX,GAAuER,UAAvE,CAAWQ,KAAX;AAAA,MAAkBC,MAAlB,GAAuET,UAAvE,CAAkBS,MAAlB;AAAA,MAA0BC,MAA1B,GAAuEV,UAAvE,CAA0BU,MAA1B;AAAA,MAAkCC,IAAlC,GAAuEX,UAAvE,CAAkCW,IAAlC;AAAA,MAAwCC,UAAxC,GAAuEZ,UAAvE,CAAwCY,UAAxC;AAAA,MAAoDC,MAApD,GAAuEb,UAAvE,CAAoDa,MAApD;AAAA,MAA4DC,OAA5D,GAAuEd,UAAvE,CAA4Dc,OAA5D;AAEA,MAAMC,cAAc,GAAGC,MAAM,CAACC,MAAP,CACrB;AACET,IAAAA,KAAK,EAALA,KADF;AAEEC,IAAAA,MAAM,EAANA,MAFF;AAGEC,IAAAA,MAAM,EAANA,MAHF;AAIEC,IAAAA,IAAI,EAAJA,IAJF;AAKEC,IAAAA,UAAU,EAAVA,UALF;AAMEC,IAAAA,MAAM,EAANA,MANF;AAOEC,IAAAA,OAAO,EAAPA;AAPF,GADqB,EAUrBb,SAVqB,CAAvB;AAeA,SAAO,IAAII,WAAJ,CAAgBE,EAAhB,EAAoBQ,cAApB,CAAP;AACD;;AAMM,SAASG,aAAT,CAAuBC,OAAvB,EAAyCC,IAAzC,EAA+E;AACpF,MAAOb,EAAP,GAAgCY,OAAhC,CAAOZ,EAAP;AAAA,MAAWC,KAAX,GAAgCW,OAAhC,CAAWX,KAAX;AAAA,MAAkBC,MAAlB,GAAgCU,OAAhC,CAAkBV,MAAlB;AAAA,MAA0BY,EAA1B,GAAgCF,OAAhC,CAA0BE,EAA1B;AACA,MAAMC,WAAW,GAAG,IAAIC,oBAAJ,CAClBhB,EADkB,EAElBS,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkBG,IAAlB,EAAwB;AACtBC,IAAAA,EAAE,4BAAqBA,EAArB,CADoB;AAEtBb,IAAAA,KAAK,EAALA,KAFsB;AAGtBC,IAAAA,MAAM,EAANA,MAHsB;AAItBe,IAAAA,WAAW,oCACRC,mBAAGC,iBADK,EACeP,OADf;AAJW,GAAxB,CAFkB,CAApB;AAWA,SAAOG,WAAP;AACD","sourcesContent":["// TODO: Two subdirectories must not depend on each other (classes vs utils)!\nimport {assert} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport Texture from '../classes/texture';\nimport Texture2D from '../classes/texture-2d';\nimport TextureCube from '../classes/texture-cube';\nimport Texture3D from '../classes/texture-3d';\nimport Framebuffer, {FramebufferProps} from '../classes/framebuffer';\n\ntype TextureType = Texture2D | TextureCube | Texture3D;\n\n/** Clone a new texture object from a reference texture object. */\nexport function cloneTextureFrom<T extends TextureType>(refTexture: T, overrides?: any): T {\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/**\n * Wraps a given texture into a framebuffer object, that can be further used\n * to read data from the texture object.\n */ \nexport function toFramebuffer(texture: Texture, opts?: FramebufferProps): Framebuffer {\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/es5/webgl-utils/typed-array-utils.js

@@ -12,10 +12,10 @@ exports.scalePixels = scalePixels;
 
 var _constants = _interopRequireDefault(require("@luma.gl/constants"));
 
-const ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';
+var ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';
 
 function getGLTypeFromTypedArray(arrayOrType) {
-  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+  var type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
 
   switch (type) {
     case Float32Array:
@@ -47,9 +47,11 @@ function getGLTypeFromTypedArray(arrayOrType) {
   }
 }
 
-function getTypedArrayFromGLType(glType, {
-  clamped = true
-} = {}) {
+function getTypedArrayFromGLType(glType, options) {
+  var _ref = options || {},
+      _ref$clamped = _ref.clamped,
+      clamped = _ref$clamped === void 0 ? true : _ref$clamped;
+
   switch (glType) {
     case _constants.default.FLOAT:
       return Float32Array;
@@ -80,37 +82,36 @@ function getTypedArrayFromGLType(glType, {
   }
 }
 
-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));
+function flipRows(options) {
+  var data = options.data,
+      width = options.width,
+      height = options.height,
+      _options$bytesPerPixe = options.bytesPerPixel,
+      bytesPerPixel = _options$bytesPerPixe === void 0 ? 4 : _options$bytesPerPixe,
+      temp = options.temp;
+  var bytesPerRow = width * bytesPerPixel;
+  var tempBuffer = temp || new Uint8Array(bytesPerRow);
+
+  for (var y = 0; y < height / 2; ++y) {
+    var topOffset = y * bytesPerRow;
+    var bottomOffset = (height - y - 1) * bytesPerRow;
+    tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));
     data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);
-    data.set(temp, bottomOffset);
+    data.set(tempBuffer, bottomOffset);
   }
 }
 
-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++) {
+function scalePixels(options) {
+  var data = options.data,
+      width = options.width,
+      height = options.height;
+  var newWidth = Math.round(width / 2);
+  var newHeight = Math.round(height / 2);
+  var newData = new Uint8Array(newWidth * newHeight * 4);
+
+  for (var y = 0; y < newHeight; y++) {
+    for (var x = 0; x < newWidth; x++) {
+      for (var c = 0; c < 4; c++) {
         newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];
       }
     }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/webgl-utils/typed-array-utils.js"],"names":["ERR_TYPE_DEDUCTION","getGLTypeFromTypedArray","arrayOrType","type","ArrayBuffer","isView","constructor","Float32Array","GL","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"}
+{"version":3,"sources":["../../../src/webgl-utils/typed-array-utils.ts"],"names":["ERR_TYPE_DEDUCTION","getGLTypeFromTypedArray","arrayOrType","type","ArrayBuffer","isView","constructor","Float32Array","GL","FLOAT","Uint16Array","UNSIGNED_SHORT","Uint32Array","UNSIGNED_INT","Uint8Array","UNSIGNED_BYTE","Uint8ClampedArray","Int8Array","BYTE","Int16Array","SHORT","Int32Array","INT","Error","getTypedArrayFromGLType","glType","options","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","tempBuffer","y","topOffset","bottomOffset","set","subarray","copyWithin","scalePixels","newWidth","Math","round","newHeight","newData","x","c"],"mappings":";;;;;;;;;;;;AAAA;;AAEA,IAAMA,kBAAkB,GAAG,+CAA3B;;AAkBO,SAASC,uBAAT,CAAiCC,WAAjC,EAA8C;AAEnD,MAAMC,IAAI,GAAGC,WAAW,CAACC,MAAZ,CAAmBH,WAAnB,IAAkCA,WAAW,CAACI,WAA9C,GAA4DJ,WAAzE;;AACA,UAAQC,IAAR;AACE,SAAKI,YAAL;AACE,aAAOC,mBAAGC,KAAV;;AACF,SAAKC,WAAL;AACE,aAAOF,mBAAGG,cAAV;;AACF,SAAKC,WAAL;AACE,aAAOJ,mBAAGK,YAAV;;AACF,SAAKC,UAAL;AACE,aAAON,mBAAGO,aAAV;;AACF,SAAKC,iBAAL;AACE,aAAOR,mBAAGO,aAAV;;AACF,SAAKE,SAAL;AACE,aAAOT,mBAAGU,IAAV;;AACF,SAAKC,UAAL;AACE,aAAOX,mBAAGY,KAAV;;AACF,SAAKC,UAAL;AACE,aAAOb,mBAAGc,GAAV;;AACF;AACE,YAAM,IAAIC,KAAJ,CAAUvB,kBAAV,CAAN;AAlBJ;AAoBD;;AAUM,SAASwB,uBAAT,CACLC,MADK,EAELC,OAFK,EAKkB;AACvB,aAAyBA,OAAO,IAAI,EAApC;AAAA,0BAAOC,OAAP;AAAA,MAAOA,OAAP,6BAAiB,IAAjB;;AAEA,UAAQF,MAAR;AACE,SAAKjB,mBAAGC,KAAR;AACE,aAAOF,YAAP;;AACF,SAAKC,mBAAGG,cAAR;AACA,SAAKH,mBAAGoB,oBAAR;AACA,SAAKpB,mBAAGqB,sBAAR;AACA,SAAKrB,mBAAGsB,sBAAR;AACE,aAAOpB,WAAP;;AACF,SAAKF,mBAAGK,YAAR;AACE,aAAOD,WAAP;;AACF,SAAKJ,mBAAGO,aAAR;AACE,aAAOY,OAAO,GAAGX,iBAAH,GAAuBF,UAArC;;AACF,SAAKN,mBAAGU,IAAR;AACE,aAAOD,SAAP;;AACF,SAAKT,mBAAGY,KAAR;AACE,aAAOD,UAAP;;AACF,SAAKX,mBAAGc,GAAR;AACE,aAAOD,UAAP;;AACF;AACE,YAAM,IAAIE,KAAJ,CAAU,oDAAV,CAAN;AAnBJ;AAqBD;;AAQO,SAASQ,QAAT,CAAkBL,OAAlB,EAMC;AACP,MAAOM,IAAP,GAAuDN,OAAvD,CAAOM,IAAP;AAAA,MAAaC,KAAb,GAAuDP,OAAvD,CAAaO,KAAb;AAAA,MAAoBC,MAApB,GAAuDR,OAAvD,CAAoBQ,MAApB;AAAA,8BAAuDR,OAAvD,CAA4BS,aAA5B;AAAA,MAA4BA,aAA5B,sCAA4C,CAA5C;AAAA,MAA+CC,IAA/C,GAAuDV,OAAvD,CAA+CU,IAA/C;AACA,MAAMC,WAAW,GAAGJ,KAAK,GAAGE,aAA5B;AAGA,MAAMG,UAAU,GAAGF,IAAI,IAAI,IAAItB,UAAJ,CAAeuB,WAAf,CAA3B;;AACA,OAAK,IAAIE,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGL,MAAM,GAAG,CAA7B,EAAgC,EAAEK,CAAlC,EAAqC;AACnC,QAAMC,SAAS,GAAGD,CAAC,GAAGF,WAAtB;AACA,QAAMI,YAAY,GAAG,CAACP,MAAM,GAAGK,CAAT,GAAa,CAAd,IAAmBF,WAAxC;AAEAC,IAAAA,UAAU,CAACI,GAAX,CAAeV,IAAI,CAACW,QAAL,CAAcH,SAAd,EAAyBA,SAAS,GAAGH,WAArC,CAAf;AAEAL,IAAAA,IAAI,CAACY,UAAL,CAAgBJ,SAAhB,EAA2BC,YAA3B,EAAyCA,YAAY,GAAGJ,WAAxD;AAEAL,IAAAA,IAAI,CAACU,GAAL,CAASJ,UAAT,EAAqBG,YAArB;AACD;AACF;;AAGM,SAASI,WAAT,CAAqBnB,OAArB,EAQL;AACA,MAAOM,IAAP,GAA8BN,OAA9B,CAAOM,IAAP;AAAA,MAAaC,KAAb,GAA8BP,OAA9B,CAAaO,KAAb;AAAA,MAAoBC,MAApB,GAA8BR,OAA9B,CAAoBQ,MAApB;AACA,MAAMY,QAAQ,GAAGC,IAAI,CAACC,KAAL,CAAWf,KAAK,GAAG,CAAnB,CAAjB;AACA,MAAMgB,SAAS,GAAGF,IAAI,CAACC,KAAL,CAAWd,MAAM,GAAG,CAApB,CAAlB;AACA,MAAMgB,OAAO,GAAG,IAAIpC,UAAJ,CAAegC,QAAQ,GAAGG,SAAX,GAAuB,CAAtC,CAAhB;;AACA,OAAK,IAAIV,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGU,SAApB,EAA+BV,CAAC,EAAhC,EAAoC;AAClC,SAAK,IAAIY,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGL,QAApB,EAA8BK,CAAC,EAA/B,EAAmC;AACjC,WAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG,CAApB,EAAuBA,CAAC,EAAxB,EAA4B;AAC1BF,QAAAA,OAAO,CAAC,CAACX,CAAC,GAAGO,QAAJ,GAAeK,CAAhB,IAAqB,CAArB,GAAyBC,CAA1B,CAAP,GAAsCpB,IAAI,CAAC,CAACO,CAAC,GAAG,CAAJ,GAAQN,KAAR,GAAgBkB,CAAC,GAAG,CAArB,IAA0B,CAA1B,GAA8BC,CAA/B,CAA1C;AACD;AACF;AACF;;AACD,SAAO;AAACpB,IAAAA,IAAI,EAAEkB,OAAP;AAAgBjB,IAAAA,KAAK,EAAEa,QAAvB;AAAiCZ,IAAAA,MAAM,EAAEe;AAAzC,GAAP;AACD","sourcesContent":["import GL from '@luma.gl/constants';\n\nconst ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';\n\ntype TypedArrayConstructor =\n  | Float32ArrayConstructor\n  | Uint16ArrayConstructor\n  | Uint32ArrayConstructor\n  | Uint8ArrayConstructor\n  | Uint8ClampedArrayConstructor\n  | Int8ArrayConstructor\n  | Int16ArrayConstructor\n  | Int32ArrayConstructor;\n\n/**\n * Converts TYPED ARRAYS to corresponding GL constant\n * Used to auto deduce gl parameter types\n * @param {*} arrayOrType\n * @returns\n */\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/**\n * Converts GL constant to corresponding TYPED ARRAY\n * Used to auto deduce gl parameter types\n * @param {*} glType\n * @param {*} param1\n * @returns\n */\n// eslint-disable-next-line complexity\nexport function getTypedArrayFromGLType(\n  glType: any,\n  options?: {\n    clamped?: boolean;\n  }\n): TypedArrayConstructor {\n  const {clamped = true} = options || {};\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\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\n * @param {*} param0\n */\n export function flipRows(options: {\n  data: any;\n  width: any;\n  height: any;\n  bytesPerPixel?: number;\n  temp?: any;\n}): void {\n  const {data, width, height, bytesPerPixel = 4, temp} = options;\n  const bytesPerRow = width * bytesPerPixel;\n\n  // make a temp buffer to hold one row\n  const tempBuffer = 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    tempBuffer.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(tempBuffer, bottomOffset);\n  }\n}\n\n\nexport function scalePixels(options: {\n  data: any;\n  width: any;\n  height: any;\n}): {\n  data: Uint8Array;\n  width: number;\n  height: number;\n} {\n  const {data, width, height} = options;\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/dist/esm/_deprecated/context-api.js

@@ -0,0 +1,76 @@
+import GL from '@luma.gl/constants';
+import { WebGLDevice } from '@luma.gl/webgl';
+import { DEPRECATED_FEATURES } from './features';
+export function createGLContext(options) {
+  const webglDevice = new WebGLDevice(options);
+  return webglDevice.gl;
+}
+export function instrumentGLContext(gl, options) {
+  const webglDevice = WebGLDevice.attach(gl, options);
+  return webglDevice.gl;
+}
+export function resizeGLContext(gl, options) {
+  const webglDevice = WebGLDevice.attach(gl);
+  webglDevice.resize(options);
+}
+export function hasFeatures(gl, features) {
+  const webglDevice = WebGLDevice.attach(gl);
+  const normalizedFeatures = Array.isArray(features) ? features : [features];
+  const deviceFeatures = normalizedFeatures.map(feature => classicToDeviceFeature(feature));
+  return deviceFeatures.every(feature => webglDevice.features.has(feature));
+}
+
+function classicToDeviceFeature(feature) {
+  const deviceFeature = feature.toLowerCase().replace(/\_/g, '-');
+
+  if (deviceFeature.startsWith('webgl2') || deviceFeature.startsWith('glsl-')) {
+    return deviceFeature;
+  }
+
+  return "webgl-".concat(deviceFeature);
+}
+
+export function hasFeature(gl, feature) {
+  return hasFeatures(gl, feature);
+}
+export function getFeatures(gl) {
+  const webglDevice = WebGLDevice.attach(gl);
+  const featureMap = {};
+
+  for (const feature in DEPRECATED_FEATURES) {
+    featureMap[feature] = webglDevice.features.has(classicToDeviceFeature(feature));
+  }
+
+  return featureMap;
+}
+export function getContextDebugInfo(gl) {
+  const webglDevice = WebGLDevice.attach(gl);
+  const info = webglDevice.info;
+  return { ...webglDevice.info,
+    vendorMasked: webglDevice.info.vendor,
+    rendererMasked: webglDevice.info.renderer
+  };
+}
+export function getGLContextInfo(gl) {
+  const info = getContextDebugInfo(gl);
+  return {
+    [GL.UNMASKED_VENDOR_WEBGL]: info.vendor,
+    [GL.UNMASKED_RENDERER_WEBGL]: info.renderer,
+    [GL.VENDOR]: info.vendorMasked,
+    [GL.RENDERER]: info.rendererMasked,
+    [GL.VERSION]: info.version
+  };
+}
+export function getContextInfo(gl) {
+  return { ...getContextDebugInfo(gl),
+    ...getContextLimits(gl),
+    info: getGLContextInfo(gl)
+  };
+}
+export function getContextLimits(gl) {
+  const webglDevice = WebGLDevice.attach(gl);
+  return {
+    limits: webglDevice.webglLimits
+  };
+}
+//# sourceMappingURL=context-api.js.map

package/dist/esm/_deprecated/context-api.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/_deprecated/context-api.ts"],"names":["GL","WebGLDevice","DEPRECATED_FEATURES","createGLContext","options","webglDevice","gl","instrumentGLContext","attach","resizeGLContext","resize","hasFeatures","features","normalizedFeatures","Array","isArray","deviceFeatures","map","feature","classicToDeviceFeature","every","has","deviceFeature","toLowerCase","replace","startsWith","hasFeature","getFeatures","featureMap","getContextDebugInfo","info","vendorMasked","vendor","rendererMasked","renderer","getGLContextInfo","UNMASKED_VENDOR_WEBGL","UNMASKED_RENDERER_WEBGL","VENDOR","RENDERER","VERSION","version","getContextInfo","getContextLimits","limits","webglLimits"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\n// LEGACY luma.gl v8 API for WebGLRendering context\n// DEPRECATED API - may be removed in luma.gl v9 or v10.\n\n/* eslint-disable quotes */\nimport GL from '@luma.gl/constants';\nimport {WebGLDevice, WebGLDeviceProps} from '@luma.gl/webgl';\nimport {DEPRECATED_FEATURES} from './features';\n\nexport type GLContextOptions = WebGLDeviceProps & {\n  throwOnError?: boolean; // If set to false, return `null` if context creation fails.\n};\n\n/** @deprecated Use `new WebGLDevice()` or `luma.createDevice()` */\nexport function createGLContext(options?: GLContextOptions): WebGLRenderingContext | null {\n  const webglDevice = new WebGLDevice(options);\n  // Note: OK to return the context, it holds on to the device\n  return webglDevice.gl;\n}\n\n/** @deprecated Use `WebGLDevice.attach()` */\nexport function instrumentGLContext(\n  gl: WebGLRenderingContext | WebGL2RenderingContext,\n  options?: GLContextOptions\n): WebGLRenderingContext {\n  const webglDevice = WebGLDevice.attach(gl, options);\n  return webglDevice.gl;\n}\n\n/**\n * Resize the canvas' drawing buffer.\n *\n * Can match the canvas CSS size, and optionally also consider devicePixelRatio\n * Can be called every frame\n *\n * Regardless of size, the drawing buffer will always be scaled to the viewport, but\n * for best visual results, usually set to either:\n *  canvas CSS width x canvas CSS height\n *  canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio\n * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html\n *\n * resizeGLContext(gl, {width, height, useDevicePixels})\n * @deprecated Use WebGLDevice.resize()\n */\nexport function resizeGLContext(\n  gl: WebGLRenderingContext,\n  options?: {\n    width?: number;\n    height?: number;\n    useDevicePixels?: boolean | number;\n  }\n) {\n  const webglDevice = WebGLDevice.attach(gl);\n  webglDevice.resize(options);\n}\n\n/** \n * Check one or more features\n * @deprecated Use `WebGLDevice.features.has()`\n*/\nexport function hasFeatures(gl: WebGLRenderingContext, features: string | string[]): boolean {\n  const webglDevice = WebGLDevice.attach(gl);\n  const normalizedFeatures = Array.isArray(features) ? features : [features];\n  const deviceFeatures = normalizedFeatures.map(feature => classicToDeviceFeature(feature));\n  // @ts-expect-error Feature is a string enum\n  return deviceFeatures.every((feature) => webglDevice.features.has(feature));\n}\n\nfunction classicToDeviceFeature(feature: string): string {\n  const deviceFeature = feature.toLowerCase().replace(/\\_/g, '-');\n  if (deviceFeature.startsWith('webgl2') || deviceFeature.startsWith('glsl-')) {\n    return deviceFeature;\n  }\n  return `webgl-${deviceFeature}`;\n}\n\n/**\n * Check one feature\n * @deprecated Use `WebGLDevice.features`\n */\nexport function hasFeature(gl: WebGLRenderingContext, feature: string): boolean {\n  return hasFeatures(gl, feature);\n}\n\n/**\n * Return a map of supported features\n * @deprecated Use `WebGLDevice.features`\n */\nexport function getFeatures(gl: WebGLRenderingContext): Record<string, boolean>  {\n  const webglDevice = WebGLDevice.attach(gl);\n  const featureMap: Record<string, boolean> = {};\n  for (const feature in DEPRECATED_FEATURES) {\n    // @ts-expect-error Feature is a string enum\n    featureMap[feature] = webglDevice.features.has(classicToDeviceFeature(feature));\n  }\n  return featureMap;\n}\n\n/**\n * Provides strings identifying the GPU vendor and driver.\n * https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/\n *\n * @deprecated Use `WebGLDevice.info`\n */\nexport function getContextDebugInfo(gl: WebGLRenderingContext): {\n  vendor: string;\n  renderer: string;\n  vendorMasked: string;\n  rendererMasked: string;\n  version: string;\n} {\n  const webglDevice = WebGLDevice.attach(gl);\n  const info = webglDevice.info;\n  return {\n    ...webglDevice.info,\n    vendorMasked: webglDevice.info.vendor,\n    rendererMasked: webglDevice.info.renderer\n  };\n}\n\n/** @deprecated Use `WebGLDevice.info` */\nexport function getGLContextInfo(gl) {\n  const info = getContextDebugInfo(gl);\n  return {\n    [GL.UNMASKED_VENDOR_WEBGL]: info.vendor,\n    [GL.UNMASKED_RENDERER_WEBGL]: info.renderer,\n    [GL.VENDOR]: info.vendorMasked,\n    [GL.RENDERER]: info.rendererMasked,\n    [GL.VERSION]: info.version,\n  };\n}\n\n/** @deprecated Use `WebGLDevice.info` and `WebGLDevice.limits` */\nexport function getContextInfo(gl) {\n  return {\n    ...getContextDebugInfo(gl),\n    ...getContextLimits(gl),\n    info: getGLContextInfo(gl),\n  };\n}\n\n/** @deprecated Use `WebGLDevice.limits` */\nexport function getContextLimits(gl) {\n  const webglDevice = WebGLDevice.attach(gl);\n  return {limits: webglDevice.webglLimits};\n}\n"],"file":"context-api.js"}

package/dist/esm/_deprecated/features.js

@@ -0,0 +1,111 @@
+import GL from '@luma.gl/constants';
+import { isWebGL2 } from '@luma.gl/webgl';
+import { assert } from '@luma.gl/api';
+export const DEPRECATED_FEATURES = {
+  WEBGL2: 'WEBGL2',
+  VERTEX_ARRAY_OBJECT: 'VERTEX_ARRAY_OBJECT',
+  TIMER_QUERY: 'TIMER_QUERY',
+  INSTANCED_RENDERING: 'INSTANCED_RENDERING',
+  MULTIPLE_RENDER_TARGETS: 'MULTIPLE_RENDER_TARGETS',
+  ELEMENT_INDEX_UINT32: 'ELEMENT_INDEX_UINT32',
+  BLEND_EQUATION_MINMAX: 'BLEND_EQUATION_MINMAX',
+  FLOAT_BLEND: 'FLOAT_BLEND',
+  COLOR_ENCODING_SRGB: 'COLOR_ENCODING_SRGB',
+  TEXTURE_DEPTH: 'TEXTURE_DEPTH',
+  TEXTURE_FLOAT: 'TEXTURE_FLOAT',
+  TEXTURE_HALF_FLOAT: 'TEXTURE_HALF_FLOAT',
+  TEXTURE_FILTER_LINEAR_FLOAT: 'TEXTURE_FILTER_LINEAR_FLOAT',
+  TEXTURE_FILTER_LINEAR_HALF_FLOAT: 'TEXTURE_FILTER_LINEAR_HALF_FLOAT',
+  TEXTURE_FILTER_ANISOTROPIC: 'TEXTURE_FILTER_ANISOTROPIC',
+  COLOR_ATTACHMENT_RGBA32F: 'COLOR_ATTACHMENT_RGBA32F',
+  COLOR_ATTACHMENT_FLOAT: 'COLOR_ATTACHMENT_FLOAT',
+  COLOR_ATTACHMENT_HALF_FLOAT: 'COLOR_ATTACHMENT_HALF_FLOAT',
+  GLSL_FRAG_DATA: 'GLSL_FRAG_DATA',
+  GLSL_FRAG_DEPTH: 'GLSL_FRAG_DEPTH',
+  GLSL_DERIVATIVES: 'GLSL_DERIVATIVES',
+  GLSL_TEXTURE_LOD: 'GLSL_TEXTURE_LOD'
+};
+export function getWebGLFeatures(gl) {
+  gl.getExtension('EXT_color_buffer_float');
+  gl.getExtension('WEBGL_color_buffer_float');
+  gl.getExtension('EXT_float_blend');
+  const features = new Set();
+
+  for (const feature in WEBGL_FEATURES) {
+    if (isFeatureSupported(gl, feature)) {
+      features.add(feature);
+    }
+  }
+
+  return features;
+}
+
+function isFeatureSupported(gl, cap) {
+  const feature = WEBGL_FEATURES[cap];
+  assert(feature, cap);
+  const [webgl1Feature, webgl2Feature] = feature;
+  const featureDefinition = isWebGL2(gl) ? webgl2Feature : webgl1Feature;
+
+  if (cap === DEPRECATED_FEATURES.COLOR_ATTACHMENT_RGBA32F && !isWebGL2(gl)) {
+    return checkFloat32ColorAttachment(gl);
+  }
+
+  if (typeof featureDefinition === 'string') {
+    return Boolean(gl.getExtension(featureDefinition));
+  }
+
+  return featureDefinition;
+}
+
+function checkFloat32ColorAttachment(gl) {
+  let texture;
+  let framebuffer;
+
+  try {
+    const texture = gl.createTexture();
+    gl.bindTexture(GL.TEXTURE_2D, texture);
+    const level = 0;
+    const internalFormat = gl.RGBA;
+    const width = 1;
+    const height = 1;
+    const border = 0;
+    const srcFormat = gl.RGBA;
+    const srcType = gl.UNSIGNED_BYTE;
+    const pixel = new Uint8Array([0, 0, 255, 255]);
+    gl.texImage2D(gl.TEXTURE_2D, level, internalFormat, width, height, border, srcFormat, srcType, pixel);
+    const framebuffer = gl.createFramebuffer();
+    gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer);
+    gl.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, texture, 0);
+    const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER) === GL.FRAMEBUFFER_COMPLETE;
+    return status;
+  } finally {
+    gl.deleteTexture(texture);
+    gl.deleteFramebuffer(framebuffer);
+  }
+}
+
+const WEBGL_FEATURES = {
+  [DEPRECATED_FEATURES.WEBGL2]: [false, true],
+  [DEPRECATED_FEATURES.VERTEX_ARRAY_OBJECT]: ['OES_vertex_array_object', true],
+  [DEPRECATED_FEATURES.TIMER_QUERY]: ['EXT_disjoint_timer_query', 'EXT_disjoint_timer_query_webgl2'],
+  [DEPRECATED_FEATURES.INSTANCED_RENDERING]: ['ANGLE_instanced_arrays', true],
+  [DEPRECATED_FEATURES.MULTIPLE_RENDER_TARGETS]: ['WEBGL_draw_buffers', true],
+  [DEPRECATED_FEATURES.ELEMENT_INDEX_UINT32]: ['OES_element_index_uint', true],
+  [DEPRECATED_FEATURES.BLEND_EQUATION_MINMAX]: ['EXT_blend_minmax', true],
+  [DEPRECATED_FEATURES.FLOAT_BLEND]: ['EXT_float_blend', 'EXT_float_blend'],
+  [DEPRECATED_FEATURES.COLOR_ENCODING_SRGB]: ['EXT_sRGB', true],
+  [DEPRECATED_FEATURES.TEXTURE_DEPTH]: ['WEBGL_depth_texture', true],
+  [DEPRECATED_FEATURES.TEXTURE_FLOAT]: ['OES_texture_float', true],
+  [DEPRECATED_FEATURES.TEXTURE_HALF_FLOAT]: ['OES_texture_half_float', true],
+  [DEPRECATED_FEATURES.TEXTURE_FILTER_LINEAR_FLOAT]: ['OES_texture_float_linear', 'OES_texture_float_linear'],
+  [DEPRECATED_FEATURES.TEXTURE_FILTER_LINEAR_HALF_FLOAT]: ['OES_texture_half_float_linear', 'OES_texture_half_float_linear'],
+  [DEPRECATED_FEATURES.TEXTURE_FILTER_ANISOTROPIC]: ['EXT_texture_filter_anisotropic', 'EXT_texture_filter_anisotropic'],
+  [DEPRECATED_FEATURES.COLOR_ATTACHMENT_RGBA32F]: [false, 'EXT_color_buffer_float'],
+  [DEPRECATED_FEATURES.COLOR_ATTACHMENT_FLOAT]: [false, 'EXT_color_buffer_float'],
+  [DEPRECATED_FEATURES.COLOR_ATTACHMENT_HALF_FLOAT]: ['EXT_color_buffer_half_float', 'EXT_color_buffer_half_float'],
+  [DEPRECATED_FEATURES.GLSL_FRAG_DATA]: ['WEBGL_draw_buffers', true],
+  [DEPRECATED_FEATURES.GLSL_FRAG_DEPTH]: ['EXT_frag_depth', true],
+  [DEPRECATED_FEATURES.GLSL_DERIVATIVES]: ['OES_standard_derivatives', true],
+  [DEPRECATED_FEATURES.GLSL_TEXTURE_LOD]: ['EXT_shader_texture_lod', true]
+};
+//# sourceMappingURL=features.js.map