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

package/dist/es5/device/device-limits.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/device/device-limits.ts"],"names":["getDeviceLimits","gl","gl2","maxTextureDimension1D","maxTextureDimension2D","getParameter","GL","MAX_TEXTURE_SIZE","maxTextureDimension3D","MAX_3D_TEXTURE_SIZE","maxTextureArrayLayers","MAX_ARRAY_TEXTURE_LAYERS","maxBindGroups","maxDynamicUniformBuffersPerPipelineLayout","maxDynamicStorageBuffersPerPipelineLayout","maxSampledTexturesPerShaderStage","MAX_VERTEX_TEXTURE_IMAGE_UNITS","maxSamplersPerShaderStage","MAX_COMBINED_TEXTURE_IMAGE_UNITS","maxStorageBuffersPerShaderStage","maxStorageTexturesPerShaderStage","maxUniformBuffersPerShaderStage","MAX_UNIFORM_BUFFER_BINDINGS","maxUniformBufferBindingSize","MAX_UNIFORM_BLOCK_SIZE","maxStorageBufferBindingSize","minUniformBufferOffsetAlignment","UNIFORM_BUFFER_OFFSET_ALIGNMENT","minStorageBufferOffsetAlignment","maxVertexBuffers","maxVertexAttributes","MAX_VERTEX_ATTRIBS","maxVertexBufferArrayStride","maxInterStageShaderComponents","MAX_VARYING_COMPONENTS","maxComputeWorkgroupStorageSize","maxComputeInvocationsPerWorkgroup","maxComputeWorkgroupSizeX","maxComputeWorkgroupSizeY","maxComputeWorkgroupSizeZ","maxComputeWorkgroupsPerDimension","getWebGLLimits","get","pname","get2","defaultValue","ALIASED_LINE_WIDTH_RANGE","ALIASED_POINT_SIZE_RANGE","MAX_CUBE_MAP_TEXTURE_SIZE","MAX_TEXTURE_IMAGE_UNITS","MAX_RENDERBUFFER_SIZE","MAX_VARYING_VECTORS","MAX_VERTEX_UNIFORM_VECTORS","MAX_FRAGMENT_UNIFORM_VECTORS","MAX_VIEWPORT_DIMS","MAX_CLIENT_WAIT_TIMEOUT_WEBGL","MAX_COLOR_ATTACHMENTS","MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS","MAX_COMBINED_UNIFORM_BLOCKS","MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS","MAX_DRAW_BUFFERS","MAX_ELEMENT_INDEX","MAX_ELEMENTS_INDICES","MAX_ELEMENTS_VERTICES","MAX_FRAGMENT_INPUT_COMPONENTS","MAX_FRAGMENT_UNIFORM_BLOCKS","MAX_FRAGMENT_UNIFORM_COMPONENTS","MAX_SAMPLES","MAX_SERVER_WAIT_TIMEOUT","MAX_TEXTURE_LOD_BIAS","MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS","MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS","MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS","MAX_VERTEX_OUTPUT_COMPONENTS","MAX_VERTEX_UNIFORM_BLOCKS","MAX_VERTEX_UNIFORM_COMPONENTS","MIN_PROGRAM_TEXEL_OFFSET","MAX_PROGRAM_TEXEL_OFFSET"],"mappings":";;;;;;;;;;;;AAEA;;AACA;;AAGO,SAASA,eAAT,CAAyBC,EAAzB,EAAkE;AACvE,MAAMC,GAA2B,GAAG,mCAAiBD,EAAjB,CAApC;AACA,SAAO;AACLE,IAAAA,qBAAqB,EAAE,CADlB;AAELC,IAAAA,qBAAqB,EAAEH,EAAE,CAACI,YAAH,CAAgBC,mBAAGC,gBAAnB,CAFlB;AAGLC,IAAAA,qBAAqB,EAAEN,GAAG,GAAGA,GAAG,CAACG,YAAJ,CAAiBC,mBAAGG,mBAApB,CAAH,GAA8C,CAHnE;AAILC,IAAAA,qBAAqB,EAAER,GAAG,GAAGA,GAAG,CAACG,YAAJ,CAAiBC,mBAAGK,wBAApB,CAAH,GAAmD,CAJxE;AAKLC,IAAAA,aAAa,EAAE,CALV;AAMLC,IAAAA,yCAAyC,EAAE,CANtC;AAOLC,IAAAA,yCAAyC,EAAE,CAPtC;AAQLC,IAAAA,gCAAgC,EAAEd,EAAE,CAACI,YAAH,CAAgBC,mBAAGU,8BAAnB,CAR7B;AASLC,IAAAA,yBAAyB,EAAEhB,EAAE,CAACI,YAAH,CAAgBC,mBAAGY,gCAAnB,CATtB;AAULC,IAAAA,+BAA+B,EAAE,CAV5B;AAWLC,IAAAA,gCAAgC,EAAE,CAX7B;AAYLC,IAAAA,+BAA+B,EAAEnB,GAAG,GAAGA,GAAG,CAACG,YAAJ,CAAiBC,mBAAGgB,2BAApB,CAAH,GAAsD,CAZrF;AAaLC,IAAAA,2BAA2B,EAAErB,GAAG,GAAGA,GAAG,CAACG,YAAJ,CAAiBC,mBAAGkB,sBAApB,CAAH,GAAiD,CAb5E;AAcLC,IAAAA,2BAA2B,EAAE,CAdxB;AAeLC,IAAAA,+BAA+B,EAAExB,GAAG,GAAGA,GAAG,CAACG,YAAJ,CAAiBC,mBAAGqB,+BAApB,CAAH,GAA0D,CAfzF;AAgBLC,IAAAA,+BAA+B,EAAE,CAhB5B;AAiBLC,IAAAA,gBAAgB,EAAE,CAjBb;AAkBLC,IAAAA,mBAAmB,EAAE7B,EAAE,CAACI,YAAH,CAAgBC,mBAAGyB,kBAAnB,CAlBhB;AAmBLC,IAAAA,0BAA0B,EAAE,IAnBvB;AAoBLC,IAAAA,6BAA6B,EAAE/B,GAAG,GAAGA,GAAG,CAACG,YAAJ,CAAiBC,mBAAG4B,sBAApB,CAAH,GAAiD,CApB9E;AAqBLC,IAAAA,8BAA8B,EAAE,CArB3B;AAsBLC,IAAAA,iCAAiC,EAAE,CAtB9B;AAuBLC,IAAAA,wBAAwB,EAAE,CAvBrB;AAwBLC,IAAAA,wBAAwB,EAAE,CAxBrB;AAyBLC,IAAAA,wBAAwB,EAAE,CAzBrB;AA0BLC,IAAAA,gCAAgC,EAAE;AA1B7B,GAAP;AA4BD;;AAsDM,SAASC,cAAT,CAAwBxC,EAAxB,EAAgE;AAAA;;AACrE,MAAMC,GAAG,GAAG,mCAAiBD,EAAjB,CAAZ;;AACA,WAASyC,GAAT,CAAyBC,KAAzB,EAA2C;AACzC,WAAO1C,EAAE,CAACI,YAAH,CAAgBsC,KAAhB,CAAP;AACD;;AAGD,WAASC,IAAT,CAAiBD,KAAjB,EAAgCE,YAAhC,EAAoD;AAClD,WAAO3C,GAAG,GAAGA,GAAG,CAACG,YAAJ,CAAiBsC,KAAjB,CAAH,GAAmCE,YAAY,IAAI,CAA7D;AACD;;AACD,wDACGvC,mBAAGwC,wBADN,EACiCJ,GAAG,CAACpC,mBAAGwC,wBAAJ,CADpC,uCAEGxC,mBAAGyC,wBAFN,EAEiCL,GAAG,CAACpC,mBAAGyC,wBAAJ,CAFpC,uCAGGzC,mBAAGC,gBAHN,EAGyBmC,GAAG,CAACpC,mBAAGC,gBAAJ,CAH5B,uCAIGD,mBAAG0C,yBAJN,EAIkCN,GAAG,CAACpC,mBAAG0C,yBAAJ,CAJrC,uCAKG1C,mBAAG2C,uBALN,EAKgCP,GAAG,CAACpC,mBAAG2C,uBAAJ,CALnC,uCAMG3C,mBAAGY,gCANN,EAMyCwB,GAAG,CAACpC,mBAAGY,gCAAJ,CAN5C,uCAOGZ,mBAAGU,8BAPN,EAOuC0B,GAAG,CAACpC,mBAAGU,8BAAJ,CAP1C,uCAQGV,mBAAG4C,qBARN,EAQ8BR,GAAG,CAACpC,mBAAG4C,qBAAJ,CARjC,uCASG5C,mBAAG6C,mBATN,EAS4BT,GAAG,CAACpC,mBAAG6C,mBAAJ,CAT/B,uCAUG7C,mBAAGyB,kBAVN,EAU2BW,GAAG,CAACpC,mBAAGyB,kBAAJ,CAV9B,uCAWGzB,mBAAG8C,0BAXN,EAWmCV,GAAG,CAACpC,mBAAG8C,0BAAJ,CAXtC,uCAYG9C,mBAAG+C,4BAZN,EAYqCX,GAAG,CAACpC,mBAAG+C,4BAAJ,CAZxC,uCAaG/C,mBAAGgD,iBAbN,EAa0BZ,GAAG,CAACpC,mBAAGgD,iBAAJ,CAb7B,uCAmBGhD,mBAAGG,mBAnBN,EAmB4BmC,IAAI,CAACtC,mBAAGG,mBAAJ,CAnBhC,uCAoBGH,mBAAGK,wBApBN,EAoBiCiC,IAAI,CAACtC,mBAAGK,wBAAJ,CApBrC,uCAqBGL,mBAAGiD,6BArBN,EAqBsCX,IAAI,CAACtC,mBAAGiD,6BAAJ,CArB1C,uCAsBGjD,mBAAGkD,qBAtBN,EAsB8BZ,IAAI,CAACtC,mBAAGkD,qBAAJ,CAtBlC,uCAuBGlD,mBAAGmD,wCAvBN,EAuBiDb,IAAI,CAACtC,mBAAGmD,wCAAJ,CAvBrD,uCAwBGnD,mBAAGoD,2BAxBN,EAwBoCd,IAAI,CAACtC,mBAAGoD,2BAAJ,CAxBxC,uCAyBGpD,mBAAGqD,sCAzBN,EAyB+Cf,IAAI,CAACtC,mBAAGqD,sCAAJ,CAzBnD,uCA0BGrD,mBAAGsD,gBA1BN,EA0ByBhB,IAAI,CAACtC,mBAAGsD,gBAAJ,CA1B7B,uCA2BGtD,mBAAGuD,iBA3BN,EA2B0BjB,IAAI,CAACtC,mBAAGuD,iBAAJ,CA3B9B,uCA4BGvD,mBAAGwD,oBA5BN,EA4B6BlB,IAAI,CAACtC,mBAAGwD,oBAAJ,CA5BjC,uCA6BGxD,mBAAGyD,qBA7BN,EA6B8BnB,IAAI,CAACtC,mBAAGyD,qBAAJ,CA7BlC,uCA8BGzD,mBAAG0D,6BA9BN,EA8BsCpB,IAAI,CAACtC,mBAAG0D,6BAAJ,CA9B1C,uCA+BG1D,mBAAG2D,2BA/BN,EA+BoCrB,IAAI,CAACtC,mBAAG2D,2BAAJ,CA/BxC,uCAgCG3D,mBAAG4D,+BAhCN,EAgCwCtB,IAAI,CAACtC,mBAAG4D,+BAAJ,CAhC5C,uCAiCG5D,mBAAG6D,WAjCN,EAiCoBvB,IAAI,CAACtC,mBAAG6D,WAAJ,CAjCxB,uCAkCG7D,mBAAG8D,uBAlCN,EAkCgCxB,IAAI,CAACtC,mBAAG8D,uBAAJ,CAlCpC,uCAmCG9D,mBAAG+D,oBAnCN,EAmC6BzB,IAAI,CAACtC,mBAAG+D,oBAAJ,CAnCjC,uCAoCG/D,mBAAGgE,6CApCN,EAoCsD1B,IAAI,CAACtC,mBAAGgE,6CAAJ,CApC1D,uCAqCGhE,mBAAGiE,uCArCN,EAqCgD3B,IAAI,CAACtC,mBAAGiE,uCAAJ,CArCpD,uCAsCGjE,mBAAGkE,0CAtCN,EAsCmD5B,IAAI,CAACtC,mBAAGkE,0CAAJ,CAtCvD,uCAuCGlE,mBAAGkB,sBAvCN,EAuC+BoB,IAAI,CAACtC,mBAAGkB,sBAAJ,CAvCnC,uCAwCGlB,mBAAGgB,2BAxCN,EAwCoCsB,IAAI,CAACtC,mBAAGgB,2BAAJ,CAxCxC,uCAyCGhB,mBAAG4B,sBAzCN,EAyC+BU,IAAI,CAACtC,mBAAG4B,sBAAJ,CAzCnC,uCA0CG5B,mBAAGmE,4BA1CN,EA0CqC7B,IAAI,CAACtC,mBAAGmE,4BAAJ,CA1CzC,uCA2CGnE,mBAAGoE,yBA3CN,EA2CkC9B,IAAI,CAACtC,mBAAGoE,yBAAJ,CA3CtC,uCA4CGpE,mBAAGqE,6BA5CN,EA4CsC/B,IAAI,CAACtC,mBAAGqE,6BAAJ,CA5C1C,uCA6CGrE,mBAAGsE,wBA7CN,EA6CiChC,IAAI,CAACtC,mBAAGsE,wBAAJ,CA7CrC,uCA8CGtE,mBAAGuE,wBA9CN,EA8CiCjC,IAAI,CAACtC,mBAAGuE,wBAAJ,CA9CrC,uCA+CGvE,mBAAGqB,+BA/CN,EA+CwCiB,IAAI,CAACtC,mBAAGqB,+BAAJ,CA/C5C;AAiDD","sourcesContent":["// luma.gl, MIT license\nimport type {DeviceLimits} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport {getWebGL2Context} from '../context/context/webgl-checks';\n\n/** Populate a WebGPU style device limits */\nexport function getDeviceLimits(gl: WebGLRenderingContext): DeviceLimits {\n  const gl2: WebGL2RenderingContext = getWebGL2Context(gl);\n  return {\n    maxTextureDimension1D: 0, // WebGL does not support 1D textures\n    maxTextureDimension2D: gl.getParameter(GL.MAX_TEXTURE_SIZE),\n    maxTextureDimension3D: gl2 ? gl2.getParameter(GL.MAX_3D_TEXTURE_SIZE) : 0,\n    maxTextureArrayLayers: gl2 ? gl2.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,\n    maxBindGroups: 1, // TBD\n    maxDynamicUniformBuffersPerPipelineLayout: 0, // TBD\n    maxDynamicStorageBuffersPerPipelineLayout: 0, // TBD\n    maxSampledTexturesPerShaderStage: gl.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS), // TBD\n    maxSamplersPerShaderStage: gl.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),\n    maxStorageBuffersPerShaderStage: 0, // TBD\n    maxStorageTexturesPerShaderStage: 0, // TBD\n    maxUniformBuffersPerShaderStage: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,\n    maxUniformBufferBindingSize: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE) : 0,\n    maxStorageBufferBindingSize: 0,\n    minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,\n    minStorageBufferOffsetAlignment: 0, // TBD\n    maxVertexBuffers: 0,\n    maxVertexAttributes: gl.getParameter(GL.MAX_VERTEX_ATTRIBS),\n    maxVertexBufferArrayStride: 2048, // TBD, this is just the default value from WebGPU\n    maxInterStageShaderComponents: gl2 ? gl2.getParameter(GL.MAX_VARYING_COMPONENTS) : 0,\n    maxComputeWorkgroupStorageSize: 0, // WebGL does not support compute shaders\n    maxComputeInvocationsPerWorkgroup: 0, // WebGL does not support compute shaders\n    maxComputeWorkgroupSizeX: 0, // WebGL does not support compute shaders\n    maxComputeWorkgroupSizeY: 0, // WebGL does not support compute shaders\n    maxComputeWorkgroupSizeZ: 0, // WebGL does not support compute shaders\n    maxComputeWorkgroupsPerDimension: 0, // WebGL does not support compute shaders\n  }\n}\n\n/** WebGL context limits */\nexport type WebGLLimits = {\n  [GL.ALIASED_LINE_WIDTH_RANGE]: [number, number];\n  [GL.ALIASED_POINT_SIZE_RANGE]: [number, number];\n  [GL.MAX_TEXTURE_SIZE]: number;\n  [GL.MAX_CUBE_MAP_TEXTURE_SIZE]: number;\n  [GL.MAX_TEXTURE_IMAGE_UNITS]: number;\n  [GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: number;\n  [GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: number;\n  [GL.MAX_RENDERBUFFER_SIZE]: number;\n  [GL.MAX_VARYING_VECTORS]: number;\n  [GL.MAX_VERTEX_ATTRIBS]: number;\n  [GL.MAX_VERTEX_UNIFORM_VECTORS]: number;\n  [GL.MAX_FRAGMENT_UNIFORM_VECTORS]: number;\n  [GL.MAX_VIEWPORT_DIMS]: [number, number];\n\n  // Extensions\n  // [GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: number;\n\n  // WebGL2 Limits\n  [GL.MAX_3D_TEXTURE_SIZE]: number;\n  [GL.MAX_ARRAY_TEXTURE_LAYERS]: number;\n  [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: number;\n  [GL.MAX_COLOR_ATTACHMENTS]: number;\n  [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: number;\n  [GL.MAX_COMBINED_UNIFORM_BLOCKS]: number;\n  [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: number;\n  [GL.MAX_DRAW_BUFFERS]: number;\n  [GL.MAX_ELEMENT_INDEX]: number;\n  [GL.MAX_ELEMENTS_INDICES]: number;\n  [GL.MAX_ELEMENTS_VERTICES]: number;\n  [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: number;\n  [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: number;\n  [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: number;\n  [GL.MAX_SAMPLES]: number;\n  [GL.MAX_SERVER_WAIT_TIMEOUT]: number;\n  [GL.MAX_TEXTURE_LOD_BIAS]: number;\n  [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: number;\n  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: number;\n  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: number;\n  [GL.MAX_UNIFORM_BLOCK_SIZE]: number;\n  [GL.MAX_UNIFORM_BUFFER_BINDINGS]: number;\n  [GL.MAX_VARYING_COMPONENTS]: number;\n  [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: number;\n  [GL.MAX_VERTEX_UNIFORM_BLOCKS]: number;\n  [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: number;\n  [GL.MIN_PROGRAM_TEXEL_OFFSET]: number;\n  [GL.MAX_PROGRAM_TEXEL_OFFSET]: number;\n  [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: number;\n};\n\n\nexport function getWebGLLimits(gl: WebGLRenderingContext): WebGLLimits {\n  const gl2 = getWebGL2Context(gl);\n  function get<T = number>(pname: number): T {\n    return gl.getParameter(pname) as T;\n  }\n  function get2(pname: number, defaultValue?: number): number;\n  function get2<T>(pname: number, defaultValue: T): T;\n  function get2<T>(pname: number, defaultValue: T): T {\n    return gl2 ? gl2.getParameter(pname) as T : (defaultValue || 0) as T;\n  }\n  return {\n    [GL.ALIASED_LINE_WIDTH_RANGE]: get(GL.ALIASED_LINE_WIDTH_RANGE),\n    [GL.ALIASED_POINT_SIZE_RANGE]: get(GL.ALIASED_POINT_SIZE_RANGE),\n    [GL.MAX_TEXTURE_SIZE]: get(GL.MAX_TEXTURE_SIZE),\n    [GL.MAX_CUBE_MAP_TEXTURE_SIZE]: get(GL.MAX_CUBE_MAP_TEXTURE_SIZE), // GLint\n    [GL.MAX_TEXTURE_IMAGE_UNITS]: get(GL.MAX_TEXTURE_IMAGE_UNITS), // GLint\n    [GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS), // GLint\n    [GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS), // GLint\n    [GL.MAX_RENDERBUFFER_SIZE]: get(GL.MAX_RENDERBUFFER_SIZE), // GLint\n    [GL.MAX_VARYING_VECTORS]: get(GL.MAX_VARYING_VECTORS), // GLint\n    [GL.MAX_VERTEX_ATTRIBS]: get(GL.MAX_VERTEX_ATTRIBS), // GLint\n    [GL.MAX_VERTEX_UNIFORM_VECTORS]: get(GL.MAX_VERTEX_UNIFORM_VECTORS), // GLint\n    [GL.MAX_FRAGMENT_UNIFORM_VECTORS]: get(GL.MAX_FRAGMENT_UNIFORM_VECTORS), // GLint\n    [GL.MAX_VIEWPORT_DIMS]: get(GL.MAX_VIEWPORT_DIMS),\n\n    // Extensions\n    // [GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: {gl1: 1.0, extension: 'EXT_texture_filter_anisotropic'},\n\n    // WebGL2 Limits\n    [GL.MAX_3D_TEXTURE_SIZE]: get2(GL.MAX_3D_TEXTURE_SIZE), //  GLint\n    [GL.MAX_ARRAY_TEXTURE_LAYERS]: get2(GL.MAX_ARRAY_TEXTURE_LAYERS), // GLint\n    [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL), //  GLint64\n    [GL.MAX_COLOR_ATTACHMENTS]: get2(GL.MAX_COLOR_ATTACHMENTS), //  GLint\n    [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS), // GLint64\n    [GL.MAX_COMBINED_UNIFORM_BLOCKS]: get2(GL.MAX_COMBINED_UNIFORM_BLOCKS), //  GLint\n    [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS), // GLint64\n    [GL.MAX_DRAW_BUFFERS]: get2(GL.MAX_DRAW_BUFFERS), // GLint\n    [GL.MAX_ELEMENT_INDEX]: get2(GL.MAX_ELEMENT_INDEX), //  GLint64\n    [GL.MAX_ELEMENTS_INDICES]: get2(GL.MAX_ELEMENTS_INDICES), // GLint\n    [GL.MAX_ELEMENTS_VERTICES]: get2(GL.MAX_ELEMENTS_VERTICES), //  GLint\n    [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(GL.MAX_FRAGMENT_INPUT_COMPONENTS), //  GLint\n    [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(GL.MAX_FRAGMENT_UNIFORM_BLOCKS), //  GLint\n    [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(GL.MAX_FRAGMENT_UNIFORM_COMPONENTS), //  GLint\n    [GL.MAX_SAMPLES]: get2(GL.MAX_SAMPLES), //  GLint\n    [GL.MAX_SERVER_WAIT_TIMEOUT]: get2(GL.MAX_SERVER_WAIT_TIMEOUT), //  GLint64\n    [GL.MAX_TEXTURE_LOD_BIAS]: get2(GL.MAX_TEXTURE_LOD_BIAS), // GLfloat\n    [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS), //  GLint\n    [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS), //  GLint\n    [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS), // GLint\n    [GL.MAX_UNIFORM_BLOCK_SIZE]: get2(GL.MAX_UNIFORM_BLOCK_SIZE), // GLint64\n    [GL.MAX_UNIFORM_BUFFER_BINDINGS]: get2(GL.MAX_UNIFORM_BUFFER_BINDINGS), //  GLint\n    [GL.MAX_VARYING_COMPONENTS]: get2(GL.MAX_VARYING_COMPONENTS), // GLint\n    [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(GL.MAX_VERTEX_OUTPUT_COMPONENTS), // GLint\n    [GL.MAX_VERTEX_UNIFORM_BLOCKS]: get2(GL.MAX_VERTEX_UNIFORM_BLOCKS), //  GLint\n    [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(GL.MAX_VERTEX_UNIFORM_COMPONENTS), //  GLint\n    [GL.MIN_PROGRAM_TEXEL_OFFSET]: get2(GL.MIN_PROGRAM_TEXEL_OFFSET), // GLint\n    [GL.MAX_PROGRAM_TEXEL_OFFSET]: get2(GL.MAX_PROGRAM_TEXEL_OFFSET), // GLint\n    [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) // GLint\n  };\n}\n"],"file":"device-limits.js"}

