super-three 0.147.1 → 0.154.0

package/src/renderers/WebGLRenderer.js

@@ -1,22 +1,35 @@
 import {
 	REVISION,
 	BackSide,
-	DoubleSide,
 	FrontSide,
+	DoubleSide,
 	RGBAFormat,
 	HalfFloatType,
 	FloatType,
 	UnsignedByteType,
-	LinearEncoding,
 	NoToneMapping,
-	LinearMipmapLinearFilter
+	LinearMipmapLinearFilter,
+	SRGBColorSpace,
+	LinearSRGBColorSpace,
+	sRGBEncoding,
+	LinearEncoding,
+	RGBAIntegerFormat,
+	RGIntegerFormat,
+	RedIntegerFormat,
+	UnsignedIntType,
+	UnsignedShortType,
+	UnsignedInt248Type,
+	UnsignedShort4444Type,
+	UnsignedShort5551Type,
+	WebGLCoordinateSystem
 } from '../constants.js';
-import { floorPowerOfTwo } from '../math/MathUtils.js';
+import { Color } from '../math/Color.js';
 import { Frustum } from '../math/Frustum.js';
 import { Matrix4 } from '../math/Matrix4.js';
 import { Vector2 } from '../math/Vector2.js';
 import { Vector3 } from '../math/Vector3.js';
 import { Vector4 } from '../math/Vector4.js';
+import { floorPowerOfTwo } from '../math/MathUtils.js';
 import { WebGLAnimation } from './webgl/WebGLAnimation.js';
 import { WebGLAttributes } from './webgl/WebGLAttributes.js';
 import { WebGLBackground } from './webgl/WebGLBackground.js';
@@ -56,1138 +69,1222 @@ function createCanvasElement() {
 
 }
 
