第五章 DOM接口 DOM Interfaces

第五章 DOM接口 DOM Interfaces

本章介绍在DOM上扩展的接口和功能,它们在运行时提供支持,从而可以访问到之前介绍的那些功能函数

5.1 类型 Types

下边的类型在所有接口中都有使用,所有这些接口将在后续章节中陆续介绍

typedef events::Event Event;

typedef html::HTMLCanvasElement HTMLCanvasElement;

typedef html::HTMLImageElement HTMLImageElement;

typedef html::HTMLVideoElement HTMLVideoElement;

typedef html::ImageData ImageData;

typedef unsigned long  GLenum;

typedef boolean        GLboolean;

typedef unsigned long  GLbitfield;

typedef byte           GLbyte;         /* 'byte' should be a signed 8 bit type. */

typedef short          GLshort;

typedef long           GLint;

typedef long           GLsizei;

typedef long long      GLintptr;

typedef long long      GLsizeiptr;

typedef unsigned byte  GLubyte;        /* 'unsigned byte' should be an unsigned 8 bit type. */

typedef unsigned short GLushort;

typedef unsigned long  GLuint;

typedef float          GLfloat;

typedef float          GLclampf; 

5.2 WebGLContextAttributes
WebGLContextAttributes接口包含了绘制表面的特性并且作为getContext方法的第二个参数.本地对象可能以该参数的形式提供,指定的特性可以通过本地对象获取到.

[Callback] interface WebGLContextAttributes {
attribute boolean alpha;
attribute boolean depth;
attribute boolean stencil;
attribute boolean antialias;
attribute boolean premultipliedAlpha;
attribute boolean preserveDrawingBuffer;
};

5.2.1 设备创建参数 Context creation parameters
下边列出了WebGLContextAttributes 对象的每一个特性及其使用方法,每个特性的默认值.
默认值的使用场景,1,使用getContext方法时没有传递第二个参数,2,访问本地对象相关属性性,本地对象不包含该属性,那么将返回默认值.
alpha
     默认值:true.当该值为真时,绘制缓冲将包含一个透明通道,为了操作OpenGL对象的透明通道和混合页面故.如果值为假,则没有透明通道.
depth
     默认为true,如果该值为真,则绘制缓冲将包含一个至少16位的深度缓冲区,如果为假则没有深度缓冲区
stencil
     默认为false,当该值为真时绘制缓冲区将包含一个至少8位的模板缓冲区,否则没有
antialias
     默认值:true,当该值为真且实现者支持抗锯齿,绘制缓冲将使用选择的抗锯齿技术和质量,如果该值为假或者实现者不支持时,将不执行抗锯齿操作.
premultipliedAlpha
     默认值为false,该值为false时,一旦绘制缓冲呈现后(绘制缓冲区一节中介绍的那样),缓冲区的值将被默认值覆盖,所有绘制缓冲都将被重置,包括颜色缓冲,深度缓冲和模板缓冲.如果该值为真,缓冲区的值不会被重置,这些值一直保留到清除或用户手动覆盖为止.

在某些硬件环境中设置该值为真将可能带来性能问题 例II Here is an ECMAScript example which passes a WebGLContextAttributes argument to getContext. It assumes the presence of a canvas element named "canvas1" on the page. var canvas = document.getElementById('canvas1'); var context = canvas.getContext('webgl', { antialias: false, stencil: true });

5.3 WebGLObject
WebGLObject 接口是所有GL对象的父接口

interface WebGLObject {

};

5.4 WebGLBuffer
WebGLBuffer 接口呈现一个OpenGL Buffer Object.创建该对象时调用glGenBuffers方法,绑定时使用glBindBuffer,删除时需要用glDeleteBuffers 方法

interface WebGLBuffer : WebGLObject {

};

5.5 WebGLFramebuffer
WebGLFramebuffer 接口呈现一个OpenGL Framebuffer Object,使用方法glGenFramebuffers创建,使用方法glGenFramebuffers绑定,销毁时使用方法glDeleteFramebuffers

interface WebGLFramebuffer : WebGLObject {

};

5.6 WebGLProgram
WebGLProgram 接口呈现OpenGL Program Object对象,创建时使用glCreateProgram 方法,使用时使用方法glUseProgram ,销毁时使用方法glDeleteProgram

interface WebGLProgram : WebGLObject {

};

5.7 WebGLRenderbuffer
WebGLRenderbuffer 呈现OpenGL Renderbuffer Object,使用glGenRenderbuffers 方法创建,绑定时使用方法glBindRenderbuffer ,删除用glDeleteRenderbuffers

interface WebGLRenderbuffer : WebGLObject {

};

5.8 WebGLShader
WebGLShader呈现OpenGL Shader Object,使用glCreateShader 创建,附加到Program对象时使用glAttachShader 方法,使用glDeleteShader 删除

interface WebGLShader : WebGLObject {

};

5.9 WebGLTexture
WebGLTexture接口呈现OpenGL Texture Object,使用glGenTextures 方法创建,glBindTexture 绑定,glDeleteTextures 删除

interface WebGLTexture : WebGLObject {

};

