@luma.gl/webgl 9.0.0-beta.6 → 9.0.0-beta.8

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

@@ -6,25 +6,25 @@ import { GL } from '@luma.gl/constants';
 // prettier-ignore
 export class WebGLDeviceLimits extends DeviceLimits {
     get maxTextureDimension1D() { return 0; } // WebGL does not support 1D textures
-    get maxTextureDimension2D() { return this.getParameter(GL.MAX_TEXTURE_SIZE); }
-    get maxTextureDimension3D() { return this.getParameter(GL.MAX_3D_TEXTURE_SIZE); }
-    get maxTextureArrayLayers() { return this.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS); }
+    get maxTextureDimension2D() { return this.getParameter(3379); }
+    get maxTextureDimension3D() { return this.getParameter(32883); }
+    get maxTextureArrayLayers() { return this.getParameter(35071); }
     get maxBindGroups() { return 0; }
     get maxDynamicUniformBuffersPerPipelineLayout() { return 0; } // TBD
     get maxDynamicStorageBuffersPerPipelineLayout() { return 0; } // TBD
-    get maxSampledTexturesPerShaderStage() { return this.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS); } // ) TBD
-    get maxSamplersPerShaderStage() { return this.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS); }
+    get maxSampledTexturesPerShaderStage() { return this.getParameter(35660); } // ) TBD
+    get maxSamplersPerShaderStage() { return this.getParameter(35661); }
     get maxStorageBuffersPerShaderStage() { return 0; } // TBD
     get maxStorageTexturesPerShaderStage() { return 0; } // TBD
-    get maxUniformBuffersPerShaderStage() { return this.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS); }
-    get maxUniformBufferBindingSize() { return this.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE); }
+    get maxUniformBuffersPerShaderStage() { return this.getParameter(35375); }
+    get maxUniformBufferBindingSize() { return this.getParameter(35376); }
     get maxStorageBufferBindingSize() { return 0; }
-    get minUniformBufferOffsetAlignment() { return this.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT); }
+    get minUniformBufferOffsetAlignment() { return this.getParameter(35380); }
     get minStorageBufferOffsetAlignment() { return 0; }
     get maxVertexBuffers() { return 16; } // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284
-    get maxVertexAttributes() { return this.getParameter(GL.MAX_VERTEX_ATTRIBS); }
+    get maxVertexAttributes() { return this.getParameter(34921); }
     get maxVertexBufferArrayStride() { return 2048; } // TBD, this is just the default value from WebGPU
-    get maxInterStageShaderComponents() { return this.getParameter(GL.MAX_VARYING_COMPONENTS); }
+    get maxInterStageShaderComponents() { return this.getParameter(35659); }
     get maxComputeWorkgroupStorageSize() { return 0; } // WebGL does not support compute shaders
     get maxComputeInvocationsPerWorkgroup() { return 0; } // WebGL does not support compute shaders
     get maxComputeWorkgroupSizeX() { return 0; } // WebGL does not support compute shaders

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

@@ -7,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) {
@@ -83,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.js

@@ -70,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) {
@@ -106,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) {
@@ -128,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) {
@@ -169,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,
@@ -238,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/set-uniform.js

@@ -17,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.js

@@ -5,20 +5,20 @@ 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');
     }
@@ -27,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');
@@ -48,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');
@@ -62,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);
     }
 }
@@ -76,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/webgl-renderbuffer.js

@@ -71,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() {
@@ -90,6 +90,6 @@ export class WEBGLRenderbuffer extends WebGLResource {
         this.trackDeallocatedMemory();
     }
     _bindHandle(handle) {
-        this.gl.bindRenderbuffer(GL.RENDERBUFFER, handle);
+        this.gl.bindRenderbuffer(36161, handle);
     }
 }

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

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { Resource, uid, stubRemovedMethods } from '@luma.gl/core';
-import { WebGLDevice } from "../webgl-device.js";
 const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual methods';
 /**
  * Base class for WebGL object wrappers
@@ -17,7 +16,7 @@ export class WebGLResource extends Resource {
     byteLength = 0;
     constructor(device, props, defaultProps) {
         super(device, props, defaultProps);
-        this.device = WebGLDevice.attach(device);
+        this.device = device;
         const gl = this.device.gl;
         // extends
         const { id } = props || {};

package/dist/adapter/resources/webgl-buffer.js

@@ -13,7 +13,7 @@ export class WEBGLBuffer extends Buffer {
     /** Usage is a hint on how frequently the buffer will be updates */
     glUsage;
     /** Index type is needed when issuing draw calls, so we pre-compute it */