package/dist/es5/device/get-device-info.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDeviceInfo = getDeviceInfo;
+
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+
+var _webglChecks = require("../context/context/webgl-checks");
+
+function getDeviceInfo(gl) {
+  var vendorMasked = gl.getParameter(_constants.default.VENDOR);
+  var rendererMasked = gl.getParameter(_constants.default.RENDERER);
+  var ext = gl.getExtension('WEBGL_debug_renderer_info');
+  var vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : _constants.default.VENDOR);
+  var rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : _constants.default.RENDERER);
+  var vendor = vendorUnmasked || vendorMasked;
+  var renderer = rendererUnmasked || rendererMasked;
+  var gpuVendor = identifyGPUVendor(vendor, renderer);
+  return {
+    type: (0, _webglChecks.isWebGL2)(gl) ? 'webgl2' : 'webgl',
+    gpuVendor: gpuVendor,
+    vendor: vendorUnmasked || vendorMasked,
+    renderer: rendererUnmasked || rendererMasked,
+    version: gl.getParameter(_constants.default.VERSION),
+    shadingLanguages: ['glsl'],
+    shadingLanguageVersions: {
+      'glsl': gl.getParameter(_constants.default.SHADING_LANGUAGE_VERSION)
+    }
+  };
+}
+
+function identifyGPUVendor(vendor, renderer) {
+  if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) {
+    return 'NVIDIA';
+  }
+
+  if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) {
+    return 'INTEL';
+  }
+
+  if (vendor.match(/Apple/i) || renderer.match(/Apple/i)) {
+    return 'APPLE';
+  }
+
+  if (vendor.match(/AMD/i) || renderer.match(/AMD/i) || vendor.match(/ATI/i) || renderer.match(/ATI/i)) {
+    return 'AMD';
+  }
+
+  return 'UNKNOWN';
+}
+//# sourceMappingURL=get-device-info.js.map