-function WebGLRenderer( parameters = {} ) {
+class WebGLRenderer {
 
-	this.isWebGLRenderer = true;
+	constructor( parameters = {} ) {
 
-	const _canvas = parameters.canvas !== undefined ? parameters.canvas : createCanvasElement(),
-		_context = parameters.context !== undefined ? parameters.context : null,
+		const {
+			canvas = createCanvasElement(),
+			context = null,
+			depth = true,
+			stencil = true,
+			alpha = false,
+			antialias = false,
+			premultipliedAlpha = true,
+			preserveDrawingBuffer = false,
+			powerPreference = 'default',
+			failIfMajorPerformanceCaveat = false,
+		} = parameters;
 
-		_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,
-		_powerPreference = parameters.powerPreference !== undefined ? parameters.powerPreference : 'default',
-		_failIfMajorPerformanceCaveat = parameters.failIfMajorPerformanceCaveat !== undefined ? parameters.failIfMajorPerformanceCaveat : false;
+		this.isWebGLRenderer = true;
 
-	let _alpha;
+		let _alpha;
 
-	if ( _context !== null ) {
+		if ( context !== null ) {
 
-		_alpha = _context.getContextAttributes().alpha;
+			_alpha = context.getContextAttributes().alpha;
 
-	} else {
+		} else {
 
-		_alpha = parameters.alpha !== undefined ? parameters.alpha : false;
+			_alpha = alpha;
 
-	}
+		}
 
-	let currentRenderList = null;
-	let currentRenderState = null;
+		const uintClearColor = new Uint32Array( 4 );
+		const intClearColor = new Int32Array( 4 );
 
-	// render() can be called from within a callback triggered by another render.
-	// We track this so that the nested render call gets its list and state isolated from the parent render call.
+		let currentRenderList = null;
+		let currentRenderState = null;
 
-	const renderListStack = [];
-	const renderStateStack = [];
+		// render() can be called from within a callback triggered by another render.
+		// We track this so that the nested render call gets its list and state isolated from the parent render call.
 
-	// public properties
+		const renderListStack = [];
+		const renderStateStack = [];
 
-	this.domElement = _canvas;
+		// public properties
 
-	// Debug configuration container
-	this.debug = {
+		this.domElement = canvas;
 
-		/**
-		 * Enables error checking and reporting when shader programs are being compiled
-		 * @type {boolean}
-		 */
-		checkShaderErrors: true
-	};
+		// Debug configuration container
+		this.debug = {
 
-	// clearing
+			/**
+			 * Enables error checking and reporting when shader programs are being compiled
+			 * @type {boolean}
+			 */
+			checkShaderErrors: true,
+			/**
+			 * Callback for custom error reporting.
+			 * @type {?Function}
+			 */
+			onShaderError: null
+		};
 
-	this.autoClear = true;
-	this.autoClearColor = true;
-	this.autoClearDepth = true;
-	this.autoClearStencil = true;
+		// clearing
 
-	// scene graph
+		this.autoClear = true;
+		this.autoClearColor = true;
+		this.autoClearDepth = true;
+		this.autoClearStencil = true;
 
-	this.sortObjects = true;
+		// scene graph
 
-	// user-defined clipping
+		this.sortObjects = true;
 
-	this.clippingPlanes = [];
-	this.localClippingEnabled = false;
+		// user-defined clipping
 
-	// physically based shading
+		this.clippingPlanes = [];
+		this.localClippingEnabled = false;
 
-	this.outputEncoding = LinearEncoding;
+		// physically based shading
 
-	// physical lights
+		this.outputColorSpace = SRGBColorSpace;
 
-	this.physicallyCorrectLights = false;
+		// physical lights
 
-	// tone mapping
+		this.useLegacyLights = true;
 
-	this.toneMapping = NoToneMapping;
-	this.toneMappingExposure = 1.0;
+		// tone mapping
 
-	// internal properties
+		this.toneMapping = NoToneMapping;
+		this.toneMappingExposure = 1.0;
 
-	const _this = this;
+		// internal properties
 
-	let _isContextLost = false;
+		const _this = this;
 
-	// internal state cache
+		let _isContextLost = false;
 
-	let _currentActiveCubeFace = 0;
-	let _currentActiveMipmapLevel = 0;
-	let _currentRenderTarget = null;
-	let _currentMaterialId = - 1;
+		// internal state cache
 
-	let _currentCamera = null;
+		let _currentActiveCubeFace = 0;
+		let _currentActiveMipmapLevel = 0;
+		let _currentRenderTarget = null;
+		let _currentMaterialId = - 1;
 
-	const _currentViewport = new Vector4();
-	const _currentScissor = new Vector4();
-	let _currentScissorTest = null;
+		let _currentCamera = null;
 
-	//
+		const _currentViewport = new Vector4();
+		const _currentScissor = new Vector4();
+		let _currentScissorTest = null;
 
-	let _width = _canvas.width;
-	let _height = _canvas.height;
+		const _currentClearColor = new Color( 0x000000 );
+		let _currentClearAlpha = 0;
 
-	let _pixelRatio = 1;
-	let _opaqueSort = null;
-	let _transparentSort = null;
+		//
 
-	const _viewport = new Vector4( 0, 0, _width, _height );
-	const _scissor = new Vector4( 0, 0, _width, _height );
-	let _scissorTest = false;
+		let _width = canvas.width;
+		let _height = canvas.height;
 
-	// frustum
+		let _pixelRatio = 1;
+		let _opaqueSort = null;
+		let _transparentSort = null;
 
-	const _frustum = new Frustum();
+		const _viewport = new Vector4( 0, 0, _width, _height );
+		const _scissor = new Vector4( 0, 0, _width, _height );
+		let _scissorTest = false;
 
-	// clipping
+		// frustum
 
-	let _clippingEnabled = false;
-	let _localClippingEnabled = false;
+		const _frustum = new Frustum();
 
-	// transmission
+		// clipping
 
-	let _transmissionRenderTarget = null;
+		let _clippingEnabled = false;
+		let _localClippingEnabled = false;
 
-	// camera matrices cache
+		// transmission
 
-	const _projScreenMatrix = new Matrix4();
+		let _transmissionRenderTarget = null;
 
-	const _vector2 = new Vector2();
-	const _vector3 = new Vector3();
+		// camera matrices cache
 
-	const _emptyScene = { background: null, fog: null, environment: null, overrideMaterial: null, isScene: true };
+		const _projScreenMatrix = new Matrix4();
 
-	function getTargetPixelRatio() {
+		const _vector2 = new Vector2();
+		const _vector3 = new Vector3();
 
-		return _currentRenderTarget === null ? _pixelRatio : 1;
+		const _emptyScene = { background: null, fog: null, environment: null, overrideMaterial: null, isScene: true };
 
-	}
+		function getTargetPixelRatio() {
 
-	// initialize
+			return _currentRenderTarget === null ? _pixelRatio : 1;
 
-	let _gl = _context;
+		}
 
-	function getContext( contextNames, contextAttributes ) {
+		// initialize
 
-		for ( let i = 0; i < contextNames.length; i ++ ) {
+		let _gl = context;
 
-			const contextName = contextNames[ i ];
-			const context = _canvas.getContext( contextName, contextAttributes );
-			if ( context !== null ) return context;
+		function getContext( contextNames, contextAttributes ) {
 
-		}
+			for ( let i = 0; i < contextNames.length; i ++ ) {
 
-		return null;
+				const contextName = contextNames[ i ];
+				const context = canvas.getContext( contextName, contextAttributes );
+				if ( context !== null ) return context;
 
-	}
+			}
 
-	try {
-
-		const contextAttributes = {
-			alpha: true,
-			depth: _depth,
-			stencil: _stencil,
-			antialias: _antialias,
-			premultipliedAlpha: _premultipliedAlpha,
-			preserveDrawingBuffer: _preserveDrawingBuffer,
-			powerPreference: _powerPreference,
-			failIfMajorPerformanceCaveat: _failIfMajorPerformanceCaveat
-		};
+			return null;
 
-		// OffscreenCanvas does not have setAttribute, see #22811
-		if ( 'setAttribute' in _canvas ) _canvas.setAttribute( 'data-engine', `three.js r${REVISION}` );
+		}
 
-		// event listeners must be registered before WebGL context is created, see #12753
-		_canvas.addEventListener( 'webglcontextlost', onContextLost, false );
-		_canvas.addEventListener( 'webglcontextrestored', onContextRestore, false );
-		_canvas.addEventListener( 'webglcontextcreationerror', onContextCreationError, false );
+		try {
+
+			const contextAttributes = {
+				alpha: true,
+				depth,
+				stencil,
+				antialias,
+				premultipliedAlpha,
+				preserveDrawingBuffer,
+				powerPreference,
+				failIfMajorPerformanceCaveat,
+			};
 
-		if ( _gl === null ) {
+			// OffscreenCanvas does not have setAttribute, see #22811
+			if ( 'setAttribute' in canvas ) canvas.setAttribute( 'data-engine', `three.js r${REVISION}` );
 
-			const contextNames = [ 'webgl2', 'webgl', 'experimental-webgl' ];
+			// event listeners must be registered before WebGL context is created, see #12753
+			canvas.addEventListener( 'webglcontextlost', onContextLost, false );
+			canvas.addEventListener( 'webglcontextrestored', onContextRestore, false );
+			canvas.addEventListener( 'webglcontextcreationerror', onContextCreationError, false );
 
-			if ( _this.isWebGL1Renderer === true ) {
+			if ( _gl === null ) {
 
-				contextNames.shift();
+				const contextNames = [ 'webgl2', 'webgl', 'experimental-webgl' ];
 
-			}
+				if ( _this.isWebGL1Renderer === true ) {
 
-			_gl = getContext( contextNames, contextAttributes );
+					contextNames.shift();
 
-			if ( _gl === null ) {
+				}
 
-				if ( getContext( contextNames ) ) {
+				_gl = getContext( contextNames, contextAttributes );
 
-					throw new Error( 'Error creating WebGL context with your selected attributes.' );
+				if ( _gl === null ) {
 
-				} else {
+					if ( getContext( contextNames ) ) {
+
+						throw new Error( 'Error creating WebGL context with your selected attributes.' );
+
+					} else {
 
-					throw new Error( 'Error creating WebGL context.' );
+						throw new Error( 'Error creating WebGL context.' );
+
+					}
 
 				}
 
 			}
 
-		}
+			if ( typeof WebGLRenderingContext !== 'undefined' && _gl instanceof WebGLRenderingContext ) { // @deprecated, r153
 
-		// Some experimental-webgl implementations do not have getShaderPrecisionFormat
+				console.warn( 'THREE.WebGLRenderer: WebGL 1 support was deprecated in r153 and will be removed in r163.' );
 
-		if ( _gl.getShaderPrecisionFormat === undefined ) {
+			}
 
-			_gl.getShaderPrecisionFormat = function () {
+			// Some experimental-webgl implementations do not have getShaderPrecisionFormat
 
-				return { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 };
+			if ( _gl.getShaderPrecisionFormat === undefined ) {
 
-			};
+				_gl.getShaderPrecisionFormat = function () {
+
+					return { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 };
+
+				};
+
+			}
+
+		} catch ( error ) {
+
+			console.error( 'THREE.WebGLRenderer: ' + error.message );
+			throw error;
 
 		}
 
-	} catch ( error ) {
+		let extensions, capabilities, state, info;
+		let properties, textures, cubemaps, cubeuvmaps, attributes, geometries, objects;
+		let programCache, materials, renderLists, renderStates, clipping, shadowMap;
 
-		console.error( 'THREE.WebGLRenderer: ' + error.message );
-		throw error;
+		let background, morphtargets, bufferRenderer, indexedBufferRenderer;
 
-	}
+		let utils, bindingStates, uniformsGroups;
 
-	let extensions, capabilities, state, info;
-	let properties, textures, cubemaps, cubeuvmaps, attributes, geometries, objects;
-	let programCache, materials, renderLists, renderStates, clipping, shadowMap;
+		function initGLContext() {
 
-	let background, morphtargets, bufferRenderer, indexedBufferRenderer;
+			extensions = new WebGLExtensions( _gl );
 
-	let utils, bindingStates, uniformsGroups;
+			capabilities = new WebGLCapabilities( _gl, extensions, parameters );
 
-	function initGLContext() {
+			extensions.init( capabilities );
 
-		extensions = new WebGLExtensions( _gl );
+			utils = new WebGLUtils( _gl, extensions, capabilities );
 
-		capabilities = new WebGLCapabilities( _gl, extensions, parameters );
+			state = new WebGLState( _gl, extensions, capabilities );
 
-		extensions.init( capabilities );
+			info = new WebGLInfo( _gl );
+			properties = new WebGLProperties();
+			textures = new WebGLTextures( _gl, extensions, state, properties, capabilities, utils, info );
+			cubemaps = new WebGLCubeMaps( _this );
+			cubeuvmaps = new WebGLCubeUVMaps( _this );
+			attributes = new WebGLAttributes( _gl, capabilities );
+			bindingStates = new WebGLBindingStates( _gl, extensions, attributes, capabilities );
+			geometries = new WebGLGeometries( _gl, attributes, info, bindingStates );
+			objects = new WebGLObjects( _gl, geometries, attributes, info );
+			morphtargets = new WebGLMorphtargets( _gl, capabilities, textures );
+			clipping = new WebGLClipping( properties );
+			programCache = new WebGLPrograms( _this, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping );
+			materials = new WebGLMaterials( _this, properties );
+			renderLists = new WebGLRenderLists();
+			renderStates = new WebGLRenderStates( extensions, capabilities );
+			background = new WebGLBackground( _this, cubemaps, cubeuvmaps, state, objects, _alpha, premultipliedAlpha );
+			shadowMap = new WebGLShadowMap( _this, objects, capabilities );
+			uniformsGroups = new WebGLUniformsGroups( _gl, info, capabilities, state );
 
-		utils = new WebGLUtils( _gl, extensions, capabilities );
+			bufferRenderer = new WebGLBufferRenderer( _gl, extensions, info, capabilities );
+			indexedBufferRenderer = new WebGLIndexedBufferRenderer( _gl, extensions, info, capabilities );
 
-		state = new WebGLState( _gl, extensions, capabilities );
+			info.programs = programCache.programs;
 
-		info = new WebGLInfo( _gl );
-		properties = new WebGLProperties();
-		textures = new WebGLTextures( _gl, extensions, state, properties, capabilities, utils, info );
-		cubemaps = new WebGLCubeMaps( _this );
-		cubeuvmaps = new WebGLCubeUVMaps( _this );
-		attributes = new WebGLAttributes( _gl, capabilities );
-		bindingStates = new WebGLBindingStates( _gl, extensions, attributes, capabilities );
-		geometries = new WebGLGeometries( _gl, attributes, info, bindingStates );
-		objects = new WebGLObjects( _gl, geometries, attributes, info );
-		morphtargets = new WebGLMorphtargets( _gl, capabilities, textures );
-		clipping = new WebGLClipping( properties );
-		programCache = new WebGLPrograms( _this, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping );
-		materials = new WebGLMaterials( _this, properties );
-		renderLists = new WebGLRenderLists();
-		renderStates = new WebGLRenderStates( extensions, capabilities );
-		background = new WebGLBackground( _this, cubemaps, cubeuvmaps, state, objects, _alpha, _premultipliedAlpha );
-		shadowMap = new WebGLShadowMap( _this, objects, capabilities );
-		uniformsGroups = new WebGLUniformsGroups( _gl, info, capabilities, state );
+			_this.capabilities = capabilities;
+			_this.extensions = extensions;
+			_this.properties = properties;
+			_this.renderLists = renderLists;
+			_this.shadowMap = shadowMap;
+			_this.state = state;
+			_this.info = info;
 
-		bufferRenderer = new WebGLBufferRenderer( _gl, extensions, info, capabilities );
-		indexedBufferRenderer = new WebGLIndexedBufferRenderer( _gl, extensions, info, capabilities );
+		}
 
-		info.programs = programCache.programs;
+		initGLContext();
 
-		_this.capabilities = capabilities;
-		_this.extensions = extensions;
-		_this.properties = properties;
-		_this.renderLists = renderLists;
-		_this.shadowMap = shadowMap;
-		_this.state = state;
-		_this.info = info;
+		// xr
 
-	}
+		const xr = ( typeof navigator !== 'undefined' && 'xr' in navigator ) ? new WebXRManager( _this, _gl ) : new WebVRManager( _this );
 
-	initGLContext();
+		this.xr = xr;
 
-	const xr = ( typeof navigator !== 'undefined' && 'xr' in navigator ) ? new WebXRManager( _this, _gl ) : new WebVRManager( _this );
+		// API
 
-	this.xr = xr;
+		this.getContext = function () {
 
-	// API
+			return _gl;
 
-	this.getContext = function () {
+		};
 
-		return _gl;
+		this.getContextAttributes = function () {
 
-	};
+			return _gl.getContextAttributes();
 
-	this.getContextAttributes = function () {
+		};
 
-		return _gl.getContextAttributes();
+		this.forceContextLoss = function () {
 
-	};
+			const extension = extensions.get( 'WEBGL_lose_context' );
+			if ( extension ) extension.loseContext();
 
-	this.forceContextLoss = function () {
+		};
 
-		const extension = extensions.get( 'WEBGL_lose_context' );
-		if ( extension ) extension.loseContext();
+		this.forceContextRestore = function () {
 
-	};
+			const extension = extensions.get( 'WEBGL_lose_context' );
+			if ( extension ) extension.restoreContext();
 
-	this.forceContextRestore = function () {
+		};
 
-		const extension = extensions.get( 'WEBGL_lose_context' );
-		if ( extension ) extension.restoreContext();
+		this.getPixelRatio = function () {
 
-	};
+			return _pixelRatio;
 
-	this.getPixelRatio = function () {
+		};
 
-		return _pixelRatio;
+		this.setPixelRatio = function ( value ) {
 
-	};
+			if ( value === undefined ) return;
 
-	this.setPixelRatio = function ( value ) {
+			_pixelRatio = value;
 
-		if ( value === undefined ) return;
+			this.setSize( _width, _height, false );
 
-		_pixelRatio = value;
+		};
 
-		this.setSize( _width, _height, false );
+		this.getSize = function ( target ) {
 
-	};
+			return target.set( _width, _height );
 
-	this.getSize = function ( target ) {
+		};
 
-		return target.set( _width, _height );
+		this.setSize = function ( width, height, updateStyle = true ) {
 
-	};
+			if ( xr.isPresenting ) {
 
-	this.setSize = function ( width, height, updateStyle ) {
+				console.warn( 'THREE.WebGLRenderer: Can\'t change size while VR device is presenting.' );
+				return;
 
-		if ( xr.isPresenting ) {
+			}
 
-			console.warn( 'THREE.WebGLRenderer: Can\'t change size while VR device is presenting.' );
-			return;
+			_width = width;
+			_height = height;
 
-		}
+			canvas.width = Math.floor( width * _pixelRatio );
+			canvas.height = Math.floor( height * _pixelRatio );
 
-		_width = width;
-		_height = height;
+			if ( updateStyle === true ) {
 
-		_canvas.width = Math.floor( width * _pixelRatio );
-		_canvas.height = Math.floor( height * _pixelRatio );
+				canvas.style.width = width + 'px';
+				canvas.style.height = height + 'px';
 
-		if ( updateStyle !== false ) {
+			}
 
-			_canvas.style.width = width + 'px';
-			_canvas.style.height = height + 'px';
+			this.setViewport( 0, 0, width, height );
 
-		}
+		};
 
-		this.setViewport( 0, 0, width, height );
+		this.getDrawingBufferSize = function ( target ) {
 
-	};
+			return target.set( _width * _pixelRatio, _height * _pixelRatio ).floor();
 
-	this.getDrawingBufferSize = function ( target ) {
+		};
 
-		return target.set( _width * _pixelRatio, _height * _pixelRatio ).floor();
+		this.setDrawingBufferSize = function ( width, height, pixelRatio ) {
 
-	};
+			_width = width;
+			_height = height;
 
-	this.setDrawingBufferSize = function ( width, height, pixelRatio ) {
+			_pixelRatio = pixelRatio;
 
-		_width = width;
-		_height = height;
+			canvas.width = Math.floor( width * pixelRatio );
+			canvas.height = Math.floor( height * pixelRatio );
 
-		_pixelRatio = pixelRatio;
+			this.setViewport( 0, 0, width, height );
 
-		_canvas.width = Math.floor( width * pixelRatio );
-		_canvas.height = Math.floor( height * pixelRatio );
+		};
 
-		this.setViewport( 0, 0, width, height );
+		this.getCurrentViewport = function ( target ) {
 
-	};
+			return target.copy( _currentViewport );
 
-	this.getCurrentViewport = function ( target ) {
+		};
 
-		return target.copy( _currentViewport );
+		this.getViewport = function ( target ) {
 
-	};
+			return target.copy( _viewport );
 
-	this.getViewport = function ( target ) {
+		};
 
-		return target.copy( _viewport );
+		this.setViewport = function ( x, y, width, height ) {
 
-	};
+			if ( x.isVector4 ) {
 
-	this.setViewport = function ( x, y, width, height ) {
+				_viewport.set( x.x, x.y, x.z, x.w );
 
-		if ( x.isVector4 ) {
+			} else {
 
-			_viewport.set( x.x, x.y, x.z, x.w );
+				_viewport.set( x, y, width, height );
 
-		} else {
+			}
 
-			_viewport.set( x, y, width, height );
+			state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor() );
 
-		}
+		};
+
+		this.getScissor = function ( target ) {
 
-		state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor() );
+			return target.copy( _scissor );
 
-	};
+		};
 
-	this.getScissor = function ( target ) {
+		this.setScissor = function ( x, y, width, height ) {
 
-		return target.copy( _scissor );
+			if ( x.isVector4 ) {
 
-	};
+				_scissor.set( x.x, x.y, x.z, x.w );
 
-	this.setScissor = function ( x, y, width, height ) {
+			} else {
 
-		if ( x.isVector4 ) {
+				_scissor.set( x, y, width, height );
 
-			_scissor.set( x.x, x.y, x.z, x.w );
+			}
 
-		} else {
+			state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor() );
 
-			_scissor.set( x, y, width, height );
+		};
 
-		}
+		this.getScissorTest = function () {
 
-		state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor() );
+			return _scissorTest;
 
-	};
+		};
 
-	this.getScissorTest = function () {
+		this.setScissorTest = function ( boolean ) {
 
-		return _scissorTest;
+			state.setScissorTest( _scissorTest = boolean );
 
-	};
+		};
 
-	this.setScissorTest = function ( boolean ) {
+		this.setOpaqueSort = function ( method ) {
 
-		state.setScissorTest( _scissorTest = boolean );
+			_opaqueSort = method;
 
-	};
+		};
 
-	this.setOpaqueSort = function ( method ) {
+		this.setTransparentSort = function ( method ) {
 
-		_opaqueSort = method;
+			_transparentSort = method;
 
-	};
+		};
 
-	this.setTransparentSort = function ( method ) {
+		// Clearing
 
-		_transparentSort = method;
+		this.getClearColor = function ( target ) {
 
-	};
+			return target.copy( background.getClearColor() );
 
-	// Clearing
+		};
 
-	this.getClearColor = function ( target ) {
+		this.setClearColor = function () {
 
-		return target.copy( background.getClearColor() );
+			background.setClearColor.apply( background, arguments );
 
-	};
+		};
 
-	this.setClearColor = function () {
+		this.getClearAlpha = function () {
 
-		background.setClearColor.apply( background, arguments );
+			return background.getClearAlpha();
 
-	};
+		};
 
-	this.getClearAlpha = function () {
+		this.setClearAlpha = function () {
 
-		return background.getClearAlpha();
+			background.setClearAlpha.apply( background, arguments );
 
-	};
+		};
 
-	this.setClearAlpha = function () {
+		this.clear = function ( color = true, depth = true, stencil = true ) {
 
-		background.setClearAlpha.apply( background, arguments );
+			let bits = 0;
 
-	};
+			if ( color ) {
 
-	this.clear = function ( color = true, depth = true, stencil = true ) {
+				// check if we're trying to clear an integer target
+				let isIntegerFormat = false;
+				if ( _currentRenderTarget !== null ) {
 
-		let bits = 0;
+					const targetFormat = _currentRenderTarget.texture.format;
+					isIntegerFormat = targetFormat === RGBAIntegerFormat ||
+						targetFormat === RGIntegerFormat ||
+						targetFormat === RedIntegerFormat;
 
-		if ( color ) bits |= _gl.COLOR_BUFFER_BIT;
-		if ( depth ) bits |= _gl.DEPTH_BUFFER_BIT;
-		if ( stencil ) bits |= _gl.STENCIL_BUFFER_BIT;
+				}
 
-		_gl.clear( bits );
+				// use the appropriate clear functions to clear the target if it's a signed
+				// or unsigned integer target
+				if ( isIntegerFormat ) {
 
-	};
+					const targetType = _currentRenderTarget.texture.type;
+					const isUnsignedType = targetType === UnsignedByteType ||
+						targetType === UnsignedIntType ||
+						targetType === UnsignedShortType ||
+						targetType === UnsignedInt248Type ||
+						targetType === UnsignedShort4444Type ||
+						targetType === UnsignedShort5551Type;
 
-	this.clearColor = function () {
+					const clearColor = background.getClearColor();
+					const a = background.getClearAlpha();
+					const r = clearColor.r;
+					const g = clearColor.g;
+					const b = clearColor.b;
 
-		this.clear( true, false, false );
+					if ( isUnsignedType ) {
 
-	};
+						uintClearColor[ 0 ] = r;
+						uintClearColor[ 1 ] = g;
+						uintClearColor[ 2 ] = b;
+						uintClearColor[ 3 ] = a;
+						_gl.clearBufferuiv( _gl.COLOR, 0, uintClearColor );
 
-	this.clearDepth = function () {
+					} else {
 
-		this.clear( false, true, false );
+						intClearColor[ 0 ] = r;
+						intClearColor[ 1 ] = g;
+						intClearColor[ 2 ] = b;
+						intClearColor[ 3 ] = a;
+						_gl.clearBufferiv( _gl.COLOR, 0, intClearColor );
 
-	};
+					}
 
-	this.clearStencil = function () {
+				} else {
 
-		this.clear( false, false, true );
+					bits |= _gl.COLOR_BUFFER_BIT;
 
-	};
+				}
 
-	//
+			}
 
-	this.dispose = function () {
+			if ( depth ) bits |= _gl.DEPTH_BUFFER_BIT;
+			if ( stencil ) bits |= _gl.STENCIL_BUFFER_BIT;
 
-		_canvas.removeEventListener( 'webglcontextlost', onContextLost, false );
-		_canvas.removeEventListener( 'webglcontextrestored', onContextRestore, false );
-		_canvas.removeEventListener( 'webglcontextcreationerror', onContextCreationError, false );
+			_gl.clear( bits );
 
-		renderLists.dispose();
-		renderStates.dispose();
-		properties.dispose();
-		cubemaps.dispose();
-		cubeuvmaps.dispose();
-		objects.dispose();
-		bindingStates.dispose();
-		uniformsGroups.dispose();
-		programCache.dispose();
+		};
 
-		xr.dispose();
+		this.clearColor = function () {
 
-		xr.removeEventListener( 'sessionstart', onXRSessionStart );
-		xr.removeEventListener( 'sessionend', onXRSessionEnd );
+			this.clear( true, false, false );
 
-		if ( _transmissionRenderTarget ) {
+		};
 
-			_transmissionRenderTarget.dispose();
-			_transmissionRenderTarget = null;
+		this.clearDepth = function () {
 
-		}
+			this.clear( false, true, false );
 
-		animation.stop();
+		};
 
-	};
+		this.clearStencil = function () {
 
-	// Events
+			this.clear( false, false, true );
 
-	function onContextLost( event ) {
+		};
 
-		event.preventDefault();
+		//
 
-		console.log( 'THREE.WebGLRenderer: Context Lost.' );
+		this.dispose = function () {
 
-		_isContextLost = true;
+			canvas.removeEventListener( 'webglcontextlost', onContextLost, false );
+			canvas.removeEventListener( 'webglcontextrestored', onContextRestore, false );
+			canvas.removeEventListener( 'webglcontextcreationerror', onContextCreationError, false );
 
-	}
+			renderLists.dispose();
+			renderStates.dispose();
+			properties.dispose();
+			cubemaps.dispose();
+			cubeuvmaps.dispose();
+			objects.dispose();
+			bindingStates.dispose();
+			uniformsGroups.dispose();
+			programCache.dispose();
 
-	function onContextRestore( /* event */ ) {
+			xr.dispose();
 
-		console.log( 'THREE.WebGLRenderer: Context Restored.' );
+			xr.removeEventListener( 'sessionstart', onXRSessionStart );
+			xr.removeEventListener( 'sessionend', onXRSessionEnd );
 
-		_isContextLost = false;
+			if ( _transmissionRenderTarget ) {
 
-		const infoAutoReset = info.autoReset;
-		const shadowMapEnabled = shadowMap.enabled;
-		const shadowMapAutoUpdate = shadowMap.autoUpdate;
-		const shadowMapNeedsUpdate = shadowMap.needsUpdate;
-		const shadowMapType = shadowMap.type;
+				_transmissionRenderTarget.dispose();
+				_transmissionRenderTarget = null;
 
-		initGLContext();
+			}
 
-		info.autoReset = infoAutoReset;
-		shadowMap.enabled = shadowMapEnabled;
-		shadowMap.autoUpdate = shadowMapAutoUpdate;
-		shadowMap.needsUpdate = shadowMapNeedsUpdate;
-		shadowMap.type = shadowMapType;
+			animation.stop();
 
-	}
+		};
 
-	function onContextCreationError( event ) {
+		// Events
 
-		console.error( 'THREE.WebGLRenderer: A WebGL context could not be created. Reason: ', event.statusMessage );
+		function onContextLost( event ) {
 
-	}
+			event.preventDefault();
 
-	function onMaterialDispose( event ) {
+			console.log( 'THREE.WebGLRenderer: Context Lost.' );
 
-		const material = event.target;
+			_isContextLost = true;
 
-		material.removeEventListener( 'dispose', onMaterialDispose );
+		}
 
-		deallocateMaterial( material );
+		function onContextRestore( /* event */ ) {
 
-	}
+			console.log( 'THREE.WebGLRenderer: Context Restored.' );
 
-	// Buffer deallocation
+			_isContextLost = false;
 
-	function deallocateMaterial( material ) {
+			const infoAutoReset = info.autoReset;
+			const shadowMapEnabled = shadowMap.enabled;
+			const shadowMapAutoUpdate = shadowMap.autoUpdate;
+			const shadowMapNeedsUpdate = shadowMap.needsUpdate;
+			const shadowMapType = shadowMap.type;
 
-		releaseMaterialProgramReferences( material );
+			initGLContext();
 
-		properties.remove( material );
+			info.autoReset = infoAutoReset;
+			shadowMap.enabled = shadowMapEnabled;
+			shadowMap.autoUpdate = shadowMapAutoUpdate;
+			shadowMap.needsUpdate = shadowMapNeedsUpdate;
+			shadowMap.type = shadowMapType;
 
-	}
+		}
+
+		function onContextCreationError( event ) {
 
+			console.error( 'THREE.WebGLRenderer: A WebGL context could not be created. Reason: ', event.statusMessage );
 
-	function releaseMaterialProgramReferences( material ) {
+		}
 
-		const programs = properties.get( material ).programs;
+		function onMaterialDispose( event ) {
 
-		if ( programs !== undefined ) {
+			const material = event.target;
 
-			programs.forEach( function ( program ) {
+			material.removeEventListener( 'dispose', onMaterialDispose );
 
-				programCache.releaseProgram( program );
+			deallocateMaterial( material );
 
-			} );
+		}
 
-			if ( material.isShaderMaterial ) {
+		// Buffer deallocation
 
-				programCache.releaseShaderCache( material );
+		function deallocateMaterial( material ) {
 
-			}
+			releaseMaterialProgramReferences( material );
+
+			properties.remove( material );
 
 		}
 
-	}
 
-	// Buffer rendering
+		function releaseMaterialProgramReferences( material ) {
 
-	this.renderBufferDirect = function ( camera, scene, geometry, material, object, group ) {
+			const programs = properties.get( material ).programs;
 
-		if ( scene === null ) scene = _emptyScene; // renderBufferDirect second parameter used to be fog (could be null)
+			if ( programs !== undefined ) {
 
-		const frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 );
+				programs.forEach( function ( program ) {
 
-		const program = setProgram( camera, scene, geometry, material, object );
+					programCache.releaseProgram( program );
 
-		state.setMaterial( material, frontFaceCW );
+				} );
 
-		//
+				if ( material.isShaderMaterial ) {
 
-		let index = geometry.index;
-		let rangeFactor = 1;
+					programCache.releaseShaderCache( material );
 
-		if ( material.wireframe === true ) {
+				}
 
-			index = geometries.getWireframeAttribute( geometry );
-			rangeFactor = 2;
+			}
 
 		}
 
-		//
+		// Buffer rendering
 
-		const drawRange = geometry.drawRange;
-		const position = geometry.attributes.position;
+		this.renderBufferDirect = function ( camera, scene, geometry, material, object, group ) {
 
-		let drawStart = drawRange.start * rangeFactor;
-		let drawEnd = ( drawRange.start + drawRange.count ) * rangeFactor;
+			if ( scene === null ) scene = _emptyScene; // renderBufferDirect second parameter used to be fog (could be null)
 
-		if ( group !== null ) {
+			const frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 );
 
-			drawStart = Math.max( drawStart, group.start * rangeFactor );
-			drawEnd = Math.min( drawEnd, ( group.start + group.count ) * rangeFactor );
+			const program = setProgram( camera, scene, geometry, material, object );
 
-		}
+			state.setMaterial( material, frontFaceCW );
 
-		if ( index !== null ) {
+			//
 
-			drawStart = Math.max( drawStart, 0 );
-			drawEnd = Math.min( drawEnd, index.count );
+			let index = geometry.index;
+			let rangeFactor = 1;
 
-		} else if ( position !== undefined && position !== null ) {
+			if ( material.wireframe === true ) {
 
-			drawStart = Math.max( drawStart, 0 );
-			drawEnd = Math.min( drawEnd, position.count );
+				index = geometries.getWireframeAttribute( geometry );
+				rangeFactor = 2;
 
-		}
+			}
 
-		const drawCount = drawEnd - drawStart;
+			//
 
-		if ( drawCount < 0 || drawCount === Infinity ) return;
+			const drawRange = geometry.drawRange;
+			const position = geometry.attributes.position;
 
-		//
+			let drawStart = drawRange.start * rangeFactor;
+			let drawEnd = ( drawRange.start + drawRange.count ) * rangeFactor;
 
-		bindingStates.setup( object, material, program, geometry, index );
+			if ( group !== null ) {
 
-		let attribute;
-		let renderer = bufferRenderer;
+				drawStart = Math.max( drawStart, group.start * rangeFactor );
+				drawEnd = Math.min( drawEnd, ( group.start + group.count ) * rangeFactor );
 
-		if ( index !== null ) {
+			}
 
-			attribute = attributes.get( index );
+			if ( index !== null ) {
 
-			renderer = indexedBufferRenderer;
-			renderer.setIndex( attribute );
+				drawStart = Math.max( drawStart, 0 );
+				drawEnd = Math.min( drawEnd, index.count );
 
-		}
+			} else if ( position !== undefined && position !== null ) {
 
-		//
+				drawStart = Math.max( drawStart, 0 );
+				drawEnd = Math.min( drawEnd, position.count );
 
-		if ( object.isMesh ) {
+			}
 
-			if ( material.wireframe === true ) {
+			const drawCount = drawEnd - drawStart;
 
-				state.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() );
-				renderer.setMode( _gl.LINES );
+			if ( drawCount < 0 || drawCount === Infinity ) return;
 
-			} else {
+			//
 
-				renderer.setMode( _gl.TRIANGLES );
+			bindingStates.setup( object, material, program, geometry, index );
 
-			}
+			let attribute;
+			let renderer = bufferRenderer;
 
-		} else if ( object.isLine ) {
+			if ( index !== null ) {
 
-			let lineWidth = material.linewidth;
+				attribute = attributes.get( index );
 
-			if ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material
+				renderer = indexedBufferRenderer;
+				renderer.setIndex( attribute );
 
-			state.setLineWidth( lineWidth * getTargetPixelRatio() );
+			}
 
-			if ( object.isLineSegments ) {
+			//
 
-				renderer.setMode( _gl.LINES );
+			if ( object.isMesh ) {
 
-			} else if ( object.isLineLoop ) {
+				if ( material.wireframe === true ) {
 
-				renderer.setMode( _gl.LINE_LOOP );
+					state.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() );
+					renderer.setMode( _gl.LINES );
 
-			} else {
+				} else {
 
-				renderer.setMode( _gl.LINE_STRIP );
+					renderer.setMode( _gl.TRIANGLES );
 
-			}
+				}
 
-		} else if ( object.isPoints ) {
+			} else if ( object.isLine ) {
 
-			renderer.setMode( _gl.POINTS );
+				let lineWidth = material.linewidth;
 
-		} else if ( object.isSprite ) {
+				if ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material
 
-			renderer.setMode( _gl.TRIANGLES );
+				state.setLineWidth( lineWidth * getTargetPixelRatio() );
 
-		}
+				if ( object.isLineSegments ) {
 
-		if ( object.isInstancedMesh ) {
+					renderer.setMode( _gl.LINES );
 
-			renderer.renderInstances( drawStart, drawCount, object.count );
+				} else if ( object.isLineLoop ) {
 
-		} else if ( geometry.isInstancedBufferGeometry ) {
+					renderer.setMode( _gl.LINE_LOOP );
 
-			const maxInstanceCount = geometry._maxInstanceCount !== undefined ? geometry._maxInstanceCount : Infinity;
-			const instanceCount = Math.min( geometry.instanceCount, maxInstanceCount );
+				} else {
 
-			renderer.renderInstances( drawStart, drawCount, instanceCount );
+					renderer.setMode( _gl.LINE_STRIP );
 
-		} else {
+				}
 
-			renderer.render( drawStart, drawCount );
+			} else if ( object.isPoints ) {
 
-		}
+				renderer.setMode( _gl.POINTS );
 
-	};
+			} else if ( object.isSprite ) {
 
-	// Compile
+				renderer.setMode( _gl.TRIANGLES );
 
-	this.compile = function ( scene, camera ) {
+			}
 
-		function prepare( material, scene, object ) {
+			if ( object.isInstancedMesh ) {
 
-			if ( material.transparent === true && material.side === DoubleSide ) {
+				renderer.renderInstances( drawStart, drawCount, object.count );
 
-				material.side = BackSide;
-				material.needsUpdate = true;
-				getProgram( material, scene, object );
+			} else if ( geometry.isInstancedBufferGeometry ) {
 
-				material.side = FrontSide;
-				material.needsUpdate = true;
-				getProgram( material, scene, object );
+				const maxInstanceCount = geometry._maxInstanceCount !== undefined ? geometry._maxInstanceCount : Infinity;
+				const instanceCount = Math.min( geometry.instanceCount, maxInstanceCount );
 
-				material.side = DoubleSide;
+				renderer.renderInstances( drawStart, drawCount, instanceCount );
 
 			} else {
 
-				getProgram( material, scene, object );
+				renderer.render( drawStart, drawCount );
 
 			}
 
-		}
+		};
 
-		currentRenderState = renderStates.get( scene );
-		currentRenderState.init();
+		// Compile
 
-		renderStateStack.push( currentRenderState );
+		this.compile = function ( scene, camera ) {
 
-		scene.traverseVisible( function ( object ) {
+			function prepare( material, scene, object ) {
 
-			if ( object.isLight && object.layers.test( camera.layers ) ) {
+				if ( material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false ) {
 
-				currentRenderState.pushLight( object );
+					material.side = BackSide;
+					material.needsUpdate = true;
+					getProgram( material, scene, object );
 
-				if ( object.castShadow ) {
+					material.side = FrontSide;
+					material.needsUpdate = true;
+					getProgram( material, scene, object );
 
-					currentRenderState.pushShadow( object );
+					material.side = DoubleSide;
+
+				} else {
+
+					getProgram( material, scene, object );
 
 				}
 
 			}
 
-		} );
+			currentRenderState = renderStates.get( scene );
+			currentRenderState.init();
 
-		currentRenderState.setupLights( _this.physicallyCorrectLights );
+			renderStateStack.push( currentRenderState );
 
-		scene.traverse( function ( object ) {
+			scene.traverseVisible( function ( object ) {
 
-			const material = object.material;
+				if ( object.isLight && object.layers.test( camera.layers ) ) {
 
-			if ( material ) {
+					currentRenderState.pushLight( object );
 
-				if ( Array.isArray( material ) ) {
+					if ( object.castShadow ) {
 
-					for ( let i = 0; i < material.length; i ++ ) {
+						currentRenderState.pushShadow( object );
 
-						const material2 = material[ i ];
+					}
 
-						prepare( material2, scene, object );
+				}
 
-					}
+			} );
 
-				} else {
+			currentRenderState.setupLights( _this.useLegacyLights );
 
-					prepare( material, scene, object );
+			scene.traverse( function ( object ) {
 
-				}
+				const material = object.material;
 
-			}
+				if ( material ) {
 
-		} );
+					if ( Array.isArray( material ) ) {
 
-		renderStateStack.pop();
-		currentRenderState = null;
+						for ( let i = 0; i < material.length; i ++ ) {
 
-	};
+							const material2 = material[ i ];
 
-	// Animation Loop
+							prepare( material2, scene, object );
 
-	let onAnimationFrameCallback = null;
+						}
 
-	function onAnimationFrame( time ) {
+					} else {
 
-		if ( onAnimationFrameCallback ) onAnimationFrameCallback( time );
+						prepare( material, scene, object );
 
-	}
+					}
 
-	function onXRSessionStart() {
+				}
 
-		animation.stop();
+			} );
 
-	}
+			renderStateStack.pop();
+			currentRenderState = null;
 
-	function onXRSessionEnd() {
+		};
 
-		animation.start();
+		// Animation Loop
 
-	}
+		let onAnimationFrameCallback = null;
 
-	const animation = new WebGLAnimation();
-	animation.setAnimationLoop( onAnimationFrame );
+		function onAnimationFrame( time ) {
 
-	if ( typeof self !== 'undefined' ) animation.setContext( self );
+			if ( onAnimationFrameCallback ) onAnimationFrameCallback( time );
 
-	this.setAnimationLoop = function ( callback ) {
+		}
 
-		onAnimationFrameCallback = callback;
-		xr.setAnimationLoop( callback );
+		function onXRSessionStart() {
 
-		( callback === null ) ? animation.stop() : animation.start();
+			animation.stop();
 
-	};
+		}
 
-	xr.addEventListener( 'sessionstart', onXRSessionStart );
-	xr.addEventListener( 'sessionend', onXRSessionEnd );
+		function onXRSessionEnd() {
 
-	// Rendering
+			animation.start();
 
-	this.render = function ( scene, camera ) {
+		}
 
-		if ( camera !== undefined && camera.isCamera !== true ) {
+		const animation = new WebGLAnimation();
+		animation.setAnimationLoop( onAnimationFrame );
 
-			console.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' );
-			return;
+		if ( typeof self !== 'undefined' ) animation.setContext( self );
 
-		}
+		this.setAnimationLoop = function ( callback ) {
 
-		if ( _isContextLost === true ) return;
+			onAnimationFrameCallback = callback;
+			xr.setAnimationLoop( callback );
 
-		// update scene graph
+			( callback === null ) ? animation.stop() : animation.start();
 
-		if ( scene.matrixWorldAutoUpdate === true ) scene.updateMatrixWorld();
+		};
 
-		// update camera matrices and frustum
+		xr.addEventListener( 'sessionstart', onXRSessionStart );
+		xr.addEventListener( 'sessionend', onXRSessionEnd );
 
-		if ( camera.parent === null && camera.matrixWorldAutoUpdate === true ) camera.updateMatrixWorld();
+		// Rendering
 
-		if ( xr.enabled === true && xr.isPresenting === true ) {
+		this.render = function ( scene, camera ) {
 
-			if ( xr.cameraAutoUpdate === true ) xr.updateCamera( camera );
+			if ( camera !== undefined && camera.isCamera !== true ) {
 
-			camera = xr.getCamera(); // use XR camera for rendering
+				console.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' );
+				return;
 
-		}
+			}
 
-		//
-		if ( scene.isScene === true ) scene.onBeforeRender( _this, scene, camera, _currentRenderTarget );
+			if ( _isContextLost === true ) return;
 
-		currentRenderState = renderStates.get( scene, renderStateStack.length );
-		currentRenderState.init();
+			// update scene graph
 
-		renderStateStack.push( currentRenderState );
+			if ( scene.matrixWorldAutoUpdate === true ) scene.updateMatrixWorld();
 
-		_projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );
-		_frustum.setFromProjectionMatrix( _projScreenMatrix );
+			// update camera matrices and frustum
 
-		_localClippingEnabled = this.localClippingEnabled;
-		_clippingEnabled = clipping.init( this.clippingPlanes, _localClippingEnabled, camera );
+			if ( camera.parent === null && camera.matrixWorldAutoUpdate === true ) camera.updateMatrixWorld();
 
-		currentRenderList = renderLists.get( scene, renderListStack.length );
-		currentRenderList.init();
+			if ( xr.enabled === true && xr.isPresenting === true ) {
 
-		renderListStack.push( currentRenderList );
+				if ( xr.cameraAutoUpdate === true ) xr.updateCamera( camera );
 
-		projectObject( scene, camera, 0, _this.sortObjects );
+				camera = xr.getCamera(); // use XR camera for rendering
 
-		currentRenderList.finish();
+			}
 
-		if ( _this.sortObjects === true ) {
+			//
+			if ( scene.isScene === true ) scene.onBeforeRender( _this, scene, camera, _currentRenderTarget );
 
-			currentRenderList.sort( _opaqueSort, _transparentSort );
+			currentRenderState = renderStates.get( scene, renderStateStack.length );
+			currentRenderState.init();
 
-		}
+			renderStateStack.push( currentRenderState );
 
-		//
+			_projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );
+			_frustum.setFromProjectionMatrix( _projScreenMatrix );
 
-		if ( _clippingEnabled === true ) clipping.beginShadows();
+			_localClippingEnabled = this.localClippingEnabled;
+			_clippingEnabled = clipping.init( this.clippingPlanes, _localClippingEnabled );
 
-		const shadowsArray = currentRenderState.state.shadowsArray;
+			currentRenderList = renderLists.get( scene, renderListStack.length );
+			currentRenderList.init();
 
-		shadowMap.render( shadowsArray, scene, camera );
+			renderListStack.push( currentRenderList );
 
-		if ( _clippingEnabled === true ) clipping.endShadows();
+			projectObject( scene, camera, 0, _this.sortObjects );
 
-		//
+			currentRenderList.finish();
 
-		if ( this.info.autoReset === true ) this.info.reset();
+			if ( _this.sortObjects === true ) {
 
-		//
+				currentRenderList.sort( _opaqueSort, _transparentSort );
 
-		background.render( currentRenderList, scene );
+			}
 
-		// render scene
+			//
 
-		currentRenderState.setupLights( _this.physicallyCorrectLights );
+			this.info.render.frame ++;
 
-		if ( camera.isArrayCamera ) {
+			if ( _clippingEnabled === true ) clipping.beginShadows();
 
-			const cameras = camera.cameras;
+			const shadowsArray = currentRenderState.state.shadowsArray;
 
-			for ( let i = 0, l = cameras.length; i < l; i ++ ) {
+			shadowMap.render( shadowsArray, scene, camera );
 
-				const camera2 = cameras[ i ];
+			if ( _clippingEnabled === true ) clipping.endShadows();
 
-				renderScene( currentRenderList, scene, camera2, camera2.viewport );
+			//
 
-			}
+			if ( this.info.autoReset === true ) this.info.reset();
 
-		} else {
 
-			renderScene( currentRenderList, scene, camera );
+			//
 
-		}
+			background.render( currentRenderList, scene );
 
-		//
+			// render scene
 
-		if ( _currentRenderTarget !== null ) {
+			currentRenderState.setupLights( _this.useLegacyLights );
 
-			// resolve multisample renderbuffers to a single-sample texture if necessary
+			if ( camera.isArrayCamera ) {
 
-			textures.updateMultisampleRenderTarget( _currentRenderTarget );
+				const cameras = camera.cameras;
 
-			// Generate mipmap if we're using any kind of mipmap filtering
+				for ( let i = 0, l = cameras.length; i < l; i ++ ) {
 
-			textures.updateRenderTargetMipmap( _currentRenderTarget );
+					const camera2 = cameras[ i ];
 
-		}
+					renderScene( currentRenderList, scene, camera2, camera2.viewport );
 
-		//
+				}
+
+			} else {
 
-		if ( scene.isScene === true ) scene.onAfterRender( _this, scene, camera );
+				renderScene( currentRenderList, scene, camera );
 
-		if ( xr.enabled && xr.submitFrame ) {
+			}
 
-			xr.submitFrame();
+			//
 
-		}
-		// _gl.finish();
+			if ( _currentRenderTarget !== null ) {
 
-		bindingStates.resetDefaultState();
-		_currentMaterialId = - 1;
-		_currentCamera = null;
+				// resolve multisample renderbuffers to a single-sample texture if necessary
 
-		renderStateStack.pop();
+				textures.updateMultisampleRenderTarget( _currentRenderTarget );
 
-		if ( renderStateStack.length > 0 ) {
+				// Generate mipmap if we're using any kind of mipmap filtering
 
-			currentRenderState = renderStateStack[ renderStateStack.length - 1 ];
+				textures.updateRenderTargetMipmap( _currentRenderTarget );
 
-		} else {
+			}
 
-			currentRenderState = null;
+			//
 
-		}
+			if ( scene.isScene === true ) scene.onAfterRender( _this, scene, camera );
 
-		renderListStack.pop();
+			if ( xr.enabled && xr.submitFrame ) {
 
-		if ( renderListStack.length > 0 ) {
+				xr.submitFrame();
 
-			currentRenderList = renderListStack[ renderListStack.length - 1 ];
+			}
+			// _gl.finish();
 
-		} else {
+			bindingStates.resetDefaultState();
+			_currentMaterialId = - 1;
+			_currentCamera = null;
 
-			currentRenderList = null;
+			renderStateStack.pop();
 
-		}
+			if ( renderStateStack.length > 0 ) {
 
-	};
+				currentRenderState = renderStateStack[ renderStateStack.length - 1 ];
 
-	function projectObject( object, camera, groupOrder, sortObjects ) {
+			} else {
 
-		if ( object.visible === false ) return;
+				currentRenderState = null;
 
-		const visible = object.layers.test( camera.layers );
+			}
+
+			renderListStack.pop();
 
-		if ( visible ) {
+			if ( renderListStack.length > 0 ) {
 
-			if ( object.isGroup ) {
+				currentRenderList = renderListStack[ renderListStack.length - 1 ];
 
-				groupOrder = object.renderOrder;
+			} else {
 
-			} else if ( object.isLOD ) {
+				currentRenderList = null;
 
-				if ( object.autoUpdate === true ) object.update( camera );
+			}
 
-			} else if ( object.isLight ) {
+		};
 
-				currentRenderState.pushLight( object );
+		function projectObject( object, camera, groupOrder, sortObjects ) {
 
-				if ( object.castShadow ) {
+			if ( object.visible === false ) return;
 
-					currentRenderState.pushShadow( object );
+			const visible = object.layers.test( camera.layers );
 
-				}
+			if ( visible ) {
 
-			} else if ( object.isSprite ) {
+				if ( object.isGroup ) {
 
-				if ( ! object.frustumCulled || _frustum.intersectsSprite( object ) ) {
+					groupOrder = object.renderOrder;
 
-					if ( sortObjects ) {
+				} else if ( object.isLOD ) {
 
-						_vector3.setFromMatrixPosition( object.matrixWorld )
-							.applyMatrix4( _projScreenMatrix );
+					if ( object.autoUpdate === true ) object.update( camera );
 
-					}
+				} else if ( object.isLight ) {
 
-					const geometry = objects.update( object );
-					const material = object.material;
+					currentRenderState.pushLight( object );
 
-					if ( material.visible ) {
+					if ( object.castShadow ) {
 
-						currentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );
+						currentRenderState.pushShadow( object );
 
 					}
 
-				}
+				} else if ( object.isSprite ) {
+
+					if ( ! object.frustumCulled || _frustum.intersectsSprite( object ) ) {
 
-			} else if ( object.isMesh || object.isLine || object.isPoints ) {
+						if ( sortObjects ) {
 
-				if ( object.isSkinnedMesh ) {
+							_vector3.setFromMatrixPosition( object.matrixWorld )
+								.applyMatrix4( _projScreenMatrix );
 
-					// update skeleton only once in a frame
+						}
+
+						const geometry = objects.update( object );
+						const material = object.material;
 
-					if ( object.skeleton.frame !== info.render.frame ) {
+						if ( material.visible ) {
 
-						object.skeleton.update();
-						object.skeleton.frame = info.render.frame;
+							currentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );
+
+						}
 
 					}
 
-				}
+				} else if ( object.isMesh || object.isLine || object.isPoints ) {
 
-				if ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) {
+					if ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) {
 
-					if ( sortObjects ) {
+						const geometry = objects.update( object );
+						const material = object.material;
 
-						_vector3.setFromMatrixPosition( object.matrixWorld )
-							.applyMatrix4( _projScreenMatrix );
+						if ( sortObjects ) {
 
-					}
+							if ( object.boundingSphere !== undefined ) {
 
-					const geometry = objects.update( object );
-					const material = object.material;
+								if ( object.boundingSphere === null ) object.computeBoundingSphere();
+								_vector3.copy( object.boundingSphere.center );
 
-					if ( Array.isArray( material ) ) {
+							} else {
 
-						const groups = geometry.groups;
+								if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
+								_vector3.copy( geometry.boundingSphere.center );
 
-						for ( let i = 0, l = groups.length; i < l; i ++ ) {
+							}
+
+							_vector3
+								.applyMatrix4( object.matrixWorld )
+								.applyMatrix4( _projScreenMatrix );
+
+						}
+
+						if ( Array.isArray( material ) ) {
+
+							const groups = geometry.groups;
+
+							for ( let i = 0, l = groups.length; i < l; i ++ ) {
 
-							const group = groups[ i ];
-							const groupMaterial = material[ group.materialIndex ];
+								const group = groups[ i ];
+								const groupMaterial = material[ group.materialIndex ];
 
-							if ( groupMaterial && groupMaterial.visible ) {
+								if ( groupMaterial && groupMaterial.visible ) {
 
-								currentRenderList.push( object, geometry, groupMaterial, groupOrder, _vector3.z, group );
+									currentRenderList.push( object, geometry, groupMaterial, groupOrder, _vector3.z, group );
+
+								}
 
 							}
 
-						}
+						} else if ( material.visible ) {
 
-					} else if ( material.visible ) {
+							currentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );
 
-						currentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );
+						}
 
 					}
 
@@ -1195,1090 +1292,1180 @@ function WebGLRenderer( parameters = {} ) {
 
 			}
 
-		}
+			const children = object.children;
 
-		const children = object.children;
+			for ( let i = 0, l = children.length; i < l; i ++ ) {
 
-		for ( let i = 0, l = children.length; i < l; i ++ ) {
+				projectObject( children[ i ], camera, groupOrder, sortObjects );
 
-			projectObject( children[ i ], camera, groupOrder, sortObjects );
+			}
 
 		}
 
-	}
+		function renderScene( currentRenderList, scene, camera, viewport ) {
 
-	function renderScene( currentRenderList, scene, camera, viewport ) {
+			const opaqueObjects = currentRenderList.opaque;
+			const transmissiveObjects = currentRenderList.transmissive;
+			const transparentObjects = currentRenderList.transparent;
 
-		const opaqueObjects = currentRenderList.opaque;
-		const transmissiveObjects = currentRenderList.transmissive;
-		const transparentObjects = currentRenderList.transparent;
+			currentRenderState.setupLightsView( camera );
 
-		currentRenderState.setupLightsView( camera );
+			if ( _clippingEnabled === true ) clipping.setGlobalState( _this.clippingPlanes, camera );
 
-		if ( transmissiveObjects.length > 0 ) renderTransmissionPass( opaqueObjects, scene, camera );
+			if ( transmissiveObjects.length > 0 ) renderTransmissionPass( opaqueObjects, transmissiveObjects, scene, camera );
 
-		if ( viewport ) state.viewport( _currentViewport.copy( viewport ) );
+			if ( viewport ) state.viewport( _currentViewport.copy( viewport ) );
 
-		if ( opaqueObjects.length > 0 ) renderObjects( opaqueObjects, scene, camera );
-		if ( transmissiveObjects.length > 0 ) renderObjects( transmissiveObjects, scene, camera );
-		if ( transparentObjects.length > 0 ) renderObjects( transparentObjects, scene, camera );
+			if ( opaqueObjects.length > 0 ) renderObjects( opaqueObjects, scene, camera );
+			if ( transmissiveObjects.length > 0 ) renderObjects( transmissiveObjects, scene, camera );
+			if ( transparentObjects.length > 0 ) renderObjects( transparentObjects, scene, camera );
 
-		// Ensure depth buffer writing is enabled so it can be cleared on next render
+			// Ensure depth buffer writing is enabled so it can be cleared on next render
 
-		state.buffers.depth.setTest( true );
-		state.buffers.depth.setMask( true );
-		state.buffers.color.setMask( true );
+			state.buffers.depth.setTest( true );
+			state.buffers.depth.setMask( true );
+			state.buffers.color.setMask( true );
 
-		state.setPolygonOffset( false );
+			state.setPolygonOffset( false );
 
-	}
+		}
 
-	function renderTransmissionPass( opaqueObjects, scene, camera ) {
+		function renderTransmissionPass( opaqueObjects, transmissiveObjects, scene, camera ) {
 
-		const isWebGL2 = capabilities.isWebGL2;
+			const isWebGL2 = capabilities.isWebGL2;
 
-		if ( _transmissionRenderTarget === null ) {
+			if ( _transmissionRenderTarget === null ) {
 
-			_transmissionRenderTarget = new WebGLRenderTarget( 1, 1, {
-				generateMipmaps: true,
-				type: extensions.has( 'EXT_color_buffer_half_float' ) ? HalfFloatType : UnsignedByteType,
-				minFilter: LinearMipmapLinearFilter,
-				samples: ( isWebGL2 && _antialias === true ) ? 4 : 0
-			} );
+				_transmissionRenderTarget = new WebGLRenderTarget( 1, 1, {
+					generateMipmaps: true,
+					type: extensions.has( 'EXT_color_buffer_half_float' ) ? HalfFloatType : UnsignedByteType,
+					minFilter: LinearMipmapLinearFilter,
+					samples: ( isWebGL2 ) ? 4 : 0
+				} );
 
-		}
+				// debug
 
-		_this.getDrawingBufferSize( _vector2 );
+				/*
+				const geometry = new PlaneGeometry();
+				const material = new MeshBasicMaterial( { map: _transmissionRenderTarget.texture } );
 
-		if ( isWebGL2 ) {
+				const mesh = new Mesh( geometry, material );
+				scene.add( mesh );
+				*/
 
-			_transmissionRenderTarget.setSize( _vector2.x, _vector2.y );
+			}
 
-		} else {
+			_this.getDrawingBufferSize( _vector2 );
 
-			_transmissionRenderTarget.setSize( floorPowerOfTwo( _vector2.x ), floorPowerOfTwo( _vector2.y ) );
+			if ( isWebGL2 ) {
 
-		}
+				_transmissionRenderTarget.setSize( _vector2.x, _vector2.y );
 
-		//
+			} else {
 
-		const currentRenderTarget = _this.getRenderTarget();
-		_this.setRenderTarget( _transmissionRenderTarget );
-		_this.clear();
+				_transmissionRenderTarget.setSize( floorPowerOfTwo( _vector2.x ), floorPowerOfTwo( _vector2.y ) );
 
-		// Turn off the features which can affect the frag color for opaque objects pass.
-		// Otherwise they are applied twice in opaque objects pass and transmission objects pass.
-		const currentToneMapping = _this.toneMapping;
-		_this.toneMapping = NoToneMapping;
+			}
 
-		renderObjects( opaqueObjects, scene, camera );
+			//
 
-		_this.toneMapping = currentToneMapping;
+			const currentRenderTarget = _this.getRenderTarget();
+			_this.setRenderTarget( _transmissionRenderTarget );
 
-		textures.updateMultisampleRenderTarget( _transmissionRenderTarget );
-		textures.updateRenderTargetMipmap( _transmissionRenderTarget );
+			_this.getClearColor( _currentClearColor );
+			_currentClearAlpha = _this.getClearAlpha();
+			if ( _currentClearAlpha < 1 ) _this.setClearColor( 0xffffff, 0.5 );
 
-		_this.setRenderTarget( currentRenderTarget );
+			_this.clear();
 
-	}
+			// Turn off the features which can affect the frag color for opaque objects pass.
+			// Otherwise they are applied twice in opaque objects pass and transmission objects pass.
+			const currentToneMapping = _this.toneMapping;
+			_this.toneMapping = NoToneMapping;
 
-	function renderObjects( renderList, scene, camera ) {
+			renderObjects( opaqueObjects, scene, camera );
 
-		const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;
+			textures.updateMultisampleRenderTarget( _transmissionRenderTarget );
+			textures.updateRenderTargetMipmap( _transmissionRenderTarget );
 
-		for ( let i = 0, l = renderList.length; i < l; i ++ ) {
+			let renderTargetNeedsUpdate = false;
 
-			const renderItem = renderList[ i ];
+			for ( let i = 0, l = transmissiveObjects.length; i < l; i ++ ) {
 
-			const object = renderItem.object;
-			const geometry = renderItem.geometry;
-			const material = overrideMaterial === null ? renderItem.material : overrideMaterial;
-			const group = renderItem.group;
+				const renderItem = transmissiveObjects[ i ];
 
-			if ( object.layers.test( camera.layers ) ) {
+				const object = renderItem.object;
+				const geometry = renderItem.geometry;
+				const material = renderItem.material;
+				const group = renderItem.group;
 
-				renderObject( object, scene, camera, geometry, material, group );
+				if ( material.side === DoubleSide && object.layers.test( camera.layers ) ) {
 
-			}
+					const currentSide = material.side;
 
-		}
+					material.side = BackSide;
+					material.needsUpdate = true;
 
-	}
+					renderObject( object, scene, camera, geometry, material, group );
 
-	function renderObject( object, scene, camera, geometry, material, group ) {
+					material.side = currentSide;
+					material.needsUpdate = true;
 
-		object.onBeforeRender( _this, scene, camera, geometry, material, group );
+					renderTargetNeedsUpdate = true;
 
-		object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );
-		object.normalMatrix.getNormalMatrix( object.modelViewMatrix );
+				}
 
-		material.onBeforeRender( _this, scene, camera, geometry, object, group );
+			}
 
-		if ( material.transparent === true && material.side === DoubleSide ) {
+			if ( renderTargetNeedsUpdate === true ) {
 
-			material.side = BackSide;
-			material.needsUpdate = true;
-			_this.renderBufferDirect( camera, scene, geometry, material, object, group );
+				textures.updateMultisampleRenderTarget( _transmissionRenderTarget );
+				textures.updateRenderTargetMipmap( _transmissionRenderTarget );
 
-			material.side = FrontSide;
-			material.needsUpdate = true;
-			_this.renderBufferDirect( camera, scene, geometry, material, object, group );
+			}
 
-			material.side = DoubleSide;
+			_this.setRenderTarget( currentRenderTarget );
 
-		} else {
+			_this.setClearColor( _currentClearColor, _currentClearAlpha );
 
-			_this.renderBufferDirect( camera, scene, geometry, material, object, group );
+			_this.toneMapping = currentToneMapping;
 
 		}
 
-		object.onAfterRender( _this, scene, camera, geometry, material, group );
+		function renderObjects( renderList, scene, camera ) {
 
-	}
+			const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;
 
-	function getProgram( material, scene, object ) {
+			for ( let i = 0, l = renderList.length; i < l; i ++ ) {
 
-		if ( scene.isScene !== true ) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...
+				const renderItem = renderList[ i ];
 
-		const materialProperties = properties.get( material );
+				const object = renderItem.object;
+				const geometry = renderItem.geometry;
+				const material = overrideMaterial === null ? renderItem.material : overrideMaterial;
+				const group = renderItem.group;
 
-		const lights = currentRenderState.state.lights;
-		const shadowsArray = currentRenderState.state.shadowsArray;
+				if ( object.layers.test( camera.layers ) ) {
 
-		const lightsStateVersion = lights.state.version;
+					renderObject( object, scene, camera, geometry, material, group );
 
-		const parameters = programCache.getParameters( material, lights.state, shadowsArray, scene, object );
-		const programCacheKey = programCache.getProgramCacheKey( parameters );
+				}
 
-		let programs = materialProperties.programs;
+			}
 
-		// always update environment and fog - changing these trigger an getProgram call, but it's possible that the program doesn't change
+		}
 
-		materialProperties.environment = material.isMeshStandardMaterial ? scene.environment : null;
-		materialProperties.fog = scene.fog;
-		materialProperties.envMap = ( material.isMeshStandardMaterial ? cubeuvmaps : cubemaps ).get( material.envMap || materialProperties.environment );
+		function renderObject( object, scene, camera, geometry, material, group ) {
 
-		if ( programs === undefined ) {
+			object.onBeforeRender( _this, scene, camera, geometry, material, group );
 
-			// new material
+			object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );
+			object.normalMatrix.getNormalMatrix( object.modelViewMatrix );
 
-			material.addEventListener( 'dispose', onMaterialDispose );
+			material.onBeforeRender( _this, scene, camera, geometry, object, group );
 
-			programs = new Map();
-			materialProperties.programs = programs;
+			if ( material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false ) {
 
-		}
+				material.side = BackSide;
+				material.needsUpdate = true;
+				_this.renderBufferDirect( camera, scene, geometry, material, object, group );
 
-		let program = programs.get( programCacheKey );
+				material.side = FrontSide;
+				material.needsUpdate = true;
+				_this.renderBufferDirect( camera, scene, geometry, material, object, group );
 
-		if ( program !== undefined ) {
+				material.side = DoubleSide;
 
-			// early out if program and light state is identical
+			} else {
 
-			if ( materialProperties.currentProgram === program && materialProperties.lightsStateVersion === lightsStateVersion ) {
+				_this.renderBufferDirect( camera, scene, geometry, material, object, group );
 
-				updateCommonMaterialProperties( material, parameters );
+			}
 
-				return program;
+			object.onAfterRender( _this, scene, camera, geometry, material, group );
 
-			}
+		}
 
-		} else {
+		function getProgram( material, scene, object ) {
 
-			parameters.uniforms = programCache.getUniforms( material );
+			if ( scene.isScene !== true ) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...
 
-			material.onBuild( object, parameters, _this );
+			const materialProperties = properties.get( material );
 
-			material.onBeforeCompile( parameters, _this );
+			const lights = currentRenderState.state.lights;
+			const shadowsArray = currentRenderState.state.shadowsArray;
 
-			program = programCache.acquireProgram( parameters, programCacheKey );
-			programs.set( programCacheKey, program );
+			const lightsStateVersion = lights.state.version;
 
-			materialProperties.uniforms = parameters.uniforms;
+			const parameters = programCache.getParameters( material, lights.state, shadowsArray, scene, object );
+			const programCacheKey = programCache.getProgramCacheKey( parameters );
 
-		}
+			let programs = materialProperties.programs;
 
-		const uniforms = materialProperties.uniforms;
+			// always update environment and fog - changing these trigger an getProgram call, but it's possible that the program doesn't change
 
-		if ( ( ! material.isShaderMaterial && ! material.isRawShaderMaterial ) || material.clipping === true ) {
+			materialProperties.environment = material.isMeshStandardMaterial ? scene.environment : null;
+			materialProperties.fog = scene.fog;
+			materialProperties.envMap = ( material.isMeshStandardMaterial ? cubeuvmaps : cubemaps ).get( material.envMap || materialProperties.environment );
 
-			uniforms.clippingPlanes = clipping.uniform;
+			if ( programs === undefined ) {
 
-		}
+				// new material
 
-		updateCommonMaterialProperties( material, parameters );
+				material.addEventListener( 'dispose', onMaterialDispose );
 
-		// store the light setup it was created for
+				programs = new Map();
+				materialProperties.programs = programs;
 
-		materialProperties.needsLights = materialNeedsLights( material );
-		materialProperties.lightsStateVersion = lightsStateVersion;
+			}
 
-		if ( materialProperties.needsLights ) {
+			let program = programs.get( programCacheKey );
 
-			// wire up the material to this renderer's lighting state
+			if ( program !== undefined ) {
 
-			uniforms.ambientLightColor.value = lights.state.ambient;
-			uniforms.lightProbe.value = lights.state.probe;
-			uniforms.directionalLights.value = lights.state.directional;
-			uniforms.directionalLightShadows.value = lights.state.directionalShadow;
-			uniforms.spotLights.value = lights.state.spot;
-			uniforms.spotLightShadows.value = lights.state.spotShadow;
-			uniforms.rectAreaLights.value = lights.state.rectArea;
-			uniforms.ltc_1.value = lights.state.rectAreaLTC1;
-			uniforms.ltc_2.value = lights.state.rectAreaLTC2;
-			uniforms.pointLights.value = lights.state.point;
-			uniforms.pointLightShadows.value = lights.state.pointShadow;
-			uniforms.hemisphereLights.value = lights.state.hemi;
+				// early out if program and light state is identical
 
-			uniforms.directionalShadowMap.value = lights.state.directionalShadowMap;
-			uniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix;
-			uniforms.spotShadowMap.value = lights.state.spotShadowMap;
-			uniforms.spotLightMatrix.value = lights.state.spotLightMatrix;
-			uniforms.spotLightMap.value = lights.state.spotLightMap;
-			uniforms.pointShadowMap.value = lights.state.pointShadowMap;
-			uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix;
-			// TODO (abelnation): add area lights shadow info to uniforms
+				if ( materialProperties.currentProgram === program && materialProperties.lightsStateVersion === lightsStateVersion ) {
 
-		}
+					updateCommonMaterialProperties( material, parameters );
 
-		const progUniforms = program.getUniforms();
-		const uniformsList = WebGLUniforms.seqWithValue( progUniforms.seq, uniforms );
+					return program;
 
-		materialProperties.currentProgram = program;
-		materialProperties.uniformsList = uniformsList;
+				}
 
-		return program;
+			} else {
 
-	}
+				parameters.uniforms = programCache.getUniforms( material );
 
-	function updateCommonMaterialProperties( material, parameters ) {
+				material.onBuild( object, parameters, _this );
 
-		const materialProperties = properties.get( material );
+				material.onBeforeCompile( parameters, _this );
 
-		materialProperties.outputEncoding = parameters.outputEncoding;
-		materialProperties.instancing = parameters.instancing;
-		materialProperties.skinning = parameters.skinning;
-		materialProperties.morphTargets = parameters.morphTargets;
-		materialProperties.morphNormals = parameters.morphNormals;
-		materialProperties.morphColors = parameters.morphColors;
-		materialProperties.morphTargetsCount = parameters.morphTargetsCount;
-		materialProperties.numClippingPlanes = parameters.numClippingPlanes;
-		materialProperties.numIntersection = parameters.numClipIntersection;
-		materialProperties.vertexAlphas = parameters.vertexAlphas;
-		materialProperties.vertexTangents = parameters.vertexTangents;
-		materialProperties.toneMapping = parameters.toneMapping;
+				program = programCache.acquireProgram( parameters, programCacheKey );
+				programs.set( programCacheKey, program );
 
-	}
+				materialProperties.uniforms = parameters.uniforms;
 
-	function setProgram( camera, scene, geometry, material, object ) {
+			}
 
-		if ( scene.isScene !== true ) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...
+			const uniforms = materialProperties.uniforms;
 
-		textures.resetTextureUnits();
+			if ( ( ! material.isShaderMaterial && ! material.isRawShaderMaterial ) || material.clipping === true ) {
 
-		const fog = scene.fog;
-		const environment = material.isMeshStandardMaterial ? scene.environment : null;
-		const encoding = ( _currentRenderTarget === null ) ? _this.outputEncoding : ( _currentRenderTarget.isXRRenderTarget === true ? _currentRenderTarget.texture.encoding : LinearEncoding );
-		const envMap = ( material.isMeshStandardMaterial ? cubeuvmaps : cubemaps ).get( material.envMap || environment );
-		const vertexAlphas = material.vertexColors === true && !! geometry.attributes.color && geometry.attributes.color.itemSize === 4;
-		const vertexTangents = !! material.normalMap && !! geometry.attributes.tangent;
-		const morphTargets = !! geometry.morphAttributes.position;
-		const morphNormals = !! geometry.morphAttributes.normal;
-		const morphColors = !! geometry.morphAttributes.color;
-		const toneMapping = material.toneMapped ? _this.toneMapping : NoToneMapping;
+				uniforms.clippingPlanes = clipping.uniform;
 
-		const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
-		const morphTargetsCount = ( morphAttribute !== undefined ) ? morphAttribute.length : 0;
+			}
 
-		const materialProperties = properties.get( material );
-		const lights = currentRenderState.state.lights;
+			updateCommonMaterialProperties( material, parameters );
 
-		if ( _clippingEnabled === true ) {
+			// store the light setup it was created for
 
-			if ( _localClippingEnabled === true || camera !== _currentCamera ) {
+			materialProperties.needsLights = materialNeedsLights( material );
+			materialProperties.lightsStateVersion = lightsStateVersion;
 
-				const useCache =
-					camera === _currentCamera &&
-					material.id === _currentMaterialId;
+			if ( materialProperties.needsLights ) {
 
-				// we might want to call this function with some ClippingGroup
-				// object instead of the material, once it becomes feasible
-				// (#8465, #8379)
-				clipping.setState( material, camera, useCache );
+				// wire up the material to this renderer's lighting state
+
+				uniforms.ambientLightColor.value = lights.state.ambient;
+				uniforms.lightProbe.value = lights.state.probe;
+				uniforms.directionalLights.value = lights.state.directional;
+				uniforms.directionalLightShadows.value = lights.state.directionalShadow;
+				uniforms.spotLights.value = lights.state.spot;
+				uniforms.spotLightShadows.value = lights.state.spotShadow;
+				uniforms.rectAreaLights.value = lights.state.rectArea;
+				uniforms.ltc_1.value = lights.state.rectAreaLTC1;
+				uniforms.ltc_2.value = lights.state.rectAreaLTC2;
+				uniforms.pointLights.value = lights.state.point;
+				uniforms.pointLightShadows.value = lights.state.pointShadow;
+				uniforms.hemisphereLights.value = lights.state.hemi;
+
+				uniforms.directionalShadowMap.value = lights.state.directionalShadowMap;
+				uniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix;
+				uniforms.spotShadowMap.value = lights.state.spotShadowMap;
+				uniforms.spotLightMatrix.value = lights.state.spotLightMatrix;
+				uniforms.spotLightMap.value = lights.state.spotLightMap;
+				uniforms.pointShadowMap.value = lights.state.pointShadowMap;
+				uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix;
+				// TODO (abelnation): add area lights shadow info to uniforms
 
 			}
 
-		}
+			const progUniforms = program.getUniforms();
+			const uniformsList = WebGLUniforms.seqWithValue( progUniforms.seq, uniforms );
 
-		//
+			materialProperties.currentProgram = program;
+			materialProperties.uniformsList = uniformsList;
 
-		let needsProgramChange = false;
+			return program;
 
-		if ( material.version === materialProperties.__version ) {
+		}
 
-			if ( materialProperties.needsLights && ( materialProperties.lightsStateVersion !== lights.state.version ) ) {
+		function updateCommonMaterialProperties( material, parameters ) {
 
-				needsProgramChange = true;
+			const materialProperties = properties.get( material );
 
-			} else if ( materialProperties.outputEncoding !== encoding ) {
+			materialProperties.outputColorSpace = parameters.outputColorSpace;
+			materialProperties.instancing = parameters.instancing;
+			materialProperties.skinning = parameters.skinning;
+			materialProperties.morphTargets = parameters.morphTargets;
+			materialProperties.morphNormals = parameters.morphNormals;
+			materialProperties.morphColors = parameters.morphColors;
+			materialProperties.morphTargetsCount = parameters.morphTargetsCount;
+			materialProperties.numClippingPlanes = parameters.numClippingPlanes;
+			materialProperties.numIntersection = parameters.numClipIntersection;
+			materialProperties.vertexAlphas = parameters.vertexAlphas;
+			materialProperties.vertexTangents = parameters.vertexTangents;
+			materialProperties.toneMapping = parameters.toneMapping;
 
-				needsProgramChange = true;
+		}
 
-			} else if ( object.isInstancedMesh && materialProperties.instancing === false ) {
+		function setProgram( camera, scene, geometry, material, object ) {
 
-				needsProgramChange = true;
+			if ( scene.isScene !== true ) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...
 
-			} else if ( ! object.isInstancedMesh && materialProperties.instancing === true ) {
+			textures.resetTextureUnits();
 
-				needsProgramChange = true;
+			const fog = scene.fog;
+			const environment = material.isMeshStandardMaterial ? scene.environment : null;
+			const colorSpace = ( _currentRenderTarget === null ) ? _this.outputColorSpace : ( _currentRenderTarget.isXRRenderTarget === true ? _currentRenderTarget.texture.colorSpace : LinearSRGBColorSpace );
+			const envMap = ( material.isMeshStandardMaterial ? cubeuvmaps : cubemaps ).get( material.envMap || environment );
+			const vertexAlphas = material.vertexColors === true && !! geometry.attributes.color && geometry.attributes.color.itemSize === 4;
+			const vertexTangents = !! geometry.attributes.tangent && ( !! material.normalMap || material.anisotropy > 0 );
+			const morphTargets = !! geometry.morphAttributes.position;
+			const morphNormals = !! geometry.morphAttributes.normal;
+			const morphColors = !! geometry.morphAttributes.color;
+			const toneMapping = material.toneMapped ? _this.toneMapping : NoToneMapping;
 
-			} else if ( object.isSkinnedMesh && materialProperties.skinning === false ) {
+			const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
+			const morphTargetsCount = ( morphAttribute !== undefined ) ? morphAttribute.length : 0;
 
-				needsProgramChange = true;
+			const materialProperties = properties.get( material );
+			const lights = currentRenderState.state.lights;
 
-			} else if ( ! object.isSkinnedMesh && materialProperties.skinning === true ) {
+			if ( _clippingEnabled === true ) {
 
-				needsProgramChange = true;
+				if ( _localClippingEnabled === true || camera !== _currentCamera ) {
 
-			} else if ( materialProperties.envMap !== envMap ) {
+					const useCache =
+						camera === _currentCamera &&
+						material.id === _currentMaterialId;
 
-				needsProgramChange = true;
+					// we might want to call this function with some ClippingGroup
+					// object instead of the material, once it becomes feasible
+					// (#8465, #8379)
+					clipping.setState( material, camera, useCache );
 
-			} else if ( material.fog === true && materialProperties.fog !== fog ) {
+				}
 
-				needsProgramChange = true;
+			}
 
-			} else if ( materialProperties.numClippingPlanes !== undefined &&
-				( materialProperties.numClippingPlanes !== clipping.numPlanes ||
-				materialProperties.numIntersection !== clipping.numIntersection ) ) {
+			//
 
-				needsProgramChange = true;
+			let needsProgramChange = false;
 
-			} else if ( materialProperties.vertexAlphas !== vertexAlphas ) {
+			if ( material.version === materialProperties.__version ) {
 
-				needsProgramChange = true;
+				if ( materialProperties.needsLights && ( materialProperties.lightsStateVersion !== lights.state.version ) ) {
 
-			} else if ( materialProperties.vertexTangents !== vertexTangents ) {
+					needsProgramChange = true;
 
-				needsProgramChange = true;
+				} else if ( materialProperties.outputColorSpace !== colorSpace ) {
 
-			} else if ( materialProperties.morphTargets !== morphTargets ) {
+					needsProgramChange = true;
 
-				needsProgramChange = true;
+				} else if ( object.isInstancedMesh && materialProperties.instancing === false ) {
 
-			} else if ( materialProperties.morphNormals !== morphNormals ) {
+					needsProgramChange = true;
 
-				needsProgramChange = true;
+				} else if ( ! object.isInstancedMesh && materialProperties.instancing === true ) {
 
-			} else if ( materialProperties.morphColors !== morphColors ) {
+					needsProgramChange = true;
 
-				needsProgramChange = true;
+				} else if ( object.isSkinnedMesh && materialProperties.skinning === false ) {
 
-			} else if ( materialProperties.toneMapping !== toneMapping ) {
+					needsProgramChange = true;
 
-				needsProgramChange = true;
+				} else if ( ! object.isSkinnedMesh && materialProperties.skinning === true ) {
 
-			} else if ( capabilities.isWebGL2 === true && materialProperties.morphTargetsCount !== morphTargetsCount ) {
+					needsProgramChange = true;
 
-				needsProgramChange = true;
+				} else if ( materialProperties.envMap !== envMap ) {
 
-			}
+					needsProgramChange = true;
 
-		} else {
+				} else if ( material.fog === true && materialProperties.fog !== fog ) {
 
-			needsProgramChange = true;
-			materialProperties.__version = material.version;
+					needsProgramChange = true;
 
-		}
+				} else if ( materialProperties.numClippingPlanes !== undefined &&
+					( materialProperties.numClippingPlanes !== clipping.numPlanes ||
+					materialProperties.numIntersection !== clipping.numIntersection ) ) {
 
-		//
+					needsProgramChange = true;
 
-		let program = materialProperties.currentProgram;
+				} else if ( materialProperties.vertexAlphas !== vertexAlphas ) {
 
-		if ( needsProgramChange === true ) {
+					needsProgramChange = true;
 
-			program = getProgram( material, scene, object );
+				} else if ( materialProperties.vertexTangents !== vertexTangents ) {
 
-		}
+					needsProgramChange = true;
 
-		let refreshProgram = false;
-		let refreshMaterial = false;
-		let refreshLights = false;
+				} else if ( materialProperties.morphTargets !== morphTargets ) {
 
-		const p_uniforms = program.getUniforms(),
-			m_uniforms = materialProperties.uniforms;
+					needsProgramChange = true;
 
-		if ( state.useProgram( program.program ) ) {
+				} else if ( materialProperties.morphNormals !== morphNormals ) {
 
-			refreshProgram = true;
-			refreshMaterial = true;
-			refreshLights = true;
+					needsProgramChange = true;
 
-		}
+				} else if ( materialProperties.morphColors !== morphColors ) {
 
-		if ( material.id !== _currentMaterialId ) {
+					needsProgramChange = true;
 
-			_currentMaterialId = material.id;
+				} else if ( materialProperties.toneMapping !== toneMapping ) {
 
-			refreshMaterial = true;
+					needsProgramChange = true;
 
-		}
+				} else if ( capabilities.isWebGL2 === true && materialProperties.morphTargetsCount !== morphTargetsCount ) {
 
-		if ( refreshProgram || _currentCamera !== camera ) {
+					needsProgramChange = true;
 
-			p_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix );
+				}
 
-			if ( capabilities.logarithmicDepthBuffer ) {
+			} else {
 
-				p_uniforms.setValue( _gl, 'logDepthBufFC',
-					2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
+				needsProgramChange = true;
+				materialProperties.__version = material.version;
 
 			}
 
-			if ( _currentCamera !== camera ) {
+			//
 
-				_currentCamera = camera;
+			let program = materialProperties.currentProgram;
 
-				// lighting uniforms depend on the camera so enforce an update
-				// now, in case this material supports lights - or later, when
-				// the next material that does gets activated:
+			if ( needsProgramChange === true ) {
 
-				refreshMaterial = true;		// set to true on material change
-				refreshLights = true;		// remains set until update done
+				program = getProgram( material, scene, object );
 
 			}
 
-			// load material specific uniforms
-			// (shader material also gets them for the sake of genericity)
+			let refreshProgram = false;
+			let refreshMaterial = false;
+			let refreshLights = false;
 
-			if ( material.isShaderMaterial ||
-				material.isMeshPhongMaterial ||
-				material.isMeshToonMaterial ||
-				material.isMeshStandardMaterial ||
-				material.envMap ) {
+			const p_uniforms = program.getUniforms(),
+				m_uniforms = materialProperties.uniforms;
 
-				const uCamPos = p_uniforms.map.cameraPosition;
+			if ( state.useProgram( program.program ) ) {
 
-				if ( uCamPos !== undefined ) {
+				refreshProgram = true;
+				refreshMaterial = true;
+				refreshLights = true;
 
-					uCamPos.setValue( _gl,
-						_vector3.setFromMatrixPosition( camera.matrixWorld ) );
+			}
 
-				}
+			if ( material.id !== _currentMaterialId ) {
+
+				_currentMaterialId = material.id;
+
+				refreshMaterial = true;
 
 			}
 
-			if ( material.isMeshPhongMaterial ||
-				material.isMeshToonMaterial ||
-				material.isMeshLambertMaterial ||
-				material.isMeshBasicMaterial ||
-				material.isMeshStandardMaterial ||
-				material.isShaderMaterial ) {
+			if ( refreshProgram || _currentCamera !== camera ) {
 
-				p_uniforms.setValue( _gl, 'isOrthographic', camera.isOrthographicCamera === true );
+				p_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix );
 
-			}
+				if ( capabilities.logarithmicDepthBuffer ) {
 
-			if ( material.isMeshPhongMaterial ||
-				material.isMeshToonMaterial ||
-				material.isMeshLambertMaterial ||
-				material.isMeshBasicMaterial ||
-				material.isMeshStandardMaterial ||
-				material.isShaderMaterial ||
-				material.isShadowMaterial ||
-				object.isSkinnedMesh ) {
+					p_uniforms.setValue( _gl, 'logDepthBufFC',
+						2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
 
-				p_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );
+				}
 
-			}
+				if ( _currentCamera !== camera ) {
 
-		}
+					_currentCamera = camera;
 
-		// skinning and morph target uniforms must be set even if material didn't change
-		// auto-setting of texture unit for bone and morph texture must go before other textures
-		// otherwise textures used for skinning and morphing can take over texture units reserved for other material textures
+					// lighting uniforms depend on the camera so enforce an update
+					// now, in case this material supports lights - or later, when
+					// the next material that does gets activated:
 
-		if ( object.isSkinnedMesh ) {
+					refreshMaterial = true;		// set to true on material change
+					refreshLights = true;		// remains set until update done
 
-			p_uniforms.setOptional( _gl, object, 'bindMatrix' );
-			p_uniforms.setOptional( _gl, object, 'bindMatrixInverse' );
+				}
 
-			const skeleton = object.skeleton;
+				// load material specific uniforms
+				// (shader material also gets them for the sake of genericity)
 
-			if ( skeleton ) {
+				if ( material.isShaderMaterial ||
+					material.isMeshPhongMaterial ||
+					material.isMeshToonMaterial ||
+					material.isMeshStandardMaterial ||
+					material.envMap ) {
 
-				if ( capabilities.floatVertexTextures ) {
+					const uCamPos = p_uniforms.map.cameraPosition;
 
-					if ( skeleton.boneTexture === null ) skeleton.computeBoneTexture();
+					if ( uCamPos !== undefined ) {
 
-					p_uniforms.setValue( _gl, 'boneTexture', skeleton.boneTexture, textures );
-					p_uniforms.setValue( _gl, 'boneTextureSize', skeleton.boneTextureSize );
+						uCamPos.setValue( _gl,
+							_vector3.setFromMatrixPosition( camera.matrixWorld ) );
 
-				} else {
+					}
+
+				}
+
+				if ( material.isMeshPhongMaterial ||
+					material.isMeshToonMaterial ||
+					material.isMeshLambertMaterial ||
+					material.isMeshBasicMaterial ||
+					material.isMeshStandardMaterial ||
+					material.isShaderMaterial ) {
+
+					p_uniforms.setValue( _gl, 'isOrthographic', camera.isOrthographicCamera === true );
+
+				}
 
-					console.warn( 'THREE.WebGLRenderer: SkinnedMesh can only be used with WebGL 2. With WebGL 1 OES_texture_float and vertex textures support is required.' );
+				if ( material.isMeshPhongMaterial ||
+					material.isMeshToonMaterial ||
+					material.isMeshLambertMaterial ||
+					material.isMeshBasicMaterial ||
+					material.isMeshStandardMaterial ||
+					material.isShaderMaterial ||
+					material.isShadowMaterial ||
+					object.isSkinnedMesh ) {
+
+					p_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );
 
 				}
 
 			}
 
-		}
+			// skinning and morph target uniforms must be set even if material didn't change
+			// auto-setting of texture unit for bone and morph texture must go before other textures
+			// otherwise textures used for skinning and morphing can take over texture units reserved for other material textures
 
-		const morphAttributes = geometry.morphAttributes;
+			if ( object.isSkinnedMesh ) {
 
-		if ( morphAttributes.position !== undefined || morphAttributes.normal !== undefined || ( morphAttributes.color !== undefined && capabilities.isWebGL2 === true ) ) {
+				p_uniforms.setOptional( _gl, object, 'bindMatrix' );
+				p_uniforms.setOptional( _gl, object, 'bindMatrixInverse' );
 
-			morphtargets.update( object, geometry, material, program );
+				const skeleton = object.skeleton;
 
-		}
+				if ( skeleton ) {
 
-		if ( refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow ) {
+					if ( capabilities.floatVertexTextures ) {
 
-			materialProperties.receiveShadow = object.receiveShadow;
-			p_uniforms.setValue( _gl, 'receiveShadow', object.receiveShadow );
+						if ( skeleton.boneTexture === null ) skeleton.computeBoneTexture();
 
-		}
+						p_uniforms.setValue( _gl, 'boneTexture', skeleton.boneTexture, textures );
+						p_uniforms.setValue( _gl, 'boneTextureSize', skeleton.boneTextureSize );
 
-		// https://github.com/mrdoob/three.js/pull/24467#issuecomment-1209031512
+					} else {
 
-		if ( material.isMeshGouraudMaterial && material.envMap !== null ) {
+						console.warn( 'THREE.WebGLRenderer: SkinnedMesh can only be used with WebGL 2. With WebGL 1 OES_texture_float and vertex textures support is required.' );
 
-			m_uniforms.envMap.value = envMap;
+					}
 
-			m_uniforms.flipEnvMap.value = ( envMap.isCubeTexture && envMap.isRenderTargetTexture === false ) ? - 1 : 1;
+				}
 
-		}
+			}
 
-		if ( refreshMaterial ) {
+			const morphAttributes = geometry.morphAttributes;
 
-			p_uniforms.setValue( _gl, 'toneMappingExposure', _this.toneMappingExposure );
+			if ( morphAttributes.position !== undefined || morphAttributes.normal !== undefined || ( morphAttributes.color !== undefined && capabilities.isWebGL2 === true ) ) {
 
-			if ( materialProperties.needsLights ) {
+				morphtargets.update( object, geometry, program );
 
-				// the current material requires lighting info
+			}
 
-				// note: all lighting uniforms are always set correctly
-				// they simply reference the renderer's state for their
-				// values
-				//
-				// use the current material's .needsUpdate flags to set
-				// the GL state when required
+			if ( refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow ) {
 
-				markUniformsLightsNeedsUpdate( m_uniforms, refreshLights );
+				materialProperties.receiveShadow = object.receiveShadow;
+				p_uniforms.setValue( _gl, 'receiveShadow', object.receiveShadow );
 
 			}
 
-			// refresh uniforms common to several materials
+			// https://github.com/mrdoob/three.js/pull/24467#issuecomment-1209031512
+
+			if ( material.isMeshGouraudMaterial && material.envMap !== null ) {
 
-			if ( fog && material.fog === true ) {
+				m_uniforms.envMap.value = envMap;
 
-				materials.refreshFogUniforms( m_uniforms, fog );
+				m_uniforms.flipEnvMap.value = ( envMap.isCubeTexture && envMap.isRenderTargetTexture === false ) ? - 1 : 1;
 
 			}
 
-			materials.refreshMaterialUniforms( m_uniforms, material, _pixelRatio, _height, _transmissionRenderTarget );
+			if ( refreshMaterial ) {
 
-			WebGLUniforms.upload( _gl, materialProperties.uniformsList, m_uniforms, textures );
+				p_uniforms.setValue( _gl, 'toneMappingExposure', _this.toneMappingExposure );
 
-		}
+				if ( materialProperties.needsLights ) {
 
-		if ( material.isShaderMaterial && material.uniformsNeedUpdate === true ) {
+					// the current material requires lighting info
 
-			WebGLUniforms.upload( _gl, materialProperties.uniformsList, m_uniforms, textures );
-			material.uniformsNeedUpdate = false;
+					// note: all lighting uniforms are always set correctly
+					// they simply reference the renderer's state for their
+					// values
+					//
+					// use the current material's .needsUpdate flags to set
+					// the GL state when required
 
-		}
+					markUniformsLightsNeedsUpdate( m_uniforms, refreshLights );
+
+				}
 
-		if ( material.isSpriteMaterial ) {
+				// refresh uniforms common to several materials
 
-			p_uniforms.setValue( _gl, 'center', object.center );
+				if ( fog && material.fog === true ) {
 
-		}
+					materials.refreshFogUniforms( m_uniforms, fog );
 
-		// common matrices
+				}
 
-		p_uniforms.setValue( _gl, 'modelViewMatrix', object.modelViewMatrix );
-		p_uniforms.setValue( _gl, 'normalMatrix', object.normalMatrix );
-		p_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld );
+				materials.refreshMaterialUniforms( m_uniforms, material, _pixelRatio, _height, _transmissionRenderTarget );
 
-		// UBOs
+				WebGLUniforms.upload( _gl, materialProperties.uniformsList, m_uniforms, textures );
 
-		if ( material.isShaderMaterial || material.isRawShaderMaterial ) {
+			}
 
-			const groups = material.uniformsGroups;
+			if ( material.isShaderMaterial && material.uniformsNeedUpdate === true ) {
 
-			for ( let i = 0, l = groups.length; i < l; i ++ ) {
+				WebGLUniforms.upload( _gl, materialProperties.uniformsList, m_uniforms, textures );
+				material.uniformsNeedUpdate = false;
 
-				if ( capabilities.isWebGL2 ) {
+			}
 
-					const group = groups[ i ];
+			if ( material.isSpriteMaterial ) {
 
-					uniformsGroups.update( group, program );
-					uniformsGroups.bind( group, program );
+				p_uniforms.setValue( _gl, 'center', object.center );
 
-				} else {
+			}
 
-					console.warn( 'THREE.WebGLRenderer: Uniform Buffer Objects can only be used with WebGL 2.' );
+			// common matrices
+
+			p_uniforms.setValue( _gl, 'modelViewMatrix', object.modelViewMatrix );
+			p_uniforms.setValue( _gl, 'normalMatrix', object.normalMatrix );
+			p_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld );
+
+			// UBOs
+
+			if ( material.isShaderMaterial || material.isRawShaderMaterial ) {
+
+				const groups = material.uniformsGroups;
+
+				for ( let i = 0, l = groups.length; i < l; i ++ ) {
+
+					if ( capabilities.isWebGL2 ) {
+
+						const group = groups[ i ];
+
+						uniformsGroups.update( group, program );
+						uniformsGroups.bind( group, program );
+
+					} else {
+
+						console.warn( 'THREE.WebGLRenderer: Uniform Buffer Objects can only be used with WebGL 2.' );
+
+					}
 
 				}
 
 			}
 
+			return program;
+
 		}
 
-		return program;
+		// If uniforms are marked as clean, they don't need to be loaded to the GPU.
 
-	}
+		function markUniformsLightsNeedsUpdate( uniforms, value ) {
 
-	// If uniforms are marked as clean, they don't need to be loaded to the GPU.
+			uniforms.ambientLightColor.needsUpdate = value;
+			uniforms.lightProbe.needsUpdate = value;
 
-	function markUniformsLightsNeedsUpdate( uniforms, value ) {
+			uniforms.directionalLights.needsUpdate = value;
+			uniforms.directionalLightShadows.needsUpdate = value;
+			uniforms.pointLights.needsUpdate = value;
+			uniforms.pointLightShadows.needsUpdate = value;
+			uniforms.spotLights.needsUpdate = value;
+			uniforms.spotLightShadows.needsUpdate = value;
+			uniforms.rectAreaLights.needsUpdate = value;
+			uniforms.hemisphereLights.needsUpdate = value;
 
-		uniforms.ambientLightColor.needsUpdate = value;
-		uniforms.lightProbe.needsUpdate = value;
+		}
 
-		uniforms.directionalLights.needsUpdate = value;
-		uniforms.directionalLightShadows.needsUpdate = value;
-		uniforms.pointLights.needsUpdate = value;
-		uniforms.pointLightShadows.needsUpdate = value;
-		uniforms.spotLights.needsUpdate = value;
-		uniforms.spotLightShadows.needsUpdate = value;
-		uniforms.rectAreaLights.needsUpdate = value;
-		uniforms.hemisphereLights.needsUpdate = value;
+		function materialNeedsLights( material ) {
 
-	}
+			return material.isMeshLambertMaterial || material.isMeshToonMaterial || material.isMeshPhongMaterial ||
+				material.isMeshStandardMaterial || material.isShadowMaterial ||
+				( material.isShaderMaterial && material.lights === true );
 
-	function materialNeedsLights( material ) {
+		}
 
-		return material.isMeshLambertMaterial || material.isMeshToonMaterial || material.isMeshPhongMaterial ||
-			material.isMeshStandardMaterial || material.isShadowMaterial ||
-			( material.isShaderMaterial && material.lights === true );
+		this.setTexture2D = ( function () {
 
-	}
+			var warned = false;
 
-	this.setTexture2D = ( function () {
+			// backwards compatibility: peel texture.texture
+			return function setTexture2D( texture, slot ) {
 
-		var warned = false;
+				if ( texture && texture.isWebGLRenderTarget ) {
 
-		// backwards compatibility: peel texture.texture
-		return function setTexture2D( texture, slot ) {
+					if ( ! warned ) {
 
-			if ( texture && texture.isWebGLRenderTarget ) {
+						console.warn( "THREE.WebGLRenderer.setTexture2D: don't use render targets as textures. Use their .texture property instead." );
+						warned = true;
 
-				if ( ! warned ) {
+					}
 
-					console.warn( "THREE.WebGLRenderer.setTexture2D: don't use render targets as textures. Use their .texture property instead." );
-					warned = true;
+					texture = texture.texture;
 
 				}
 
-				texture = texture.texture;
-
-			}
+				textures.setTexture2D( texture, slot );
 
-			textures.setTexture2D( texture, slot );
+			};
 
-		};
+		}() );
 
-	}() );
+		this.getActiveCubeFace = function () {
 
-	this.getActiveCubeFace = function () {
+			return _currentActiveCubeFace;
 
-		return _currentActiveCubeFace;
+		};
 
-	};
+		this.getActiveMipmapLevel = function () {
 
-	this.getActiveMipmapLevel = function () {
+			return _currentActiveMipmapLevel;
 
-		return _currentActiveMipmapLevel;
+		};
 
-	};
+		this.getRenderTarget = function () {
 
-	this.getRenderTarget = function () {
+			return _currentRenderTarget;
 
-		return _currentRenderTarget;
+		};
 
-	};
+		this.setRenderTargetTextures = function ( renderTarget, colorTexture, depthTexture ) {
 
-	this.setRenderTargetTextures = function ( renderTarget, colorTexture, depthTexture ) {
+			properties.get( renderTarget.texture ).__webglTexture = colorTexture;
+			properties.get( renderTarget.depthTexture ).__webglTexture = depthTexture;
 
-		properties.get( renderTarget.texture ).__webglTexture = colorTexture;
-		properties.get( renderTarget.depthTexture ).__webglTexture = depthTexture;
+			const renderTargetProperties = properties.get( renderTarget );
+			renderTargetProperties.__hasExternalTextures = true;
 
-		const renderTargetProperties = properties.get( renderTarget );
-		renderTargetProperties.__hasExternalTextures = true;
+			if ( renderTargetProperties.__hasExternalTextures ) {
 
-		if ( renderTargetProperties.__hasExternalTextures ) {
+				renderTargetProperties.__autoAllocateDepthBuffer = depthTexture === undefined;
 
-			renderTargetProperties.__autoAllocateDepthBuffer = depthTexture === undefined;
+				if ( ! renderTargetProperties.__autoAllocateDepthBuffer ) {
 
-			if ( ! renderTargetProperties.__autoAllocateDepthBuffer ) {
+					// The multisample_render_to_texture extension doesn't work properly if there
+					// are midframe flushes and an external depth buffer. Disable use of the extension.
+					if ( extensions.has( 'WEBGL_multisampled_render_to_texture' ) === true ) {
 
-				// The multisample_render_to_texture extension doesn't work properly if there
-				// are midframe flushes and an external depth buffer. Disable use of the extension.
-				if ( extensions.has( 'WEBGL_multisampled_render_to_texture' ) === true ) {
+						console.warn( 'THREE.WebGLRenderer: Render-to-texture extension was disabled because an external texture was provided' );
+						renderTargetProperties.__useRenderToTexture = false;
 
-					console.warn( 'THREE.WebGLRenderer: Render-to-texture extension was disabled because an external texture was provided' );
-					renderTargetProperties.__useRenderToTexture = false;
+					}
 
 				}
 
 			}
 
-		}
+		};
 
-	};
+		this.setRenderTargetFramebuffer = function ( renderTarget, defaultFramebuffer ) {
 
-	this.setRenderTargetFramebuffer = function ( renderTarget, defaultFramebuffer ) {
+			const renderTargetProperties = properties.get( renderTarget );
+			renderTargetProperties.__webglFramebuffer = defaultFramebuffer;
+			renderTargetProperties.__useDefaultFramebuffer = defaultFramebuffer === undefined;
 
-		const renderTargetProperties = properties.get( renderTarget );
-		renderTargetProperties.__webglFramebuffer = defaultFramebuffer;
-		renderTargetProperties.__useDefaultFramebuffer = defaultFramebuffer === undefined;
+		};
 
-	};
+		this.setRenderTarget = function ( renderTarget, activeCubeFace = 0, activeMipmapLevel = 0 ) {
 
-	this.setRenderTarget = function ( renderTarget, activeCubeFace = 0, activeMipmapLevel = 0 ) {
+			_currentRenderTarget = renderTarget;
+			_currentActiveCubeFace = activeCubeFace;
+			_currentActiveMipmapLevel = activeMipmapLevel;
 
-		_currentRenderTarget = renderTarget;
-		_currentActiveCubeFace = activeCubeFace;
-		_currentActiveMipmapLevel = activeMipmapLevel;
+			let useDefaultFramebuffer = true;
+			let framebuffer = null;
+			let isCube = false;
+			let isRenderTarget3D = false;
 
-		let useDefaultFramebuffer = true;
-		let framebuffer = null;
-		let isCube = false;
-		let isRenderTarget3D = false;
+			if ( renderTarget ) {
 
-		if ( renderTarget ) {
+				const renderTargetProperties = properties.get( renderTarget );
 
-			const renderTargetProperties = properties.get( renderTarget );
+				if ( renderTargetProperties.__useDefaultFramebuffer !== undefined ) {
 
-			if ( renderTargetProperties.__useDefaultFramebuffer !== undefined ) {
+					// We need to make sure to rebind the framebuffer.
+					state.bindFramebuffer( _gl.FRAMEBUFFER, null );
+					useDefaultFramebuffer = false;
 
-				// We need to make sure to rebind the framebuffer.
-				state.bindFramebuffer( _gl.FRAMEBUFFER, null );
-				useDefaultFramebuffer = false;
+				} else if ( renderTargetProperties.__webglFramebuffer === undefined ) {
 
-			} else if ( renderTargetProperties.__webglFramebuffer === undefined ) {
+					textures.setupRenderTarget( renderTarget );
 
-				textures.setupRenderTarget( renderTarget );
+				} else if ( renderTargetProperties.__hasExternalTextures ) {
 
-			} else if ( renderTargetProperties.__hasExternalTextures ) {
+					// Color and depth texture must be rebound in order for the swapchain to update.
+					textures.rebindTextures( renderTarget, properties.get( renderTarget.texture ).__webglTexture, properties.get( renderTarget.depthTexture ).__webglTexture );
 
-				// Color and depth texture must be rebound in order for the swapchain to update.
-				textures.rebindTextures( renderTarget, properties.get( renderTarget.texture ).__webglTexture, properties.get( renderTarget.depthTexture ).__webglTexture );
+				}
 
-			}
+				const texture = renderTarget.texture;
+
+				if ( texture.isData3DTexture || texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
 
-			const texture = renderTarget.texture;
+					isRenderTarget3D = true;
 
-			if ( texture.isData3DTexture || texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
+				}
 
-				isRenderTarget3D = true;
+				const __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer;
 
-			}
+				if ( renderTarget.isWebGLCubeRenderTarget ) {
 
-			const __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer;
+					framebuffer = __webglFramebuffer[ activeCubeFace ];
+					isCube = true;
 
-			if ( renderTarget.isWebGLCubeRenderTarget ) {
+				} else if ( ( capabilities.isWebGL2 && renderTarget.samples > 0 ) && textures.useMultisampledRTT( renderTarget ) === false ) {
+
+					framebuffer = properties.get( renderTarget ).__webglMultisampledFramebuffer;
+
+				} else {
 
-				framebuffer = __webglFramebuffer[ activeCubeFace ];
-				isCube = true;
+					framebuffer = __webglFramebuffer;
 
-			} else if ( ( capabilities.isWebGL2 && renderTarget.samples > 0 ) && textures.useMultisampledRTT( renderTarget ) === false ) {
+				}
 
-				framebuffer = properties.get( renderTarget ).__webglMultisampledFramebuffer;
+				_currentViewport.copy( renderTarget.viewport );
+				_currentScissor.copy( renderTarget.scissor );
+				_currentScissorTest = renderTarget.scissorTest;
 
 			} else {
 
-				framebuffer = __webglFramebuffer;
+				_currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor();
+				_currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor();
+				_currentScissorTest = _scissorTest;
 
 			}
 
-			_currentViewport.copy( renderTarget.viewport );
-			_currentScissor.copy( renderTarget.scissor );
-			_currentScissorTest = renderTarget.scissorTest;
+			const framebufferBound = state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
 
-		} else {
+			if ( framebufferBound && capabilities.drawBuffers && useDefaultFramebuffer ) {
 
-			_currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor();
-			_currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor();
-			_currentScissorTest = _scissorTest;
+				state.drawBuffers( renderTarget, framebuffer );
 
-		}
+			}
 
-		const framebufferBound = state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+			state.viewport( _currentViewport );
+			state.scissor( _currentScissor );
+			state.setScissorTest( _currentScissorTest );
 
-		if ( framebufferBound && capabilities.drawBuffers && useDefaultFramebuffer ) {
+			if ( isCube ) {
 
-			state.drawBuffers( renderTarget, framebuffer );
+				const textureProperties = properties.get( renderTarget.texture );
+				_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + activeCubeFace, textureProperties.__webglTexture, activeMipmapLevel );
 
-		}
+			} else if ( isRenderTarget3D ) {
+
+				const textureProperties = properties.get( renderTarget.texture );
+				const layer = activeCubeFace || 0;
+				_gl.framebufferTextureLayer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, textureProperties.__webglTexture, activeMipmapLevel || 0, layer );
 
-		state.viewport( _currentViewport );
-		state.scissor( _currentScissor );
-		state.setScissorTest( _currentScissorTest );
+			}
 
-		if ( isCube ) {
+			_currentMaterialId = - 1; // reset current material to ensure correct uniform bindings
 
-			const textureProperties = properties.get( renderTarget.texture );
-			_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + activeCubeFace, textureProperties.__webglTexture, activeMipmapLevel );
+		};
 
-		} else if ( isRenderTarget3D ) {
+		this.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer, activeCubeFaceIndex ) {
 
-			const textureProperties = properties.get( renderTarget.texture );
-			const layer = activeCubeFace || 0;
-			_gl.framebufferTextureLayer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, textureProperties.__webglTexture, activeMipmapLevel || 0, layer );
+			if ( ! ( renderTarget && renderTarget.isWebGLRenderTarget ) ) {
 
-		}
+				console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' );
+				return;
 
-		_currentMaterialId = - 1; // reset current material to ensure correct uniform bindings
+			}
 
-	};
+			let framebuffer = properties.get( renderTarget ).__webglFramebuffer;
 
-	this.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer, activeCubeFaceIndex ) {
+			if ( renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined ) {
 
-		if ( ! ( renderTarget && renderTarget.isWebGLRenderTarget ) ) {
+				framebuffer = framebuffer[ activeCubeFaceIndex ];
 
-			console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' );
-			return;
+			}
 
-		}
+			if ( framebuffer ) {
 
-		let framebuffer = properties.get( renderTarget ).__webglFramebuffer;
+				state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
 
-		if ( renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined ) {
+				try {
 
-			framebuffer = framebuffer[ activeCubeFaceIndex ];
+					const texture = renderTarget.texture;
+					const textureFormat = texture.format;
+					const textureType = texture.type;
 
-		}
+					if ( textureFormat !== RGBAFormat && utils.convert( textureFormat ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_FORMAT ) ) {
 
-		if ( framebuffer ) {
+						console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' );
+						return;
 
-			state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+					}
 
-			try {
+					const halfFloatSupportedByExt = ( textureType === HalfFloatType ) && ( extensions.has( 'EXT_color_buffer_half_float' ) || ( capabilities.isWebGL2 && extensions.has( 'EXT_color_buffer_float' ) ) );
 
-				const texture = renderTarget.texture;
-				const textureFormat = texture.format;
-				const textureType = texture.type;
+					if ( textureType !== UnsignedByteType && utils.convert( textureType ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_TYPE ) && // Edge and Chrome Mac < 52 (#9513)
+						! ( textureType === FloatType && ( capabilities.isWebGL2 || extensions.has( 'OES_texture_float' ) || extensions.has( 'WEBGL_color_buffer_float' ) ) ) && // Chrome Mac >= 52 and Firefox
+						! halfFloatSupportedByExt ) {
 
-				if ( textureFormat !== RGBAFormat && utils.convert( textureFormat ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_FORMAT ) ) {
+						console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.' );
+						return;
 
-					console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' );
-					return;
+					}
 
-				}
+					// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
+
+					if ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) {
+
+						_gl.readPixels( x, y, width, height, utils.convert( textureFormat ), utils.convert( textureType ), buffer );
+
+					}
 
-				const halfFloatSupportedByExt = ( textureType === HalfFloatType ) && ( extensions.has( 'EXT_color_buffer_half_float' ) || ( capabilities.isWebGL2 && extensions.has( 'EXT_color_buffer_float' ) ) );
+				} finally {
 
-				if ( textureType !== UnsignedByteType && utils.convert( textureType ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_TYPE ) && // Edge and Chrome Mac < 52 (#9513)
-					! ( textureType === FloatType && ( capabilities.isWebGL2 || extensions.has( 'OES_texture_float' ) || extensions.has( 'WEBGL_color_buffer_float' ) ) ) && // Chrome Mac >= 52 and Firefox
-					! halfFloatSupportedByExt ) {
+					// restore framebuffer of current render target if necessary
 
-					console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.' );
-					return;
+					const framebuffer = ( _currentRenderTarget !== null ) ? properties.get( _currentRenderTarget ).__webglFramebuffer : null;
+					state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
 
 				}
 
-				// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
+			}
 
-				if ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) {
+		};
 
-					_gl.readPixels( x, y, width, height, utils.convert( textureFormat ), utils.convert( textureType ), buffer );
+		this.copyFramebufferToTexture = function ( position, texture, level = 0 ) {
 
-				}
+			const levelScale = Math.pow( 2, - level );
+			const width = Math.floor( texture.image.width * levelScale );
+			const height = Math.floor( texture.image.height * levelScale );
 
-			} finally {
+			textures.setTexture2D( texture, 0 );
 
-				// restore framebuffer of current render target if necessary
+			_gl.copyTexSubImage2D( _gl.TEXTURE_2D, level, 0, 0, position.x, position.y, width, height );
 
-				const framebuffer = ( _currentRenderTarget !== null ) ? properties.get( _currentRenderTarget ).__webglFramebuffer : null;
-				state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+			state.unbindTexture();
 
-			}
+		};
 
-		}
+		this.copyTextureToTexture = function ( position, srcTexture, dstTexture, level = 0 ) {
 
-	};
+			const width = srcTexture.image.width;
+			const height = srcTexture.image.height;
+			const glFormat = utils.convert( dstTexture.format );
+			const glType = utils.convert( dstTexture.type );
 
-	this.copyFramebufferToTexture = function ( position, texture, level = 0 ) {
+			textures.setTexture2D( dstTexture, 0 );
 
-		const levelScale = Math.pow( 2, - level );
-		const width = Math.floor( texture.image.width * levelScale );
-		const height = Math.floor( texture.image.height * levelScale );
+			// As another texture upload may have changed pixelStorei
+			// parameters, make sure they are correct for the dstTexture
+			_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY );
+			_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha );
+			_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment );
 
-		textures.setTexture2D( texture, 0 );
+			if ( srcTexture.isDataTexture ) {
 
-		_gl.copyTexSubImage2D( _gl.TEXTURE_2D, level, 0, 0, position.x, position.y, width, height );
+				_gl.texSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, width, height, glFormat, glType, srcTexture.image.data );
 
-		state.unbindTexture();
+			} else {
 
-	};
+				if ( srcTexture.isCompressedTexture ) {
 
-	this.copyTextureToTexture = function ( position, srcTexture, dstTexture, level = 0 ) {
+					_gl.compressedTexSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, srcTexture.mipmaps[ 0 ].width, srcTexture.mipmaps[ 0 ].height, glFormat, srcTexture.mipmaps[ 0 ].data );
 
-		const width = srcTexture.image.width;
-		const height = srcTexture.image.height;
-		const glFormat = utils.convert( dstTexture.format );
-		const glType = utils.convert( dstTexture.type );
+				} else {
 
-		textures.setTexture2D( dstTexture, 0 );
+					_gl.texSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, glFormat, glType, srcTexture.image );
 
-		// As another texture upload may have changed pixelStorei
-		// parameters, make sure they are correct for the dstTexture
-		_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY );
-		_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha );
-		_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment );
+				}
 
