var srcW = image.width;

var srcH = image.height;

if ((srcW > size) || (srcH > size)) {

var scale = size / Math.max(srcW, srcH);

var dstW = Math.floor(srcW * scale);

var dstH = Math.floor(srcH * scale);

console.warn('Image dimensions larger than max supported texture size of ' + size + '. ' +

'Resizing from ' + srcW + ', ' + srcH + ' to ' + dstW + ', ' + dstH + '.');

var canvas = document.createElement('canvas');

canvas.width = dstW;

canvas.height = dstH;

var context = canvas.getContext('2d');

context.drawImage(image, 0, 0, srcW, srcH, 0, 0, dstW, dstH);

return canvas;

}

return image;

var ua = window.navigator.userAgent;

var msie = ua.indexOf("MSIE ");

var trident = navigator.userAgent.match(/Trident.*rv:11\./);

return (msie > 0 || !!trident);

var texture = gl.createTexture();

gl.bindTexture(gl.TEXTURE_2D, texture);

gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);

gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);

gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);

gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);

var width = 2;

var height = 2;

gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, pixelFormat, null);

// Try to use this texture as a render target.

var fbo = gl.createFramebuffer();

gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);

gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);

gl.bindTexture(gl.TEXTURE_2D, null);

// It is legal for a WebGL implementation exposing the OES_texture_float extension to

// support floating-point textures but not as attachments to framebuffer objects.

if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) {

gl.deleteTexture(texture);

return false;

}

gl.deleteTexture(texture);

gl.bindFramebuffer(gl.FRAMEBUFFER, null);

return true;

var storage = new ArrayBuffer(16);

var bufferId = gl.createBuffer();

gl.bindBuffer(gl.ARRAY_BUFFER, bufferId);

gl.bufferData(gl.ARRAY_BUFFER, storage, gl.STATIC_DRAW);

gl.getError(); // Clear error flag

gl.vertexAttribPointer(0, 4, gl.UNSIGNED_BYTE, false, 4, 0);

var supported = (gl.getError() === 0);

gl.deleteBuffer(bufferId);

return supported;

var i;

this.canvas = canvas;

this.shader = null;

this.vertexBuffers = [];

this.vbOffsets = [];

this._enableAutoInstancing = false;

this.autoInstancingMaxObjects = 16384;

this.attributesInvalidated = true;

this.instancedAttribs = { };

this.enabledAttributes = { };

this.transformFeedbackBuffer = null;

this.activeFramebuffer = null;

this.boundBuffers = [ null, null ];

this.textureUnit = 0;

this.textureUnits = [];

this._maxPixelRatio = 1;

this.renderTarget = null;

this.feedback = null;

// local width/height without pixelRatio applied

this._width = 0;

this._height = 0;

this.updateClientRect();

// Array of WebGL objects that need to be re-initialized after a context restore event

this.shaders = [];

this.buffers = [];

this.textures = [];

this.targets = [];

// Add handlers for when the WebGL context is lost or restored

this.contextLost = false;

canvas.addEventListener("webglcontextlost", function (event) {

event.preventDefault();

this.contextLost = true;

// #ifdef DEBUG

console.log('pc.GraphicsDevice: WebGL context lost.');

// #endif

this.fire('devicelost');

}.bind(this), false);

canvas.addEventListener("webglcontextrestored", function () {

// #ifdef DEBUG

console.log('pc.GraphicsDevice: WebGL context restored.');

// #endif

this.initializeContext();

this.contextLost = false;

this.fire('devicerestored');

}.bind(this), false);

// Retrieve the WebGL context

var preferWebGl2 = (options && options.preferWebGl2 !== undefined) ? options.preferWebGl2 : true;

var names = preferWebGl2 ? ["webgl2", "experimental-webgl2", "webgl", "experimental-webgl"] :

["webgl", "experimental-webgl"];

var gl = null;

options = options || {};

options.stencil = true;

for (i = 0; i < names.length; i++) {

try {

gl = canvas.getContext(names[i], options);

} catch (e) { }

if (gl) {

this.webgl2 = preferWebGl2 && i < 2;

break;

}

}

if (!gl) {

throw new Error("WebGL not supported");

}

this.gl = gl;

this.initializeExtensions();