5.10 WebGLUniformLocation
WebGLUniformLocation接口在含阴影程序中使用一致的变量输出地址信息

interface WebGLUniformLocation {

};

5.11 WebGLActiveInfo
WebGLActiveInfo 对象通过调用方法getActiveAttrib 和getActiveUniform 返回

interface WebGLActiveInfo {

    readonly attribute GLint size;

    readonly attribute GLenum type;

    readonly attribute DOMString name;

};

5.11.1 Attributes 以下的属性有效:

size of type GLint

    The size of the requested variable.

type of type GLenum

    The data type of the requested variable.

name of type DOMString

    The name of the requested variable.

5.12 ArrayBuffer and Typed Arrays

顶点vertex,索引index,纹理texture和其它数据使用ArrayBuffer对象和视图views(在TypedArray中规范中定义)传递至WebGL的实现中.除了Float64Array外,所有的typed array views都可以同WebGL一起用,OpenGL ES 2.0WebGL,都不支持双精度浮点数double-precision floating-point data Typed Arrays支持交错模式顶点数据的创建,和异质模式顶点数据的创建,Typed Arrays还支持上传不同的数据块到大的顶点缓冲对象里,和其它OpenGL程序里经常要使用的场景
例III

Here is an ECMAScript example showing access to the same ArrayBuffer using different types of typed arrays. In this case the buffer contains a floating point vertex position (x, y, z) followed by a color as 4 unsigned bytes (r, g, b, a).

var numVertices = 100; // for example

// Compute the size needed for the buffer, in bytes and floats

var vertexSize = 3 * Float32Array.BYTES_PER_ELEMENT +

     4 * Uint8Array.BYTES_PER_ELEMENT;

var vertexSizeInFloats = vertexSize / Float32Array.BYTES_PER_ELEMENT;

// Allocate the buffer

var buf = new ArrayBuffer(numVertices * vertexSize);

// Map this buffer to a Float32Array to access the positions

var positionArray = new Float32Array(buf);

// Map the same buffer to a Uint8Array to access the color

var colorArray = new Uint8Array(buf);

// Set up the initial offset of the vertices and colors within the buffer

var positionIdx = 0;

var colorIdx = 3 * Float32Array.BYTES_PER_ELEMENT;

// Initialize the buffer

for (var i = 0; i < numVertices; i++) {

    positionArray[positionIdx] = ...;

    positionArray[positionIdx + 1] = ...;

    positionArray[positionIdx + 2] = ...;

    colorArray[colorIdx] = ...;

    colorArray[colorIdx + 1] = ...;

    colorArray[colorIdx + 2] = ...;

    colorArray[colorIdx + 3] = ...;

    positionIdx += vertexSizeInFloats;

    colorIdx += vertexSize;

}

5.13 The WebGL context
WebGLRenderingContext 对象承载了API,使得可以像OpenGL ES 2.0方式渲染到canvas 对象里

interface WebGLRenderingContext {

    /* ClearBufferMask */

    const GLenum DEPTH_BUFFER_BIT               = 0x00000100;

    const GLenum STENCIL_BUFFER_BIT             = 0x00000400;

    const GLenum COLOR_BUFFER_BIT               = 0x00004000;

    /* BeginMode */

    const GLenum POINTS                         = 0x0000;

    const GLenum LINES                          = 0x0001;

    const GLenum LINE_LOOP                      = 0x0002;

    const GLenum LINE_STRIP                     = 0x0003;

    const GLenum TRIANGLES                      = 0x0004;

    const GLenum TRIANGLE_STRIP                 = 0x0005;

    const GLenum TRIANGLE_FAN                   = 0x0006;

    /* AlphaFunction (not supported in ES20) */

    /*      NEVER */

    /*      LESS */

    /*      EQUAL */

    /*      LEQUAL */

    /*      GREATER */

    /*      NOTEQUAL */

    /*      GEQUAL */

    /*      ALWAYS */

    /* BlendingFactorDest */

    const GLenum ZERO                           = 0;

    const GLenum ONE                            = 1;

    const GLenum SRC_COLOR                      = 0x0300;

    const GLenum ONE_MINUS_SRC_COLOR            = 0x0301;

    const GLenum SRC_ALPHA                      = 0x0302;

    const GLenum ONE_MINUS_SRC_ALPHA            = 0x0303;

    const GLenum DST_ALPHA                      = 0x0304;

    const GLenum ONE_MINUS_DST_ALPHA            = 0x0305;

    /* BlendingFactorSrc */

    /*      ZERO */

    /*      ONE */

    const GLenum DST_COLOR                      = 0x0306;

    const GLenum ONE_MINUS_DST_COLOR            = 0x0307;

    const GLenum SRC_ALPHA_SATURATE             = 0x0308;

    /*      SRC_ALPHA */

    /*      ONE_MINUS_SRC_ALPHA */

    /*      DST_ALPHA */

    /*      ONE_MINUS_DST_ALPHA */

    /* BlendEquationSeparate */

    const GLenum FUNC_ADD                       = 0x8006;

    const GLenum BLEND_EQUATION                 = 0x8009;

    const GLenum BLEND_EQUATION_RGB             = 0x8009;   /* same as BLEND_EQUATION */

