import { REVISION, MaxEquation, MinEquation, RGB_ETC1_Format, RGBA_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGB_PVRTC_2BPPV1_Format, RGB_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT5_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT1_Format, RGB_S3TC_DXT1_Format, SrcAlphaSaturateFactor, OneMinusDstColorFactor, DstColorFactor, OneMinusDstAlphaFactor, DstAlphaFactor, OneMinusSrcAlphaFactor, SrcAlphaFactor, OneMinusSrcColorFactor, SrcColorFactor, OneFactor, ZeroFactor, ReverseSubtractEquation, SubtractEquation, AddEquation, DepthFormat, DepthStencilFormat, LuminanceAlphaFormat, LuminanceFormat, RGBAFormat, RGBFormat, AlphaFormat, HalfFloatType, FloatType, UnsignedIntType, IntType, UnsignedShortType, ShortType, ByteType, UnsignedInt248Type, UnsignedShort565Type, UnsignedShort5551Type, UnsignedShort4444Type, UnsignedByteType, LinearMipMapLinearFilter, LinearMipMapNearestFilter, LinearFilter, NearestMipMapLinearFilter, NearestMipMapNearestFilter, NearestFilter, MirroredRepeatWrapping, ClampToEdgeWrapping, RepeatWrapping, FrontFaceDirectionCW, NoBlending, BackSide, DoubleSide, TriangleFanDrawMode, TriangleStripDrawMode, TrianglesDrawMode, NoColors, FlatShading, LinearToneMapping } from '../constants';

import { Matrix4 } from '../math/Matrix4';

import { WebGLUniforms } from './webgl/WebGLUniforms';

import { UniformsUtils } from './shaders/UniformsUtils';

import { ShaderLib } from './shaders/ShaderLib';

import { LensFlarePlugin } from './webgl/plugins/LensFlarePlugin';

import { SpritePlugin } from './webgl/plugins/SpritePlugin';

import { WebGLShadowMap } from './webgl/WebGLShadowMap';

import { ShaderMaterial } from '../materials/ShaderMaterial';

import { Mesh } from '../objects/Mesh';

import { BoxBufferGeometry } from '../geometries/BoxBufferGeometry';

import { PlaneBufferGeometry } from '../geometries/PlaneBufferGeometry';

import { MeshBasicMaterial } from '../materials/MeshBasicMaterial';

import { PerspectiveCamera } from '../cameras/PerspectiveCamera';

import { OrthographicCamera } from '../cameras/OrthographicCamera';

import { WebGLIndexedBufferRenderer } from './webgl/WebGLIndexedBufferRenderer';

import { WebGLBufferRenderer } from './webgl/WebGLBufferRenderer';

import { WebGLLights } from './webgl/WebGLLights';

import { WebGLPrograms } from './webgl/WebGLPrograms';

import { WebGLObjects } from './webgl/WebGLObjects';

import { WebGLTextures } from './webgl/WebGLTextures';

import { WebGLProperties } from './webgl/WebGLProperties';

import { WebGLState } from './webgl/WebGLState';

import { WebGLCapabilities } from './webgl/WebGLCapabilities';

import { BufferGeometry } from '../core/BufferGeometry';

import { WebGLExtensions } from './webgl/WebGLExtensions';

import { Vector3 } from '../math/Vector3';

import { Sphere } from '../math/Sphere';

import { WebGLClipping } from './webgl/WebGLClipping';

import { Frustum } from '../math/Frustum';

import { Vector4 } from '../math/Vector4';

import { Color } from '../math/Color';

/**

* @author supereggbert / http://www.paulbrunt.co.uk/

* @author mrdoob / http://mrdoob.com/

* @author alteredq / http://alteredqualia.com/

* @author szimek / https://github.com/szimek/

* @author tschw

*/