this.initializeCapabilities();

this.initializeRenderState();

for (i = 0; i < this.maxCombinedTextures; i++) {

this.textureUnits.push([null, null, null]);

}

// put the rest of the constructor in a function

// so that the constructor remains small. Small constructors

// are optimized by Firefox due to type inference

(function () {

this.defaultClearOptions = {

color: [0, 0, 0, 1],

depth: 1,

stencil: 0,

flags: pc.CLEARFLAG_COLOR | pc.CLEARFLAG_DEPTH

};

this.glAddress = [

gl.REPEAT,

gl.CLAMP_TO_EDGE,

gl.MIRRORED_REPEAT

];

this.glBlendEquation = [

gl.FUNC_ADD,

gl.FUNC_SUBTRACT,

gl.FUNC_REVERSE_SUBTRACT,

this.webgl2 ? gl.MIN : this.extBlendMinmax ? this.extBlendMinmax.MIN_EXT : gl.FUNC_ADD,

this.webgl2 ? gl.MAX : this.extBlendMinmax ? this.extBlendMinmax.MAX_EXT : gl.FUNC_ADD

];

this.glBlendFunction = [

gl.ZERO,

gl.ONE,

gl.SRC_COLOR,

gl.ONE_MINUS_SRC_COLOR,

gl.DST_COLOR,

gl.ONE_MINUS_DST_COLOR,

gl.SRC_ALPHA,

gl.SRC_ALPHA_SATURATE,

gl.ONE_MINUS_SRC_ALPHA,

gl.DST_ALPHA,

gl.ONE_MINUS_DST_ALPHA

];

this.glComparison = [

gl.NEVER,

gl.LESS,

gl.EQUAL,

gl.LEQUAL,

gl.GREATER,

gl.NOTEQUAL,

gl.GEQUAL,

gl.ALWAYS

];

this.glStencilOp = [

gl.KEEP,

gl.ZERO,

gl.REPLACE,

gl.INCR,

gl.INCR_WRAP,

gl.DECR,

gl.DECR_WRAP,

gl.INVERT

];

this.glClearFlag = [

0,

gl.COLOR_BUFFER_BIT,

gl.DEPTH_BUFFER_BIT,

gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT,

gl.STENCIL_BUFFER_BIT,

gl.STENCIL_BUFFER_BIT | gl.COLOR_BUFFER_BIT,

gl.STENCIL_BUFFER_BIT | gl.DEPTH_BUFFER_BIT,

gl.STENCIL_BUFFER_BIT | gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT

];

this.glCull = [

0,

gl.BACK,

gl.FRONT,

gl.FRONT_AND_BACK

];

this.glFilter = [

gl.NEAREST,

gl.LINEAR,

gl.NEAREST_MIPMAP_NEAREST,

gl.NEAREST_MIPMAP_LINEAR,

gl.LINEAR_MIPMAP_NEAREST,

gl.LINEAR_MIPMAP_LINEAR

];

this.glPrimitive = [

gl.POINTS,

gl.LINES,

gl.LINE_LOOP,

gl.LINE_STRIP,

gl.TRIANGLES,

gl.TRIANGLE_STRIP,

gl.TRIANGLE_FAN

];

this.glType = [

gl.BYTE,

gl.UNSIGNED_BYTE,

gl.SHORT,

gl.UNSIGNED_SHORT,

gl.INT,

gl.UNSIGNED_INT,

gl.FLOAT

];

this.targetToSlot = {};

this.targetToSlot[gl.TEXTURE_2D] = 0;

this.targetToSlot[gl.TEXTURE_CUBE_MAP] = 1;

this.targetToSlot[gl.TEXTURE_3D] = 2;

this.targetToSlot[gl.ARRAY_BUFFER] = 0;

this.targetToSlot[gl.ELEMENT_ARRAY_BUFFER] = 1;

// Define the uniform commit functions

var scopeX, scopeY, scopeZ, scopeW;

var uniformValue;

this.commitFunction = [];

this.commitFunction[pc.UNIFORMTYPE_BOOL] = function (uniform, value) {

if (uniform.value !== value) {

gl.uniform1i(uniform.locationId, value);

uniform.value = value;

}

};

this.commitFunction[pc.UNIFORMTYPE_INT] = this.commitFunction[pc.UNIFORMTYPE_BOOL];

this.commitFunction[pc.UNIFORMTYPE_FLOAT] = function (uniform, value) {

if (uniform.value !== value) {

gl.uniform1f(uniform.locationId, value);

uniform.value = value;

}

};

this.commitFunction[pc.UNIFORMTYPE_VEC2] = function (uniform, value) {

uniformValue = uniform.value;

scopeX = value[0];

scopeY = value[1];

if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY) {

gl.uniform2fv(uniform.locationId, value);

uniformValue[0] = scopeX;

uniformValue[1] = scopeY;

}

};

this.commitFunction[pc.UNIFORMTYPE_VEC3] = function (uniform, value) {

uniformValue = uniform.value;

scopeX = value[0];

scopeY = value[1];

scopeZ = value[2];

if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ) {

gl.uniform3fv(uniform.locationId, value);

uniformValue[0] = scopeX;

uniformValue[1] = scopeY;

uniformValue[2] = scopeZ;

}

};