    const GLenum BLEND_EQUATION_ALPHA           = 0x883D;

    /* BlendSubtract */

    const GLenum FUNC_SUBTRACT                  = 0x800A;

    const GLenum FUNC_REVERSE_SUBTRACT          = 0x800B;

    /* Separate Blend Functions */

    const GLenum BLEND_DST_RGB                  = 0x80C8;

    const GLenum BLEND_SRC_RGB                  = 0x80C9;

    const GLenum BLEND_DST_ALPHA                = 0x80CA;

    const GLenum BLEND_SRC_ALPHA                = 0x80CB;

    const GLenum CONSTANT_COLOR                 = 0x8001;

    const GLenum ONE_MINUS_CONSTANT_COLOR       = 0x8002;

    const GLenum CONSTANT_ALPHA                 = 0x8003;

    const GLenum ONE_MINUS_CONSTANT_ALPHA       = 0x8004;

    const GLenum BLEND_COLOR                    = 0x8005;

    /* Buffer Objects */

    const GLenum ARRAY_BUFFER                   = 0x8892;

    const GLenum ELEMENT_ARRAY_BUFFER           = 0x8893;

    const GLenum ARRAY_BUFFER_BINDING           = 0x8894;

    const GLenum ELEMENT_ARRAY_BUFFER_BINDING   = 0x8895;

    const GLenum STREAM_DRAW                    = 0x88E0;

    const GLenum STATIC_DRAW                    = 0x88E4;

    const GLenum DYNAMIC_DRAW                   = 0x88E8;

    const GLenum BUFFER_SIZE                    = 0x8764;

    const GLenum BUFFER_USAGE                   = 0x8765;

    const GLenum CURRENT_VERTEX_ATTRIB          = 0x8626;

    /* CullFaceMode */

    const GLenum FRONT                          = 0x0404;

    const GLenum BACK                           = 0x0405;

    const GLenum FRONT_AND_BACK                 = 0x0408;

    /* DepthFunction */

    /*      NEVER */

    /*      LESS */

    /*      EQUAL */

    /*      LEQUAL */

    /*      GREATER */

    /*      NOTEQUAL */

    /*      GEQUAL */

    /*      ALWAYS */

    /* EnableCap */

    /* TEXTURE_2D */

    const GLenum CULL_FACE                      = 0x0B44;

    const GLenum BLEND                          = 0x0BE2;

    const GLenum DITHER                         = 0x0BD0;

    const GLenum STENCIL_TEST                   = 0x0B90;

    const GLenum DEPTH_TEST                     = 0x0B71;

    const GLenum SCISSOR_TEST                   = 0x0C11;

    const GLenum POLYGON_OFFSET_FILL            = 0x8037;

    const GLenum SAMPLE_ALPHA_TO_COVERAGE       = 0x809E;

    const GLenum SAMPLE_COVERAGE                = 0x80A0;

    /* ErrorCode */

    const GLenum NO_ERROR                       = 0;

    const GLenum INVALID_ENUM                   = 0x0500;

    const GLenum INVALID_VALUE                  = 0x0501;

    const GLenum INVALID_OPERATION              = 0x0502;

    const GLenum OUT_OF_MEMORY                  = 0x0505;

    /* FrontFaceDirection */

    const GLenum CW                             = 0x0900;

    const GLenum CCW                            = 0x0901;

    /* GetPName */

    const GLenum LINE_WIDTH                     = 0x0B21;

    const GLenum ALIASED_POINT_SIZE_RANGE       = 0x846D;

    const GLenum ALIASED_LINE_WIDTH_RANGE       = 0x846E;

    const GLenum CULL_FACE_MODE                 = 0x0B45;

    const GLenum FRONT_FACE                     = 0x0B46;

    const GLenum DEPTH_RANGE                    = 0x0B70;

    const GLenum DEPTH_WRITEMASK                = 0x0B72;

    const GLenum DEPTH_CLEAR_VALUE              = 0x0B73;

    const GLenum DEPTH_FUNC                     = 0x0B74;

    const GLenum STENCIL_CLEAR_VALUE            = 0x0B91;

    const GLenum STENCIL_FUNC                   = 0x0B92;

    const GLenum STENCIL_FAIL                   = 0x0B94;

    const GLenum STENCIL_PASS_DEPTH_FAIL        = 0x0B95;

    const GLenum STENCIL_PASS_DEPTH_PASS        = 0x0B96;

    const GLenum STENCIL_REF                    = 0x0B97;

    const GLenum STENCIL_VALUE_MASK             = 0x0B93;

    const GLenum STENCIL_WRITEMASK              = 0x0B98;

    const GLenum STENCIL_BACK_FUNC              = 0x8800;

    const GLenum STENCIL_BACK_FAIL              = 0x8801;

    const GLenum STENCIL_BACK_PASS_DEPTH_FAIL   = 0x8802;

    const GLenum STENCIL_BACK_PASS_DEPTH_PASS   = 0x8803;

    const GLenum STENCIL_BACK_REF               = 0x8CA3;

    const GLenum STENCIL_BACK_VALUE_MASK        = 0x8CA4;