package/dist/es5/device/get-device-info.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/device/get-device-info.ts"],"names":["getDeviceInfo","gl","vendorMasked","getParameter","GL","VENDOR","rendererMasked","RENDERER","ext","getExtension","vendorUnmasked","UNMASKED_VENDOR_WEBGL","rendererUnmasked","UNMASKED_RENDERER_WEBGL","vendor","renderer","gpuVendor","identifyGPUVendor","type","version","VERSION","shadingLanguages","shadingLanguageVersions","SHADING_LANGUAGE_VERSION","match"],"mappings":";;;;;;;;;AACA;;AACA;;AAGO,SAASA,aAAT,CAAuBC,EAAvB,EAA8D;AACnE,MAAMC,YAAY,GAAGD,EAAE,CAACE,YAAH,CAAgBC,mBAAGC,MAAnB,CAArB;AACA,MAAMC,cAAc,GAAGL,EAAE,CAACE,YAAH,CAAgBC,mBAAGG,QAAnB,CAAvB;AAGA,MAAMC,GAAG,GAAGP,EAAE,CAACQ,YAAH,CAAgB,2BAAhB,CAAZ;AACA,MAAMC,cAAc,GAAGT,EAAE,CAACE,YAAH,CAAgBK,GAAG,GAAGA,GAAG,CAACG,qBAAP,GAA+BP,mBAAGC,MAArD,CAAvB;AACA,MAAMO,gBAAgB,GAAGX,EAAE,CAACE,YAAH,CAAgBK,GAAG,GAAGA,GAAG,CAACK,uBAAP,GAAiCT,mBAAGG,QAAvD,CAAzB;AACA,MAAMO,MAAM,GAAGJ,cAAc,IAAIR,YAAjC;AACA,MAAMa,QAAQ,GAAGH,gBAAgB,IAAIN,cAArC;AACA,MAAMU,SAAS,GAAGC,iBAAiB,CAACH,MAAD,EAASC,QAAT,CAAnC;AACA,SAAO;AACLG,IAAAA,IAAI,EAAE,2BAASjB,EAAT,IAAe,QAAf,GAA0B,OAD3B;AAELe,IAAAA,SAAS,EAATA,SAFK;AAGLF,IAAAA,MAAM,EAAEJ,cAAc,IAAIR,YAHrB;AAILa,IAAAA,QAAQ,EAAEH,gBAAgB,IAAIN,cAJzB;AAKLa,IAAAA,OAAO,EAAElB,EAAE,CAACE,YAAH,CAAgBC,mBAAGgB,OAAnB,CALJ;AAMLC,IAAAA,gBAAgB,EAAE,CAAC,MAAD,CANb;AAOLC,IAAAA,uBAAuB,EAAE;AACvB,cAAQrB,EAAE,CAACE,YAAH,CAAgBC,mBAAGmB,wBAAnB;AADe;AAPpB,GAAP;AAWD;;AAED,SAASN,iBAAT,CAA2BH,MAA3B,EAA2CC,QAA3C,EAA+G;AAC7G,MAAID,MAAM,CAACU,KAAP,CAAa,SAAb,KAA2BT,QAAQ,CAACS,KAAT,CAAe,SAAf,CAA/B,EAA0D;AACxD,WAAO,QAAP;AACD;;AACD,MAAIV,MAAM,CAACU,KAAP,CAAa,QAAb,KAA0BT,QAAQ,CAACS,KAAT,CAAe,QAAf,CAA9B,EAAwD;AACtD,WAAO,OAAP;AACD;;AACD,MAAIV,MAAM,CAACU,KAAP,CAAa,QAAb,KAA0BT,QAAQ,CAACS,KAAT,CAAe,QAAf,CAA9B,EAAwD;AACtD,WAAO,OAAP;AACD;;AACD,MACEV,MAAM,CAACU,KAAP,CAAa,MAAb,KACAT,QAAQ,CAACS,KAAT,CAAe,MAAf,CADA,IAEAV,MAAM,CAACU,KAAP,CAAa,MAAb,CAFA,IAGAT,QAAQ,CAACS,KAAT,CAAe,MAAf,CAJF,EAKE;AACA,WAAO,KAAP;AACD;;AACD,SAAO,SAAP;AACD","sourcesContent":["import {DeviceInfo} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport {isWebGL2} from '../context/context/webgl-checks';\n  \n/** @returns strings identifying the GPU vendor and driver. */\nexport function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo {\n  const vendorMasked = gl.getParameter(GL.VENDOR);\n  const rendererMasked = gl.getParameter(GL.RENDERER);\n  // Get unmasked strings if available\n  // https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/\n  const ext = gl.getExtension('WEBGL_debug_renderer_info');\n  const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : GL.VENDOR);\n  const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : GL.RENDERER);\n  const vendor = vendorUnmasked || vendorMasked;\n  const renderer = rendererUnmasked || rendererMasked;\n  const gpuVendor = identifyGPUVendor(vendor, renderer);\n  return {\n    type: isWebGL2(gl) ? 'webgl2' : 'webgl',\n    gpuVendor,\n    vendor: vendorUnmasked || vendorMasked,\n    renderer: rendererUnmasked || rendererMasked,\n    version: gl.getParameter(GL.VERSION),\n    shadingLanguages: ['glsl'],\n    shadingLanguageVersions: {\n      'glsl': gl.getParameter(GL.SHADING_LANGUAGE_VERSION) as string\n    }\n  };\n}\n\nfunction identifyGPUVendor(vendor: string, renderer: string): 'NVIDIA' | 'INTEL' | 'APPLE' | 'AMD' | 'UNKNOWN' {\n  if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) {\n    return 'NVIDIA';\n  }\n  if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) {\n    return 'INTEL';\n  }\n  if (vendor.match(/Apple/i) || renderer.match(/Apple/i)) {\n    return 'APPLE';\n  }\n  if (\n    vendor.match(/AMD/i) ||\n    renderer.match(/AMD/i) ||\n    vendor.match(/ATI/i) ||\n    renderer.match(/ATI/i)\n  ) {\n    return 'AMD';\n  }\n  return 'UNKNOWN';\n}\n"],"file":"get-device-info.js"}

package/dist/es5/device/webgl-device.js

@@ -0,0 +1,279 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getWebGLDevice = getWebGLDevice;
+exports.default = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _api = require("@luma.gl/api");
+
+var _polyfillContext = require("../context/polyfill/polyfill-context");
+
+var _trackContextState = require("../context/state-tracker/track-context-state");
+
+var _devicePixels = require("../context/context/device-pixels");
+
+var _createContext2 = require("../context/context/create-context");
+
+var _getCanvas = require("../context/context/get-canvas");
+
+var _webglChecks = require("../context/context/webgl-checks");
+
+var _getDeviceInfo = require("./get-device-info");
+
+var _deviceFeatures = require("./device-features");
+
+var _deviceLimits = require("./device-limits");
+
+var _webglBuffer = _interopRequireDefault(require("../classes/webgl-buffer"));
+
+var _webglShader = require("../classes/webgl-shader");
+
+var _texture2d = _interopRequireDefault(require("../classes/texture-2d"));
+
+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 _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var DEFAULT_DEVICE_PROPS = {
+  canvas: undefined,
+  gl: undefined,
+  webgl2: true,
+  webgl1: true,
+  manageState: true,
+  width: 800,
+  height: 600,
+  debug: false,
+  break: undefined,
+  onContextLost: function onContextLost() {
+    return console.error('WebGL context lost');
+  },
+  onContextRestored: function onContextRestored() {
+    return console.info('WebGL context restored');
+  },
+  alpha: undefined,
+  depth: undefined,
+  stencil: undefined,
+  antialias: undefined,
+  premultipliedAlpha: undefined,
+  preserveDrawingBuffer: undefined,
+  failIfMajorPerformanceCaveat: undefined
+};
+var glToContextMap = new WeakMap();
+
+function getWebGLDevice(gl) {
+  return glToContextMap.get(gl);
+}
+
+var counter = 0;
+
+var WebGLDevice = function (_Device) {
+  (0, _inherits2.default)(WebGLDevice, _Device);
+
+  var _super = _createSuper(WebGLDevice);
+
+  function WebGLDevice(props) {
+    var _this$props$gl;
+
+    var _this;
+
+    (0, _classCallCheck2.default)(this, WebGLDevice);
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "features", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "limits", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "info", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "lost", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "props", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "userData", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isWebGL2", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "gl", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "gl2", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "offScreen", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "webglFeatures", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "webglLimits", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "defaultFramebuffer", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "defaultVertexArray", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_state", 'uninitialized');
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_canvasSizeInfo", {
+      clientWidth: 0,
+      clientHeight: 0,
+      devicePixelRatio: 1
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_extensions", {});
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_polyfilled", false);
+    _this.props = _objectSpread(_objectSpread({}, DEFAULT_DEVICE_PROPS), props);
+    var device = (_this$props$gl = _this.props.gl) === null || _this$props$gl === void 0 ? void 0 : _this$props$gl.device;
+
+    if (device) {
+      if (device._state !== 'initialized') {
+        _api.log.error('recursive context');
+
+        throw new Error('recursive context');
+      }
+
+      return (0, _possibleConstructorReturn2.default)(_this, device);
+    }
+
+    _this.offScreen = typeof OffscreenCanvas !== 'undefined' && props.canvas instanceof OffscreenCanvas;
+    _this.gl = _this.props.gl || _this._createContext(props);
+    _this.gl2 = _this.gl;
+    _this.isWebGL2 = (0, _webglChecks.isWebGL2)(_this.gl);
+    _this._state = 'initializing';
+
+    if (_this.gl.device) {
+      _api.log.error('device already created');
+
+      throw new Error('device already created');
+    }
+
+    _this.gl.device = (0, _assertThisInitialized2.default)(_this);
+    _this.gl._version = typeof WebGL2RenderingContext !== 'undefined' && _this.gl instanceof WebGL2RenderingContext ? 2 : 1;
+    glToContextMap.set(_this.gl, (0, _assertThisInitialized2.default)(_this));
+    _this.info = (0, _getDeviceInfo.getDeviceInfo)(_this.gl);
+    var debug = _this.gl.debug ? ' debug' : '';
+    var webGL = (0, _webglChecks.isWebGL2)(_this.gl) ? 'WebGL2' : 'WebGL1';
+
+    _api.log.group(0, "".concat(webGL).concat(debug, " context: ").concat(_this.info.vendor, ", ").concat(_this.info.renderer))();
+
+    (0, _polyfillContext.polyfillContext)(_this.gl);
+
+    _api.log.probe(0, 'polyfilled context')();
+
+    (0, _trackContextState.trackContextState)(_this.gl, {
+      copyState: false,
+      log: function log() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        return _api.log.log.apply(_api.log, [1].concat(args))();
+      }
+    });
+
+    _api.log.probe(0, 'instrumented context')();
+
+    _this.features = (0, _deviceFeatures.getDeviceFeatures)(_this.gl);
+
+    _api.log.probe(0, "queried device features ".concat(counter))();
+
+    _this.limits = (0, _deviceLimits.getDeviceLimits)(_this.gl);
+
+    _api.log.probe(0, 'queried device limits')();
+
+    _this.webglLimits = (0, _deviceLimits.getWebGLLimits)(_this.gl);
+
+    _api.log.probe(0, 'queried webgl limits')();
+
+    _api.log.groupEnd(0)();
+
+    _this._state = 'initialized';
+    return _this;
+  }
+
+  (0, _createClass2.default)(WebGLDevice, [{
+    key: "destroy",
+    value: function destroy() {
+      var ext = this.gl.getExtension('STACKGL_destroy_context');
+
+      if (ext) {
+        ext.destroy();
+      }
+    }
+  }, {
+    key: "resize",
+    value: function resize(options) {
+      if (this.gl.canvas) {
+        var devicePixelRatio = (0, _devicePixels.getDevicePixelRatio)(options === null || options === void 0 ? void 0 : options.useDevicePixels);
+        (0, _devicePixels.setDevicePixelRatio)(this.gl, devicePixelRatio, options);
+        return;
+      }
+
+      var ext = this.gl.getExtension('STACKGL_resize_drawingbuffer');
+
+      if (ext && options && "width" in options && "height" in options) {
+        ext.resize(options.width, options.height);
+      }
+    }
+  }, {
+    key: "_createBuffer",
+    value: function _createBuffer(props) {
+      return new _webglBuffer.default(this.gl, props);
+    }
+  }, {
+    key: "createTexture",
+    value: function createTexture(props) {
+      return new _texture2d.default(this.gl, props);
+    }
+  }, {
+    key: "createShader",
+    value: function createShader(props) {
+      return new _webglShader.WEBGLShader(this.gl, props);
+    }
+  }, {
+    key: "commit",
+    value: function commit() {
+      if (this.offScreen && this.gl.commit) {
+        this.gl.commit();
+      }
+    }
+  }, {
+    key: "_createContext",
+    value: function _createContext(options) {
+      var _this$props = this.props,
+          width = _this$props.width,
+          height = _this$props.height,
+          canvas = _this$props.canvas;
+      var targetCanvas = (0, _getCanvas.getCanvas)({
+        canvas: canvas,
+        width: width,
+        height: height
+      });
+      return (0, _createContext2.createBrowserContext)(targetCanvas, options);
+    }
+  }], [{
+    key: "fromContext",
+    value: function fromContext(gl) {
+      return gl.device;
+    }
+  }, {
+    key: "attach",
+    value: function attach(gl, props) {
+      if (gl instanceof WebGLDevice) {
+        return gl;
+      }
+
+      if (!(0, _webglChecks.isWebGL)(gl)) {
+        throw new Error('Invalid WebGLRenderingContext');
+      }
+
+      return new WebGLDevice(_objectSpread(_objectSpread({}, props), {}, {
+        gl: gl
+      }));
+    }
+  }]);
+  return WebGLDevice;
+}(_api.Device);
+
+exports.default = WebGLDevice;
+//# sourceMappingURL=webgl-device.js.map