function WebGLRenderer( parameters ) {

console.log( 'THREE.WebGLRenderer', REVISION );

parameters = parameters || {};

var _canvas = parameters.canvas !== undefined ? parameters.canvas : document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' ),

_context = parameters.context !== undefined ? parameters.context : null,

_alpha = parameters.alpha !== undefined ? parameters.alpha : false,

_depth = parameters.depth !== undefined ? parameters.depth : true,

_stencil = parameters.stencil !== undefined ? parameters.stencil : true,

_antialias = parameters.antialias !== undefined ? parameters.antialias : false,

_premultipliedAlpha = parameters.premultipliedAlpha !== undefined ? parameters.premultipliedAlpha : true,

_preserveDrawingBuffer = parameters.preserveDrawingBuffer !== undefined ? parameters.preserveDrawingBuffer : false;

var lights = [];

var opaqueObjects = [];

var opaqueObjectsLastIndex = - 1;

var transparentObjects = [];

var transparentObjectsLastIndex = - 1;

var morphInfluences = new Float32Array( 8 );

var sprites = [];

var lensFlares = [];

// public properties

this.domElement = _canvas;

this.context = null;

// clearing

this.autoClear = true;

this.autoClearColor = true;

this.autoClearDepth = true;

this.autoClearStencil = true;

// scene graph

this.sortObjects = true;

// user-defined clipping

this.clippingPlanes = [];

this.localClippingEnabled = false;

// physically based shading

this.gammaFactor = 2.0; // for backwards compatibility

this.gammaInput = false;

this.gammaOutput = false;

// physical lights

this.physicallyCorrectLights = false;

// tone mapping

this.toneMapping = LinearToneMapping;

this.toneMappingExposure = 1.0;

this.toneMappingWhitePoint = 1.0;

// morphs

this.maxMorphTargets = 8;

this.maxMorphNormals = 4;

// internal properties

var _this = this,

// internal state cache

_currentProgram = null,

_currentRenderTarget = null,

_currentFramebuffer = null,

_currentMaterialId = - 1,

_currentGeometryProgram = '',

_currentCamera = null,

_currentScissor = new Vector4(),

_currentScissorTest = null,

_currentViewport = new Vector4(),

//

_usedTextureUnits = 0,

//

_clearColor = new Color( 0x000000 ),

_clearAlpha = 0,

_width = _canvas.width,

_height = _canvas.height,

_pixelRatio = 1,

_scissor = new Vector4( 0, 0, _width, _height ),

_scissorTest = false,

_viewport = new Vector4( 0, 0, _width, _height ),

// frustum

_frustum = new Frustum(),

// clipping

_clipping = new WebGLClipping(),

_clippingEnabled = false,

_localClippingEnabled = false,

_sphere = new Sphere(),

// camera matrices cache

_projScreenMatrix = new Matrix4(),

_vector3 = new Vector3(),

// light arrays cache

_lights = {

hash: '',

ambient: [ 0, 0, 0 ],

directional: [],

directionalShadowMap: [],

directionalShadowMatrix: [],

spot: [],

spotShadowMap: [],

spotShadowMatrix: [],

point: [],

pointShadowMap: [],

pointShadowMatrix: [],

hemi: [],

shadows: []

},

// info

_infoRender = {

calls: 0,

vertices: 0,

faces: 0,

points: 0

};

this.info = {

render: _infoRender,

memory: {

geometries: 0,

textures: 0

},

programs: null

};

// initialize

var _gl;

try {

var attributes = {

alpha: _alpha,

depth: _depth,

stencil: _stencil,

antialias: _antialias,

premultipliedAlpha: _premultipliedAlpha,

preserveDrawingBuffer: _preserveDrawingBuffer

};

_gl = _context || _canvas.getContext( 'webgl', attributes ) || _canvas.getContext( 'experimental-webgl', attributes );

if ( _gl === null ) {

if ( _canvas.getContext( 'webgl' ) !== null ) {

throw 'Error creating WebGL context with your selected attributes.';

} else {

throw 'Error creating WebGL context.';

}

}

// Some experimental-webgl implementations do not have getShaderPrecisionFormat

if ( _gl.getShaderPrecisionFormat === undefined ) {

_gl.getShaderPrecisionFormat = function () {

return { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 };

};

}

_canvas.addEventListener( 'webglcontextlost', onContextLost, false );

} catch ( error ) {

console.error( 'THREE.WebGLRenderer: ' + error );

}

var extensions = new WebGLExtensions( _gl );

extensions.get( 'WEBGL_depth_texture' );

extensions.get( 'OES_texture_float' );

extensions.get( 'OES_texture_float_linear' );

extensions.get( 'OES_texture_half_float' );

extensions.get( 'OES_texture_half_float_linear' );

extensions.get( 'OES_standard_derivatives' );

extensions.get( 'ANGLE_instanced_arrays' );

if ( extensions.get( 'OES_element_index_uint' ) ) {

BufferGeometry.MaxIndex = 4294967296;

}

var capabilities = new WebGLCapabilities( _gl, extensions, parameters );

var state = new WebGLState( _gl, extensions, paramThreeToGL );

var properties = new WebGLProperties();

var textures = new WebGLTextures( _gl, extensions, state, properties, capabilities, paramThreeToGL, this.info );

var objects = new WebGLObjects( _gl, properties, this.info );

var programCache = new WebGLPrograms( this, capabilities );

var lightCache = new WebGLLights();

this.info.programs = programCache.programs;

var bufferRenderer = new WebGLBufferRenderer( _gl, extensions, _infoRender );

var indexedBufferRenderer = new WebGLIndexedBufferRenderer( _gl, extensions, _infoRender );

//

var backgroundCamera = new OrthographicCamera( - 1, 1, 1, - 1, 0, 1 );

var backgroundCamera2 = new PerspectiveCamera();

var backgroundPlaneMesh = new Mesh(

new PlaneBufferGeometry( 2, 2 ),

new MeshBasicMaterial( { depthTest: false, depthWrite: false, fog: false } )

);

var backgroundBoxShader = ShaderLib[ 'cube' ];

var backgroundBoxMesh = new Mesh(

new BoxBufferGeometry( 5, 5, 5 ),

new ShaderMaterial( {

uniforms: backgroundBoxShader.uniforms,

vertexShader: backgroundBoxShader.vertexShader,

fragmentShader: backgroundBoxShader.fragmentShader,

side: BackSide,

depthTest: false,

depthWrite: false,

fog: false

} )

);

//

function getTargetPixelRatio() {

return _currentRenderTarget === null ? _pixelRatio : 1;

}

function glClearColor( r, g, b, a ) {

if ( _premultipliedAlpha === true ) {

r *= a; g *= a; b *= a;

}

state.clearColor( r, g, b, a );

}

function setDefaultGLState() {

state.init();

state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) );