    const GLenum STENCIL_BACK_WRITEMASK         = 0x8CA5;

    const GLenum VIEWPORT                       = 0x0BA2;

    const GLenum SCISSOR_BOX                    = 0x0C10;

    /*      SCISSOR_TEST */

    const GLenum COLOR_CLEAR_VALUE              = 0x0C22;

    const GLenum COLOR_WRITEMASK                = 0x0C23;

    const GLenum UNPACK_ALIGNMENT               = 0x0CF5;

    const GLenum PACK_ALIGNMENT                 = 0x0D05;

    const GLenum MAX_TEXTURE_SIZE               = 0x0D33;

    const GLenum MAX_VIEWPORT_DIMS              = 0x0D3A;

    const GLenum SUBPIXEL_BITS                  = 0x0D50;

    const GLenum RED_BITS                       = 0x0D52;

    const GLenum GREEN_BITS                     = 0x0D53;

    const GLenum BLUE_BITS                      = 0x0D54;

    const GLenum ALPHA_BITS                     = 0x0D55;

    const GLenum DEPTH_BITS                     = 0x0D56;

    const GLenum STENCIL_BITS                   = 0x0D57;

    const GLenum POLYGON_OFFSET_UNITS           = 0x2A00;

    /*      POLYGON_OFFSET_FILL */

    const GLenum POLYGON_OFFSET_FACTOR          = 0x8038;

    const GLenum TEXTURE_BINDING_2D             = 0x8069;

    const GLenum SAMPLE_BUFFERS                 = 0x80A8;

    const GLenum SAMPLES                        = 0x80A9;

    const GLenum SAMPLE_COVERAGE_VALUE          = 0x80AA;

    const GLenum SAMPLE_COVERAGE_INVERT         = 0x80AB;

    /* GetTextureParameter */

    /*      TEXTURE_MAG_FILTER */

    /*      TEXTURE_MIN_FILTER */

    /*      TEXTURE_WRAP_S */

    /*      TEXTURE_WRAP_T */

    const GLenum NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2;

    const GLenum COMPRESSED_TEXTURE_FORMATS     = 0x86A3;

    /* HintMode */

    const GLenum DONT_CARE                      = 0x1100;

    const GLenum FASTEST                        = 0x1101;

    const GLenum NICEST                         = 0x1102;

    /* HintTarget */

    const GLenum GENERATE_MIPMAP_HINT            = 0x8192;

    /* DataType */

    const GLenum BYTE                           = 0x1400;

    const GLenum UNSIGNED_BYTE                  = 0x1401;

    const GLenum SHORT                          = 0x1402;

    const GLenum UNSIGNED_SHORT                 = 0x1403;

    const GLenum INT                            = 0x1404;

    const GLenum UNSIGNED_INT                   = 0x1405;

    const GLenum FLOAT                          = 0x1406;

    /* PixelFormat */

    const GLenum DEPTH_COMPONENT                = 0x1902;

    const GLenum ALPHA                          = 0x1906;

    const GLenum RGB                            = 0x1907;

    const GLenum RGBA                           = 0x1908;

    const GLenum LUMINANCE                      = 0x1909;

    const GLenum LUMINANCE_ALPHA                = 0x190A;

    /* PixelType */

    /*      UNSIGNED_BYTE */

    const GLenum UNSIGNED_SHORT_4_4_4_4         = 0x8033;

    const GLenum UNSIGNED_SHORT_5_5_5_1         = 0x8034;

    const GLenum UNSIGNED_SHORT_5_6_5           = 0x8363;

    /* Shaders */

    const GLenum FRAGMENT_SHADER                  = 0x8B30;

    const GLenum VERTEX_SHADER                    = 0x8B31;

    const GLenum MAX_VERTEX_ATTRIBS               = 0x8869;

    const GLenum MAX_VERTEX_UNIFORM_VECTORS       = 0x8DFB;

    const GLenum MAX_VARYING_VECTORS              = 0x8DFC;

    const GLenum MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;

    const GLenum MAX_VERTEX_TEXTURE_IMAGE_UNITS   = 0x8B4C;

    const GLenum MAX_TEXTURE_IMAGE_UNITS          = 0x8872;

    const GLenum MAX_FRAGMENT_UNIFORM_VECTORS     = 0x8DFD;

    const GLenum SHADER_TYPE                      = 0x8B4F;

    const GLenum DELETE_STATUS                    = 0x8B80;

    const GLenum LINK_STATUS                      = 0x8B82;

    const GLenum VALIDATE_STATUS                  = 0x8B83;

    const GLenum ATTACHED_SHADERS                 = 0x8B85;

    const GLenum ACTIVE_UNIFORMS                  = 0x8B86;

    const GLenum ACTIVE_ATTRIBUTES                = 0x8B89;

    const GLenum SHADING_LANGUAGE_VERSION         = 0x8B8C;

    const GLenum CURRENT_PROGRAM                  = 0x8B8D;

    /* StencilFunction */

    const GLenum NEVER                          = 0x0200;

    const GLenum LESS                           = 0x0201;

    const GLenum EQUAL                          = 0x0202;

    const GLenum LEQUAL                         = 0x0203;

    const GLenum GREATER                        = 0x0204;

