// Copyright (c) 2011-2012 Turbulenz Limited
/*global TurbulenzEngine*/
/*global TGALoader*/
/*global DDSLoader*/
/*global TARLoader*/
/*global Int8Array*/
/*global Int16Array*/
/*global Int32Array*/
/*global Uint8Array*/
/*global Uint8ClampedArray*/
/*global Uint16Array*/
/*global Uint32Array*/
/*global Float32Array*/
/*global ArrayBuffer*/
/*global DataView*/
/*global window*/
"use strict";

//
// WebGLTexture
//
function WebGLTexture() {}
WebGLTexture.prototype =
{
    version : 1,

    setData : function textureSetDataFn(data)
    {
        var gd = this.gd;
        var target = this.target;
        gd.bindTexture(target, this.glTexture);
        this.updateData(data);
        gd.bindTexture(target, null);
    },

    // Internal
    createGLTexture : function createGLTextureFn(data)
    {
        var gd = this.gd;
        var gl = gd.gl;

        var target;
        if (this.cubemap)
        {
            target = gl.TEXTURE_CUBE_MAP;
        }
        else if (this.depth > 1)
        {
            //target = gl.TEXTURE_3D;
            // 3D textures are not supported yet
            return false;
        }
        else
        {
            target = gl.TEXTURE_2D;
        }
        this.target = target;

        var gltex = gl.createTexture();
        this.glTexture = gltex;

        gd.bindTexture(target, gltex);

        gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, gl.LINEAR);

        if (this.mipmaps || 1 < this.numDataLevels)
        {
            gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_NEAREST);
        }
        else
        {
            gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
        }

        this.updateData(data);

        gd.bindTexture(target, null);

        return true;
    },

    updateData : function updateDataFn(data)
    {
        var gd = this.gd;
        var gl = gd.gl;

        function log2(a)
        {
            return Math.floor(Math.log(a) / Math.log(2));
        }

        var generateMipMaps = this.mipmaps && (this.numDataLevels !== (1 + Math.max(log2(this.width), log2(this.height))));
        var format = this.format;
        var internalFormat, gltype, srcStep, bufferData = null;
        var compressedTexturesExtension;

        if (format === gd.PIXELFORMAT_A8)
        {
            internalFormat = gl.ALPHA;
            gltype = gl.UNSIGNED_BYTE;
            srcStep = 1;
            if (data && !data.src)
            {
                if (data instanceof Uint8Array)
                {
                    bufferData = data;
                }
                else
                {
                    bufferData = new Uint8Array(data);
                }
            }
        }
        else if (format === gd.PIXELFORMAT_L8)
        {
            internalFormat = gl.LUMINANCE;
            gltype = gl.UNSIGNED_BYTE;
            srcStep = 1;
            if (data && !data.src)
            {
                if (data instanceof Uint8Array)
                {
                    bufferData = data;
                }
                else
                {
                    bufferData = new Uint8Array(data);
                }
            }
        }
        else if (format === gd.PIXELFORMAT_L8A8)
        {
            internalFormat = gl.LUMINANCE_ALPHA;
            gltype = gl.UNSIGNED_BYTE;
            srcStep = 2;
            if (data && !data.src)
            {
                if (data instanceof Uint8Array)
                {
                    bufferData = data;
                }
                else
                {
                    bufferData = new Uint8Array(data);
                }
            }
        }
        else if (format === gd.PIXELFORMAT_R5G5B5A1)
        {
            internalFormat = gl.RGBA;
            gltype = gl.UNSIGNED_SHORT_5_5_5_1;
            srcStep = 1;
            if (data && !data.src)
            {
                if (data instanceof Uint16Array)
                {
                    bufferData = data;
                }
                else
                {
                    bufferData = new Uint16Array(data);
                }
            }
        }
        else if (format === gd.PIXELFORMAT_R5G6B5)
        {
            internalFormat = gl.RGB;
            gltype = gl.UNSIGNED_SHORT_5_6_5;
            srcStep = 1;
            if (data && !data.src)
            {
                if (data instanceof Uint16Array)
                {
                    bufferData = data;
                }
                else
                {
                    bufferData = new Uint16Array(data);
                }
            }
        }
        else if (format === gd.PIXELFORMAT_R8G8B8A8)
        {
            internalFormat = gl.RGBA;
            gltype = gl.UNSIGNED_BYTE;
            srcStep = 4;
            if (data && !data.src)
            {
                if (data instanceof Uint8Array)
                {
                    // Some browsers consider Uint8ClampedArray to be
                    // an instance of Uint8Array (which is correct as
                    // per the spec), yet won't accept a
                    // Uint8ClampedArray as pixel data for a
                    // gl.UNSIGNED_BYTE Texture.  If we have a
                    // Uint8ClampedArray then we can just reuse the
                    // underlying data.

                    if (typeof Uint8ClampedArray !== "undefined" &&
                        data instanceof Uint8ClampedArray)
                    {
                        bufferData = new Uint8Array(data.buffer);
                    }
                    else
                    {
                        bufferData = data;
                    }
                }
                else
                {
                    bufferData = new Uint8Array(data);
                }
            }
        }
        else if (format === gd.PIXELFORMAT_R8G8B8)
        {
            internalFormat = gl.RGB;
            gltype = gl.UNSIGNED_BYTE;
            srcStep = 3;
            if (data && !data.src)
            {
                if (data instanceof Uint8Array)
                {
                    // See comment above about Uint8ClampedArray

                    if (typeof Uint8ClampedArray !== "undefined" &&
                        data instanceof Uint8ClampedArray)
                    {
                        bufferData = new Uint8Array(data.buffer);
                    }
                    else
                    {
                        bufferData = data;
                    }
                }
                else
                {
                    bufferData = new Uint8Array(data);
                }
            }
        }
        else if (format === gd.PIXELFORMAT_D24S8)
        {
            //internalFormat = gl.DEPTH24_STENCIL8_EXT;
            //gltype = gl.UNSIGNED_INT_24_8_EXT;
            //internalFormat = gl.DEPTH_COMPONENT;
            internalFormat = gl.DEPTH_STENCIL;
            gltype = gl.UNSIGNED_INT;
            srcStep = 1;
            if (data && !data.src)
            {
                bufferData = new Uint32Array(data);
            }
        }
        else if (format === gd.PIXELFORMAT_DXT1 ||
                 format === gd.PIXELFORMAT_DXT3 ||
                 format === gd.PIXELFORMAT_DXT5)
        {
            compressedTexturesExtension = gd.compressedTexturesExtension;
            if (compressedTexturesExtension)
            {
                if (format === gd.PIXELFORMAT_DXT1)
                {
                    internalFormat = compressedTexturesExtension.COMPRESSED_RGBA_S3TC_DXT1_EXT;
                    srcStep = 8;
                }
                else if (format === gd.PIXELFORMAT_DXT3)
                {
                    internalFormat = compressedTexturesExtension.COMPRESSED_RGBA_S3TC_DXT3_EXT;
                    srcStep = 16;
                }
                else //if (format === gd.PIXELFORMAT_DXT5)
                {
                    internalFormat = compressedTexturesExtension.COMPRESSED_RGBA_S3TC_DXT5_EXT;
                    srcStep = 16;
                }

                if (internalFormat === undefined)
                {
                    return; // Unsupported format
                }

                if (data && !data.src)
                {
                    if (data instanceof Uint8Array)
                    {
                        bufferData = data;
                    }
                    else
                    {
                        bufferData = new Uint8Array(data);
                    }
                }
            }
            else
            {
                return;   // Unsupported format
            }
        }
        else
        {
            return;   //unknown/unsupported format
        }

        var numLevels = (data && 0 < this.numDataLevels ? this.numDataLevels : 1);
        var w = this.width, h = this.height, offset = 0, target, n, levelSize, levelData;
        if (this.cubemap)
        {
            target = gl.TEXTURE_CUBE_MAP;
            gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
            gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);

            for (var f = 0; f < 6; f += 1)
            {
                var faceTarget = (gl.TEXTURE_CUBE_MAP_POSITIVE_X + f);
                for (n = 0; n < numLevels; n += 1)
                {
                    if (compressedTexturesExtension)
                    {
                        levelSize = (Math.floor((w + 3) / 4) * Math.floor((h + 3) / 4) * srcStep);
                        if (bufferData)
                        {
                            if (numLevels === 1)
                            {
                                levelData = bufferData;
                            }
                            else
                            {
                                levelData = bufferData.subarray(offset, (offset + levelSize));
                            }
                        }
                        else
                        {
                            levelData = new Uint8Array(levelSize);
                        }
                        if (gd.WEBGL_compressed_texture_s3tc)
                        {
                            gl.compressedTexImage2D(faceTarget, n, internalFormat, w, h, 0,
                                                    levelData);
                        }
                        else
                        {
                            compressedTexturesExtension.compressedTexImage2D(faceTarget, n, internalFormat, w, h, 0,
                                                                             levelData);
                        }
                    }
                    else
                    {
                        levelSize = (w * h * srcStep);
                        if (bufferData)
                        {
                            if (numLevels === 1)
                            {
                                levelData = bufferData;
                            }
                            else
                            {
                                levelData = bufferData.subarray(offset, (offset + levelSize));
                            }
                            gl.texImage2D(faceTarget, n, internalFormat, w, h, 0, internalFormat, gltype, levelData);
                        }
                        else if (data)
                        {
                            gl.texImage2D(faceTarget, n, internalFormat, internalFormat, gltype, data);
                        }
                        else
                        {
                            gl.texImage2D(faceTarget, n, internalFormat, w, h, 0, internalFormat, gltype,
                                          new Uint8Array(levelSize));
                        }
                    }
                    offset += levelSize;
                    w = (w > 1 ? Math.floor(w / 2) : 1);
                    h = (h > 1 ? Math.floor(h / 2) : 1);
                }
                w = this.width;
                h = this.height;
            }
        }
        else
        {
            target = gl.TEXTURE_2D;
            gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
            gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);

            for (n = 0; n < numLevels; n += 1)
            {
                if (compressedTexturesExtension)
                {
                    levelSize = (Math.floor((w + 3) / 4) * Math.floor((h + 3) / 4) * srcStep);
                    if (bufferData)
                    {
                        if (numLevels === 1)
                        {
                            levelData = bufferData;
                        }
                        else
                        {
                            levelData = bufferData.subarray(offset, (offset + levelSize));
                        }
                    }
                    else
                    {
                        levelData = new Uint8Array(levelSize);
                    }
                    if (gd.WEBGL_compressed_texture_s3tc)
                    {
                        gl.compressedTexImage2D(target, n, internalFormat, w, h, 0, levelData);
                    }
                    else
                    {
                        compressedTexturesExtension.compressedTexImage2D(target, n, internalFormat, w, h, 0, levelData);
                    }
                }
                else
                {
                    levelSize = (w * h * srcStep);
                    if (bufferData)
                    {
                        if (numLevels === 1)
                        {
                            levelData = bufferData;
                        }
                        else
                        {
                            levelData = bufferData.subarray(offset, (offset + levelSize));
                        }
                        gl.texImage2D(target, n, internalFormat, w, h, 0, internalFormat, gltype, levelData);
                    }
                    else if (data)
                    {
                        gl.texImage2D(target, n, internalFormat, internalFormat, gltype, data);
                    }
                    else
                    {
                        gl.texImage2D(target, n, internalFormat, w, h, 0, internalFormat, gltype,
                                      new Uint8Array(levelSize));
                    }
                }
                offset += levelSize;
                w = (w > 1 ? Math.floor(w / 2) : 1);
                h = (h > 1 ? Math.floor(h / 2) : 1);
            }
        }

        if (generateMipMaps)
        {
            gl.generateMipmap(target);
        }
    },

    updateMipmaps : function updateMipmapsFn(face)
    {
        if (this.mipmaps)
        {
            if (this.depth > 1)
            {
                TurbulenzEngine.callOnError(
                    "3D texture mipmap generation unsupported");
                return;
            }

            if (this.cubemap && face !== 5)
            {
                return;
            }

            var gd = this.gd;
            var gl = gd.gl;

            var target = this.target;
            gd.bindTexture(target, this.glTexture);
            gl.generateMipmap(target);
            gd.bindTexture(target, null);
        }
    },

    destroy : function textureDestroyFn()
    {
        var gd = this.gd;
        if (gd)
        {
            var glTexture = this.glTexture;
            if (glTexture)
            {
                var gl = gd.gl;
                if (gl)
                {
                    gd.unbindTexture(glTexture);
                    gl.deleteTexture(glTexture);
                }
                delete this.glTexture;
            }

            delete this.sampler;
            delete this.gd;
        }
    },

    typedArrayIsValid : function textureTypedArrayIsValidFn(typedArray)
    {
        var gd = this.gd;
        var format = this.format;

        if (gd)
        {
            if ((format === gd.PIXELFORMAT_A8) ||
                (format === gd.PIXELFORMAT_L8) ||
                (format === gd.PIXELFORMAT_S8))
            {
                return ((typedArray instanceof Uint8Array) ||
                        (typeof Uint8ClampedArray !== "undefined" &&
                         typedArray instanceof Uint8ClampedArray)) &&
                    (typedArray.length ===
                     this.width * this.height * this.depth);
            }
            if (format === gd.PIXELFORMAT_L8A8)
            {
                return ((typedArray instanceof Uint8Array) ||
                        (typeof Uint8ClampedArray !== "undefined" &&
                         typedArray instanceof Uint8ClampedArray)) &&
                    (typedArray.length ===
                     2 * this.width * this.height * this.depth);
            }
            if (format === gd.PIXELFORMAT_R8G8B8)
            {
                return ((typedArray instanceof Uint8Array) ||
                        (typeof Uint8ClampedArray !== "undefined" &&
                         typedArray instanceof Uint8ClampedArray)) &&
                    (typedArray.length ===
                     3 * this.width * this.height * this.depth);
            }
            if (format === gd.PIXELFORMAT_R8G8B8A8)
            {
                return ((typedArray instanceof Uint8Array) ||
                        (typeof Uint8ClampedArray !== "undefined" &&
                         typedArray instanceof Uint8ClampedArray)) &&
                    (typedArray.length ===
                     4 * this.width * this.height * this.depth);
            }
            if ((format === gd.PIXELFORMAT_R5G5B5A1) ||
                (format === gd.PIXELFORMAT_R5G6B5))
            {
                return (typedArray instanceof Uint16Array) &&
                    (typedArray.length ===
                     this.width * this.height * this.depth);
            }
        }
        return false;
    }
};

// Constructor function
WebGLTexture.create = function webGLTextureCreateFn(gd, params)
{
    var tex = new WebGLTexture();
    tex.gd = gd;
    tex.mipmaps = params.mipmaps;
    tex.dynamic = params.dynamic;
    tex.renderable = params.renderable;
    tex.numDataLevels = 0;

    var src = params.src;
    if (src)
    {
        tex.name = params.name || src;
        var extension;
        var data = params.data;
        if (data)
        {
            // do not trust file extensions if we got data...
            if (data[0] === 137 &&
                data[1] === 80 &&
                data[2] === 78 &&
                data[3] === 71)
            {
                extension = '.png';
            }
            else if (data[0] === 255 &&
                     data[1] === 216 &&
                     data[2] === 255 &&
                     (data[3] === 224 || data[3] === 225))
            {
                extension = '.jpg';
            }
            else if (data[0] === 68 &&
                     data[1] === 68 &&
                     data[2] === 83 &&
                     data[3] === 32)
            {
                extension = '.dds';
            }
            else
            {
                extension = src.slice(-4);
            }
        }
        else
        {
            extension = src.slice(-4);
        }

        // DDS and TGA textures require out own image loaders
        if (extension === '.dds' ||
            extension === '.tga')
        {
            if (extension === '.tga' && typeof TGALoader !== 'undefined')
            {
                var tgaParams = {
                    gd: gd,
                    onload : function tgaLoadedFn(data, width, height, format, status)
                    {
                        tex.width = width;
                        tex.height = height;
                        tex.depth = 1;
                        tex.format = format;
                        tex.cubemap = false;
                        var result = tex.createGLTexture(data);
                        if (params.onload)
                        {
                            params.onload(result ? tex : null, status);
                        }
                    },
                    onerror : function tgaFailedFn()
                    {
                        tex.failed = true;
                        if (params.onload)
                        {
                            params.onload(null);
                        }
                    }
                };
                if (data)
                {
                    tgaParams.data = data;
                }
                else
                {
                    tgaParams.src = src;
                }
                TGALoader.create(tgaParams);
                return tex;
            }
            else if (extension === '.dds' && typeof DDSLoader !== 'undefined')
            {
                var ddsParams = {
                    gd: gd,
                    onload : function ddsLoadedFn(data, width, height, format, numLevels, cubemap, depth, status)
                    {
                        tex.width = width;
                        tex.height = height;
                        tex.format = format;
                        tex.cubemap = cubemap;
                        tex.depth = depth;
                        tex.numDataLevels = numLevels;
                        var result = tex.createGLTexture(data);
                        if (params.onload)
                        {
                            params.onload(result ? tex : null, status);
                        }
                    },
                    onerror : function ddsFailedFn()
                    {
                        tex.failed = true;
                        if (params.onload)
                        {
                            params.onload(null);
                        }
                    }
                };
                if (data)
                {
                    ddsParams.data = data;
                }
                else
                {
                    ddsParams.src = src;
                }
                DDSLoader.create(ddsParams);
                return tex;
            }
            else
            {
                TurbulenzEngine.callOnError(
                    'Missing image loader required for ' + src);

                tex = webGLTextureCreateFn(gd, {
                    name    : (params.name || src),
                    width   : 2,
                    height  : 2,
                    depth   : 1,
                    format  : 'R8G8B8A8',
                    cubemap : false,
                    mipmaps : params.mipmaps,
                    dynamic : params.dynamic,
                    renderable : params.renderable,
                    data    : [255,  20, 147, 255,
                               255,   0,   0, 255,
                               255, 255, 255, 255,
                               255,  20, 147, 255]
                });

                if (params.onload)
                {
                    if (TurbulenzEngine)
                    {
                        TurbulenzEngine.setTimeout(function () {
                            params.onload(tex, 200);
                        }, 0);
                    }
                    else
                    {
                        window.setTimeout(function () {
                            params.onload(tex, 200);
                        }, 0);
                    }
                }
                return tex;
            }
        }

        var img = new Image();
        img.onload = function imageLoadedFn()
        {
            tex.width = img.width;
            tex.height = img.height;
            tex.depth = 1;
            tex.format = gd.PIXELFORMAT_R8G8B8A8;
            tex.cubemap = false;
            var result = tex.createGLTexture(img);
            if (params.onload)
            {
                params.onload(result ? tex : null, 200);
            }
        };
        img.onerror = function imageFailedFn()
        {
            tex.failed = true;
            if (params.onload)
            {
                params.onload(null);
            }
        };
        if (data)
        {
            if (extension === '.jpg' || extension === '.jpeg')
            {
                src = 'data:image/jpeg;base64,' + TurbulenzEngine.base64Encode(data);
            }
            else if (extension === '.png')
            {
                src = 'data:image/png;base64,' + TurbulenzEngine.base64Encode(data);
            }
        }
        else
        {
            img.crossOrigin = 'anonymous';
        }
        img.src = src;
    }
    else
    {
        // Invalid src values like "" fall through to here
        if ("" === src && params.onload)
        {
            // Assume the caller intended to pass in a valid url.
            return null;
        }

        var format = params.format;
        if (typeof format === 'string')
        {
            format = gd['PIXELFORMAT_' + format];
        }

        tex.width = params.width;
        tex.height = params.height;
        tex.depth = params.depth;
        tex.format = format;
        tex.cubemap = params.cubemap;
        tex.name = params.name;

        var result = tex.createGLTexture(params.data);
        if (!result)
        {
            tex = null;
        }

        if (params.onload)
        {
            params.onload(tex, 200);
        }
    }

    return tex;
};