package/dist/es5/device/webgl-device.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/device/webgl-device.ts"],"names":["DEFAULT_DEVICE_PROPS","canvas","undefined","gl","webgl2","webgl1","manageState","width","height","debug","break","onContextLost","console","error","onContextRestored","info","alpha","depth","stencil","antialias","premultipliedAlpha","preserveDrawingBuffer","failIfMajorPerformanceCaveat","glToContextMap","WeakMap","getWebGLDevice","get","counter","WebGLDevice","props","clientWidth","clientHeight","devicePixelRatio","device","_state","log","Error","offScreen","OffscreenCanvas","_createContext","gl2","isWebGL2","_version","WebGL2RenderingContext","set","webGL","group","vendor","renderer","probe","copyState","args","features","limits","webglLimits","groupEnd","ext","getExtension","destroy","options","useDevicePixels","resize","WEBGLBuffer","Texture2D","WEBGLShader","commit","targetCanvas","Device"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\nimport {Device, DeviceInfo, DeviceLimits, log} from '@luma.gl/api';\nimport {polyfillContext} from '../context/polyfill/polyfill-context';\nimport {trackContextState} from '../context/state-tracker/track-context-state';\nimport { ContextState } from '../context/context/context-state';\nimport {getDevicePixelRatio, setDevicePixelRatio} from '../context/context/device-pixels';\nimport {createBrowserContext} from '../context/context/create-context';\nimport {getCanvas} from '../context/context/get-canvas';\nimport {isWebGL, isWebGL2} from '../context/context/webgl-checks';\nimport {getDeviceInfo} from './get-device-info';\nimport {getDeviceFeatures, Feature} from './device-features';\nimport {getDeviceLimits, getWebGLLimits, WebGLLimits} from './device-limits';\n\n// WebGL classes\nimport type {BufferProps, ShaderProps} from '@luma.gl/api';\nimport WEBGLBuffer from '../classes/webgl-buffer';\nimport {WEBGLShader} from '../classes/webgl-shader';\nimport Texture2D, {Texture2DProps} from '../classes/texture-2d';\nimport type {default as Framebuffer} from '../classes/framebuffer';\nimport type {default as VertexArrayObject} from '../classes/vertex-array-object';\n\n/** WebGLDevice options */\nexport type WebGLDeviceProps = {\n  canvas?: HTMLCanvasElement | OffscreenCanvas | string; // A canvas element or a canvas string id\n  width?: number /** width is only used when creating a new canvas */;\n  height?: number /** height is only used when creating a new canvas */;\n  // Attach to existing context\n  gl?: WebGLRenderingContext | WebGL2RenderingContext;\n  // COMMON CONTEXT PARAMETERS\n  webgl2?: boolean; // Set to false to not create a WebGL2 context (force webgl1)\n  webgl1?: boolean; // set to false to not create a WebGL1 context (fails if webgl2 not available)\n  manageState?: boolean; // Set to false to disable WebGL state management instrumentation\n  debug?: boolean; // Instrument context (at the expense of performance)\n  break?: Array<any>; // TODO: types\n  onContextLost?: (event: Event) => void;\n  onContextRestored?: (event: Event) => void;\n  // BROWSER CONTEXT PARAMETERS\n  alpha?: boolean; // Default render target has an alpha buffer.\n  depth?: boolean; // Default render target has a depth buffer of at least 16 bits.\n  stencil?: boolean; // Default render target has a stencil buffer of at least 8 bits.\n  antialias?: boolean; // Boolean that indicates whether or not to perform anti-aliasing.\n  premultipliedAlpha?: boolean; // Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n  preserveDrawingBuffer?: boolean; // Default render target buffers will not be automatically cleared and will preserve their values until cleared or overwritten\n  failIfMajorPerformanceCaveat?: boolean; // Do not create if the system performance is low.\n};\n\nconst DEFAULT_DEVICE_PROPS: Required<WebGLDeviceProps> = {\n  canvas: undefined, // A canvas element or a canvas string id\n  gl: undefined,\n  webgl2: true, // Attempt to create a WebGL2 context\n  webgl1: true, // Attempt to create a WebGL1 context (false to fail if webgl2 not available)\n  manageState: true,\n  width: 800, // width are height are only used by headless gl\n  height: 600,\n  debug: false, // Instrument context (at the expense of performance)\n  break: undefined,\n  onContextLost: () => console.error('WebGL context lost'),\n  onContextRestored: () => console.info('WebGL context restored'),\n\n  alpha: undefined,\n  depth: undefined,\n  stencil: undefined,\n  antialias: undefined,\n  premultipliedAlpha: undefined,\n  preserveDrawingBuffer: undefined,\n  failIfMajorPerformanceCaveat: undefined\n};\n\n// TODO use weakmap instead of modifying context\nconst glToContextMap = new WeakMap<WebGLRenderingContext | WebGL2RenderingContext, WebGLDevice>();\n\nexport function getWebGLDevice(gl: WebGLRenderingContext | WebGL2RenderingContext): WebGLDevice | undefined {\n  return glToContextMap.get(gl);\n}\n\nlet counter = 0;\n\n/** WebGPU style Device API for a WebGL context */\nexport default class WebGLDevice extends Device implements ContextState {\n  // WebGPU style API\n\n  /** A set like interface to test features */\n  readonly features: Set<Feature>;\n  readonly limits: DeviceLimits;\n  readonly info: DeviceInfo;\n\n  /** Promise that rejects when context is lost */\n  readonly lost: Promise<string>;\n\n  // Common API\n  props: Required<WebGLDeviceProps>;\n  userData: {[key: string]: any};\n\n  // WebGL specific API\n  readonly isWebGL2: boolean;\n  readonly gl: WebGLRenderingContext;\n  readonly gl2: WebGL2RenderingContext;\n  /** Is this device attached to an offscreen context */\n  readonly offScreen: boolean = false;\n\n  readonly webglFeatures: Set<string>;\n  readonly webglLimits: WebGLLimits;\n\n  defaultFramebuffer?: Framebuffer;\n  defaultVertexArray?: VertexArrayObject;\n\n  // State used by luma.gl classes\n  _state: 'uninitialized' | 'initializing' | 'initialized' = 'uninitialized';\n  readonly _canvasSizeInfo = {clientWidth: 0, clientHeight: 0, devicePixelRatio: 1};\n  readonly _extensions: Record<string, any> = {};\n  _polyfilled: boolean = false;\n\n  /**\n   * \n   */\n  static fromContext(gl: WebGLRenderingContext): WebGLDevice {\n    // @ts-expect-error\n    return gl.device as WebGLDevice;\n  }\n\n  /**\n   * Get a device instance from a GL context\n   * Creates and instruments the device if not already created\n   * @param gl\n   * @returns\n   */\n  static attach(\n    gl: Device | WebGLRenderingContext | WebGL2RenderingContext,\n    props?: WebGLDeviceProps\n  ): WebGLDevice {\n    if (gl instanceof WebGLDevice) {\n      return gl;\n    }  \n    if (!isWebGL(gl)) {\n      throw new Error('Invalid WebGLRenderingContext');\n    }\n    return new WebGLDevice({...props, gl: gl as WebGLRenderingContext});\n  }\n\n\n  constructor(props: WebGLDeviceProps) {\n    super();\n    \n    this.props = {...DEFAULT_DEVICE_PROPS, ...props};\n\n    // If attaching to an already attached context, return the attached device\n    // @ts-expect-error device is attached to context\n    const device: WebGLDevice | undefined = this.props.gl?.device;\n    if (device) {\n      if (device._state !== 'initialized') {\n        log.error('recursive context');\n        throw new Error('recursive context');\n      }\n      return device;\n    }\n\n    this.offScreen =\n      typeof OffscreenCanvas !== 'undefined' &&\n      props.canvas instanceof OffscreenCanvas;\n\n    // Create an instrument context\n    this.gl = (this.props.gl || this._createContext(props)) as WebGLRenderingContext;\n    this.gl2 = this.gl as WebGL2RenderingContext;\n    this.isWebGL2 = isWebGL2(this.gl);\n    this._state = 'initializing';\n    // Avoid multiple instrumentations\n    // @ts-expect-error\n    if (this.gl.device) {\n      log.error('device already created');\n      throw new Error('device already created'); // ASSERT this device;\n    }\n    // @ts-expect-error\n    this.gl.device = this;\n    // @ts-ignore\n    this.gl._version = typeof WebGL2RenderingContext !== 'undefined' && this.gl instanceof WebGL2RenderingContext ? 2 : 1;\n    // TODO - move to weak map indexing\n    glToContextMap.set(this.gl, this);\n\n    // Luma Device fields\n    this.info = getDeviceInfo(this.gl);\n    // Log some debug info about the newly created context\n    // @ts-expect-error device is attached to context\n    const debug = this.gl.debug ? ' debug' : '';\n    const webGL = isWebGL2(this.gl) ? 'WebGL2' : 'WebGL1';\n    log.group(0, `${webGL}${debug} context: ${this.info.vendor}, ${this.info.renderer}`)();\n\n    polyfillContext(this.gl);\n    log.probe(0, 'polyfilled context')();\n\n    // Install context state tracking\n    trackContextState(this.gl, {\n      copyState: false,\n      log: (...args) => log.log(1, ...args)()\n    });\n    log.probe(0, 'instrumented context')();\n\n    // WebGPU Device fields\n    this.features = getDeviceFeatures(this.gl);\n    log.probe(0, `queried device features ${counter}`)();\n    this.limits = getDeviceLimits(this.gl);\n    log.probe(0, 'queried device limits')();\n\n    // Add seer integration - TODO - currently removed\n\n    // WEBGL specific fields\n    this.webglLimits = getWebGLLimits(this.gl);\n    log.probe(0, 'queried webgl limits')();\n\n    // Add debug instrumentation to the context\n    // if (isBrowser() && props.debug) {\n    //   // @ts-ignore\n    //   const {makeDebugContext} = global;\n    //   if (!makeDebugContext) {\n    //     log.warn('WebGL debug mode not activated. import \"@luma.gl/debug\" to enable.')();\n    //   } else {\n    //     // @ts-ignore\n    //     this.gl = global.makeDebugContext(this.gl, props);\n    //     this.gl2 = this.gl as WebGL2RenderingContext;\n    //     // Debug forces log level to at least 1\n    //     log.level = Math.max(log.level, 1);\n    //   }\n    // }\n\n    log.groupEnd(0)();\n    this._state = 'initialized';\n  }\n\n  /**\n   * Destroys the context\n   * @note Has no effect for browser contexts, there is no browser API for destroying contexts\n   */\n  destroy() {\n    let ext = this.gl.getExtension('STACKGL_destroy_context');\n    if (ext) {\n      ext.destroy();\n    }\n    // ext = this.gl.getExtension('WEBGL_lose_context');\n    // if (ext) {\n    //   // TODO - disconnect context lost callbacks?\n    //   ext.loseContext();\n    // }\n  }\n\n  // WEBGL SPECIFIC METHODS\n\n  /**\n   * Resize the canvas' drawing buffer.\n   *\n   * Can match the canvas CSS size, and optionally also consider devicePixelRatio\n   * Can be called every frame\n   *\n   * Regardless of size, the drawing buffer will always be scaled to the viewport, but\n   * for best visual results, usually set to either:\n   *  canvas CSS width x canvas CSS height\n   *  canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio\n   * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html\n   */\n  resize(options?: {width?: number; height?: number; useDevicePixels?: boolean | number}): void {\n    // Resize browser context .\n    if (this.gl.canvas) {\n      const devicePixelRatio = getDevicePixelRatio(options?.useDevicePixels);\n      setDevicePixelRatio(this.gl, devicePixelRatio, options);\n      return;\n    }\n\n    // Resize headless gl context\n    const ext = this.gl.getExtension('STACKGL_resize_drawingbuffer');\n    if (ext && options && `width` in options && `height` in options) {\n      ext.resize(options.width, options.height);\n    }\n  }\n\n  _createBuffer(props: BufferProps): WEBGLBuffer {\n    return new WEBGLBuffer(this.gl, props);\n  }\n\n  createTexture(props: Texture2DProps): Texture2D {\n    return new Texture2D(this.gl, props);\n  }\n\n  createShader(props: ShaderProps): WEBGLShader {\n    return new WEBGLShader(this.gl, props);\n  }\n\n  /**\n   * Offscreen Canvas Support: Commit the frame\n   * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/commit\n   * Chrome's offscreen canvas does not require gl.commit\n   */\n  commit(): void {\n    // @ts-expect-error gl.commit is not officially part of WebGLRenderingContext\n    if (this.offScreen && this.gl.commit) {\n      // @ts-expect-error gl.commit is not officially part of WebGLRenderingContext\n      this.gl.commit();\n    }\n  }\n\n  // PRIVATE METHODS\n\n  /**\n   * Creates a context giving access to the WebGL API\n   */\n  _createContext(options?: WebGLDeviceProps): WebGLRenderingContext {\n    const {width, height, canvas} = this.props;\n    // Get or create a canvas\n    const targetCanvas = getCanvas({canvas, width, height});\n    // Create a WebGL context in the canvas\n    return createBrowserContext(targetCanvas, options);\n  }\n}\n\n/*\nimport {\n  isWebGL, isWebGL2,\n  createGLContext,\n  instrumentGLContext,\n  getContextDebugInfo,\n  resizeGLContext\n} from '@luma.gl/gltools';\n\n// prettier-ignore\nimport {\n  Device, DeviceInfo, DeviceLimits,\n  Buffer, BufferProps\n} from '@luma.gl/api';\n\nimport {getWebGLDeviceInfo} from '../converters/webgl-device-info';\nimport {getWebGLLimits} from '../converters/webgl-limits';\nimport {getWebGLFeatures} from '../converters/webgl-features';\n\nexport default class WEBGLDevice implements Device {\n  readonly handle: WebGLRenderingContext;\n  readonly gl: WebGLRenderingContext;\n  readonly gl2: WebGL2RenderingContext | null;\n  readonly canvas: HTMLCanvasElement;\n\n  static isSupported(options: {canvas?: HTMLCanvasElement}): boolean {\n    const {canvas} = options;\n    let gl;\n    try {\n      gl = canvas && canvas.getContext(\"webgl\");\n      gl = gl && canvas && canvas.getContext(\"experimental-webgl\");\n    } catch (x) {\n      gl = null;\n    }\n    return Boolean(gl);\n  }\n\n  constructor(props = {}) {\n    const {canvas, swapChainFormat = \"bgra8unorm\"} = props;\n\n    const gl = createGLContext(props);\n    this.handle =\n    this.gl = gl;\n    this.gl2 = gl instanceof WebGL2RenderingContext ? gl : null;\n    this.canvas = canvas;\n  }\n\n  resize(width, height) {\n    resizeGLContext(this.gl);\n  }\n\n  getInfo(): DeviceInfo {\n    return getWebGLDeviceInfo(this.gl);\n  }\n\n  getLimits(): DeviceLimits {\n    return getWebGLLimits(this.gl, this.gl2);\n  }\n\n  getFeatures(): string[] {\n    return getWebGLFeatures(this.gl);\n  }\n\n  createBuffer(props: WebGPUBufferProps): WEBGLBuffer {\n    return new WEBGLBuffer(this.gl2 || this.gl, props);\n  }\n\n  createTexture(props: WebGPUTextureProps): WEBGLTexture {\n    return new WEBGLTexture(this, props);\n  }\n\n  createSampler(props: WebGPUSamplerProps): WEBGLSampler {\n    return new WEBGLSampler(this, props);\n  }\n\n  createShader(props: WebGPUShaderProps): WEBGLShader {\n    return new WEBGLShader(this, props);\n  }\n\n  createRenderPipeline(props: WebGPURenderPipelineProps): WEBGLPipeline {\n    return new WEBGLRenderPipeline(this, props);\n  }\n\n  createComputePipeline(props: WebGPUComputePipelineProps): WebGPUPipeline {\n    return new WebGPUComputePipeline(this, props);\n  }\n\n\n  // PRIVATE\n\n  _startFrame() {}\n\n  _endFrame() {}\n}\n*/\n"],"file":"webgl-device.js"}