    const GLenum NOTEQUAL                       = 0x0205;

    const GLenum GEQUAL                         = 0x0206;

    const GLenum ALWAYS                         = 0x0207;

    /* StencilOp */

    /*      ZERO */

    const GLenum KEEP                           = 0x1E00;

    const GLenum REPLACE                        = 0x1E01;

    const GLenum INCR                           = 0x1E02;

    const GLenum DECR                           = 0x1E03;

    const GLenum INVERT                         = 0x150A;

    const GLenum INCR_WRAP                      = 0x8507;

    const GLenum DECR_WRAP                      = 0x8508;

    /* StringName */

    const GLenum VENDOR                         = 0x1F00;

    const GLenum RENDERER                       = 0x1F01;

    const GLenum VERSION                        = 0x1F02;

    /* TextureMagFilter */

    const GLenum NEAREST                        = 0x2600;

    const GLenum LINEAR                         = 0x2601;

    /* TextureMinFilter */

    /*      NEAREST */

    /*      LINEAR */

    const GLenum NEAREST_MIPMAP_NEAREST         = 0x2700;

    const GLenum LINEAR_MIPMAP_NEAREST          = 0x2701;

    const GLenum NEAREST_MIPMAP_LINEAR          = 0x2702;

    const GLenum LINEAR_MIPMAP_LINEAR           = 0x2703;

    /* TextureParameterName */

    const GLenum TEXTURE_MAG_FILTER             = 0x2800;

    const GLenum TEXTURE_MIN_FILTER             = 0x2801;

    const GLenum TEXTURE_WRAP_S                 = 0x2802;

    const GLenum TEXTURE_WRAP_T                 = 0x2803;

    /* TextureTarget */

    const GLenum TEXTURE_2D                     = 0x0DE1;

    const GLenum TEXTURE                        = 0x1702;

    const GLenum TEXTURE_CUBE_MAP               = 0x8513;

    const GLenum TEXTURE_BINDING_CUBE_MAP       = 0x8514;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_X    = 0x8515;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_X    = 0x8516;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_Y    = 0x8517;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Y    = 0x8518;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_Z    = 0x8519;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Z    = 0x851A;

    const GLenum MAX_CUBE_MAP_TEXTURE_SIZE      = 0x851C;

    /* TextureUnit */

    const GLenum TEXTURE0                       = 0x84C0;

    const GLenum TEXTURE1                       = 0x84C1;

    const GLenum TEXTURE2                       = 0x84C2;

    const GLenum TEXTURE3                       = 0x84C3;

    const GLenum TEXTURE4                       = 0x84C4;

    const GLenum TEXTURE5                       = 0x84C5;

    const GLenum TEXTURE6                       = 0x84C6;

    const GLenum TEXTURE7                       = 0x84C7;

    const GLenum TEXTURE8                       = 0x84C8;

    const GLenum TEXTURE9                       = 0x84C9;

    const GLenum TEXTURE10                      = 0x84CA;

    const GLenum TEXTURE11                      = 0x84CB;

    const GLenum TEXTURE12                      = 0x84CC;

    const GLenum TEXTURE13                      = 0x84CD;

    const GLenum TEXTURE14                      = 0x84CE;

    const GLenum TEXTURE15                      = 0x84CF;

    const GLenum TEXTURE16                      = 0x84D0;

    const GLenum TEXTURE17                      = 0x84D1;

    const GLenum TEXTURE18                      = 0x84D2;

    const GLenum TEXTURE19                      = 0x84D3;

    const GLenum TEXTURE20                      = 0x84D4;

    const GLenum TEXTURE21                      = 0x84D5;

    const GLenum TEXTURE22                      = 0x84D6;

    const GLenum TEXTURE23                      = 0x84D7;

    const GLenum TEXTURE24                      = 0x84D8;

    const GLenum TEXTURE25                      = 0x84D9;

    const GLenum TEXTURE26                      = 0x84DA;

    const GLenum TEXTURE27                      = 0x84DB;

    const GLenum TEXTURE28                      = 0x84DC;

    const GLenum TEXTURE29                      = 0x84DD;

    const GLenum TEXTURE30                      = 0x84DE;

    const GLenum TEXTURE31                      = 0x84DF;

    const GLenum ACTIVE_TEXTURE                 = 0x84E0;

    /* TextureWrapMode */

    const GLenum REPEAT                         = 0x2901;

    const GLenum CLAMP_TO_EDGE                  = 0x812F;

    const GLenum MIRRORED_REPEAT                = 0x8370;

    /* Uniform Types */

    const GLenum FLOAT_VEC2                     = 0x8B50;

    const GLenum FLOAT_VEC3                     = 0x8B51;

    const GLenum FLOAT_VEC4                     = 0x8B52;

    const GLenum INT_VEC2                       = 0x8B53;

    const GLenum INT_VEC3                       = 0x8B54;

    const GLenum INT_VEC4                       = 0x8B55;

    const GLenum BOOL                           = 0x8B56;

    const GLenum BOOL_VEC2                      = 0x8B57;

    const GLenum BOOL_VEC3                      = 0x8B58;

    const GLenum BOOL_VEC4                      = 0x8B59;

