@openglobus/og 0.28.7 → 1.0.0-rc2

package/lib/webgl/Handler.d.ts

@@ -4,8 +4,7 @@ import type { EventsHandler } from "../Events";
 import type { TypedArray } from "../utils/shared";
 import { Vec2 } from "../math/Vec2";
 import type { NumberArray2 } from "../math/Vec2";
-import { ProgramController } from "./ProgramController";
-import { Program } from "./Program";
+import { ShaderProgram } from "./ShaderProgram";
 import { Stack } from "../Stack";
 export type WebGLContextExt = {
     type: string;
@@ -100,17 +99,17 @@ declare class Handler {
      */
     gl: WebGLContextExt | null;
     /**
-     * Shader program controller list.
+     * Shader program list.
      * @public
-     * @type {Record<string, ProgramController>}
+     * @type {Record<string, ShaderProgram>}
      */
-    programs: Record<string, ProgramController>;
+    programs: Record<string, ShaderProgram>;
     /**
-     * Current active shader program controller.
+     * Current active shader program.
      * @public
-     * @type {ProgramController}
+     * @type {ShaderProgram}
      */
-    activeProgram: ProgramController | null;
+    activeProgram: ShaderProgram | null;
     /**
      * Handler parameters.
      * @private
@@ -157,24 +156,23 @@ declare class Handler {
     createTexture: Record<string, CreateTextureFunc>;
     createTextureDefault: CreateTextureFunc;
     ONCANVASRESIZE: Function | null;
-    createTexture_n: CreateTextureFunc;
-    createTexture_l: CreateTextureFunc;
-    createTexture_mm: CreateTextureFunc;
-    createTexture_a: CreateTextureFunc;
     intersectionObserver?: IntersectionObserver;
     resizeObserver?: ResizeObserver;
     protected _requestAnimationFrameId: number;
+    protected _clipControlZeroToOne: boolean;
+    clipControl: ((origin: number, depth: number) => void) | undefined;
+    protected _getMipmapLevels(width: number, height: number): number;
     constructor(canvasTarget: string | HTMLCanvasElement | undefined, params?: IHandlerParameters);
     set frameDelay(delay: number);
     isInitialized(): boolean;
     protected _createCanvas(): void;
     /**
      * The return value is null if the extension is not supported, or an extension object otherwise.
-     * @param {WebGLRenderingContext | WebGL2RenderingContext | null} gl - WebGl context pointer.
+     * @param {WebGL2RenderingContext | null} gl - WebGl context pointer.
      * @param {string} name - Extension name.
      * @returns {any} -
      */
-    static getExtension(gl: WebGLRenderingContext | WebGL2RenderingContext | null, name: string): any | undefined;
+    static getExtension(gl: WebGL2RenderingContext | null, name: string): any | undefined;
     /**
      * Returns a drawing context on the canvas, or null if the context identifier is not supported.
      * @param {HTMLCanvasElement} canvas - HTML canvas object.
@@ -189,24 +187,24 @@ declare class Handler {
      */
     setFrameCallback(callback: Function): void;
     /**
-     * Creates empty texture.
+     * Creates an empty immutable 2D texture (WebGL2).
      * @public
-     * @param {number} [width=1] - Specifies the width of the texture image.
-     * @param {number} [height=1] - Specifies the width of the texture image.
-     * @param {string} [filter="NEAREST"] - Specifies GL_TEXTURE_MIN(MAX)_FILTER texture value.
-     * @param {string} [internalFormat="RGBA"] - Specifies the color components in the texture.
-     * @param {string} [format="RGBA"] - Specifies the format of the texel data.
-     * @param {string} [type="UNSIGNED_BYTE"] - Specifies the data type of the texel data.
-     * @param {number} [level=0] - Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image.
-     * @returns {WebGLTexture | null} - WebGL texture object.
+     * @param {number} [width=1] - Texture width in pixels.
+     * @param {number} [height=1] - Texture height in pixels.
+     * @param {string} [filter="NEAREST"] - GL_TEXTURE_MIN_FILTER and GL_TEXTURE_MAG_FILTER value.
+     * @param {string} [internalFormat="RGBA8"] - Sized internal format (e.g. "RGBA8", "RGBA16F", "R16F").
+     * @param {string} [param="CLAMP_TO_EDGE"] - GL_TEXTURE_WRAP_S/T value.
+     * @param {number} [levels=1] - Number of mipmap levels (immutable storage).
+     * @returns {WebGLTexture | null} - Created WebGL texture object.
      */
-    createEmptyTexture2DExt(width?: number, height?: number, filter?: string, internalFormat?: string, format?: string, type?: string, param?: string, level?: number): WebGLTexture | null;
+    createEmptyTexture2DExt(width?: number, height?: number, filter?: string, internalFormat?: string, param?: string, levels?: number): WebGLTexture | null;
     /**
      * Creates Empty NEAREST filtered texture.
      * @public
      * @param {number} width - Empty texture width.
      * @param {number} height - Empty texture height.
-     * @param {number} [internalFormat]
+     * @param {number} [internalFormat] - Internal texture format, `gl.RGBA` by default.
+     * @param {number} [texParami] - Wrap mode for S/T axes, `gl.CLAMP_TO_EDGE` by default.
      * @returns {WebGLTexture | null} - WebGL texture object.
      */
     createEmptyTexture_n(width: number, height: number, internalFormat?: number | null, texParami?: number | null): WebGLTexture | null;
@@ -223,53 +221,13 @@ declare class Handler {
     /**
      * Creates NEAREST filter texture.
      * @public
-     * @param {HTMLCanvasElement | Image} image - Image or Canvas object.
-     * @param {number} [internalFormat]
-     * @param {number} [texParami]
-     * @param {WebGLTexture | null} [texture=null]
-     * @returns {WebGLTexture | null} - WebGL texture object.
-     */
-    createTexture_n_webgl1(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTexture | null;
-    /**
-     * Creates LINEAR filter texture.
-     * @public
-     * @param {ImageSource} image - Image or Canvas object.
-     * @param {number} [internalFormat]
-     * @param {number} [texParami]
-     * @param {WebGLTexture | null} [texture]
-     * @returns {WebGLTexture | null} - WebGL texture object.
-     */
-    createTexture_l_webgl1(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTexture | null;
-    /**
-     * Creates MIPMAP filter texture.
-     * @public
-     * @param {ImageSource} image - Image or Canvas object.
-     * @param {number} [internalFormat]
-     * @param {number} [texParami]
-     * @param {WebGLTexture | null} [texture]
-     * @returns {WebGLTexture | null} - WebGL texture object.
-     */
-    createTexture_mm_webgl1(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTexture | null;
-    /**
-     * Creates ANISOTROPY filter texture.
-     * @public
      * @param {ImageSource} image - Image or Canvas object.
      * @param {number} [internalFormat]
      * @param {number} [texParami]
      * @param {WebGLTexture | null} [texture]
      * @returns {WebGLTexture | null} - WebGL texture object.
      */
-    createTexture_a_webgl1(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTexture | null;
-    /**
-     * Creates NEAREST filter texture.
-     * @public
-     * @param {ImageSource} image - Image or Canvas object.
-     * @param {number} [internalFormat]
-     * @param {number} [texParami]
-     * @param {WebGLTexture | null} [texture]
-     * @returns {WebGLTexture | null} - WebGL texture object.
-     */
-    createTexture_n_webgl2(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTexture | null;
+    createTexture_n(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTextureExt | null;
     /**
      * Creates LINEAR filter texture.
      * @public
@@ -279,7 +237,7 @@ declare class Handler {
      * @param {WebGLTexture | null} [texture]
      * @returns {WebGLTexture | null} - WebGL texture object.
      */
-    createTexture_l_webgl2(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTexture | null;
+    createTexture_l(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTextureExt | null;
     /**
      * Creates MIPMAP filter texture.
      * @public
@@ -289,7 +247,7 @@ declare class Handler {
      * @param {WebGLTexture | null} [texture]
      * @returns {WebGLTexture | null} - WebGL texture object.
      */
-    createTexture_mm_webgl2(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTexture | null;
+    createTexture_mm(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTextureExt | null;
     /**
      * Creates ANISOTROPY filter texture.
      * @public
@@ -299,7 +257,7 @@ declare class Handler {
      * @param {WebGLTexture | null} [texture]
      * @returns {WebGLTexture | null} - WebGL texture object.
      */
-    createTexture_a_webgl2(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTexture | null;
+    createTexture_a(image: ImageSource, internalFormat?: number | null, texParami?: number | null, texture?: WebGLTexture | null): WebGLTextureExt | null;
     /**
      * Creates cube texture.
      * @public
@@ -310,17 +268,19 @@ declare class Handler {
      * @param {string} params.ny - Negative Y or bottom image url.
      * @param {string} params.pz - Positive Z or face image url.
      * @param {string} params.nz - Negative Z or back image url.
+     * @param {number} [colorSpace=gl.SRGB8_ALPHA8] - Cube texture internal format (for example gl.SRGB8_ALPHA8 or gl.RGBA8).
+     * @param {number} [textureFilter=gl.LINEAR] - Cube texture filter (for example gl.LINEAR or gl.NEAREST).
      * @returns {WebGLTexture | null} - WebGL texture object.
      */
-    loadCubeMapTexture(params: Texture3DParams): WebGLTexture | null;
+    loadCubeMapTexture(params: Texture3DParams, colorSpace?: number | null, textureFilter?: number | null): WebGLTextureExt | null;
     /**
      * Adds shader program to the handler.
      * @public
-     * @param {Program} program - Shader program.
+     * @param {ShaderProgram} program - Shader program.
      * @param {boolean} [activate] - If false program will not compile.
-     * @return {Program} -
+     * @return {ShaderProgram} -
      */
-    addProgram(program: Program, activate?: boolean): Program;
+    addProgram(program: ShaderProgram, activate?: boolean): ShaderProgram;
     /**
      * Removes shader program from handler.
      * @public
@@ -330,15 +290,15 @@ declare class Handler {
     /**
      * Adds shader programs to the handler.
      * @public
-     * @param {Array.<Program>} programsArr - Shader program array.
+     * @param {Array.<ShaderProgram>} programsArr - Shader program array.
      */
-    addPrograms(programsArr: Program[]): void;
+    addPrograms(programsArr: ShaderProgram[]): void;
     /**
      * Used in addProgram
      * @protected
-     * @param {ProgramController} sc - Program controller
+     * @param {ShaderProgram} program - ShaderProgram
      */
-    protected _initProgramController(sc: ProgramController): void;
+    protected _initProgram(program: ShaderProgram): void;
     /**
      * Used in init function.
      * @private
@@ -353,7 +313,7 @@ declare class Handler {
      */
     initializeExtension(extensionStr: string, showLog?: boolean): any;
     /**
-     * Main function that initialize handler.
+     * Main function that initializes handler.
      * @public
      */
     initialize(): void;
@@ -363,41 +323,54 @@ declare class Handler {
      * @protected
      */
     protected _setDefaults(): void;
+    /**
+     * Returns true when clip-control depth range is currently ZERO_TO_ONE.
+     * @public
+     * @returns {boolean} -
+     */
+    get isClipControlZeroToOne(): boolean;
+    /**
+     * Switches clip-control depth range between ZERO_TO_ONE and NEGATIVE_ONE_TO_ONE.
+     * If EXT_clip_control is unavailable, the internal ZERO_TO_ONE flag is reset to false.
+     * @public
+     * @param {boolean} useZeroToOne - True sets ZERO_TO_ONE, false sets NEGATIVE_ONE_TO_ONE.
+     */
+    setClipControlZeroToOne(useZeroToOne: boolean): void;
     getCanvasSize(): NumberArray2;
     /**
-     * Creates STREAM_DRAW ARRAY buffer.
+     * Creates ARRAY_BUFFER storage for frequently updated data.
      * @public
-     * @param {number} itemSize - Array item size.
-     * @param {number} numItems - Items quantity.
-     * @param {number} [usage=STATIC_DRAW] - Parameter of the bufferData call can be one of STATIC_DRAW, DYNAMIC_DRAW, or STREAM_DRAW.
-     * @param {number} [bytes=4] -
+     * @param {number} itemSize - Number of scalar components per item.
+     * @param {number} numItems - Number of items.
+     * @param {number} [usage=STREAM_DRAW] - GL usage hint (STATIC_DRAW, DYNAMIC_DRAW or STREAM_DRAW).
+     * @param {number} [bytes=4] - Bytes per scalar component.
      * @return {WebGLBufferExt} -
      */
     createStreamArrayBuffer(itemSize: number, numItems: number, usage?: number, bytes?: number): WebGLBufferExt;
     /**
-     * Sets stream buffer.
+     * Uploads data to an existing ARRAY_BUFFER via bufferSubData.
      * @public
-     * @param {WebGLBufferExt} buffer -
-     * @param {TypedArray} array -
-     * @param {number} [offset=0] -
+     * @param {WebGLBufferExt} buffer - Target ARRAY_BUFFER.
+     * @param {TypedArray} array - Source data to upload.
+     * @param {number} [offset=0] - Byte offset in the target buffer.
      * @return {WebGLBufferExt} -
      */
     setStreamArrayBuffer(buffer: WebGLBufferExt, array: TypedArray, offset?: number): WebGLBufferExt;
     /**
-     * Creates ARRAY buffer.
+     * Creates and initializes ARRAY_BUFFER from a typed array.
      * @public
-     * @param {TypedArray} array - Input array.
-     * @param {number} itemSize - Array item size.
-     * @param {number} numItems - Items quantity.
-     * @param {number} [usage=STATIC_DRAW] - Parameter of the bufferData call can be one of STATIC_DRAW, DYNAMIC_DRAW, or STREAM_DRAW.
+     * @param {TypedArray} array - Source data.
+     * @param {number} itemSize - Number of scalar components per item.
+     * @param {number} [numItems] - Number of items (computed from array length when omitted).
+     * @param {number} [usage=STATIC_DRAW] - GL usage hint (STATIC_DRAW, DYNAMIC_DRAW or STREAM_DRAW).
      * @return {WebGLBufferExt} -
      */
     createArrayBuffer(array: TypedArray, itemSize: number, numItems?: number, usage?: number): WebGLBufferExt;
     /**
-     * Creates ARRAY buffer specific length.
+     * Creates ARRAY_BUFFER storage with a specific byte length and no initial data.
      * @public
-     * @param {number} size -
-     * @param {number} [usage=STATIC_DRAW] - Parameter of the bufferData call can be one of STATIC_DRAW, DYNAMIC_DRAW, or STREAM_DRAW.
+     * @param {number} size - Buffer size in bytes.
+     * @param {number} [usage=STATIC_DRAW] - GL usage hint (STATIC_DRAW, DYNAMIC_DRAW or STREAM_DRAW).
      * @return {WebGLBufferExt} -
      */
     createArrayBufferLength(size: number, usage?: number): WebGLBufferExt;
@@ -472,14 +445,23 @@ declare class Handler {
      */
     protected _animationFrameCallback(): void;
     /**
-     * Creates default texture object.
+     * Creates a default 2x2 texture and passes it to callback.
+     * If `params.color` is set, a solid color texture is created.
+     * If `params.url` is set, the image is loaded asynchronously.
+     * Otherwise a fallback gray texture is created.
+     * @public
+     * @param {IDefaultTextureParams | null} params - Texture source parameters.
+     * @param {function(WebGLTextureExt): void} success - Callback with created texture.
+     */
+    createDefaultTexture(params: IDefaultTextureParams | null, success: (texture: WebGLTextureExt) => void, internalFormat?: number | null): void;
+    /**
+     * Deletes texture if it is not marked as default.
      * @public
-     * @param {IDefaultTextureParams | null} params - Texture parameters.
-     * @param {function(WebGLTextureExt): void} [success] - Creation callback.
+     * @param {WebGLTextureExt | null | undefined} texture - Texture to delete.
      */
-    createDefaultTexture(params: IDefaultTextureParams | null, success: (texture: WebGLTextureExt) => void): void;
     deleteTexture(texture: WebGLTextureExt | null | undefined): void;
     /**
+     * Releases handler resources, WebGL objects, observers and canvas.
      * @public
      */
     destroy(): void;

package/lib/webgl/ShaderProgram.d.ts

@@ -0,0 +1,190 @@
+import type { ProgramVariable } from "./variableHandlers";
+import type { Handler, WebGLBufferExt } from "./Handler";
+type WebGLProgramExt = WebGLProgram & {
+    [id: string]: WebGLUniformLocation | number | null;
+};
+type ProgramBinding = WebGLUniformLocation | number;
+type ProgramMaterial = {
+    attributes: Record<string, any>;
+    uniforms: Record<string, any>;
+    vertexShader: string;
+    fragmentShader: string;
+};
+/**
+ * Represents more comfortable using WebGL shader program.
+ * @class
+ * @param {string} name - ShaderProgram name.
+ * @param {ProgramMaterial} material - Object stores uniforms, attributes and program codes:
+ * @param {Record<string, any>} material.uniforms - Uniforms definition section.
+ * @param {Record<string, any>} material.attributes - Attributes definition section.
+ * @param {string} material.vertexShader - Vertex glsl code.
+ * @param {string} material.fragmentShader - Fragment glsl code.
+ */
+declare class ShaderProgram {
+    [id: string]: any;
+    /**
+     * Shader program name.
+     * @public
+     * @type {string}
+     */
+    name: string;
+    protected _handler: Handler | null;
+    _activated: boolean;
+    attributes: {
+        [id: string]: number;
+    };
+    uniforms: {
+        [id: string]: WebGLUniformLocation;
+    };
+    protected _attributes: Record<string, ProgramVariable>;
+    protected _uniforms: Record<string, ProgramVariable>;
+    vertexShader: string;
+    fragmentShader: string;
+    drawElementsInstanced: Function | null;
+    vertexAttribDivisor: Function | null;
+    /**
+     * Webgl context.
+     * @public
+     * @type {WebGL2RenderingContext | null}
+     */
+    gl: WebGL2RenderingContext | null;
+    /**
+     * All program variables.
+     * @protected
+     * @type {Record<string, ProgramVariable>}
+     */
+    protected _variables: Record<string, ProgramVariable>;
+    /**
+     * ShaderProgram pointer.
+     * @protected
+     * @type {WebGLProgramExt | null}
+     */
+    protected _p: WebGLProgramExt | null;
+    /**
+     * Texture counter.
+     * @public
+     * @type {number}
+     */
+    _textureID: number;
+    /**
+     * ShaderProgram attributes array.
+     * @protected
+     * @type {number[]}
+     */
+    protected _attribArrays: number[];
+    /**
+     * ShaderProgram attributes divisors.
+     * @protected
+     * @type {number[]}
+     */
+    protected _attribDivisor: number[];
+    protected _bindings: Record<string, ProgramBinding>;
+    protected _dynamicBindingNames: Set<string>;
+    constructor(name: string, material: ProgramMaterial);
+    /**
+     * Attaches this shader program to a handler.
+     * @param {Handler} handler - WebGL handler.
+     * @returns {ShaderProgram}
+     */
+    attach(handler: Handler): this;
+    /**
+     * Initializes this shader program using handler WebGL context.
+     * @returns {ShaderProgram}
+     */
+    initialize(): this;
+    protected _bindVariable(name: string, location: ProgramBinding): void;
+    /**
+     * Binds attribute buffer and sets its pointer.
+     * @param {ShaderProgram} program - Shader program instance.
+     * @param {ProgramVariable} variable - Attribute variable descriptor.
+     */
+    static bindBuffer(program: ShaderProgram, variable: ProgramVariable): void;
+    /**
+     * Makes this shader program current in WebGL context.
+     */
+    use(): void;
+    /**
+     * Activates this shader program and disables previously active one.
+     * @returns {ShaderProgram}
+     */
+    activate(): this;
+    /**
+     * Deactivates this shader program.
+     * @returns {ShaderProgram}
+     */
+    deactivate(): this;
+    /**
+     * Returns `true` if this shader program is active.
+     * @returns {boolean}
+     */
+    isActive(): boolean;
+    /**
+     * Removes this shader program from its handler and releases WebGL program.
+     */
+    remove(): void;
+    /**
+     * Sets provided shader variables and applies them.
+     * Automatically activates this shader program.
+     * @param {Record<string, any>} material - Variable values by variable name.
+     * @returns {ShaderProgram}
+     */
+    set(material: Record<string, any>): this;
+    /**
+     * Applies currently stored shader variable values.
+     */
+    apply(): void;
+    /**
+     * Draws indexed geometry from provided index buffer.
+     * @param {number} mode - WebGL draw mode.
+     * @param {WebGLBufferExt} buffer - Index buffer.
+     * @returns {ShaderProgram}
+     */
+    drawIndexBuffer(mode: number, buffer: WebGLBufferExt): this;
+    /**
+     * Draws non-indexed geometry.
+     * @param {number} mode - WebGL draw mode.
+     * @param {number} numItems - Vertex count to draw.
+     * @returns {ShaderProgram}
+     */
+    drawArrays(mode: number, numItems: number): this;
+    /**
+     * Check and log for a shader compile errors and warnings. Returns True - if no errors otherwise returns False.
+     * @private
+     * @param {WebGLShader} shader - WebGl shader program.
+     * @param {string} src - Shader program source.
+     * @returns {boolean} -
+     */
+    protected _getShaderCompileStatus(shader: WebGLShader, src: string): boolean;
+    /**
+     * Returns compiled vertex shader program pointer.
+     * @private
+     * @param {string} src - Vertex shader source code.
+     * @returns {Object} -
+     */
+    protected _createVertexShader(src: string): WebGLShader | undefined;
+    /**
+     * Returns compiled fragment shader program pointer.
+     * @private
+     * @param {string} src - Vertex shader source code.
+     * @returns {Object} -
+     */
+    protected _createFragmentShader(src: string): WebGLShader | undefined;
+    /**
+     * Disables all attribute arrays used by this shader program.
+     */
+    disableAttribArrays(): void;
+    /**
+     * Enables all attribute arrays used by this shader program.
+     */
+    enableAttribArrays(): void;
+    /**
+     * Deletes underlying WebGL program.
+     */
+    delete(): void;
+    /**
+     * Compiles shaders, links WebGL program and resolves variable locations.
+     * @param {WebGL2RenderingContext} gl - WebGL context.
+     */
+    createProgram(gl: WebGL2RenderingContext): void;
+}
+export { ShaderProgram };

package/lib/webgl/index.d.ts

@@ -2,6 +2,6 @@ import { Framebuffer } from "./Framebuffer";
 import { Handler } from "./Handler";
 import type { WebGLContextExt, WebGLBufferExt, WebGLTextureExt, ImageSource } from "./Handler";
 import { Multisample } from "./Multisample";
-import { Program } from "./Program";
+import { ShaderProgram } from "./ShaderProgram";
 import { types } from "./types";
-export { Framebuffer, Handler, Multisample, types, Program, WebGLContextExt, WebGLBufferExt, WebGLTextureExt, ImageSource };
+export { Framebuffer, Handler, Multisample, types, ShaderProgram, WebGLContextExt, WebGLBufferExt, WebGLTextureExt, ImageSource };

package/lib/webgl/variableHandlers.d.ts

@@ -2,6 +2,7 @@
  * @module og/webgl/variableHandlers
  */
 import type { WebGLBufferExt } from "./Handler";
+import type { WebGLTextureExt } from "./Handler";
 export type VariableHandler = {
     u: {
         [id: number]: Function;
@@ -14,7 +15,7 @@ export type ProgramVariable = {
     type: string | number;
     func: Function;
     _pName: WebGLUniformLocation | number;
-    value: number | Float32Array | Int32Array | WebGLBufferExt;
+    value: number | Float32Array | Int32Array | WebGLBufferExt | WebGLTextureExt | WebGLTextureExt[];
     itemType: string | number;
     normalized: boolean;
     divisor: number;