@luma.gl/webgl 9.0.0-beta.5 → 9.0.0-beta.7

package/dist/adapter/helpers/decode-webgl-types.js

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { GL } from '@luma.gl/constants';
 /** Check is uniform is of sampler type */
@@ -6,50 +7,50 @@ export function isSamplerUniform(type) {
     return SAMPLER_TYPES.includes(type);
 }
 const SAMPLER_TYPES = [
-    GL.SAMPLER_2D,
-    GL.SAMPLER_CUBE,
-    GL.SAMPLER_3D,
-    GL.SAMPLER_2D_SHADOW,
-    GL.SAMPLER_2D_ARRAY,
-    GL.SAMPLER_2D_ARRAY_SHADOW,
-    GL.SAMPLER_CUBE_SHADOW,
-    GL.INT_SAMPLER_2D,
-    GL.INT_SAMPLER_3D,
-    GL.INT_SAMPLER_CUBE,
-    GL.INT_SAMPLER_2D_ARRAY,
-    GL.UNSIGNED_INT_SAMPLER_2D,
-    GL.UNSIGNED_INT_SAMPLER_3D,
-    GL.UNSIGNED_INT_SAMPLER_CUBE,
-    GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
+    35678,
+    35680,
+    35679,
+    35682,
+    36289,
+    36292,
+    36293,
+    36298,
+    36299,
+    36300,
+    36303,
+    36306,
+    36307,
+    36308,
+    36311
 ];
 // Composite types table
 const COMPOSITE_GL_TYPES = {
-    [GL.FLOAT]: [GL.FLOAT, 1, 'float', 'f32', 'float32'],
-    [GL.FLOAT_VEC2]: [GL.FLOAT, 2, 'vec2', 'vec2<f32>', 'float32x2'],
-    [GL.FLOAT_VEC3]: [GL.FLOAT, 3, 'vec3', 'vec3<f32>', 'float32x3'],
-    [GL.FLOAT_VEC4]: [GL.FLOAT, 4, 'vec4', 'vec4<f32>', 'float32x4'],
-    [GL.INT]: [GL.INT, 1, 'int', 'i32', 'sint32'],
-    [GL.INT_VEC2]: [GL.INT, 2, 'ivec2', 'vec2<i32>', 'sint32x2'],
-    [GL.INT_VEC3]: [GL.INT, 3, 'ivec3', 'vec3<i32>', 'sint32x3'],
-    [GL.INT_VEC4]: [GL.INT, 4, 'ivec4', 'vec4<i32>', 'sint32x4'],
-    [GL.UNSIGNED_INT]: [GL.UNSIGNED_INT, 1, 'uint', 'u32', 'uint32'],
-    [GL.UNSIGNED_INT_VEC2]: [GL.UNSIGNED_INT, 2, 'uvec2', 'vec2<u32>', 'uint32x2'],
-    [GL.UNSIGNED_INT_VEC3]: [GL.UNSIGNED_INT, 3, 'uvec3', 'vec3<u32>', 'uint32x3'],
-    [GL.UNSIGNED_INT_VEC4]: [GL.UNSIGNED_INT, 4, 'uvec4', 'vec4<u32>', 'uint32x4'],
-    [GL.BOOL]: [GL.FLOAT, 1, 'bool', 'f32', 'float32'],
-    [GL.BOOL_VEC2]: [GL.FLOAT, 2, 'bvec2', 'vec2<f32>', 'float32x2'],
-    [GL.BOOL_VEC3]: [GL.FLOAT, 3, 'bvec3', 'vec3<f32>', 'float32x3'],
-    [GL.BOOL_VEC4]: [GL.FLOAT, 4, 'bvec4', 'vec4<f32>', 'float32x4'],
+    [5126]: [5126, 1, 'float', 'f32', 'float32'],
+    [35664]: [5126, 2, 'vec2', 'vec2<f32>', 'float32x2'],
+    [35665]: [5126, 3, 'vec3', 'vec3<f32>', 'float32x3'],
+    [35666]: [5126, 4, 'vec4', 'vec4<f32>', 'float32x4'],
+    [5124]: [5124, 1, 'int', 'i32', 'sint32'],
+    [35667]: [5124, 2, 'ivec2', 'vec2<i32>', 'sint32x2'],
+    [35668]: [5124, 3, 'ivec3', 'vec3<i32>', 'sint32x3'],
+    [35669]: [5124, 4, 'ivec4', 'vec4<i32>', 'sint32x4'],
+    [5125]: [5125, 1, 'uint', 'u32', 'uint32'],
+    [36294]: [5125, 2, 'uvec2', 'vec2<u32>', 'uint32x2'],
+    [36295]: [5125, 3, 'uvec3', 'vec3<u32>', 'uint32x3'],
+    [36296]: [5125, 4, 'uvec4', 'vec4<u32>', 'uint32x4'],
+    [35670]: [5126, 1, 'bool', 'f32', 'float32'],
+    [35671]: [5126, 2, 'bvec2', 'vec2<f32>', 'float32x2'],
+    [35672]: [5126, 3, 'bvec3', 'vec3<f32>', 'float32x3'],
+    [35673]: [5126, 4, 'bvec4', 'vec4<f32>', 'float32x4'],
     // TODO - are sizes/components below correct?
-    [GL.FLOAT_MAT2]: [GL.FLOAT, 8, 'mat2', 'mat2x2<f32>'], // 4
-    [GL.FLOAT_MAT2x3]: [GL.FLOAT, 8, 'mat2x3', 'mat2x3<f32>'], // 6
-    [GL.FLOAT_MAT2x4]: [GL.FLOAT, 8, 'mat2x4', 'mat2x4<f32>'], // 8
-    [GL.FLOAT_MAT3x2]: [GL.FLOAT, 12, 'mat3x2', 'mat3x2<f32>'], // 6
-    [GL.FLOAT_MAT3]: [GL.FLOAT, 12, 'mat3', 'mat3x3<f32>'], // 9
-    [GL.FLOAT_MAT3x4]: [GL.FLOAT, 12, 'mat3x4', 'mat3x4<f32>'], // 12
-    [GL.FLOAT_MAT4x2]: [GL.FLOAT, 16, 'mat4x2', 'mat4x2<f32>'], // 8
-    [GL.FLOAT_MAT4x3]: [GL.FLOAT, 16, 'mat4x3', 'mat4x3<f32>'], // 12
-    [GL.FLOAT_MAT4]: [GL.FLOAT, 16, 'mat4', 'mat4x4<f32>'] // 16
+    [35674]: [5126, 8, 'mat2', 'mat2x2<f32>'], // 4
+    [35685]: [5126, 8, 'mat2x3', 'mat2x3<f32>'], // 6
+    [35686]: [5126, 8, 'mat2x4', 'mat2x4<f32>'], // 8
+    [35687]: [5126, 12, 'mat3x2', 'mat3x2<f32>'], // 6
+    [35675]: [5126, 12, 'mat3', 'mat3x3<f32>'], // 9
+    [35688]: [5126, 12, 'mat3x4', 'mat3x4<f32>'], // 12
+    [35689]: [5126, 16, 'mat4x2', 'mat4x2<f32>'], // 8
+    [35690]: [5126, 16, 'mat4x3', 'mat4x3<f32>'], // 12
+    [35676]: [5126, 16, 'mat4', 'mat4x4<f32>'] // 16
 };
 /** Decomposes a composite type (GL.VEC3) into a basic type (GL.FLOAT) and components (3) */
 export function decodeGLUniformType(glUniformType) {
@@ -82,11 +83,11 @@ export function decomposeCompositeGLDataType(compositeGLDataType) {
 }
 export function getCompositeGLDataType(type, components) {
     switch (type) {
-        case GL.BYTE:
-        case GL.UNSIGNED_BYTE:
-        case GL.SHORT:
-        case GL.UNSIGNED_SHORT:
-            type = GL.FLOAT;
+        case 5120:
+        case 5121:
+        case 5122:
+        case 5123:
+            type = 5126;
             break;
         default:
     }

package/dist/adapter/helpers/get-shader-layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-shader-layout.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-shader-layout.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,YAAY,EAKb,MAAM,eAAe,CAAC;AAMvB;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE,YAAY,GAAG,YAAY,CA2D/F"}
+{"version":3,"file":"get-shader-layout.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-shader-layout.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,YAAY,EAKb,MAAM,eAAe,CAAC;AAMvB;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,sBAAsB,EAAE,OAAO,EAAE,YAAY,GAAG,YAAY,CA2D/F"}

package/dist/adapter/helpers/get-shader-layout.js

@@ -1,8 +1,9 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { GL } from '@luma.gl/constants';
-import { Accessor } from '../../classic/accessor'; // TODO - should NOT depend on classic API
-import { decodeGLUniformType, decodeGLAttributeType, isSamplerUniform } from './decode-webgl-types';
+import { Accessor } from "../../classic/accessor.js"; // TODO - should NOT depend on classic API
+import { decodeGLUniformType, decodeGLAttributeType, isSamplerUniform } from "./decode-webgl-types.js";
 /**
  * Extract metadata describing binding information for a program's shaders
  * Note: `linkProgram()` needs to have been called
@@ -69,7 +70,7 @@ export function getShaderLayout(gl, program) {
  */
 function readAttributeDeclarations(gl, program) {
     const attributes = [];
-    const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+    const count = gl.getProgramParameter(program, 35721);
     for (let index = 0; index < count; index++) {
         const activeInfo = gl.getActiveAttrib(program, index);
         if (!activeInfo) {
@@ -80,7 +81,7 @@ function readAttributeDeclarations(gl, program) {
         // Add only user provided attributes, for built-in attributes like `gl_InstanceID` location will be < 0
         if (location >= 0) {
             const { attributeType } = decodeGLAttributeType(compositeType);
-            // Whether an attribute is instanced is essentially fixed by the structure of the shader code, 
+            // Whether an attribute is instanced is essentially fixed by the structure of the shader code,
             // so it is arguably a static property of the shader.
             // There is no hint in the shader declarations
             // Heuristic: Any attribute name containing the word "instance" will be assumed to be instanced
@@ -89,7 +90,7 @@ function readAttributeDeclarations(gl, program) {
                 name,
                 location,
                 stepMode,
-                type: attributeType,
+                type: attributeType
                 // size - for arrays, size is the number of elements in the array
             });
         }
@@ -105,7 +106,7 @@ function readAttributeDeclarations(gl, program) {
  */
 function readVaryings(gl, program) {
     const varyings = [];
-    const count = gl.getProgramParameter(program, GL.TRANSFORM_FEEDBACK_VARYINGS);
+    const count = gl.getProgramParameter(program, 35971);
     for (let location = 0; location < count; location++) {
         const activeInfo = gl.getTransformFeedbackVarying(program, location);
         if (!activeInfo) {
@@ -127,7 +128,7 @@ function readVaryings(gl, program) {
  */
 function readUniformBindings(gl, program) {
     const uniforms = [];
-    const uniformCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORMS);
+    const uniformCount = gl.getProgramParameter(program, 35718);
     for (let i = 0; i < uniformCount; i++) {
         const activeInfo = gl.getActiveUniform(program, i);
         if (!activeInfo) {
@@ -168,27 +169,27 @@ function readUniformBindings(gl, program) {
 function readUniformBlocks(gl, program) {
     const getBlockParameter = (blockIndex, pname) => gl.getActiveUniformBlockParameter(program, blockIndex, pname);
     const uniformBlocks = [];
-    const blockCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
+    const blockCount = gl.getProgramParameter(program, 35382);
     for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
         const blockInfo = {
             name: gl.getActiveUniformBlockName(program, blockIndex) || '',
-            location: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_BINDING),
-            byteLength: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_DATA_SIZE),
-            vertex: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
-            fragment: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
-            uniformCount: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
+            location: getBlockParameter(blockIndex, 35391),
+            byteLength: getBlockParameter(blockIndex, 35392),
+            vertex: getBlockParameter(blockIndex, 35396),
+            fragment: getBlockParameter(blockIndex, 35398),
+            uniformCount: getBlockParameter(blockIndex, 35394),
             uniforms: []
         };
-        const uniformIndices = getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
-        const uniformType = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE); // Array of GLenum indicating the types of the uniforms.
-        const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE); // Array of GLuint indicating the sizes of the uniforms.
+        const uniformIndices = getBlockParameter(blockIndex, 35395) || [];
+        const uniformType = gl.getActiveUniforms(program, uniformIndices, 35383); // Array of GLenum indicating the types of the uniforms.
+        const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, 35384); // Array of GLuint indicating the sizes of the uniforms.
         // const uniformBlockIndex = gl.getActiveUniforms(
         //   program,
         //   uniformIndices,
         //   GL.UNIFORM_BLOCK_INDEX
         // ); // Array of GLint indicating the block indices of the uniforms.
-        const uniformOffset = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET); // Array of GLint indicating the uniform buffer offsets.
-        const uniformStride = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE); // Array of GLint indicating the strides between the elements.
+        const uniformOffset = gl.getActiveUniforms(program, uniformIndices, 35387); // Array of GLint indicating the uniform buffer offsets.
+        const uniformStride = gl.getActiveUniforms(program, uniformIndices, 35388); // Array of GLint indicating the strides between the elements.
         // const uniformMatrixStride = gl.getActiveUniforms(
         //   program,
         //   uniformIndices,
@@ -237,21 +238,21 @@ function readUniformBlocks(gl, program) {
   }
 */
 const SAMPLER_UNIFORMS_GL_TO_GPU = {
-    [GL.SAMPLER_2D]: ['2d', 'float'],
-    [GL.SAMPLER_CUBE]: ['cube', 'float'],
-    [GL.SAMPLER_3D]: ['3d', 'float'],
-    [GL.SAMPLER_2D_SHADOW]: ['3d', 'depth'],
-    [GL.SAMPLER_2D_ARRAY]: ['2d-array', 'float'],
-    [GL.SAMPLER_2D_ARRAY_SHADOW]: ['2d-array', 'depth'],
-    [GL.SAMPLER_CUBE_SHADOW]: ['cube', 'float'],
-    [GL.INT_SAMPLER_2D]: ['2d', 'sint'],
-    [GL.INT_SAMPLER_3D]: ['3d', 'sint'],
-    [GL.INT_SAMPLER_CUBE]: ['cube', 'sint'],
-    [GL.INT_SAMPLER_2D_ARRAY]: ['2d-array', 'uint'],
-    [GL.UNSIGNED_INT_SAMPLER_2D]: ['2d', 'uint'],
-    [GL.UNSIGNED_INT_SAMPLER_3D]: ['3d', 'uint'],
-    [GL.UNSIGNED_INT_SAMPLER_CUBE]: ['cube', 'uint'],
-    [GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ['2d-array', 'uint']
+    [35678]: ['2d', 'float'],
+    [35680]: ['cube', 'float'],
+    [35679]: ['3d', 'float'],
+    [35682]: ['3d', 'depth'],
+    [36289]: ['2d-array', 'float'],
+    [36292]: ['2d-array', 'depth'],
+    [36293]: ['cube', 'float'],
+    [36298]: ['2d', 'sint'],
+    [36299]: ['3d', 'sint'],
+    [36300]: ['cube', 'sint'],
+    [36303]: ['2d-array', 'uint'],
+    [36306]: ['2d', 'uint'],
+    [36307]: ['3d', 'uint'],
+    [36308]: ['cube', 'uint'],
+    [36311]: ['2d-array', 'uint']
 };
 function getSamplerInfo(type) {
     const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];

package/dist/adapter/helpers/parse-shader-compiler-log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-shader-compiler-log.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/parse-shader-compiler-log.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,eAAe,CAAC;AAEnD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAI,SAAS,eAAe,EAAE,CA8ClF"}
+{"version":3,"file":"parse-shader-compiler-log.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/parse-shader-compiler-log.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,eAAe,CAAC;AAEnD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,eAAe,EAAE,CA8CjF"}

package/dist/adapter/helpers/parse-shader-compiler-log.js

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 /**
  * Parse a WebGL-format GLSL compilation log into an array of WebGPU style message records.
@@ -23,7 +24,7 @@ export function parseShaderCompilerLog(errLog) {
                 lineNum: 0,
                 linePos: 0
             });
-            continue; // eslint-disable-line no-continue  
+            continue; // eslint-disable-line no-continue
         }
         const [messageType, linePosition, lineNumber, ...rest] = segments;
         let lineNum = parseInt(lineNumber, 10);

package/dist/adapter/helpers/set-uniform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-uniform.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/set-uniform.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,EAAK,eAAe,EAAE,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAEtE,8DAA8D;AAE9D,wBAAgB,UAAU,CACxB,EAAE,EAAE,sBAAsB,EAC1B,QAAQ,EAAE,oBAAoB,EAC9B,IAAI,EAAE,eAAe,GAAG,aAAa,EACrC,KAAK,EAAE,YAAY,GAClB,IAAI,CAwEN"}
+{"version":3,"file":"set-uniform.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/set-uniform.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,EAAK,eAAe,EAAE,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAEtE,8DAA8D;AAE9D,wBAAgB,UAAU,CACxB,EAAE,EAAE,sBAAsB,EAC1B,QAAQ,EAAE,oBAAoB,EAC9B,IAAI,EAAE,eAAe,GAAG,aAAa,EACrC,KAAK,EAAE,YAAY,GAClB,IAAI,CAwEN"}

package/dist/adapter/helpers/set-uniform.js

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { GL } from '@luma.gl/constants';
 /** Set a raw uniform (without type conversion and caching) */
@@ -16,54 +17,54 @@ export function setUniform(gl, location, type, value) {
     const arrayValue = typeof uniformValue === 'number' ? [uniformValue] : uniformValue;
     // prettier-ignore
     switch (type) {
-        case GL.SAMPLER_2D:
-        case GL.SAMPLER_CUBE:
-        case GL.SAMPLER_3D:
-        case GL.SAMPLER_2D_SHADOW:
-        case GL.SAMPLER_2D_ARRAY:
-        case GL.SAMPLER_2D_ARRAY_SHADOW:
-        case GL.SAMPLER_CUBE_SHADOW:
-        case GL.INT_SAMPLER_2D:
-        case GL.INT_SAMPLER_3D:
-        case GL.INT_SAMPLER_CUBE:
-        case GL.INT_SAMPLER_2D_ARRAY:
-        case GL.UNSIGNED_INT_SAMPLER_2D:
-        case GL.UNSIGNED_INT_SAMPLER_3D:
-        case GL.UNSIGNED_INT_SAMPLER_CUBE:
-        case GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
+        case 35678:
+        case 35680:
+        case 35679:
+        case 35682:
+        case 36289:
+        case 36292:
+        case 36293:
+        case 36298:
+        case 36299:
+        case 36300:
+        case 36303:
+        case 36306:
+        case 36307:
+        case 36308:
+        case 36311:
             if (typeof value !== 'number') {
                 throw new Error('samplers must be set to integers');
             }
             return gl.uniform1i(location, value);
-        case GL.FLOAT: return gl.uniform1fv(location, arrayValue);
-        case GL.FLOAT_VEC2: return gl.uniform2fv(location, arrayValue);
-        case GL.FLOAT_VEC3: return gl.uniform3fv(location, arrayValue);
-        case GL.FLOAT_VEC4: return gl.uniform4fv(location, arrayValue);
-        case GL.INT: return gl.uniform1iv(location, arrayValue);
-        case GL.INT_VEC2: return gl.uniform2iv(location, arrayValue);
-        case GL.INT_VEC3: return gl.uniform3iv(location, arrayValue);
-        case GL.INT_VEC4: return gl.uniform4iv(location, arrayValue);
-        case GL.BOOL: return gl.uniform1iv(location, arrayValue);
-        case GL.BOOL_VEC2: return gl.uniform2iv(location, arrayValue);
-        case GL.BOOL_VEC3: return gl.uniform3iv(location, arrayValue);
-        case GL.BOOL_VEC4: return gl.uniform4iv(location, arrayValue);
+        case 5126: return gl.uniform1fv(location, arrayValue);
+        case 35664: return gl.uniform2fv(location, arrayValue);
+        case 35665: return gl.uniform3fv(location, arrayValue);
+        case 35666: return gl.uniform4fv(location, arrayValue);
+        case 5124: return gl.uniform1iv(location, arrayValue);
+        case 35667: return gl.uniform2iv(location, arrayValue);
+        case 35668: return gl.uniform3iv(location, arrayValue);
+        case 35669: return gl.uniform4iv(location, arrayValue);
+        case 35670: return gl.uniform1iv(location, arrayValue);
+        case 35671: return gl.uniform2iv(location, arrayValue);
+        case 35672: return gl.uniform3iv(location, arrayValue);
+        case 35673: return gl.uniform4iv(location, arrayValue);
         // WEBGL2 - unsigned integers
-        case GL.UNSIGNED_INT: return gl2.uniform1uiv(location, arrayValue, 1);
-        case GL.UNSIGNED_INT_VEC2: return gl2.uniform2uiv(location, arrayValue, 2);
-        case GL.UNSIGNED_INT_VEC3: return gl2.uniform3uiv(location, arrayValue, 3);
-        case GL.UNSIGNED_INT_VEC4: return gl2.uniform4uiv(location, arrayValue, 4);
+        case 5125: return gl2.uniform1uiv(location, arrayValue, 1);
+        case 36294: return gl2.uniform2uiv(location, arrayValue, 2);
+        case 36295: return gl2.uniform3uiv(location, arrayValue, 3);
+        case 36296: return gl2.uniform4uiv(location, arrayValue, 4);
         // WebGL2 - quadratic matrices
         // false: don't transpose the matrix
-        case GL.FLOAT_MAT2: return gl.uniformMatrix2fv(location, false, arrayValue);
-        case GL.FLOAT_MAT3: return gl.uniformMatrix3fv(location, false, arrayValue);
-        case GL.FLOAT_MAT4: return gl.uniformMatrix4fv(location, false, arrayValue);
+        case 35674: return gl.uniformMatrix2fv(location, false, arrayValue);
+        case 35675: return gl.uniformMatrix3fv(location, false, arrayValue);
+        case 35676: return gl.uniformMatrix4fv(location, false, arrayValue);
         // WebGL2 - rectangular matrices
-        case GL.FLOAT_MAT2x3: return gl2.uniformMatrix2x3fv(location, false, arrayValue);
-        case GL.FLOAT_MAT2x4: return gl2.uniformMatrix2x4fv(location, false, arrayValue);
-        case GL.FLOAT_MAT3x2: return gl2.uniformMatrix3x2fv(location, false, arrayValue);
-        case GL.FLOAT_MAT3x4: return gl2.uniformMatrix3x4fv(location, false, arrayValue);
-        case GL.FLOAT_MAT4x2: return gl2.uniformMatrix4x2fv(location, false, arrayValue);
-        case GL.FLOAT_MAT4x3: return gl2.uniformMatrix4x3fv(location, false, arrayValue);
+        case 35685: return gl2.uniformMatrix2x3fv(location, false, arrayValue);
+        case 35686: return gl2.uniformMatrix2x4fv(location, false, arrayValue);
+        case 35687: return gl2.uniformMatrix3x2fv(location, false, arrayValue);
+        case 35688: return gl2.uniformMatrix3x4fv(location, false, arrayValue);
+        case 35689: return gl2.uniformMatrix4x2fv(location, false, arrayValue);
+        case 35690: return gl2.uniformMatrix4x3fv(location, false, arrayValue);
     }
     throw new Error('Illegal uniform');
 }

package/dist/adapter/helpers/webgl-topology-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgl-topology-utils.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/webgl-topology-utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,EAAE,EAAE,mBAAmB,EAAE,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAC,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAGhD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,WAAW,CAmB/E;AAGD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IAAC,QAAQ,EAAE,mBAAmB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,GAAG,MAAM,CAkBvG;AAGD,wBAAgB,cAAc,CAAC,OAAO,EAAE;IAAC,QAAQ,EAAE,mBAAmB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,GAAG,MAAM,CAapG;AAED,sCAAsC;AACtC,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,iBAAiB,GAEzB,EAAE,CAAC,MAAM,GACT,EAAE,CAAC,KAAK,GACR,EAAE,CAAC,UAAU,GACb,EAAE,CAAC,SAAS,GACZ,EAAE,CAAC,SAAS,GACZ,EAAE,CAAC,cAAc,GACjB,EAAE,CAAC,YAAY,CAYlB;AAED,oDAAoD;AACpD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,iBAAiB,GAAG,EAAE,CAAC,MAAM,GAAG,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAY/F"}
+{"version":3,"file":"webgl-topology-utils.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/webgl-topology-utils.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,EAAE,EAAE,mBAAmB,EAAE,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAC,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAGhD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,WAAW,CAmB/E;AAGD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,MAAM,CAkBT;AAGD,wBAAgB,cAAc,CAAC,OAAO,EAAE;IACtC,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,MAAM,CAaT;AAED,sCAAsC;AACtC,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,iBAAiB,GAEzB,EAAE,CAAC,MAAM,GACT,EAAE,CAAC,KAAK,GACR,EAAE,CAAC,UAAU,GACb,EAAE,CAAC,SAAS,GACZ,EAAE,CAAC,SAAS,GACZ,EAAE,CAAC,cAAc,GACjB,EAAE,CAAC,YAAY,CAYlB;AAED,oDAAoD;AACpD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,iBAAiB,GAAG,EAAE,CAAC,MAAM,GAAG,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAY/F"}

package/dist/adapter/helpers/webgl-topology-utils.js

@@ -1,23 +1,24 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { GL } from '@luma.gl/constants';
 // Counts the number of complete primitives given a number of vertices and a drawMode
 export function getPrimitiveDrawMode(drawMode) {
     switch (drawMode) {
-        case GL.POINTS:
-            return GL.POINTS;
-        case GL.LINES:
-            return GL.LINES;
-        case GL.LINE_STRIP:
-            return GL.LINES;
-        case GL.LINE_LOOP:
-            return GL.LINES;
-        case GL.TRIANGLES:
-            return GL.TRIANGLES;
-        case GL.TRIANGLE_STRIP:
-            return GL.TRIANGLES;
-        case GL.TRIANGLE_FAN:
-            return GL.TRIANGLES;
+        case 0:
+            return 0;
+        case 1:
+            return 1;
+        case 3:
+            return 1;
+        case 2:
+            return 1;
+        case 4:
+            return 4;
+        case 5:
+            return 4;
+        case 6:
+            return 4;
         default:
             throw new Error('drawMode');
     }
@@ -26,17 +27,17 @@ export function getPrimitiveDrawMode(drawMode) {
 export function getPrimitiveCount(options) {
     const { drawMode, vertexCount } = options;
     switch (drawMode) {
-        case GL.POINTS:
-        case GL.LINE_LOOP:
+        case 0:
+        case 2:
             return vertexCount;
-        case GL.LINES:
+        case 1:
             return vertexCount / 2;
-        case GL.LINE_STRIP:
+        case 3:
             return vertexCount - 1;
-        case GL.TRIANGLES:
+        case 4:
             return vertexCount / 3;
-        case GL.TRIANGLE_STRIP:
-        case GL.TRIANGLE_FAN:
+        case 5:
+        case 6:
             return vertexCount - 2;
         default:
             throw new Error('drawMode');
@@ -47,11 +48,11 @@ export function getVertexCount(options) {
     const { drawMode, vertexCount } = options;
     const primitiveCount = getPrimitiveCount({ drawMode, vertexCount });
     switch (getPrimitiveDrawMode(drawMode)) {
-        case GL.POINTS:
+        case 0:
             return primitiveCount;
-        case GL.LINES:
+        case 1:
             return primitiveCount * 2;
-        case GL.TRIANGLES:
+        case 4:
             return primitiveCount * 3;
         default:
             throw new Error('drawMode');
@@ -61,13 +62,13 @@ export function getVertexCount(options) {
 export function getGLDrawMode(topology) {
     // prettier-ignore
     switch (topology) {
-        case 'point-list': return GL.POINTS;
-        case 'line-list': return GL.LINES;
-        case 'line-strip': return GL.LINE_STRIP;
-        case 'line-loop-webgl': return GL.LINE_LOOP;
-        case 'triangle-list': return GL.TRIANGLES;
-        case 'triangle-strip': return GL.TRIANGLE_STRIP;
-        case 'triangle-fan-webgl': return GL.TRIANGLE_FAN;
+        case 'point-list': return 0;
+        case 'line-list': return 1;
+        case 'line-strip': return 3;
+        case 'line-loop-webgl': return 2;
+        case 'triangle-list': return 4;
+        case 'triangle-strip': return 5;
+        case 'triangle-fan-webgl': return 6;
         default: throw new Error(topology);
     }
 }
@@ -75,13 +76,13 @@ export function getGLDrawMode(topology) {
 export function getGLPrimitive(topology) {
     // prettier-ignore
     switch (topology) {
-        case 'point-list': return GL.POINTS;
-        case 'line-list': return GL.LINES;
-        case 'line-strip': return GL.LINES;
-        case 'line-loop-webgl': return GL.LINES;
-        case 'triangle-list': return GL.TRIANGLES;
-        case 'triangle-strip': return GL.TRIANGLES;
-        case 'triangle-fan-webgl': return GL.TRIANGLES;
+        case 'point-list': return 0;
+        case 'line-list': return 1;
+        case 'line-strip': return 1;
+        case 'line-loop-webgl': return 1;
+        case 'triangle-list': return 4;
+        case 'triangle-strip': return 4;
+        case 'triangle-fan-webgl': return 4;
         default: throw new Error(topology);
     }
 }

package/dist/adapter/objects/constants-to-keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants-to-keys.d.ts","sourceRoot":"","sources":["../../../src/adapter/objects/constants-to-keys.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AAGtC,wBAAgB,WAAW,CAAC,EAAE,EAAE,sBAAsB,EAAE,IAAI,EAAE,MAAM,GAAG,EAAE,GAAG,EAAE,CAkB7E"}
+{"version":3,"file":"constants-to-keys.d.ts","sourceRoot":"","sources":["../../../src/adapter/objects/constants-to-keys.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AAGtC,wBAAgB,WAAW,CAAC,EAAE,EAAE,sBAAsB,EAAE,IAAI,EAAE,MAAM,GAAG,EAAE,GAAG,EAAE,CAkB7E"}

package/dist/adapter/objects/constants-to-keys.js

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { assert } from '@luma.gl/core';
 // Resolve a WebGL enumeration name (returns itself if already a number)

package/dist/adapter/objects/webgl-renderbuffer.d.ts

@@ -1,7 +1,7 @@
 import { ResourceProps, TextureFormat } from '@luma.gl/core';
 import { GL } from '@luma.gl/constants';
-import { WebGLDevice } from '../webgl-device';
-import { WebGLResource } from './webgl-resource';
+import { WebGLDevice } from "../webgl-device.js";
+import { WebGLResource } from "./webgl-resource.js";
 export type RenderbufferProps = ResourceProps & {
     format: TextureFormat;
     width?: number;

package/dist/adapter/objects/webgl-renderbuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgl-renderbuffer.d.ts","sourceRoot":"","sources":["../../../src/adapter/objects/webgl-renderbuffer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAS,aAAa,EAAE,aAAa,EAAC,MAAM,eAAe,CAAC;AACnE,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAI/C,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG;IAC9C,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,SAAQ,aAAa,CAAC,iBAAiB,CAAC;IACrE,gBAAyB,YAAY,EAAE,QAAQ,CAAC,iBAAiB,CAAC,CAQhE;IAEF,IAAa,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAA2B;IAEtE,IAAI,KAAK,IAAI,MAAM,CAA6B;IAChD,IAAI,MAAM,IAAI,MAAM,CAA8B;IAClD,IAAI,MAAM,IAAI,aAAa,CAA8B;IACzD,IAAI,OAAO,IAAI,MAAM,CAA+B;IACpD,IAAI,UAAU,SAAc;IAE5B,4BAA4B;IAC5B,QAAQ,EAAE,EAAE,CAAC;IAEb,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO;gBAIxE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,iBAAiB;IAUzD,MAAM,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI;IAUnD,iEAAiE;IACjE,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,IAAI;IAuBtD,aAAa;IAIb,aAAa,IAAI,IAAI;IAKrB,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;CAGtD"}
+{"version":3,"file":"webgl-renderbuffer.d.ts","sourceRoot":"","sources":["../../../src/adapter/objects/webgl-renderbuffer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAS,aAAa,EAAE,aAAa,EAAC,MAAM,eAAe,CAAC;AACnE,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,EAAC,WAAW,EAAC,2BAAwB;AAC5C,OAAO,EAAC,aAAa,EAAC,4BAAyB;AAO/C,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG;IAC9C,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,SAAQ,aAAa,CAAC,iBAAiB,CAAC;IACrE,gBAAyB,YAAY,EAAE,QAAQ,CAAC,iBAAiB,CAAC,CAQhE;IAEF,IAAa,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAE1C;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IACD,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD,IAAI,MAAM,IAAI,aAAa,CAE1B;IACD,IAAI,OAAO,IAAI,MAAM,CAEpB;IACD,IAAI,UAAU,SAEb;IAED,4BAA4B;IAC5B,QAAQ,EAAE,EAAE,CAAC;IAEb,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO;gBAIxE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,iBAAiB;IAUzD,MAAM,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI;IAUnD,iEAAiE;IACjE,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,IAAI;IA6BtD,aAAa;IAIb,aAAa,IAAI,IAAI;IAKrB,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;CAGtD"}

package/dist/adapter/objects/webgl-renderbuffer.js

@@ -1,10 +1,11 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { assert } from '@luma.gl/core';
 import { GL } from '@luma.gl/constants';
-import { WebGLResource } from './webgl-resource';
-import { isRenderbufferFormatSupported } from '../converters/texture-formats';
-import { convertTextureFormatToGL, getTextureFormatBytesPerPixel } from '../converters/texture-formats';
+import { WebGLResource } from "./webgl-resource.js";
+import { isRenderbufferFormatSupported } from "../converters/texture-formats.js";
+import { convertTextureFormatToGL, getTextureFormatBytesPerPixel } from "../converters/texture-formats.js";
 /**
  * Renderbuffers are GPU objects that contain images.
  * In contrast to Textures they are optimized for use as render targets, with Framebuffers.
@@ -25,16 +26,28 @@ export class WEBGLRenderbuffer extends WebGLResource {
         height: 1,
         samples: 0
     };
-    get [Symbol.toStringTag]() { return 'Renderbuffer'; }
-    get width() { return this.props.width; }
-    get height() { return this.props.height; }
-    get format() { return this.props.format; }
-    get samples() { return this.props.samples; }
-    get attachment() { return; }
+    get [Symbol.toStringTag]() {
+        return 'Renderbuffer';
+    }
+    get width() {
+        return this.props.width;
+    }
+    get height() {
+        return this.props.height;
+    }
+    get format() {
+        return this.props.format;
+    }
+    get samples() {
+        return this.props.samples;
+    }
+    get attachment() {
+        return;
+    }
     /** WebGL format constant */
     glFormat;
     static isTextureFormatSupported(device, format) {
-        return isRenderbufferFormatSupported(device.gl, format);
+        return isRenderbufferFormatSupported(device.gl, format, device._extensions);
     }
     constructor(device, props) {
         // TODO - remove temporary sanity check
@@ -58,15 +71,15 @@ export class WEBGLRenderbuffer extends WebGLResource {
         const { format, width, height, samples } = props;
         assert(format, 'Needs format');
         this.trackDeallocatedMemory();
-        this.gl.bindRenderbuffer(GL.RENDERBUFFER, this.handle);
+        this.gl.bindRenderbuffer(36161, this.handle);
         if (samples !== 0) {
-            this.gl.renderbufferStorageMultisample(GL.RENDERBUFFER, samples, this.glFormat, width, height);
+            this.gl.renderbufferStorageMultisample(36161, samples, this.glFormat, width, height);
         }
         else {
-            this.gl.renderbufferStorage(GL.RENDERBUFFER, this.glFormat, width, height);
+            this.gl.renderbufferStorage(36161, this.glFormat, width, height);
         }
-        this.gl.bindRenderbuffer(GL.RENDERBUFFER, null);
-        this.trackAllocatedMemory(width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat));
+        this.gl.bindRenderbuffer(36161, null);
+        this.trackAllocatedMemory(width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.format));
     }
     // RESOURCE IMPLEMENTATION
     _createHandle() {
@@ -77,6 +90,6 @@ export class WEBGLRenderbuffer extends WebGLResource {
         this.trackDeallocatedMemory();
     }
     _bindHandle(handle) {
-        this.gl.bindRenderbuffer(GL.RENDERBUFFER, handle);
+        this.gl.bindRenderbuffer(36161, handle);
     }
 }