@luma.gl/webgl 8.6.0-alpha.4 → 9.0.0-alpha.10

package/dist/es5/index.js

@@ -2,15 +2,13 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _typeof = require("@babel/runtime/helpers/typeof");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "lumaStats", {
+Object.defineProperty(exports, "registerHeadlessGL", {
   enumerable: true,
   get: function get() {
-    return _init.lumaStats;
+    return _createHeadlessContext.registerHeadlessGL;
   }
 });
 Object.defineProperty(exports, "WebGLDevice", {
@@ -19,190 +17,100 @@ Object.defineProperty(exports, "WebGLDevice", {
     return _webglDevice.default;
   }
 });
-Object.defineProperty(exports, "getWebGLDevice", {
-  enumerable: true,
-  get: function get() {
-    return _webglDevice.getWebGLDevice;
-  }
-});
-Object.defineProperty(exports, "requestAnimationFrame", {
-  enumerable: true,
-  get: function get() {
-    return _requestAnimationFrame.requestAnimationFrame;
-  }
-});
-Object.defineProperty(exports, "cancelAnimationFrame", {
-  enumerable: true,
-  get: function get() {
-    return _requestAnimationFrame.cancelAnimationFrame;
-  }
-});
-Object.defineProperty(exports, "cloneTextureFrom", {
+Object.defineProperty(exports, "WebGLCanvasContext", {
   enumerable: true,
   get: function get() {
-    return _textureUtils.cloneTextureFrom;
+    return _webglCanvasContext.default;
   }
 });
-Object.defineProperty(exports, "getKeyValue", {
+Object.defineProperty(exports, "WEBGLResource", {
   enumerable: true,
   get: function get() {
-    return _constantsToKeys.getKeyValue;
+    return _webglResource.default;
   }
 });
-Object.defineProperty(exports, "getKey", {
+Object.defineProperty(exports, "WebGLResource", {
   enumerable: true,
   get: function get() {
-    return _constantsToKeys.getKey;
+    return _webglResource.default;
   }
 });
-Object.defineProperty(exports, "Accessor", {
-  enumerable: true,
-  get: function get() {
-    return _accessor.default;
-  }
-});
-Object.defineProperty(exports, "Buffer", {
+Object.defineProperty(exports, "WEBGLBuffer", {
   enumerable: true,
   get: function get() {
     return _webglBuffer.default;
   }
 });
-Object.defineProperty(exports, "Texture2D", {
-  enumerable: true,
-  get: function get() {
-    return _texture2d.default;
-  }
-});
-Object.defineProperty(exports, "TextureCube", {
-  enumerable: true,
-  get: function get() {
-    return _textureCube.default;
-  }
-});
-Object.defineProperty(exports, "Program", {
-  enumerable: true,
-  get: function get() {
-    return _program.default;
-  }
-});
-Object.defineProperty(exports, "Framebuffer", {
-  enumerable: true,
-  get: function get() {
-    return _framebuffer.default;
-  }
-});
-Object.defineProperty(exports, "Renderbuffer", {
-  enumerable: true,
-  get: function get() {
-    return _renderbuffer.default;
-  }
-});
-Object.defineProperty(exports, "Shader", {
-  enumerable: true,
-  get: function get() {
-    return _shader.Shader;
-  }
-});
-Object.defineProperty(exports, "VertexShader", {
+Object.defineProperty(exports, "WEBGLTexture", {
   enumerable: true,
   get: function get() {
-    return _shader.VertexShader;
+    return _webglTexture.default;
   }
 });
-Object.defineProperty(exports, "FragmentShader", {
+Object.defineProperty(exports, "WEBGLShader", {
   enumerable: true,
   get: function get() {
-    return _shader.FragmentShader;
+    return _webglShader.default;
   }
 });
-Object.defineProperty(exports, "clear", {
+Object.defineProperty(exports, "WEBGLSampler", {
   enumerable: true,
   get: function get() {
-    return _clear.clear;
+    return _webglSampler.default;
   }
 });
-Object.defineProperty(exports, "clearBuffer", {
+Object.defineProperty(exports, "WEBGLFramebuffer", {
   enumerable: true,
   get: function get() {
-    return _clear.clearBuffer;
+    return _webglFramebuffer.default;
   }
 });
-Object.defineProperty(exports, "readPixelsToArray", {
+Object.defineProperty(exports, "WEBGLRenderPipeline", {
   enumerable: true,
   get: function get() {
-    return _copyAndBlit.readPixelsToArray;
+    return _webglRenderPipeline.default;
   }
 });
-Object.defineProperty(exports, "readPixelsToBuffer", {
+Object.defineProperty(exports, "WEBGLCommandEncoder", {
   enumerable: true,
   get: function get() {
-    return _copyAndBlit.readPixelsToBuffer;
+    return _webglCommandEncoder.default;
   }
 });
-Object.defineProperty(exports, "copyToDataUrl", {
+Object.defineProperty(exports, "WEBGLRenderPass", {
   enumerable: true,
   get: function get() {
-    return _copyAndBlit.copyToDataUrl;
+    return _webglRenderPass.default;
   }
 });
-Object.defineProperty(exports, "copyToImage", {
+Object.defineProperty(exports, "WEBGLRenderbuffer", {
   enumerable: true,
   get: function get() {
-    return _copyAndBlit.copyToImage;
+    return _webglRenderbuffer.default;
   }
 });
-Object.defineProperty(exports, "copyToTexture", {
+Object.defineProperty(exports, "WEBGLVertexArrayObject", {
   enumerable: true,
   get: function get() {
-    return _copyAndBlit.copyToTexture;
+    return _webglVertexArrayObject.default;
   }
 });
-Object.defineProperty(exports, "blit", {
-  enumerable: true,
-  get: function get() {
-    return _copyAndBlit.blit;
-  }
-});
-Object.defineProperty(exports, "Query", {
-  enumerable: true,
-  get: function get() {
-    return _query.default;
-  }
-});
-Object.defineProperty(exports, "Texture3D", {
-  enumerable: true,
-  get: function get() {
-    return _texture3d.default;
-  }
-});
-Object.defineProperty(exports, "TransformFeedback", {
-  enumerable: true,
-  get: function get() {
-    return _transformFeedback.default;
-  }
-});
-Object.defineProperty(exports, "VertexArrayObject", {
-  enumerable: true,
-  get: function get() {
-    return _vertexArrayObject.default;
-  }
-});
-Object.defineProperty(exports, "VertexArray", {
+Object.defineProperty(exports, "Accessor", {
   enumerable: true,
   get: function get() {
-    return _vertexArray.default;
+    return _accessor.default;
   }
 });
-Object.defineProperty(exports, "UniformBufferLayout", {
+Object.defineProperty(exports, "ClassicBuffer", {
   enumerable: true,
   get: function get() {
-    return _uniformBufferLayout.default;
+    return _buffer.default;
   }
 });
-Object.defineProperty(exports, "setDeviceParameters", {
+Object.defineProperty(exports, "Buffer", {
   enumerable: true,
   get: function get() {
-    return _setDeviceParameters.setDeviceParameters;
+    return _buffer.default;
   }
 });
 Object.defineProperty(exports, "isWebGL", {
@@ -247,6 +155,18 @@ Object.defineProperty(exports, "cssToDevicePixels", {
     return _devicePixels.cssToDevicePixels;
   }
 });
+Object.defineProperty(exports, "setDeviceParameters", {
+  enumerable: true,
+  get: function get() {
+    return _deviceParameters.setDeviceParameters;
+  }
+});
+Object.defineProperty(exports, "withDeviceParameters", {
+  enumerable: true,
+  get: function get() {
+    return _deviceParameters.withDeviceParameters;
+  }
+});
 Object.defineProperty(exports, "getParameters", {
   enumerable: true,
   get: function get() {
@@ -295,199 +215,67 @@ Object.defineProperty(exports, "polyfillContext", {
     return _polyfillContext.polyfillContext;
   }
 });
-Object.defineProperty(exports, "parseUniformName", {
-  enumerable: true,
-  get: function get() {
-    return _uniforms.parseUniformName;
-  }
-});
-Object.defineProperty(exports, "getUniformSetter", {
-  enumerable: true,
-  get: function get() {
-    return _uniforms.getUniformSetter;
-  }
-});
-Object.defineProperty(exports, "getDebugTableForUniforms", {
-  enumerable: true,
-  get: function get() {
-    return _debugUniforms.getDebugTableForUniforms;
-  }
-});
-Object.defineProperty(exports, "getDebugTableForVertexArray", {
-  enumerable: true,
-  get: function get() {
-    return _debugVertexArray.getDebugTableForVertexArray;
-  }
-});
-Object.defineProperty(exports, "getDebugTableForProgramConfiguration", {
+Object.defineProperty(exports, "getShaderLayout", {
   enumerable: true,
   get: function get() {
-    return _debugProgramConfiguration.getDebugTableForProgramConfiguration;
+    return _getShaderLayout.getShaderLayout;
   }
 });
 Object.defineProperty(exports, "getProgramBindings", {
   enumerable: true,
   get: function get() {
-    return _getProgramBindings.getProgramBindings;
-  }
-});
-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;
+    return _getShaderLayout.getProgramBindings;
   }
 });
-Object.defineProperty(exports, "setPathPrefix", {
+Object.defineProperty(exports, "_checkFloat32ColorAttachment", {
   enumerable: true,
   get: function get() {
-    return _api.setPathPrefix;
+    return _textureFormats._checkFloat32ColorAttachment;
   }
 });
-Object.defineProperty(exports, "loadFile", {
-  enumerable: true,
-  get: function get() {
-    return _api.loadFile;
-  }
-});
-Object.defineProperty(exports, "loadImage", {
-  enumerable: true,
-  get: function get() {
-    return _api.loadImage;
-  }
-});
-Object.defineProperty(exports, "createGLContext", {
-  enumerable: true,
-  get: function get() {
-    return _contextApi.createGLContext;
-  }
-});
-Object.defineProperty(exports, "instrumentGLContext", {
-  enumerable: true,
-  get: function get() {
-    return _contextApi.instrumentGLContext;
-  }
-});
-Object.defineProperty(exports, "resizeGLContext", {
-  enumerable: true,
-  get: function get() {
-    return _contextApi.resizeGLContext;
-  }
-});
-Object.defineProperty(exports, "hasFeature", {
-  enumerable: true,
-  get: function get() {
-    return _contextApi.hasFeature;
-  }
-});
-Object.defineProperty(exports, "hasFeatures", {
-  enumerable: true,
-  get: function get() {
-    return _contextApi.hasFeatures;
-  }
-});
-Object.defineProperty(exports, "getFeatures", {
-  enumerable: true,
-  get: function get() {
-    return _contextApi.getFeatures;
-  }
-});
-Object.defineProperty(exports, "getContextInfo", {
-  enumerable: true,
-  get: function get() {
-    return _contextApi.getContextInfo;
-  }
-});
-Object.defineProperty(exports, "getGLContextInfo", {
-  enumerable: true,
-  get: function get() {
-    return _contextApi.getGLContextInfo;
-  }
-});
-Object.defineProperty(exports, "getContextLimits", {
-  enumerable: true,
-  get: function get() {
-    return _contextApi.getContextLimits;
-  }
-});
-Object.defineProperty(exports, "getContextDebugInfo", {
-  enumerable: true,
-  get: function get() {
-    return _contextApi.getContextDebugInfo;
-  }
-});
-Object.defineProperty(exports, "FEATURES", {
-  enumerable: true,
-  get: function get() {
-    return _features.FEATURES;
-  }
-});
-
-var _init = require("./init");
-
-var _webglDevice = _interopRequireWildcard(require("./adapter/webgl-device"));
-
-var _requestAnimationFrame = require("./webgl-utils/request-animation-frame");
 
-var _textureUtils = require("./webgl-utils/texture-utils");
+require("@luma.gl/api");
 
-var _constantsToKeys = require("./webgl-utils/constants-to-keys");
+require("./init");
 
-var _accessor = _interopRequireDefault(require("./classes/accessor"));
+var _createHeadlessContext = require("./context/context/create-headless-context");
 
-var _webglBuffer = _interopRequireDefault(require("./classes/webgl-buffer"));
+var _webglDevice = _interopRequireDefault(require("./adapter/webgl-device"));
 
-var _texture2d = _interopRequireDefault(require("./classes/texture-2d"));
+var _webglCanvasContext = _interopRequireDefault(require("./adapter/webgl-canvas-context"));
 
-var _textureCube = _interopRequireDefault(require("./classes/texture-cube"));
+var _webglResource = _interopRequireDefault(require("./adapter/objects/webgl-resource"));
 
-var _program = _interopRequireDefault(require("./classes/program"));
+var _webglBuffer = _interopRequireDefault(require("./adapter/resources/webgl-buffer"));
 
-var _framebuffer = _interopRequireDefault(require("./classes/framebuffer"));
+var _webglTexture = _interopRequireDefault(require("./adapter/resources/webgl-texture"));
 
-var _renderbuffer = _interopRequireDefault(require("./classes/renderbuffer"));
+var _webglShader = _interopRequireDefault(require("./adapter/resources/webgl-shader"));
 
-var _shader = require("./classes/shader");
+var _webglSampler = _interopRequireDefault(require("./adapter/resources/webgl-sampler"));
 
-var _clear = require("./classes/clear");
+var _webglFramebuffer = _interopRequireDefault(require("./adapter/resources/webgl-framebuffer"));
 
-var _copyAndBlit = require("./classes/copy-and-blit");
+var _webglRenderPipeline = _interopRequireDefault(require("./adapter/resources/webgl-render-pipeline"));
 
-var _query = _interopRequireDefault(require("./classes/query"));
+var _webglCommandEncoder = _interopRequireDefault(require("./adapter/resources/webgl-command-encoder"));
 
-var _texture3d = _interopRequireDefault(require("./classes/texture-3d"));
+var _webglRenderPass = _interopRequireDefault(require("./adapter/resources/webgl-render-pass"));
 
-var _transformFeedback = _interopRequireDefault(require("./classes/transform-feedback"));
+var _webglRenderbuffer = _interopRequireDefault(require("./adapter/objects/webgl-renderbuffer"));
 
-var _vertexArrayObject = _interopRequireDefault(require("./classes/vertex-array-object"));
+var _webglVertexArrayObject = _interopRequireDefault(require("./adapter/objects/webgl-vertex-array-object"));
 
-var _vertexArray = _interopRequireDefault(require("./classes/vertex-array"));
+var _accessor = _interopRequireDefault(require("./classic/accessor"));
 
-var _uniformBufferLayout = _interopRequireDefault(require("./classes/uniform-buffer-layout"));
-
-var _setDeviceParameters = require("./adapter/converters/set-device-parameters");
+var _buffer = _interopRequireDefault(require("./classic/buffer"));
 
 var _webglChecks = require("./context/context/webgl-checks");
 
 var _devicePixels = require("./context/context/device-pixels");
 
+var _deviceParameters = require("./adapter/converters/device-parameters");
+
 var _unifiedParameterApi = require("./context/parameters/unified-parameter-api");
 
 var _withParameters = require("./context/state-tracker/with-parameters");
@@ -496,23 +284,7 @@ var _trackContextState = require("./context/state-tracker/track-context-state");
 
 var _polyfillContext = require("./context/polyfill/polyfill-context");
 
-var _uniforms = require("./classes/uniforms");
-
-var _debugUniforms = require("./debug/debug-uniforms");
-
-var _debugVertexArray = require("./debug/debug-vertex-array");
-
-var _debugProgramConfiguration = require("./debug/debug-program-configuration");
-
-var _getProgramBindings = require("./helpers/get-program-bindings");
-
-var _api = require("@luma.gl/api");
-
-var _contextApi = require("./_deprecated/context-api");
-
-var _features = require("./_deprecated/features");
-
-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); }
+var _getShaderLayout = require("./adapter/helpers/get-shader-layout");
 
-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; }
+var _textureFormats = require("./adapter/converters/texture-formats");
 //# sourceMappingURL=index.js.map

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;;AAIA;;AAEA;;AAGA;;AAWA;;AAEA;;AAEA;;AAEA;;AAEA;;AACA;;AAEA;;AAKA;;AASA;;AAKA;;AAMA;;AAKA;;AAOA;;AAGA;;AACA;;AACA;;AACA;;AAGA;;AAMA;;AAKA;;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\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// HELPERS - EXPERIMENTAL\nexport {getProgramBindings} from './helpers/get-program-bindings';\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// GLTOOLS\nexport type {GLContextOptions} from './_deprecated/context-api';\nexport {\n  createGLContext,\n  instrumentGLContext,\n  resizeGLContext,\n  hasFeature,\n  hasFeatures,\n  getFeatures,\n  getContextInfo,\n  getGLContextInfo,\n  getContextLimits,\n  getContextDebugInfo\n} from './_deprecated/context-api';\n\n// Features\nexport {FEATURES} from './_deprecated/features';\n\n// REMOVED in v8.7\n// getShaderInfo,\n// getShaderName\n// getShaderVersion\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA;;AACA;;AAKA;;AAGA;;AACA;;AAGA;;AACA;;AACA;;AAEA;;AACA;;AACA;;AAEA;;AAEA;;AACA;;AAKA;;AACA;;AAGA;;AAGA;;AAEA;;AASA;;AAIA;;AAGA;;AAMA;;AAKA;;AAOA;;AAGA;;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\nimport '@luma.gl/api';\nimport './init'\n\n// Types\nexport type {WebGLLimits} from './adapter/device-helpers/device-limits';\n\nexport {registerHeadlessGL} from './context/context/create-headless-context';\n\n// WebGL adapter classes\nexport {default as WebGLDevice} from './adapter/webgl-device';\nexport {default as WebGLCanvasContext} from './adapter/webgl-canvas-context';\n\n// WebGL Resource classes\nexport {default as WEBGLResource, default as WebGLResource} from './adapter/objects/webgl-resource';\nexport {default as WEBGLBuffer} from './adapter/resources/webgl-buffer';\nexport {default as WEBGLTexture} from './adapter/resources/webgl-texture';\n// export {default as WEBGLExternalTexture} from './adapter/resources/webgl-external-texture';\nexport {default as WEBGLShader} from './adapter/resources/webgl-shader';\nexport {default as WEBGLSampler} from './adapter/resources/webgl-sampler';\nexport {default as WEBGLFramebuffer} from './adapter/resources/webgl-framebuffer';\n\nexport {default as WEBGLRenderPipeline} from './adapter/resources/webgl-render-pipeline';\n// export {default as WEBGLComputePipeline} from './adapter/resources/webgl-compute-pipeline';\nexport {default as WEBGLCommandEncoder} from './adapter/resources/webgl-command-encoder';\nexport {default as WEBGLRenderPass} from './adapter/resources/webgl-render-pass';\n//export {default as WEBGLComputePass} from './adapter/resources/webgl-compute-pass';\n\n// non-api resources\nexport type {RenderbufferProps} from './adapter/objects/webgl-renderbuffer';\nexport {default as WEBGLRenderbuffer} from './adapter/objects/webgl-renderbuffer';\nexport {default as WEBGLVertexArrayObject} from './adapter/objects/webgl-vertex-array-object';\n\n// WebGL adapter classes (Legacy, will be moved to gltools)\nexport {default as Accessor} from './classic/accessor';\nexport type {AccessorObject} from './types';\nexport type {ClassicBufferProps, ClassicBufferProps as BufferProps} from './classic/buffer';\nexport {default as ClassicBuffer, default as Buffer} from './classic/buffer';\n\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 {setDeviceParameters, withDeviceParameters} from './adapter/converters/device-parameters';\n\nexport type {GLParameters} from './types/webgl';\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// HELPERS - EXPERIMENTAL\nexport {getShaderLayout, getProgramBindings} from './adapter/helpers/get-shader-layout';\nexport {_checkFloat32ColorAttachment} from './adapter/converters/texture-formats';\n"],"file":"index.js"}

package/dist/es5/init.js

@@ -2,49 +2,9 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "lumaStats", {
-  enumerable: true,
-  get: function get() {
-    return _api.lumaStats;
-  }
-});
-exports.default = void 0;
-
 var _api = require("@luma.gl/api");
 
-var _env = require("@probe.gl/env");
-
 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';
-
-if (globalThis.luma && globalThis.luma.VERSION !== VERSION) {
-  throw new Error("luma.gl - multiple VERSIONs detected: ".concat(globalThis.luma.VERSION, " vs ").concat(VERSION));
-}
-
-if (!globalThis.luma) {
-  _api.luma.registerDevices([_webglDevice.default]);
-
-  if ((0, _env.isBrowser)()) {
-    _api.log.log(1, "luma.gl ".concat(VERSION, " - ").concat(STARTUP_MESSAGE))();
-  }
-
-  globalThis.luma = globalThis.luma || {
-    VERSION: VERSION,
-    version: VERSION,
-    log: _api.log,
-    stats: _api.lumaStats,
-    globals: {
-      modules: {},
-      nodeIO: {}
-    }
-  };
-}
-
-var _default = globalThis.luma;
-exports.default = _default;
+_api.luma.registerDevices([_webglDevice.default]);
 //# sourceMappingURL=init.js.map

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 './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"}
+{"version":3,"sources":["../../src/init.ts"],"names":["luma","registerDevices","WebGLDevice"],"mappings":";;;;AAAA;;AACA;;AAEAA,UAAKC,eAAL,CAAqB,CAACC,oBAAD,CAArB","sourcesContent":["import {luma} from '@luma.gl/api';\nimport WebGLDevice from './adapter/webgl-device';\n\nluma.registerDevices([WebGLDevice]);\n"],"file":"init.js"}

package/dist/es5/{context/parameters/webgl-parameters.js → types/webgl.js}

@@ -3,4 +3,4 @@
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
 var _constants = _interopRequireDefault(require("@luma.gl/constants"));
-//# sourceMappingURL=webgl-parameters.js.map
+//# sourceMappingURL=webgl.js.map

package/dist/es5/types/webgl.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/types/webgl.ts"],"names":[],"mappings":";;;;AACA","sourcesContent":["import type {NumberArray} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\n\ntype Framebuffer = any;\n\nexport type GLDrawMode =\n  | GL.POINTS\n  | GL.LINES\n  | GL.LINE_STRIP\n  | GL.LINE_LOOP\n  | GL.TRIANGLES\n  | GL.TRIANGLE_STRIP\n  | GL.TRIANGLE_FAN;\n\nexport type GLPrimitive = GL.POINTS | GL.LINES | GL.TRIANGLES;\n\nexport type GLType =\n  | GL.FLOAT\n  | GL.UNSIGNED_SHORT\n  | GL.UNSIGNED_INT\n  | GL.UNSIGNED_BYTE\n  | GL.BYTE\n  | GL.SHORT\n  | GL.INT;\n\nexport type GLPackedType =\n  | GL.UNSIGNED_SHORT_5_6_5\n  | GL.UNSIGNED_SHORT_4_4_4_4\n  | GL.UNSIGNED_SHORT_5_5_5_1;\n\nexport type GLUniformType = GLSamplerType | GLCompositeType;\n\nexport type GLSamplerType =\n  | GL.SAMPLER_2D\n  | GL.SAMPLER_CUBE\n  | GL.SAMPLER_3D\n  | GL.SAMPLER_2D_SHADOW\n  | GL.SAMPLER_2D_ARRAY\n  | GL.SAMPLER_2D_ARRAY_SHADOW\n  | GL.SAMPLER_CUBE_SHADOW\n  | GL.INT_SAMPLER_2D\n  | GL.INT_SAMPLER_3D\n  | GL.INT_SAMPLER_CUBE\n  | GL.INT_SAMPLER_2D_ARRAY\n  | GL.UNSIGNED_INT_SAMPLER_2D\n  | GL.UNSIGNED_INT_SAMPLER_3D\n  | GL.UNSIGNED_INT_SAMPLER_CUBE\n  | GL.UNSIGNED_INT_SAMPLER_2D_ARRAY;\n\n// Composite types table\nexport type GLCompositeType =\n  | GL.FLOAT\n  | GL.FLOAT_VEC2\n  | GL.FLOAT_VEC3\n  | GL.FLOAT_VEC4\n  | GL.INT\n  | GL.INT_VEC2\n  | GL.INT_VEC3\n  | GL.INT_VEC4\n  | GL.UNSIGNED_INT\n  | GL.UNSIGNED_INT_VEC2\n  | GL.UNSIGNED_INT_VEC3\n  | GL.UNSIGNED_INT_VEC4\n  | GL.BOOL\n  | GL.BOOL_VEC2\n  | GL.BOOL_VEC3\n  | GL.BOOL_VEC4\n  | GL.FLOAT_MAT2\n  | GL.FLOAT_MAT2x3\n  | GL.FLOAT_MAT2x4\n  | GL.FLOAT_MAT3x2\n  | GL.FLOAT_MAT3\n  | GL.FLOAT_MAT3x4\n  | GL.FLOAT_MAT4x2\n  | GL.FLOAT_MAT4x3\n  | GL.FLOAT_MAT4;\n\nexport type GLFunction =\n  | GL.NEVER\n  | GL.LESS\n  | GL.EQUAL\n  | GL.LEQUAL\n  | GL.GREATER\n  | GL.NOTEQUAL\n  | GL.GEQUAL\n  | GL.ALWAYS;\n\nexport type GLBlendEquation =\n  | GL.FUNC_ADD\n  | GL.FUNC_SUBTRACT\n  | GL.FUNC_REVERSE_SUBTRACT\n  | GL.MIN_EXT\n  | GL.MAX_EXT;\n\nexport type GLBlendFunction =\n  | GL.ZERO\n  | GL.ONE\n  | GL.SRC_COLOR\n  | GL.ONE_MINUS_SRC_COLOR\n  | GL.DST_COLOR\n  | GL.ONE_MINUS_DST_COLOR\n  | GL.SRC_ALPHA\n  | GL.ONE_MINUS_SRC_ALPHA\n  | GL.DST_ALPHA\n  | GL.ONE_MINUS_DST_ALPHA\n  | GL.CONSTANT_COLOR\n  | GL.ONE_MINUS_CONSTANT_COLOR\n  | GL.CONSTANT_ALPHA\n  | GL.ONE_MINUS_CONSTANT_ALPHA\n  | GL.SRC_ALPHA_SATURATE;\n\nexport type GLStencilOp =\n  | GL.KEEP\n  | GL.ZERO\n  | GL.REPLACE\n  | GL.INCR\n  | GL.INCR_WRAP\n  | GL.DECR\n  | GL.DECR_WRAP\n  | GL.INVERT;\n\n/** Parameters for textures and samplers */\nexport type GLSamplerParameters = {\n  [GL.TEXTURE_WRAP_S]?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;\n  [GL.TEXTURE_WRAP_T]?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;\n  [GL.TEXTURE_WRAP_R]?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;\n  [GL.TEXTURE_MAG_FILTER]?: GL.NEAREST | GL.LINEAR;\n  [GL.TEXTURE_MIN_FILTER]?:\n    | GL.NEAREST\n    | GL.LINEAR\n    | GL.NEAREST_MIPMAP_NEAREST\n    | GL.NEAREST_MIPMAP_LINEAR\n    | GL.LINEAR_MIPMAP_NEAREST\n    | GL.LINEAR_MIPMAP_LINEAR;\n  [GL.TEXTURE_MIN_LOD]?: number;\n  [GL.TEXTURE_MAX_LOD]?: number;\n  [GL.TEXTURE_COMPARE_FUNC]?: number; // COMPARE_FUNC);\n  [GL.TEXTURE_COMPARE_MODE]?: GL.COMPARE_REF_TO_TEXTURE;\n  [GL.TEXTURE_MAX_ANISOTROPY_EXT]?: number; //\n};\n\n/**\n * All global WebGL values set by a variety of setter gl.enable ...\n */\nexport type GLValueParameters = {\n  [GL.BLEND]?: boolean;\n  [GL.BLEND_COLOR]?: [number, number, number, number] | NumberArray;\n  [GL.BLEND_EQUATION_RGB]?: GLBlendEquation;\n  [GL.BLEND_EQUATION_ALPHA]?: GLBlendEquation;\n  [GL.BLEND_SRC_RGB]?: GLBlendFunction;\n  [GL.BLEND_DST_RGB]?: GLBlendFunction;\n  [GL.BLEND_SRC_ALPHA]?: GLBlendFunction;\n  [GL.BLEND_DST_ALPHA]?: GLBlendFunction;\n  [GL.COLOR_CLEAR_VALUE]?: [number, number, number, number] | NumberArray;\n  [GL.COLOR_WRITEMASK]?: [boolean, boolean, boolean, boolean] | boolean[];\n  [GL.CULL_FACE]?: boolean;\n  [GL.CULL_FACE_MODE]?: GL.FRONT | GL.BACK | GL.FRONT_AND_BACK;\n  [GL.DEPTH_TEST]?: boolean;\n  [GL.DEPTH_CLEAR_VALUE]?: number;\n  [GL.DEPTH_FUNC]?: GLFunction;\n  [GL.DEPTH_RANGE]?: [number, number] | NumberArray;\n  [GL.DEPTH_WRITEMASK]?: boolean;\n  [GL.DITHER]?: boolean;\n  [GL.FRAGMENT_SHADER_DERIVATIVE_HINT]?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;\n  [GL.CURRENT_PROGRAM]?: WebGLProgram | null;\n  [GL.FRAMEBUFFER_BINDING]?: WebGLFramebuffer | null;\n  [GL.RENDERBUFFER_BINDING]?: WebGLRenderbuffer | null;\n  [GL.TRANSFORM_FEEDBACK_BINDING]?: WebGLTransformFeedback | null;\n  [GL.VERTEX_ARRAY_BINDING]?: WebGLVertexArrayObject | null;\n  [GL.ARRAY_BUFFER_BINDING]?: WebGLBuffer | null;\n  [GL.COPY_READ_BUFFER_BINDING]?: WebGLBuffer | null;\n  [GL.COPY_WRITE_BUFFER_BINDING]?: WebGLBuffer | null;\n  [GL.PIXEL_PACK_BUFFER_BINDING]?: WebGLBuffer | null;\n  [GL.PIXEL_UNPACK_BUFFER_BINDING]?: WebGLBuffer | null;\n  [GL.TEXTURE_BINDING_2D]?: WebGLTexture | null;\n  [GL.TEXTURE_BINDING_2D_ARRAY]?: WebGLTexture | null;\n  [GL.TEXTURE_BINDING_3D]?: WebGLTexture | null;\n  [GL.TEXTURE_BINDING_CUBE_MAP]?: WebGLTexture | null;\n  [GL.FRONT_FACE]?: GL.CW | GL.CCW;\n  [GL.GENERATE_MIPMAP_HINT]?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;\n  [GL.LINE_WIDTH]?: number;\n  [GL.POLYGON_OFFSET_FILL]?: boolean;\n  [GL.POLYGON_OFFSET_FACTOR]?: number;\n  [GL.POLYGON_OFFSET_UNITS]?: number;\n  [GL.SAMPLE_ALPHA_TO_COVERAGE]?: boolean;\n  [GL.SAMPLE_COVERAGE]?: boolean;\n  [GL.RASTERIZER_DISCARD]?: boolean;\n  [GL.SAMPLE_COVERAGE_VALUE]?: number;\n  [GL.SAMPLE_COVERAGE_INVERT]?: boolean;\n  [GL.SCISSOR_TEST]?: boolean;\n  [GL.SCISSOR_BOX]?: [number, number, number, number] | NumberArray;\n  [GL.STENCIL_TEST]?: boolean;\n  [GL.STENCIL_CLEAR_VALUE]?: number;\n  [GL.STENCIL_WRITEMASK]?: number;\n  [GL.STENCIL_BACK_WRITEMASK]?: number;\n  [GL.STENCIL_FUNC]?: GLFunction;\n  [GL.STENCIL_REF]?: GLFunction;\n  [GL.STENCIL_VALUE_MASK]?: GLFunction;\n  [GL.STENCIL_BACK_FUNC]?: GLFunction;\n  [GL.STENCIL_BACK_REF]?: GLFunction;\n  [GL.STENCIL_BACK_VALUE_MASK]?: GLFunction;\n  [GL.STENCIL_FAIL]?: GLStencilOp;\n  [GL.STENCIL_PASS_DEPTH_FAIL]?: GLStencilOp;\n  [GL.STENCIL_PASS_DEPTH_PASS]?: GLStencilOp;\n  [GL.STENCIL_BACK_FAIL]?: GLStencilOp;\n  [GL.STENCIL_BACK_PASS_DEPTH_FAIL]?: GLStencilOp;\n  [GL.STENCIL_BACK_PASS_DEPTH_PASS]?: GLStencilOp;\n  [GL.VIEWPORT]?: [number, number, number, number] | NumberArray;\n\n  // WEBGL1 PIXEL PACK/UNPACK MODES\n  [GL.PACK_ALIGNMENT]?: number;\n  [GL.UNPACK_ALIGNMENT]?: number;\n  [GL.UNPACK_FLIP_Y_WEBGL]?: boolean;\n  [GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]?: boolean;\n  [GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]?: GL.NONE | GL.BROWSER_DEFAULT_WEBGL;\n\n  // WEBGL2 PIXEL PACK/UNPACK MODES\n  // RASTERIZER_DISCARD ...\n  [GL.PACK_ROW_LENGTH]?: number;\n  [GL.PACK_SKIP_PIXELS]?: number;\n  [GL.PACK_SKIP_ROWS]?: number;\n  [GL.READ_FRAMEBUFFER_BINDING]?: Framebuffer | null;\n  [GL.UNPACK_ROW_LENGTH]?: number;\n  [GL.UNPACK_IMAGE_HEIGHT]?: number;\n  [GL.UNPACK_SKIP_PIXELS]?: number;\n  [GL.UNPACK_SKIP_ROWS]?: number;\n  [GL.UNPACK_SKIP_IMAGES]?: number;\n};\n\nexport type GLFunctionParameters = {\n  // Function-style setters\n  framebuffer?: Framebuffer | null;\n  blend?: boolean;\n  blendColor?: [number, number, number, number] | NumberArray;\n  blendEquation?: GLBlendEquation | [GLBlendEquation, GLBlendEquation];\n  blendFunc?:\n    | [GLBlendFunction, GLBlendFunction]\n    | [GLBlendFunction, GLBlendFunction, GLBlendFunction, GLBlendFunction];\n\n  clearColor?: [number, number, number, number] | NumberArray;\n  clearDepth?: number;\n  clearStencil?: number;\n\n  colorMask?: [boolean, boolean, boolean, boolean] | boolean[];\n\n  cull?: boolean;\n  cullFace?: GL.FRONT | GL.BACK | GL.FRONT_AND_BACK;\n\n  depthTest?: boolean;\n  depthFunc?: GLFunction;\n  depthMask?: boolean;\n  depthRange?: [number, number] | NumberArray;\n\n  dither?: boolean;\n\n  derivativeHint?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;\n\n  frontFace?: GL.CW | GL.CCW;\n\n  mipmapHint?: GL.FASTEST | GL.NICEST | GL.DONT_CARE;\n\n  lineWidth?: number;\n\n  polygonOffsetFill?: boolean;\n  polygonOffset?: [number, number];\n\n  sampleCoverage?: [number, boolean];\n\n  scissorTest?: boolean;\n  scissor?: [number, number, number, number] | NumberArray;\n\n  stencilTest?: boolean;\n  stencilMask?: number | [number, number];\n  stencilFunc?:\n    | [GLFunction, number, number]\n    | [GLFunction, number, number, GLFunction, number, number];\n  stencilOp?:\n    | [GLStencilOp, GLStencilOp, GLStencilOp]\n    | [GLStencilOp, GLStencilOp, GLStencilOp, GLStencilOp, GLStencilOp, GLStencilOp];\n  viewport?: [number, number, number, number] | NumberArray;\n};\n\n/** WebGL style parameters object (with both GL constants and function style fields) */\nexport type GLParameters = GLValueParameters & GLFunctionParameters;\n"],"file":"webgl.js"}