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

package/dist/es5/index.js

@@ -2,431 +2,419 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
+var _typeof = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "lumaStats", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _init.lumaStats;
   }
 });
+Object.defineProperty(exports, "WebGLDevice", {
+  enumerable: true,
+  get: function get() {
+    return _webglDevice.default;
+  }
+});
+Object.defineProperty(exports, "getWebGLDevice", {
+  enumerable: true,
+  get: function get() {
+    return _webglDevice.getWebGLDevice;
+  }
+});
 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, "cloneTextureFrom", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _textureUtils.cloneTextureFrom;
   }
 });
 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, "getContextInfo", {
-  enumerable: true,
-  get: function () {
-    return _limits.getContextInfo;
-  }
-});
-Object.defineProperty(exports, "getGLContextInfo", {
-  enumerable: true,
-  get: function () {
-    return _limits.getGLContextInfo;
-  }
-});
-Object.defineProperty(exports, "getContextLimits", {
-  enumerable: true,
-  get: function () {
-    return _limits.getContextLimits;
-  }
-});
-Object.defineProperty(exports, "FEATURES", {
-  enumerable: true,
-  get: function () {
-    return _webglFeaturesTable.FEATURES;
-  }
-});
-Object.defineProperty(exports, "hasFeature", {
-  enumerable: true,
-  get: function () {
-    return _features.hasFeature;
-  }
-});
-Object.defineProperty(exports, "hasFeatures", {
-  enumerable: true,
-  get: function () {
-    return _features.hasFeatures;
-  }
-});
-Object.defineProperty(exports, "getFeatures", {
-  enumerable: true,
-  get: function () {
-    return _features.getFeatures;
-  }
-});
-Object.defineProperty(exports, "canCompileGLGSExtension", {
-  enumerable: true,
-  get: function () {
-    return _checkGlslExtension.default;
-  }
-});
 Object.defineProperty(exports, "Accessor", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _accessor.default;
   }
 });
 Object.defineProperty(exports, "Buffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _webglBuffer.default;
   }
 });
 Object.defineProperty(exports, "Texture2D", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _texture2d.default;
   }
 });
-Object.defineProperty(exports, "Texture2DProps", {
-  enumerable: true,
-  get: function () {
-    return _texture2d.Texture2DProps;
-  }
-});
 Object.defineProperty(exports, "TextureCube", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _textureCube.default;
   }
 });
-Object.defineProperty(exports, "TextureCubeProps", {
-  enumerable: true,
-  get: function () {
-    return _textureCube.TextureCubeProps;
-  }
-});
 Object.defineProperty(exports, "Shader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _webglShader.Shader;
   }
 });
 Object.defineProperty(exports, "VertexShader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _webglShader.VertexShader;
   }
 });
 Object.defineProperty(exports, "FragmentShader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _webglShader.FragmentShader;
   }
 });
-Object.defineProperty(exports, "ShaderProps", {
-  enumerable: true,
-  get: function () {
-    return _webglShader.ShaderProps;
-  }
-});
 Object.defineProperty(exports, "Program", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _program.default;
   }
 });
-Object.defineProperty(exports, "ProgramProps", {
-  enumerable: true,
-  get: function () {
-    return _program.ProgramProps;
-  }
-});
 Object.defineProperty(exports, "Framebuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _framebuffer.default;
   }
 });
-Object.defineProperty(exports, "FramebufferProps", {
-  enumerable: true,
-  get: function () {
-    return _framebuffer.FramebufferProps;
-  }
-});
 Object.defineProperty(exports, "Renderbuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _renderbuffer.default;
   }
 });
-Object.defineProperty(exports, "RenderbufferProps", {
-  enumerable: true,
-  get: function () {
-    return _renderbuffer.RenderbufferProps;
-  }
-});
 Object.defineProperty(exports, "clear", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _clear.clear;
   }
 });
 Object.defineProperty(exports, "clearBuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _clear.clearBuffer;
   }
 });
 Object.defineProperty(exports, "readPixelsToArray", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _copyAndBlit.readPixelsToArray;
   }
 });
 Object.defineProperty(exports, "readPixelsToBuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _copyAndBlit.readPixelsToBuffer;
   }
 });
 Object.defineProperty(exports, "copyToDataUrl", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _copyAndBlit.copyToDataUrl;
   }
 });
 Object.defineProperty(exports, "copyToImage", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _copyAndBlit.copyToImage;
   }
 });
 Object.defineProperty(exports, "copyToTexture", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _copyAndBlit.copyToTexture;
   }
 });
 Object.defineProperty(exports, "blit", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _copyAndBlit.blit;
   }
 });
 Object.defineProperty(exports, "Query", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _query.default;
   }
 });