//
// WebGLRenderBuffer
//
function WebGLRenderBuffer() {}
WebGLRenderBuffer.prototype =
{
    version : 1,

    destroy : function renderBufferDestroyFn()
    {
        var gd = this.gd;
        if (gd)
        {
            var glBuffer = this.glBuffer;
            if (glBuffer)
            {
                var gl = gd.gl;
                if (gl)
                {
                    gl.deleteRenderbuffer(glBuffer);
                }
                delete this.glBuffer;
            }

            delete this.gd;
        }
    }
};

// Constructor function
WebGLRenderBuffer.create = function webGLRenderBufferFn(gd, params)
{
    var renderBuffer = new WebGLRenderBuffer();

    var width = params.width;
    var height = params.height;
    var format = params.format;
    if (typeof format === 'string')
    {
        format = gd['PIXELFORMAT_' + format];
    }

    if (format !== gd.PIXELFORMAT_D24S8)
    {
        return null;
    }

    var gl = gd.gl;

    var glBuffer = gl.createRenderbuffer();

    gl.bindRenderbuffer(gl.RENDERBUFFER, glBuffer);

    gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, width, height);

    renderBuffer.width = gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_WIDTH);
    renderBuffer.height = gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_HEIGHT);

    gl.bindRenderbuffer(gl.RENDERBUFFER, null);

    if (renderBuffer.width < width ||
        renderBuffer.height < height)
    {
        gl.deleteRenderbuffer(glBuffer);
        return null;
    }

    renderBuffer.gd = gd;
    renderBuffer.format = format;
    renderBuffer.glBuffer = glBuffer;

    return renderBuffer;
};


//
// WebGLRenderTarget
//
function WebGLRenderTarget() {}
WebGLRenderTarget.prototype =
{
    version : 1,

    // Shared because there can only be one active at a time
    oldViewportBox : [],
    oldScissorBox : [],

    copyBox : function copyBoxFn(dst, src)
    {
        dst[0] = src[0];
        dst[1] = src[1];
        dst[2] = src[2];
        dst[3] = src[3];
    },

    bind : function bindFn()
    {
        var gd = this.gd;
        var gl = gd.gl;

        gd.unbindTexture(this.colorTexture0.glTexture);
        if (this.depthTexture)
        {
            gd.unbindTexture(this.depthTexture.glTexture);
        }

        gl.bindFramebuffer(gl.FRAMEBUFFER, this.glObject);

        var state = gd.state;
        this.copyBox(this.oldViewportBox, state.viewportBox);
        this.copyBox(this.oldScissorBox, state.scissorBox);
        gd.setViewport(0, 0, this.width, this.height);
        gd.setScissor(0, 0, this.width, this.height);

        return true;
    },

    unbind : function unbindFn()
    {
        var gd = this.gd;
        var gl = gd.gl;

        gl.bindFramebuffer(gl.FRAMEBUFFER, null);

        gd.setViewport.apply(gd, this.oldViewportBox);
        gd.setScissor.apply(gd, this.oldScissorBox);

        this.colorTexture0.updateMipmaps(this.face);
        if (this.depthTexture)
        {
            this.depthTexture.updateMipmaps(this.face);
        }
    },

    destroy : function renderTargetDestroyFn()
    {
        var gd = this.gd;
        if (gd)
        {
            var glObject = this.glObject;
            if (glObject)
            {
                var gl = gd.gl;
                if (gl)
                {
                    gl.deleteFramebuffer(glObject);
                }
                delete this.glObject;
            }

            delete this.colorTexture0;
            delete this.colorTexture1;
            delete this.colorTexture2;
            delete this.colorTexture3;
            delete this.depthBuffer;
            delete this.depthTexture;
            delete this.gd;
        }
    }
};

// Constructor function
WebGLRenderTarget.create = function webGLRenderTargetFn(gd, params)
{
    var renderTarget = new WebGLRenderTarget();

    var colorTexture0 = params.colorTexture0;
    var colorTexture1 = (colorTexture0 ? (params.colorTexture1 || null) : null);
    var colorTexture2 = (colorTexture1 ? (params.colorTexture2 || null) : null);
    var colorTexture3 = (colorTexture2 ? (params.colorTexture3 || null) : null);
    var depthBuffer = params.depthBuffer || null;
    var depthTexture = params.depthTexture || null;
    var face = params.face;

    var maxSupported  = gd.maxSupported("RENDERTARGET_COLOR_TEXTURES");
    if (colorTexture1 && maxSupported < 2)
    {
        return null;
    }
    if (colorTexture2 && maxSupported < 3)
    {
        return null;
    }
    if (colorTexture3 && maxSupported < 4)
    {
        return null;
    }

    var gl = gd.gl;

    var glObject = gl.createFramebuffer();

    gl.bindFramebuffer(gl.FRAMEBUFFER, glObject);

    var width, height;
    if (colorTexture0)
    {
        width = colorTexture0.width;
        height = colorTexture0.height;

        var glTexture = colorTexture0.glTexture;
        if (glTexture === undefined)
        {
            TurbulenzEngine.callOnError("Color texture is not a Texture");
            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
            gl.deleteFramebuffer(glObject);
            return null;
        }

        var colorAttachment0 = gl.COLOR_ATTACHMENT0;
        if (colorTexture0.cubemap)
        {
            gl.framebufferTexture2D(gl.FRAMEBUFFER, colorAttachment0, (gl.TEXTURE_CUBE_MAP_POSITIVE_X + face), glTexture, 0);
        }
        else
        {
            gl.framebufferTexture2D(gl.FRAMEBUFFER, colorAttachment0, gl.TEXTURE_2D, glTexture, 0);
        }

        if (colorTexture1)
        {
            glTexture = colorTexture1.glTexture;
            if (colorTexture1.cubemap)
            {
                gl.framebufferTexture2D(gl.FRAMEBUFFER, (colorAttachment0 + 1), (gl.TEXTURE_CUBE_MAP_POSITIVE_X + face), glTexture, 0);
            }
            else
            {
                gl.framebufferTexture2D(gl.FRAMEBUFFER, (colorAttachment0 + 1), gl.TEXTURE_2D, glTexture, 0);
            }

            if (colorTexture2)
            {
                glTexture = colorTexture2.glTexture;
                if (colorTexture1.cubemap)
                {
                    gl.framebufferTexture2D(gl.FRAMEBUFFER, (colorAttachment0 + 2), (gl.TEXTURE_CUBE_MAP_POSITIVE_X + face), glTexture, 0);
                }
                else
                {
                    gl.framebufferTexture2D(gl.FRAMEBUFFER, (colorAttachment0 + 2), gl.TEXTURE_2D, glTexture, 0);
                }

                if (colorTexture3)
                {
                    glTexture = colorTexture3.glTexture;
                    if (colorTexture1.cubemap)
                    {
                        gl.framebufferTexture2D(gl.FRAMEBUFFER, (colorAttachment0 + 3), (gl.TEXTURE_CUBE_MAP_POSITIVE_X + face), glTexture, 0);
                    }
                    else
                    {
                        gl.framebufferTexture2D(gl.FRAMEBUFFER, (colorAttachment0 + 3), gl.TEXTURE_2D, glTexture, 0);
                    }
                }
            }
        }
    }
    else if (depthTexture)
    {
        width = depthTexture.width;
        height = depthTexture.height;
    }
    else if (depthBuffer)
    {
        width = depthBuffer.width;
        height = depthBuffer.height;
    }
    else
    {
        TurbulenzEngine.callOnError(
            "No RenderBuffers or Textures specified for this RenderTarget");
        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
        gl.deleteFramebuffer(glObject);
        return null;
    }

    if (depthTexture)
    {
        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT,
                                gl.TEXTURE_2D, depthTexture.glTexture, 0);
    }
    else if (depthBuffer)
    {
        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT,
                                   gl.RENDERBUFFER, depthBuffer.glBuffer);
    }

    var status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);

    gl.bindFramebuffer(gl.FRAMEBUFFER, null);

    if (status !== gl.FRAMEBUFFER_COMPLETE)
    {
        gl.deleteFramebuffer(glObject);
        return null;
    }

    renderTarget.gd = gd;
    renderTarget.glObject = glObject;
    renderTarget.colorTexture0 = colorTexture0;
    renderTarget.colorTexture1 = colorTexture1;
    renderTarget.colorTexture2 = colorTexture2;
    renderTarget.colorTexture3 = colorTexture3;
    renderTarget.depthBuffer = depthBuffer;
    renderTarget.depthTexture = depthTexture;
    renderTarget.width = width;
    renderTarget.height = height;
    renderTarget.face = face;

    return renderTarget;
};


//
// WebGLIndexBuffer
//
function WebGLIndexBuffer() {}
WebGLIndexBuffer.prototype =
{
    version : 1,

    map : function indexBufferMapFn(offset, numIndices)
    {
        if (offset === undefined)
        {
            offset = 0;
        }
        if (numIndices === undefined)
        {
            numIndices = this.numIndices;
        }

        var gd = this.gd;
        var gl = gd.gl;

        var format = this.format;
        var data;
        if (format === gl.UNSIGNED_BYTE)
        {
            data = new Uint8Array(numIndices);
        }
        else if (format === gl.UNSIGNED_SHORT)
        {
            data = new Uint16Array(numIndices);
        }
        else //if (format === gl.UNSIGNED_INT)
        {
            data = new Uint32Array(numIndices);
        }

        var numValues = 0;
        var writer = function indexBufferWriterFn()
        {
            var numArguments = arguments.length;
            for (var n = 0; n < numArguments; n += 1)
            {
                data[numValues] = arguments[n];
                numValues += 1;
            }
        };
        writer.data = data;
        writer.offset = offset;
        writer.getNumWrittenIndices = function getNumWrittenIndicesFn()
        {
            return numValues;
        };
        writer.write = writer;
        return writer;
    },

    unmap : function indexBufferUnmapFn(writer)
    {
        if (writer)
        {
            var gd = this.gd;
            var gl = gd.gl;

            var data = writer.data;
            delete writer.data;

            var offset = writer.offset;

            delete writer.write;

            var numIndices = writer.getNumWrittenIndices();
            if (!numIndices)
            {
                return;
            }

            if (numIndices < data.length)
            {
                data = data.subarray(0, numIndices);
            }

            gd.setIndexBuffer(this);

            if (numIndices < this.numIndices)
            {
                gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, offset, data);
            }
            else
            {
                gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, this.usage);
            }
        }
    },

    setData : function indexBufferSetDataFn(data, offset, numIndices)
    {
        if (offset === undefined)
        {
            offset = 0;
        }
        if (numIndices === undefined)
        {
            numIndices = this.numIndices;
        }

        var gd = this.gd;
        var gl = gd.gl;

        var bufferData;
        var format = this.format;
        if (format === gl.UNSIGNED_BYTE)
        {
            if (data instanceof Uint8Array)
            {
                bufferData = data;
            }
            else
            {
                bufferData = new Uint8Array(data);
            }
        }
        else if (format === gl.UNSIGNED_SHORT)
        {
            if (data instanceof Uint16Array)
            {
                bufferData = data;
            }
            else
            {
                bufferData = new Uint16Array(data);
            }
            offset *= 2;
        }
        else if (format === gl.UNSIGNED_INT)
        {
            if (data instanceof Uint32Array)
            {
                bufferData = data;
            }
            else
            {
                bufferData = new Uint32Array(data);
            }
            offset *= 4;
        }
        data = undefined;

        if (numIndices < bufferData.length)
        {
            bufferData = bufferData.subarray(0, numIndices);
        }

        gd.setIndexBuffer(this);

        if (numIndices < this.numIndices)
        {
            gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, offset, bufferData);
        }
        else
        {
            gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, bufferData, this.usage);
        }
    },

    destroy : function indexBufferDestroyFn()
    {
        var gd = this.gd;
        if (gd)
        {
            var glBuffer = this.glBuffer;
            if (glBuffer)
            {
                var gl = gd.gl;
                if (gl)
                {
                    gd.unsetIndexBuffer(this);
                    gl.deleteBuffer(glBuffer);
                }
                delete this.glBuffer;
            }

            delete this.gd;
        }
    }
};

// Constructor function
WebGLIndexBuffer.create = function webGLIndexBufferCreateFn(gd, params)
{
    var gl = gd.gl;

    var ib = new WebGLIndexBuffer();
    ib.gd = gd;

    var numIndices = params.numIndices;
    ib.numIndices = numIndices;

    var format = params.format;
    if (typeof format === "string")
    {
        format = gd['INDEXFORMAT_' + format];
    }
    ib.format = format;

    var stride;
    if (format === gl.UNSIGNED_BYTE)
    {
        stride = 1;
    }
    else if (format === gl.UNSIGNED_SHORT)
    {
        stride = 2;
    }
    else //if (format === gl.UNSIGNED_INT)
    {
        stride = 4;
    }
    ib.stride = stride;

    /*jshint sub: true*/
    // Avoid dot notation lookup to prevent Google Closure complaining about transient being a keyword
    ib['transient'] = (params['transient'] || false);
    ib.dynamic = (params.dynamic || ib['transient']);
    ib.usage = (ib['transient'] ? gl.STREAM_DRAW : (ib.dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW));
    /*jshint sub: false*/

    ib.glBuffer = gl.createBuffer();

    if (params.data)
    {
        ib.setData(params.data, 0, numIndices);
    }
    else
    {
        gd.setIndexBuffer(ib);

        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, (numIndices * stride), ib.usage);
    }

    return ib;
};


//
// WebGLSemantics
//
function WebGLSemantics() {}
WebGLSemantics.prototype =
{
    version : 1
};

// Constructor function
WebGLSemantics.create = function webGLSemanticsCreateFn(gd, attributes)
{
    var semantics = new WebGLSemantics();

    var numAttributes = attributes.length;
    semantics.length = numAttributes;
    for (var i = 0; i < numAttributes; i += 1)
    {
        var attribute = attributes[i];
        if (typeof attribute === "string")
        {
            semantics[i] = gd['SEMANTIC_' + attribute];
        }
        else
        {
            semantics[i] = attribute;
        }
    }

    return semantics;
};