this.commitFunction[pc.UNIFORMTYPE_VEC4] = function (uniform, value) {

uniformValue = uniform.value;

scopeX = value[0];

scopeY = value[1];

scopeZ = value[2];

scopeW = value[3];

if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ || uniformValue[3] !== scopeW) {

gl.uniform4fv(uniform.locationId, value);

uniformValue[0] = scopeX;

uniformValue[1] = scopeY;

uniformValue[2] = scopeZ;

uniformValue[3] = scopeW;

}

};

this.commitFunction[pc.UNIFORMTYPE_IVEC2] = function (uniform, value) {

uniformValue = uniform.value;

scopeX = value[0];

scopeY = value[1];

if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY) {

gl.uniform2iv(uniform.locationId, value);

uniformValue[0] = scopeX;

uniformValue[1] = scopeY;

}

};

this.commitFunction[pc.UNIFORMTYPE_BVEC2] = this.commitFunction[pc.UNIFORMTYPE_IVEC2];

this.commitFunction[pc.UNIFORMTYPE_IVEC3] = function (uniform, value) {

uniformValue = uniform.value;

scopeX = value[0];

scopeY = value[1];

scopeZ = value[2];

if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ) {

gl.uniform3iv(uniform.locationId, value);

uniformValue[0] = scopeX;

uniformValue[1] = scopeY;

uniformValue[2] = scopeZ;

}

};

this.commitFunction[pc.UNIFORMTYPE_BVEC3] = this.commitFunction[pc.UNIFORMTYPE_IVEC3];

this.commitFunction[pc.UNIFORMTYPE_IVEC4] = function (uniform, value) {

uniformValue = uniform.value;

scopeX = value[0];

scopeY = value[1];

scopeZ = value[2];

scopeW = value[3];

if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ || uniformValue[3] !== scopeW) {

gl.uniform4iv(uniform.locationId, value);

uniformValue[0] = scopeX;

uniformValue[1] = scopeY;

uniformValue[2] = scopeZ;

uniformValue[3] = scopeW;

}

};

this.commitFunction[pc.UNIFORMTYPE_BVEC4] = this.commitFunction[pc.UNIFORMTYPE_IVEC4];

this.commitFunction[pc.UNIFORMTYPE_MAT2] = function (uniform, value) {

gl.uniformMatrix2fv(uniform.locationId, false, value);

};

this.commitFunction[pc.UNIFORMTYPE_MAT3] = function (uniform, value) {

gl.uniformMatrix3fv(uniform.locationId, false, value);

};

this.commitFunction[pc.UNIFORMTYPE_MAT4] = function (uniform, value) {

gl.uniformMatrix4fv(uniform.locationId, false, value);

};

this.commitFunction[pc.UNIFORMTYPE_FLOATARRAY] = function (uniform, value) {

gl.uniform1fv(uniform.locationId, value);

};

// Create the ScopeNamespace for shader attributes and variables

this.scope = new pc.ScopeSpace("Device");

this.programLib = new pc.ProgramLibrary(this);

for (var generator in pc.programlib)

this.programLib.register(generator, pc.programlib[generator]);

pc.events.attach(this);

