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

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

@@ -1,21 +1,19 @@
 // luma.gl, MIT license
-import {Resource, assert, uid, stubRemovedMethods} from '@luma.gl/api';
-import type {Device, ResourceProps} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+import {Resource, assert, uid, stubRemovedMethods} from '@luma.gl/core';
+import type {Device, ResourceProps} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
 import {isWebGL2, assertWebGLContext} from '../../context/context/webgl-checks';
-import WebGLDevice from '../webgl-device';
+import {WebGLDevice} from '../webgl-device';
 
 // Requires full GL enum to be bundled... Make these bindings dependent on dynamic import (debug)?
-import {getKey, getKeyValue} from './constants-to-keys';
+import {getKeyValue} from './constants-to-keys';
 
 const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual methods';
 
 /**
  * Base class for WebGL object wrappers
  */
- export default abstract class WebGLResource<Props> extends Resource<Props> {
-  id: string;
-  userData: any;
+export abstract class WebGLResource<Props extends ResourceProps> extends Resource<Props> {
   readonly device: WebGLDevice;
   readonly gl: WebGLRenderingContext;
   readonly gl2: WebGL2RenderingContext;
@@ -34,12 +32,10 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
     assertWebGLContext(gl);
 
     // extends 
-    // @ts-expect-error
-    const {id, userData = {}} = props || {};
+    const {id} = props || {};
     this.gl = gl;
     this.gl2 = gl as WebGL2RenderingContext;
     this.id = id || uid(this.constructor.name);
-    this.userData = userData;
 
     // Set the handle
     // If handle was provided, use it, otherwise create a new handle
@@ -48,7 +44,6 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
     // this.glCount = glGetContextLossCount(this.gl);
 
     // Default VertexArray needs to be created with null handle, so compare against undefined
-    // @ts-expect-error
     this._handle = props?.handle;
     if (this._handle === undefined) {
       this._handle = this._createHandle();
@@ -57,7 +52,7 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
     this.byteLength = 0;
   }
 
-  toString(): string {
+  override toString(): string {
     return `${this.constructor.name}(${this.id})`;
   }
 
@@ -74,11 +69,7 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
     return this._handle;
   }
 
-  destroy(): void {
-    this.delete();
-  }
-
-  delete({deleteChildren = false} = {}) {
+  override delete({deleteChildren = false} = {}) {
     // Delete this object, and get refs to any children
     // @ts-expect-error
     const children = this._handle && this._deleteHandle(this._handle);
@@ -91,7 +82,7 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
     // @ts-expect-error
     if (children && deleteChildren) {
       // @ts-expect-error
-      children.filter(Boolean).forEach((child) => child.delete());
+      children.filter(Boolean).forEach((child) => child.destroy());
     }
 
     return this;
@@ -130,7 +121,7 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
    * @param name
    * @return param
    */
-  getParameter(pname: number, props = {}): any {
+  getParameter(pname: number, props: any = {}): any {
     pname = getKeyValue(this.gl, pname);
     assert(pname);
 
@@ -163,7 +154,7 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
   // Many resources support a getParameter call -
   // getParameters will get all parameters - slow but useful for debugging
   // eslint-disable-next-line complexity
-  getParameters(options: {parameters?, keys?} = {}) {
+  getParameters(options: {parameters?: any, keys?: any} = {}) {
     const {parameters, keys} = options;
 
     // Get parameter definitions for this Resource
@@ -188,10 +179,10 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
         (!('extension' in parameter) || this.gl.getExtension(parameter.extension));
 
       if (parameterAvailable) {
-        const key = keys ? getKey(this.gl, pname) : pname;
+        const key = keys ? this.device.getGLKey(pname) : pname;
         values[key] = this.getParameter(pname, options);
         if (keys && parameter.type === 'GLenum') {
-          values[key] = getKey(this.gl, values[key]);
+          values[key] = this.device.getGLKey(values[key]);
         }
       }
     }

package/src/adapter/objects/webgl-vertex-array-object.ts

@@ -1,64 +1,104 @@
-import {assert, ResourceProps} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+import type {Device, Buffer, ResourceProps, TypedArray, NumericArray} from '@luma.gl/core';
+import {Resource, assert, getScratchArray, fillArray} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
 import {getBrowser} from '@probe.gl/env';
 
-import WebGLDevice from '../webgl-device';
-import WebGLResource from './webgl-resource';
+import {WebGLDevice} from '../webgl-device';
+import {WebGLResource} from './webgl-resource';
+import {WEBGLBuffer} from '../resources/webgl-buffer';
 
-import Buffer from '../resources/webgl-buffer';
+import {BufferWithAccessor} from '../../classic/buffer-with-accessor';
+import {AccessorObject} from '../..';
 
 const ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';
 
 /**
  * VertexArrayObject properties
+ * @param constantAttributeZero Attribute 0 can not be disable on most desktop OpenGL based browsers
+ * and on iOS Safari browser.
  */
 export type VertexArrayObjectProps = ResourceProps & {
+  constantAttributeZero?: boolean;
 };
 
 /** VertexArrayObject wrapper */
-export default class WEBGLVertexArrayObject extends WebGLResource<VertexArrayObjectProps> {
-  get [Symbol.toStringTag](): string {
+export class WEBGLVertexArrayObject extends WebGLResource<VertexArrayObjectProps> {
+  override get [Symbol.toStringTag](): string {
     return 'BaseVertexArrayObject';
   }
 
-  constructor(device: WebGLDevice, props?: VertexArrayObjectProps) {
-    // @ts-expect-error
-    super(device, props, {});
+  /** Buffer constant */
+  private buffer: BufferWithAccessor | null = null;
+  private bufferValue = null;
+
+  static isConstantAttributeZeroSupported(device: Device): boolean {
+    return device.info.type === 'webgl2' || getBrowser() === 'Chrome';
   }
 
-  _createHandle() {
+  // Create a VertexArray
+  constructor(device: Device, props?: VertexArrayObjectProps) {
+    super(device, props, {...Resource.defaultProps, constantAttributeZero: false});
+    Object.seal(this);
+  }
+
+  override destroy(): void {
+    super.destroy();
+    if (this.buffer) {
+      this.buffer?.destroy();
+    }  }
+
+  override _createHandle() {
     return this.gl2.createVertexArray();
   }
 
-  _deleteHandle(): void {
+  override _deleteHandle(): void {
     this.gl2.deleteVertexArray(this.handle);
     // @ts-expect-error
     return [this.elements];
     // return [this.elements, ...this.buffers];
   }
 
-  _bindHandle(handle: WEBGLVertexArrayObject): void {
+  override _bindHandle(handle: WEBGLVertexArrayObject): void {
     this.gl2.bindVertexArray(handle);
   }
 
+  /**
+   * Enabling an attribute location makes it reference the currently bound buffer
+   *  Disabling an attribute location makes it reference the global constant value
+   * TODO - handle single values for size 1 attributes?
+   * TODO - convert classic arrays based on known type?
+   */
+  enable(location: number, enable = true): void {
+    // Attribute 0 cannot be disabled in most desktop OpenGL based browsers...
+    const canDisableAttributeZero = this.device.isWebGL2 || getBrowser() === 'Chrome';
+    const canDisableAttribute = canDisableAttributeZero || location !== 0;
+
+    if (enable || canDisableAttribute) {
+      location = Number(location);
+      this.bind(() =>
+        enable
+          ? this.gl.enableVertexAttribArray(location)
+          : this.gl.disableVertexAttribArray(location)
+      );
+    }  }
+
   // Set (bind) an elements buffer, for indexed rendering.
   // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
-  setElementBuffer(elementBuffer: Buffer = null, opts = {}) {
-    assert(!elementBuffer || elementBuffer.target === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
+  setElementBuffer(elementBuffer: WEBGLBuffer | null = null, opts = {}) {
+    assert(!elementBuffer || elementBuffer.glTarget === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
 
     // The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject...
     this.bind(() => {
       this.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
     });
-
-    return this;
   }
 
   /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
-  setBuffer(location: number, buffer: Buffer, accessor: any): this {
+  setBuffer(location: number, buffer: WEBGLBuffer, accessor: AccessorObject): void {
     // Check target
-    if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {
-      return this.setElementBuffer(buffer, accessor);
+    if (buffer.glTarget === GL.ELEMENT_ARRAY_BUFFER) {
+      this.setElementBuffer(buffer, accessor);
+      return;
     }
 
     const {size, type, stride, offset, normalized, integer, divisor} = accessor;
@@ -83,29 +123,154 @@ export default class WEBGLVertexArrayObject extends WebGLResource<VertexArrayObj
 
       // NOTE We don't unbind buffer here, typically another buffer will be bound just after
     });
+  }
 
-    return this;
+  /**
+   * Set an attribute to a constant value
+   * @param device
+   * @param location
+   * @param array
+   * 
+   * @note Constants are stored globally on the WebGL context, not the VAO
+   * so they need to be updated before every render
+   * @todo - use known type (in configuration or passed in) to allow non-typed arrays?
+   * @todo - remember/cache values to avoid setting them unnecessarily?
+   */
+  setConstant(location: any, array: TypedArray): void {
+    switch (array.constructor) {
+      case Float32Array:
+        setConstantFloatArray(this.device, location, array as Float32Array);
+        break;
+      case Int32Array:
+        setConstantIntArray(this.device, location, array as Int32Array);
+        break;
+      case Uint32Array:
+        setConstantUintArray(this.device, location, array as Uint32Array);
+        break;
+      default:
+        assert(false);
+    }
   }
 
   /**
-   * Enabling an attribute location makes it reference the currently bound buffer
-   *  Disabling an attribute location makes it reference the global constant value
-   * TODO - handle single values for size 1 attributes?
-   * TODO - convert classic arrays based on known type?
+   * Provide a means to create a buffer that is equivalent to a constant.
+   * NOTE: Desktop OpenGL cannot disable attribute 0.
+   * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled-
+   * this-has-significant-performance-penalty
    */
-  enable(location: number, enable = true): this {
-    // Attribute 0 cannot be disabled in most desktop OpenGL based browsers...
-    const canDisableAttributeZero = this.device.isWebGL2 || getBrowser() === 'Chrome';
-    const canDisableAttribute = canDisableAttributeZero || location !== 0;
+  getConstantBuffer(elementCount: number, value): Buffer {
+    // Create buffer only when needed, and reuse it (avoids inflating buffer creation statistics)
 
-    if (enable || canDisableAttribute) {
-      location = Number(location);
-      this.bind(() =>
-        enable
-          ? this.gl.enableVertexAttribArray(location)
-          : this.gl.disableVertexAttribArray(location)
-      );
+    const constantValue = normalizeConstantArrayValue(value);
+
+    const byteLength = constantValue.byteLength * elementCount;
+    const length = constantValue.length * elementCount;
+
+    let updateNeeded = !this.buffer;
+
+    this.buffer = this.buffer || this.device.createBuffer({byteLength}) as BufferWithAccessor;
+    updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);
+
+    // Reallocate and update contents if needed
+    updateNeeded =
+      updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
+
+    if (updateNeeded) {
+      // Create a typed array that is big enough, and fill it with the required data
+      const typedArray = getScratchArray(value.constructor, length);
+      fillArray({target: typedArray, source: constantValue, start: 0, count: length});
+      this.buffer.subData(typedArray);
+      this.bufferValue = value;
+    }
+
+    return this.buffer;
+  }
+}
+
+function setConstantFloatArray(device: WebGLDevice, location: number, array: Float32Array): void {
+  switch (array.length) {
+    case 1:
+      device.gl.vertexAttrib1fv(location, array);
+      break;
+    case 2:
+      device.gl.vertexAttrib2fv(location, array);
+      break;
+    case 3:
+      device.gl.vertexAttrib3fv(location, array);
+      break;
+    case 4:
+      device.gl.vertexAttrib4fv(location, array);
+      break;
+    default:
+      assert(false);
+  }
+}
+
+function setConstantIntArray(device: WebGLDevice, location: number, array: Int32Array): void {
+  device.assertWebGL2();
+  device.gl2?.vertexAttribI4iv(location, array);
+  // switch (array.length) {
+  //   case 1:
+  //     gl.vertexAttribI1iv(location, array);
+  //     break;
+  //   case 2:
+  //     gl.vertexAttribI2iv(location, array);
+  //     break;
+  //   case 3:
+  //     gl.vertexAttribI3iv(location, array);
+  //     break;
+  //   case 4:
+  //     break;
+  //   default:
+  //     assert(false);
+  // }
+}
+
+function setConstantUintArray(device: WebGLDevice, location: number, array: Uint32Array) {
+  device.assertWebGL2();
+  device.gl2?.vertexAttribI4uiv(location, array);
+  // switch (array.length) {
+  //   case 1:
+  //     gl.vertexAttribI1uiv(location, array);
+  //     break;
+  //   case 2:
+  //     gl.vertexAttribI2uiv(location, array);
+  //     break;
+  //   case 3:
+  //     gl.vertexAttribI3uiv(location, array);
+  //     break;
+  //   case 4:
+  //     gl.vertexAttribI4uiv(location, array);
+  //     break;
+  //   default:
+  //     assert(false);
+  // }
+}
+
+// HELPERS
+
+/**
+ * TODO - convert Arrays based on known type? (read type from accessor, don't assume Float32Array)
+ * TODO - handle single values for size 1 attributes?
+ */
+function normalizeConstantArrayValue(arrayValue: NumericArray) {
+  if (Array.isArray(arrayValue)) {
+    return new Float32Array(arrayValue);
+  }
+  return arrayValue;
+}
+
+/**
+ * 
+ */
+function compareConstantArrayValues(v1: NumericArray, v2: NumericArray): boolean {
+  if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
+    return false;
+  }
+  for (let i = 0; i < v1.length; ++i) {
+    if (v1[i] !== v2[i]) {
+      return false;
     }
-    return this;
   }
+  return true;
 }

package/src/adapter/resources/webgl-buffer.ts

@@ -1,25 +1,30 @@
-import type {BufferProps} from '@luma.gl/api';
-import {Buffer, assert} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import WebGLDevice from '../webgl-device';
+import type {BufferProps} from '@luma.gl/core';
+import {Buffer, assert} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
+import {WebGLDevice} from '../webgl-device';
 
 const DEBUG_DATA_LENGTH = 10;
 
 /** WebGL Buffer interface */
-export default class WEBGLBuffer extends Buffer {
+export class WEBGLBuffer extends Buffer {
   readonly device: WebGLDevice;
   readonly gl: WebGLRenderingContext;
   readonly gl2: WebGL2RenderingContext | null;
   readonly handle: WebGLBuffer;
-  readonly target: number;
 
+  /** Target in OpenGL defines the type of buffer */
+  readonly glTarget: GL.ARRAY_BUFFER | GL.ELEMENT_ARRAY_BUFFER | GL.UNIFORM_BUFFER;
+  /** Usage is a hint on how frequently the buffer will be updates */
+  readonly glUsage: GL.STATIC_DRAW | GL.DYNAMIC_DRAW;
+  /** Index type is needed when issuing draw calls, so we pre-compute it */
+  readonly glIndexType: GL.UNSIGNED_SHORT | GL.UNSIGNED_INT = GL.UNSIGNED_SHORT;
+
+  /** Number of bytes allocated on the GPU for this buffer */
   byteLength: number;
+  /** Number of bytes used */
   bytesUsed: number;
-  debugData: ArrayBuffer;
-
-  webglUsage: number;
-
-  accessor: {};
+  /** A partial CPU-side copy of the data in this buffer, for debugging purposes */
+  debugData: ArrayBuffer | null = null;
 
   constructor(device: WebGLDevice, props: BufferProps = {}) {
     super(device, props);
@@ -28,18 +33,17 @@ export default class WEBGLBuffer extends Buffer {
     this.gl = this.device.gl;
     this.gl2 = this.device.gl2;
 
-    const handle = typeof props === 'object' ? (props as BufferProps).handle : undefined;
+    const handle = typeof props === 'object' ? (props ).handle : undefined;
     this.handle = handle || this.gl.createBuffer();
-    // @ts-expect-error Add metadata for spector
-    this.handle.__SPECTOR_Metadata = {...this.props, data: typeof this.props.data}; // {name: this.props.id};
-
-    // In WebGL1, need to make sure we use GL.ELEMENT_ARRAY_BUFFER when initializing element buffers
-    // otherwise buffer type will lock to generic (non-element) buffer
-    // In WebGL2, we can use GL.COPY_READ_BUFFER which avoids locking the type here
-    // @ts-expect-error Hack - Checking for subclass prop
-    this.target = this.props.target || getWebGLTarget(this.props.usage);
-    // @ts-expect-error Hack - Checking for subclass prop
-    this.webglUsage = this.props.webglUsage || getWebGLUsage(this.props.usage);
+    device.setSpectorMetadata(this.handle, {...this.props, data: typeof this.props.data});
+
+    // - In WebGL1, need to make sure we use GL.ELEMENT_ARRAY_BUFFER when initializing element buffers
+    //   otherwise buffer type will lock to generic (non-element) 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.debugData = null;
 
     // Set data: (re)initializes the buffer
@@ -48,25 +52,19 @@ export default class WEBGLBuffer extends Buffer {
     } else {
       this._initWithByteLength(props.byteLength || 0);
     }
-
-    // Deprecated: Merge main props and accessor
-    // this.accessor = {...props.accessor};
-
-    // Object.seal(this);
   }
 
-   // PRIVATE METHODS
+  // PRIVATE METHODS
 
-  // Allocate a new buffer and initialize to contents of typed array
+  /** Allocate a new buffer and initialize to contents of typed array */
   _initWithData(data, byteOffset: number = 0, byteLength: number = data.byteLength + byteOffset): this {
     assert(ArrayBuffer.isView(data));
 
-    const target = this._getWriteTarget();
-
-    this.gl.bindBuffer(target, this.handle);
-    this.gl.bufferData(target, byteLength, this.webglUsage);
-    this.gl.bufferSubData(target, byteOffset, data);
-    this.gl.bindBuffer(target, null);
+    const glTarget = this._getWriteTarget();
+    this.gl.bindBuffer(glTarget, this.handle);
+    this.gl.bufferData(glTarget, byteLength, this.glUsage);
+    this.gl.bufferSubData(glTarget, byteOffset, data);
+    this.gl.bindBuffer(glTarget, null);
 
     this.debugData = data.slice(0, DEBUG_DATA_LENGTH);
     this.bytesUsed = byteLength;
@@ -88,11 +86,11 @@ export default class WEBGLBuffer extends Buffer {
       data = new Float32Array(0);
     }
 
-    const target = this._getWriteTarget();
+    const glTarget = this._getWriteTarget();
 
-    this.gl.bindBuffer(target, this.handle);
-    this.gl.bufferData(target, data, this.webglUsage);
-    this.gl.bindBuffer(target, null);
+    this.gl.bindBuffer(glTarget, this.handle);
+    this.gl.bufferData(glTarget, data, this.glUsage);
+    this.gl.bindBuffer(glTarget, null);
 
     this.debugData = null;
     this.bytesUsed = byteLength;
@@ -101,41 +99,40 @@ export default class WEBGLBuffer extends Buffer {
     return this;
   }
 
-  destroy(): void {
-    if (this.handle) {
+  override destroy(): void {
+    if (!this.destroyed && this.handle) {
       this.removeStats();
       this.trackDeallocatedMemory();
       this.gl.deleteBuffer(this.handle);
+      this.destroyed = true;
       // @ts-expect-error
       this.handle = null;
     }
   }
 
-  write(data: ArrayBufferView, byteOffset: number = 0): void {
+  override write(data: ArrayBufferView, byteOffset: number = 0): void {
     const srcOffset = 0;
-    const byteLength = data.byteLength;
+    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 target = this.device.isWebGL2 ? GL.COPY_WRITE_BUFFER : this.target;
-    this.gl.bindBuffer(target, this.handle);
+    const glTarget = this.device.isWebGL2 ? GL.COPY_WRITE_BUFFER : this.glTarget;
+    this.gl.bindBuffer(glTarget, this.handle);
     // WebGL2: subData supports additional srcOffset and length parameters
     if (srcOffset !== 0 || byteLength !== undefined) {
       this.device.assertWebGL2();
-
-      // @ts-expect-error
-      this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength);
+      this.gl2.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength);
     } else {
-      this.gl.bufferSubData(target, byteOffset, data);
+      this.gl.bufferSubData(glTarget, byteOffset, data);
     }
-    this.gl.bindBuffer(target, null);
+    this.gl.bindBuffer(glTarget, null);
 
     // TODO - update local `data` if offsets are right
     // this.debugData = data.slice(byteOffset, 40);
   }
 
   /** Read data from the buffer */
-  async readAsync(
+  override async readAsync(
     byteOffset: number = 0,
     byteLength?: number
   ): Promise<ArrayBuffer> {
@@ -162,13 +159,13 @@ export default class WEBGLBuffer extends Buffer {
   }
 
   _getWriteTarget() {
-    return this.target;
-    // return this.device.isWebGL2 ? GL.COPY_WRITE_BUFFER : this.target;
+    return this.glTarget;
+    // return this.device.isWebGL2 ? GL.COPY_WRITE_BUFFER : this.glTarget;
   }
 
   _getReadTarget() {
-    return this.target;
-    return this.device.isWebGL2 ? GL.COPY_READ_BUFFER : this.target;
+    return this.glTarget;
+    // return this.device.isWebGL2 ? GL.COPY_READ_BUFFER : this.glTarget;
   }
 }
 
@@ -183,7 +180,7 @@ export default class WEBGLBuffer extends Buffer {
 // static INDIRECT = 0x0100;
 // static QUERY_RESOLVE = 0x0200;
 
-function getWebGLTarget(usage: number): GL {
+function getWebGLTarget(usage: number): GL.ARRAY_BUFFER | GL.ELEMENT_ARRAY_BUFFER | GL.UNIFORM_BUFFER {
   if (usage & Buffer.INDEX) {
     return GL.ELEMENT_ARRAY_BUFFER;
   }
@@ -205,7 +202,8 @@ function getWebGLTarget(usage: number): GL {
   return GL.ARRAY_BUFFER;
 }
 
-function getWebGLUsage(usage: number): GL {
+/** @todo usage is not passed correctly */
+function getWebGLUsage(usage: number): GL.STATIC_DRAW | GL.DYNAMIC_DRAW {
   if (usage & Buffer.INDEX) {
     return GL.STATIC_DRAW;
   }
@@ -215,5 +213,5 @@ function getWebGLUsage(usage: number): GL {
   if (usage & Buffer.UNIFORM) {
     return GL.DYNAMIC_DRAW;
   }
-  return GL.DYNAMIC_DRAW;
+  return GL.STATIC_DRAW;
 }