//
// WebGLVertexBuffer
//
function WebGLVertexBuffer() {}
WebGLVertexBuffer.prototype =
{
    version : 1,

    map : function vertexBufferMapFn(offset, numVertices)
    {
        if (offset === undefined)
        {
            offset = 0;
        }
        if (numVertices === undefined)
        {
            numVertices = this.numVertices;
        }

        var gd = this.gd;
        var gl = gd.gl;

        var numValuesPerVertex = this.stride;
        var attributes = this.attributes;
        var numAttributes = attributes.length;

        var data, writer;
        var numValues = 0;

        if (this.hasSingleFormat)
        {
            var maxNumValues = (numVertices * numValuesPerVertex);
            var format = attributes[0].format;

            if (format === gl.BYTE)
            {
                data = new Int8Array(maxNumValues);
            }
            else if (format === gl.UNSIGNED_BYTE)
            {
                data = new Uint8Array(maxNumValues);
            }
            else if (format === gl.SHORT)
            {
                data = new Int16Array(maxNumValues);
            }
            else if (format === gl.UNSIGNED_SHORT)
            {
                data = new Uint16Array(maxNumValues);
            }
            else if (format === gl.INT)
            {
                data = new Int32Array(maxNumValues);
            }
            else if (format === gl.UNSIGNED_INT)
            {
                data = new Uint32Array(maxNumValues);
            }
            else if (format === gl.FLOAT)
            {
                data = new Float32Array(maxNumValues);
            }

            writer = function vertexBufferWriterSingleFn()
            {
                var numArguments = arguments.length;
                var currentArgument = 0;
                for (var a = 0; a < numAttributes; a += 1)
                {
                    var attribute = attributes[a];
                    var numComponents = attribute.numComponents;
                    var currentComponent = 0, j;
                    do
                    {
                        if (currentArgument < numArguments)
                        {
                            var value = arguments[currentArgument];
                            currentArgument += 1;
                            if (typeof value === "number")
                            {
                                if (attribute.normalized)
                                {
                                    value *= attribute.normalizationScale;
                                }
                                data[numValues] = value;
                                numValues += 1;
                                currentComponent += 1;
                            }
                            else if (currentComponent === 0)
                            {
                                var numSubArguments = value.length;
                                if (numSubArguments > numComponents)
                                {
                                    numSubArguments = numComponents;
                                }
                                if (attribute.normalized)
                                {
                                    var scale = attribute.normalizationScale;
                                    for (j = 0; j < numSubArguments; j += 1)
                                    {
                                        data[numValues] = (value[j] * scale);
                                        numValues += 1;
                                        currentComponent += 1;
                                    }
                                }
                                else
                                {
                                    for (j = 0; j < numSubArguments; j += 1)
                                    {
                                        data[numValues] = value[j];
                                        numValues += 1;
                                        currentComponent += 1;
                                    }
                                }
                                while (currentComponent < numComponents)
                                {
                                    // No need to clear to zeros
                                    numValues += 1;
                                    currentComponent += 1;
                                }
                                break;
                            }
                            else
                            {
                                TurbulenzEngine.callOnError(
                                    'Missing values for attribute ' + a);
                                return null;
                            }
                        }
                        else
                        {
                            // No need to clear to zeros
                            numValues += 1;
                            currentComponent += 1;
                        }
                    }
                    while (currentComponent < numComponents);
                }
            };
        }
        else
        {
            var destOffset = 0;
            var bufferSize = (numVertices * this.strideInBytes);

            data = new ArrayBuffer(bufferSize);

            if (typeof DataView !== 'undefined' && 'setFloat32' in DataView.prototype)
            {
                var dataView = new DataView(data);

                writer = function vertexBufferWriterDataViewFn()
                {
                    var numArguments = arguments.length;
                    var currentArgument = 0;
                    for (var a = 0; a < numAttributes; a += 1)
                    {
                        var attribute = attributes[a];
                        var numComponents = attribute.numComponents;
                        var setter = attribute.typedSetter;
                        var componentStride = attribute.componentStride;
                        var currentComponent = 0, j;
                        do
                        {
                            if (currentArgument < numArguments)
                            {
                                var value = arguments[currentArgument];
                                currentArgument += 1;
                                if (typeof value === "number")
                                {
                                    if (attribute.normalized)
                                    {
                                        value *= attribute.normalizationScale;
                                    }
                                    setter.call(dataView, destOffset, value, true);
                                    destOffset += componentStride;
                                    currentComponent += 1;
                                    numValues += 1;
                                }
                                else if (currentComponent === 0)
                                {
                                    var numSubArguments = value.length;
                                    if (numSubArguments > numComponents)
                                    {
                                        numSubArguments = numComponents;
                                    }
                                    if (attribute.normalized)
                                    {
                                        var scale = attribute.normalizationScale;
                                        for (j = 0; j < numSubArguments; j += 1)
                                        {
                                            setter.call(dataView, destOffset, (value[j] * scale), true);
                                            destOffset += componentStride;
                                            currentComponent += 1;
                                            numValues += 1;
                                        }
                                    }
                                    else
                                    {
                                        for (j = 0; j < numSubArguments; j += 1)
                                        {
                                            setter.call(dataView, destOffset, value[j], true);
                                            destOffset += componentStride;
                                            currentComponent += 1;
                                            numValues += 1;
                                        }
                                    }
                                    while (currentComponent < numComponents)
                                    {
                                        // No need to clear to zeros
                                        numValues += 1;
                                        currentComponent += 1;
                                    }
                                    break;
                                }
                                else
                                {
                                    TurbulenzEngine.callOnError(
                                        'Missing values for attribute ' + a);
                                    return null;
                                }
                            }
                            else
                            {
                                // No need to clear to zeros
                                numValues += 1;
                                currentComponent += 1;
                            }
                        }
                        while (currentComponent < numComponents);
                    }
                };
            }
            else
            {
                writer = function vertexBufferWriterMultiFn()
                {
                    var numArguments = arguments.length;
                    var currentArgument = 0;
                    var dest;
                    for (var a = 0; a < numAttributes; a += 1)
                    {
                        var attribute = attributes[a];
                        var numComponents = attribute.numComponents;
                        dest = new attribute.typedArray(data, destOffset, numComponents);
                        destOffset += attribute.stride;

                        var currentComponent = 0, j;
                        do
                        {
                            if (currentArgument < numArguments)
                            {
                                var value = arguments[currentArgument];
                                currentArgument += 1;
                                if (typeof value === "number")
                                {
                                    if (attribute.normalized)
                                    {
                                        value *= attribute.normalizationScale;
                                    }
                                    dest[currentComponent] = value;
                                    currentComponent += 1;
                                    numValues += 1;
                                }
                                else if (currentComponent === 0)
                                {
                                    var numSubArguments = value.length;
                                    if (numSubArguments > numComponents)
                                    {
                                        numSubArguments = numComponents;
                                    }
                                    if (attribute.normalized)
                                    {
                                        var scale = attribute.normalizationScale;
                                        for (j = 0; j < numSubArguments; j += 1)
                                        {
                                            dest[currentComponent] = (value[j] * scale);
                                            currentComponent += 1;
                                            numValues += 1;
                                        }
                                    }
                                    else
                                    {
                                        for (j = 0; j < numSubArguments; j += 1)
                                        {
                                            dest[currentComponent] = value[j];
                                            currentComponent += 1;
                                            numValues += 1;
                                        }
                                    }
                                    while (currentComponent < numComponents)
                                    {
                                        // No need to clear to zeros
                                        currentComponent += 1;
                                        numValues += 1;
                                    }
                                    break;
                                }
                                else
                                {
                                    TurbulenzEngine.callOnError(
                                        'Missing values for attribute ' + a);
                                    return null;
                                }
                            }
                            else
                            {
                                // No need to clear to zeros
                                currentComponent += 1;
                                numValues += 1;
                            }
                        }
                        while (currentComponent < numComponents);
                    }
                };
            }
        }

        writer.data = data;
        writer.offset = offset;
        writer.getNumWrittenVertices = function getNumWrittenVerticesFn()
        {
            return Math.floor(numValues / numValuesPerVertex);
        };
        writer.getNumWrittenValues = function getNumWrittenValuesFn()
        {
            return numValues;
        };
        writer.write = writer;
        return writer;
    },

    unmap : function vertexBufferUnmapFn(writer)
    {
        if (writer)
        {
            var data = writer.data;
            delete writer.data;

            delete writer.write;

            var numVertices = writer.getNumWrittenVertices();
            if (!numVertices)
            {
                return;
            }

            var offset = writer.offset;

            var stride = this.strideInBytes;

            if (this.hasSingleFormat)
            {
                var numValues = writer.getNumWrittenValues();
                if (numValues < data.length)
                {
                    data = data.subarray(0, numValues);
                }
            }
            else
            {
                var numBytes = (numVertices * stride);
                if (numBytes < data.byteLength)
                {
                    data = data.slice(0, numBytes);
                }
            }

            var gd = this.gd;
            var gl = gd.gl;

            gd.bindVertexBuffer(this.glBuffer);

            if (numVertices < this.numVertices)
            {
                gl.bufferSubData(gl.ARRAY_BUFFER, (offset * stride), data);
            }
            else
            {
                gl.bufferData(gl.ARRAY_BUFFER, data, this.usage);
            }
        }
    },

    setData : function vertexBufferSetDataFn(data, offset, numVertices)
    {
        if (offset === undefined)
        {
            offset = 0;
        }
        if (numVertices === undefined)
        {
            numVertices = this.numVertices;
        }

        var gd = this.gd;
        var gl = gd.gl;
        var strideInBytes = this.strideInBytes;

        // Fast path for ArrayBuffer data

        if (data.constructor === ArrayBuffer)
        {
            gd.bindVertexBuffer(this.glBuffer);

            if (numVertices < this.numVertices)
            {
                gl.bufferSubData(gl.ARRAY_BUFFER, (offset * strideInBytes), data);
            }
            else
            {
                gl.bufferData(gl.ARRAY_BUFFER, data, this.usage);
            }
            return;
        }

        var attributes = this.attributes;
        var numAttributes = this.numAttributes;
        var attribute, format, bufferData, TypedArrayConstructor;

        if (this.hasSingleFormat)
        {
            attribute = attributes[0];
            format = attribute.format;

            if (format === gl.BYTE)
            {
                if (!(data instanceof Int8Array))
                {
                    TypedArrayConstructor = Int8Array;
                }
            }
            else if (format === gl.UNSIGNED_BYTE)
            {
                if (!(data instanceof Uint8Array))
                {
                    TypedArrayConstructor = Uint8Array;
                }
            }
            else if (format === gl.SHORT)
            {
                if (!(data instanceof Int16Array))
                {
                    TypedArrayConstructor = Int16Array;
                }
            }
            else if (format === gl.UNSIGNED_SHORT)
            {
                if (!(data instanceof Uint16Array))
                {
                    TypedArrayConstructor = Uint16Array;
                }
            }
            else if (format === gl.INT)
            {
                if (!(data instanceof Int32Array))
                {
                    TypedArrayConstructor = Int32Array;
                }
            }
            else if (format === gl.UNSIGNED_INT)
            {
                if (!(data instanceof Uint32Array))
                {
                    TypedArrayConstructor = Uint32Array;
                }
            }
            else if (format === gl.FLOAT)
            {
                if (!(data instanceof Float32Array))
                {
                    TypedArrayConstructor = Float32Array;
                }
            }

            var numValuesPerVertex = this.stride;
            var numValues = (numVertices * numValuesPerVertex);

            if (TypedArrayConstructor)
            {
                // Data has to be put into a Typed Array and
                // potentially normalized.

                if (attribute.normalized)
                {
                    data = this.scaleValues(data, attribute.normalizationScale, numValues);
                }
                bufferData = new TypedArrayConstructor(data);
                if (numValues < bufferData.length)
                {
                    bufferData = bufferData.subarray(0, numValues);
                }
            }
            else
            {
                bufferData = data;
            }

            if (numValues < data.length)
            {
                bufferData = bufferData.subarray(0, numValues);
            }
        }
        else
        {
            var bufferSize = (numVertices * strideInBytes);

            bufferData = new ArrayBuffer(bufferSize);

            var srcOffset = 0, destOffset = 0, v, c, a, numComponents, componentStride, scale;
            if (typeof DataView !== 'undefined' && 'setFloat32' in DataView.prototype)
            {
                var dataView = new DataView(bufferData);

                for (v = 0; v < numVertices; v += 1)
                {
                    for (a = 0; a < numAttributes; a += 1)
                    {
                        attribute = attributes[a];
                        numComponents = attribute.numComponents;
                        componentStride = attribute.componentStride;
                        var setter = attribute.typedSetter;
                        if (attribute.normalized)
                        {
                            scale = attribute.normalizationScale;
                            for (c = 0; c < numComponents; c += 1)
                            {
                                setter.call(dataView, destOffset, (data[srcOffset] * scale), true);
                                destOffset += componentStride;
                                srcOffset += 1;
                            }
                        }
                        else
                        {
                            for (c = 0; c < numComponents; c += 1)
                            {
                                setter.call(dataView, destOffset, data[srcOffset], true);
                                destOffset += componentStride;
                                srcOffset += 1;
                            }
                        }
                    }
                }
            }
            else
            {
                for (v = 0; v < numVertices; v += 1)
                {
                    for (a = 0; a < numAttributes; a += 1)
                    {
                        attribute = attributes[a];
                        numComponents = attribute.numComponents;
                        var dest = new attribute.typedArray(bufferData, destOffset, numComponents);
                        destOffset += attribute.stride;
                        if (attribute.normalized)
                        {
                            scale = attribute.normalizationScale;
                            for (c = 0; c < numComponents; c += 1)
                            {
                                dest[c] = (data[srcOffset] * scale);
                                srcOffset += 1;
                            }
                        }
                        else
                        {
                            for (c = 0; c < numComponents; c += 1)
                            {
                                dest[c] = data[srcOffset];
                                srcOffset += 1;
                            }
                        }
                    }
                }
            }
        }
        data = undefined;

        gd.bindVertexBuffer(this.glBuffer);

        if (numVertices < this.numVertices)
        {
            gl.bufferSubData(gl.ARRAY_BUFFER, (offset * strideInBytes), bufferData);
        }
        else
        {
            gl.bufferData(gl.ARRAY_BUFFER, bufferData, this.usage);
        }
    },

    // Internal
    scaleValues : function scaleValuesFn(values, scale, numValues)
    {
        if (numValues === undefined)
        {
            numValues = values.length;
        }
        var scaledValues = new values.constructor(numValues);
        for (var n = 0; n < numValues; n += 1)
        {
            scaledValues[n] = (values[n] * scale);
        }
        return scaledValues;
    },

    bindAttributes : function bindAttributesFn(numAttributes, attributes, offset)
    {
        var gd = this.gd;
        var gl = gd.gl;
        var vertexAttributes = this.attributes;
        var stride = this.strideInBytes;
        var attributeMask = 0;
        /*jshint bitwise: false*/
        for (var n = 0; n < numAttributes; n += 1)
        {
            var vertexAttribute = vertexAttributes[n];
            var attribute = attributes[n];

            attributeMask |= (1 << attribute);

            gl.vertexAttribPointer(attribute,
                                   vertexAttribute.numComponents,
                                   vertexAttribute.format,
                                   vertexAttribute.normalized,
                                   stride,
                                   offset);

            offset += vertexAttribute.stride;
        }
        /*jshint bitwise: true*/
        return attributeMask;
    },

    setAttributes : function setAttributesFn(attributes)
    {
        var gd = this.gd;

        var numAttributes = attributes.length;
        this.numAttributes = numAttributes;

        this.attributes = [];
        var stride = 0, numValuesPerVertex = 0, hasSingleFormat = true;

        for (var i = 0; i < numAttributes; i += 1)
        {
            var format = attributes[i];
            if (typeof format === "string")
            {
                format = gd['VERTEXFORMAT_' + format];
            }
            this.attributes[i] = format;
            stride += format.stride;
            numValuesPerVertex += format.numComponents;

            if (hasSingleFormat && i)
            {
                if (format.format !== this.attributes[i - 1].format)
                {
                    hasSingleFormat = false;
                }
            }
        }
        this.strideInBytes = stride;
        this.stride = numValuesPerVertex;
        this.hasSingleFormat = hasSingleFormat;

        return stride;
    },

    resize : function resizeFn(size)
    {
        if (size !== (this.strideInBytes * this.numVertices))
        {
            var gd = this.gd;
            var gl = gd.gl;

            gd.bindVertexBuffer(this.glBuffer);

            var bufferType = gl.ARRAY_BUFFER;
            gl.bufferData(bufferType, size, this.usage);

            var bufferSize = gl.getBufferParameter(bufferType, gl.BUFFER_SIZE);
            this.numVertices = Math.floor(bufferSize / this.strideInBytes);
        }
    },

    destroy : function vertexBufferDestroyFn()
    {
        var gd = this.gd;
        if (gd)
        {
            var glBuffer = this.glBuffer;
            if (glBuffer)
            {
                var gl = gd.gl;
                if (gl)
                {
                    gd.unbindVertexBuffer(glBuffer);
                    gl.deleteBuffer(glBuffer);
                }
                delete this.glBuffer;
            }

            delete this.gd;
        }
    }
};

// Constructor function
WebGLVertexBuffer.create = function webGLVertexBufferCreateFn(gd, params)
{
    var gl = gd.gl;

    var vb = new WebGLVertexBuffer();
    vb.gd = gd;

    var numVertices = params.numVertices;
    vb.numVertices = numVertices;

    var strideInBytes = vb.setAttributes(params.attributes);

    /*jshint sub: true*/
    // Avoid dot notation lookup to prevent Google Closure complaining about transient being a keyword
    vb['transient'] = (params['transient'] || false);
    vb.dynamic = (params.dynamic || vb['transient']);
    vb.usage = (vb['transient'] ? gl.STREAM_DRAW : (vb.dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW));
    /*jshint sub: false*/
    vb.glBuffer = gl.createBuffer();

    var bufferSize = (numVertices * strideInBytes);

    if (params.data)
    {
        vb.setData(params.data, 0, numVertices);
    }
    else
    {
        gd.bindVertexBuffer(vb.glBuffer);

        gl.bufferData(gl.ARRAY_BUFFER, bufferSize, vb.usage);
    }

    return vb;
};


//
// WebGLPass
//
function WebGLPass() {}
WebGLPass.prototype =
{
    version : 1,

    updateParametersData : function updateParametersDataFn(gd)
    {
        var gl = gd.gl;

        this.dirty = false;

        // Set parameters
        var hasProperty = Object.prototype.hasOwnProperty;
        var parameters = this.parameters;
        for (var p in parameters)
        {
            if (hasProperty.call(parameters, p))
            {
                var parameter = parameters[p];
                if (parameter.dirty)
                {
                    parameter.dirty = 0;

                    var paramInfo = parameter.info;
                    var location = parameter.location;
                    if (paramInfo &&
                        null !== location)
                    {
                        var parameterValues = paramInfo.values;
                        var sampler = parameter.sampler;
                        if (sampler)
                        {
                            gd.setTexture(parameter.textureUnit, parameterValues, sampler);
                        }
                        else if (1 < paramInfo.numValues)
                        {
                            parameter.setter.call(gl, location, parameterValues);
                        }
                        else //if (1 === paramInfo.numValues)
                        {
                            parameter.setter.call(gl, location, parameterValues[0]);
                        }
                    }
                }
            }
        }
    },

    initializeParameters : function passInitializeParametersFn(gd)
    {
        var gl = gd.gl;

        var glProgram = this.glProgram;

        gd.setProgram(glProgram);

        var passParameters = this.parameters;
        for (var p in passParameters)
        {
            if (passParameters.hasOwnProperty(p))
            {
                var parameter = passParameters[p];

                var paramInfo = parameter.info;
                if (paramInfo)
                {
                    var location = gl.getUniformLocation(glProgram, p);
                    if (null !== location)
                    {
                        parameter.location = location;

                        if (parameter.sampler)
                        {
                            gl.uniform1i(location, parameter.textureUnit);
                        }
                        else
                        {
                            if (1 < paramInfo.numValues)
                            {
                                parameter.setter.call(gl, location, paramInfo.values);
                            }
                            else //if (1 === paramInfo.numValues)
                            {
                                parameter.setter.call(gl, location, paramInfo.values[0]);
                            }
                        }
                    }
                }
            }
        }
    },

    destroy : function passDestroyFn()
    {
        delete this.glProgram;
        delete this.semanticsMask;
        delete this.parameters;

        var states = this.states;
        if (states)
        {
            states.length = 0;
            delete this.states;
        }
    }
};

// Constructor function
WebGLPass.create = function webGLPassCreateFn(gd, shader, params)
{
    var gl = gd.gl;

    var pass = new WebGLPass();

    pass.name = (params.name || null);

    var programs = shader.programs;
    var parameters = shader.parameters;

    var parameterNames = params.parameters;
    var programNames = params.programs;
    var semanticNames = params.semantics;
    var states = params.states;

    var compoundProgramName = programNames.join(':');
    var linkedProgram = shader.linkedPrograms[compoundProgramName];
    var glProgram, semanticsMask, p, s;
    if (linkedProgram === undefined)
    {
        // Create GL program
        glProgram = gl.createProgram();

        var numPrograms = programNames.length;
        for (p = 0; p < numPrograms; p += 1)
        {
            var glShader = programs[programNames[p]];
            if (glShader)
            {
                gl.attachShader(glProgram, glShader);
            }
        }

        /*jshint bitwise: false*/
        var numSemantics = semanticNames.length;
        semanticsMask = 0;
        for (s = 0; s < numSemantics; s += 1)
        {
            var semanticName = semanticNames[s];
            var attribute = gd['SEMANTIC_' + semanticName];
            if (attribute !== undefined)
            {
                semanticsMask |= (1 << attribute);
                gl.bindAttribLocation(glProgram, attribute, ("ATTR" + attribute));
            }
        }
        /*jshint bitwise: true*/

        gl.linkProgram(glProgram);

        shader.linkedPrograms[compoundProgramName] = {
                glProgram : glProgram,
                semanticsMask : semanticsMask
            };
    }
    else
    {
        //console.log('Reused program ' + compoundProgramName);
        glProgram = linkedProgram.glProgram;
        semanticsMask = linkedProgram.semanticsMask;
    }

    pass.glProgram = glProgram;
    pass.semanticsMask = semanticsMask;

    // Set parameters
    var numTextureUnits = 0;
    var passParameters = {};
    pass.parameters = passParameters;
    var numParameters = parameterNames ? parameterNames.length : 0;
    for (p = 0; p < numParameters; p += 1)
    {
        var parameterName = parameterNames[p];

        var parameter = {};
        passParameters[parameterName] = parameter;

        var paramInfo = parameters[parameterName];
        parameter.info = paramInfo;
        if (paramInfo)
        {
            parameter.location = null;
            if (paramInfo.sampler)
            {
                parameter.sampler = paramInfo.sampler;
                parameter.textureUnit = numTextureUnits;
                numTextureUnits += 1;
            }
            else
            {
                parameter.sampler = undefined;
                parameter.textureUnit = undefined;
            }
            parameter.setter = paramInfo.setter;
        }
    }
    pass.numTextureUnits = numTextureUnits;
    pass.numParameters = numParameters;

    function equalRenderStates(defaultValues, values)
    {
        var numDefaultValues = defaultValues.length;
        var n;
        for (n = 0; n < numDefaultValues; n += 1)
        {
            if (defaultValues[n] !== values[n])
            {
                return false;
            }
        }
        return true;
    }

    var hasProperty = Object.prototype.hasOwnProperty;
    var stateHandlers = gd.stateHandlers;
    var passStates = [];
    var passStatesSet = {};
    pass.states = passStates;
    pass.statesSet = passStatesSet;
    for (s in states)
    {
        if (hasProperty.call(states, s))
        {
            var stateHandler = stateHandlers[s];
            if (stateHandler)
            {
                var values = stateHandler.parse(states[s]);
                if (values !== null)
                {
                    if (equalRenderStates(stateHandler.defaultValues, values))
                    {
                        continue;
                    }
                    passStates.push({
                        name: s,
                        set: stateHandler.set,
                        reset: stateHandler.reset,
                        values: values
                    });
                    passStatesSet[s] = true;
                }
                else
                {
                    TurbulenzEngine.callOnError('Unknown value for state ' +
                                                s + ': ' + states[s]);
                }
            }
        }
    }

    return pass;
};


