@luma.gl/webgl 8.6.0-alpha.2 → 8.6.0-alpha.3

package/dist/es5/helpers/get-program-bindings.js

@@ -0,0 +1,274 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getProgramBindings = getProgramBindings;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+
+var _webglChecks = require("../context/context/webgl-checks");
+
+var _accessor = _interopRequireDefault(require("../classes/accessor"));
+
+var _attributeUtils = require("../webgl-utils/attribute-utils");
+
+var _SAMPLER_UNIFORMS_GL_;
+
+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; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function getProgramBindings(gl, program) {
+  var config = {
+    attributes: readAttributeBindings(gl, program),
+    uniforms: readUniformBindings(gl, program),
+    uniformBlocks: readUniformBlocks(gl, program),
+    varyings: readVaryings(gl, program)
+  };
+  Object.seal(config);
+  return config;
+}
+
+function readAttributeBindings(gl, program) {
+  var attributes = [];
+  var count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+
+  for (var index = 0; index < count; index++) {
+    var _gl$getActiveAttrib = gl.getActiveAttrib(program, index),
+        name = _gl$getActiveAttrib.name,
+        compositeType = _gl$getActiveAttrib.type,
+        size = _gl$getActiveAttrib.size;
+
+    var location = gl.getAttribLocation(program, name);
+
+    if (location >= 0) {
+      var _decomposeCompositeGL = (0, _attributeUtils.decomposeCompositeGLType)(compositeType),
+          type = _decomposeCompositeGL.type,
+          components = _decomposeCompositeGL.components;
+
+      var accessor = {
+        type: type,
+        size: size * components
+      };
+      inferProperties(location, name, accessor);
+      var attributeInfo = {
+        location: location,
+        name: name,
+        accessor: new _accessor.default(accessor)
+      };
+      attributes.push(attributeInfo);
+    }
+  }
+
+  attributes.sort(function (a, b) {
+    return a.location - b.location;
+  });
+  return attributes;
+}
+
+function readVaryings(gl, program) {
+  if (!(0, _webglChecks.isWebGL2)(gl)) {
+    return [];
+  }
+
+  var varyings = [];
+  var count = gl.getProgramParameter(program, gl.TRANSFORM_FEEDBACK_VARYINGS);
+
+  for (var location = 0; location < count; location++) {
+    var _gl$getTransformFeedb = gl.getTransformFeedbackVarying(program, location),
+        name = _gl$getTransformFeedb.name,
+        compositeType = _gl$getTransformFeedb.type,
+        size = _gl$getTransformFeedb.size;
+
+    var _decomposeCompositeGL2 = (0, _attributeUtils.decomposeCompositeGLType)(compositeType),
+        type = _decomposeCompositeGL2.type,
+        components = _decomposeCompositeGL2.components;
+
+    var accessor = new _accessor.default({
+      type: type,
+      size: size * components
+    });
+    var varying = {
+      location: location,
+      name: name,
+      accessor: accessor
+    };
+    varyings.push(varying);
+  }
+
+  varyings.sort(function (a, b) {
+    return a.location - b.location;
+  });
+  return varyings;
+}
+
+function readUniformBindings(gl, program) {
+  var uniforms = [];
+  var uniformCount = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
+
+  for (var i = 0; i < uniformCount; i++) {
+    var _gl$getActiveUniform = gl.getActiveUniform(program, i),
+        rawName = _gl$getActiveUniform.name,
+        size = _gl$getActiveUniform.size,
+        type = _gl$getActiveUniform.type;
+
+    var _parseUniformName = parseUniformName(rawName),
+        name = _parseUniformName.name,
+        isArray = _parseUniformName.isArray;
+
+    var webglLocation = gl.getUniformLocation(program, name);
+    var uniformInfo = {
+      location: webglLocation,
+      name: name,
+      size: size,
+      type: type,
+      isArray: isArray
+    };
+    uniforms.push(uniformInfo);
+
+    if (uniformInfo.size > 1) {
+      for (var j = 0; j < uniformInfo.size; j++) {
+        var elementName = "".concat(name, "[").concat(j, "]");
+        webglLocation = gl.getUniformLocation(program, elementName);
+
+        var arrayElementUniformInfo = _objectSpread(_objectSpread({}, uniformInfo), {}, {
+          name: elementName,
+          location: webglLocation
+        });
+
+        uniforms.push(arrayElementUniformInfo);
+      }
+    }
+  }
+
+  return uniforms;
+}
+
+function readUniformBlocks(gl, program) {
+  var getBlockParameter = function getBlockParameter(blockIndex, pname) {
+    return gl.getActiveUniformBlockParameter(program, blockIndex, pname);
+  };
+
+  var uniformBlocks = [];
+  var blockCount = gl.getProgramParameter(program, gl.ACTIVE_UNIFORM_BLOCKS);
+
+  for (var blockIndex = 0; blockIndex < blockCount; blockIndex++) {
+    var blockInfo = {
+      name: gl.getActiveUniformBlockName(program, blockIndex),
+      location: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_BINDING),
+      byteLength: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_DATA_SIZE),
+      vertex: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
+      fragment: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
+      uniformCount: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
+      uniformIndices: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES),
+      uniforms: []
+    };
+
+    for (var uniformIndex = 0; uniformIndex < blockInfo.uniformCount; ++uniformIndex) {}
+
+    uniformBlocks.push(blockInfo);
+  }
+
+  uniformBlocks.sort(function (a, b) {
+    return a.location - b.location;
+  });
+  return uniformBlocks;
+}
+
+var SAMPLER_UNIFORMS_GL_TO_GPU = (_SAMPLER_UNIFORMS_GL_ = {}, (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.SAMPLER_2D, ['2d', 'float']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.SAMPLER_CUBE, ['cube', 'float']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.SAMPLER_3D, ['3d', 'float']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.SAMPLER_2D_SHADOW, ['3d', 'depth']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.SAMPLER_2D_ARRAY, ['2d-array', 'float']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.SAMPLER_2D_ARRAY_SHADOW, ['2d-array', 'depth']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.SAMPLER_CUBE_SHADOW, ['cube', 'float']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.INT_SAMPLER_2D, ['2d', 'sint']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.INT_SAMPLER_3D, ['3d', 'sint']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.INT_SAMPLER_CUBE, ['cube', 'sint']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.INT_SAMPLER_2D_ARRAY, ['2d-array', 'sint']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.UNSIGNED_INT_SAMPLER_2D, ['2d', 'sint']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.UNSIGNED_INT_SAMPLER_3D, ['3d', 'sint']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.UNSIGNED_INT_SAMPLER_CUBE, ['cube', 'sint']), (0, _defineProperty2.default)(_SAMPLER_UNIFORMS_GL_, _constants.default.UNSIGNED_INT_SAMPLER_2D_ARRAY, ['2d-array', 'sint']), _SAMPLER_UNIFORMS_GL_);
+
+function generateWebGPUStyleBindings(config) {
+  var bindings = [];
+
+  var _iterator = _createForOfIteratorHelper(config.uniformBlocks),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var blockInfo = _step.value;
+      bindings.push({
+        binding: blockInfo.location,
+        visibility: (blockInfo.vertex ? 0x1 : 0) & (blockInfo.fragment ? 0x2 : 0),
+        buffer: {
+          type: 'uniform'
+        }
+      });
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  var _iterator2 = _createForOfIteratorHelper(config.uniforms),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var uniformInfo = _step2.value;
+      var sampler = SAMPLER_UNIFORMS_GL_TO_GPU[uniformInfo.type];
+
+      if (sampler) {
+        var _sampler = (0, _slicedToArray2.default)(sampler, 2),
+            viewDimension = _sampler[0],
+            sampleType = _sampler[1];
+
+        bindings.push({
+          binding: uniformInfo.location,
+          visibility: 0,
+          texture: {
+            viewDimension: viewDimension,
+            sampleType: sampleType
+          }
+        });
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+}
+
+function parseUniformName(name) {
+  if (name[name.length - 1] !== ']') {
+    return {
+      name: name,
+      length: 1,
+      isArray: false
+    };
+  }
+
+  var UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
+  var matches = name.match(UNIFORM_NAME_REGEXP);
+
+  if (!matches || matches.length < 2) {
+    throw new Error("Failed to parse GLSL uniform name ".concat(name));
+  }
+
+  return {
+    name: matches[1],
+    length: matches[2] || 1,
+    isArray: Boolean(matches[2])
+  };
+}
+
+function inferProperties(accessor, location, name) {
+  if (/instance/i.test(name)) {
+    accessor.divisor = 1;
+  }
+}
+//# sourceMappingURL=get-program-bindings.js.map

package/dist/es5/helpers/get-program-bindings.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/helpers/get-program-bindings.ts"],"names":["getProgramBindings","gl","program","config","attributes","readAttributeBindings","uniforms","readUniformBindings","uniformBlocks","readUniformBlocks","varyings","readVaryings","Object","seal","count","getProgramParameter","ACTIVE_ATTRIBUTES","index","getActiveAttrib","name","compositeType","type","size","location","getAttribLocation","components","accessor","inferProperties","attributeInfo","Accessor","push","sort","a","b","TRANSFORM_FEEDBACK_VARYINGS","getTransformFeedbackVarying","varying","uniformCount","ACTIVE_UNIFORMS","i","getActiveUniform","rawName","parseUniformName","isArray","webglLocation","getUniformLocation","uniformInfo","j","elementName","arrayElementUniformInfo","getBlockParameter","blockIndex","pname","getActiveUniformBlockParameter","blockCount","ACTIVE_UNIFORM_BLOCKS","blockInfo","getActiveUniformBlockName","UNIFORM_BLOCK_BINDING","byteLength","UNIFORM_BLOCK_DATA_SIZE","vertex","UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER","fragment","UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER","UNIFORM_BLOCK_ACTIVE_UNIFORMS","uniformIndices","UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES","uniformIndex","SAMPLER_UNIFORMS_GL_TO_GPU","GL","SAMPLER_2D","SAMPLER_CUBE","SAMPLER_3D","SAMPLER_2D_SHADOW","SAMPLER_2D_ARRAY","SAMPLER_2D_ARRAY_SHADOW","SAMPLER_CUBE_SHADOW","INT_SAMPLER_2D","INT_SAMPLER_3D","INT_SAMPLER_CUBE","INT_SAMPLER_2D_ARRAY","UNSIGNED_INT_SAMPLER_2D","UNSIGNED_INT_SAMPLER_3D","UNSIGNED_INT_SAMPLER_CUBE","UNSIGNED_INT_SAMPLER_2D_ARRAY","generateWebGPUStyleBindings","bindings","binding","visibility","buffer","sampler","viewDimension","sampleType","texture","length","UNIFORM_NAME_REGEXP","matches","match","Error","Boolean","test","divisor"],"mappings":"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","sourcesContent":["import GL from '@luma.gl/constants';\nimport {isWebGL2} from '../context/context/webgl-checks';\nimport {ProgramBindings, AttributeBinding, UniformBinding, UniformBlockBinding, VaryingBinding} from './program-bindings'\nimport Accessor from '../classes/accessor';\nimport {decomposeCompositeGLType} from '../webgl-utils/attribute-utils';\n\n/**\n * Extract metadata describing binding information for a program's shaders\n * Note: `linkProgram()` needs to have been called\n * (although linking does not need to have been successful).\n*/\nexport function getProgramBindings(gl: WebGL2RenderingContext, program: WebGLProgram): ProgramBindings {\n  const config: ProgramBindings = {\n    attributes: readAttributeBindings(gl, program),\n    uniforms: readUniformBindings(gl, program),\n    uniformBlocks: readUniformBlocks(gl, program),\n    varyings: readVaryings(gl, program)\n  };\n\n  Object.seal(config);\n  return config;\n  // generateWebGPUStyleBindings(bindings);\n}\n\n\n/**\n * Extract info about all transform feedback varyings\n *\n * linkProgram needs to have been called, although linking does not need to have been successful\n */\nfunction readAttributeBindings(gl: WebGL2RenderingContext, program: WebGLProgram): AttributeBinding[] {\n  const attributes: AttributeBinding[] = [];\n\n  const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);\n\n  for (let index = 0; index < count; index++) {\n    const {name, type: compositeType, size} = gl.getActiveAttrib(program, index);\n    const location = gl.getAttribLocation(program, name);\n    // Add only user provided attributes, for built-in attributes like\n    // `gl_InstanceID` locaiton will be < 0\n    if (location >= 0) {\n      const {type, components} = decomposeCompositeGLType(compositeType);\n      const accessor = {type, size: size * components};\n      inferProperties(location, name, accessor);\n    \n      const attributeInfo = {location, name, accessor: new Accessor(accessor)}; // Base values\n      attributes.push(attributeInfo);\n    }\n  }\n\n  attributes.sort((a, b) => a.location - b.location);\n  return attributes;\n}\n\n/**\n * Extract info about all transform feedback varyings\n *\n * linkProgram needs to have been called, although linking does not need to have been successful\n */\nfunction readVaryings(gl: WebGL2RenderingContext, program: WebGLProgram): VaryingBinding[] {\n  if (!isWebGL2(gl)) {\n    return [];\n  }\n\n  const varyings = [];\n\n  const count = gl.getProgramParameter(program, gl.TRANSFORM_FEEDBACK_VARYINGS);\n  for (let location = 0; location < count; location++) {\n    const {name, type: compositeType, size} = gl.getTransformFeedbackVarying(program, location);\n    const {type, components} = decomposeCompositeGLType(compositeType);\n    const accessor = new Accessor({type, size: size * components});\n    const varying = {location, name, accessor}; // Base values\n    varyings.push(varying);\n  }\n\n  varyings.sort((a, b) => a.location - b.location);\n  return varyings;\n}\n\n/**\n * Extract info about all uniforms\n *\n * Query uniform locations and build name to setter map.\n */\nfunction readUniformBindings(gl: WebGL2RenderingContext, program: WebGLProgram): UniformBinding[] {\n  const uniforms: UniformBinding[] = [];\n\n  const uniformCount = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);\n  for (let i = 0; i < uniformCount; i++) {\n    const {name: rawName, size, type} = gl.getActiveUniform(program, i);\n    const {name, isArray} = parseUniformName(rawName);\n    let webglLocation = gl.getUniformLocation(program, name);\n    const uniformInfo = {\n      // WebGL locations are uniquely typed but just numbers\n      location: webglLocation as number,\n      name,\n      size,\n      type,\n      isArray\n    };\n    uniforms.push(uniformInfo);\n\n    // Array (e.g. matrix) uniforms can occupy several 4x4 byte banks\n    if (uniformInfo.size > 1) {\n      for (let j = 0; j < uniformInfo.size; j++) {\n        const elementName = `${name}[${j}]`;\n\n        webglLocation = gl.getUniformLocation(program, elementName);\n\n        const arrayElementUniformInfo = {\n          ...uniformInfo,\n          name: elementName,\n          location: webglLocation as number\n        };\n\n        uniforms.push(arrayElementUniformInfo);\n      }\n    }\n  }\n  return uniforms;\n}\n\n/**\n * Extract info about all \"active\" uniform blocks\n *\n * (\"Active\" just means that unused (aka inactive) blocks may have been\n * optimized away during linking)\n */\nfunction readUniformBlocks(gl: WebGL2RenderingContext, program: WebGLProgram): UniformBlockBinding[] {\n  const getBlockParameter = (blockIndex, pname) => gl.getActiveUniformBlockParameter(program, blockIndex, pname);\n\n  const uniformBlocks: UniformBlockBinding[] = [];\n\n  const blockCount = gl.getProgramParameter(program, gl.ACTIVE_UNIFORM_BLOCKS);\n  for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {\n\n    const blockInfo = {\n      name: gl.getActiveUniformBlockName(program, blockIndex),\n      location: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_BINDING),\n      byteLength: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_DATA_SIZE),\n      vertex: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),\n      fragment: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),\n      uniformCount: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS),\n      uniformIndices: getBlockParameter(blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES),\n      uniforms: []\n    }\n\n    for (let uniformIndex = 0; uniformIndex < blockInfo.uniformCount; ++uniformIndex) {\n      // TODO - Can we extract more?\n    }\n\n    uniformBlocks.push(blockInfo);\n  }\n\n  uniformBlocks.sort((a, b) => a.location - b.location);\n  return uniformBlocks;\n}\n\nconst SAMPLER_UNIFORMS_GL_TO_GPU = {\n  [GL.SAMPLER_2D]: ['2d', 'float'],\n  [GL.SAMPLER_CUBE]: ['cube', 'float'],\n  [GL.SAMPLER_3D]: ['3d', 'float'],\n  [GL.SAMPLER_2D_SHADOW]: ['3d', 'depth'],\n  [GL.SAMPLER_2D_ARRAY]: ['2d-array', 'float'],\n  [GL.SAMPLER_2D_ARRAY_SHADOW]: ['2d-array', 'depth'],\n  [GL.SAMPLER_CUBE_SHADOW]: ['cube', 'float'],\n  [GL.INT_SAMPLER_2D]: ['2d', 'sint'],\n  [GL.INT_SAMPLER_3D]: ['3d', 'sint'],\n  [GL.INT_SAMPLER_CUBE]: ['cube', 'sint'],\n  [GL.INT_SAMPLER_2D_ARRAY]: ['2d-array', 'sint'],\n  [GL.UNSIGNED_INT_SAMPLER_2D]: ['2d', 'sint'],\n  [GL.UNSIGNED_INT_SAMPLER_3D]: ['3d', 'sint'],\n  [GL.UNSIGNED_INT_SAMPLER_CUBE]: ['cube', 'sint'],\n  [GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ['2d-array', 'sint']\n};\n\n/**\n * Generate a list of \"WebGPU-style\" bindings for this program\n */\nfunction generateWebGPUStyleBindings(config: ProgramBindings) {\n  const bindings: any = [];\n\n  // Uniform blocks\n  for (const blockInfo of config.uniformBlocks) {\n    bindings.push({\n      binding: blockInfo.location,\n      visibility: (blockInfo.vertex ? 0x1 : 0) & (blockInfo.fragment ? 0x2 : 0),\n      buffer: {\n        type: 'uniform',\n        // minBindingSize: blockInfo.size\n      }\n    })\n  }\n\n  // Sampler uniforms\n  for (const uniformInfo of config.uniforms) {\n    let sampler = SAMPLER_UNIFORMS_GL_TO_GPU[uniformInfo.type];\n    if (sampler) {\n      const [viewDimension, sampleType] = sampler;\n      bindings.push({\n        binding: uniformInfo.location,\n        visibility: 0, // Not available in WebGL on individual uniforms?\n        texture: {\n          viewDimension,\n          sampleType\n        }\n      });\n    }\n  }\n}\n\n// HELPERS\n\nfunction parseUniformName(name) {\n  // Shortcut to avoid redundant or bad matches\n  if (name[name.length - 1] !== ']'){\n    return {\n      name,\n      length: 1,\n      isArray: false\n    };\n  }\n\n  // if array name then clean the array brackets\n  const UNIFORM_NAME_REGEXP = /([^[]*)(\\[[0-9]+\\])?/;\n  const matches = name.match(UNIFORM_NAME_REGEXP);\n  if (!matches || matches.length < 2) {\n    throw new Error(`Failed to parse GLSL uniform name ${name}`);\n  }\n\n  return {\n    name: matches[1],\n    length: matches[2] || 1,\n    isArray: Boolean(matches[2])\n  };\n}\n\n// Extract additional attribute metadata from shader names (based on attribute naming conventions)\nfunction inferProperties(accessor, location, name) {\n  if (/instance/i.test(name)) {\n    // Any attribute containing the word \"instance\" will be assumed to be instanced\n    accessor.divisor = 1;\n  }\n}\n"],"file":"get-program-bindings.js"}

package/dist/es5/helpers/program-bindings.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=program-bindings.js.map

package/dist/es5/helpers/program-bindings.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"program-bindings.js"}

package/dist/es5/index.js

@@ -79,40 +79,40 @@ Object.defineProperty(exports, "TextureCube", {
     return _textureCube.default;
   }
 });