this.supportsBoneTextures = this.extTextureFloat && this.maxVertexTextures > 0;

this.useTexCubeLod = this.extTextureLod && this.maxTextures < 16;

// Calculate an estimate of the maximum number of bones that can be uploaded to the GPU

// based on the number of available uniforms and the number of uniforms required for non-

// bone data. This is based off of the Standard shader. A user defined shader may have

// even less space available for bones so this calculated value can be overridden via

// pc.GraphicsDevice.setBoneLimit.

var numUniforms = this.vertexUniformsCount;

numUniforms -= 4 * 4; // Model, view, projection and shadow matrices

numUniforms -= 8; // 8 lights max, each specifying a position vector

numUniforms -= 1; // Eye position

numUniforms -= 4 * 4; // Up to 4 texture transforms

this.boneLimit = Math.floor(numUniforms / 4);

// Put a limit on the number of supported bones before skin partitioning must be performed

// Some GPUs have demonstrated performance issues if the number of vectors allocated to the

// skin matrix palette is left unbounded

this.boneLimit = Math.min(this.boneLimit, 128);

if (this.unmaskedRenderer === 'Mali-450 MP') {

this.boneLimit = 34;

}

if (this.unmaskedRenderer === 'Apple A8 GPU') {

this.forceCpuParticles = true;

}

// Profiler stats

this._drawCallsPerFrame = 0;

this._shaderSwitchesPerFrame = 0;

this._primsPerFrame = [];

for (i = pc.PRIMITIVE_POINTS; i <= pc.PRIMITIVE_TRIFAN; i++) {

this._primsPerFrame[i] = 0;

}

this._renderTargetCreationTime = 0;

this._vram = {

// #ifdef PROFILER

texShadow: 0,

texAsset: 0,

texLightmap: 0,

// #endif

tex: 0,

vb: 0,

ib: 0

};

this._shaderStats = {

vsCompiled: 0,

fsCompiled: 0,

linked: 0,

materialShaders: 0,

compileTime: 0

};

// Handle IE11's inability to take UNSIGNED_BYTE as a param for vertexAttribPointer

this.supportsUnsignedByte = testUnsignedByteAttribute(gl);

this.constantTexSource = this.scope.resolve("source");

if (!pc._benchmarked) {

if (this.extTextureFloat) {

if (this.webgl2) {

// In WebGL2 float texture renderability is dictated by the EXT_color_buffer_float extension

this.extTextureFloatRenderable = this.extColorBufferFloat;

} else {

// In WebGL1 we should just try rendering into a float texture

this.extTextureFloatRenderable = testRenderable(gl, gl.FLOAT);

}

}

if (this.extTextureHalfFloat) {

if (this.webgl2) {

// EXT_color_buffer_float should affect both float and halffloat formats

this.extTextureHalfFloatRenderable = this.extColorBufferFloat;

} else {

// Manual render check for half float

this.extTextureHalfFloatRenderable = testRenderable(gl, this.extTextureHalfFloat.HALF_FLOAT_OES);

}

}

if (this.extTextureFloatRenderable) {

var device = this;

var chunks = pc.shaderChunks;

var test1 = chunks.createShaderFromCode(device, chunks.fullscreenQuadVS, chunks.precisionTestPS, "ptest1");

var test2 = chunks.createShaderFromCode(device, chunks.fullscreenQuadVS, chunks.precisionTest2PS, "ptest2");

var size = 1;

var tex = new pc.Texture(device, {

format: pc.PIXELFORMAT_RGBA32F,

width: size,

height: size,

mipmaps: false,

minFilter: pc.FILTER_NEAREST,

magFilter: pc.FILTER_NEAREST

});

var targ = new pc.RenderTarget(device, tex, {

depth: false

});

pc.drawQuadWithShader(device, targ, test1);

var tex2 = new pc.Texture(device, {

format: pc.PIXELFORMAT_R8_G8_B8_A8,

width: size,

height: size,

mipmaps: false,

minFilter: pc.FILTER_NEAREST,

magFilter: pc.FILTER_NEAREST

});

var targ2 = new pc.RenderTarget(device, tex2, {

depth: false

});

this.constantTexSource.setValue(tex);

pc.drawQuadWithShader(device, targ2, test2);

var pixels = new Uint8Array(size * size * 4);

gl.bindFramebuffer(gl.FRAMEBUFFER, targ2._glFrameBuffer);

gl.readPixels(0, 0, size, size, gl.RGBA, gl.UNSIGNED_BYTE, pixels);

var x = pixels[0] / 255.0;

var y = pixels[1] / 255.0;

var z = pixels[2] / 255.0;

var w = pixels[3] / 255.0;

var f = x / (256.0 * 256.0 * 256.0) + y / (256.0 * 256.0) + z / 256.0 + w;

this.extTextureFloatHighPrecision = f === 0.0;

tex.destroy();

targ.destroy();

tex2.destroy();

targ2.destroy();

pc.destroyPostEffectQuad();

gl.bindFramebuffer(gl.FRAMEBUFFER, null);

}

pc.extTextureFloatRenderable = this.extTextureFloatRenderable;

pc.extTextureHalfFloatRenderable = this.extTextureHalfFloatRenderable;

pc.extTextureFloatHighPrecision = this.extTextureFloatHighPrecision;

pc._benchmarked = true;

} else {

this.extTextureFloatRenderable = pc.extTextureFloatRenderable;

this.extTextureHalfFloatRenderable = pc.extTextureHalfFloatRenderable;

this.extTextureFloatHighPrecision = pc.extTextureFloatHighPrecision;

}

}).call(this);