    const GLenum FLOAT_MAT2                     = 0x8B5A;

    const GLenum FLOAT_MAT3                     = 0x8B5B;

    const GLenum FLOAT_MAT4                     = 0x8B5C;

    const GLenum SAMPLER_2D                     = 0x8B5E;

    const GLenum SAMPLER_CUBE                   = 0x8B60;

    /* Vertex Arrays */

    const GLenum VERTEX_ATTRIB_ARRAY_ENABLED        = 0x8622;

    const GLenum VERTEX_ATTRIB_ARRAY_SIZE           = 0x8623;

    const GLenum VERTEX_ATTRIB_ARRAY_STRIDE         = 0x8624;

    const GLenum VERTEX_ATTRIB_ARRAY_TYPE           = 0x8625;

    const GLenum VERTEX_ATTRIB_ARRAY_NORMALIZED     = 0x886A;

    const GLenum VERTEX_ATTRIB_ARRAY_POINTER        = 0x8645;

    const GLenum VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;

    /* Shader Source */

    const GLenum COMPILE_STATUS                 = 0x8B81;

    /* Shader Precision-Specified Types */

    const GLenum LOW_FLOAT                      = 0x8DF0;

    const GLenum MEDIUM_FLOAT                   = 0x8DF1;

    const GLenum HIGH_FLOAT                     = 0x8DF2;

    const GLenum LOW_INT                        = 0x8DF3;

    const GLenum MEDIUM_INT                     = 0x8DF4;

    const GLenum HIGH_INT                       = 0x8DF5;

    /* Framebuffer Object. */

    const GLenum FRAMEBUFFER                    = 0x8D40;

    const GLenum RENDERBUFFER                   = 0x8D41;

    const GLenum RGBA4                          = 0x8056;

    const GLenum RGB5_A1                        = 0x8057;

    const GLenum RGB565                         = 0x8D62;

    const GLenum DEPTH_COMPONENT16              = 0x81A5;

    const GLenum STENCIL_INDEX                  = 0x1901;

    const GLenum STENCIL_INDEX8                 = 0x8D48;

    const GLenum DEPTH_STENCIL                  = 0x84F9;

    const GLenum RENDERBUFFER_WIDTH             = 0x8D42;

    const GLenum RENDERBUFFER_HEIGHT            = 0x8D43;

    const GLenum RENDERBUFFER_INTERNAL_FORMAT   = 0x8D44;

    const GLenum RENDERBUFFER_RED_SIZE          = 0x8D50;

    const GLenum RENDERBUFFER_GREEN_SIZE        = 0x8D51;

    const GLenum RENDERBUFFER_BLUE_SIZE         = 0x8D52;

    const GLenum RENDERBUFFER_ALPHA_SIZE        = 0x8D53;

    const GLenum RENDERBUFFER_DEPTH_SIZE        = 0x8D54;

    const GLenum RENDERBUFFER_STENCIL_SIZE      = 0x8D55;

    const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE           = 0x8CD0;

    const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_NAME           = 0x8CD1;

    const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL         = 0x8CD2;

    const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;

    const GLenum COLOR_ATTACHMENT0              = 0x8CE0;

    const GLenum DEPTH_ATTACHMENT               = 0x8D00;

    const GLenum STENCIL_ATTACHMENT             = 0x8D20;

    const GLenum DEPTH_STENCIL_ATTACHMENT       = 0x821A;

    const GLenum NONE                           = 0;

    const GLenum FRAMEBUFFER_COMPLETE                      = 0x8CD5;

    const GLenum FRAMEBUFFER_INCOMPLETE_ATTACHMENT         = 0x8CD6;

    const GLenum FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;

    const GLenum FRAMEBUFFER_INCOMPLETE_DIMENSIONS         = 0x8CD9;

    const GLenum FRAMEBUFFER_UNSUPPORTED                   = 0x8CDD;

    const GLenum FRAMEBUFFER_BINDING            = 0x8CA6;

    const GLenum RENDERBUFFER_BINDING           = 0x8CA7;

    const GLenum MAX_RENDERBUFFER_SIZE          = 0x84E8;

    const GLenum INVALID_FRAMEBUFFER_OPERATION  = 0x0506;

    /* WebGL-specific enums */

    const GLenum UNPACK_FLIP_Y_WEBGL            = 0x9240;

    const GLenum UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241;

    const GLenum CONTEXT_LOST_WEBGL             = 0x9242;

    const GLenum UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243;

    const GLenum BROWSER_DEFAULT_WEBGL          = 0x9244;

    readonly attribute HTMLCanvasElement canvas;

    readonly attribute GLsizei drawingBufferWidth;

    readonly attribute GLsizei drawingBufferHeight;

    WebGLContextAttributes getContextAttributes();

    boolean isContextLost();

    DOMString[ ] getSupportedExtensions();

    object getExtension(DOMString name);

    void activeTexture(GLenum texture);

    void attachShader(WebGLProgram program, WebGLShader shader);

    void bindAttribLocation(WebGLProgram program, GLuint index, DOMString name);

    void bindBuffer(GLenum target, WebGLBuffer buffer);