//
// WebGLTechnique
//
function WebGLTechnique() {}
WebGLTechnique.prototype =
{
    version : 1,

    getPass : function getPassFn(id)
    {
        var passes = this.passes;
        var numPasses = passes.length;
        if (typeof id === "string")
        {
            for (var n = 0; n < numPasses; n += 1)
            {
                var pass = passes[n];
                if (pass.name === id)
                {
                    return pass;
                }
            }
        }
        else
        {
            /*jshint bitwise: false*/
            id = (id | 0);
            /*jshint bitwise: true*/
            if (id < numPasses)
            {
                return passes[id];
            }
        }
        return null;
    },

    activate : function activateFn(gd)
    {
        this.device = gd;

        if (!this.initialized)
        {
            this.shader.initialize(gd);
            this.initialize(gd);
        }
    },

    deactivate : function deactivateFn()
    {
        this.device = null;
    },

    checkProperties : function checkPropertiesFn(gd)
    {
        // Check for parameters set directly into the technique...
        var fakeTechniqueParameters = {}, p;
        for (p in this)
        {
            if (p !== 'version' &&
                p !== 'name' &&
                p !== 'passes' &&
                p !== 'numPasses' &&
                p !== 'device' &&
                p !== 'numParameters')
            {
                fakeTechniqueParameters[p] = this[p];
            }
        }

        if (fakeTechniqueParameters)
        {
            var passes = this.passes;
            if (passes.length === 1)
            {
                gd.setParametersImmediate(gd, passes, fakeTechniqueParameters);
            }
            else
            {
                gd.setParametersDeferred(gd, passes, fakeTechniqueParameters);
            }

            var hasProperty = Object.prototype.hasOwnProperty;
            for (p in fakeTechniqueParameters)
            {
                if (hasProperty.call(fakeTechniqueParameters, p))
                {
                    delete this[p];
                }
            }
        }
    },

    initialize : function techniqueInitializeFn(gd)
    {
        if (this.initialized)
        {
            return;
        }

        var passes = this.passes;
        if (passes)
        {
            var numPasses = passes.length;
            var n;
            for (n = 0; n < numPasses; n += 1)
            {
                passes[n].initializeParameters(gd);
            }
        }

        if (Object.defineProperty)
        {
            this.initializeParametersSetters(gd);
        }

        this.initialized = true;
    },

    initializeParametersSetters : function initializeParametersSettersFn(gd)
    {
        var gl = gd.gl;

        function make_sampler_setter(pass, parameter) {
            return function (parameterValues) {
                if (this.device)
                {
                    gd.setTexture(parameter.textureUnit, parameterValues, parameter.info.sampler);
                }
                else
                {
                    pass.dirty = true;
                    parameter.dirty = 1;
                    parameter.info.values = parameterValues;
                }
            };
        }

        function make_float_uniform_setter(pass, parameter) {

            var paramInfo = parameter.info;
            var location = parameter.location;

            function setDeferredParameter(parameterValues)
            {
                if (typeof parameterValues !== 'number')
                {
                    var values = paramInfo.values;
                    var numValues = Math.min(paramInfo.numValues, parameterValues.length);
                    for (var v = 0; v < numValues; v += 1)
                    {
                        values[v] = parameterValues[v];
                    }
                    parameter.dirty = Math.max(numValues, (parameter.dirty || 0));
                }
                else
                {
                    paramInfo.values[0] = parameterValues;
                    parameter.dirty = (parameter.dirty || 1);
                }
                pass.dirty = true;
            }

            switch (paramInfo.columns)
            {
            case 1:
                if (1 === paramInfo.numValues)
                {
                    return function (parameterValues)
                    {
                        if (this.device)
                        {
                            gl.uniform1f(location, parameterValues);
                        }
                        else
                        {
                            setDeferredParameter(parameterValues);
                        }
                    };
                }
                return function (parameterValues)
                {
                    if (this.device)
                    {
                        gl.uniform1fv(location, parameterValues);
                    }
                    else
                    {
                        setDeferredParameter(parameterValues);
                    }
                };
            case 2:
                return function (parameterValues)
                {
                    if (this.device)
                    {
                        gl.uniform2fv(location, parameterValues);
                    }
                    else
                    {
                        setDeferredParameter(parameterValues);
                    }
                };
            case 3:
                return function (parameterValues)
                {
                    if (this.device)
                    {
                        gl.uniform3fv(location, parameterValues);
                    }
                    else
                    {
                        setDeferredParameter(parameterValues);
                    }
                };
            case 4:
                return function (parameterValues)
                {
                    if (this.device)
                    {
                        gl.uniform4fv(location, parameterValues);
                    }
                    else
                    {
                        setDeferredParameter(parameterValues);
                    }
                };
            default:
                return null;
            }
        }

        function make_int_uniform_setter(pass, parameter) {
            var paramInfo = parameter.info;
            var location = parameter.location;

            function setDeferredParameter(parameterValues)
            {
                if (typeof parameterValues !== 'number')
                {
                    var values = paramInfo.values;
                    var numValues = Math.min(paramInfo.numValues, parameterValues.length);
                    for (var v = 0; v < numValues; v += 1)
                    {
                        values[v] = parameterValues[v];
                    }
                    parameter.dirty = Math.max(numValues, (parameter.dirty || 0));
                }
                else
                {
                    paramInfo.values[0] = parameterValues;
                    parameter.dirty = (parameter.dirty || 1);
                }
                pass.dirty = true;
            }

            switch (paramInfo.columns)
            {
            case 1:
                if (1 === paramInfo.numValues)
                {
                    return function (parameterValues)
                    {
                        if (this.device)
                        {
                            gl.uniform1i(location, parameterValues);
                        }
                        else
                        {
                            setDeferredParameter(parameterValues);
                        }
                    };
                }
                return function (parameterValues)
                {
                    if (this.device)
                    {
                        gl.uniform1iv(location, parameterValues);
                    }
                    else
                    {
                        setDeferredParameter(parameterValues);
                    }
                };
            case 2:
                return function (parameterValues)
                {
                    if (this.device)
                    {
                        gl.uniform2iv(location, parameterValues);
                    }
                    else
                    {
                        setDeferredParameter(parameterValues);
                    }
                };
            case 3:
                return function (parameterValues)
                {
                    if (this.device)
                    {
                        gl.uniform3iv(location, parameterValues);
                    }
                    else
                    {
                        setDeferredParameter(parameterValues);
                    }
                };
            case 4:
                return function (parameterValues)
                {
                    if (this.device)
                    {
                        gl.uniform4iv(location, parameterValues);
                    }
                    else
                    {
                        setDeferredParameter(parameterValues);
                    }
                };
            default:
                return null;
            }
        }

        var passes = this.passes;
        var numPasses = passes.length;
        var pass, parameters, p, parameter, paramInfo, setter;
        if (numPasses === 1)
        {
            pass = passes[0];
            parameters = pass.parameters;
            for (p in parameters)
            {
                if (parameters.hasOwnProperty(p))
                {
                    parameter = parameters[p];
                    paramInfo = parameter.info;
                    if (paramInfo)
                    {
                        if (undefined !== parameter.location)
                        {
                            if (parameter.sampler)
                            {
                                setter = make_sampler_setter(pass, parameter);
                            }
                            else
                            {
                                if (paramInfo.type === 'float')
                                {
                                    setter = make_float_uniform_setter(pass, parameter);
                                }
                                else
                                {
                                    setter = make_int_uniform_setter(pass, parameter);
                                }
                            }

                            Object.defineProperty(this, p, {
                                    set : setter,
                                    enumerable : false,
                                    configurable : false
                                });
                        }
                    }
                }
            }

            this.checkProperties = function ()
            {
            };
        }
        else
        {
            Object.defineProperty(this, 'device', {
                    writable : true,
                    enumerable : false,
                    configurable : false
                });

            Object.defineProperty(this, 'version', {
                    writable : false,
                    enumerable : false,
                    configurable : false
                });

            Object.defineProperty(this, 'name', {
                    writable : false,
                    enumerable : false,
                    configurable : false
                });

            Object.defineProperty(this, 'passes', {
                    writable : false,
                    enumerable : false,
                    configurable : false
                });

            Object.defineProperty(this, 'numParameters', {
                    writable : false,
                    enumerable : false,
                    configurable : false
                });
        }
    },

    destroy : function techniqueDestroyFn()
    {
        var passes = this.passes;
        if (passes)
        {
            var numPasses = passes.length;
            var n;

            for (n = 0; n < numPasses; n += 1)
            {
                passes[n].destroy();
            }

            passes.length = 0;

            delete this.passes;
        }

        delete this.device;
    }
};

// Constructor function
WebGLTechnique.create = function webGLTechniqueCreateFn(gd, shader, name, passes)
{
    var technique = new WebGLTechnique();

    technique.initialized = false;
    technique.shader = shader;
    technique.name = name;

    var numPasses = passes.length, n;
    var numParameters = 0;
    technique.passes = [];
    technique.numPasses = numPasses;
    for (n = 0; n < numPasses; n += 1)
    {
        var passParams = passes[n];
        if (passParams.parameters)
        {
            numParameters += passParams.parameters.length;
        }
        technique.passes[n] = WebGLPass.create(gd, shader, passParams);
    }

    technique.numParameters = numParameters;

    technique.device = null;


    return technique;
};

//
// WebGLShader
//
function WebGLShader() {}
WebGLShader.prototype =
{
    version : 1,

    getTechnique : function getTechniqueFn(name)
    {
        if (typeof name === "string")
        {
            return this.techniques[name];
        }
        else
        {
            var techniques = this.techniques;
            for (var t in techniques)
            {
                if (techniques.hasOwnProperty(t))
                {
                    if (name === 0)
                    {
                        return techniques[t];
                    }
                    else
                    {
                        name -= 1;
                    }
                }
            }
            return null;
        }
    },

    getParameter : function getParameterFn(name)
    {
        if (typeof name === "string")
        {
            return this.parameters[name];
        }
        else
        {
            /*jshint bitwise: false*/
            name = (name | 0);
            /*jshint bitwise: true*/
            var parameters = this.parameters;
            for (var p in parameters)
            {
                if (parameters.hasOwnProperty(p))
                {
                    if (name === 0)
                    {
                        return parameters[p];
                    }
                    else
                    {
                        name -= 1;
                    }
                }
            }
            return null;
        }
    },

    initialize : function shaderInitializeFn(gd)
    {
        if (this.initialized)
        {
            return;
        }

        var gl = gd.gl;
        var p;

        // Check copmpiled programs as late as possible
        var shaderPrograms = this.programs;
        for (p in shaderPrograms)
        {
            if (shaderPrograms.hasOwnProperty(p))
            {
                var compiledProgram = shaderPrograms[p];
                var compiled = gl.getShaderParameter(compiledProgram, gl.COMPILE_STATUS);
                if (!compiled)
                {
                    var compilerInfo = gl.getShaderInfoLog(compiledProgram);
                    TurbulenzEngine.callOnError(
                        'Program "' + p + '" failed to compile: ' + compilerInfo);
                }
            }
        }

        // Check linked programs as late as possible
        var linkedPrograms = this.linkedPrograms;
        for (p in linkedPrograms)
        {
            if (linkedPrograms.hasOwnProperty(p))
            {
                var linkedProgram = linkedPrograms[p];
                var glProgram = linkedProgram.glProgram;
                if (glProgram)
                {
                    var linked = gl.getProgramParameter(glProgram, gl.LINK_STATUS);
                    if (!linked)
                    {
                        var linkerInfo = gl.getProgramInfoLog(glProgram);
                        TurbulenzEngine.callOnError(
                            'Program "' + p + '" failed to link: ' + linkerInfo);
                    }
                }
            }
        }

        this.initialized = true;
    },

    destroy : function shaderDestroyFn()
    {
        var gd = this.gd;
        if (gd)
        {
            var gl = gd.gl;
            var p;

            var techniques = this.techniques;
            if (techniques)
            {
                for (p in techniques)
                {
                    if (techniques.hasOwnProperty(p))
                    {
                        techniques[p].destroy();
                    }
                }
                delete this.techniques;
            }

            var linkedPrograms = this.linkedPrograms;
            if (linkedPrograms)
            {
                if (gl)
                {
                    for (p in linkedPrograms)
                    {
                        if (linkedPrograms.hasOwnProperty(p))
                        {
                            var linkedProgram = linkedPrograms[p];
                            var glProgram = linkedProgram.glProgram;
                            if (glProgram)
                            {
                                gl.deleteProgram(glProgram);
                                delete linkedProgram.glProgram;
                            }
                        }
                    }
                }
                delete this.linkedPrograms;
            }

            var programs = this.programs;
            if (programs)
            {
                if (gl)
                {
                    for (p in programs)
                    {
                        if (programs.hasOwnProperty(p))
                        {
                            gl.deleteShader(programs[p]);
                        }
                    }
                }
                delete this.programs;
            }

            delete this.samplers;
            delete this.parameters;
            delete this.gd;
        }
    }
};

// Constructor function
WebGLShader.create = function webGLShaderCreateFn(gd, params)
{
    var gl = gd.gl;

    var shader = new WebGLShader();

    shader.initialized = false;

    var techniques = params.techniques;
    var parameters = params.parameters;
    var programs = params.programs;
    var samplers = params.samplers;
    var p;

    shader.gd = gd;
    shader.name = params.name;

    // Compile programs as early as possible
    var shaderPrograms = {};
    shader.programs = shaderPrograms;
    for (p in programs)
    {
        if (programs.hasOwnProperty(p))
        {
            var program = programs[p];

            var glShaderType;
            if (program.type === 'fragment')
            {
                glShaderType = gl.FRAGMENT_SHADER;
            }
            else if (program.type === 'vertex')
            {
                glShaderType = gl.VERTEX_SHADER;
            }
            var glShader = gl.createShader(glShaderType);

            gl.shaderSource(glShader, program.code);

            gl.compileShader(glShader);

            shaderPrograms[p] = glShader;
        }
    }

    var linkedPrograms = {};
    shader.linkedPrograms = linkedPrograms;

    // Samplers
    var defaultSampler = gd.DEFAULT_SAMPLER;
    var maxAnisotropy = gd.maxAnisotropy;

    shader.samplers = {};
    var sampler;
    for (p in samplers)
    {
        if (samplers.hasOwnProperty(p))
        {
            sampler = samplers[p];

            var samplerMaxAnisotropy = sampler.MaxAnisotropy;
            if (samplerMaxAnisotropy)
            {
                if (samplerMaxAnisotropy > maxAnisotropy)
                {
                    samplerMaxAnisotropy = maxAnisotropy;
                }
            }
            else
            {
                samplerMaxAnisotropy = defaultSampler.maxAnisotropy;
            }

            sampler = {
                minFilter : (sampler.MinFilter || defaultSampler.minFilter),
                magFilter : (sampler.MagFilter || defaultSampler.magFilter),
                wrapS : (sampler.WrapS || defaultSampler.wrapS),
                wrapT : (sampler.WrapT || defaultSampler.wrapT),
                wrapR : (sampler.WrapR || defaultSampler.wrapR),
                maxAnisotropy : samplerMaxAnisotropy
            };
            if (sampler.wrapS === 0x2900)
            {
                sampler.wrapS = gl.CLAMP_TO_EDGE;
            }
            if (sampler.wrapT === 0x2900)
            {
                sampler.wrapT = gl.CLAMP_TO_EDGE;
            }
            if (sampler.wrapR === 0x2900)
            {
                sampler.wrapR = gl.CLAMP_TO_EDGE;
            }
            shader.samplers[p] = gd.createSampler(sampler);
        }
    }

    // Parameters
    var numParameters = 0;
    shader.parameters = {};
    for (p in parameters)
    {
        if (parameters.hasOwnProperty(p))
        {
            var parameter = parameters[p];
            if (!parameter.columns)
            {
                parameter.columns = 1;
            }
            if (!parameter.rows)
            {
                parameter.rows = 1;
            }
            parameter.numValues = (parameter.columns * parameter.rows);
            var parameterType = parameter.type;
            if (parameterType === "float" ||
                parameterType === "int" ||
                parameterType === "bool")
            {
                var parameterValues = parameter.values;
                if (parameterValues)
                {
                    if (parameterType === "float")
                    {
                        parameter.values = new Float32Array(parameterValues);
                    }
                    else
                    {
                        parameter.values = new Int32Array(parameterValues);
                    }
                }
                else
                {
                    if (parameterType === "float")
                    {
                        parameter.values = new Float32Array(parameter.numValues);
                    }
                    else
                    {
                        parameter.values = new Int32Array(parameter.numValues);
                    }
                }

                if (parameterType === 'float')
                {
                    switch (parameter.columns)
                    {
                    case 1:
                        if (1 === parameter.numValues)
                        {
                            parameter.setter = gl.uniform1f;
                        }
                        else
                        {
                            parameter.setter = gl.uniform1fv;
                        }
                        break;
                    case 2:
                        parameter.setter = gl.uniform2fv;
                        break;
                    case 3:
                        parameter.setter = gl.uniform3fv;
                        break;
                    case 4:
                        parameter.setter = gl.uniform4fv;
                        break;
                    default:
                        break;
                    }
                }
                else
                {
                    switch (parameter.columns)
                    {
                    case 1:
                        if (1 === parameter.numValues)
                        {
                            parameter.setter = gl.uniform1i;
                        }
                        else
                        {
                            parameter.setter = gl.uniform1iv;
                        }
                        break;
                    case 2:
                        parameter.setter = gl.uniform2iv;
                        break;
                    case 3:
                        parameter.setter = gl.uniform3iv;
                        break;
                    case 4:
                        parameter.setter = gl.uniform4iv;
                        break;
                    default:
                        break;
                    }
                }
            }
            else // Sampler
            {
                sampler = shader.samplers[p];
                if (!sampler)
                {
                    sampler = defaultSampler;
                    shader.samplers[p] = defaultSampler;
                }
                parameter.sampler = sampler;
                parameter.values = null;
            }

            parameter.name = p;

            shader.parameters[p] = parameter;
            numParameters += 1;
        }
    }
    shader.numParameters = numParameters;

    // Techniques and passes
    var shaderTechniques = {};
    var numTechniques = 0;
    shader.techniques = shaderTechniques;
    for (p in techniques)
    {
        if (techniques.hasOwnProperty(p))
        {
            shaderTechniques[p] = WebGLTechnique.create(gd, shader, p, techniques[p]);
            numTechniques += 1;
        }
    }
    shader.numTechniques = numTechniques;

    return shader;
};