state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) );

glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha );

}

function resetGLState() {

_currentProgram = null;

_currentCamera = null;

_currentGeometryProgram = '';

_currentMaterialId = - 1;

state.reset();

}

setDefaultGLState();

this.context = _gl;

this.capabilities = capabilities;

this.extensions = extensions;

this.properties = properties;

this.state = state;

// shadow map

var shadowMap = new WebGLShadowMap( this, _lights, objects, capabilities );

this.shadowMap = shadowMap;

// Plugins

var spritePlugin = new SpritePlugin( this, sprites );

var lensFlarePlugin = new LensFlarePlugin( this, lensFlares );

// API

this.getContext = function () {

return _gl;

};

this.getContextAttributes = function () {

return _gl.getContextAttributes();

};

this.forceContextLoss = function () {

extensions.get( 'WEBGL_lose_context' ).loseContext();

};

this.getMaxAnisotropy = function () {

return capabilities.getMaxAnisotropy();

};

this.getPrecision = function () {

return capabilities.precision;

};

this.getPixelRatio = function () {

return _pixelRatio;

};

this.setPixelRatio = function ( value ) {

if ( value === undefined ) return;

_pixelRatio = value;

this.setSize( _viewport.z, _viewport.w, false );

};

this.getSize = function () {

return {

width: _width,

height: _height

};

};

