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

package/dist/adapter/device-helpers/device-limits.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapter/device-helpers/device-limits.ts"],"names":["GL","getWebGL2Context","getDeviceLimits","gl","gl2","maxTextureDimension1D","maxTextureDimension2D","getParameter","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":"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","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/adapter/device-helpers/get-device-info.d.ts

@@ -0,0 +1,4 @@
+import { DeviceInfo } from '@luma.gl/api';
+/** @returns strings identifying the GPU vendor and driver. */
+export declare function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo;
+//# sourceMappingURL=get-device-info.d.ts.map

package/dist/adapter/device-helpers/get-device-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-device-info.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/get-device-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAIxC,8DAA8D;AAC9D,wBAAgB,aAAa,CAAC,EAAE,EAAE,qBAAqB,GAAG,UAAU,CAsBnE"}

package/dist/adapter/device-helpers/get-device-info.js

@@ -0,0 +1,44 @@
+import GL from '@luma.gl/constants';
+import { isWebGL2 } from '../../context/context/webgl-checks';
+export function getDeviceInfo(gl) {
+  const vendorMasked = gl.getParameter(GL.VENDOR);
+  const rendererMasked = gl.getParameter(GL.RENDERER);
+  const ext = gl.getExtension('WEBGL_debug_renderer_info');
+  const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : GL.VENDOR);
+  const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : GL.RENDERER);
+  const vendor = vendorUnmasked || vendorMasked;
+  const renderer = rendererUnmasked || rendererMasked;
+  const gpuVendor = identifyGPUVendor(vendor, renderer);
+  return {
+    type: isWebGL2(gl) ? 'webgl2' : 'webgl',
+    gpuVendor,
+    vendor: vendorUnmasked || vendorMasked,
+    renderer: rendererUnmasked || rendererMasked,
+    version: gl.getParameter(GL.VERSION),
+    shadingLanguages: ['glsl'],
+    shadingLanguageVersions: {
+      'glsl': gl.getParameter(GL.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/adapter/device-helpers/get-device-info.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapter/device-helpers/get-device-info.ts"],"names":["GL","isWebGL2","getDeviceInfo","gl","vendorMasked","getParameter","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,OAAOA,EAAP,MAAe,oBAAf;AACA,SAAQC,QAAR,QAAuB,oCAAvB;AAGA,OAAO,SAASC,aAAT,CAAuBC,EAAvB,EAA8D;AACnE,QAAMC,YAAY,GAAGD,EAAE,CAACE,YAAH,CAAgBL,EAAE,CAACM,MAAnB,CAArB;AACA,QAAMC,cAAc,GAAGJ,EAAE,CAACE,YAAH,CAAgBL,EAAE,CAACQ,QAAnB,CAAvB;AAGA,QAAMC,GAAG,GAAGN,EAAE,CAACO,YAAH,CAAgB,2BAAhB,CAAZ;AACA,QAAMC,cAAc,GAAGR,EAAE,CAACE,YAAH,CAAgBI,GAAG,GAAGA,GAAG,CAACG,qBAAP,GAA+BZ,EAAE,CAACM,MAArD,CAAvB;AACA,QAAMO,gBAAgB,GAAGV,EAAE,CAACE,YAAH,CAAgBI,GAAG,GAAGA,GAAG,CAACK,uBAAP,GAAiCd,EAAE,CAACQ,QAAvD,CAAzB;AACA,QAAMO,MAAM,GAAGJ,cAAc,IAAIP,YAAjC;AACA,QAAMY,QAAQ,GAAGH,gBAAgB,IAAIN,cAArC;AACA,QAAMU,SAAS,GAAGC,iBAAiB,CAACH,MAAD,EAASC,QAAT,CAAnC;AACA,SAAO;AACLG,IAAAA,IAAI,EAAElB,QAAQ,CAACE,EAAD,CAAR,GAAe,QAAf,GAA0B,OAD3B;AAELc,IAAAA,SAFK;AAGLF,IAAAA,MAAM,EAAEJ,cAAc,IAAIP,YAHrB;AAILY,IAAAA,QAAQ,EAAEH,gBAAgB,IAAIN,cAJzB;AAKLa,IAAAA,OAAO,EAAEjB,EAAE,CAACE,YAAH,CAAgBL,EAAE,CAACqB,OAAnB,CALJ;AAMLC,IAAAA,gBAAgB,EAAE,CAAC,MAAD,CANb;AAOLC,IAAAA,uBAAuB,EAAE;AACvB,cAAQpB,EAAE,CAACE,YAAH,CAAgBL,EAAE,CAACwB,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/adapter/device-helpers/is-old-ie.d.ts

@@ -0,0 +1,2 @@
+export declare function isOldIE(opts?: {}): boolean;
+//# sourceMappingURL=is-old-ie.d.ts.map

package/dist/adapter/device-helpers/is-old-ie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-old-ie.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/is-old-ie.ts"],"names":[],"mappings":"AACA,wBAAgB,OAAO,CAAC,IAAI,KAAK,WAShC"}

package/dist/{esm/features/check-old-ie.js → adapter/device-helpers/is-old-ie.js}

@@ -1,8 +1,8 @@
-export default function isOldIE(opts = {}) {
-  const navigator = typeof window !== 'undefined' && window.navigator || {};
+export function isOldIE(opts = {}) {
+  const navigator = typeof window !== 'undefined' ? window.navigator || {} : {};
   const userAgent = opts.userAgent || navigator.userAgent || '';
   const isMSIE = userAgent.indexOf('MSIE ') !== -1;
   const isTrident = userAgent.indexOf('Trident/') !== -1;
   return isMSIE || isTrident;
 }
-//# sourceMappingURL=check-old-ie.js.map
+//# sourceMappingURL=is-old-ie.js.map

package/dist/adapter/device-helpers/is-old-ie.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapter/device-helpers/is-old-ie.ts"],"names":["isOldIE","opts","navigator","window","userAgent","isMSIE","indexOf","isTrident"],"mappings":"AACA,OAAO,SAASA,OAAT,CAAiBC,IAAI,GAAG,EAAxB,EAA4B;AACjC,QAAMC,SAAS,GAAG,OAAOC,MAAP,KAAkB,WAAlB,GAAgCA,MAAM,CAACD,SAAP,IAAoB,EAApD,GAAyD,EAA3E;AAEA,QAAME,SAAS,GAAGH,IAAI,CAACG,SAAL,IAAkBF,SAAS,CAACE,SAA5B,IAAyC,EAA3D;AAGA,QAAMC,MAAM,GAAGD,SAAS,CAACE,OAAV,CAAkB,OAAlB,MAA+B,CAAC,CAA/C;AACA,QAAMC,SAAS,GAAGH,SAAS,CAACE,OAAV,CAAkB,UAAlB,MAAkC,CAAC,CAArD;AACA,SAAOD,MAAM,IAAIE,SAAjB;AACD","sourcesContent":["// opts allows user agent to be overridden for testing\nexport function isOldIE(opts = {}) {\n  const navigator = typeof window !== 'undefined' ? window.navigator || {} : {};\n  // @ts-expect-error\n  const userAgent = opts.userAgent || navigator.userAgent || '';\n  // We only care about older versions of IE (IE 11 and below). Newer versions of IE (Edge)\n  // have much better web standards support.\n  const isMSIE = userAgent.indexOf('MSIE ') !== -1;\n  const isTrident = userAgent.indexOf('Trident/') !== -1;\n  return isMSIE || isTrident;\n}\n"],"file":"is-old-ie.js"}

package/dist/adapter/webgl-device.d.ts

@@ -0,0 +1,111 @@
+/// <reference types="offscreencanvas" />
+import { Device, DeviceInfo, DeviceLimits } from '@luma.gl/api';
+import { ContextState } from '../context/context/context-state';
+import { Feature } from './device-helpers/device-features';
+import { WebGLLimits } from './device-helpers/device-limits';
+import type { BufferProps, ShaderProps } from '@luma.gl/api';
+import WEBGLBuffer from '../classes/webgl-buffer';
+import { WEBGLShader } from '../adapter/webgl-shader';
+import Texture2D, { Texture2DProps } from '../classes/texture-2d';
+import type { default as Framebuffer } from '../classes/framebuffer';
+import type { default as VertexArrayObject } from '../classes/vertex-array-object';
+/** WebGLDevice options */
+export declare type WebGLDeviceProps = {
+    canvas?: HTMLCanvasElement | OffscreenCanvas | string;
+    width?: number /** width is only used when creating a new canvas */;
+    height?: number /** height is only used when creating a new canvas */;
+    gl?: WebGLRenderingContext | WebGL2RenderingContext;
+    webgl2?: boolean;
+    webgl1?: boolean;
+    manageState?: boolean;
+    debug?: boolean;
+    break?: Array<any>;
+    onContextLost?: (event: Event) => void;
+    onContextRestored?: (event: Event) => void;
+    alpha?: boolean;
+    depth?: boolean;
+    stencil?: boolean;
+    antialias?: boolean;
+    premultipliedAlpha?: boolean;
+    preserveDrawingBuffer?: boolean;
+    failIfMajorPerformanceCaveat?: boolean;
+};
+export declare function getWebGLDevice(gl: WebGLRenderingContext | WebGL2RenderingContext): WebGLDevice | undefined;
+/** WebGPU style Device API for a WebGL context */
+export default class WebGLDevice extends Device implements ContextState {
+    /** A set like interface to test features */
+    readonly features: Set<Feature>;
+    readonly limits: DeviceLimits;
+    readonly info: DeviceInfo;
+    /** Promise that rejects when context is lost */
+    readonly lost: Promise<string>;
+    props: Required<WebGLDeviceProps>;
+    userData: {
+        [key: string]: any;
+    };
+    readonly isWebGL2: boolean;
+    readonly gl: WebGLRenderingContext;
+    readonly gl2: WebGL2RenderingContext;
+    /** Is this device attached to an offscreen context */
+    readonly offScreen: boolean;
+    readonly webglFeatures: Set<string>;
+    readonly webglLimits: WebGLLimits;
+    defaultFramebuffer?: Framebuffer;
+    defaultVertexArray?: VertexArrayObject;
+    _state: 'uninitialized' | 'initializing' | 'initialized';
+    readonly _canvasSizeInfo: {
+        clientWidth: number;
+        clientHeight: number;
+        devicePixelRatio: number;
+    };
+    readonly _extensions: Record<string, any>;
+    _polyfilled: boolean;
+    /**
+     *
+     */
+    static fromContext(gl: WebGLRenderingContext): WebGLDevice;
+    /**
+     * Get a device instance from a GL context
+     * Creates and instruments the device if not already created
+     * @param gl
+     * @returns
+     */
+    static attach(gl: Device | WebGLRenderingContext | WebGL2RenderingContext, props?: WebGLDeviceProps): WebGLDevice;
+    constructor(props: WebGLDeviceProps);
+    /**
+     * Destroys the context
+     * @note Has no effect for browser contexts, there is no browser API for destroying contexts
+     */
+    destroy(): void;
+    /**
+     * Resize the canvas' drawing buffer.
+     *
+     * Can match the canvas CSS size, and optionally also consider devicePixelRatio
+     * Can be called every frame
+     *
+     * Regardless of size, the drawing buffer will always be scaled to the viewport, but
+     * for best visual results, usually set to either:
+     *  canvas CSS width x canvas CSS height
+     *  canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio
+     * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html
+     */
+    resize(options?: {
+        width?: number;
+        height?: number;
+        useDevicePixels?: boolean | number;
+    }): void;
+    _createBuffer(props: BufferProps): WEBGLBuffer;
+    createTexture(props: Texture2DProps): Texture2D;
+    createShader(props: ShaderProps): WEBGLShader;
+    /**
+     * Offscreen Canvas Support: Commit the frame
+     * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/commit
+     * Chrome's offscreen canvas does not require gl.commit
+     */
+    commit(): void;
+    /**
+     * Creates a context giving access to the WebGL API
+     */
+    _createContext(options?: WebGLDeviceProps): WebGLRenderingContext;
+}
+//# sourceMappingURL=webgl-device.d.ts.map

package/dist/adapter/webgl-device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-device.d.ts","sourceRoot":"","sources":["../../src/adapter/webgl-device.ts"],"names":[],"mappings":"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"}

package/dist/adapter/webgl-device.js

@@ -0,0 +1,208 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { Device, log } from '@luma.gl/api';
+import { polyfillContext } from '../context/polyfill/polyfill-context';
+import { trackContextState } from '../context/state-tracker/track-context-state';
+import { getDevicePixelRatio, setDevicePixelRatio } from '../context/context/device-pixels';
+import { createBrowserContext } from '../context/context/create-context';
+import { getCanvas } from '../context/context/get-canvas';
+import { isWebGL, isWebGL2 } from '../context/context/webgl-checks';
+import { getDeviceInfo } from './device-helpers/get-device-info';
+import { getDeviceFeatures } from './device-helpers/device-features';
+import { getDeviceLimits, getWebGLLimits } from './device-helpers/device-limits';
+import WEBGLBuffer from '../classes/webgl-buffer';
+import { WEBGLShader } from '../adapter/webgl-shader';
+import Texture2D from '../classes/texture-2d';
+const DEFAULT_DEVICE_PROPS = {
+  canvas: undefined,
+  gl: undefined,
+  webgl2: true,
+  webgl1: true,
+  manageState: true,
+  width: 800,
+  height: 600,
+  debug: false,
+  break: undefined,
+  onContextLost: () => console.error('WebGL context lost'),
+  onContextRestored: () => console.info('WebGL context restored'),
+  alpha: undefined,
+  depth: undefined,
+  stencil: undefined,
+  antialias: undefined,
+  premultipliedAlpha: undefined,
+  preserveDrawingBuffer: undefined,
+  failIfMajorPerformanceCaveat: undefined
+};
+const glToContextMap = new WeakMap();
+export function getWebGLDevice(gl) {
+  return glToContextMap.get(gl);
+}
+let counter = 0;
+export default class WebGLDevice extends Device {
+  static fromContext(gl) {
+    return gl.device;
+  }
+
+  static attach(gl, props) {
+    if (gl instanceof WebGLDevice) {
+      return gl;
+    }
+
+    if (!isWebGL(gl)) {
+      throw new Error('Invalid WebGLRenderingContext');
+    }
+
+    return new WebGLDevice({ ...props,
+      gl: gl
+    });
+  }
+
+  constructor(props) {
+    var _this$props$gl;
+
+    super();
+
+    _defineProperty(this, "features", void 0);
+
+    _defineProperty(this, "limits", void 0);
+
+    _defineProperty(this, "info", void 0);
+
+    _defineProperty(this, "lost", void 0);
+
+    _defineProperty(this, "props", void 0);
+
+    _defineProperty(this, "userData", void 0);
+
+    _defineProperty(this, "isWebGL2", void 0);
+
+    _defineProperty(this, "gl", void 0);
+
+    _defineProperty(this, "gl2", void 0);
+
+    _defineProperty(this, "offScreen", false);
+
+    _defineProperty(this, "webglFeatures", void 0);
+
+    _defineProperty(this, "webglLimits", void 0);
+
+    _defineProperty(this, "defaultFramebuffer", void 0);
+
+    _defineProperty(this, "defaultVertexArray", void 0);
+
+    _defineProperty(this, "_state", 'uninitialized');
+
+    _defineProperty(this, "_canvasSizeInfo", {
+      clientWidth: 0,
+      clientHeight: 0,
+      devicePixelRatio: 1
+    });
+
+    _defineProperty(this, "_extensions", {});
+
+    _defineProperty(this, "_polyfilled", false);
+
+    this.props = { ...DEFAULT_DEVICE_PROPS,
+      ...props
+    };
+    const 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') {
+        log.error('recursive context');
+        throw new Error('recursive context');
+      }
+
+      return device;
+    }
+
+    this.offScreen = typeof OffscreenCanvas !== 'undefined' && props.canvas instanceof OffscreenCanvas;
+    this.gl = this.props.gl || this._createContext(props);
+    this.gl2 = this.gl;
+    this.isWebGL2 = isWebGL2(this.gl);
+    this._state = 'initializing';
+
+    if (this.gl.device) {
+      log.error('device already created');
+      throw new Error('device already created');
+    }
+
+    this.gl.device = this;
+    this.gl._version = typeof WebGL2RenderingContext !== 'undefined' && this.gl instanceof WebGL2RenderingContext ? 2 : 1;
+    glToContextMap.set(this.gl, this);
+    this.info = getDeviceInfo(this.gl);
+    const debug = this.gl.debug ? ' debug' : '';
+    const webGL = isWebGL2(this.gl) ? 'WebGL2' : 'WebGL1';
+    log.group(0, "".concat(webGL).concat(debug, " context: ").concat(this.info.vendor, ", ").concat(this.info.renderer))();
+    polyfillContext(this.gl);
+    log.probe(0, 'polyfilled context')();
+    trackContextState(this.gl, {
+      copyState: false,
+      log: (...args) => log.log(1, ...args)()
+    });
+    log.probe(0, 'instrumented context')();
+    this.features = getDeviceFeatures(this.gl);
+    log.probe(0, "queried device features ".concat(counter))();
+    this.limits = getDeviceLimits(this.gl);
+    log.probe(0, 'queried device limits')();
+    this.webglLimits = getWebGLLimits(this.gl);
+    log.probe(0, 'queried webgl limits')();
+    log.groupEnd(0)();
+    this._state = 'initialized';
+  }
+
+  destroy() {
+    let ext = this.gl.getExtension('STACKGL_destroy_context');
+
+    if (ext) {
+      ext.destroy();
+    }
+  }
+
+  resize(options) {
+    if (this.gl.canvas) {
+      const devicePixelRatio = getDevicePixelRatio(options === null || options === void 0 ? void 0 : options.useDevicePixels);
+      setDevicePixelRatio(this.gl, devicePixelRatio, options);
+      return;
+    }
+
+    const ext = this.gl.getExtension('STACKGL_resize_drawingbuffer');
+
+    if (ext && options && "width" in options && "height" in options) {
+      ext.resize(options.width, options.height);
+    }
+  }
+
+  _createBuffer(props) {
+    return new WEBGLBuffer(this.gl, props);
+  }
+
+  createTexture(props) {
+    return new Texture2D(this, props);
+  }
+
+  createShader(props) {
+    return new WEBGLShader(this, props);
+  }
+
+  commit() {
+    if (this.offScreen && this.gl.commit) {
+      this.gl.commit();
+    }
+  }
+
+  _createContext(options) {
+    const {
+      width,
+      height,
+      canvas
+    } = this.props;
+    const targetCanvas = getCanvas({
+      canvas,
+      width,
+      height
+    });
+    return createBrowserContext(targetCanvas, options);
+  }
+
+}
+//# sourceMappingURL=webgl-device.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapter/webgl-device.ts"],"names":["Device","log","polyfillContext","trackContextState","getDevicePixelRatio","setDevicePixelRatio","createBrowserContext","getCanvas","isWebGL","isWebGL2","getDeviceInfo","getDeviceFeatures","getDeviceLimits","getWebGLLimits","WEBGLBuffer","WEBGLShader","Texture2D","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","fromContext","device","attach","props","Error","constructor","clientWidth","clientHeight","devicePixelRatio","_state","offScreen","OffscreenCanvas","_createContext","gl2","_version","WebGL2RenderingContext","set","webGL","group","vendor","renderer","probe","copyState","args","features","limits","webglLimits","groupEnd","destroy","ext","getExtension","resize","options","useDevicePixels","_createBuffer","createTexture","createShader","commit","targetCanvas"],"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 './device-helpers/get-device-info';\nimport {getDeviceFeatures, Feature} from './device-helpers/device-features';\nimport {getDeviceLimits, getWebGLLimits, WebGLLimits} from './device-helpers/device-limits';\n\n// WebGL classes\nimport type {BufferProps, ShaderProps} from '@luma.gl/api';\nimport WEBGLBuffer from '../classes/webgl-buffer';\nimport {WEBGLShader} from '../adapter/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, props);\n  }\n\n  createShader(props: ShaderProps): WEBGLShader {\n    return new WEBGLShader(this, 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"}

package/dist/adapter/webgl-shader.d.ts

@@ -0,0 +1,18 @@
+import { Shader, ShaderProps } from '@luma.gl/api';
+import { CompilerMessage } from '@luma.gl/shadertools';
+import WebGLDevice from '../adapter/webgl-device';
+/**
+ * An immutable compiled shader program that execute portions of the GPU Pipeline
+ */
+export declare class WEBGLShader extends Shader {
+    readonly device: WebGLDevice;
+    readonly gl: WebGLRenderingContext;
+    readonly handle: WebGLShader;
+    readonly stage: 'vertex' | 'fragment';
+    readonly source: string;
+    constructor(device: WebGLDevice, props: ShaderProps);
+    destroy(): void;
+    compilationInfo(): Promise<readonly CompilerMessage[]>;
+    _compile(source: any): void;
+}
+//# sourceMappingURL=webgl-shader.d.ts.map

package/dist/adapter/webgl-shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-shader.d.ts","sourceRoot":"","sources":["../../src/adapter/webgl-shader.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,MAAM,EAAE,WAAW,EAAC,MAAM,cAAc,CAAC;AAE3D,OAAO,EAAgB,eAAe,EAAoB,MAAM,sBAAsB,CAAC;AAEvF,OAAO,WAAW,MAAM,yBAAyB,CAAC;AAElD;;GAEG;AACF,qBAAa,WAAY,SAAQ,MAAM;IACtC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,EAAE,EAAE,qBAAqB,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAE7B,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,UAAU,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW;IAmBnD,OAAO,IAAI,IAAI;IAST,eAAe,IAAI,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC;IAO5D,QAAQ,CAAC,MAAM,KAAA;CAqBhB"}

package/dist/adapter/webgl-shader.js

@@ -0,0 +1,82 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { log, uid, Shader } from '@luma.gl/api';
+import GL from '@luma.gl/constants';
+import { getShaderInfo, formatCompilerLog } from '@luma.gl/shadertools';
+import { parseShaderCompilerLog } from '../webgl-utils/parse-shader-compiler-log';
+export class WEBGLShader extends Shader {
+  constructor(device, props) {
+    super(device, {
+      id: getShaderIdFromProps(props),
+      ...props
+    });
+
+    _defineProperty(this, "device", void 0);
+
+    _defineProperty(this, "gl", void 0);
+
+    _defineProperty(this, "handle", void 0);
+
+    _defineProperty(this, "stage", void 0);
+
+    _defineProperty(this, "source", void 0);
+
+    this.device = device;
+    this.gl = device.gl;
+
+    switch (this.props.stage) {
+      case 'vertex':
+        this.handle = this.props.handle || this.gl.createShader(GL.VERTEX_SHADER);
+        break;
+
+      case 'fragment':
+        this.handle = this.props.handle || this.gl.createShader(GL.FRAGMENT_SHADER);
+        break;
+
+      default:
+        throw new Error(this.props.stage);
+    }
+
+    this.stage = this.props.stage;
+    this.source = this.props.source;
+
+    this._compile(this.source);
+  }
+
+  destroy() {
+    if (this.handle) {
+      this.removeStats();
+      this.gl.deleteShader(this.handle);
+      this.handle = null;
+    }
+  }
+
+  async compilationInfo() {
+    const log = this.gl.getShaderInfoLog(this.handle);
+    return parseShaderCompilerLog(log);
+  }
+
+  _compile(source) {
+    const addGLSLVersion = source => source.startsWith('#version ') ? source : "#version 100\n".concat(source);
+
+    source = addGLSLVersion(source);
+    this.gl.shaderSource(this.handle, source);
+    this.gl.compileShader(this.handle);
+    const compileStatus = this.gl.getShaderParameter(this.handle, GL.COMPILE_STATUS);
+
+    if (!compileStatus) {
+      const shaderLog = this.gl.getShaderInfoLog(this.handle);
+      const messages = parseShaderCompilerLog(shaderLog).filter(message => message.type === 'error');
+      const formattedLog = formatCompilerLog(messages, source);
+      const shaderName = getShaderInfo(source).name;
+      const shaderDescription = "".concat(this.stage, " shader ").concat(shaderName);
+      log.error("GLSL compilation errors in ".concat(shaderDescription, "\n").concat(formattedLog))();
+      throw new Error("GLSL compilation errors in ".concat(shaderName));
+    }
+  }
+
+}
+
+function getShaderIdFromProps(props) {
+  return getShaderInfo(props.source).name || props.id || uid("unnamed ".concat(props.stage, "-shader"));
+}
+//# sourceMappingURL=webgl-shader.js.map

package/dist/adapter/webgl-shader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapter/webgl-shader.ts"],"names":["log","uid","Shader","GL","getShaderInfo","formatCompilerLog","parseShaderCompilerLog","WEBGLShader","constructor","device","props","id","getShaderIdFromProps","gl","stage","handle","createShader","VERTEX_SHADER","FRAGMENT_SHADER","Error","source","_compile","destroy","removeStats","deleteShader","compilationInfo","getShaderInfoLog","addGLSLVersion","startsWith","shaderSource","compileShader","compileStatus","getShaderParameter","COMPILE_STATUS","shaderLog","messages","filter","message","type","formattedLog","shaderName","name","shaderDescription","error"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\nimport {log, uid, Shader, ShaderProps} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport {getShaderInfo, CompilerMessage, formatCompilerLog} from '@luma.gl/shadertools';\nimport {parseShaderCompilerLog} from '../webgl-utils/parse-shader-compiler-log';\nimport WebGLDevice from '../adapter/webgl-device';\n\n/**\n * An immutable compiled shader program that execute portions of the GPU Pipeline\n */\n export class WEBGLShader extends Shader {\n  readonly device: WebGLDevice;\n  readonly gl: WebGLRenderingContext;\n  readonly handle: WebGLShader;\n\n  readonly stage: 'vertex' | 'fragment';\n  readonly source: string;\n\n  constructor(device: WebGLDevice, props: ShaderProps) {\n    super(device, {id: getShaderIdFromProps(props), ...props});\n    this.device = device;\n    this.gl = device.gl;\n    switch (this.props.stage) {\n      case 'vertex':\n        this.handle = this.props.handle || this.gl.createShader(GL.VERTEX_SHADER);\n        break;\n      case 'fragment':\n        this.handle = this.props.handle || this.gl.createShader(GL.FRAGMENT_SHADER);\n        break;\n      default:\n        throw new Error(this.props.stage);\n    }\n    this.stage = this.props.stage;\n    this.source = this.props.source;\n    this._compile(this.source);\n  }\n\n  destroy(): void {\n    if (this.handle) {\n      this.removeStats();\n      this.gl.deleteShader(this.handle);\n      // @ts-expect-error\n      this.handle = null;\n    }\n  }\n\n  async compilationInfo(): Promise<readonly CompilerMessage[]> {\n    const log = this.gl.getShaderInfoLog(this.handle);\n    return parseShaderCompilerLog(log);\n  }\n\n  // PRIVATE METHODS\n\n  _compile(source) {\n    const addGLSLVersion = source => source.startsWith('#version ') ? source : `#version 100\\n${source}`;\n    source = addGLSLVersion(source);\n\n    this.gl.shaderSource(this.handle, source);\n    this.gl.compileShader(this.handle);\n\n    // TODO - For performance reasons, avoid checking shader compilation errors on production?\n    // TODO - Load log even when no error reported, to catch warnings?\n    // https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings\n    const compileStatus = this.gl.getShaderParameter(this.handle, GL.COMPILE_STATUS);\n    if (!compileStatus) {\n      const shaderLog = this.gl.getShaderInfoLog(this.handle);\n      const messages = parseShaderCompilerLog(shaderLog).filter(message => message.type === 'error');\n      const formattedLog = formatCompilerLog(messages, source);\n      const shaderName: string = getShaderInfo(source).name;\n      const shaderDescription = `${this.stage} shader ${shaderName}`;\n      log.error(`GLSL compilation errors in ${shaderDescription}\\n${formattedLog}`)();\n      throw new Error(`GLSL compilation errors in ${shaderName}`);\n    }\n  }\n}\n\n// HELPERS\n\n/** Deduce an id, from shader source, or supplied id, or shader type */\nfunction getShaderIdFromProps(props: ShaderProps): string {\n  return getShaderInfo(props.source).name ||\n    props.id ||\n    uid(`unnamed ${props.stage}-shader`);\n}\n"],"file":"webgl-shader.js"}

package/dist/bundle.d.ts

@@ -0,0 +1,2 @@
+declare const moduleExports: any;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}