//
// WebGLTechniqueParameters
//
function WebGLTechniqueParameters() {}

// Constructor function
WebGLTechniqueParameters.create = function WebGLTechniqueParametersFn(params)
{
    var techniqueParameters = new WebGLTechniqueParameters();

    if (params)
    {
        for (var p in params)
        {
            if (params.hasOwnProperty(p))
            {
                techniqueParameters[p] = params[p];
            }
        }
    }

    return techniqueParameters;
};

//
// WebGLTechniqueParameterBuffer
//
function techniqueParameterBufferSetData(data, offset, numValues)
{
    for (var n = 0, o = offset; n < numValues; n += 1, o += 1)
    {
        this[o] = data[n];
    }
    return o;
}

function techniqueParameterBufferCreate(params)
{
    if (Float32Array.prototype.map === undefined)
    {
        Float32Array.prototype.map = function techniqueParameterBufferMap(offset, numFloats) {
            if (offset === undefined)
            {
                offset = 0;
            }
            var buffer = this;
            if (numFloats === undefined)
            {
                numFloats = this.length;
            }
            function techniqueParameterBufferWriter()
            {
                var numArguments = arguments.length;
                for (var a = 0; a < numArguments; a += 1)
                {
                    var value = arguments[a];
                    if (typeof value === 'number')
                    {
                        buffer[offset] = value;
                        offset += 1;
                    }
                    else
                    {
                        offset = techniqueParameterBufferSetData.call(buffer, value, offset, value.length);
                    }
                }
            }
            return techniqueParameterBufferWriter;
        };

        Float32Array.prototype.unmap = function techniqueParameterBufferUnmap(/* writer */) {
        };
    }

    return new Float32Array(params.numFloats);
}


//
// WebGLDrawParameters
//
function WebGLDrawParameters()
{
    // Streams, TechniqueParameters and Instances are stored as indexed properties
    this.endStreams = 0;
    this.endTechniqueParameters = (16 * 3);
    this.endInstances = ((16 * 3) + 8);
    this.firstIndex = 0;
    this.count = 0;
    this.sortKey = 0;
    this.technique = null;
    this.indexBuffer = null;
    this.primitive = -1;
    this.userData = null;

    // Initialize for 1 Stream, 2 TechniqueParameters and 8 Instances
    this[0] = undefined;
    this[1] = undefined;
    this[2] = undefined;

    this[(16 * 3) + 0] = undefined;
    this[(16 * 3) + 1] = undefined;

    this[((16 * 3) + 8) + 0] = undefined;
    this[((16 * 3) + 8) + 1] = undefined;
    this[((16 * 3) + 8) + 2] = undefined;
    this[((16 * 3) + 8) + 3] = undefined;
    this[((16 * 3) + 8) + 4] = undefined;
    this[((16 * 3) + 8) + 5] = undefined;
    this[((16 * 3) + 8) + 6] = undefined;
    this[((16 * 3) + 8) + 7] = undefined;
}

WebGLDrawParameters.prototype =
{
    version : 1,

    setTechniqueParameters : function setTechniqueParametersFn(indx, techniqueParameters)
    {
        if (indx < 8)
        {
            indx += (16 * 3);

            this[indx] = techniqueParameters;

            var endTechniqueParameters = this.endTechniqueParameters;
            if (techniqueParameters)
            {
                if (endTechniqueParameters <= indx)
                {
                    this.endTechniqueParameters = (indx + 1);
                }
            }
            else
            {
                while ((16 * 3) < endTechniqueParameters &&
                       !this[endTechniqueParameters - 1])
                {
                    endTechniqueParameters -= 1;
                }
                this.endTechniqueParameters = endTechniqueParameters;
            }
        }
    },

    setVertexBuffer : function setVertexBufferFn(indx, vertexBuffer)
    {
        if (indx < 16)
        {
            indx *= 3;

            this[indx] = vertexBuffer;

            var endStreams = this.endStreams;
            if (vertexBuffer)
            {
                if (endStreams <= indx)
                {
                    this.endStreams = (indx + 3);
                }
            }
            else
            {
                while (0 < endStreams &&
                       !this[endStreams - 3])
                {
                    endStreams -= 3;
                }
                this.endStreams = endStreams;
            }
        }
    },

    setSemantics : function setSemanticsFn(indx, semantics)
    {
        if (indx < 16)
        {
            this[(indx * 3) + 1] = semantics;
        }
    },

    setOffset : function setOffsetFn(indx, offset)
    {
        if (indx < 16)
        {
            this[(indx * 3) + 2] = offset;
        }
    },

    getTechniqueParameters : function getTechniqueParametersFn(indx)
    {
        if (indx < 8)
        {
            return this[indx + (16 * 3)];
        }
        else
        {
            return undefined;
        }
    },

    getVertexBuffer : function getVertexBufferFn(indx)
    {
        if (indx < 16)
        {
            return this[(indx * 3) + 0];
        }
        else
        {
            return undefined;
        }
    },

    getSemantics : function getSemanticsFn(indx)
    {
        if (indx < 16)
        {
            return this[(indx * 3) + 1];
        }
        else
        {
            return undefined;
        }
    },

    getOffset : function getOffsetFn(indx)
    {
        if (indx < 16)
        {
            return this[(indx * 3) + 2];
        }
        else
        {
            return undefined;
        }
    },

    addInstance : function drawParametersAddInstanceFn(instanceParameters)
    {
        if (instanceParameters)
        {
            var endInstances = this.endInstances;
            this.endInstances = (endInstances + 1);
            this[endInstances] = instanceParameters;
        }
    },

    removeInstances : function drawParametersRemoveInstancesFn()
    {
        this.endInstances = ((16 * 3) + 8);
    },

    getNumInstances : function drawParametersGetNumInstancesFn()
    {
        return (this.endInstances - ((16 * 3) + 8));
    }
};

// Constructor function
WebGLDrawParameters.create = function webGLDrawParametersFn(/* params */)
{
    return new WebGLDrawParameters();
};