var gl = this.gl;

var precision = "highp";

// Query the precision supported by ints and floats in vertex and fragment shaders.

// Note that getShaderPrecisionFormat is not guaranteed to be present (such as some

// instances of the default Android browser). In this case, assume highp is available.

if (gl.getShaderPrecisionFormat) {

var vertexShaderPrecisionHighpFloat = gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT);

var vertexShaderPrecisionMediumpFloat = gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.MEDIUM_FLOAT);

var fragmentShaderPrecisionHighpFloat = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT);

var fragmentShaderPrecisionMediumpFloat = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT );

var highpAvailable = vertexShaderPrecisionHighpFloat.precision > 0 && fragmentShaderPrecisionHighpFloat.precision > 0;

var mediumpAvailable = vertexShaderPrecisionMediumpFloat.precision > 0 && fragmentShaderPrecisionMediumpFloat.precision > 0;

if (!highpAvailable) {

if (mediumpAvailable) {

precision = "mediump";

// #ifdef DEBUG

console.warn("WARNING: highp not supported, using mediump");

// #endif

} else {

precision = "lowp";

// #ifdef DEBUG

console.warn( "WARNING: highp and mediump not supported, using lowp" );

// #endif

}

}

}

return precision;

var gl = this.gl;

if (this.webgl2) {

this.extBlendMinmax = true;

this.extDrawBuffers = true;

this.extInstancing = true;

this.extStandardDerivatives = true;

this.extTextureFloat = true;

this.extTextureHalfFloat = true;

this.extTextureHalfFloatLinear = true;

this.extTextureLod = true;

this.extUintElement = true;

} else {

this.extBlendMinmax = gl.getExtension("EXT_blend_minmax");

this.extDrawBuffers = gl.getExtension('EXT_draw_buffers');

this.extInstancing = gl.getExtension("ANGLE_instanced_arrays");

this.extStandardDerivatives = gl.getExtension("OES_standard_derivatives");

this.extTextureFloat = gl.getExtension("OES_texture_float");

this.extTextureHalfFloat = gl.getExtension("OES_texture_half_float");

this.extTextureHalfFloatLinear = gl.getExtension("OES_texture_half_float_linear");

this.extTextureLod = gl.getExtension('EXT_shader_texture_lod');

this.extUintElement = gl.getExtension("OES_element_index_uint");

}

this.extRendererInfo = gl.getExtension('WEBGL_debug_renderer_info');

this.extTextureFloatLinear = gl.getExtension("OES_texture_float_linear");

this.extColorBufferFloat = gl.getExtension('EXT_color_buffer_float');

this.extTextureFilterAnisotropic = gl.getExtension('EXT_texture_filter_anisotropic') ||

gl.getExtension('WEBKIT_EXT_texture_filter_anisotropic');

this.extCompressedTextureETC1 = gl.getExtension('WEBGL_compressed_texture_etc1');