    void bindFramebuffer(GLenum target, WebGLFramebuffer framebuffer);

    void bindRenderbuffer(GLenum target, WebGLRenderbuffer renderbuffer);

    void bindTexture(GLenum target, WebGLTexture texture);

    void blendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

    void blendEquation(GLenum mode);

    void blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);

    void blendFunc(GLenum sfactor, GLenum dfactor);

    void blendFuncSeparate(GLenum srcRGB, GLenum dstRGB,

                           GLenum srcAlpha, GLenum dstAlpha);

    void bufferData(GLenum target, GLsizeiptr size, GLenum usage);

    void bufferData(GLenum target, ArrayBufferView data, GLenum usage);

    void bufferData(GLenum target, ArrayBuffer data, GLenum usage);

    void bufferSubData(GLenum target, GLintptr offset, ArrayBufferView data);

    void bufferSubData(GLenum target, GLintptr offset, ArrayBuffer data);

    GLenum checkFramebufferStatus(GLenum target);

    void clear(GLbitfield mask);

    void clearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

    void clearDepth(GLclampf depth);

    void clearStencil(GLint s);

    void colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

    void compileShader(WebGLShader shader);

    void copyTexImage2D(GLenum target, GLint level, GLenum internalformat,

                        GLint x, GLint y, GLsizei width, GLsizei height,

                        GLint border);

    void copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                           GLint x, GLint y, GLsizei width, GLsizei height);

    WebGLBuffer createBuffer();

    WebGLFramebuffer createFramebuffer();

    WebGLProgram createProgram();

    WebGLRenderbuffer createRenderbuffer();

    WebGLShader createShader(GLenum type);

    WebGLTexture createTexture();

    void cullFace(GLenum mode);

    void deleteBuffer(WebGLBuffer buffer);

    void deleteFramebuffer(WebGLFramebuffer framebuffer);

    void deleteProgram(WebGLProgram program);

    void deleteRenderbuffer(WebGLRenderbuffer renderbuffer);

    void deleteShader(WebGLShader shader);

    void deleteTexture(WebGLTexture texture);

    void depthFunc(GLenum func);

    void depthMask(GLboolean flag);

    void depthRange(GLclampf zNear, GLclampf zFar);

    void detachShader(WebGLProgram program, WebGLShader shader);

    void disable(GLenum cap);

    void disableVertexAttribArray(GLuint index);

    void drawArrays(GLenum mode, GLint first, GLsizei count);

    void drawElements(GLenum mode, GLsizei count, GLenum type, GLintptr offset);

    void enable(GLenum cap);

    void enableVertexAttribArray(GLuint index);

    void finish();

    void flush();

    void framebufferRenderbuffer(GLenum target, GLenum attachment,

                                 GLenum renderbuffertarget,

                                 WebGLRenderbuffer renderbuffer);

    void framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget,

                              WebGLTexture texture, GLint level);

    void frontFace(GLenum mode);

    void generateMipmap(GLenum target);

    WebGLActiveInfo getActiveAttrib(WebGLProgram program, GLuint index);

    WebGLActiveInfo getActiveUniform(WebGLProgram program, GLuint index);

    WebGLShader[ ] getAttachedShaders(WebGLProgram program);

    GLint getAttribLocation(WebGLProgram program, DOMString name);

    any getParameter(GLenum pname);

    any getBufferParameter(GLenum target, GLenum pname);

    GLenum getError();

    any getFramebufferAttachmentParameter(GLenum target, GLenum attachment,

                                          GLenum pname);

    any getProgramParameter(WebGLProgram program, GLenum pname);

    DOMString getProgramInfoLog(WebGLProgram program);

    any getRenderbufferParameter(GLenum target, GLenum pname);

    any getShaderParameter(WebGLShader shader, GLenum pname);

    DOMString getShaderInfoLog(WebGLShader shader);

    DOMString getShaderSource(WebGLShader shader);

    any getTexParameter(GLenum target, GLenum pname);

    any getUniform(WebGLProgram program, WebGLUniformLocation location);

    WebGLUniformLocation getUniformLocation(WebGLProgram program, DOMString name);

    any getVertexAttrib(GLuint index, GLenum pname);

    GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname);

    void hint(GLenum target, GLenum mode);

    GLboolean isBuffer(WebGLBuffer buffer);

    GLboolean isEnabled(GLenum cap);

    GLboolean isFramebuffer(WebGLFramebuffer framebuffer);

    GLboolean isProgram(WebGLProgram program);

    GLboolean isRenderbuffer(WebGLRenderbuffer renderbuffer);

    GLboolean isShader(WebGLShader shader);

    GLboolean isTexture(WebGLTexture texture);

    void lineWidth(GLfloat width);

    void linkProgram(WebGLProgram program);

    void pixelStorei(GLenum pname, GLint param);

    void polygonOffset(GLfloat factor, GLfloat units);

    void readPixels(GLint x, GLint y, GLsizei width, GLsizei height,

                    GLenum format, GLenum type, ArrayBufferView pixels);

    void renderbufferStorage(GLenum target, GLenum internalformat,

                             GLsizei width, GLsizei height);

    void sampleCoverage(GLclampf value, GLboolean invert);

    void scissor(GLint x, GLint y, GLsizei width, GLsizei height);

    void shaderSource(WebGLShader shader, DOMString source);

    void stencilFunc(GLenum func, GLint ref, GLuint mask);

    void stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);

    void stencilMask(GLuint mask);

    void stencilMaskSeparate(GLenum face, GLuint mask);

    void stencilOp(GLenum fail, GLenum zfail, GLenum zpass);

    void stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);

    void texImage2D(GLenum target, GLint level, GLenum internalformat,

                    GLsizei width, GLsizei height, GLint border, GLenum format,

                    GLenum type, ArrayBufferView pixels);

    void texImage2D(GLenum target, GLint level, GLenum internalformat,

                    GLenum format, GLenum type, ImageData pixels);

    void texImage2D(GLenum target, GLint level, GLenum internalformat,

                    GLenum format, GLenum type, HTMLImageElement image);

    void texImage2D(GLenum target, GLint level, GLenum internalformat,

                    GLenum format, GLenum type, HTMLCanvasElement canvas);

    void texImage2D(GLenum target, GLint level, GLenum internalformat,

                    GLenum format, GLenum type, HTMLVideoElement video);

    void texParameterf(GLenum target, GLenum pname, GLfloat param);

    void texParameteri(GLenum target, GLenum pname, GLint param);

    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                       GLsizei width, GLsizei height,

                       GLenum format, GLenum type, ArrayBufferView pixels);

    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                       GLenum format, GLenum type, ImageData pixels);

    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                       GLenum format, GLenum type, HTMLImageElement image);

    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                       GLenum format, GLenum type, HTMLCanvasElement canvas);

    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                       GLenum format, GLenum type, HTMLVideoElement video);

    void uniform1f(WebGLUniformLocation location, GLfloat x);

    void uniform1fv(WebGLUniformLocation location, Float32Array v);

    void uniform1fv(WebGLUniformLocation location, float[] v);

    void uniform1i(WebGLUniformLocation location, GLint x);

    void uniform1iv(WebGLUniformLocation location, Int32Array v);

    void uniform1iv(WebGLUniformLocation location, long[] v);

    void uniform2f(WebGLUniformLocation location, GLfloat x, GLfloat y);

    void uniform2fv(WebGLUniformLocation location, Float32Array v);

    void uniform2fv(WebGLUniformLocation location, float[] v);

    void uniform2i(WebGLUniformLocation location, GLint x, GLint y);

    void uniform2iv(WebGLUniformLocation location, Int32Array v);

    void uniform2iv(WebGLUniformLocation location, long[] v);

    void uniform3f(WebGLUniformLocation location, GLfloat x, GLfloat y, GLfloat z);

    void uniform3fv(WebGLUniformLocation location, Float32Array v);

    void uniform3fv(WebGLUniformLocation location, float[] v);

    void uniform3i(WebGLUniformLocation location, GLint x, GLint y, GLint z);

    void uniform3iv(WebGLUniformLocation location, Int32Array v);

    void uniform3iv(WebGLUniformLocation location, long[] v);

    void uniform4f(WebGLUniformLocation location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    void uniform4fv(WebGLUniformLocation location, Float32Array v);

    void uniform4fv(WebGLUniformLocation location, float[] v);

    void uniform4i(WebGLUniformLocation location, GLint x, GLint y, GLint z, GLint w);

    void uniform4iv(WebGLUniformLocation location, Int32Array v);

    void uniform4iv(WebGLUniformLocation location, long[] v);

    void uniformMatrix2fv(WebGLUniformLocation location, GLboolean transpose,

                          Float32Array value);

    void uniformMatrix2fv(WebGLUniformLocation location, GLboolean transpose,

                          float[] value);

    void uniformMatrix3fv(WebGLUniformLocation location, GLboolean transpose,

                          Float32Array value);

    void uniformMatrix3fv(WebGLUniformLocation location, GLboolean transpose,

                          float[] value);

    void uniformMatrix4fv(WebGLUniformLocation location, GLboolean transpose,

                          Float32Array value);

    void uniformMatrix4fv(WebGLUniformLocation location, GLboolean transpose,

                          float[] value);

    void useProgram(WebGLProgram program);

    void validateProgram(WebGLProgram program);

    void vertexAttrib1f(GLuint indx, GLfloat x);

    void vertexAttrib1fv(GLuint indx, Float32Array values);

    void vertexAttrib1fv(GLuint indx, float[] values);

    void vertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);

    void vertexAttrib2fv(GLuint indx, Float32Array values);

    void vertexAttrib2fv(GLuint indx, float[] values);

    void vertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);

    void vertexAttrib3fv(GLuint indx, Float32Array values);

    void vertexAttrib3fv(GLuint indx, float[] values);

    void vertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    void vertexAttrib4fv(GLuint indx, Float32Array values);

    void vertexAttrib4fv(GLuint indx, float[] values);

    void vertexAttribPointer(GLuint indx, GLint size, GLenum type,

                             GLboolean normalized, GLsizei stride, GLintptr offset);

    void viewport(GLint x, GLint y, GLsizei width, GLsizei height);

};