this.setSize = function ( width, height, updateStyle ) {

_width = width;

_height = height;

_canvas.width = width * _pixelRatio;

_canvas.height = height * _pixelRatio;

if ( updateStyle !== false ) {

_canvas.style.width = width + 'px';

_canvas.style.height = height + 'px';

}

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

};

this.setViewport = function ( x, y, width, height ) {

state.viewport( _viewport.set( x, y, width, height ) );

};

this.setScissor = function ( x, y, width, height ) {

state.scissor( _scissor.set( x, y, width, height ) );

};

this.setScissorTest = function ( boolean ) {

state.setScissorTest( _scissorTest = boolean );

};

// Clearing

this.getClearColor = function () {

return _clearColor;

};

this.setClearColor = function ( color, alpha ) {

_clearColor.set( color );

_clearAlpha = alpha !== undefined ? alpha : 1;

glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha );

};

this.getClearAlpha = function () {

return _clearAlpha;

};

this.setClearAlpha = function ( alpha ) {

_clearAlpha = alpha;

glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha );

};

this.clear = function ( color, depth, stencil ) {

var bits = 0;

if ( color === undefined || color ) bits |= _gl.COLOR_BUFFER_BIT;

if ( depth === undefined || depth ) bits |= _gl.DEPTH_BUFFER_BIT;

if ( stencil === undefined || stencil ) bits |= _gl.STENCIL_BUFFER_BIT;

_gl.clear( bits );

};

this.clearColor = function () {

this.clear( true, false, false );

};

this.clearDepth = function () {

this.clear( false, true, false );

};

this.clearStencil = function () {

this.clear( false, false, true );

};

this.clearTarget = function ( renderTarget, color, depth, stencil ) {

this.setRenderTarget( renderTarget );

this.clear( color, depth, stencil );

};

// Reset

this.resetGLState = resetGLState;

this.dispose = function() {

transparentObjects = [];

transparentObjectsLastIndex = -1;

opaqueObjects = [];

opaqueObjectsLastIndex = -1;

_canvas.removeEventListener( 'webglcontextlost', onContextLost, false );

};

// Events

function onContextLost( event ) {

event.preventDefault();

resetGLState();

setDefaultGLState();

properties.clear();

}

function onMaterialDispose( event ) {

var material = event.target;

material.removeEventListener( 'dispose', onMaterialDispose );

deallocateMaterial( material );

}

// Buffer deallocation

function deallocateMaterial( material ) {

releaseMaterialProgramReference( material );

properties.delete( material );

}

function releaseMaterialProgramReference( material ) {

var programInfo = properties.get( material ).program;

material.program = undefined;

if ( programInfo !== undefined ) {

programCache.releaseProgram( programInfo );

}

}

// Buffer rendering

this.renderBufferImmediate = function ( object, program, material ) {

state.initAttributes();

var buffers = properties.get( object );

if ( object.hasPositions && ! buffers.position ) buffers.position = _gl.createBuffer();

if ( object.hasNormals && ! buffers.normal ) buffers.normal = _gl.createBuffer();

if ( object.hasUvs && ! buffers.uv ) buffers.uv = _gl.createBuffer();

if ( object.hasColors && ! buffers.color ) buffers.color = _gl.createBuffer();

var attributes = program.getAttributes();

if ( object.hasPositions ) {

_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.position );

_gl.bufferData( _gl.ARRAY_BUFFER, object.positionArray, _gl.DYNAMIC_DRAW );

state.enableAttribute( attributes.position );

_gl.vertexAttribPointer( attributes.position, 3, _gl.FLOAT, false, 0, 0 );

}

if ( object.hasNormals ) {

_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.normal );

if ( ! material.isMeshPhongMaterial &&

! material.isMeshStandardMaterial &&

material.shading === FlatShading ) {

for ( var i = 0, l = object.count * 3; i < l; i += 9 ) {

var array = object.normalArray;

var nx = ( array[ i + 0 ] + array[ i + 3 ] + array[ i + 6 ] ) / 3;

var ny = ( array[ i + 1 ] + array[ i + 4 ] + array[ i + 7 ] ) / 3;

var nz = ( array[ i + 2 ] + array[ i + 5 ] + array[ i + 8 ] ) / 3;

array[ i + 0 ] = nx;

array[ i + 1 ] = ny;

array[ i + 2 ] = nz;

array[ i + 3 ] = nx;

array[ i + 4 ] = ny;

array[ i + 5 ] = nz;

array[ i + 6 ] = nx;

array[ i + 7 ] = ny;

array[ i + 8 ] = nz;

}

}