-		if ( srcTexture.isDataTexture ) {
+			}
 
-			_gl.texSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, width, height, glFormat, glType, srcTexture.image.data );
+			// Generate mipmaps only when copying level 0
+			if ( level === 0 && dstTexture.generateMipmaps ) _gl.generateMipmap( _gl.TEXTURE_2D );
 
-		} else {
+			state.unbindTexture();
 
-			if ( srcTexture.isCompressedTexture ) {
+		};
 
-				_gl.compressedTexSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, srcTexture.mipmaps[ 0 ].width, srcTexture.mipmaps[ 0 ].height, glFormat, srcTexture.mipmaps[ 0 ].data );
+		this.copyTextureToTexture3D = function ( sourceBox, position, srcTexture, dstTexture, level = 0 ) {
 
-			} else {
+			if ( _this.isWebGL1Renderer ) {
 
-				_gl.texSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, glFormat, glType, srcTexture.image );
+				console.warn( 'THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.' );
+				return;
 
 			}
 
-		}
+			const width = sourceBox.max.x - sourceBox.min.x + 1;
+			const height = sourceBox.max.y - sourceBox.min.y + 1;
+			const depth = sourceBox.max.z - sourceBox.min.z + 1;
+			const glFormat = utils.convert( dstTexture.format );
+			const glType = utils.convert( dstTexture.type );
+			let glTarget;
 