-Object.defineProperty(exports, "Shader", {
+Object.defineProperty(exports, "Program", {
   enumerable: true,
   get: function get() {
-    return _webglShader.Shader;
+    return _program.default;
   }
 });
-Object.defineProperty(exports, "VertexShader", {
+Object.defineProperty(exports, "Framebuffer", {
   enumerable: true,
   get: function get() {
-    return _webglShader.VertexShader;
+    return _framebuffer.default;
   }
 });
-Object.defineProperty(exports, "FragmentShader", {
+Object.defineProperty(exports, "Renderbuffer", {
   enumerable: true,
   get: function get() {
-    return _webglShader.FragmentShader;
+    return _renderbuffer.default;
   }
 });
-Object.defineProperty(exports, "Program", {
+Object.defineProperty(exports, "Shader", {
   enumerable: true,
   get: function get() {
-    return _program.default;
+    return _shader.Shader;
   }
 });
-Object.defineProperty(exports, "Framebuffer", {
+Object.defineProperty(exports, "VertexShader", {
   enumerable: true,
   get: function get() {
-    return _framebuffer.default;
+    return _shader.VertexShader;
   }
 });
-Object.defineProperty(exports, "Renderbuffer", {
+Object.defineProperty(exports, "FragmentShader", {
   enumerable: true,
   get: function get() {
-    return _renderbuffer.default;
+    return _shader.FragmentShader;
   }
 });
 Object.defineProperty(exports, "clear", {
@@ -199,6 +199,12 @@ Object.defineProperty(exports, "UniformBufferLayout", {
     return _uniformBufferLayout.default;
   }
 });
+Object.defineProperty(exports, "setDeviceParameters", {
+  enumerable: true,
+  get: function get() {
+    return _setDeviceParameters.setDeviceParameters;
+  }
+});
 Object.defineProperty(exports, "isWebGL", {
   enumerable: true,
   get: function get() {
@@ -361,10 +367,16 @@ Object.defineProperty(exports, "loadImage", {
     return _api.loadImage;
   }
 });
+Object.defineProperty(exports, "getProgramBindings", {
+  enumerable: true,
+  get: function get() {
+    return _getProgramBindings.getProgramBindings;
+  }
+});
 
 var _init = require("./init");
 
-var _webglDevice = _interopRequireWildcard(require("./device/webgl-device"));
+var _webglDevice = _interopRequireWildcard(require("./adapter/webgl-device"));
 
 var _requestAnimationFrame = require("./webgl-utils/request-animation-frame");
 
@@ -380,14 +392,14 @@ var _texture2d = _interopRequireDefault(require("./classes/texture-2d"));
 
 var _textureCube = _interopRequireDefault(require("./classes/texture-cube"));
 
-var _webglShader = require("./classes/webgl-shader");
-
 var _program = _interopRequireDefault(require("./classes/program"));
 
 var _framebuffer = _interopRequireDefault(require("./classes/framebuffer"));
 
 var _renderbuffer = _interopRequireDefault(require("./classes/renderbuffer"));
 
+var _shader = require("./classes/shader");
+
 var _clear = require("./classes/clear");
 
 var _copyAndBlit = require("./classes/copy-and-blit");
@@ -404,6 +416,8 @@ var _vertexArray = _interopRequireDefault(require("./classes/vertex-array"));
 
 var _uniformBufferLayout = _interopRequireDefault(require("./classes/uniform-buffer-layout"));
 
+var _setDeviceParameters = require("./adapter/converters/set-device-parameters");
+
 var _webglChecks = require("./context/context/webgl-checks");
 
 var _devicePixels = require("./context/context/device-pixels");
@@ -426,6 +440,8 @@ var _debugProgramConfiguration = require("./debug/debug-program-configuration");
 
 var _api = require("@luma.gl/api");
 
+var _getProgramBindings = require("./helpers/get-program-bindings");
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA;;AAIA;;AAGA;;AAGA;;AACA;;AAGA;;AAIA;;AAEA;;AAEA;;AAGA;;AAEA;;AAEA;;AAEA;;AAEA;;AAGA;;AAWA;;AAEA;;AAEA;;AAEA;;AAEA;;AACA;;AAKA;;AASA;;AAKA;;AAMA;;AAKA;;AAOA;;AAGA;;AACA;;AACA;;AACA;;AAMA","sourcesContent":["// luma.gl Base WebGL wrapper library\n// Provides simple class/function wrappers around the low level webgl objects\n// These classes are intentionally close to the WebGL API\n// but make it easier to use.\n// Higher level abstractions can be built on these classes\n\n// Initialize any global state\nimport './init';\n\n// export type {WebGLDeviceProps, WebGLDeviceInfo, WebGPUDeviceLimits} from './lib/webgl-device';\nexport type {WebGLDeviceProps} from './device/webgl-device';\nexport {default as WebGLDevice, getWebGLDevice} from './device/webgl-device';\n\n// UTILS\nexport {requestAnimationFrame, cancelAnimationFrame} from './webgl-utils/request-animation-frame';\n\n// WebGL Functions\nexport {cloneTextureFrom} from './webgl-utils/texture-utils';\nexport {getKeyValue, getKey} from './webgl-utils/constants-to-keys';\n\n// WebGL Helper Classes\nexport {default as Accessor} from './classes/accessor';\n\n// WebGL1 classes\nexport type {BufferProps} from '@luma.gl/api';\nexport {default as Buffer} from './classes/webgl-buffer';\nexport type {Texture2DProps} from './classes/texture-2d';\nexport {default as Texture2D} from './classes/texture-2d';\nexport type {TextureCubeProps} from './classes/texture-cube';\nexport {default as TextureCube} from './classes/texture-cube';\n\nexport type {ShaderProps} from './classes/webgl-shader';\nexport {Shader, VertexShader, FragmentShader} from './classes/webgl-shader';\nexport type {ProgramProps} from './classes/program';\nexport {default as Program} from './classes/program';\nexport type {FramebufferProps} from './classes/framebuffer';\nexport {default as Framebuffer} from './classes/framebuffer';\nexport type {RenderbufferProps} from './classes/renderbuffer';\nexport {default as Renderbuffer} from './classes/renderbuffer';\n\nexport {clear, clearBuffer} from './classes/clear';\n\n// Copy and Blit\nexport {\n  readPixelsToArray,\n  readPixelsToBuffer,\n  copyToDataUrl,\n  copyToImage,\n  copyToTexture,\n  blit\n} from './classes/copy-and-blit';\n\n// WebGL2 classes & Extensions\nexport type {QueryProps} from './classes/query';\nexport {default as Query} from './classes/query';\nexport type {Texture3DProps} from './classes/texture-3d';\nexport {default as Texture3D} from './classes/texture-3d';\nexport type {TransformFeedbackProps} from './classes/transform-feedback';\nexport {default as TransformFeedback} from './classes/transform-feedback';\nexport type {VertexArrayObjectProps} from './classes/vertex-array-object';\nexport {default as VertexArrayObject} from './classes/vertex-array-object';\nexport type {VertexArrayProps} from './classes/vertex-array';\nexport {default as VertexArray} from './classes/vertex-array';\nexport {default as UniformBufferLayout} from './classes/uniform-buffer-layout';\n\n// experimental WebGL exports\n\n// UTILS\nexport {\n  isWebGL,\n  isWebGL2,\n  getWebGL2Context,\n  assertWebGLContext,\n  assertWebGL2Context\n} from './context/context/webgl-checks';\n\n// Device ratio\nexport {cssToDeviceRatio, cssToDevicePixels} from './context/context/device-pixels';\n\n// Unified parameter API\n\nexport type {GLParameters} from './context/parameters/webgl-parameters';\nexport {\n  getParameters,\n  setParameters,\n  resetParameters\n} from './context/parameters/unified-parameter-api';\n\nexport {\n  withParameters\n} from './context/state-tracker/with-parameters';\n\n// State tracking\nexport {\n  trackContextState,\n  pushContextState,\n  popContextState\n} from './context/state-tracker/track-context-state';\n\n// Polyfills (supports a subset of WebGL2 APIs on WebGL1 contexts)\nexport {polyfillContext} from './context/polyfill/polyfill-context';\n\n// INTERNAL\nexport {parseUniformName, getUniformSetter} from './classes/uniforms';\nexport {getDebugTableForUniforms} from './debug/debug-uniforms';\nexport {getDebugTableForVertexArray} from './debug/debug-vertex-array';\nexport {getDebugTableForProgramConfiguration} from './debug/debug-program-configuration';\n\n// DEPRECATED\n\n// Deprecated re-exports\nexport {lumaStats} from './init';\nexport {log, assert, uid, isObjectEmpty} from '@luma.gl/api';\nexport {setPathPrefix, loadFile, loadImage} from '@luma.gl/api';\n\n\n// export {\n//   getContextInfo, getGLContextInfo, getContextLimits,\n//   FEATURES,\n//   getFeatures,\n//   canCompileGLGSExtension\n// } from '@luma.gl/gltools';\n\n// REMOVED in v8.6\n// getShaderInfo,\n// getShaderName\n// getShaderVersion\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA;;AAIA;;AAGA;;AAGA;;AACA;;AAGA;;AAIA;;AAEA;;AAEA;;AAGA;;AAEA;;AAEA;;AAIA;;AAEA;;AAGA;;AAWA;;AAEA;;AAEA;;AAEA;;AAEA;;AACA;;AAEA;;AAKA;;AASA;;AAKA;;AAMA;;AAKA;;AAOA;;AAGA;;AACA;;AACA;;AACA;;AAMA;;AAWA","sourcesContent":["// luma.gl Base WebGL wrapper library\n// Provides simple class/function wrappers around the low level webgl objects\n// These classes are intentionally close to the WebGL API\n// but make it easier to use.\n// Higher level abstractions can be built on these classes\n\n// Initialize any global state\nimport './init';\n\n// export type {WebGLDeviceProps, WebGLDeviceInfo, WebGPUDeviceLimits} from './lib/webgl-device';\nexport type {WebGLDeviceProps} from './adapter/webgl-device';\nexport {default as WebGLDevice, getWebGLDevice} from './adapter/webgl-device';\n\n// UTILS\nexport {requestAnimationFrame, cancelAnimationFrame} from './webgl-utils/request-animation-frame';\n\n// WebGL Functions\nexport {cloneTextureFrom} from './webgl-utils/texture-utils';\nexport {getKeyValue, getKey} from './webgl-utils/constants-to-keys';\n\n// WebGL Helper Classes\nexport {default as Accessor} from './classes/accessor';\n\n// WebGL1 classes\nexport type {BufferProps} from '@luma.gl/api';\nexport {default as Buffer} from './classes/webgl-buffer';\nexport type {Texture2DProps} from './classes/texture-2d';\nexport {default as Texture2D} from './classes/texture-2d';\nexport type {TextureCubeProps} from './classes/texture-cube';\nexport {default as TextureCube} from './classes/texture-cube';\n\nexport type {ProgramProps} from './classes/program';\nexport {default as Program} from './classes/program';\nexport type {FramebufferProps} from './classes/framebuffer';\nexport {default as Framebuffer} from './classes/framebuffer';\nexport type {RenderbufferProps} from './classes/renderbuffer';\nexport {default as Renderbuffer} from './classes/renderbuffer';\n\n// Classic luma.gl classes (For backwards compatibility)\nexport type {ShaderProps} from './classes/shader';\nexport {Shader, VertexShader, FragmentShader} from './classes/shader';\n\nexport {clear, clearBuffer} from './classes/clear';\n\n// Copy and Blit\nexport {\n  readPixelsToArray,\n  readPixelsToBuffer,\n  copyToDataUrl,\n  copyToImage,\n  copyToTexture,\n  blit\n} from './classes/copy-and-blit';\n\n// WebGL2 classes & Extensions\nexport type {QueryProps} from './classes/query';\nexport {default as Query} from './classes/query';\nexport type {Texture3DProps} from './classes/texture-3d';\nexport {default as Texture3D} from './classes/texture-3d';\nexport type {TransformFeedbackProps} from './classes/transform-feedback';\nexport {default as TransformFeedback} from './classes/transform-feedback';\nexport type {VertexArrayObjectProps} from './classes/vertex-array-object';\nexport {default as VertexArrayObject} from './classes/vertex-array-object';\nexport type {VertexArrayProps} from './classes/vertex-array';\nexport {default as VertexArray} from './classes/vertex-array';\nexport {default as UniformBufferLayout} from './classes/uniform-buffer-layout';\n\nexport {setDeviceParameters} from './adapter/converters/set-device-parameters';\n\n// experimental WebGL exports\n\n// UTILS\nexport {\n  isWebGL,\n  isWebGL2,\n  getWebGL2Context,\n  assertWebGLContext,\n  assertWebGL2Context\n} from './context/context/webgl-checks';\n\n// Device ratio\nexport {cssToDeviceRatio, cssToDevicePixels} from './context/context/device-pixels';\n\n// Unified parameter API\n\nexport type {GLParameters} from './context/parameters/webgl-parameters';\nexport {\n  getParameters,\n  setParameters,\n  resetParameters\n} from './context/parameters/unified-parameter-api';\n\nexport {\n  withParameters\n} from './context/state-tracker/with-parameters';\n\n// State tracking\nexport {\n  trackContextState,\n  pushContextState,\n  popContextState\n} from './context/state-tracker/track-context-state';\n\n// Polyfills (supports a subset of WebGL2 APIs on WebGL1 contexts)\nexport {polyfillContext} from './context/polyfill/polyfill-context';\n\n// INTERNAL\nexport {parseUniformName, getUniformSetter} from './classes/uniforms';\nexport {getDebugTableForUniforms} from './debug/debug-uniforms';\nexport {getDebugTableForVertexArray} from './debug/debug-vertex-array';\nexport {getDebugTableForProgramConfiguration} from './debug/debug-program-configuration';\n\n// DEPRECATED\n\n// Deprecated re-exports\nexport {lumaStats} from './init';\nexport {log, assert, uid, isObjectEmpty} from '@luma.gl/api';\nexport {setPathPrefix, loadFile, loadImage} from '@luma.gl/api';\n\n// export {\n//   getContextInfo, getGLContextInfo, getContextLimits,\n//   FEATURES,\n//   getFeatures,\n//   canCompileGLGSExtension\n// } from '@luma.gl/gltools';\n\n// HELPERS - EXPERIMENTAL\nexport {getProgramBindings} from './helpers/get-program-bindings';\n\n// REMOVED in v8.7\n// getShaderInfo,\n// getShaderName\n// getShaderVersion\n"],"file":"index.js"}

package/dist/es5/init.js

@@ -17,7 +17,7 @@ var _api = require("@luma.gl/api");
 
 var _env = require("@probe.gl/env");
 
-var _webglDevice = _interopRequireDefault(require("./device/webgl-device"));
+var _webglDevice = _interopRequireDefault(require("./adapter/webgl-device"));
 
 var VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'untranspiled source';
 var STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';

package/dist/es5/init.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/init.ts"],"names":["VERSION","__VERSION__","STARTUP_MESSAGE","globalThis","luma","Error","registerDevices","WebGLDevice","log","version","stats","lumaStats","globals","modules","nodeIO"],"mappings":";;;;;;;;;;;;;;;AAAA;;AACA;;AAEA;;AAIA,IAAMA,OAAO,GAAG,OAAOC,WAAP,KAAuB,WAAvB,GAAqCA,WAArC,GAAmD,qBAAnE;AAEA,IAAMC,eAAe,GAAG,qDAAxB;;AAKA,IAAIC,UAAU,CAACC,IAAX,IAAmBD,UAAU,CAACC,IAAX,CAAgBJ,OAAhB,KAA4BA,OAAnD,EAA4D;AAC1D,QAAM,IAAIK,KAAJ,iDAAmDF,UAAU,CAACC,IAAX,CAAgBJ,OAAnE,iBAAiFA,OAAjF,EAAN;AACD;;AAED,IAAI,CAACG,UAAU,CAACC,IAAhB,EAAsB;AACpBA,YAAKE,eAAL,CAAqB,CAACC,oBAAD,CAArB;;AAEA,MAAI,qBAAJ,EAAiB;AACfC,aAAIA,GAAJ,CAAQ,CAAR,oBAAsBR,OAAtB,gBAAmCE,eAAnC;AACD;;AAEDC,EAAAA,UAAU,CAACC,IAAX,GAAkBD,UAAU,CAACC,IAAX,IAAmB;AACnCJ,IAAAA,OAAO,EAAPA,OADmC;AAEnCS,IAAAA,OAAO,EAAET,OAF0B;AAGnCQ,IAAAA,GAAG,EAAHA,QAHmC;AAOnCE,IAAAA,KAAK,EAAEC,cAP4B;AAcnCC,IAAAA,OAAO,EAAE;AACPC,MAAAA,OAAO,EAAE,EADF;AAEPC,MAAAA,MAAM,EAAE;AAFD;AAd0B,GAArC;AAmBD;;eAGcX,UAAU,CAACC,I","sourcesContent":["import {log} from '@luma.gl/api';\nimport {isBrowser} from '@probe.gl/env';\nimport {luma, lumaStats} from '@luma.gl/api';\nimport WebGLDevice from './device/webgl-device';\n\n// Version detection using babel plugin\n// @ts-expect-error\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'untranspiled source';\n\nconst STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';\n// Assign luma.log.level in console to control logging: \\\n// 0: none, 1: minimal, 2: verbose, 3: attribute/uniforms, 4: gl logs\n// luma.log.break[], set to gl funcs, luma.log.profile[] set to model names`;\n\nif (globalThis.luma && globalThis.luma.VERSION !== VERSION) {\n  throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION}`);\n}\n\nif (!globalThis.luma) {\n  luma.registerDevices([WebGLDevice]);\n\n  if (isBrowser()) {\n    log.log(1, `luma.gl ${VERSION} - ${STARTUP_MESSAGE}`)();\n  }\n\n  globalThis.luma = globalThis.luma || {\n    VERSION,\n    version: VERSION,\n    log,\n\n    // A global stats object that various components can add information to\n    // E.g. see webgl/resource.js\n    stats: lumaStats,\n\n    // Keep some luma globals in a sub-object\n    // This allows us to dynamically detect if certain modules have been\n    // included (such as IO and headless) and enable related functionality,\n    // without unconditionally requiring and thus bundling big dependencies\n    // into the app.\n    globals: {\n      modules: {},\n      nodeIO: {}\n    }\n  };\n}\n\nexport {lumaStats};\nexport default globalThis.luma;\n"],"file":"init.js"}
+{"version":3,"sources":["../../src/init.ts"],"names":["VERSION","__VERSION__","STARTUP_MESSAGE","globalThis","luma","Error","registerDevices","WebGLDevice","log","version","stats","lumaStats","globals","modules","nodeIO"],"mappings":";;;;;;;;;;;;;;;AAAA;;AACA;;AAEA;;AAIA,IAAMA,OAAO,GAAG,OAAOC,WAAP,KAAuB,WAAvB,GAAqCA,WAArC,GAAmD,qBAAnE;AAEA,IAAMC,eAAe,GAAG,qDAAxB;;AAKA,IAAIC,UAAU,CAACC,IAAX,IAAmBD,UAAU,CAACC,IAAX,CAAgBJ,OAAhB,KAA4BA,OAAnD,EAA4D;AAC1D,QAAM,IAAIK,KAAJ,iDAAmDF,UAAU,CAACC,IAAX,CAAgBJ,OAAnE,iBAAiFA,OAAjF,EAAN;AACD;;AAED,IAAI,CAACG,UAAU,CAACC,IAAhB,EAAsB;AACpBA,YAAKE,eAAL,CAAqB,CAACC,oBAAD,CAArB;;AAEA,MAAI,qBAAJ,EAAiB;AACfC,aAAIA,GAAJ,CAAQ,CAAR,oBAAsBR,OAAtB,gBAAmCE,eAAnC;AACD;;AAEDC,EAAAA,UAAU,CAACC,IAAX,GAAkBD,UAAU,CAACC,IAAX,IAAmB;AACnCJ,IAAAA,OAAO,EAAPA,OADmC;AAEnCS,IAAAA,OAAO,EAAET,OAF0B;AAGnCQ,IAAAA,GAAG,EAAHA,QAHmC;AAOnCE,IAAAA,KAAK,EAAEC,cAP4B;AAcnCC,IAAAA,OAAO,EAAE;AACPC,MAAAA,OAAO,EAAE,EADF;AAEPC,MAAAA,MAAM,EAAE;AAFD;AAd0B,GAArC;AAmBD;;eAGcX,UAAU,CAACC,I","sourcesContent":["import {log} from '@luma.gl/api';\nimport {isBrowser} from '@probe.gl/env';\nimport {luma, lumaStats} from '@luma.gl/api';\nimport WebGLDevice from './adapter/webgl-device';\n\n// Version detection using babel plugin\n// @ts-expect-error\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'untranspiled source';\n\nconst STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';\n// Assign luma.log.level in console to control logging: \\\n// 0: none, 1: minimal, 2: verbose, 3: attribute/uniforms, 4: gl logs\n// luma.log.break[], set to gl funcs, luma.log.profile[] set to model names`;\n\nif (globalThis.luma && globalThis.luma.VERSION !== VERSION) {\n  throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION}`);\n}\n\nif (!globalThis.luma) {\n  luma.registerDevices([WebGLDevice]);\n\n  if (isBrowser()) {\n    log.log(1, `luma.gl ${VERSION} - ${STARTUP_MESSAGE}`)();\n  }\n\n  globalThis.luma = globalThis.luma || {\n    VERSION,\n    version: VERSION,\n    log,\n\n    // A global stats object that various components can add information to\n    // E.g. see webgl/resource.js\n    stats: lumaStats,\n\n    // Keep some luma globals in a sub-object\n    // This allows us to dynamically detect if certain modules have been\n    // included (such as IO and headless) and enable related functionality,\n    // without unconditionally requiring and thus bundling big dependencies\n    // into the app.\n    globals: {\n      modules: {},\n      nodeIO: {}\n    }\n  };\n}\n\nexport {lumaStats};\nexport default globalThis.luma;\n"],"file":"init.js"}

package/dist/es5/types/accessor.d.ts

@@ -0,0 +1,29 @@
+// ACCESSORS
+
+/**
+ * Attribute descriptor object
+ */
+export type Accessor = {
+  format?: string;
+  offset?: number;
+  location?: number;
+
+  // can now be described with single WebGPU-style `format` string
+  type?: number;
+  size?: number;
+  normalized?: boolean;
+  integer?: boolean;
+
+  // deprecated - now shared between accessors in the surrounding BufferAccessor object
+  stride?: number;
+  divisor?: number;
+};
+
+/**
+ * List of attribute descriptors for one interleaved buffer
+ */
+export type BufferAccessors = {
+  stride?: number;
+  stepMode?: 'vertex' | 'instance';
+  attributes: Accessor[];
+}

package/dist/esm/adapter/converters/set-device-parameters.js

@@ -0,0 +1,124 @@
+import { log } from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+import { WebGLDevice } from '@luma.gl/webgl';
+export function setDeviceParameters(device, parameters) {
+  const webglDevice = WebGLDevice.attach(device);
+  const {
+    gl,
+    gl2
+  } = webglDevice;
+
+  if (parameters.cullMode) {
+    switch (parameters.cullMode) {
+      case 'none':
+        gl.disable(GL.CULL_FACE);
+        break;
+
+      case 'front':
+        gl.enable(GL.CULL_FACE);
+        gl.cullFace(GL.FRONT);
+        break;
+
+      case 'back':
+        gl.enable(GL.CULL_FACE);
+        gl.cullFace(GL.BACK);
+        break;
+    }
+  }
+
+  if (parameters.frontFace) {
+    gl.frontFace(map('frontFace', parameters.frontFace, {
+      ccw: GL.CCW,
+      cw: GL.CW
+    }));
+  }
+
+  if (parameters.depthBias !== undefined) {
+    gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
+  }
+
+  if (parameters.depthWriteEnabled !== undefined) {
+    gl.depthMask(mapBoolean('depthWriteEnabled', parameters.depthWriteEnabled));
+  }
+
+  if (parameters.depthCompare) {
+    parameters.depthCompare !== 'always' ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST), gl.depthFunc(convertCompareFunction('depthCompare', parameters.depthCompare));
+  }
+
+  if (parameters.stencilWriteMask) {
+    const mask = parameters.stencilWriteMask;
+    gl.stencilMaskSeparate(GL.FRONT, mask);
+    gl.stencilMaskSeparate(GL.BACK, mask);
+  }
+
+  if (parameters.stencilReadMask) {
+    log.warn('stencilReadMask not supported under WebGL');
+  }
+
+  if (parameters.stencilCompare) {
+    const mask = parameters.stencilReadMask || 0xffffffff;
+    const glValue = convertCompareFunction('depthCompare', parameters.stencilCompare);
+    parameters.stencilCompare !== 'always' ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST), gl.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);
+    gl.stencilFuncSeparate(GL.BACK, glValue, 0, mask);
+  }
+
+  if (parameters.stencilPassOperation) {
+    const dppass = convertStencilOperation('stencilPassOperation', parameters.stencilPassOperation);
+    const sfail = convertStencilOperation('stencilFailOperation', parameters.stencilFailOperation);
+    const dpfail = convertStencilOperation('stencilDepthFailOperation', parameters.stencilDepthFailOperation);
+    gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);
+  }
+}
+export function convertCompareFunction(parameter, value) {
+  return map(parameter, value, {
+    'never': GL.NEVER,
+    'less': GL.LESS,
+    'equal': GL.EQUAL,
+    'less-equal': GL.LEQUAL,
+    'greater': GL.GREATER,
+    'not-equal': GL.NOTEQUAL,
+    'greater-equal': GL.GEQUAL,
+    'always': GL.ALWAYS
+  });
+}
+
+function convertStencilOperation(parameter, value) {
+  return map(parameter, value, {
+    'keep': GL.KEEP,
+    'zero': GL.ZERO,
+    'replace': GL.REPLACE,
+    'invert': GL.INVERT,
+    'increment-clamp': GL.INCR,
+    'decrement-clamp': GL.DECR,
+    'increment-wrap': GL.INCR_WRAP,
+    'decrement-wrap': GL.DECR_WRAP
+  });
+}
+
+function convertBlendOperationToEquation(parameter, value) {
+  return map(parameter, value, {
+    'add': GL.FUNC_ADD,
+    'sub': GL.FUNC_SUBTRACT,
+    'reverse-subtract': GL.FUNC_REVERSE_SUBTRACT,
+    'min': GL.MIN,
+    'max': GL.MAX
+  });
+}
+
+function message(parameter, value) {
+  return "Illegal parameter ".concat(value, " for ").concat(parameter);
+}
+
+function map(parameter, value, valueMap) {
+  if (!(value in valueMap)) {
+    throw new Error(message(parameter, value));
+  }
+
+  return valueMap[value];
+}
+
+function mapBoolean(parameter, value) {
+  return value;
+}
+//# sourceMappingURL=set-device-parameters.js.map