_gl.bufferData( _gl.ARRAY_BUFFER, object.normalArray, _gl.DYNAMIC_DRAW );

state.enableAttribute( attributes.normal );

_gl.vertexAttribPointer( attributes.normal, 3, _gl.FLOAT, false, 0, 0 );

}

if ( object.hasUvs && material.map ) {

_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.uv );

_gl.bufferData( _gl.ARRAY_BUFFER, object.uvArray, _gl.DYNAMIC_DRAW );

state.enableAttribute( attributes.uv );

_gl.vertexAttribPointer( attributes.uv, 2, _gl.FLOAT, false, 0, 0 );

}

if ( object.hasColors && material.vertexColors !== NoColors ) {

_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.color );

_gl.bufferData( _gl.ARRAY_BUFFER, object.colorArray, _gl.DYNAMIC_DRAW );

state.enableAttribute( attributes.color );

_gl.vertexAttribPointer( attributes.color, 3, _gl.FLOAT, false, 0, 0 );

}

state.disableUnusedAttributes();

_gl.drawArrays( _gl.TRIANGLES, 0, object.count );

object.count = 0;

};

this.renderBufferDirect = function ( camera, fog, geometry, material, object, group ) {

setMaterial( material );

var program = setProgram( camera, fog, material, object );

var updateBuffers = false;

var geometryProgram = geometry.id + '_' + program.id + '_' + material.wireframe;

if ( geometryProgram !== _currentGeometryProgram ) {

_currentGeometryProgram = geometryProgram;

updateBuffers = true;

}

// morph targets

var morphTargetInfluences = object.morphTargetInfluences;

if ( morphTargetInfluences !== undefined ) {

var activeInfluences = [];

for ( var i = 0, l = morphTargetInfluences.length; i < l; i ++ ) {

var influence = morphTargetInfluences[ i ];

activeInfluences.push( [ influence, i ] );

}

activeInfluences.sort( absNumericalSort );

if ( activeInfluences.length > 8 ) {

activeInfluences.length = 8;

}

var morphAttributes = geometry.morphAttributes;

for ( var i = 0, l = activeInfluences.length; i < l; i ++ ) {

var influence = activeInfluences[ i ];

morphInfluences[ i ] = influence[ 0 ];

if ( influence[ 0 ] !== 0 ) {

var index = influence[ 1 ];

if ( material.morphTargets === true && morphAttributes.position ) geometry.addAttribute( 'morphTarget' + i, morphAttributes.position[ index ] );

if ( material.morphNormals === true && morphAttributes.normal ) geometry.addAttribute( 'morphNormal' + i, morphAttributes.normal[ index ] );

} else {

if ( material.morphTargets === true ) geometry.removeAttribute( 'morphTarget' + i );

if ( material.morphNormals === true ) geometry.removeAttribute( 'morphNormal' + i );

}

}

for ( var i = activeInfluences.length, il = morphInfluences.length; i < il; i ++ ) {

morphInfluences[ i ] = 0.0;

}

program.getUniforms().setValue(

_gl, 'morphTargetInfluences', morphInfluences );

updateBuffers = true;

}

//

var index = geometry.index;

var position = geometry.attributes.position;

var rangeFactor = 1;

if ( material.wireframe === true ) {

index = objects.getWireframeAttribute( geometry );

rangeFactor = 2;

}

var renderer;

if ( index !== null ) {

renderer = indexedBufferRenderer;

renderer.setIndex( index );

} else {

renderer = bufferRenderer;

}

if ( updateBuffers ) {

setupVertexAttributes( material, program, geometry );

if ( index !== null ) {

_gl.bindBuffer( _gl.ELEMENT_ARRAY_BUFFER, objects.getAttributeBuffer( index ) );

}

}

//

var dataCount = 0;

if ( index !== null ) {

dataCount = index.count;

} else if ( position !== undefined ) {

dataCount = position.count;

}

var rangeStart = geometry.drawRange.start * rangeFactor;

var rangeCount = geometry.drawRange.count * rangeFactor;

var groupStart = group !== null ? group.start * rangeFactor : 0;

var groupCount = group !== null ? group.count * rangeFactor : Infinity;

var drawStart = Math.max( rangeStart, groupStart );

var drawEnd = Math.min( dataCount, rangeStart + rangeCount, groupStart + groupCount ) - 1;

var drawCount = Math.max( 0, drawEnd - drawStart + 1 );

if ( drawCount === 0 ) return;

//

if ( object.isMesh ) {

if ( material.wireframe === true ) {

state.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() );

renderer.setMode( _gl.LINES );

} else {

switch ( object.drawMode ) {

case TrianglesDrawMode:

renderer.setMode( _gl.TRIANGLES );

break;

case TriangleStripDrawMode:

renderer.setMode( _gl.TRIANGLE_STRIP );

break;

case TriangleFanDrawMode:

renderer.setMode( _gl.TRIANGLE_FAN );

break;

}

}

} else if ( object.isLine ) {

var lineWidth = material.linewidth;

if ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material

state.setLineWidth( lineWidth * getTargetPixelRatio() );

if ( object.isLineSegments ) {

renderer.setMode( _gl.LINES );

} else {

renderer.setMode( _gl.LINE_STRIP );

}

} else if ( object.isPoints ) {

renderer.setMode( _gl.POINTS );

}