-		// Generate mipmaps only when copying level 0
-		if ( level === 0 && dstTexture.generateMipmaps ) _gl.generateMipmap( _gl.TEXTURE_2D );
+			if ( dstTexture.isData3DTexture ) {
 
-		state.unbindTexture();
+				textures.setTexture3D( dstTexture, 0 );
+				glTarget = _gl.TEXTURE_3D;
 
-	};
+			} else if ( dstTexture.isDataArrayTexture ) {
 
-	this.copyTextureToTexture3D = function ( sourceBox, position, srcTexture, dstTexture, level = 0 ) {
+				textures.setTexture2DArray( dstTexture, 0 );
+				glTarget = _gl.TEXTURE_2D_ARRAY;
 
-		if ( _this.isWebGL1Renderer ) {
+			} else {
 
-			console.warn( 'THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.' );
-			return;
+				console.warn( 'THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.' );
+				return;
 
-		}
+			}
 
-		const width = sourceBox.max.x - sourceBox.min.x + 1;
-		const height = sourceBox.max.y - sourceBox.min.y + 1;
-		const depth = sourceBox.max.z - sourceBox.min.z + 1;
-		const glFormat = utils.convert( dstTexture.format );
-		const glType = utils.convert( dstTexture.type );
-		let glTarget;
+			_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY );
+			_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha );
+			_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment );
 