this.extCompressedTexturePVRTC = gl.getExtension('WEBGL_compressed_texture_pvrtc') ||

gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc');

this.extCompressedTextureS3TC = gl.getExtension('WEBGL_compressed_texture_s3tc') ||

gl.getExtension('WEBKIT_WEBGL_compressed_texture_s3tc');

// IE 11 can't use mip maps with S3TC

if (this.extCompressedTextureS3TC && _isIE())

this.extCompressedTextureS3TC = null;

var gl = this.gl;

this.maxPrecision = this.precision = this.getPrecision();

var contextAttribs = gl.getContextAttributes();

this.supportsMsaa = contextAttribs.antialias;

this.supportsStencil = contextAttribs.stencil;

// Query parameter values from the WebGL context

this.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);

this.maxCubeMapSize = gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE);

this.maxRenderBufferSize = gl.getParameter(gl.MAX_RENDERBUFFER_SIZE);

this.maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);

this.maxCombinedTextures = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);

this.maxVertexTextures = gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS);

this.vertexUniformsCount = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS);

this.fragmentUniformsCount = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS);

this.unmaskedRenderer = this.extRendererInfo ? gl.getParameter(this.extRendererInfo.UNMASKED_RENDERER_WEBGL) : '';

this.unmaskedVendor = this.extRendererInfo ? gl.getParameter(this.extRendererInfo.UNMASKED_VENDOR_WEBGL) : '';

if (this.webgl2) {

this.maxDrawBuffers = gl.getParameter(gl.MAX_DRAW_BUFFERS);

this.maxColorAttachments = gl.getParameter(gl.MAX_COLOR_ATTACHMENTS);

this.maxVolumeSize = gl.getParameter(gl.MAX_3D_TEXTURE_SIZE);

} else {

this.maxDrawBuffers = this.extDrawBuffers ? gl.getParameter(this.extDrawBuffers.MAX_DRAW_BUFFERS_EXT) : 1;

this.maxColorAttachments = this.extDrawBuffers ? gl.getParameter(this.extDrawBuffers.MAX_COLOR_ATTACHMENTS_EXT) : 1;

this.maxVolumeSize = 1;

}

var gl = this.gl;

// Initialize render state to a known start state

this.blending = false;

gl.disable(gl.BLEND);

this.blendSrc = pc.BLENDMODE_ONE;

this.blendDst = pc.BLENDMODE_ZERO;

this.blendSrcAlpha = pc.BLENDMODE_ONE;

this.blendDstAlpha = pc.BLENDMODE_ZERO;

this.separateAlphaBlend = false;

this.blendEquation = pc.BLENDEQUATION_ADD;

this.blendAlphaEquation = pc.BLENDEQUATION_ADD;

this.separateAlphaEquation = false;

gl.blendFunc(gl.ONE, gl.ZERO);

gl.blendEquation(gl.FUNC_ADD);

this.writeRed = true;

this.writeGreen = true;

this.writeBlue = true;

this.writeAlpha = true;

gl.colorMask(true, true, true, true);

this.cullMode = pc.CULLFACE_BACK;

gl.enable(gl.CULL_FACE);

gl.cullFace(gl.BACK);

this.depthTest = true;

gl.enable(gl.DEPTH_TEST);

this.depthFunc = pc.FUNC_LESSEQUAL;

gl.depthFunc(gl.LEQUAL);

this.depthWrite = true;

gl.depthMask(true);

this.stencil = false;

gl.disable(gl.STENCIL_TEST);

this.stencilFuncFront = this.stencilFuncBack = pc.FUNC_ALWAYS;

this.stencilRefFront = this.stencilRefBack = 0;

this.stencilMaskFront = this.stencilMaskBack = 0xFF;

gl.stencilFunc(gl.ALWAYS, 0, 0xFF);

this.stencilFailFront = this.stencilFailBack = pc.STENCILOP_KEEP;

this.stencilZfailFront = this.stencilZfailBack = pc.STENCILOP_KEEP;

this.stencilZpassFront = this.stencilZpassBack = pc.STENCILOP_KEEP;

this.stencilWriteMaskFront = 0xFF;

this.stencilWriteMaskBack = 0xFF;