if ( geometry && geometry.isInstancedBufferGeometry ) {

if ( geometry.maxInstancedCount > 0 ) {

renderer.renderInstances( geometry, drawStart, drawCount );

}

} else {

renderer.render( drawStart, drawCount );

}

};

function setupVertexAttributes( material, program, geometry, startIndex ) {

var extension;

if ( geometry && geometry.isInstancedBufferGeometry ) {

extension = extensions.get( 'ANGLE_instanced_arrays' );

if ( extension === null ) {

console.error( 'THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );

return;

}

}

if ( startIndex === undefined ) startIndex = 0;

state.initAttributes();

var geometryAttributes = geometry.attributes;

var programAttributes = program.getAttributes();

var materialDefaultAttributeValues = material.defaultAttributeValues;

for ( var name in programAttributes ) {

var programAttribute = programAttributes[ name ];

if ( programAttribute >= 0 ) {

var geometryAttribute = geometryAttributes[ name ];

if ( geometryAttribute !== undefined ) {

var type = _gl.FLOAT;

var array = geometryAttribute.array;

var normalized = geometryAttribute.normalized;

if ( array instanceof Float32Array ) {

type = _gl.FLOAT;

} else if ( array instanceof Float64Array ) {

console.warn( "Unsupported data buffer format: Float64Array" );

} else if ( array instanceof Uint16Array ) {

type = _gl.UNSIGNED_SHORT;

} else if ( array instanceof Int16Array ) {

type = _gl.SHORT;

} else if ( array instanceof Uint32Array ) {

type = _gl.UNSIGNED_INT;

} else if ( array instanceof Int32Array ) {

type = _gl.INT;

} else if ( array instanceof Int8Array ) {

type = _gl.BYTE;

} else if ( array instanceof Uint8Array ) {

type = _gl.UNSIGNED_BYTE;

}

var size = geometryAttribute.itemSize;

var buffer = objects.getAttributeBuffer( geometryAttribute );

if ( geometryAttribute.isInterleavedBufferAttribute ) {

var data = geometryAttribute.data;

var stride = data.stride;

var offset = geometryAttribute.offset;

if ( data && data.isInstancedInterleavedBuffer ) {

state.enableAttributeAndDivisor( programAttribute, data.meshPerAttribute, extension );

if ( geometry.maxInstancedCount === undefined ) {