-Object.defineProperty(exports, "QueryProps", {
+Object.defineProperty(exports, "Texture3D", {
   enumerable: true,
-  get: function () {
-    return _query.QueryProps;
+  get: function get() {
+    return _texture3d.default;
   }
 });
-Object.defineProperty(exports, "Texture3D", {
+Object.defineProperty(exports, "TransformFeedback", {
   enumerable: true,
-  get: function () {
-    return _texture3d.default;
+  get: function get() {
+    return _transformFeedback.default;
   }
 });
-Object.defineProperty(exports, "Texture3DProps", {
+Object.defineProperty(exports, "VertexArrayObject", {
   enumerable: true,
-  get: function () {
-    return _texture3d.Texture3DProps;
+  get: function get() {
+    return _vertexArrayObject.default;
   }
 });
-Object.defineProperty(exports, "TransformFeedback", {
+Object.defineProperty(exports, "VertexArray", {
   enumerable: true,
-  get: function () {
-    return _transformFeedback.default;
+  get: function get() {
+    return _vertexArray.default;
   }
 });
-Object.defineProperty(exports, "TransformFeedbackProps", {
+Object.defineProperty(exports, "UniformBufferLayout", {
   enumerable: true,
-  get: function () {
-    return _transformFeedback.TransformFeedbackProps;
+  get: function get() {
+    return _uniformBufferLayout.default;
   }
 });
-Object.defineProperty(exports, "VertexArrayObject", {
+Object.defineProperty(exports, "isWebGL", {
   enumerable: true,
-  get: function () {
-    return _vertexArrayObject.default;
+  get: function get() {
+    return _webglChecks.isWebGL;
   }
 });
-Object.defineProperty(exports, "VertexArrayObjectProps", {
+Object.defineProperty(exports, "isWebGL2", {
   enumerable: true,
-  get: function () {
-    return _vertexArrayObject.VertexArrayObjectProps;
+  get: function get() {
+    return _webglChecks.isWebGL2;
   }
 });
-Object.defineProperty(exports, "VertexArray", {
+Object.defineProperty(exports, "getWebGL2Context", {
   enumerable: true,
-  get: function () {
-    return _vertexArray.default;
+  get: function get() {
+    return _webglChecks.getWebGL2Context;
   }
 });
-Object.defineProperty(exports, "VertexArrayProps", {
+Object.defineProperty(exports, "assertWebGLContext", {
   enumerable: true,
-  get: function () {
-    return _vertexArray.VertexArrayProps;
+  get: function get() {
+    return _webglChecks.assertWebGLContext;
   }
 });
-Object.defineProperty(exports, "UniformBufferLayout", {
+Object.defineProperty(exports, "assertWebGL2Context", {
   enumerable: true,
-  get: function () {
-    return _uniformBufferLayout.default;
+  get: function get() {
+    return _webglChecks.assertWebGL2Context;
   }
 });
-Object.defineProperty(exports, "setPathPrefix", {
+Object.defineProperty(exports, "cssToDeviceRatio", {
   enumerable: true,
-  get: function () {
-    return _loadFile.setPathPrefix;
+  get: function get() {
+    return _devicePixels.cssToDeviceRatio;
   }
 });
-Object.defineProperty(exports, "loadFile", {
+Object.defineProperty(exports, "cssToDevicePixels", {
   enumerable: true,
-  get: function () {
-    return _loadFile.loadFile;
+  get: function get() {
+    return _devicePixels.cssToDevicePixels;
   }
 });
-Object.defineProperty(exports, "loadImage", {
+Object.defineProperty(exports, "getParameters", {
   enumerable: true,
-  get: function () {
-    return _loadFile.loadImage;
+  get: function get() {
+    return _unifiedParameterApi.getParameters;
   }
 });
-Object.defineProperty(exports, "log", {
+Object.defineProperty(exports, "setParameters", {
   enumerable: true,
-  get: function () {
-    return _gltools.log;
+  get: function get() {
+    return _unifiedParameterApi.setParameters;
   }
 });
-Object.defineProperty(exports, "assert", {
+Object.defineProperty(exports, "resetParameters", {
   enumerable: true,
-  get: function () {
-    return _assert.default;
+  get: function get() {
+    return _unifiedParameterApi.resetParameters;
   }
 });
-Object.defineProperty(exports, "uid", {
+Object.defineProperty(exports, "withParameters", {
   enumerable: true,
-  get: function () {
-    return _utils.uid;
+  get: function get() {
+    return _withParameters.withParameters;
   }
 });
-Object.defineProperty(exports, "isObjectEmpty", {
+Object.defineProperty(exports, "trackContextState", {
   enumerable: true,
-  get: function () {
-    return _utils.isObjectEmpty;
+  get: function get() {
+    return _trackContextState.trackContextState;
+  }
+});
+Object.defineProperty(exports, "pushContextState", {
+  enumerable: true,
+  get: function get() {
+    return _trackContextState.pushContextState;
+  }
+});
+Object.defineProperty(exports, "popContextState", {
+  enumerable: true,
+  get: function get() {
+    return _trackContextState.popContextState;
+  }
+});
+Object.defineProperty(exports, "polyfillContext", {
+  enumerable: true,
+  get: function get() {
+    return _polyfillContext.polyfillContext;
   }
 });
 Object.defineProperty(exports, "parseUniformName", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _uniforms.parseUniformName;
   }
 });
 Object.defineProperty(exports, "getUniformSetter", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _uniforms.getUniformSetter;
   }
 });
 Object.defineProperty(exports, "getDebugTableForUniforms", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _debugUniforms.getDebugTableForUniforms;
   }
 });
 Object.defineProperty(exports, "getDebugTableForVertexArray", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _debugVertexArray.getDebugTableForVertexArray;
   }
 });
 Object.defineProperty(exports, "getDebugTableForProgramConfiguration", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _debugProgramConfiguration.getDebugTableForProgramConfiguration;
   }
 });
+Object.defineProperty(exports, "log", {
+  enumerable: true,
+  get: function get() {
+    return _api.log;
+  }
+});
+Object.defineProperty(exports, "assert", {
+  enumerable: true,
+  get: function get() {
+    return _api.assert;
+  }
+});
+Object.defineProperty(exports, "uid", {
+  enumerable: true,
+  get: function get() {
+    return _api.uid;
+  }
+});
+Object.defineProperty(exports, "isObjectEmpty", {
+  enumerable: true,
+  get: function get() {
+    return _api.isObjectEmpty;
+  }
+});
+Object.defineProperty(exports, "setPathPrefix", {
+  enumerable: true,
+  get: function get() {
+    return _api.setPathPrefix;
+  }
+});
+Object.defineProperty(exports, "loadFile", {
+  enumerable: true,
+  get: function get() {
+    return _api.loadFile;
+  }
+});
+Object.defineProperty(exports, "loadImage", {
+  enumerable: true,
+  get: function get() {
+    return _api.loadImage;
+  }
+});
 
 var _init = require("./init");
 
+var _webglDevice = _interopRequireWildcard(require("./device/webgl-device"));
+
 var _requestAnimationFrame = require("./webgl-utils/request-animation-frame");
 
 var _textureUtils = require("./webgl-utils/texture-utils");
 
 var _constantsToKeys = require("./webgl-utils/constants-to-keys");
 
-var _limits = require("./features/limits");
-
-var _webglFeaturesTable = require("./features/webgl-features-table");
-
-var _features = require("./features/features");
-
-var _checkGlslExtension = _interopRequireDefault(require("./features/check-glsl-extension"));
-
 var _accessor = _interopRequireDefault(require("./classes/accessor"));
 
 var _webglBuffer = _interopRequireDefault(require("./classes/webgl-buffer"));
 
-var _texture2d = _interopRequireWildcard(require("./classes/texture-2d"));
+var _texture2d = _interopRequireDefault(require("./classes/texture-2d"));
 
-var _textureCube = _interopRequireWildcard(require("./classes/texture-cube"));
+var _textureCube = _interopRequireDefault(require("./classes/texture-cube"));
 
 var _webglShader = require("./classes/webgl-shader");
 
-var _program = _interopRequireWildcard(require("./classes/program"));
+var _program = _interopRequireDefault(require("./classes/program"));
 
-var _framebuffer = _interopRequireWildcard(require("./classes/framebuffer"));
+var _framebuffer = _interopRequireDefault(require("./classes/framebuffer"));
 
-var _renderbuffer = _interopRequireWildcard(require("./classes/renderbuffer"));
+var _renderbuffer = _interopRequireDefault(require("./classes/renderbuffer"));
 
 var _clear = require("./classes/clear");
 
 var _copyAndBlit = require("./classes/copy-and-blit");
 
-var _query = _interopRequireWildcard(require("./classes/query"));
+var _query = _interopRequireDefault(require("./classes/query"));
 
-var _texture3d = _interopRequireWildcard(require("./classes/texture-3d"));
+var _texture3d = _interopRequireDefault(require("./classes/texture-3d"));
 
-var _transformFeedback = _interopRequireWildcard(require("./classes/transform-feedback"));
+var _transformFeedback = _interopRequireDefault(require("./classes/transform-feedback"));
 
-var _vertexArrayObject = _interopRequireWildcard(require("./classes/vertex-array-object"));
+var _vertexArrayObject = _interopRequireDefault(require("./classes/vertex-array-object"));
 
-var _vertexArray = _interopRequireWildcard(require("./classes/vertex-array"));
+var _vertexArray = _interopRequireDefault(require("./classes/vertex-array"));
 
 var _uniformBufferLayout = _interopRequireDefault(require("./classes/uniform-buffer-layout"));
 
-var _loadFile = require("./utils/load-file");
+var _webglChecks = require("./context/context/webgl-checks");
 
-var _gltools = require("@luma.gl/gltools");
+var _devicePixels = require("./context/context/device-pixels");
 
-var _assert = _interopRequireDefault(require("./utils/assert"));
+var _unifiedParameterApi = require("./context/parameters/unified-parameter-api");
 
-var _utils = require("./utils/utils");
+var _withParameters = require("./context/state-tracker/with-parameters");
+
+var _trackContextState = require("./context/state-tracker/track-context-state");
+
+var _polyfillContext = require("./context/polyfill/polyfill-context");
 
 var _uniforms = require("./classes/uniforms");
 
@@ -436,7 +424,9 @@ var _debugVertexArray = require("./debug/debug-vertex-array");
 
 var _debugProgramConfiguration = require("./debug/debug-program-configuration");
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+var _api = require("@luma.gl/api");
+
+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; }
+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; }
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA;;AAGA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA;;AAIA;;AACA;;AACA;;AAEA;;AACA;;AACA;;AACA;;AAEA;;AAGA;;AAUA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAIA;;AAGA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AACA","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\nexport {lumaStats} from './init';\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';\nexport {getContextInfo, getGLContextInfo, getContextLimits} from './features/limits';\nexport {FEATURES} from './features/webgl-features-table';\nexport {hasFeature, hasFeatures, getFeatures} from './features/features';\nexport {default as canCompileGLGSExtension} from './features/check-glsl-extension';\n\n// WebGL Helper Classes\nexport {default as Accessor} from './classes/accessor';\n\n// WebGL1 classes\n// export type {BufferProps} from './api/buffer';\nexport {default as Buffer} from './classes/webgl-buffer';\nexport {default as Texture2D, Texture2DProps} from './classes/texture-2d';\nexport {default as TextureCube, TextureCubeProps} from './classes/texture-cube';\n\nexport {Shader, VertexShader, FragmentShader, ShaderProps} from './classes/webgl-shader';\nexport {default as Program, ProgramProps} from './classes/program';\nexport {default as Framebuffer, FramebufferProps} from './classes/framebuffer';\nexport {default as Renderbuffer, RenderbufferProps} 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 {default as Query, QueryProps} from './classes/query';\nexport {default as Texture3D, Texture3DProps} from './classes/texture-3d';\nexport {default as TransformFeedback, TransformFeedbackProps} from './classes/transform-feedback';\nexport {default as VertexArrayObject, VertexArrayObjectProps} from './classes/vertex-array-object';\nexport {default as VertexArray, VertexArrayProps} from './classes/vertex-array';\nexport {default as UniformBufferLayout} from './classes/uniform-buffer-layout';\n\n// experimental WebGL exports\n\nexport {setPathPrefix, loadFile, loadImage} from './utils/load-file';\n\n// UTILS\nexport {log} from '@luma.gl/gltools';\nexport {default as assert} from './utils/assert';\nexport {uid, isObjectEmpty} from './utils/utils';\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// 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;;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"}