//
// WebGLGraphicsDevice
//
function WebGLGraphicsDevice() {}
WebGLGraphicsDevice.prototype =
{
    version : 1,

    SEMANTIC_POSITION: 0,
    SEMANTIC_POSITION0: 0,
    SEMANTIC_BLENDWEIGHT: 1,
    SEMANTIC_BLENDWEIGHT0: 1,
    SEMANTIC_NORMAL: 2,
    SEMANTIC_NORMAL0: 2,
    SEMANTIC_COLOR: 3,
    SEMANTIC_COLOR0: 3,
    SEMANTIC_COLOR1: 4,
    SEMANTIC_SPECULAR: 4,
    SEMANTIC_FOGCOORD: 5,
    SEMANTIC_TESSFACTOR: 5,
    SEMANTIC_PSIZE0: 6,
    SEMANTIC_BLENDINDICES: 7,
    SEMANTIC_BLENDINDICES0: 7,
    SEMANTIC_TEXCOORD: 8,
    SEMANTIC_TEXCOORD0: 8,
    SEMANTIC_TEXCOORD1: 9,
    SEMANTIC_TEXCOORD2: 10,
    SEMANTIC_TEXCOORD3: 11,
    SEMANTIC_TEXCOORD4: 12,
    SEMANTIC_TEXCOORD5: 13,
    SEMANTIC_TEXCOORD6: 14,
    SEMANTIC_TEXCOORD7: 15,
    SEMANTIC_TANGENT: 14,
    SEMANTIC_TANGENT0: 14,
    SEMANTIC_BINORMAL0: 15,
    SEMANTIC_BINORMAL: 15,
    SEMANTIC_PSIZE: 6,
    SEMANTIC_ATTR0: 0,
    SEMANTIC_ATTR1: 1,
    SEMANTIC_ATTR2: 2,
    SEMANTIC_ATTR3: 3,
    SEMANTIC_ATTR4: 4,
    SEMANTIC_ATTR5: 5,
    SEMANTIC_ATTR6: 6,
    SEMANTIC_ATTR7: 7,
    SEMANTIC_ATTR8: 8,
    SEMANTIC_ATTR9: 9,
    SEMANTIC_ATTR10: 10,
    SEMANTIC_ATTR11: 11,
    SEMANTIC_ATTR12: 12,
    SEMANTIC_ATTR13: 13,
    SEMANTIC_ATTR14: 14,
    SEMANTIC_ATTR15: 15,

    PIXELFORMAT_A8: 0,
    PIXELFORMAT_L8: 1,
    PIXELFORMAT_L8A8: 2,
    PIXELFORMAT_R5G5B5A1: 3,
    PIXELFORMAT_R5G6B5: 4,
    PIXELFORMAT_R8G8B8A8: 5,
    PIXELFORMAT_R8G8B8: 6,
    PIXELFORMAT_D24S8: 7,
    PIXELFORMAT_DXT1: 8,
    PIXELFORMAT_DXT3: 9,
    PIXELFORMAT_DXT5: 10,

    drawIndexed : function drawIndexedFn(primitive, numIndices, first)
    {
        var gl = this.gl;
        var indexBuffer = this.activeIndexBuffer;

        var offset;
        if (first)
        {
            offset = (first * indexBuffer.stride);
        }
        else
        {
            offset = 0;
        }

        var format = indexBuffer.format;

        var attributeMask = this.attributeMask;

        var activeTechnique = this.activeTechnique;
        var passes = activeTechnique.passes;
        var numPasses = passes.length;
        var mask;

        activeTechnique.checkProperties(this);

        /*jshint bitwise: false*/
        if (1 === numPasses)
        {
            mask = (passes[0].semanticsMask & attributeMask);
            if (mask !== this.clientStateMask)
            {
                this.enableClientState(mask);
            }

            gl.drawElements(primitive, numIndices, format, offset);
        }
        else
        {
            for (var p = 0; p < numPasses; p += 1)
            {
                var pass = passes[p];

                mask = (pass.semanticsMask & attributeMask);
                if (mask !== this.clientStateMask)
                {
                    this.enableClientState(mask);
                }

                this.setPass(pass);

                gl.drawElements(primitive, numIndices, format, offset);
            }
        }
        /*jshint bitwise: true*/
    },

    draw : function drawFn(primitive, numVertices, first)
    {
        var gl = this.gl;

        var attributeMask = this.attributeMask;

        var activeTechnique = this.activeTechnique;
        var passes = activeTechnique.passes;
        var numPasses = passes.length;
        var mask;

        activeTechnique.checkProperties(this);

        /*jshint bitwise: false*/
        if (1 === numPasses)
        {
            mask = (passes[0].semanticsMask & attributeMask);
            if (mask !== this.clientStateMask)
            {
                this.enableClientState(mask);
            }

            gl.drawArrays(primitive, first, numVertices);
        }
        else
        {
            for (var p = 0; p < numPasses; p += 1)
            {
                var pass = passes[p];

                mask = (pass.semanticsMask & attributeMask);
                if (mask !== this.clientStateMask)
                {
                    this.enableClientState(mask);
                }

                this.setPass(pass);

                gl.drawArrays(primitive, first, numVertices);
            }
        }
        /*jshint bitwise: true*/
    },

    setTechniqueParameters : function setTechniqueParametersFn()
    {
        var activeTechnique = this.activeTechnique;
        var passes = activeTechnique.passes;
        var setParameters = (1 === passes.length ? this.setParametersImmediate : this.setParametersDeferred);
        var numTechniqueParameters = arguments.length;
        for (var t = 0; t < numTechniqueParameters; t += 1)
        {
            setParameters(this, passes, arguments[t]);
        }
    },

    //Internal

    setParametersImmediate : function setParametersImmediateFn(gd, passes, techniqueParameters)
    {
        var gl = gd.gl;

        var parameters = passes[0].parameters;
        /*jshint forin: true*/
        for (var p in techniqueParameters)
        {
            var parameter = parameters[p];
            if (parameter !== undefined)
            {
                var sampler = parameter.sampler;
                var parameterValues = techniqueParameters[p];
                if (parameterValues !== undefined)
                {
                    if (sampler !== undefined)
                    {
                        gd.setTexture(parameter.textureUnit, parameterValues, sampler);
                    }
                    else
                    {
                        parameter.setter.call(gl, parameter.location, parameterValues);
                    }
                }
                else
                {
                    delete techniqueParameters[p];
                    if (sampler)
                    {
                        gd.setTexture(parameter.textureUnit);
                    }
                }
            }
        }
        /*jshint forin: false*/
    },

    // ONLY USE FOR SINGLE PASS TECHNIQUES ON DRAWARRAY
    setParametersCaching : function setParametersCachingFn(gd, passes, techniqueParameters)
    {
        var gl = gd.gl;

        var parameters = passes[0].parameters;
        /*jshint forin: true*/
        for (var p in techniqueParameters)
        {
            var parameter = parameters[p];
            if (parameter !== undefined)
            {
                var parameterValues = techniqueParameters[p];
                if (parameter.value !== parameterValues)
                {
                    parameter.value = parameterValues;

                    var sampler = parameter.sampler;
                    if (parameterValues !== undefined)
                    {
                        if (sampler !== undefined)
                        {
                            gd.setTexture(parameter.textureUnit, parameterValues, sampler);
                        }
                        else
                        {
                            parameter.setter.call(gl, parameter.location, parameterValues);
                        }
                    }
                    else
                    {
                        delete techniqueParameters[p];
                        if (sampler)
                        {
                            gd.setTexture(parameter.textureUnit);
                        }
                    }
                }
            }
        }
        /*jshint forin: false*/
    },

    setParametersDeferred : function setParametersDeferredFn(gd, passes, techniqueParameters)
    {
        var numPasses = passes.length;
        var min = Math.min;
        var max = Math.max;
        for (var n = 0; n < numPasses; n += 1)
        {
            var pass = passes[n];
            var parameters = pass.parameters;
            pass.dirty = true;

            /*jshint forin: true*/
            for (var p in techniqueParameters)
            {
                var parameter = parameters[p];
                if (parameter)
                {
                    var paramInfo = parameter.info;
                    var parameterValues = techniqueParameters[p];
                    if (parameterValues !== undefined)
                    {
                        if (parameter.sampler)
                        {
                            paramInfo.values = parameterValues;
                            parameter.dirty = 1;
                        }
                        else if (typeof parameterValues !== 'number')
                        {
                            var values = paramInfo.values;
                            var numValues = min(paramInfo.numValues, parameterValues.length);
                            for (var v = 0; v < numValues; v += 1)
                            {
                                values[v] = parameterValues[v];
                            }
                            parameter.dirty = max(numValues, (parameter.dirty || 0));
                        }
                        else
                        {
                            paramInfo.values[0] = parameterValues;
                            parameter.dirty = (parameter.dirty || 1);
                        }
                    }
                    else
                    {
                        delete techniqueParameters[p];
                    }
                }
            }
            /*jshint forin: false*/
        }
    },

    setTechnique : function setTechniqueFn(technique)
    {
        var activeTechnique = this.activeTechnique;
        if (activeTechnique !== technique)
        {
            if (activeTechnique)
            {
                activeTechnique.deactivate();
            }

            this.activeTechnique = technique;

            technique.activate(this);

            var passes = technique.passes;
            if (1 === passes.length)
            {
                this.setPass(passes[0]);
            }
        }
    },

    // ONLY USE FOR SINGLE PASS TECHNIQUES ON DRAWARRAY
    setTechniqueCaching : function setTechniqueCachingFn(technique)
    {
        var pass = technique.passes[0];

        var activeTechnique = this.activeTechnique;
        if (activeTechnique !== technique)
        {
            if (activeTechnique)
            {
                activeTechnique.deactivate();
            }

            this.activeTechnique = technique;

            technique.activate(this);

            this.setPass(pass);
        }

        var parameters = pass.parameters;
        for (var p in parameters)
        {
            if (parameters.hasOwnProperty(p))
            {
                parameters[p].value = null;
            }
        }
    },

    setStream : function setStreamFn(vertexBuffer, semantics, offset)
    {
        if (offset)
        {
            offset *= vertexBuffer.strideInBytes;
        }
        else
        {
            offset = 0;
        }

        this.bindVertexBuffer(vertexBuffer.glBuffer);

        var attributes = semantics;
        var numAttributes = attributes.length;
        if (numAttributes > vertexBuffer.numAttributes)
        {
            numAttributes = vertexBuffer.numAttributes;
        }

        /*jshint bitwise: false*/
        this.attributeMask |= vertexBuffer.bindAttributes(numAttributes, attributes, offset);
        /*jshint bitwise: true*/
    },

    setIndexBuffer : function setIndexBufferFn(indexBuffer)
    {
        if (this.activeIndexBuffer !== indexBuffer)
        {
            this.activeIndexBuffer = indexBuffer;
            var glBuffer;
            if (indexBuffer)
            {
                glBuffer = indexBuffer.glBuffer;
            }
            else
            {
                glBuffer = null;
            }
            var gl = this.gl;
            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, glBuffer);
        }
    },

    drawArray : function drawArrayFn(drawParametersArray, globalTechniqueParametersArray, sortMode)
    {
        var gl = this.gl;
        var ELEMENT_ARRAY_BUFFER = gl.ELEMENT_ARRAY_BUFFER;

        var setParametersCaching = this.setParametersCaching;
        var setParametersDeferred = this.setParametersDeferred;

        var setStream = this.setStream;
        var enableClientState = this.enableClientState;

        var numGlobalTechniqueParameters = globalTechniqueParametersArray.length;

        var numDrawParameters = drawParametersArray.length;
        if (numDrawParameters > 1 && sortMode)
        {
            if (sortMode > 0)
            {
                drawParametersArray.sort(function drawArraySortPositive(a, b) {
                    return (b.sortKey - a.sortKey);
                });
            }
            else if (sortMode < 0)
            {
                drawParametersArray.sort(function drawArraySortNegative(a, b) {
                    return (a.sortKey - b.sortKey);
                });
            }
        }


        var activeIndexBuffer = this.activeIndexBuffer;
        var setParameters = null;
        var lastTechnique = null;
        var lastEndStreams = -1;
        var lastDrawParameters = null;
        var techniqueParameters = null;
        var v = 0;
        var streamsMatch = false;
        var vertexBuffer = null;
        var offset = 0;
        var passes = null;
        var p = null;
        var pass = null;
        var format = 0;
        var numPasses = 0;
        var mask = 0;
        var attributeMask = 0;
        var t = 0;

        for (var n = 0; n < numDrawParameters; n += 1)
        {
            var drawParameters = drawParametersArray[n];
            var technique = drawParameters.technique;
            var endTechniqueParameters = drawParameters.endTechniqueParameters;
            var endStreams = drawParameters.endStreams;
            var endInstances = drawParameters.endInstances;
            var indexBuffer = drawParameters.indexBuffer;
            var primitive = drawParameters.primitive;
            var count = drawParameters.count;
            var firstIndex = drawParameters.firstIndex;

            if (lastTechnique !== technique)
            {
                lastTechnique = technique;

                passes = technique.passes;
                numPasses = passes.length;
                if (1 === numPasses)
                {
                    this.setTechniqueCaching(technique);
                    setParameters = setParametersCaching;
                }
                else
                {
                    this.setTechnique(technique);
                    setParameters = setParametersDeferred;
                }

                technique.checkProperties(this);

                for (t = 0; t < numGlobalTechniqueParameters; t += 1)
                {
                    setParameters(this, passes, globalTechniqueParametersArray[t]);
                }
            }

            for (t = (16 * 3); t < endTechniqueParameters; t += 1)
            {
                techniqueParameters = drawParameters[t];
                if (techniqueParameters)
                {
                    setParameters(this, passes, techniqueParameters);
                }
            }

            streamsMatch = (lastEndStreams === endStreams);
            for (v = 0; streamsMatch && v < endStreams; v += 3)
            {
                streamsMatch = (lastDrawParameters[v]     === drawParameters[v]     &&
                                lastDrawParameters[v + 1] === drawParameters[v + 1] &&
                                lastDrawParameters[v + 2] === drawParameters[v + 2]);
            }

            if (!streamsMatch)
            {
                lastEndStreams = endStreams;
                lastDrawParameters = drawParameters;

                for (v = 0; v < endStreams; v += 3)
                {
                    vertexBuffer = drawParameters[v];
                    if (vertexBuffer)
                    {
                        setStream.call(this, vertexBuffer, drawParameters[v + 1], drawParameters[v + 2]);
                    }
                }

                attributeMask = this.attributeMask;
            }

            /*jshint bitwise: false*/
            if (indexBuffer)
            {
                if (activeIndexBuffer !== indexBuffer)
                {
                    activeIndexBuffer = indexBuffer;
                    gl.bindBuffer(ELEMENT_ARRAY_BUFFER, indexBuffer.glBuffer);
                }

                offset = firstIndex;
                if (offset)
                {
                    offset *= indexBuffer.stride;
                }

                format = indexBuffer.format;

                if (1 === numPasses)
                {
                    mask = (passes[0].semanticsMask & attributeMask);
                    if (mask !== this.clientStateMask)
                    {
                        enableClientState.call(this, mask);
                    }

                    t = ((16 * 3) + 8);
                    if (t < endInstances)
                    {
                        do
                        {
                            setParameters(this, passes, drawParameters[t]);

                            gl.drawElements(primitive, count, format, offset);

                            t += 1;
                        }
                        while (t < endInstances);
                    }
                    else
                    {
                        gl.drawElements(primitive, count, format, offset);
                    }
                }
                else
                {
                    t = ((16 * 3) + 8);
                    if (t < endInstances)
                    {
                        do
                        {
                            setParameters(this, passes, drawParameters[t]);

                            for (p = 0; p < numPasses; p += 1)
                            {
                                pass = passes[p];

                                mask = (pass.semanticsMask & attributeMask);
                                if (mask !== this.clientStateMask)
                                {
                                    enableClientState.call(this, mask);
                                }

                                this.setPass(pass);

                                gl.drawElements(primitive, count, format, offset);
                            }

                            t += 1;
                        }
                        while (t < endInstances);
                    }
                    else
                    {
                        for (p = 0; p < numPasses; p += 1)
                        {
                            pass = passes[p];

                            mask = (pass.semanticsMask & attributeMask);
                            if (mask !== this.clientStateMask)
                            {
                                enableClientState.call(this, mask);
                            }

                            this.setPass(pass);

                            gl.drawElements(primitive, count, format, offset);
                        }
                    }
                }
            }
            else
            {
                if (1 === numPasses)
                {
                    mask = (passes[0].semanticsMask & attributeMask);
                    if (mask !== this.clientStateMask)
                    {
                        enableClientState.call(this, mask);
                    }

                    t = ((16 * 3) + 8);
                    if (t < endInstances)
                    {
                        do
                        {
                            setParameters(this, passes, drawParameters[t]);

                            gl.drawArrays(primitive, firstIndex, count);

                            t += 1;
                        }
                        while (t < endInstances);
                    }
                    else
                    {
                        gl.drawArrays(primitive, firstIndex, count);
                    }
                }
                else
                {
                    t = ((16 * 3) + 8);
                    if (t < endInstances)
                    {
                        do
                        {
                            setParameters(this, passes, drawParameters[t]);

                            for (p = 0; p < numPasses; p += 1)
                            {
                                pass = passes[p];

                                mask = (pass.semanticsMask & attributeMask);
                                if (mask !== this.clientStateMask)
                                {
                                    enableClientState.call(this, mask);
                                }

                                this.setPass(pass);

                                gl.drawArrays(primitive, firstIndex, count);
                            }

                            t += 1;
                        }
                        while (t < endInstances);
                    }
                    else
                    {
                        for (p = 0; p < numPasses; p += 1)
                        {
                            pass = passes[p];

                            mask = (pass.semanticsMask & attributeMask);
                            if (mask !== this.clientStateMask)
                            {
                                enableClientState.call(this, mask);
                            }

                            this.setPass(pass);

                            gl.drawArrays(primitive, firstIndex, count);
                        }
                    }
                }
            }
            /*jshint bitwise: true*/
        }

        this.activeIndexBuffer = activeIndexBuffer;
    },

    beginDraw : function beginDrawFn(primitive, numVertices, formats, semantics)
    {
        this.immediatePrimitive = primitive;
        if (numVertices)
        {
            var n;
            var immediateSemantics = this.immediateSemantics;
            var attributes = semantics;
            var numAttributes = attributes.length;
            immediateSemantics.length = numAttributes;
            for (n = 0; n < numAttributes; n += 1)
            {
                var attribute = attributes[n];
                if (typeof attribute === "string")
                {
                    attribute = this['SEMANTIC_' + attribute];
                }
                immediateSemantics[n] = attribute;
            }

            var immediateVertexBuffer = this.immediateVertexBuffer;

            var oldStride = immediateVertexBuffer.strideInBytes;
            var oldSize = (oldStride * immediateVertexBuffer.numVertices);

            var stride = immediateVertexBuffer.setAttributes(formats);
            if (stride !== oldStride)
            {
                immediateVertexBuffer.numVertices = Math.floor(oldSize / stride);
            }

            var size = (stride * numVertices);
            if (size > oldSize)
            {
                immediateVertexBuffer.resize(size);
            }

            return immediateVertexBuffer.map(0, numVertices);
        }
        return null;
    },

    endDraw : function endDrawFn(writer)
    {
        var immediateVertexBuffer = this.immediateVertexBuffer;

        var numVerticesWritten = writer.getNumWrittenVertices();

        immediateVertexBuffer.unmap(writer);

        if (numVerticesWritten)
        {
            var gl = this.gl;

            var stride = immediateVertexBuffer.strideInBytes;
            var offset = 0;

            /*jshint bitwise: false*/
            var vertexAttributes = immediateVertexBuffer.attributes;

            var semantics = this.immediateSemantics;
            var numSemantics = semantics.length;
            var deltaAttributeMask = 0;
            for (var n = 0; n < numSemantics; n += 1)
            {
                var vertexAttribute = vertexAttributes[n];

                var attribute = semantics[n];

                deltaAttributeMask |= (1 << attribute);

                gl.vertexAttribPointer(attribute,
                                       vertexAttribute.numComponents,
                                       vertexAttribute.format,
                                       vertexAttribute.normalized,
                                       stride,
                                       offset);

                offset += vertexAttribute.stride;
            }
            this.attributeMask |= deltaAttributeMask;
            /*jshint bitwise: true*/

            this.draw(this.immediatePrimitive, numVerticesWritten, 0);
        }
    },

    setViewport : function setViewportFn(x, y, w, h)
    {
        var currentBox = this.state.viewportBox;
        if (currentBox[0] !== x ||
            currentBox[1] !== y ||
            currentBox[2] !== w ||
            currentBox[3] !== h)
        {
            currentBox[0] = x;
            currentBox[1] = y;
            currentBox[2] = w;
            currentBox[3] = h;
            this.gl.viewport(x, y, w, h);
        }
    },

    setScissor : function setScissorFn(x, y, w, h)
    {
        var currentBox = this.state.scissorBox;
        if (currentBox[0] !== x ||
            currentBox[1] !== y ||
            currentBox[2] !== w ||
            currentBox[3] !== h)
        {
            currentBox[0] = x;
            currentBox[1] = y;
            currentBox[2] = w;
            currentBox[3] = h;
            this.gl.scissor(x, y, w, h);
        }
    },

    clear : function clearFn(color, depth, stencil)
    {
        var gl = this.gl;
        var state = this.state;

        var clearMask = 0;

        if (color)
        {
            clearMask += gl.COLOR_BUFFER_BIT;

            var currentColor = state.clearColor;
            var color0 = color[0];
            var color1 = color[1];
            var color2 = color[2];
            var color3 = color[3];
            if (currentColor[0] !== color0 ||
                currentColor[1] !== color1 ||
                currentColor[2] !== color2 ||
                currentColor[3] !== color3)
            {
                currentColor[0] = color0;
                currentColor[1] = color1;
                currentColor[2] = color2;
                currentColor[3] = color3;
                gl.clearColor(color0, color1, color2, color3);
            }
        }

        if (depth !== undefined)
        {
            clearMask += gl.DEPTH_BUFFER_BIT;

            if (state.clearDepth !== depth)
            {
                state.clearDepth = depth;
                gl.clearDepth(depth);
            }

            if (stencil !== undefined)
            {
                clearMask += gl.STENCIL_BUFFER_BIT;

                if (state.clearStencil !== stencil)
                {
                    state.clearStencil = stencil;
                    gl.clearStencil(stencil);
                }
            }
        }

        if (clearMask)
        {
            var colorMask = state.colorMask;
            var colorMaskEnabled = (colorMask[0] || colorMask[1] || colorMask[2] || colorMask[3]);
            var depthMask = state.depthMask;
            var program = state.program;

            if (color)
            {
                if (!colorMaskEnabled)
                {
                    // This is posibly a mistake, enable it for this call
                    gl.colorMask(true, true, true, true);
                }
            }

            if (depth !== undefined)
            {
                if (!depthMask)
                {
                    // This is posibly a mistake, enable it for this call
                    gl.depthMask(true);
                }
            }

            if (program)
            {
                gl.useProgram(null);    // Work around for Mac crash bug.
            }

            gl.clear(clearMask);

            if (color)
            {
                if (!colorMaskEnabled)
                {
                    gl.colorMask(false, false, false, false);
                }
            }

            if (depth !== undefined)
            {
                if (!depthMask)
                {
                    gl.depthMask(false);
                }
            }

            if (program)
            {
                gl.useProgram(program);
            }
        }
    },

    beginFrame : function beginFrameFn()
    {
        var gl = this.gl;

        this.attributeMask = 0;

        /*jshint bitwise: false*/
        var clientStateMask = this.clientStateMask;
        var n;
        if (clientStateMask)
        {
            for (n = 0; n < 16; n += 1)
            {
                if (clientStateMask & (1 << n))
                {
                    gl.disableVertexAttribArray(n);
                }
            }
            this.clientStateMask = 0;
        }
        /*jshint bitwise: true*/

        this.resetStates();

        this.setScissor(0, 0, this.width, this.height);
        this.setViewport(0, 0, this.width, this.height);

        return true;
    },

    beginRenderTarget : function beginRenderTargetFn(renderTarget)
    {
        this.activeRenderTarget = renderTarget;
        return renderTarget.bind();
    },

    endRenderTarget : function endRenderTargetFn()
    {
        this.activeRenderTarget.unbind();
        this.activeRenderTarget = null;
    },

    beginOcclusionQuery : function beginOcclusionQueryFn()
    {
        return false;
    },

    endOcclusionQuery : function endOcclusionQueryFn()
    {
    },

    endFrame : function endFrameFn()
    {
        var gl = this.gl;
        //gl.flush();

        if (this.activeTechnique)
        {
            this.activeTechnique.deactivate();
            this.activeTechnique = null;
        }

        if (this.activeIndexBuffer)
        {
            this.setIndexBuffer(null);
        }

        var state = this.state;
        if (state.program)
        {
            state.program = null;
            gl.useProgram(null);
        }

        this.numFrames += 1;
        var currentFrameTime = TurbulenzEngine.getTime();
        var diffTime = (currentFrameTime - this.previousFrameTime);
        if (diffTime >= 1000.0)
        {
            this.fps = (this.numFrames / (diffTime * 0.001));
            this.numFrames = 0;
            this.previousFrameTime = currentFrameTime;
        }

        var canvas = gl.canvas;
        var width = (gl.drawingBufferWidth || canvas.width);
        var height = (gl.drawingBufferHeight || canvas.height);
        if (this.width !== width ||
            this.height !== height)
        {
            this.width = width;
            this.height = height;
            this.setViewport(0, 0, width, height);
            this.setScissor(0, 0, width, height);
        }

        this.checkFullScreen();
    },

    createTechniqueParameters : function createTechniqueParametersFn(params)
    {
        return WebGLTechniqueParameters.create(params);
    },

    createSemantics : function createSemanticsFn(attributes)
    {
        return WebGLSemantics.create(this, attributes);
    },

    createVertexBuffer : function createVertexBufferFn(params)
    {
        return WebGLVertexBuffer.create(this, params);
    },

    createIndexBuffer : function createIndexBufferFn(params)
    {
        return WebGLIndexBuffer.create(this, params);
    },

    createTexture : function createTextureFn(params)
    {
        return WebGLTexture.create(this, params);
    },

    createShader : function createShaderFn(params)
    {
        return WebGLShader.create(this, params);
    },

    createTechniqueParameterBuffer : function createTechniqueParameterBufferFn(params)
    {
        return techniqueParameterBufferCreate(params);
    },

    createRenderBuffer : function createRenderBufferFn(params)
    {
        return WebGLRenderBuffer.create(this, params);
    },

    createRenderTarget : function createRenderTargetFn(params)
    {
        return WebGLRenderTarget.create(this, params);
    },

    createOcclusionQuery : function createOcclusionQueryFn(/* params */)
    {
        return null;
    },

    createDrawParameters : function createDrawParametersFn(params)
    {
        return WebGLDrawParameters.create(params);
    },

    isSupported : function isSupportedFn(name)
    {
        var gl = this.gl;
        if ("OCCLUSION_QUERIES" === name)
        {
            return false;
        }
        else if ("NPOT_MIPMAPPED_TEXTURES" === name)
        {
            return false;
        }
        else if ("TEXTURE_DXT1" === name ||
                 "TEXTURE_DXT3" === name ||
                 "TEXTURE_DXT5" === name)
        {
            var compressedTexturesExtension = this.compressedTexturesExtension;
            if (compressedTexturesExtension)
            {
                var compressedFormats = gl.getParameter(gl.COMPRESSED_TEXTURE_FORMATS);
                if (compressedFormats)
                {
                    var requestedFormat;
                    if ("TEXTURE_DXT1" === name)
                    {
                        requestedFormat = compressedTexturesExtension.COMPRESSED_RGBA_S3TC_DXT1_EXT;
                    }
                    else if ("TEXTURE_DXT3" === name)
                    {
                        requestedFormat = compressedTexturesExtension.COMPRESSED_RGBA_S3TC_DXT3_EXT;
                    }
                    else //if ("TEXTURE_DXT5" === name)
                    {
                        requestedFormat = compressedTexturesExtension.COMPRESSED_RGBA_S3TC_DXT5_EXT;
                    }
                    var numCompressedFormats = compressedFormats.length;
                    for (var n = 0; n < numCompressedFormats; n += 1)
                    {
                        if (compressedFormats[n] === requestedFormat)
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
        else if ("TEXTURE_ETC1" === name)
        {
            return false;
        }
        else if ("INDEXFORMAT_UINT" === name)
        {
            if (gl.getExtension('OES_element_index_uint'))
            {
                return true;
            }
            return false;
        }
        return undefined;
    },

    maxSupported : function maxSupportedFn(name)
    {
        var gl = this.gl;
        if ("ANISOTROPY" === name)
        {
            return this.maxAnisotropy;
        }
        else if ("TEXTURE_SIZE" === name)
        {
            return gl.getParameter(gl.MAX_TEXTURE_SIZE);
        }
        else if ("CUBEMAP_TEXTURE_SIZE" === name)
        {
            return gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE);
        }
        else if ("3D_TEXTURE_SIZE" === name)
        {
            return 0;
        }
        else if ("RENDERTARGET_COLOR_TEXTURES" === name)
        {
            return 1;
        }
        else if ("RENDERBUFFER_SIZE" === name)
        {
            return gl.getParameter(gl.MAX_RENDERBUFFER_SIZE);
        }
        return 0;
    },

    loadTexturesArchive : function loadTexturesArchiveFn(params)
    {
        var src = params.src;
        if (typeof TARLoader !== 'undefined')
        {
            TARLoader.create({
                gd: this,
                src : src,
                mipmaps : params.mipmaps,
                ontextureload : function tarTextureLoadedFn(texture)
                {
                    params.ontextureload(texture);
                },
                onload : function tarLoadedFn(success, status)
                {
                    if (params.onload)
                    {
                        params.onload(true, status);
                    }
                },
                onerror : function tarFailedFn()
                {
                    if (params.onload)
                    {
                        params.onload(false, status);
                    }
                }
            });
            return true;
        }
        else
        {
            TurbulenzEngine.callOnError(
                'Missing archive loader required for ' + src);
            return false;
        }
    },

    getScreenshot : function getScreenshotFn(compress, x, y, width, height)
    {
        var gl = this.gl;
        var canvas = gl.canvas;

        if (compress)
        {
            return canvas.toDataURL('image/jpeg');
        }
        else
        {
            if (x === undefined)
            {
                x = 0;
            }

            if (y === undefined)
            {
                y = 0;
            }

            var target = this.activeRenderTarget;
            if (!target)
            {
                target = canvas;
            }

            if (width === undefined)
            {
                width = target.width;
            }

            if (height === undefined)
            {
                height = target.height;
            }

            var pixels = new Uint8Array(4 * width * height);

            gl.readPixels(x, y, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);

            return pixels;
        }
    },

    // private
    checkFullScreen : function checkFullScreenFn()
    {
        var fullscreen = this.fullscreen;
        if (this.oldFullscreen !== fullscreen)
        {
            this.oldFullscreen = fullscreen;

            this.requestFullScreen(fullscreen);
        }
    },

    requestFullScreen : function requestFullScreenFn(fullscreen)
    {
        if (fullscreen)
        {
            var canvas = this.gl.canvas;
            if (canvas.webkitRequestFullScreenWithKeys)
            {
                canvas.webkitRequestFullScreenWithKeys();
            }
            else if (canvas.requestFullScreenWithKeys)
            {
                canvas.requestFullScreenWithKeys();
            }
            else if (canvas.webkitRequestFullScreen)
            {
                canvas.webkitRequestFullScreen(canvas.ALLOW_KEYBOARD_INPUT);
            }
            else if (canvas.mozRequestFullScreen)
            {
                canvas.mozRequestFullScreen();
            }
            else if (canvas.requestFullScreen)
            {
                canvas.requestFullScreen();
            }
            else if (canvas.requestFullscreen)
            {
                canvas.requestFullscreen();
            }
        }
        else
        {
            if (document.webkitCancelFullScreen)
            {
                document.webkitCancelFullScreen();
            }
            else if (document.cancelFullScreen)
            {
                document.cancelFullScreen();
            }
            else if (document.exitFullscreen)
            {
                document.exitFullscreen();
            }
        }
    },

    createSampler : function createSamplerFn(sampler)
    {
        var samplerKey = sampler.minFilter.toString() +
                   ':' + sampler.magFilter.toString() +
                   ':' + sampler.wrapS.toString() +
                   ':' + sampler.wrapT.toString() +
                   ':' + sampler.wrapR.toString() +
                   ':' + sampler.maxAnisotropy.toString();

        var cachedSamplers = this.cachedSamplers;
        var cachedSampler = cachedSamplers[samplerKey];
        if (!cachedSampler)
        {
            cachedSamplers[samplerKey] = sampler;
            return sampler;
        }
        return cachedSampler;
    },

    unsetIndexBuffer : function unsetIndexBufferFn(indexBuffer)
    {
        if (this.activeIndexBuffer === indexBuffer)
        {
            this.activeIndexBuffer = null;
            var gl = this.gl;
            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
        }
    },

    bindVertexBuffer : function bindVertexBufferFn(buffer)
    {
        if (this.bindedVertexBuffer !== buffer)
        {
            this.bindedVertexBuffer = buffer;
            var gl = this.gl;
            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
        }
    },

    unbindVertexBuffer : function unbindVertexBufferFn(buffer)
    {
        if (this.bindedVertexBuffer === buffer)
        {
            this.bindedVertexBuffer = null;
            var gl = this.gl;
            gl.bindBuffer(gl.ARRAY_BUFFER, null);
        }
    },

    bindTextureUnit : function bindTextureUnitFn(unit, target, texture)
    {
        var state = this.state;
        var gl = this.gl;

        if (state.activeTextureUnit !== unit)
        {
            state.activeTextureUnit = unit;
            gl.activeTexture(gl.TEXTURE0 + unit);
        }
        gl.bindTexture(target, texture);
    },

    bindTexture : function bindTextureFn(target, texture)
    {
        var state = this.state;
        var gl = this.gl;

        var dummyUnit = (state.maxTextureUnit - 1);
        if (state.activeTextureUnit !== dummyUnit)
        {
            state.activeTextureUnit = dummyUnit;
            gl.activeTexture(gl.TEXTURE0 + dummyUnit);
        }
        gl.bindTexture(target, texture);
    },

    unbindTexture : function unbindTextureFn(texture)
    {
        var state = this.state;
        var lastMaxTextureUnit = state.lastMaxTextureUnit;
        var textureUnits = state.textureUnits;
        for (var u = 0; u < lastMaxTextureUnit; u += 1)
        {
            var textureUnit = textureUnits[u];
            if (textureUnit.texture === texture)
            {
                textureUnit.texture = null;
                this.bindTextureUnit(u, textureUnit.target, null);
            }
        }
    },

    setSampler : function setSamplerFn(sampler, target)
    {
        if (sampler)
        {
            var gl = this.gl;

            gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, sampler.minFilter);
            gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, sampler.magFilter);
            gl.texParameteri(target, gl.TEXTURE_WRAP_S, sampler.wrapS);
            gl.texParameteri(target, gl.TEXTURE_WRAP_T, sampler.wrapT);
            /*
            if (sSupports3DTextures)
            {
                gl.texParameteri(target, gl.TEXTURE_WRAP_R, sampler.wrapR);
            }
            */
            if (this.TEXTURE_MAX_ANISOTROPY_EXT)
            {
                gl.texParameteri(target, this.TEXTURE_MAX_ANISOTROPY_EXT, sampler.maxAnisotropy);
            }
        }
    },

    setPass : function setPassFn(pass)
    {
        var gl = this.gl;
        var state = this.state;

        // Set renderstates
        var renderStatesSet = pass.statesSet;
        var renderStates = pass.states;
        var numRenderStates = renderStates.length;
        var r, renderState;
        for (r = 0; r < numRenderStates; r += 1)
        {
            renderState = renderStates[r];
            renderState.set.apply(renderState, renderState.values);
        }

        // Reset previous renderstates
        var renderStatesToReset = state.renderStatesToReset;
        var numRenderStatesToReset = renderStatesToReset.length;
        for (r = 0; r < numRenderStatesToReset; r += 1)
        {
            renderState = renderStatesToReset[r];
            if (!(renderState.name in renderStatesSet))
            {
                renderState.reset();
            }
        }

        // Copy set renderstates to be reset later
        renderStatesToReset.length = numRenderStates;
        for (r = 0; r < numRenderStates; r += 1)
        {
            renderStatesToReset[r] = renderStates[r];
        }

        // Reset texture units
        var lastMaxTextureUnit = state.lastMaxTextureUnit;
        var textureUnits = state.textureUnits;
        var currentMaxTextureUnit = pass.numTextureUnits;
        if (currentMaxTextureUnit < lastMaxTextureUnit)
        {
            var u = currentMaxTextureUnit;
            do
            {
                var textureUnit = textureUnits[u];
                if (textureUnit.texture)
                {
                    textureUnit.texture = null;
                    this.bindTextureUnit(u, textureUnit.target, null);
                }
                u += 1;
            }
            while (u < lastMaxTextureUnit);
        }
        state.lastMaxTextureUnit = currentMaxTextureUnit;

        var program = pass.glProgram;
        if (state.program !== program)
        {
            state.program = program;
            gl.useProgram(program);
        }

        if (pass.dirty)
        {
            pass.updateParametersData(this);
        }
    },

    enableClientState : function enableClientStateFn(mask)
    {
        var gl = this.gl;

        var oldMask = this.clientStateMask;
        this.clientStateMask = mask;

        /*jshint bitwise: false*/
        var disableMask = (oldMask & (~mask));
        var enableMask  = ((~oldMask) & mask);
        var n;

        if (disableMask)
        {
            if ((disableMask & 0xff) === 0)
            {
                disableMask >>= 8;
                n = 8;
            }
            else
            {
                n = 0;
            }
            do
            {
                if (0 !== (0x01 & disableMask))
                {
                    gl.disableVertexAttribArray(n);
                }
                n += 1;
                disableMask >>= 1;
            }
            while (disableMask);
        }

        if (enableMask)
        {
            if ((enableMask & 0xff) === 0)
            {
                enableMask >>= 8;
                n = 8;
            }
            else
            {
                n = 0;
            }
            do
            {
                if (0 !== (0x01 & enableMask))
                {
                    gl.enableVertexAttribArray(n);
                }
                n += 1;
                enableMask >>= 1;
            }
            while (enableMask);
        }
        /*jshint bitwise: true*/
    },

    setTexture : function setTextureFn(textureUnitIndex, texture, sampler)
    {
        var state = this.state;
        var gl = this.gl;

        var textureUnit = state.textureUnits[textureUnitIndex];
        var oldgltarget = textureUnit.target;
        var oldglobject = textureUnit.texture;

        if (texture)
        {
            var gltarget = texture.target;
            var globject = texture.glTexture;
            if (oldglobject !== globject ||
                oldgltarget !== gltarget)
            {
                textureUnit.target = gltarget;
                textureUnit.texture = globject;

                if (state.activeTextureUnit !== textureUnitIndex)
                {
                    state.activeTextureUnit = textureUnitIndex;
                    gl.activeTexture(gl.TEXTURE0 + textureUnitIndex);
                }

                if (oldgltarget !== gltarget &&
                    oldglobject)
                {
                    gl.bindTexture(oldgltarget, null);
                }

                gl.bindTexture(gltarget, globject);

                if (texture.sampler !== sampler)
                {
                    texture.sampler = sampler;

                    this.setSampler(sampler, gltarget);
                }
            }
        }
        else
        {
            if (oldgltarget &&
                oldglobject)
            {
                textureUnit.target = 0;
                textureUnit.texture = null;

                if (state.activeTextureUnit !== textureUnitIndex)
                {
                    state.activeTextureUnit = textureUnitIndex;
                    gl.activeTexture(gl.TEXTURE0 + textureUnitIndex);
                }

                gl.bindTexture(oldgltarget, null);
            }
        }
    },

    setProgram : function setProgramFn(program)
    {
        var state = this.state;
        if (state.program !== program)
        {
            state.program = program;
            this.gl.useProgram(program);
        }
    },

    syncState : function syncStateFn()
    {
        var state = this.state;
        var gl = this.gl;

        if (state.depthTestEnable)
        {
            gl.enable(gl.DEPTH_TEST);
        }
        else
        {
            gl.disable(gl.DEPTH_TEST);
        }

        gl.depthFunc(state.depthFunc);

        gl.depthMask(state.depthMask);

        if (state.blendEnable)
        {
            gl.enable(gl.BLEND);
        }
        else
        {
            gl.disable(gl.BLEND);
        }

        gl.blendFunc(state.blendSrc, state.blendDst);

        if (state.cullFaceEnable)
        {
            gl.enable(gl.CULL_FACE);
        }
        else
        {
            gl.disable(gl.CULL_FACE);
        }

        gl.cullFace(state.cullFace);

        gl.frontFace(state.frontFace);

        var colorMask = state.colorMask;
        gl.colorMask(colorMask[0], colorMask[1], colorMask[2], colorMask[3]);

        if (state.stencilTestEnable)
        {
            gl.enable(gl.STENCIL_TEST);
        }
        else
        {
            gl.disable(gl.STENCIL_TEST);
        }

        gl.stencilFunc(state.stencilFunc, state.stencilRef, state.stencilMask);

        gl.stencilOp(state.stencilFail, state.stencilZFail, state.stencilZPass);

        if (state.polygonOffsetFillEnable)
        {
            gl.enable(gl.POLYGON_OFFSET_FILL);
        }
        else
        {
            gl.disable(gl.POLYGON_OFFSET_FILL);
        }

        gl.polygonOffset(state.polygonOffsetFactor, state.polygonOffsetUnits);

        gl.lineWidth(state.lineWidth);

        gl.activeTexture(gl.TEXTURE0 + state.activeTextureUnit);

        var currentBox = this.state.viewportBox;
        gl.viewport(currentBox[0], currentBox[1], currentBox[2], currentBox[3]);

        currentBox = this.state.scissorBox;
        gl.scissor(currentBox[0], currentBox[1], currentBox[2], currentBox[3]);

        var currentColor = state.clearColor;
        gl.clearColor(currentColor[0], currentColor[1], currentColor[2], currentColor[3]);

        gl.clearDepth(state.clearDepth);

        gl.clearStencil(state.clearStencil);
    },

    resetStates : function resetStatesFn()
    {
        var state = this.state;

        var lastMaxTextureUnit = state.lastMaxTextureUnit;
        var textureUnits = state.textureUnits;
        for (var u = 0; u < lastMaxTextureUnit; u += 1)
        {
            var textureUnit = textureUnits[u];
            if (textureUnit.texture)
            {
                this.bindTextureUnit(u, textureUnit.target, null);
                textureUnit.texture = null;
                textureUnit.target = 0;
            }
        }
    },

    destroy : function graphicsDeviceDestroyFn()
    {
        delete this.activeTechnique;
        delete this.activeIndexBuffer;
        delete this.bindedVertexBuffer;

        if (this.immediateVertexBuffer)
        {
            this.immediateVertexBuffer.destroy();
            delete this.immediateVertexBuffer;
        }

        delete this.gl;
    }
};