-		if ( dstTexture.isData3DTexture ) {
+			const unpackRowLen = _gl.getParameter( _gl.UNPACK_ROW_LENGTH );
+			const unpackImageHeight = _gl.getParameter( _gl.UNPACK_IMAGE_HEIGHT );
+			const unpackSkipPixels = _gl.getParameter( _gl.UNPACK_SKIP_PIXELS );
+			const unpackSkipRows = _gl.getParameter( _gl.UNPACK_SKIP_ROWS );
+			const unpackSkipImages = _gl.getParameter( _gl.UNPACK_SKIP_IMAGES );
 
-			textures.setTexture3D( dstTexture, 0 );
-			glTarget = _gl.TEXTURE_3D;
+			const image = srcTexture.isCompressedTexture ? srcTexture.mipmaps[ 0 ] : srcTexture.image;
 
-		} else if ( dstTexture.isDataArrayTexture ) {
+			_gl.pixelStorei( _gl.UNPACK_ROW_LENGTH, image.width );
+			_gl.pixelStorei( _gl.UNPACK_IMAGE_HEIGHT, image.height );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_PIXELS, sourceBox.min.x );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_ROWS, sourceBox.min.y );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_IMAGES, sourceBox.min.z );
 
-			textures.setTexture2DArray( dstTexture, 0 );
-			glTarget = _gl.TEXTURE_2D_ARRAY;
+			if ( srcTexture.isDataTexture || srcTexture.isData3DTexture ) {
 
-		} else {
+				_gl.texSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, glType, image.data );
 