-    glIndexType = GL.UNSIGNED_SHORT;
+    glIndexType = 5123;
     /** Number of bytes allocated on the GPU for this buffer */
     byteLength;
     /** Number of bytes used */
@@ -30,7 +30,7 @@ export class WEBGLBuffer extends Buffer {
         // - In WebGL2, we can use GL.COPY_READ_BUFFER which avoids locking the type here
         this.glTarget = getWebGLTarget(this.props.usage);
         this.glUsage = getWebGLUsage(this.props.usage);
-        this.glIndexType = this.props.indexType === 'uint32' ? GL.UNSIGNED_INT : GL.UNSIGNED_SHORT;
+        this.glIndexType = this.props.indexType === 'uint32' ? 5125 : 5123;
         // Set data: (re)initializes the buffer
         if (props.data) {
             this._initWithData(props.data, props.byteOffset, props.byteLength);
@@ -89,7 +89,7 @@ export class WEBGLBuffer extends Buffer {
         const byteLength = undefined; // data.byteLength;
         // Create the buffer - binding it here for the first time locks the type
         // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type
-        const glTarget = GL.COPY_WRITE_BUFFER;
+        const glTarget = 36663;
         this.gl.bindBuffer(glTarget, this.handle);
         // WebGL2: subData supports additional srcOffset and length parameters
         if (srcOffset !== 0 || byteLength !== undefined) {
@@ -111,9 +111,9 @@ export class WEBGLBuffer extends Buffer {
         const data = new Uint8Array(byteLength);
         const dstOffset = 0;
         // Use GL.COPY_READ_BUFFER to avoid disturbing other targets and locking type
-        this.gl.bindBuffer(GL.COPY_READ_BUFFER, this.handle);
-        this.gl.getBufferSubData(GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
-        this.gl.bindBuffer(GL.COPY_READ_BUFFER, null);
+        this.gl.bindBuffer(36662, this.handle);
+        this.gl.getBufferSubData(36662, byteOffset, data, dstOffset, byteLength);
+        this.gl.bindBuffer(36662, null);
         // Update local `data` if offsets are 0
         this._setDebugData(data, byteOffset, byteLength);
         return data;
@@ -145,28 +145,28 @@ export class WEBGLBuffer extends Buffer {
  */
 function getWebGLTarget(usage) {
     if (usage & Buffer.INDEX) {
-        return GL.ELEMENT_ARRAY_BUFFER;
+        return 34963;
     }
     if (usage & Buffer.VERTEX) {
-        return GL.ARRAY_BUFFER;
+        return 34962;
     }
     if (usage & Buffer.UNIFORM) {
-        return GL.UNIFORM_BUFFER;
+        return 35345;
     }
     // Binding a buffer for the first time locks the type
     // In WebGL2, we can use GL.COPY_WRITE_BUFFER to avoid locking the type
-    return GL.ARRAY_BUFFER;
+    return 34962;
 }
 /** @todo usage is not passed correctly */
 function getWebGLUsage(usage) {
     if (usage & Buffer.INDEX) {
-        return GL.STATIC_DRAW;
+        return 35044;
     }
     if (usage & Buffer.VERTEX) {
-        return GL.STATIC_DRAW;
+        return 35044;
     }
     if (usage & Buffer.UNIFORM) {
-        return GL.DYNAMIC_DRAW;
+        return 35048;
     }
-    return GL.STATIC_DRAW;
+    return 35044;
 }