// Constructor function
WebGLGraphicsDevice.create = function webGLGraphicsDeviceCreateFn(canvas, params)
{
    function getAvailableContext(canvas, params, contextList)
    {
        if (canvas.getContext)
        {
            var canvasParams = {
                    alpha: false,
                    stencil: true,
                    antialias: false
                };

            var multisample = params.multisample;
            if (multisample !== undefined && 1 < multisample)
            {
                canvasParams.antialias = true;
            }

            var numContexts = contextList.length, i;
            for (i = 0; i < numContexts; i += 1)
            {
                try
                {
                    var context = canvas.getContext(contextList[i], canvasParams);
                    if (context)
                    {
                        return context;
                    }
                }
                catch (ex)
                {
                }
            }
        }
        return null;
    }

    // TODO: Test if we can also use "webkit-3d" and "moz-webgl"
    var gl = getAvailableContext(canvas, params, ['webgl', 'experimental-webgl']);
    if (!gl)
    {
        return null;
    }

    var width = (gl.drawingBufferWidth || canvas.width);
    var height = (gl.drawingBufferHeight || canvas.height);

    gl.enable(gl.SCISSOR_TEST);
    gl.depthRange(0.0, 1.0);
    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
    //gl.hint(gl.GENERATE_MIPMAP_HINT, gl.NICEST);

    var gd = new WebGLGraphicsDevice();
    gd.gl = gl;
    gd.width = width;
    gd.height = height;

    var extensions = gl.getSupportedExtensions();
    if (extensions)
    {
        extensions = extensions.join(' ');
    }
    else
    {
        extensions = '';
    }
    gd.extensions = extensions;
    gd.shadingLanguageVersion = gl.getParameter(gl.SHADING_LANGUAGE_VERSION);
    gd.rendererVersion = gl.getParameter(gl.VERSION);
    gd.renderer = gl.getParameter(gl.RENDERER);
    gd.vendor = gl.getParameter(gl.VENDOR);

    if (extensions.indexOf('WEBGL_compressed_texture_s3tc') !== -1)
    {
        gd.WEBGL_compressed_texture_s3tc = true;
        if (extensions.indexOf('WEBKIT_WEBGL_compressed_texture_s3tc') !== -1)
        {
            gd.compressedTexturesExtension = gl.getExtension('WEBKIT_WEBGL_compressed_texture_s3tc');
        }
        else if (extensions.indexOf('MOZ_WEBGL_compressed_texture_s3tc') !== -1)
        {
            gd.compressedTexturesExtension = gl.getExtension('MOZ_WEBGL_compressed_texture_s3tc');
        }
        else
        {
            gd.compressedTexturesExtension = gl.getExtension('WEBGL_compressed_texture_s3tc');
        }
    }
    else if (extensions.indexOf('WEBKIT_WEBGL_compressed_textures') !== -1)
    {
        gd.compressedTexturesExtension = gl.getExtension('WEBKIT_WEBGL_compressed_textures');
    }

    var anisotropyExtension;
    if (extensions.indexOf('EXT_texture_filter_anisotropic') !== -1)
    {
        if (extensions.indexOf('MOZ_EXT_texture_filter_anisotropic') !== -1)
        {
            anisotropyExtension = gl.getExtension('MOZ_EXT_texture_filter_anisotropic');
        }
        else if (extensions.indexOf('WEBKIT_EXT_texture_filter_anisotropic') !== -1)
        {
            anisotropyExtension = gl.getExtension('WEBKIT_EXT_texture_filter_anisotropic');
        }
        else
        {
            anisotropyExtension = gl.getExtension('EXT_texture_filter_anisotropic');
        }
    }
    if (anisotropyExtension)
    {
        gd.TEXTURE_MAX_ANISOTROPY_EXT = anisotropyExtension.TEXTURE_MAX_ANISOTROPY_EXT;
        gd.maxAnisotropy = gl.getParameter(anisotropyExtension.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
    }
    else
    {
        gd.maxAnisotropy = 1;
    }

    gd.PRIMITIVE_POINTS         = gl.POINTS;
    gd.PRIMITIVE_LINES          = gl.LINES;
    gd.PRIMITIVE_LINE_LOOP      = gl.LINE_LOOP;
    gd.PRIMITIVE_LINE_STRIP     = gl.LINE_STRIP;
    gd.PRIMITIVE_TRIANGLES      = gl.TRIANGLES;
    gd.PRIMITIVE_TRIANGLE_STRIP = gl.TRIANGLE_STRIP;
    gd.PRIMITIVE_TRIANGLE_FAN   = gl.TRIANGLE_FAN;

    gd.INDEXFORMAT_UBYTE  = gl.UNSIGNED_BYTE;
    gd.INDEXFORMAT_USHORT = gl.UNSIGNED_SHORT;
    gd.INDEXFORMAT_UINT   = gl.UNSIGNED_INT;

    function getNormalizationScale(format)
    {
        if (format === gl.BYTE)
        {
            return 0x7f;
        }
        else if (format === gl.UNSIGNED_BYTE)
        {
            return 0xff;
        }
        else if (format === gl.SHORT)
        {
            return 0x7fff;
        }
        else if (format === gl.UNSIGNED_SHORT)
        {
            return 0xffff;
        }
        else if (format === gl.INT)
        {
            return 0x7fffffff;
        }
        else if (format === gl.UNSIGNED_INT)
        {
            return 0xffffffff;
        }
        else //if (format === gl.FLOAT)
        {
            return 1;
        }
    }

    function makeVertexformat(n, c, s, f, name)
    {
        var attributeFormat = {
                numComponents: c,
                stride: s,
                componentStride: (s / c),
                format: f,
                name: name
            };
        if (n)
        {
            attributeFormat.normalized = true;
            attributeFormat.normalizationScale = getNormalizationScale(f);
        }
        else
        {
            attributeFormat.normalized = false;
            attributeFormat.normalizationScale = 1;
        }

        if (typeof DataView !== 'undefined' && 'setFloat32' in DataView.prototype)
        {
            if (f === gl.BYTE)
            {
                attributeFormat.typedSetter = DataView.prototype.setInt8;
            }
            else if (f === gl.UNSIGNED_BYTE)
            {
                attributeFormat.typedSetter = DataView.prototype.setUint8;
            }
            else if (f === gl.SHORT)
            {
                attributeFormat.typedSetter = DataView.prototype.setInt16;
            }
            else if (f === gl.UNSIGNED_SHORT)
            {
                attributeFormat.typedSetter = DataView.prototype.setUint16;
            }
            else if (f === gl.INT)
            {
                attributeFormat.typedSetter = DataView.prototype.setInt32;
            }
            else if (f === gl.UNSIGNED_INT)
            {
                attributeFormat.typedSetter = DataView.prototype.setUint32;
            }
            else //if (f === gl.FLOAT)
            {
                attributeFormat.typedSetter = DataView.prototype.setFloat32;
            }
        }
        else
        {
            if (f === gl.BYTE)
            {
                attributeFormat.typedArray = Int8Array;
            }
            else if (f === gl.UNSIGNED_BYTE)
            {
                attributeFormat.typedArray = Uint8Array;
            }
            else if (f === gl.SHORT)
            {
                attributeFormat.typedArray = Int16Array;
            }
            else if (f === gl.UNSIGNED_SHORT)
            {
                attributeFormat.typedArray = Uint16Array;
            }
            else if (f === gl.INT)
            {
                attributeFormat.typedArray = Int32Array;
            }
            else if (f === gl.UNSIGNED_INT)
            {
                attributeFormat.typedArray = Uint32Array;
            }
            else //if (f === gl.FLOAT)
            {
                attributeFormat.typedArray = Float32Array;
            }
        }
        return attributeFormat;
    }

    gd.VERTEXFORMAT_BYTE4    = makeVertexformat(0, 4,  4, gl.BYTE, 'BYTE4');
    gd.VERTEXFORMAT_BYTE4N   = makeVertexformat(1, 4,  4, gl.BYTE, 'BYTE4N');
    gd.VERTEXFORMAT_UBYTE4   = makeVertexformat(0, 4,  4, gl.UNSIGNED_BYTE, 'UBYTE4');
    gd.VERTEXFORMAT_UBYTE4N  = makeVertexformat(1, 4,  4, gl.UNSIGNED_BYTE, 'UBYTE4N');
    gd.VERTEXFORMAT_SHORT2   = makeVertexformat(0, 2,  4, gl.SHORT, 'SHORT2');
    gd.VERTEXFORMAT_SHORT2N  = makeVertexformat(1, 2,  4, gl.SHORT, 'SHORT2N');
    gd.VERTEXFORMAT_SHORT4   = makeVertexformat(0, 4,  8, gl.SHORT, 'SHORT4');
    gd.VERTEXFORMAT_SHORT4N  = makeVertexformat(1, 4,  8, gl.SHORT, 'SHORT4N');
    gd.VERTEXFORMAT_USHORT2  = makeVertexformat(0, 2,  4, gl.UNSIGNED_SHORT, 'USHORT2');
    gd.VERTEXFORMAT_USHORT2N = makeVertexformat(1, 2,  4, gl.UNSIGNED_SHORT, 'USHORT2N');
    gd.VERTEXFORMAT_USHORT4  = makeVertexformat(0, 4,  8, gl.UNSIGNED_SHORT, 'USHORT4');
    gd.VERTEXFORMAT_USHORT4N = makeVertexformat(1, 4,  8, gl.UNSIGNED_SHORT, 'USHORT4N');
    gd.VERTEXFORMAT_FLOAT1   = makeVertexformat(0, 1,  4, gl.FLOAT, 'FLOAT1');
    gd.VERTEXFORMAT_FLOAT2   = makeVertexformat(0, 2,  8, gl.FLOAT, 'FLOAT2');
    gd.VERTEXFORMAT_FLOAT3   = makeVertexformat(0, 3, 12, gl.FLOAT, 'FLOAT3');
    gd.VERTEXFORMAT_FLOAT4   = makeVertexformat(0, 4, 16, gl.FLOAT, 'FLOAT4');

    gd.DEFAULT_SAMPLER = {
        minFilter : gl.LINEAR_MIPMAP_LINEAR,
        magFilter : gl.LINEAR,
        wrapS : gl.REPEAT,
        wrapT : gl.REPEAT,
        wrapR : gl.REPEAT,
        maxAnisotropy : 1
    };

    gd.cachedSamplers = {};

    var maxTextureUnit = 1;
    var maxUnit = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
    if (maxTextureUnit < maxUnit)
    {
        maxTextureUnit = maxUnit;
    }
    maxUnit = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
    if (maxTextureUnit < maxUnit)
    {
        maxTextureUnit = maxUnit;
    }

    var textureUnits = [];
    textureUnits.length = maxTextureUnit;
    for (var t = 0; t < maxTextureUnit; t += 1)
    {
        textureUnits[t] = {};
    }

    var defaultDepthFunc = gl.LEQUAL;
    var defaultBlendFuncSrc = gl.SRC_ALPHA;
    var defaultBlendFuncDst = gl.ONE_MINUS_SRC_ALPHA;
    var defaultCullFace = gl.BACK;
    var defaultFrontFace = gl.CCW;
    var defaultStencilFunc = gl.ALWAYS;
    var defaultStencilOp = gl.KEEP;

    var currentState = {
            depthTestEnable         : true,
            blendEnable             : false,
            cullFaceEnable          : true,
            stencilTestEnable       : false,
            polygonOffsetFillEnable : false,
            depthMask               : true,
            depthFunc               : defaultDepthFunc,
            blendSrc                : defaultBlendFuncSrc,
            blendDst                : defaultBlendFuncDst,
            cullFace                : defaultCullFace,
            frontFace               : defaultFrontFace,
            colorMask               : [true, true, true, true],
            stencilFunc             : defaultStencilFunc,
            stencilRef              : 0,
            stencilMask             : 0xffffffff,
            stencilFail             : defaultStencilOp,
            stencilZFail            : defaultStencilOp,
            stencilZPass            : defaultStencilOp,
            polygonOffsetFactor     : 0,
            polygonOffsetUnits      : 0,
            lineWidth               : 1,

            renderStatesToReset : [],

            viewportBox : [0, 0, width, height],
            scissorBox  : [0, 0, width, height],

            clearColor   : [0, 0, 0, 1],
            clearDepth   : 1.0,
            clearStencil : 0,

            activeTextureUnit : 0,
            maxTextureUnit    : maxTextureUnit,
            lastMaxTextureUnit: 0,
            textureUnits      : textureUnits,

            program : null
        };
    gd.state = currentState;

    // State handlers
    function setDepthTestEnable(enable)
    {
        if (currentState.depthTestEnable !== enable)
        {
            currentState.depthTestEnable = enable;
            if (enable)
            {
                gl.enable(gl.DEPTH_TEST);
            }
            else
            {
                gl.disable(gl.DEPTH_TEST);
            }
        }
    }

    function setDepthFunc(func)
    {
        if (currentState.depthFunc !== func)
        {
            currentState.depthFunc = func;
            gl.depthFunc(func);
        }
    }

    function setDepthMask(enable)
    {
        if (currentState.depthMask !== enable)
        {
            currentState.depthMask = enable;
            gl.depthMask(enable);
        }
    }

    function setBlendEnable(enable)
    {
        if (currentState.blendEnable !== enable)
        {
            currentState.blendEnable = enable;
            if (enable)
            {
                gl.enable(gl.BLEND);
            }
            else
            {
                gl.disable(gl.BLEND);
            }
        }
    }

    function setBlendFunc(src, dst)
    {
        if (currentState.blendSrc !== src || currentState.blendDst !== dst)
        {
            currentState.blendSrc = src;
            currentState.blendDst = dst;
            gl.blendFunc(src, dst);
        }
    }

    function setCullFaceEnable(enable)
    {
        if (currentState.cullFaceEnable !== enable)
        {
            currentState.cullFaceEnable = enable;
            if (enable)
            {
                gl.enable(gl.CULL_FACE);
            }
            else
            {
                gl.disable(gl.CULL_FACE);
            }
        }
    }

    function setCullFace(face)
    {
        if (currentState.cullFace !== face)
        {
            currentState.cullFace = face;
            gl.cullFace(face);
        }
    }

    function setFrontFace(face)
    {
        if (currentState.frontFace !== face)
        {
            currentState.frontFace = face;
            gl.frontFace(face);
        }
    }

    function setColorMask(mask0, mask1, mask2, mask3)
    {
        var colorMask = currentState.colorMask;
        if (colorMask[0] !== mask0 ||
            colorMask[1] !== mask1 ||
            colorMask[2] !== mask2 ||
            colorMask[3] !== mask3)
        {
            colorMask[0] = mask0;
            colorMask[1] = mask1;
            colorMask[2] = mask2;
            colorMask[3] = mask3;
            gl.colorMask(mask0, mask1, mask2, mask3);
        }
    }

    function setStencilTestEnable(enable)
    {
        if (currentState.stencilTestEnable !== enable)
        {
            currentState.stencilTestEnable = enable;
            if (enable)
            {
                gl.enable(gl.STENCIL_TEST);
            }
            else
            {
                gl.disable(gl.STENCIL_TEST);
            }
        }
    }

    function setStencilFunc(stencilFunc, stencilRef, stencilMask)
    {
        if (currentState.stencilFunc !== stencilFunc ||
            currentState.stencilRef !== stencilRef ||
            currentState.stencilMask !== stencilMask)
        {
            currentState.stencilFunc = stencilFunc;
            currentState.stencilRef = stencilRef;
            currentState.stencilMask = stencilMask;
            gl.stencilFunc(stencilFunc, stencilRef, stencilMask);
        }
    }

    function setStencilOp(stencilFail, stencilZfail, stencilZpass)
    {
        if (currentState.stencilFail !== stencilFail ||
            currentState.stencilZFail !== stencilZfail ||
            currentState.stencilZPass !== stencilZpass)
        {
            currentState.stencilFail = stencilFail;
            currentState.stencilZFail = stencilZfail;
            currentState.stencilZPass = stencilZpass;
            gl.stencilOp(stencilFail, stencilZfail, stencilZpass);
        }
    }

    function setPolygonOffsetFillEnable(enable)
    {
        if (currentState.polygonOffsetFillEnable !== enable)
        {
            currentState.polygonOffsetFillEnable = enable;
            if (enable)
            {
                gl.enable(gl.POLYGON_OFFSET_FILL);
            }
            else
            {
                gl.disable(gl.POLYGON_OFFSET_FILL);
            }
        }
    }

    function setPolygonOffset(factor, units)
    {
        if (currentState.polygonOffsetFactor !== factor ||
            currentState.polygonOffsetUnits !== units)
        {
            currentState.polygonOffsetFactor = factor;
            currentState.polygonOffsetUnits = units;
            gl.polygonOffset(factor, units);
        }
    }

    function setLineWidth(lineWidth)
    {
        if (currentState.lineWidth !== lineWidth)
        {
            currentState.lineWidth = lineWidth;
            gl.lineWidth(lineWidth);
        }
    }

    function resetDepthTestEnable()
    {
        //setDepthTestEnable(true);
        if (!currentState.depthTestEnable)
        {
            currentState.depthTestEnable = true;
            gl.enable(gl.DEPTH_TEST);
        }
    }

    function resetDepthFunc()
    {
        //setDepthFunc(defaultDepthFunc);
        var func = defaultDepthFunc;
        if (currentState.depthFunc !== func)
        {
            currentState.depthFunc = func;
            gl.depthFunc(func);
        }
    }

    function resetDepthMask()
    {
        //setDepthMask(true);
        if (!currentState.depthMask)
        {
            currentState.depthMask = true;
            gl.depthMask(true);
        }
    }

    function resetBlendEnable()
    {
        //setBlendEnable(false);
        if (currentState.blendEnable)
        {
            currentState.blendEnable = false;
            gl.disable(gl.BLEND);
        }
    }

    function resetBlendFunc()
    {
        //setBlendFunc(defaultBlendFuncSrc, defaultBlendFuncDst);
        var src = defaultBlendFuncSrc;
        var dst = defaultBlendFuncDst;
        if (currentState.blendSrc !== src || currentState.blendDst !== dst)
        {
            currentState.blendSrc = src;
            currentState.blendDst = dst;
            gl.blendFunc(src, dst);
        }
    }

    function resetCullFaceEnable()
    {
        //setCullFaceEnable(true);
        if (!currentState.cullFaceEnable)
        {
            currentState.cullFaceEnable = true;
            gl.enable(gl.CULL_FACE);
        }
    }

    function resetCullFace()
    {
        //setCullFace(defaultCullFace);
        var face = defaultCullFace;
        if (currentState.cullFace !== face)
        {
            currentState.cullFace = face;
            gl.cullFace(face);
        }
    }

    function resetFrontFace()
    {
        //setFrontFace(defaultFrontFace);
        var face = defaultFrontFace;
        if (currentState.frontFace !== face)
        {
            currentState.frontFace = face;
            gl.frontFace(face);
        }
    }

    function resetColorMask()
    {
        //setColorMask(true, true, true, true);
        var colorMask = currentState.colorMask;
        if (colorMask[0] !== true ||
            colorMask[1] !== true ||
            colorMask[2] !== true ||
            colorMask[3] !== true)
        {
            colorMask[0] = true;
            colorMask[1] = true;
            colorMask[2] = true;
            colorMask[3] = true;
            gl.colorMask(true, true, true, true);
        }
    }

    function resetStencilTestEnable()
    {
        //setStencilTestEnable(false);
        if (currentState.stencilTestEnable)
        {
            currentState.stencilTestEnable = false;
            gl.disable(gl.STENCIL_TEST);
        }
    }

    function resetStencilFunc()
    {
        //setStencilFunc(defaultStencilFunc, 0, 0xffffffff);
        var stencilFunc = defaultStencilFunc;
        if (currentState.stencilFunc !== stencilFunc ||
            currentState.stencilRef !== 0 ||
            currentState.stencilMask !== 0xffffffff)
        {
            currentState.stencilFunc = stencilFunc;
            currentState.stencilRef = 0;
            currentState.stencilMask = 0xffffffff;
            gl.stencilFunc(stencilFunc, 0, 0xffffffff);
        }
    }

    function resetStencilOp()
    {
        //setStencilOp(defaultStencilOp, defaultStencilOp, defaultStencilOp);
        var stencilOp = defaultStencilOp;
        if (currentState.stencilFail !== stencilOp ||
            currentState.stencilZFail !== stencilOp ||
            currentState.stencilZPass !== stencilOp)
        {
            currentState.stencilFail = stencilOp;
            currentState.stencilZFail = stencilOp;
            currentState.stencilZPass = stencilOp;
            gl.stencilOp(stencilOp, stencilOp, stencilOp);
        }
    }

    function resetPolygonOffsetFillEnable()
    {
        //setPolygonOffsetFillEnable(false);
        if (currentState.polygonOffsetFillEnable)
        {
            currentState.polygonOffsetFillEnable = false;
            gl.disable(gl.POLYGON_OFFSET_FILL);
        }
    }

    function resetPolygonOffset()
    {
        //setPolygonOffset(0, 0);
        if (currentState.polygonOffsetFactor !== 0 ||
            currentState.polygonOffsetUnits !== 0)
        {
            currentState.polygonOffsetFactor = 0;
            currentState.polygonOffsetUnits = 0;
            gl.polygonOffset(0, 0);
        }
    }

    function resetLineWidth()
    {
        //setLineWidth(1);
        if (currentState.lineWidth !== 1)
        {
            currentState.lineWidth = 1;
            gl.lineWidth(1);
        }
    }

    function parseBoolean(state)
    {
        if (typeof state === 'number')
        {
            return (state ? true : false);
        }
        if (typeof state !== 'boolean')
        {
            // TODO
            return null;
        }
        return [state];
    }

    function parseEnum(state)
    {
        if (typeof state !== 'number')
        {
            // TODO
            return null;
        }
        return [state];
    }

    function parseEnum2(state)
    {
        if (typeof state === 'object')
        {
            var value0 = state[0], value1 = state[1];
            if (typeof value0 !== 'number')
            {
                // TODO
                return null;
            }
            if (typeof value1 !== 'number')
            {
                // TODO
                return null;
            }
            return [value0, value1];
        }
        return null;
    }

    function parseEnum3(state)
    {
        if (typeof state === 'object')
        {
            var value0 = state[0], value1 = state[1], value2 = state[2];
            if (typeof value0 !== 'number')
            {
                // TODO
                return null;
            }
            if (typeof value1 !== 'number')
            {
                // TODO
                return null;
            }
            if (typeof value2 !== 'number')
            {
                // TODO
                return null;
            }
            return [value0, value1, value2];
        }
        return null;
    }

    function parseFloat(state)
    {
        if (typeof state !== 'number')
        {
            // TODO
            return null;
        }
        return [state];
    }

    function parseFloat2(state)
    {
        if (typeof state === 'object')
        {
            var value0 = state[0], value1 = state[1];
            if (typeof value0 !== 'number')
            {
                // TODO
                return null;
            }
            if (typeof value1 !== 'number')
            {
                // TODO
                return null;
            }
            return [value0, value1];
        }
        return null;
    }

    function parseColorMask(state)
    {
        if (typeof state === 'object')
        {
            var value0 = state[0], value1 = state[1], value2 = state[2], value3 = state[3];
            if (typeof value0 !== 'number')
            {
                // TODO
                return null;
            }
            if (typeof value1 !== 'number')
            {
                // TODO
                return null;
            }
            if (typeof value2 !== 'number')
            {
                // TODO
                return null;
            }
            if (typeof value3 !== 'number')
            {
                // TODO
                return null;
            }
            return [value0, value1, value2, value3];
        }
        return null;
    }

    var stateHandlers = {};
    function addStateHandler(name, sf, rf, pf, dv)
    {
        stateHandlers[name] = {
            set: sf,
            reset: rf,
            parse: pf,
            defaultValues: dv
        };
    }
    addStateHandler("DepthTestEnable", setDepthTestEnable, resetDepthTestEnable, parseBoolean, [true]);
    addStateHandler("DepthFunc", setDepthFunc, resetDepthFunc, parseEnum, [defaultDepthFunc]);
    addStateHandler("DepthMask", setDepthMask, resetDepthMask, parseBoolean, [true]);
    addStateHandler("BlendEnable", setBlendEnable, resetBlendEnable, parseBoolean, [false]);
    addStateHandler("BlendFunc", setBlendFunc, resetBlendFunc, parseEnum2, [defaultBlendFuncSrc, defaultBlendFuncDst]);
    addStateHandler("CullFaceEnable", setCullFaceEnable, resetCullFaceEnable, parseBoolean, [true]);
    addStateHandler("CullFace", setCullFace, resetCullFace, parseEnum, [defaultCullFace]);
    addStateHandler("FrontFace", setFrontFace, resetFrontFace, parseEnum, [defaultFrontFace]);
    addStateHandler("ColorMask", setColorMask, resetColorMask, parseColorMask, [true, true, true, true]);
    addStateHandler("StencilTestEnable", setStencilTestEnable, resetStencilTestEnable, parseBoolean, [false]);
    addStateHandler("StencilFunc", setStencilFunc, resetStencilFunc, parseEnum3, [defaultStencilFunc, 0, 0xffffffff]);
    addStateHandler("StencilOp", setStencilOp, resetStencilOp, parseEnum3, [defaultStencilOp, defaultStencilOp, defaultStencilOp]);
    addStateHandler("PolygonOffsetFillEnable", setPolygonOffsetFillEnable, resetPolygonOffsetFillEnable, parseBoolean, [false]);
    addStateHandler("PolygonOffset", setPolygonOffset, resetPolygonOffset, parseFloat2, [0, 0]);
    addStateHandler("LineWidth", setLineWidth, resetLineWidth, parseFloat, [1]);
    gd.stateHandlers = stateHandlers;

    gd.syncState();

    gd.videoRam = 0;
    gd.desktopWidth = window.screen.width;
    gd.desktopHeight = window.screen.height;

    if (Object.defineProperty)
    {
        Object.defineProperty(gd, "fullscreen", {
                get : function getFullscreenFn() {
                    return (document.fullscreenEnabled ||
                            document.mozFullScreen ||
                            document.webkitIsFullScreen ||
                            false);
                },
                set : function setFullscreenFn(newFullscreen) {
                    gd.requestFullScreen(newFullscreen);
                },
                enumerable : true,
                configurable : false
            });

        gd.checkFullScreen = function dummyCheckFullScreenFn()
        {
        };
    }
    else
    {
        gd.fullscreen = false;
        gd.oldFullscreen = false;
    }

    gd.clientStateMask = 0;
    gd.attributeMask = 0;
    gd.activeTechnique = null;
    gd.activeIndexBuffer = null;
    gd.bindedVertexBuffer = 0;
    gd.activeRenderTarget = null;

    gd.immediateVertexBuffer = gd.createVertexBuffer({
            numVertices: (256 * 1024 / 16),
            attributes: ['FLOAT4'],
            dynamic: true,
            'transient': true
        });
    gd.immediatePrimitive = -1;
    gd.immediateSemantics = [];

    gd.fps = 0;
    gd.numFrames = 0;
    gd.previousFrameTime = TurbulenzEngine.getTime();

    return gd;
};