-			console.warn( 'THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.' );
-			return;
+			} else {
 
-		}
+				if ( srcTexture.isCompressedArrayTexture ) {
 
-		_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY );
-		_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha );
-		_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment );
+					console.warn( 'THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture.' );
+					_gl.compressedTexSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, image.data );
 
-		const unpackRowLen = _gl.getParameter( _gl.UNPACK_ROW_LENGTH );
-		const unpackImageHeight = _gl.getParameter( _gl.UNPACK_IMAGE_HEIGHT );
-		const unpackSkipPixels = _gl.getParameter( _gl.UNPACK_SKIP_PIXELS );
-		const unpackSkipRows = _gl.getParameter( _gl.UNPACK_SKIP_ROWS );
-		const unpackSkipImages = _gl.getParameter( _gl.UNPACK_SKIP_IMAGES );
+				} else {
 
-		const image = srcTexture.isCompressedTexture ? srcTexture.mipmaps[ 0 ] : srcTexture.image;
+					_gl.texSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, glType, image );
 
-		_gl.pixelStorei( _gl.UNPACK_ROW_LENGTH, image.width );
-		_gl.pixelStorei( _gl.UNPACK_IMAGE_HEIGHT, image.height );
-		_gl.pixelStorei( _gl.UNPACK_SKIP_PIXELS, sourceBox.min.x );
-		_gl.pixelStorei( _gl.UNPACK_SKIP_ROWS, sourceBox.min.y );
-		_gl.pixelStorei( _gl.UNPACK_SKIP_IMAGES, sourceBox.min.z );
+				}
 
