@luma.gl/webgl 8.5.10 → 8.6.0-alpha.4

package/LICENSE

@@ -1,9 +1,16 @@
+Copyright (c) 2020 Urban Computing Foundation
+
+This software includes parts initially developed by Uber and open sourced under MIT license.
 Copyright (c) 2015 Uber Technologies, Inc.
 
 This software includes parts of PhiloGL (https://github.com/philogb/philogl)
 under MIT license. PhiloGL parts Copyright © 2013 Sencha Labs.
 
-This software includes adaptations of postprocessing code from THREE.js (https://github.com/mrdoob/three.js/) under MIT license. Additional attribution given in specific source files. THREE.js parts Copyright © 2010-2018 three.js authors.
+This software includes adaptations of some postprocessing code from 
+THREE.js (https://github.com/mrdoob/three.js/) under MIT license. 
+THREE.js parts Copyright © 2010-2018 three.js authors. 
+
+Additional attribution given in specific source files. 
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/_deprecated/context-api.d.ts

@@ -0,0 +1,85 @@
+import { WebGLDeviceProps } from '@luma.gl/webgl';
+export declare type GLContextOptions = WebGLDeviceProps & {
+    throwOnError?: boolean;
+};
+/** @deprecated Use `new WebGLDevice()` or `luma.createDevice()` */
+export declare function createGLContext(options?: GLContextOptions): WebGLRenderingContext | null;
+/** @deprecated Use `WebGLDevice.attach()` */
+export declare function instrumentGLContext(gl: WebGLRenderingContext | WebGL2RenderingContext, options?: GLContextOptions): WebGLRenderingContext;
+/**
+ * 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
+ *
+ * resizeGLContext(gl, {width, height, useDevicePixels})
+ * @deprecated Use WebGLDevice.resize()
+ */
+export declare function resizeGLContext(gl: WebGLRenderingContext, options?: {
+    width?: number;
+    height?: number;
+    useDevicePixels?: boolean | number;
+}): void;
+/**
+ * Check one or more features
+ * @deprecated Use `WebGLDevice.features.has()`
+*/
+export declare function hasFeatures(gl: WebGLRenderingContext, features: string | string[]): boolean;
+/**
+ * Check one feature
+ * @deprecated Use `WebGLDevice.features`
+ */
+export declare function hasFeature(gl: WebGLRenderingContext, feature: string): boolean;
+/**
+ * Return a map of supported features
+ * @deprecated Use `WebGLDevice.features`
+ */
+export declare function getFeatures(gl: WebGLRenderingContext): Record<string, boolean>;
+/**
+ * Provides strings identifying the GPU vendor and driver.
+ * https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/
+ *
+ * @deprecated Use `WebGLDevice.info`
+ */
+export declare function getContextDebugInfo(gl: WebGLRenderingContext): {
+    vendor: string;
+    renderer: string;
+    vendorMasked: string;
+    rendererMasked: string;
+    version: string;
+};
+/** @deprecated Use `WebGLDevice.info` */
+export declare function getGLContextInfo(gl: any): {
+    37445: string;
+    37446: string;
+    7936: string;
+    7937: string;
+    7938: string;
+};
+/** @deprecated Use `WebGLDevice.info` and `WebGLDevice.limits` */
+export declare function getContextInfo(gl: any): {
+    info: {
+        37445: string;
+        37446: string;
+        7936: string;
+        7937: string;
+        7938: string;
+    };
+    limits: import("../adapter/device-helpers/device-limits").WebGLLimits;
+    vendor: string;
+    renderer: string;
+    vendorMasked: string;
+    rendererMasked: string;
+    version: string;
+};
+/** @deprecated Use `WebGLDevice.limits` */
+export declare function getContextLimits(gl: any): {
+    limits: import("../adapter/device-helpers/device-limits").WebGLLimits;
+};
+//# sourceMappingURL=context-api.d.ts.map

package/dist/_deprecated/context-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-api.d.ts","sourceRoot":"","sources":["../../src/_deprecated/context-api.ts"],"names":[],"mappings":"AAMA,OAAO,EAAc,gBAAgB,EAAC,MAAM,gBAAgB,CAAC;AAG7D,oBAAY,gBAAgB,GAAG,gBAAgB,GAAG;IAChD,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,mEAAmE;AACnE,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,qBAAqB,GAAG,IAAI,CAIxF;AAED,6CAA6C;AAC7C,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,qBAAqB,GAAG,sBAAsB,EAClD,OAAO,CAAC,EAAE,gBAAgB,GACzB,qBAAqB,CAGvB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,qBAAqB,EACzB,OAAO,CAAC,EAAE;IACR,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CACpC,QAIF;AAED;;;EAGE;AACF,wBAAgB,WAAW,CAAC,EAAE,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAK3F;AAMD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAO9E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,qBAAqB,GAAG;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB,CAQA;AAED,yCAAyC;AACzC,wBAAgB,gBAAgB,CAAC,EAAE,KAAA;;;;;;EASlC;AAED,kEAAkE;AAClE,wBAAgB,cAAc,CAAC,EAAE,KAAA;;;;;;;;;;;;;;EAMhC;AAED,2CAA2C;AAC3C,wBAAgB,gBAAgB,CAAC,EAAE,KAAA;;EAGlC"}

package/dist/_deprecated/context-api.js

@@ -0,0 +1,70 @@
+import GL from '@luma.gl/constants';
+import { WebGLDevice } from '@luma.gl/webgl';
+import { FEATURES } from './features';
+export function createGLContext(options) {
+  const webglDevice = new WebGLDevice(options);
+  return webglDevice.gl;
+}
+export function instrumentGLContext(gl, options) {
+  const webglDevice = WebGLDevice.attach(gl, options);
+  return webglDevice.gl;
+}
+export function resizeGLContext(gl, options) {
+  const webglDevice = WebGLDevice.attach(gl);
+  webglDevice.resize(options);
+}
+export function hasFeatures(gl, features) {
+  const webglDevice = WebGLDevice.attach(gl);
+  const normalizedFeatures = Array.isArray(features) ? features : [features];
+  const deviceFeatures = normalizedFeatures.map(feature => getDeviceFeature(feature));
+  return deviceFeatures.every(feature => webglDevice.webglFeatures.has(feature));
+}
+
+function getDeviceFeature(feature) {
+  return feature.toLowerCase().replace('webgl-', '').replace('-', '_');
+}
+
+export function hasFeature(gl, feature) {
+  return hasFeatures(gl, feature);
+}
+export function getFeatures(gl) {
+  const webglDevice = WebGLDevice.attach(gl);
+  const featureMap = {};
+
+  for (const feature in FEATURES) {
+    featureMap[feature] = webglDevice.webglFeatures.has(feature);
+  }
+
+  return featureMap;
+}
+export function getContextDebugInfo(gl) {
+  const webglDevice = WebGLDevice.attach(gl);
+  const info = webglDevice.info;
+  return { ...webglDevice.info,
+    vendorMasked: webglDevice.info.vendor,
+    rendererMasked: webglDevice.info.renderer
+  };
+}
+export function getGLContextInfo(gl) {
+  const info = getContextDebugInfo(gl);
+  return {
+    [GL.UNMASKED_VENDOR_WEBGL]: info.vendor,
+    [GL.UNMASKED_RENDERER_WEBGL]: info.renderer,
+    [GL.VENDOR]: info.vendorMasked,
+    [GL.RENDERER]: info.rendererMasked,
+    [GL.VERSION]: info.version
+  };
+}
+export function getContextInfo(gl) {
+  return { ...getContextDebugInfo(gl),
+    ...getContextLimits(gl),
+    info: getGLContextInfo(gl)
+  };
+}
+export function getContextLimits(gl) {
+  const webglDevice = WebGLDevice.attach(gl);
+  return {
+    limits: webglDevice.webglLimits
+  };
+}
+//# sourceMappingURL=context-api.js.map

package/dist/_deprecated/context-api.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/_deprecated/context-api.ts"],"names":["GL","WebGLDevice","FEATURES","createGLContext","options","webglDevice","gl","instrumentGLContext","attach","resizeGLContext","resize","hasFeatures","features","normalizedFeatures","Array","isArray","deviceFeatures","map","feature","getDeviceFeature","every","webglFeatures","has","toLowerCase","replace","hasFeature","getFeatures","featureMap","getContextDebugInfo","info","vendorMasked","vendor","rendererMasked","renderer","getGLContextInfo","UNMASKED_VENDOR_WEBGL","UNMASKED_RENDERER_WEBGL","VENDOR","RENDERER","VERSION","version","getContextInfo","getContextLimits","limits","webglLimits"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\n// LEGACY luma.gl v8 API for WebGLRendering context\n// DEPRECATED API - may be removed in luma.gl v9 or v10.\n\n/* eslint-disable quotes */\nimport GL from '@luma.gl/constants';\nimport {WebGLDevice, WebGLDeviceProps} from '@luma.gl/webgl';\nimport {FEATURES} from './features';\n\nexport type GLContextOptions = WebGLDeviceProps & {\n  throwOnError?: boolean; // If set to false, return `null` if context creation fails.\n};\n\n/** @deprecated Use `new WebGLDevice()` or `luma.createDevice()` */\nexport function createGLContext(options?: GLContextOptions): WebGLRenderingContext | null {\n  const webglDevice = new WebGLDevice(options);\n  // Note: OK to return the context, it holds on to the device\n  return webglDevice.gl;\n}\n\n/** @deprecated Use `WebGLDevice.attach()` */\nexport function instrumentGLContext(\n  gl: WebGLRenderingContext | WebGL2RenderingContext,\n  options?: GLContextOptions\n): WebGLRenderingContext {\n  const webglDevice = WebGLDevice.attach(gl, options);\n  return webglDevice.gl;\n}\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 * resizeGLContext(gl, {width, height, useDevicePixels})\n * @deprecated Use WebGLDevice.resize()\n */\nexport function resizeGLContext(\n  gl: WebGLRenderingContext,\n  options?: {\n    width?: number;\n    height?: number;\n    useDevicePixels?: boolean | number;\n  }\n) {\n  const webglDevice = WebGLDevice.attach(gl);\n  webglDevice.resize(options);\n}\n\n/** \n * Check one or more features\n * @deprecated Use `WebGLDevice.features.has()`\n*/\nexport function hasFeatures(gl: WebGLRenderingContext, features: string | string[]): boolean {\n  const webglDevice = WebGLDevice.attach(gl);\n  const normalizedFeatures = Array.isArray(features) ? features : [features];\n  const deviceFeatures = normalizedFeatures.map(feature => getDeviceFeature(feature));\n  return deviceFeatures.every((feature) => webglDevice.webglFeatures.has(feature));\n}\n\nfunction getDeviceFeature(feature) {\n  return feature.toLowerCase().replace('webgl-', '').replace('-', '_');\n}\n\n/**\n * Check one feature\n * @deprecated Use `WebGLDevice.features`\n */\nexport function hasFeature(gl: WebGLRenderingContext, feature: string): boolean {\n  return hasFeatures(gl, feature);\n}\n\n/**\n * Return a map of supported features\n * @deprecated Use `WebGLDevice.features`\n */\nexport function getFeatures(gl: WebGLRenderingContext): Record<string, boolean>  {\n  const webglDevice = WebGLDevice.attach(gl);\n  const featureMap: Record<string, boolean> = {};\n  for (const feature in FEATURES) {\n    featureMap[feature] = webglDevice.webglFeatures.has(feature);\n  }\n  return featureMap;\n}\n\n/**\n * Provides strings identifying the GPU vendor and driver.\n * https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/\n *\n * @deprecated Use `WebGLDevice.info`\n */\nexport function getContextDebugInfo(gl: WebGLRenderingContext): {\n  vendor: string;\n  renderer: string;\n  vendorMasked: string;\n  rendererMasked: string;\n  version: string;\n} {\n  const webglDevice = WebGLDevice.attach(gl);\n  const info = webglDevice.info;\n  return {\n    ...webglDevice.info,\n    vendorMasked: webglDevice.info.vendor,\n    rendererMasked: webglDevice.info.renderer\n  };\n}\n\n/** @deprecated Use `WebGLDevice.info` */\nexport function getGLContextInfo(gl) {\n  const info = getContextDebugInfo(gl);\n  return {\n    [GL.UNMASKED_VENDOR_WEBGL]: info.vendor,\n    [GL.UNMASKED_RENDERER_WEBGL]: info.renderer,\n    [GL.VENDOR]: info.vendorMasked,\n    [GL.RENDERER]: info.rendererMasked,\n    [GL.VERSION]: info.version,\n  };\n}\n\n/** @deprecated Use `WebGLDevice.info` and `WebGLDevice.limits` */\nexport function getContextInfo(gl) {\n  return {\n    ...getContextDebugInfo(gl),\n    ...getContextLimits(gl),\n    info: getGLContextInfo(gl),\n  };\n}\n\n/** @deprecated Use `WebGLDevice.limits` */\nexport function getContextLimits(gl) {\n  const webglDevice = WebGLDevice.attach(gl);\n  return {limits: webglDevice.webglLimits};\n}\n"],"file":"context-api.js"}

package/dist/_deprecated/features.d.ts

@@ -0,0 +1,27 @@
+export declare const FEATURES: {
+    WEBGL2: string;
+    VERTEX_ARRAY_OBJECT: string;
+    TIMER_QUERY: string;
+    INSTANCED_RENDERING: string;
+    MULTIPLE_RENDER_TARGETS: string;
+    ELEMENT_INDEX_UINT32: string;
+    BLEND_EQUATION_MINMAX: string;
+    FLOAT_BLEND: string;
+    COLOR_ENCODING_SRGB: string;
+    TEXTURE_DEPTH: string;
+    TEXTURE_FLOAT: string;
+    TEXTURE_HALF_FLOAT: string;
+    TEXTURE_FILTER_LINEAR_FLOAT: string;
+    TEXTURE_FILTER_LINEAR_HALF_FLOAT: string;
+    TEXTURE_FILTER_ANISOTROPIC: string;
+    COLOR_ATTACHMENT_RGBA32F: string;
+    COLOR_ATTACHMENT_FLOAT: string;
+    COLOR_ATTACHMENT_HALF_FLOAT: string;
+    GLSL_FRAG_DATA: string;
+    GLSL_FRAG_DEPTH: string;
+    GLSL_DERIVATIVES: string;
+    GLSL_TEXTURE_LOD: string;
+};
+/** Extract all WebGL features */
+export declare function getWebGLFeatures(gl: WebGLRenderingContext): Set<string>;
+//# sourceMappingURL=features.d.ts.map

package/dist/_deprecated/features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../src/_deprecated/features.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;CAsCpB,CAAC;AAEF,iCAAiC;AACjC,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,qBAAqB,GAAG,GAAG,CAAC,MAAM,CAAC,CAavE"}

package/{src/features/webgl-features-table.js → dist/_deprecated/features.js}

@@ -1,104 +1,111 @@
-import Framebuffer from '../classes/framebuffer';
-import Texture2D from '../classes/texture-2d';
-// TODO - this should be the default export, test cases need updating
+import GL from '@luma.gl/constants';
+import { isWebGL2 } from '@luma.gl/webgl';
+import { assert } from '@luma.gl/api';
 export const FEATURES = {
   WEBGL2: 'WEBGL2',
-
-  // API SUPPORT
   VERTEX_ARRAY_OBJECT: 'VERTEX_ARRAY_OBJECT',
   TIMER_QUERY: 'TIMER_QUERY',
   INSTANCED_RENDERING: 'INSTANCED_RENDERING',
   MULTIPLE_RENDER_TARGETS: 'MULTIPLE_RENDER_TARGETS',
-
-  // FEATURES
   ELEMENT_INDEX_UINT32: 'ELEMENT_INDEX_UINT32',
-
-  // BLENDING
   BLEND_EQUATION_MINMAX: 'BLEND_EQUATION_MINMAX',
   FLOAT_BLEND: 'FLOAT_BLEND',
-
-  // TEXTURES: '// TEXTURES', RENDERBUFFERS
   COLOR_ENCODING_SRGB: 'COLOR_ENCODING_SRGB',
-
-  // TEXTURES
   TEXTURE_DEPTH: 'TEXTURE_DEPTH',
   TEXTURE_FLOAT: 'TEXTURE_FLOAT',
   TEXTURE_HALF_FLOAT: 'TEXTURE_HALF_FLOAT',
-
   TEXTURE_FILTER_LINEAR_FLOAT: 'TEXTURE_FILTER_LINEAR_FLOAT',
   TEXTURE_FILTER_LINEAR_HALF_FLOAT: 'TEXTURE_FILTER_LINEAR_HALF_FLOAT',
   TEXTURE_FILTER_ANISOTROPIC: 'TEXTURE_FILTER_ANISOTROPIC',
-
-  // FRAMEBUFFERS: '// FRAMEBUFFERS', TEXTURES AND RENDERBUFFERS
   COLOR_ATTACHMENT_RGBA32F: 'COLOR_ATTACHMENT_RGBA32F',
   COLOR_ATTACHMENT_FLOAT: 'COLOR_ATTACHMENT_FLOAT',
   COLOR_ATTACHMENT_HALF_FLOAT: 'COLOR_ATTACHMENT_HALF_FLOAT',
-
-  // GLSL extensions
   GLSL_FRAG_DATA: 'GLSL_FRAG_DATA',
   GLSL_FRAG_DEPTH: 'GLSL_FRAG_DEPTH',
   GLSL_DERIVATIVES: 'GLSL_DERIVATIVES',
   GLSL_TEXTURE_LOD: 'GLSL_TEXTURE_LOD'
 };
+export function getWebGLFeatures(gl) {
+  gl.getExtension('EXT_color_buffer_float');
+  gl.getExtension('WEBGL_color_buffer_float');
+  gl.getExtension('EXT_float_blend');
+  const features = new Set();
+
+  for (const feature in WEBGL_FEATURES) {
+    if (isFeatureSupported(gl, feature)) {
+      features.add(feature);
+    }
+  }
+
+  return features;
+}
+
+function isFeatureSupported(gl, cap) {
+  const feature = WEBGL_FEATURES[cap];
+  assert(feature, cap);
+  const [webgl1Feature, webgl2Feature] = feature;
+  const featureDefinition = isWebGL2(gl) ? webgl2Feature : webgl1Feature;
+
+  if (cap === FEATURES.COLOR_ATTACHMENT_RGBA32F && !isWebGL2(gl)) {
+    return checkFloat32ColorAttachment(gl);
+  }
+
+  if (typeof featureDefinition === 'string') {
+    return Boolean(gl.getExtension(featureDefinition));
+  }
+
+  return featureDefinition;
+}
 
-// function to test if Float 32 bit format texture can be bound as color attachment
 function checkFloat32ColorAttachment(gl) {
-  const testTexture = new Texture2D(gl, {
-    format: gl.RGBA,
-    type: gl.FLOAT,
-    dataFormat: gl.RGBA
-  });
-  const testFb = new Framebuffer(gl, {
-    id: `test-framebuffer`,
-    check: false,
-    attachments: {
-      [gl.COLOR_ATTACHMENT0]: testTexture
-    }
-  });
-  const status = testFb.getStatus();
-  testTexture.delete();
-  testFb.delete();
-  return status === gl.FRAMEBUFFER_COMPLETE;
+  let texture;
+  let framebuffer;
+
+  try {
+    const texture = gl.createTexture();
+    gl.bindTexture(GL.TEXTURE_2D, texture);
+    const level = 0;
+    const internalFormat = gl.RGBA;
+    const width = 1;
+    const height = 1;
+    const border = 0;
+    const srcFormat = gl.RGBA;
+    const srcType = gl.UNSIGNED_BYTE;
+    const pixel = new Uint8Array([0, 0, 255, 255]);
+    gl.texImage2D(gl.TEXTURE_2D, level, internalFormat, width, height, border, srcFormat, srcType, pixel);
+    const framebuffer = gl.createFramebuffer();
+    gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer);
+    gl.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, texture, 0);
+    const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER) === GL.FRAMEBUFFER_COMPLETE;
+    return status;
+  } finally {
+    gl.deleteTexture(texture);
+    gl.deleteFramebuffer(framebuffer);
+  }
 }
 
