@luma.gl/webgl 9.0.0-alpha.3 → 9.0.0-alpha.31

package/src/adapter/helpers/get-shader-layout.ts

@@ -1,48 +1,35 @@
-import {
+// luma.gl, MIT license
+
+import type {
   ShaderLayout,
-  BindingLayout,
   UniformBinding,
   UniformBlockBinding,
-  ProgramBindings,
-  AttributeBinding,
-  VaryingBinding,
-  AttributeLayout,
-  AccessorObject
-} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+  AttributeDeclaration,
+  VaryingBinding
+} from '@luma.gl/core';
+
+import {GL} from '@luma.gl/constants';
 import {isWebGL2} from '../../context/context/webgl-checks';
-import Accessor from '../../classic/accessor'; // TODO - should NOT depend on classic API
-import {decodeUniformType, decodeAttributeType} from './uniforms';
-import {getVertexFormat} from '../converters/vertex-formats';
-import {isSamplerUniform} from './uniforms';
+import {Accessor} from '../../classic/accessor'; // TODO - should NOT depend on classic API
+import {decodeGLUniformType, decodeGLAttributeType, isSamplerUniform} from './decode-webgl-types';
+
 /**
  * Extract metadata describing binding information for a program's shaders
  * Note: `linkProgram()` needs to have been called
  * (although linking does not need to have been successful).
  */
 export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram): ShaderLayout {
-  const programBindings = getProgramBindings(gl, program);
-
   const shaderLayout: ShaderLayout = {
     attributes: [],
     bindings: []
   };
 
-  for (const attribute of programBindings.attributes) {
-    const format =
-      // attribute.accessor.format ||
-      getVertexFormat(attribute.accessor.type || GL.FLOAT, attribute.accessor.size);
-    shaderLayout.attributes.push({
-      name: attribute.name,
-      location: attribute.location,
-      format,
-      stepMode: attribute.accessor.divisor === 1 ? 'instance' : 'vertex'
-    });
-  }
+  shaderLayout.attributes = readAttributeDeclarations(gl, program);
 
   // Uniform blocks
-  for (const uniformBlock of programBindings.uniformBlocks) {
-    const uniforms = uniformBlock.uniforms.map((uniform) => ({
+  const uniformBlocks: UniformBlockBinding[] = readUniformBlocks(gl, program);
+  for (const uniformBlock of uniformBlocks) {
+    const uniforms = uniformBlock.uniforms.map(uniform => ({
       name: uniform.name,
       format: uniform.format,
       byteOffset: uniform.byteOffset,
@@ -59,8 +46,9 @@ export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram
     });
   }
 
+  const uniforms: UniformBinding[] = readUniformBindings(gl, program);
   let textureUnit = 0;
-  for (const uniform of programBindings.uniforms) {
+  for (const uniform of uniforms) {
     if (isSamplerUniform(uniform.type)) {
       const {viewDimension, sampleType} = getSamplerInfo(uniform.type);
       shaderLayout.bindings.push({
@@ -77,69 +65,64 @@ export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram
     }
   }
 
-  const uniforms = programBindings.uniforms?.filter((uniform) => uniform.location !== null) || [];
   if (uniforms.length) {
     shaderLayout.uniforms = uniforms;
   }
-  if (programBindings.varyings?.length) {
-    shaderLayout.varyings = programBindings.varyings;
+
+  // Varyings
+  const varyings: VaryingBinding[] = readVaryings(gl, program);
+  // Note - samplers are always in unform bindings, even if uniform blocks are used
+  if (varyings?.length) {
+    shaderLayout.varyings = varyings;
   }
 
   return shaderLayout;
 }
 
-/**
- * Extract metadata describing binding information for a program's shaders
- * Note: `linkProgram()` needs to have been called
- * (although linking does not need to have been successful).
- */
-export function getProgramBindings(
-  gl: WebGLRenderingContext,
-  program: WebGLProgram
-): ProgramBindings {
-  const config: ProgramBindings = {
-    attributes: readAttributeBindings(gl, program),
-    uniforms: readUniformBindings(gl, program),
-    uniformBlocks: readUniformBlocks(gl, program),
-    varyings: readVaryings(gl, program)
-  };
-
-  Object.seal(config);
-  return config;
-  // generateWebGPUStyleBindings(bindings);
-}
+// HELPERS
 
 /**
  * Extract info about all transform feedback varyings
  *
  * linkProgram needs to have been called, although linking does not need to have been successful
  */
-function readAttributeBindings(
+function readAttributeDeclarations(
   gl: WebGLRenderingContext,
   program: WebGLProgram
-): AttributeBinding[] {
-  const attributes: AttributeBinding[] = [];
+): AttributeDeclaration[] {
+  const attributes: AttributeDeclaration[] = [];
 
   const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
 
   for (let index = 0; index < count; index++) {
-    const {name, type: compositeType, size} = gl.getActiveAttrib(program, index);
+    const activeInfo = gl.getActiveAttrib(program, index);
+    if (!activeInfo) {
+      throw new Error('activeInfo');
+    }
+    const {name, type: compositeType /* , size*/} = activeInfo;
     const location = gl.getAttribLocation(program, name);
-    // Add only user provided attributes, for built-in attributes like
-    // `gl_InstanceID` locaiton will be < 0
+    // Add only user provided attributes, for built-in attributes like `gl_InstanceID` location will be < 0
     if (location >= 0) {
-      const {glType, components} = decodeAttributeType(compositeType);
-      const accessor: AccessorObject = {type: glType, size: size * components};
-      // Any attribute name containing the word "instance" will be assumed to be instanced
-      if (/instance/i.test(name)) {
-        accessor.divisor = 1;
-      }
-      const attributeInfo = {location, name, accessor: new Accessor(accessor)}; // Base values
-      attributes.push(attributeInfo);
+      const {attributeType} = decodeGLAttributeType(compositeType);
+
+      // 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
+      const stepMode = /instance/i.test(name) ? 'instance' : 'vertex';
+
+      attributes.push({
+        name,
+        location,
+        stepMode,
+        type: attributeType,
+        // size - for arrays, size is the number of elements in the array
+      });
     }
   }
 
-  attributes.sort((a: AttributeBinding, b: AttributeBinding) => a.location - b.location);
+  // Sort by declaration order
+  attributes.sort((a: AttributeDeclaration, b: AttributeDeclaration) => a.location - b.location);
   return attributes;
 }
 
@@ -158,8 +141,12 @@ function readVaryings(gl: WebGLRenderingContext, program: WebGLProgram): Varying
 
   const count = gl.getProgramParameter(program, GL.TRANSFORM_FEEDBACK_VARYINGS);
   for (let location = 0; location < count; location++) {
-    const {name, type: compositeType, size} = gl2.getTransformFeedbackVarying(program, location);
-    const {glType, components} = decodeUniformType(compositeType);
+    const activeInfo = gl2.getTransformFeedbackVarying(program, location);
+    if (!activeInfo) {
+      throw new Error('activeInfo');
+    }
+    const {name, type: compositeType, size} = activeInfo;
+    const {glType, components} = decodeGLUniformType(compositeType);
     const accessor = new Accessor({type: glType, size: size * components});
     const varying = {location, name, accessor}; // Base values
     varyings.push(varying);
@@ -179,7 +166,11 @@ function readUniformBindings(gl: WebGLRenderingContext, program: WebGLProgram):
 
   const uniformCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORMS);
   for (let i = 0; i < uniformCount; i++) {
-    const {name: rawName, size, type} = gl.getActiveUniform(program, i);
+    const activeInfo = gl.getActiveUniform(program, i);
+    if (!activeInfo) {
+      throw new Error('activeInfo');
+    }
+    const {name: rawName, size, type} = activeInfo;
     const {name, isArray} = parseUniformName(rawName);
     let webglLocation = gl.getUniformLocation(program, name);
     const uniformInfo = {
@@ -214,9 +205,7 @@ function readUniformBindings(gl: WebGLRenderingContext, program: WebGLProgram):
 
 /**
  * Extract info about all "active" uniform blocks
- *
- * ("Active" just means that unused (aka inactive) blocks may have been
- * optimized away during linking)
+ * @note In WebGL, "active" just means that unused (inactive) blocks may have been optimized away during linking)
  */
 function readUniformBlocks(
   gl: WebGLRenderingContext,
@@ -234,8 +223,8 @@ function readUniformBlocks(
 
   const blockCount = gl2.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
-    const blockInfo = {
-      name: gl2.getActiveUniformBlockName(program, blockIndex),
+    const blockInfo: UniformBlockBinding = {
+      name: gl2.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),
@@ -244,33 +233,39 @@ function readUniformBlocks(
       uniforms: [] as any[]
     };
 
-    const uniformIndices = getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES);
+    const uniformIndices =
+      (getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) as number[]) || [];
 
     const uniformType = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE); // Array of GLenum indicating the types of the uniforms.
     const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE); // Array of GLuint indicating the sizes of the uniforms.
-    const uniformBlockIndex = gl2.getActiveUniforms(
-      program,
-      uniformIndices,
-      GL.UNIFORM_BLOCK_INDEX
-    ); // Array of GLint indicating the block indices of the uniforms.
+    // const uniformBlockIndex = gl2.getActiveUniforms(
+    //   program,
+    //   uniformIndices,
+    //   GL.UNIFORM_BLOCK_INDEX
+    // ); // Array of GLint indicating the block indices of the uniforms.
     const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET); // Array of GLint indicating the uniform buffer offsets.
     const uniformStride = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE); // Array of GLint indicating the strides between the elements.
-    const uniformMatrixStride = gl2.getActiveUniforms(
-      program,
-      uniformIndices,
-      GL.UNIFORM_MATRIX_STRIDE
-    ); // Array of GLint indicating the strides between columns of a column-major matrix or a row-major matrix.
-    const uniformRowMajor = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_IS_ROW_MAJOR);
+    // const uniformMatrixStride = gl2.getActiveUniforms(
+    //   program,
+    //   uniformIndices,
+    //   GL.UNIFORM_MATRIX_STRIDE
+    // ); // Array of GLint indicating the strides between columns of a column-major matrix or a row-major matrix.
+    // const uniformRowMajor = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_IS_ROW_MAJOR);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
+      const activeInfo = gl2.getActiveUniform(program, uniformIndices[i]);
+      if (!activeInfo) {
+        throw new Error('activeInfo');
+      }
+
       blockInfo.uniforms.push({
-        name: gl2.getActiveUniform(program, uniformIndices[i]).name,
-        format: decodeUniformType(uniformType[i]).format,
+        name: activeInfo.name,
+        format: decodeGLUniformType(uniformType[i]).format,
         type: uniformType[i],
         arrayLength: uniformArrayLength[i],
         byteOffset: uniformOffset[i],
-        byteStride: uniformStride[i],
-        matrixStride: uniformStride[i],
-        rowMajor: uniformRowMajor[i]
+        byteStride: uniformStride[i]
+        // matrixStride: uniformStride[i],
+        // rowMajor: uniformRowMajor[i]
       });
     }
 
@@ -281,6 +276,27 @@ function readUniformBlocks(
   return uniformBlocks;
 }
 
+/**
+ * TOOD - compare with a above, confirm copy, then delete
+  const bindings: Binding[] = [];
+  const count = gl.getProgramParameter(program, gl.ACTIVE_UNIFORM_BLOCKS);
+  for (let blockIndex = 0; blockIndex < count; blockIndex++) {
+    const vertex = gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
+    const fragment = gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
+    const visibility = (vertex) + (fragment);
+    const binding: BufferBinding = {
+      location: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_BINDING),
+      // name: gl.getActiveUniformBlockName(program, blockIndex),
+      type: 'uniform',
+      visibility,
+      minBindingSize: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_DATA_SIZE),
+      // uniformCount: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
+      // uniformIndices: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES),
+    }
+    bindings.push(binding);
+  }
+*/
+
 const SAMPLER_UNIFORMS_GL_TO_GPU: Record<
   number,
   [
@@ -305,18 +321,18 @@ const SAMPLER_UNIFORMS_GL_TO_GPU: Record<
   [GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ['2d-array', 'uint']
 };
 
-function getSamplerInfo(type: GL):
-  | {
-      viewDimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
-      sampleType: 'float' | 'unfilterable-float' | 'depth' | 'sint' | 'uint';
-    }
-  | undefined {
-  let sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
-  if (sampler) {
-    const [viewDimension, sampleType] = sampler;
-    return {viewDimension, sampleType};
+type SamplerInfo = {
+  viewDimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+  sampleType: 'float' | 'unfilterable-float' | 'depth' | 'sint' | 'uint';
+};
+
+function getSamplerInfo(type: GL): SamplerInfo {
+  const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
+  if (!sampler) {
+    throw new Error('sampler');
   }
-  return null;
+  const [viewDimension, sampleType] = sampler;
+  return {viewDimension, sampleType};
 }
 
 // HELPERS
@@ -333,7 +349,7 @@ function parseUniformName(name: string): {name: string; length: number; isArray:
 
   // if array name then clean the array brackets
   const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
-  const matches = name.match(UNIFORM_NAME_REGEXP);
+  const matches = UNIFORM_NAME_REGEXP.exec(name);
   if (!matches || matches.length < 2) {
     throw new Error(`Failed to parse GLSL uniform name ${name}`);
   }
@@ -344,45 +360,3 @@ function parseUniformName(name: string): {name: string; length: number; isArray:
     isArray: Boolean(matches[2])
   };
 }
-
-/**
- * TODO - verify this is a copy of above and delete
- * import type {TextureFormat} from '@luma.gl/api';
-* Extract info about all "active" uniform blocks
- * ("Active" just means that unused (inactive) blocks may have been optimized away during linking)
- *
- function getUniformBlockBindings(gl, program): Binding[] {
-  if (!isWebGL2(gl)) {
-    return;
-  }
-  const bindings: Binding[] = [];
-  const count = gl.getProgramParameter(program, gl.ACTIVE_UNIFORM_BLOCKS);
-  for (let blockIndex = 0; blockIndex < count; blockIndex++) {
-    const vertex = gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
-    const fragment = gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
-    const visibility = (vertex) + (fragment);
-    const binding: BufferBinding = {
-      location: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_BINDING),
-      // name: gl.getActiveUniformBlockName(program, blockIndex),
-      type: 'uniform',
-      visibility,
-      minBindingSize: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_DATA_SIZE),
-      // uniformCount: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
-      // uniformIndices: gl.getActiveUniformBlockParameter(program, blockIndex, gl.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES),
-    }
-    bindings.push(binding);
-  }
-  return bindings;
-}
-
-function setBindings(gl2: WebGL2RenderingContext, program: WebGLProgram, bindings: Binding[][]): void {
-  for (const bindGroup of bindings) {
-    for (const binding of bindGroup) {
-
-    }
-  }
-
-  // Set up indirection table
-  // this.gl2.uniformBlockBinding(this.handle, blockIndex, blockBinding);
-}
- */

package/src/adapter/helpers/parse-shader-compiler-log.ts

@@ -1,5 +1,5 @@
 // luma.gl, MIT license
-import type {CompilerMessage} from '@luma.gl/shadertools';
+import type {CompilerMessage} from '@luma.gl/core';
 
 const MESSAGE_TYPES = ['warning', 'error', 'info'];
 
@@ -16,7 +16,7 @@ export function parseShaderCompilerLog(errLog: string) : readonly CompilerMessag
 
   for (const line of lines) {
     if (line.length <= 1) {
-      continue;
+      continue; // eslint-disable-line no-continue
     }
 
     const segments: string[] = line.split(':');

package/src/adapter/helpers/set-uniform.ts

@@ -1,5 +1,7 @@
+/* eslint-disable */
+
 // Uniforms
-import GL from '@luma.gl/constants';
+import {GL} from '@luma.gl/constants';
 
 /** Set a raw uniform (without type conversion and caching) */
 /* eslint-disable max-len */
@@ -7,7 +9,7 @@ export function setUniform(
   gl: WebGLRenderingContext,
   location: WebGLUniformLocation,
   type: GL,
-  value: number | Float32Array | Int32Array | Uint32Array
+  value: number | Float32Array | Int32Array | Uint32Array | boolean
 ): void {
   const gl2 = gl as WebGL2RenderingContext;
 
@@ -35,13 +37,12 @@ export function setUniform(
     }
   }
 
-  // @ts-expect-error
   if (value === true) {
     value = 1;
   }
-  // @ts-expect-error
+
   if (value === false) {
-    value = 1;
+    value = 0;
   }
   const arrayValue = (typeof value === 'number') ? [value] : value;
 
@@ -60,7 +61,7 @@ export function setUniform(
     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: gl.uniform4iv(location, arrayValue);
+    case GL.BOOL_VEC4: return gl.uniform4iv(location, arrayValue);
 
     // WEBGL2 - unsigned integers
     case GL.UNSIGNED_INT: return gl2.uniform1uiv(location, arrayValue, 1);

package/src/adapter/helpers/{attribute-utils.ts → webgl-topology-utils.ts}

@@ -1,8 +1,7 @@
-import GL from '@luma.gl/constants';
-import {GLDrawMode, GLPrimitive} from '../../types/webgl';
+import {GL, GLPrimitiveTopology, GLPrimitive} from '@luma.gl/constants';
 
 // Counts the number of complete primitives given a number of vertices and a drawMode
-export function getPrimitiveDrawMode(drawMode: GLDrawMode): GLPrimitive {
+export function getPrimitiveDrawMode(drawMode: GLPrimitiveTopology): GLPrimitive {
   switch (drawMode) {
     case GL.POINTS:
       return GL.POINTS;
@@ -24,7 +23,7 @@ export function getPrimitiveDrawMode(drawMode: GLDrawMode): GLPrimitive {
 }
 
 // Counts the number of complete "primitives" given a number of vertices and a drawMode
-export function getPrimitiveCount(options: {drawMode: GLDrawMode, vertexCount: number}): number {
+export function getPrimitiveCount(options: {drawMode: GLPrimitiveTopology, vertexCount: number}): number {
   const {drawMode, vertexCount} = options;
   switch (drawMode) {
     case GL.POINTS:
@@ -45,7 +44,7 @@ export function getPrimitiveCount(options: {drawMode: GLDrawMode, vertexCount: n
 }
 
 // Counts the number of vertices after splitting the vertex stream into separate "primitives"
-export function getVertexCount(options: {drawMode: GLDrawMode, vertexCount: number}): number {
+export function getVertexCount(options: {drawMode: GLPrimitiveTopology, vertexCount: number}): number {
   const {drawMode, vertexCount} = options;
   const primitiveCount = getPrimitiveCount({drawMode, vertexCount});
   switch (getPrimitiveDrawMode(drawMode)) {

package/src/adapter/objects/constants-to-keys.ts

@@ -1,5 +1,5 @@
-import {assert} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+import {assert} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
 
 // Resolve a WebGL enumeration name (returns itself if already a number)
 export function getKeyValue(gl: WebGLRenderingContext, name: string | GL): GL {
@@ -16,30 +16,8 @@ export function getKeyValue(gl: WebGLRenderingContext, name: string | GL): GL {
 
   // Look up string, after removing any 'GL.' or 'gl.' prefix
   name = name.replace(/^.*\./, '');
+  // @ts-ignore expect-error depends on settings
   const value = gl[name];
   assert(value !== undefined, `Accessing undefined constant GL.${name}`);
   return value;
 }
-
-export function getKey(gl: WebGLRenderingContext, value: any): string {
-  // @ts-expect-error 
-  gl = gl.gl || gl;
-  value = Number(value);
-  for (const key in gl) {
-    if (gl[key] === value) {
-      return `GL.${key}`;
-    }
-  }
-  return String(value);
-}
-
-export function getKeyType(gl: WebGLRenderingContext, value: any): string {
-  assert(value !== undefined, 'undefined key');
-  value = Number(value);
-  for (const key in gl) {
-    if (gl[key] === value) {
-      return `GL.${key}`;
-    }
-  }
-  return String(value);
-}

package/src/adapter/objects/webgl-renderbuffer.ts

@@ -1,29 +1,17 @@
-/* eslint-disable no-inline-comments */
-import {assert, ResourceProps} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import WebGLDevice from '../webgl-device';
-import WebGLResource from './webgl-resource';
-import {
-  isRenderbufferFormatSupported, getRenderbufferFormatBytesPerPixel
-} from '../converters/renderbuffer-formats';
+import {assert, ResourceProps, TextureFormat} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
+import {WebGLDevice} from '../webgl-device';
+import {WebGLResource} from './webgl-resource';
+import {isRenderbufferFormatSupported} from '../converters/texture-formats';
+import {convertTextureFormatToGL, getTextureFormatBytesPerPixel} from '../converters/texture-formats';
 
 export type RenderbufferProps = ResourceProps & {
-  format: number;
+  format: TextureFormat;
   width?: number;
   height?: number;
   samples?: number;
 };
 
-const DEFAULT_RENDERBUFFER_PROPS: Required<RenderbufferProps> = {
-  id: undefined,
-  handle: undefined,
-  userData: undefined,
-  format: 0,
-  width: 1, 
-  height: 1, 
-  samples: 0
-};
-
 /**
  * Renderbuffers are GPU objects that contain images.
  * In contrast to Textures they are optimized for use as render targets, with Framebuffers.
@@ -34,36 +22,54 @@ const DEFAULT_RENDERBUFFER_PROPS: Required<RenderbufferProps> = {
  * use Textures instead.
  * Renderbuffer objects also natively accommodate Multisampling (MSAA).
  */
-export default class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
-  get [Symbol.toStringTag](): string { return 'Renderbuffer'; }
+export class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
+  static override readonly defaultProps: Required<RenderbufferProps> = {
+    id: undefined,
+    handle: undefined,
+    userData: undefined,
+    format: undefined, // 'depth16unorm'
+    width: 1,
+    height: 1, 
+    samples: 0
+  };  
+
+  override get [Symbol.toStringTag](): string { return 'Renderbuffer'; }
 
   get width(): number { return this.props.width; }
   get height(): number { return this.props.height; }
-  get format(): number  { return this.props.format; }
+  get format(): TextureFormat { return this.props.format; }
   get samples(): number { return this.props.samples; }
+  get attachment() { return  }
+
+  /** WebGL format constant */
+  glFormat: GL;
 
-  static isSupported(gl: WebGLRenderingContext, options?: {format?: number}): boolean {
-    return !options.format || isRenderbufferFormatSupported(gl, options.format);
+  static isTextureFormatSupported(device: WebGLDevice, format: TextureFormat): boolean {
+    return isRenderbufferFormatSupported(device.gl, format);
   }
 
   constructor(device: WebGLDevice, props: RenderbufferProps) {
-    super(device, props, DEFAULT_RENDERBUFFER_PROPS);
+    // TODO - remove temporary sanity check
+    if (typeof props.format === 'number') {
+      throw new Error('Renderbuffer');
+    }
+    super(device, props, WEBGLRenderbuffer.defaultProps);
+    this.glFormat = convertTextureFormatToGL(this.props.format, device.isWebGL2);
     this._initialize(this.props);
   }
 
-  resize(size: {width: number, height: number}): this {
+  resize(size: {width: number, height: number}): void {
     // Don't resize if width/height haven't changed
     if (size.width !== this.width || size.height !== this.height) {
       Object.assign(this.props, {...size, format: this.format, samples: this.samples});
       this._initialize(this.props);
     }
-    return this;
   }
 
   // PRIVATE METHODS
 
   /** Creates and initializes a renderbuffer object's data store */
-  protected _initialize(props: Required<RenderbufferProps>) {
+  protected _initialize(props: Required<RenderbufferProps>): void {
     const {format, width, height, samples} = props;
     assert(format, 'Needs format');
 
@@ -72,33 +78,30 @@ export default class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps>
     this.gl.bindRenderbuffer(GL.RENDERBUFFER, this.handle);
 
     if (samples !== 0 && this.device.isWebGL2) {
-      // @ts-expect-error
-      this.gl.renderbufferStorageMultisample(GL.RENDERBUFFER, samples, format, width, height);
+      this.gl2.renderbufferStorageMultisample(GL.RENDERBUFFER, samples, this.glFormat, width, height);
     } else {
-      this.gl.renderbufferStorage(GL.RENDERBUFFER, format, width, height);
+      this.gl.renderbufferStorage(GL.RENDERBUFFER, this.glFormat, width, height);
     }
 
     this.gl.bindRenderbuffer(GL.RENDERBUFFER, null);
 
     this.trackAllocatedMemory(
-      width * height * (samples || 1) * getRenderbufferFormatBytesPerPixel(format)
+      width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat, this.device.isWebGL2)
     );
-
-    return this;
   }
 
   // RESOURCE IMPLEMENTATION
 
-  _createHandle() {
+  override _createHandle() {
     return this.gl.createRenderbuffer();
   }
 
-  _deleteHandle(): void {
+  override _deleteHandle(): void {
     this.gl.deleteRenderbuffer(this.handle);
     this.trackDeallocatedMemory();
   }
 
-  _bindHandle(handle: WEBGLRenderbuffer): void {
+  override _bindHandle(handle: WEBGLRenderbuffer): void {
     this.gl.bindRenderbuffer(GL.RENDERBUFFER, handle);
   }
 }