-		if ( srcTexture.isDataTexture || srcTexture.isData3DTexture ) {
+			}
 
-			_gl.texSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, glType, image.data );
+			_gl.pixelStorei( _gl.UNPACK_ROW_LENGTH, unpackRowLen );
+			_gl.pixelStorei( _gl.UNPACK_IMAGE_HEIGHT, unpackImageHeight );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_PIXELS, unpackSkipPixels );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_ROWS, unpackSkipRows );
+			_gl.pixelStorei( _gl.UNPACK_SKIP_IMAGES, unpackSkipImages );
 
-		} else {
+			// Generate mipmaps only when copying level 0
+			if ( level === 0 && dstTexture.generateMipmaps ) _gl.generateMipmap( glTarget );
+
+			state.unbindTexture();
+
+		};
+
+		this.initTexture = function ( texture ) {
+
+			if ( texture.isCubeTexture ) {
+
+				textures.setTextureCube( texture, 0 );
+
+			} else if ( texture.isData3DTexture ) {
+
+				textures.setTexture3D( texture, 0 );
 
-			if ( srcTexture.isCompressedArrayTexture ) {
+			} else if ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
 
-				console.warn( 'THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture.' );
-				_gl.compressedTexSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, image.data );
+				textures.setTexture2DArray( texture, 0 );
 
 			} else {
 
-				_gl.texSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, glType, image );
+				textures.setTexture2D( texture, 0 );
 
 			}
 