-// Defines luma.gl "feature" names and semantics
-// Format: 'feature-name: [WebGL1 support, WebGL2 support] / [WebGL1 and WebGL2 support]', when support is 'string' it is the name of the extension
-export default {
+const WEBGL_FEATURES = {
   [FEATURES.WEBGL2]: [false, true],
-
-  // API SUPPORT
   [FEATURES.VERTEX_ARRAY_OBJECT]: ['OES_vertex_array_object', true],
   [FEATURES.TIMER_QUERY]: ['EXT_disjoint_timer_query', 'EXT_disjoint_timer_query_webgl2'],
   [FEATURES.INSTANCED_RENDERING]: ['ANGLE_instanced_arrays', true],
   [FEATURES.MULTIPLE_RENDER_TARGETS]: ['WEBGL_draw_buffers', true],
-
-  // FEATURES
   [FEATURES.ELEMENT_INDEX_UINT32]: ['OES_element_index_uint', true],
-
-  // BLENDING
   [FEATURES.BLEND_EQUATION_MINMAX]: ['EXT_blend_minmax', true],
-  [FEATURES.FLOAT_BLEND]: ['EXT_float_blend'],
-
-  // TEXTURES, RENDERBUFFERS
+  [FEATURES.FLOAT_BLEND]: ['EXT_float_blend', 'EXT_float_blend'],
   [FEATURES.COLOR_ENCODING_SRGB]: ['EXT_sRGB', true],
-
-  // TEXTURES
   [FEATURES.TEXTURE_DEPTH]: ['WEBGL_depth_texture', true],
   [FEATURES.TEXTURE_FLOAT]: ['OES_texture_float', true],
   [FEATURES.TEXTURE_HALF_FLOAT]: ['OES_texture_half_float', true],
-
-  [FEATURES.TEXTURE_FILTER_LINEAR_FLOAT]: ['OES_texture_float_linear'],
-  [FEATURES.TEXTURE_FILTER_LINEAR_HALF_FLOAT]: ['OES_texture_half_float_linear'],
-  [FEATURES.TEXTURE_FILTER_ANISOTROPIC]: ['EXT_texture_filter_anisotropic'],
-
-  // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS
-  [FEATURES.COLOR_ATTACHMENT_RGBA32F]: [checkFloat32ColorAttachment, 'EXT_color_buffer_float'],
+  [FEATURES.TEXTURE_FILTER_LINEAR_FLOAT]: ['OES_texture_float_linear', 'OES_texture_float_linear'],
+  [FEATURES.TEXTURE_FILTER_LINEAR_HALF_FLOAT]: ['OES_texture_half_float_linear', 'OES_texture_half_float_linear'],
+  [FEATURES.TEXTURE_FILTER_ANISOTROPIC]: ['EXT_texture_filter_anisotropic', 'EXT_texture_filter_anisotropic'],
+  [FEATURES.COLOR_ATTACHMENT_RGBA32F]: [false, 'EXT_color_buffer_float'],
   [FEATURES.COLOR_ATTACHMENT_FLOAT]: [false, 'EXT_color_buffer_float'],
-  [FEATURES.COLOR_ATTACHMENT_HALF_FLOAT]: ['EXT_color_buffer_half_float'],
-
-  // GLSL extensions
+  [FEATURES.COLOR_ATTACHMENT_HALF_FLOAT]: ['EXT_color_buffer_half_float', 'EXT_color_buffer_half_float'],
   [FEATURES.GLSL_FRAG_DATA]: ['WEBGL_draw_buffers', true],
   [FEATURES.GLSL_FRAG_DEPTH]: ['EXT_frag_depth', true],
   [FEATURES.GLSL_DERIVATIVES]: ['OES_standard_derivatives', true],
   [FEATURES.GLSL_TEXTURE_LOD]: ['EXT_shader_texture_lod', true]
 };
+//# sourceMappingURL=features.js.map

package/dist/_deprecated/features.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/_deprecated/features.ts"],"names":["GL","isWebGL2","assert","FEATURES","WEBGL2","VERTEX_ARRAY_OBJECT","TIMER_QUERY","INSTANCED_RENDERING","MULTIPLE_RENDER_TARGETS","ELEMENT_INDEX_UINT32","BLEND_EQUATION_MINMAX","FLOAT_BLEND","COLOR_ENCODING_SRGB","TEXTURE_DEPTH","TEXTURE_FLOAT","TEXTURE_HALF_FLOAT","TEXTURE_FILTER_LINEAR_FLOAT","TEXTURE_FILTER_LINEAR_HALF_FLOAT","TEXTURE_FILTER_ANISOTROPIC","COLOR_ATTACHMENT_RGBA32F","COLOR_ATTACHMENT_FLOAT","COLOR_ATTACHMENT_HALF_FLOAT","GLSL_FRAG_DATA","GLSL_FRAG_DEPTH","GLSL_DERIVATIVES","GLSL_TEXTURE_LOD","getWebGLFeatures","gl","getExtension","features","Set","feature","WEBGL_FEATURES","isFeatureSupported","add","cap","webgl1Feature","webgl2Feature","featureDefinition","checkFloat32ColorAttachment","Boolean","texture","framebuffer","createTexture","bindTexture","TEXTURE_2D","level","internalFormat","RGBA","width","height","border","srcFormat","srcType","UNSIGNED_BYTE","pixel","Uint8Array","texImage2D","createFramebuffer","bindFramebuffer","FRAMEBUFFER","framebufferTexture2D","COLOR_ATTACHMENT0","status","checkFramebufferStatus","FRAMEBUFFER_COMPLETE","deleteTexture","deleteFramebuffer"],"mappings":"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","sourcesContent":["// Feature detection for WebGL\n// Provides a function that enables simple checking of which WebGL features are\n// available in an WebGL1 or WebGL2 environment.\n\nimport GL from '@luma.gl/constants';\nimport {isWebGL2} from '@luma.gl/webgl';\nimport {assert} from '@luma.gl/api';\n\n// TODO - this should be the default export, test cases need updating\nexport const FEATURES = {\n  WEBGL2: 'WEBGL2',\n\n  // API SUPPORT\n  VERTEX_ARRAY_OBJECT: 'VERTEX_ARRAY_OBJECT',\n  TIMER_QUERY: 'TIMER_QUERY',\n  INSTANCED_RENDERING: 'INSTANCED_RENDERING',\n  MULTIPLE_RENDER_TARGETS: 'MULTIPLE_RENDER_TARGETS',\n\n  // FEATURES\n  ELEMENT_INDEX_UINT32: 'ELEMENT_INDEX_UINT32',\n\n  // BLENDING\n  BLEND_EQUATION_MINMAX: 'BLEND_EQUATION_MINMAX',\n  FLOAT_BLEND: 'FLOAT_BLEND',\n\n  // TEXTURES: '// TEXTURES', RENDERBUFFERS\n  COLOR_ENCODING_SRGB: 'COLOR_ENCODING_SRGB',\n\n  // TEXTURES\n  TEXTURE_DEPTH: 'TEXTURE_DEPTH',\n  TEXTURE_FLOAT: 'TEXTURE_FLOAT',\n  TEXTURE_HALF_FLOAT: 'TEXTURE_HALF_FLOAT',\n\n  TEXTURE_FILTER_LINEAR_FLOAT: 'TEXTURE_FILTER_LINEAR_FLOAT',\n  TEXTURE_FILTER_LINEAR_HALF_FLOAT: 'TEXTURE_FILTER_LINEAR_HALF_FLOAT',\n  TEXTURE_FILTER_ANISOTROPIC: 'TEXTURE_FILTER_ANISOTROPIC',\n\n  // FRAMEBUFFERS: '// FRAMEBUFFERS', TEXTURES AND RENDERBUFFERS\n  COLOR_ATTACHMENT_RGBA32F: 'COLOR_ATTACHMENT_RGBA32F',\n  COLOR_ATTACHMENT_FLOAT: 'COLOR_ATTACHMENT_FLOAT',\n  COLOR_ATTACHMENT_HALF_FLOAT: 'COLOR_ATTACHMENT_HALF_FLOAT',\n\n  // GLSL extensions\n  GLSL_FRAG_DATA: 'GLSL_FRAG_DATA',\n  GLSL_FRAG_DEPTH: 'GLSL_FRAG_DEPTH',\n  GLSL_DERIVATIVES: 'GLSL_DERIVATIVES',\n  GLSL_TEXTURE_LOD: 'GLSL_TEXTURE_LOD'\n};\n\n/** Extract all WebGL features */\nexport function getWebGLFeatures(gl: WebGLRenderingContext): Set<string> {\n  // Enable EXT_float_blend first: https://developer.mozilla.org/en-US/docs/Web/API/EXT_float_blend\n  gl.getExtension('EXT_color_buffer_float');\n  gl.getExtension('WEBGL_color_buffer_float');\n  gl.getExtension('EXT_float_blend');\n\n  const features = new Set<string>();\n  for (const feature in WEBGL_FEATURES) {\n    if (isFeatureSupported(gl, feature)) {\n      features.add(feature);\n    }\n  }\n  return features;\n}\n\nfunction isFeatureSupported(gl: WebGLRenderingContext, cap: string): boolean {\n  const feature = WEBGL_FEATURES[cap];\n  assert(feature, cap);\n\n  const [webgl1Feature, webgl2Feature] = feature;\n\n  // Get extension name from table\n  const featureDefinition = isWebGL2(gl) ? webgl2Feature : webgl1Feature;\n\n  if (cap === FEATURES.COLOR_ATTACHMENT_RGBA32F && !isWebGL2(gl)) {\n    return checkFloat32ColorAttachment(gl);\n  }\n\n  // Check if the value is dependent on checking one or more extensions\n  if (typeof featureDefinition === 'string') {\n    return Boolean(gl.getExtension(featureDefinition));\n  }\n\n  return featureDefinition;\n}\n\n\n// function to test if Float 32 bit format texture can be bound as color attachment\nfunction checkFloat32ColorAttachment(gl: WebGLRenderingContext) {\n  let texture: WebGLTexture;\n  let framebuffer: WebGLFramebuffer;\n  try {\n    const texture = gl.createTexture();\n    gl.bindTexture(GL.TEXTURE_2D, texture);\n\n    const level = 0;\n    const internalFormat = gl.RGBA;\n    const width = 1;\n    const height = 1;\n    const border = 0;\n    const srcFormat = gl.RGBA;\n    const srcType = gl.UNSIGNED_BYTE;\n    const pixel = new Uint8Array([0, 0, 255, 255]);  // opaque blue\n    gl.texImage2D(gl.TEXTURE_2D, level, internalFormat,\n                  width, height, border, srcFormat, srcType,\n                  pixel);\n\n    const framebuffer = gl.createFramebuffer();\n    gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer);\n    gl.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, texture, 0);\n    const status = gl.checkFramebufferStatus(GL.FRAMEBUFFER) === GL.FRAMEBUFFER_COMPLETE;\n    return status;\n  } finally {\n    gl.deleteTexture(texture);\n    gl.deleteFramebuffer(framebuffer);\n  }\n}\n\n// Defines luma.gl \"feature\" names and semantics\n// Format: 'feature-name: [WebGL1 support, WebGL2 support] / [WebGL1 and WebGL2 support]', when support is 'string' it is the name of the extension\nconst WEBGL_FEATURES: Record<string, [boolean | string, boolean | string]> = {\n  [FEATURES.WEBGL2]: [false, true],\n\n  // API SUPPORT\n  [FEATURES.VERTEX_ARRAY_OBJECT]: ['OES_vertex_array_object', true],\n  [FEATURES.TIMER_QUERY]: ['EXT_disjoint_timer_query', 'EXT_disjoint_timer_query_webgl2'],\n  [FEATURES.INSTANCED_RENDERING]: ['ANGLE_instanced_arrays', true],\n  [FEATURES.MULTIPLE_RENDER_TARGETS]: ['WEBGL_draw_buffers', true],\n\n  // FEATURES\n  [FEATURES.ELEMENT_INDEX_UINT32]: ['OES_element_index_uint', true],\n\n  // BLENDING\n  [FEATURES.BLEND_EQUATION_MINMAX]: ['EXT_blend_minmax', true],\n  [FEATURES.FLOAT_BLEND]: ['EXT_float_blend', 'EXT_float_blend'],\n\n  // TEXTURES, RENDERBUFFERS\n  [FEATURES.COLOR_ENCODING_SRGB]: ['EXT_sRGB', true],\n\n  // TEXTURES\n  [FEATURES.TEXTURE_DEPTH]: ['WEBGL_depth_texture', true],\n  [FEATURES.TEXTURE_FLOAT]: ['OES_texture_float', true],\n  [FEATURES.TEXTURE_HALF_FLOAT]: ['OES_texture_half_float', true],\n\n  [FEATURES.TEXTURE_FILTER_LINEAR_FLOAT]: ['OES_texture_float_linear', 'OES_texture_float_linear'],\n  [FEATURES.TEXTURE_FILTER_LINEAR_HALF_FLOAT]: ['OES_texture_half_float_linear', 'OES_texture_half_float_linear'],\n  [FEATURES.TEXTURE_FILTER_ANISOTROPIC]: ['EXT_texture_filter_anisotropic', 'EXT_texture_filter_anisotropic'],\n\n  // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS\n  [FEATURES.COLOR_ATTACHMENT_RGBA32F]: [false, 'EXT_color_buffer_float'], // Note override check\n  [FEATURES.COLOR_ATTACHMENT_FLOAT]: [false, 'EXT_color_buffer_float'],\n  [FEATURES.COLOR_ATTACHMENT_HALF_FLOAT]: ['EXT_color_buffer_half_float', 'EXT_color_buffer_half_float'],\n\n  // GLSL extensions\n  [FEATURES.GLSL_FRAG_DATA]: ['WEBGL_draw_buffers', true],\n  [FEATURES.GLSL_FRAG_DEPTH]: ['EXT_frag_depth', true],\n  [FEATURES.GLSL_DERIVATIVES]: ['OES_standard_derivatives', true],\n  [FEATURES.GLSL_TEXTURE_LOD]: ['EXT_shader_texture_lod', true]\n};\n"],"file":"features.js"}

package/dist/adapter/converters/set-device-parameters.d.ts

@@ -0,0 +1,5 @@
+import { Device, Parameters, CompareFunction } from '@luma.gl/api';
+/** Set WebGPU Style Parameters */
+export declare function setDeviceParameters(device: Device, parameters: Parameters): void;
+export declare function convertCompareFunction(parameter: any, value: CompareFunction): number;
+//# sourceMappingURL=set-device-parameters.d.ts.map

package/dist/adapter/converters/set-device-parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-device-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/set-device-parameters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,eAAe,EAAwB,MAAM,cAAc,CAAC;AAIxF,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,QAoGzE;AA0BD,wBAAgB,sBAAsB,CAAC,SAAS,KAAA,EAAE,KAAK,EAAE,eAAe,GAAG,MAAM,CAWhF"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapter/converters/set-device-parameters.ts"],"names":["log","GL","WebGLDevice","setDeviceParameters","device","parameters","webglDevice","attach","gl","gl2","cullMode","disable","CULL_FACE","enable","cullFace","FRONT","BACK","frontFace","map","ccw","CCW","cw","CW","depthBias","undefined","polygonOffset","depthBiasSlopeScale","depthWriteEnabled","depthMask","mapBoolean","depthCompare","DEPTH_TEST","depthFunc","convertCompareFunction","stencilWriteMask","mask","stencilMaskSeparate","stencilReadMask","warn","stencilCompare","glValue","STENCIL_TEST","stencilFuncSeparate","stencilPassOperation","dppass","convertStencilOperation","sfail","stencilFailOperation","dpfail","stencilDepthFailOperation","stencilOpSeparate","parameter","value","NEVER","LESS","EQUAL","LEQUAL","GREATER","NOTEQUAL","GEQUAL","ALWAYS","KEEP","ZERO","REPLACE","INVERT","INCR","DECR","INCR_WRAP","DECR_WRAP","convertBlendOperationToEquation","FUNC_ADD","FUNC_SUBTRACT","FUNC_REVERSE_SUBTRACT","MIN","MAX","message","valueMap","Error"],"mappings":"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","sourcesContent":["import {Device, Parameters, CompareFunction, StencilOperation, log} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport {WebGLDevice} from '@luma.gl/webgl';\n\n/** Set WebGPU Style Parameters */\nexport function setDeviceParameters(device: Device, parameters: Parameters) {\n  const webglDevice = WebGLDevice.attach(device);\n  const {gl, gl2} = webglDevice;\n\n  // RASTERIZATION SETTINGS\n  if (parameters.cullMode) {\n    switch (parameters.cullMode) {\n      case 'none':\n        gl.disable(GL.CULL_FACE);\n        break;\n      case 'front':\n        gl.enable(GL.CULL_FACE);\n        gl.cullFace(GL.FRONT);\n        break;\n      case 'back':\n        gl.enable(GL.CULL_FACE);\n        gl.cullFace(GL.BACK);\n        break;\n    }\n  }\n\n  if (parameters.frontFace) {\n    gl.frontFace(map('frontFace', parameters.frontFace, {\n      ccw: GL.CCW,\n      cw: GL.CW\n    }));\n  }\n\n  if (parameters.depthBias !== undefined) {\n    gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);\n  }\n\n  // depthBiasSlopeScale: {\n  //   // Handled by depthBias\n  // },\n\n  // DEPTH STENCIL\n\n  if (parameters.depthWriteEnabled !== undefined) {\n    gl.depthMask(mapBoolean('depthWriteEnabled', parameters.depthWriteEnabled));\n  }\n\n if (parameters.depthCompare) {\n    parameters.depthCompare !== 'always' ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST),\n    gl.depthFunc(convertCompareFunction('depthCompare', parameters.depthCompare));\n  }\n\n  if (parameters.stencilWriteMask) {\n    const mask = parameters.stencilWriteMask;\n    gl.stencilMaskSeparate(GL.FRONT, mask);\n    gl.stencilMaskSeparate(GL.BACK, mask);\n  }\n\n  if (parameters.stencilReadMask) {\n    // stencilReadMask is handle inside stencil***Compare.\n    log.warn('stencilReadMask not supported under WebGL');\n  }\n\n  if (parameters.stencilCompare) {\n    const mask = parameters.stencilReadMask || 0xffffffff;\n    const glValue = convertCompareFunction('depthCompare', parameters.stencilCompare);\n    // TODO - ensure back doesn't overwrite\n    parameters.stencilCompare !== 'always' ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST),\n    gl.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);\n    gl.stencilFuncSeparate(GL.BACK, glValue, 0, mask);\n  }\n\n  if (parameters.stencilPassOperation) {\n    const dppass = convertStencilOperation('stencilPassOperation', parameters.stencilPassOperation);\n    const sfail = convertStencilOperation('stencilFailOperation', parameters.stencilFailOperation);\n    const dpfail = convertStencilOperation('stencilDepthFailOperation', parameters.stencilDepthFailOperation);\n    gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);\n    gl.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);\n  }\n\n  // stencilDepthFailOperation() {\n  //   // handled by stencilPassOperation\n  // },\n\n  // stencilFailOperation() {\n  //   // handled by stencilPassOperation\n  // },\n\n  // COLOR STATE\n\n  // if (parameters.blend) {\n  //   gl.enable(GL.BLEND);\n\n  //   const blend = parameters.blend;\n\n  //   let colorEquation = (blend && blend.color && blend.color.operation) || 'add';\n  //   let alphaEquation = (blend && blend.alpha && blend.alpha.operation) || 'add';\n  //   gl.blendEquationSeparate(colorEquation, alphaEquation);\n\n  //   let colorSrcFactor = (blend && blend.color && blend.color.srcFactor) || 'one';\n  //   let colorDstFactor = (blend && blend.color && blend.color.dstFactor) || 'zero';\n  //   let alphaSrcFactor = (blend && blend.alpha && blend.alpha.srcFactor) || 'one';\n  //   let alphaDstFactor = (blend && blend.alpha && blend.alpha.dstFactor) || 'zero';\n  //   gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);\n  // }\n}\n\n/*\n      rasterizationState: {\n        cullMode: \"back\",\n      },\n\n      depthStencilState: {\n        depthWriteEnabled: true,\n        depthCompare: \"less\",\n        format: \"depth24plus-stencil8\",\n      },\n\n      colorStates: [\n        {\n          format: \"bgra8unorm\",\n          // colorBlend.srcFactor = wgpu::BlendFactor::SrcAlpha;\n          // colorBlend.dstFactor = wgpu::BlendFactor::OneMinusSrcAlpha;\n          // alphaBlend.srcFactor = wgpu::BlendFactor::SrcAlpha;\n          // alphaBlend.dstFactor = wgpu::BlendFactor::OneMinusSrcAlpha;\n        },\n      ],\n    });\n*/\n\n\nexport function convertCompareFunction(parameter, value: CompareFunction): number {\n  return map(parameter, value, {\n    'never': GL.NEVER,\n    'less': GL.LESS,\n    'equal': GL.EQUAL,\n    'less-equal': GL.LEQUAL,\n    'greater': GL.GREATER,\n    'not-equal': GL.NOTEQUAL,\n    'greater-equal': GL.GEQUAL,\n    'always': GL.ALWAYS\n  });\n}\n\nfunction convertStencilOperation(parameter, value: StencilOperation): number {\n  return map(parameter, value, {\n    'keep': GL.KEEP,\n    'zero': GL.ZERO,\n    'replace': GL.REPLACE,\n    'invert': GL.INVERT,\n    'increment-clamp': GL.INCR,\n    'decrement-clamp': GL.DECR,\n    'increment-wrap': GL.INCR_WRAP,\n    'decrement-wrap': GL.DECR_WRAP\n  });\n}\n\nfunction convertBlendOperationToEquation(parameter, value): number {\n  return map(parameter, value, {\n    'add': GL.FUNC_ADD,\n    'sub': GL.FUNC_SUBTRACT,\n    'reverse-subtract': GL.FUNC_REVERSE_SUBTRACT,\n    // When using a WebGL 2 context, the following values are available additionally:\n    'min': GL.MIN,\n    'max': GL.MAX\n  });\n}\n\nfunction message(parameter, value) {\n  return `Illegal parameter ${value} for ${parameter}`;\n}\n\nfunction map(parameter, value, valueMap) {\n  if (!(value in valueMap)) {\n    throw new Error(message(parameter, value));\n  }\n  return valueMap[value];\n}\n\nfunction mapBoolean(parameter, value) {\n  return value;\n}\n"],"file":"set-device-parameters.js"}