-		}
+			state.unbindTexture();
 
-		_gl.pixelStorei( _gl.UNPACK_ROW_LENGTH, unpackRowLen );
-		_gl.pixelStorei( _gl.UNPACK_IMAGE_HEIGHT, unpackImageHeight );
-		_gl.pixelStorei( _gl.UNPACK_SKIP_PIXELS, unpackSkipPixels );
-		_gl.pixelStorei( _gl.UNPACK_SKIP_ROWS, unpackSkipRows );
-		_gl.pixelStorei( _gl.UNPACK_SKIP_IMAGES, unpackSkipImages );
+		};
 
-		// Generate mipmaps only when copying level 0
-		if ( level === 0 && dstTexture.generateMipmaps ) _gl.generateMipmap( glTarget );
+		this.resetState = function () {
 
-		state.unbindTexture();
+			_currentActiveCubeFace = 0;
+			_currentActiveMipmapLevel = 0;
+			_currentRenderTarget = null;
 
-	};
+			state.reset();
+			bindingStates.reset();
 
-	this.initTexture = function ( texture ) {
+		};
 
-		if ( texture.isCubeTexture ) {
+		if ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {
 
-			textures.setTextureCube( texture, 0 );
+			__THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'observe', { detail: this } ) );
 
-		} else if ( texture.isData3DTexture ) {
+		}
 
-			textures.setTexture3D( texture, 0 );
+	}
 
-		} else if ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
+	get coordinateSystem() {
 
-			textures.setTexture2DArray( texture, 0 );
+		return WebGLCoordinateSystem;
 
-		} else {
+	}
 
-			textures.setTexture2D( texture, 0 );
+	get physicallyCorrectLights() { // @deprecated, r150
 
-		}
+		console.warn( 'THREE.WebGLRenderer: the property .physicallyCorrectLights has been removed. Set renderer.useLegacyLights instead.' );
+		return ! this.useLegacyLights;
 
-		state.unbindTexture();
+	}
 
-	};
+	set physicallyCorrectLights( value ) { // @deprecated, r150
 
-	this.resetState = function () {
+		console.warn( 'THREE.WebGLRenderer: the property .physicallyCorrectLights has been removed. Set renderer.useLegacyLights instead.' );
+		this.useLegacyLights = ! value;
 
-		_currentActiveCubeFace = 0;
-		_currentActiveMipmapLevel = 0;
-		_currentRenderTarget = null;
+	}
 
-		state.reset();
-		bindingStates.reset();
+	get outputEncoding() { // @deprecated, r152
 
-	};
+		console.warn( 'THREE.WebGLRenderer: Property .outputEncoding has been removed. Use .outputColorSpace instead.' );
+		return this.outputColorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding;
 
-	if ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {
+	}
+
+	set outputEncoding( encoding ) { // @deprecated, r152
 
-		__THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'observe', { detail: this } ) );
+		console.warn( 'THREE.WebGLRenderer: Property .outputEncoding has been removed. Use .outputColorSpace instead.' );
+		this.outputColorSpace = encoding === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;
 
 	}
 
 }
 
+
 export { WebGLRenderer };