From 3b847c4a34eb30915b0973738a36aff8db89efa2 Mon Sep 17 00:00:00 2001
From: mbredif <mathieu.bredif@ign.fr>
Date: Fri, 2 Jul 2021 10:05:52 +0200
Subject: [PATCH] deprecate WebGLMRTs

---
 examples/webgl2_multiple_rendertargets.html |  20 +-
 examples/webgl_depth_texture.html           |  11 +-
 src/cameras/CubeCamera.js                   |  15 +-
 src/renderers/WebGLCubeRenderTarget.js      |  21 +-
 src/renderers/WebGLMultipleRenderTargets.js |  65 +---
 src/renderers/WebGLRenderTarget.js          |  90 ++++-
 src/renderers/WebGLRenderer.js              | 102 +++---
 src/renderers/webgl/WebGLTextures.js        | 358 +++++++++-----------
 src/textures/CubeTexture.js                 |   2 +-
 9 files changed, 333 insertions(+), 351 deletions(-)

diff --git a/examples/webgl2_multiple_rendertargets.html b/examples/webgl2_multiple_rendertargets.html
index 6c63d0301112e6..0ddba366bc7089 100644
--- a/examples/webgl2_multiple_rendertargets.html
+++ b/examples/webgl2_multiple_rendertargets.html
@@ -134,24 +134,24 @@
 
 				// Create a multi render target with Float buffers
 
-				renderTarget = new THREE.WebGLMultipleRenderTargets(
+				renderTarget = new THREE.WebGLRenderTarget(
 					window.innerWidth * window.devicePixelRatio,
 					window.innerHeight * window.devicePixelRatio,
-					2
+					{ count : 2 }
 				);
 
-				for ( let i = 0, il = renderTarget.texture.length; i < il; i ++ ) {
+				for ( let i = 0, il = renderTarget.textures.length; i < il; i ++ ) {
 
-					renderTarget.texture[ i ].minFilter = THREE.NearestFilter;
-					renderTarget.texture[ i ].magFilter = THREE.NearestFilter;
-					renderTarget.texture[ i ].type = THREE.FloatType;
+					renderTarget.textures[ i ].minFilter = THREE.NearestFilter;
+					renderTarget.textures[ i ].magFilter = THREE.NearestFilter;
+					renderTarget.textures[ i ].type = THREE.FloatType;
 
 				}
 
 				// Name our G-Buffer attachments for debugging
 
-				renderTarget.texture[ 0 ].name = 'diffuse';
-				renderTarget.texture[ 1 ].name = 'normal';
+				renderTarget.textures[ 0 ].name = 'diffuse';
+				renderTarget.textures[ 1 ].name = 'normal';
 
 				// Scene setup
 
@@ -199,8 +199,8 @@
 						vertexShader: document.querySelector( '#render-vert' ).textContent.trim(),
 						fragmentShader: document.querySelector( '#render-frag' ).textContent.trim(),
 						uniforms: {
-							tDiffuse: { value: renderTarget.texture[ 0 ] },
-							tNormal: { value: renderTarget.texture[ 1 ] },
+							tDiffuse: { value: renderTarget.textures[ 0 ] },
+							tNormal: { value: renderTarget.textures[ 1 ] },
 						},
 						glslVersion: THREE.GLSL3
 					} )
diff --git a/examples/webgl_depth_texture.html b/examples/webgl_depth_texture.html
index 52905fbc83c16a..b7914c36ccecd3 100644
--- a/examples/webgl_depth_texture.html
+++ b/examples/webgl_depth_texture.html
@@ -27,15 +27,16 @@
 		<script id="post-frag" type="x-shader/x-fragment">
 			#include <packing>
 
+			precision highp sampler2DArray;
 			varying vec2 vUv;
 			uniform sampler2D tDiffuse;
-			uniform sampler2D tDepth;
+			uniform sampler2DArray tDepth;
 			uniform float cameraNear;
 			uniform float cameraFar;
 
 
-			float readDepth( sampler2D depthSampler, vec2 coord ) {
-				float fragCoordZ = texture2D( depthSampler, coord ).x;
+			float readDepth( sampler2DArray depthSampler, vec2 coord ) {
+				float fragCoordZ = texture( depthSampler, vec3(coord, 0.5) ).x;
 				float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );
 				return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );
 			}
@@ -149,7 +150,7 @@
 				target.texture.generateMipmaps = false;
 				target.stencilBuffer = ( format === THREE.DepthStencilFormat ) ? true : false;
 				target.depthBuffer = true;
-				target.depthTexture = new THREE.DepthTexture();
+				target.depthTexture = new THREE.DataTexture2DArray();
 				target.depthTexture.format = format;
 				target.depthTexture.type = type;
 
@@ -212,7 +213,7 @@
 				camera.updateProjectionMatrix();
 
 				const dpr = renderer.getPixelRatio();
-				target.setSize( window.innerWidth * dpr, window.innerHeight * dpr );
+				target.setSize( Math.floor( window.innerWidth * dpr ), Math.floor( window.innerHeight * dpr ) );
 				renderer.setSize( window.innerWidth, window.innerHeight );
 
 			}
diff --git a/src/cameras/CubeCamera.js b/src/cameras/CubeCamera.js
index c60e199c00cb0d..b19ff7dbd05761 100644
--- a/src/cameras/CubeCamera.js
+++ b/src/cameras/CubeCamera.js
@@ -72,9 +72,13 @@ class CubeCamera extends Object3D {
 
 		renderer.xr.enabled = false;
 
-		const generateMipmaps = renderTarget.texture.generateMipmaps;
+		const generateMipmaps = new Array( renderTarget.textures.length );
+		for ( let i = 0, il = renderTarget.textures.length; i < il; i ++ ) {
 
-		renderTarget.texture.generateMipmaps = false;
+			generateMipmaps[ i ] = renderTarget.textures[ i ].generateMipmaps;
+			renderTarget.textures[ i ].generateMipmaps = false;
+
+		}
 
 		renderer.setRenderTarget( renderTarget, 0 );
 		renderer.render( scene, cameraPX );
@@ -91,7 +95,12 @@ class CubeCamera extends Object3D {
 		renderer.setRenderTarget( renderTarget, 4 );
 		renderer.render( scene, cameraPZ );
 
-		renderTarget.texture.generateMipmaps = generateMipmaps;
+
+		for ( let i = 0, il = renderTarget.textures.length; i < il; i ++ ) {
+
+			renderTarget.textures[ i ].generateMipmaps = generateMipmaps[ i ];
+
+		}
 
 		renderer.setRenderTarget( renderTarget, 5 );
 		renderer.render( scene, cameraNZ );
diff --git a/src/renderers/WebGLCubeRenderTarget.js b/src/renderers/WebGLCubeRenderTarget.js
index 3a88f08950796b..847d4dbf13a358 100644
--- a/src/renderers/WebGLCubeRenderTarget.js
+++ b/src/renderers/WebGLCubeRenderTarget.js
@@ -19,16 +19,21 @@ class WebGLCubeRenderTarget extends WebGLRenderTarget {
 
 		}
 
-		super( size, size, options );
-
 		options = options || {};
+		if ( options.texture === undefined ) {
+
+			options.texture = new CubeTexture( undefined, options.mapping, options.wrapS, options.wrapT, options.magFilter,
+				options.minFilter, options.format, options.type, options.anisotropy, options.encoding );
+
+		}
+
+		if ( options.texture._needsFlipEnvMap === undefined ) {
 
-		this.texture = new CubeTexture( undefined, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding );
+			options.texture._needsFlipEnvMap = false;
 
-		this.texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false;
-		this.texture.minFilter = options.minFilter !== undefined ? options.minFilter : LinearFilter;
+		}
 
-		this.texture._needsFlipEnvMap = false;
+		super( size, size, options );
 
 	}
 
@@ -127,9 +132,9 @@ class WebGLCubeRenderTarget extends WebGLRenderTarget {
 
 		const currentRenderTarget = renderer.getRenderTarget();
 
-		for ( let i = 0; i < 6; i ++ ) {
+		for ( let f = 0; f < 6; f ++ ) {
 
-			renderer.setRenderTarget( this, i );
+			renderer.setRenderTarget( this, f );
 
 			renderer.clear( color, depth, stencil );
 
diff --git a/src/renderers/WebGLMultipleRenderTargets.js b/src/renderers/WebGLMultipleRenderTargets.js
index 73bd6d6738ec68..01cb581f52b77e 100644
--- a/src/renderers/WebGLMultipleRenderTargets.js
+++ b/src/renderers/WebGLMultipleRenderTargets.js
@@ -4,71 +4,14 @@ class WebGLMultipleRenderTargets extends WebGLRenderTarget {
 
 	constructor( width, height, count ) {
 
-		super( width, height );
-
-		const texture = this.texture;
-
-		this.texture = [];
-
-		for ( let i = 0; i < count; i ++ ) {
-
-			this.texture[ i ] = texture.clone();
-
-		}
+		console.warn( 'WebGLMultipleRenderTargets is deprecated, use WebGLRenderTarget(width, height, {count: count}) instead.' );
+		super( width, height, { count: count } );
 
 	}
 
-	setSize( width, height, depth = 1 ) {
-
-		if ( this.width !== width || this.height !== height || this.depth !== depth ) {
-
-			this.width = width;
-			this.height = height;
-			this.depth = depth;
-
-			for ( let i = 0, il = this.texture.length; i < il; i ++ ) {
-
-				this.texture[ i ].image.width = width;
-				this.texture[ i ].image.height = height;
-				this.texture[ i ].image.depth = depth;
-
-			}
-
-			this.dispose();
-
-		}
-
-		this.viewport.set( 0, 0, width, height );
-		this.scissor.set( 0, 0, width, height );
-
-		return this;
-
-	}
-
-	copy( source ) {
-
-		this.dispose();
-
-		this.width = source.width;
-		this.height = source.height;
-		this.depth = source.depth;
-
-		this.viewport.set( 0, 0, this.width, this.height );
-		this.scissor.set( 0, 0, this.width, this.height );
-
-		this.depthBuffer = source.depthBuffer;
-		this.stencilBuffer = source.stencilBuffer;
-		this.depthTexture = source.depthTexture;
-
-		this.texture.length = 0;
-
-		for ( let i = 0, il = source.texture.length; i < il; i ++ ) {
-
-			this.texture[ i ] = source.texture[ i ].clone();
-
-		}
+	get texture() {
 
-		return this;
+		return this.textures;
 
 	}
 
diff --git a/src/renderers/WebGLRenderTarget.js b/src/renderers/WebGLRenderTarget.js
index a97b0de88baf7d..e31b5fadbe3a2e 100644
--- a/src/renderers/WebGLRenderTarget.js
+++ b/src/renderers/WebGLRenderTarget.js
@@ -10,33 +10,73 @@ import { Vector4 } from '../math/Vector4.js';
 */
 class WebGLRenderTarget extends EventDispatcher {
 
-	constructor( width, height, options = {} ) {
+	constructor( width, height, depth, options = {} ) {
+
+		if ( ! Number.isInteger( depth ) ) {
+
+			options = depth || options;
+			depth = 1;
+
+		}
 
 		super();
 
 		this.width = width;
 		this.height = height;
-		this.depth = 1;
+		this.depth = depth;
 
 		this.scissor = new Vector4( 0, 0, width, height );
 		this.scissorTest = false;
 
 		this.viewport = new Vector4( 0, 0, width, height );
 
-		this.texture = new Texture( undefined, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding );
-
-		this.texture.image = { width: width, height: height, depth: 1 };
-
-		this.texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false;
-		this.texture.minFilter = options.minFilter !== undefined ? options.minFilter : LinearFilter;
-
 		this.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true;
 		this.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : false;
 		this.depthTexture = options.depthTexture !== undefined ? options.depthTexture : null;
 
+		const count = options.count !== undefined ? options.count : 1;
+		const texture = options.texture !== undefined ? options.texture :
+			new Texture( undefined, options.mapping, options.wrapS, options.wrapT, options.magFilter,
+				options.minFilter, options.format, options.type, options.anisotropy, options.encoding );
+
+		texture.image = { width: width, height: height, depth: depth };
+		texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false;
+		texture.minFilter = options.minFilter !== undefined ? options.minFilter : LinearFilter;
+
+		this.textures = [];
+		for ( let i = 0; i < count; i ++ ) {
+
+			this.textures[ i ] = texture.clone();
+
+		}
+
+	}
+
+	get texture() {
+
+		return this.textures[ 0 ];
+
+	}
+
+	set texture( value ) {
+
+		this.textures[ 0 ] = value;
+
+	}
+
+	setTexture( texture, attachment = 0 ) {
+
+		texture.image = {
+			width: this.width,
+			height: this.height,
+			depth: this.depth
+		};
+
+		this.textures[ attachment ] = texture;
+
 	}
 
-	setTexture( texture ) {
+	setDepthTexture( texture ) {
 
 		texture.image = {
 			width: this.width,
@@ -44,11 +84,13 @@ class WebGLRenderTarget extends EventDispatcher {
 			depth: this.depth
 		};
 
-		this.texture = texture;
+		this.depthTexture = texture;
 
 	}
 
-	setSize( width, height, depth = 1 ) {
+	setSize( width, height, depth ) {
+
+		if ( depth === undefined ) depth = this.depth;
 
 		if ( this.width !== width || this.height !== height || this.depth !== depth ) {
 
@@ -56,9 +98,13 @@ class WebGLRenderTarget extends EventDispatcher {
 			this.height = height;
 			this.depth = depth;
 
-			this.texture.image.width = width;
-			this.texture.image.height = height;
-			this.texture.image.depth = depth;
+			for ( let i = 0, il = this.textures.length; i < il; i ++ ) {
+
+				this.textures[ i ].image.width = width;
+				this.textures[ i ].image.height = height;
+				this.textures[ i ].image.depth = depth;
+
+			}
 
 			this.dispose();
 
@@ -67,6 +113,8 @@ class WebGLRenderTarget extends EventDispatcher {
 		this.viewport.set( 0, 0, width, height );
 		this.scissor.set( 0, 0, width, height );
 
+		return this;
+
 	}
 
 	clone() {
@@ -77,14 +125,22 @@ class WebGLRenderTarget extends EventDispatcher {
 
 	copy( source ) {
 
+		this.dispose();
+
 		this.width = source.width;
 		this.height = source.height;
 		this.depth = source.depth;
 
 		this.viewport.copy( source.viewport );
+		this.scissor.copy( source.scissor );
+
+		this.textures.length = 0;
+		for ( let i = 0, il = source.textures.length; i < il; i ++ ) {
 
-		this.texture = source.texture.clone();
-		this.texture.image = { ...this.texture.image }; // See #20328.
+			this.textures[ i ] = source.textures[ i ].clone();
+			this.textures[ i ].image = { ...this.textures[ i ].image }; // See #20328.
+
+		}
 
 		this.depthBuffer = source.depthBuffer;
 		this.stencilBuffer = source.stencilBuffer;
diff --git a/src/renderers/WebGLRenderer.js b/src/renderers/WebGLRenderer.js
index ef99601499130a..199b5d5c30defe 100644
--- a/src/renderers/WebGLRenderer.js
+++ b/src/renderers/WebGLRenderer.js
@@ -10,7 +10,9 @@ import {
 	NoToneMapping,
 	LinearMipmapLinearFilter,
 	NearestFilter,
-	ClampToEdgeWrapping
+	ClampToEdgeWrapping,
+	DepthFormat,
+	DepthStencilFormat
 } from '../constants.js';
 import { Frustum } from '../math/Frustum.js';
 import { Matrix4 } from '../math/Matrix4.js';
@@ -1826,25 +1828,13 @@ function WebGLRenderer( parameters = {} ) {
 		}
 
 		let framebuffer = null;
-		let isCube = false;
-		let isRenderTarget3D = false;
-
 		if ( renderTarget ) {
 
-			const texture = renderTarget.texture;
-
-			if ( texture.isDataTexture3D || texture.isDataTexture2DArray ) {
-
-				isRenderTarget3D = true;
-
-			}
-
 			const __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer;
 
 			if ( renderTarget.isWebGLCubeRenderTarget ) {
 
 				framebuffer = __webglFramebuffer[ activeCubeFace ];
-				isCube = true;
 
 			} else if ( renderTarget.isWebGLMultisampleRenderTarget ) {
 
@@ -1876,35 +1866,23 @@ function WebGLRenderer( parameters = {} ) {
 
 			if ( renderTarget ) {
 
-				if ( renderTarget.isWebGLMultipleRenderTargets ) {
-
-					const textures = renderTarget.texture;
-
-					if ( _currentDrawBuffers.length !== textures.length || _currentDrawBuffers[ 0 ] !== _gl.COLOR_ATTACHMENT0 ) {
-
-						for ( let i = 0, il = textures.length; i < il; i ++ ) {
-
-							_currentDrawBuffers[ i ] = _gl.COLOR_ATTACHMENT0 + i;
-
-						}
-
-						_currentDrawBuffers.length = textures.length;
+				const textures = renderTarget.textures;
 
-						needsUpdate = true;
+				if ( _currentDrawBuffers.length !== textures.length ) {
 
-					}
+					_currentDrawBuffers.length = textures.length;
+					needsUpdate = true;
 
-				} else {
+				}
 
-					if ( _currentDrawBuffers.length !== 1 || _currentDrawBuffers[ 0 ] !== _gl.COLOR_ATTACHMENT0 ) {
+				for ( let i = 0, il = textures.length; i < il; i ++ ) {
 
-						_currentDrawBuffers[ 0 ] = _gl.COLOR_ATTACHMENT0;
-						_currentDrawBuffers.length = 1;
+					if ( _currentDrawBuffers[ i ] !== _gl.COLOR_ATTACHMENT0 + i ) {
 
+						_currentDrawBuffers[ i ] = _gl.COLOR_ATTACHMENT0 + i;
 						needsUpdate = true;
 
 					}
-
 				}
 
 			} else {
@@ -1940,19 +1918,61 @@ function WebGLRenderer( parameters = {} ) {
 		state.scissor( _currentScissor );
 		state.setScissorTest( _currentScissorTest );
 
-		if ( isCube ) {
+		if ( renderTarget ) {
+
+			const textures = renderTarget.textures;
+			for ( let i = 0, il = textures.length; i < il; i ++ ) {
+				const texture = textures[ i ];
+				const __webglTexture = properties.get( texture ).__webglTexture;
+				const attachment = _gl.COLOR_ATTACHMENT0 + i;
+				if ( texture.isDataTexture3D || texture.isDataTexture2DArray ) {
+
+					_gl.framebufferTextureLayer( _gl.FRAMEBUFFER, attachment, __webglTexture, activeMipmapLevel, activeCubeFace );
 
-			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 texture = renderTarget.depthTexture;
+				const __webglTexture = properties.get( texture ).__webglTexture;
 
-			const textureProperties = properties.get( renderTarget.texture );
-			const layer = activeCubeFace || 0;
-			_gl.framebufferTextureLayer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, textureProperties.__webglTexture, activeMipmapLevel || 0, layer );
+				let attachment = undefined;
+				if ( texture.format === DepthFormat ) {
 
-		}
+					attachment = _gl.DEPTH_ATTACHMENT;
+
+				} else if ( texture.format === DepthStencilFormat ) {
+
+					attachment = _gl.DEPTH_STENCIL_ATTACHMENT;
+
+				} else {
+
+
+			if ( renderTarget.depthTexture ) {
+
+				const texture = renderTarget.depthTexture;
+				if ( texture.isDataTexture3D || texture.isDataTexture2DArray ) {
+
+					let attachment = undefined;
+					if ( texture.format === DepthFormat ) {
 
+						attachment = _gl.DEPTH_ATTACHMENT;
+
+					} else if ( texture.format === DepthStencilFormat ) {
+
+						attachment = _gl.DEPTH_STENCIL_ATTACHMENT;
+
+					} else {
+
+						throw new Error( 'Unknown depthTexture format' );
+
+					}
+
+					const __webglTexture = properties.get( texture ).__webglTexture;
+					_gl.framebufferTextureLayer( _gl.FRAMEBUFFER, attachment, __webglTexture, activeMipmapLevel, activeCubeFace );
+
+				}
+			}
+		}
 	};
 
 	this.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer, activeCubeFaceIndex ) {
diff --git a/src/renderers/webgl/WebGLTextures.js b/src/renderers/webgl/WebGLTextures.js
index 4c2da6447ba739..336bdc9ae0bdb5 100644
--- a/src/renderers/webgl/WebGLTextures.js
+++ b/src/renderers/webgl/WebGLTextures.js
@@ -241,33 +241,21 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 	function deallocateRenderTarget( renderTarget ) {
 
-		const texture = renderTarget.texture;
-
-		const renderTargetProperties = properties.get( renderTarget );
-		const textureProperties = properties.get( texture );
-
 		if ( ! renderTarget ) return;
 
-		if ( textureProperties.__webglTexture !== undefined ) {
-
-			_gl.deleteTexture( textureProperties.__webglTexture );
-
-			info.memory.textures --;
-
-		}
-
 		if ( renderTarget.depthTexture ) {
 
 			renderTarget.depthTexture.dispose();
 
 		}
 
+		const renderTargetProperties = properties.get( renderTarget );
 		if ( renderTarget.isWebGLCubeRenderTarget ) {
 
-			for ( let i = 0; i < 6; i ++ ) {
+			for ( let f = 0; f < 6; f ++ ) {
 
-				_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ] );
-				if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ i ] );
+				_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ f ] );
+				if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ f ] );
 
 			}
 
@@ -281,27 +269,22 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 		}
 
-		if ( renderTarget.isWebGLMultipleRenderTargets ) {
-
-			for ( let i = 0, il = texture.length; i < il; i ++ ) {
-
-				const attachmentProperties = properties.get( texture[ i ] );
+		for ( let i = 0, il = renderTarget.textures.length; i < il; i ++ ) {
 
-				if ( attachmentProperties.__webglTexture ) {
+			const texture = renderTarget.textures[ i ];
+			const textureProperties = properties.get( texture );
 
-					_gl.deleteTexture( attachmentProperties.__webglTexture );
-
-					info.memory.textures --;
-
-				}
+			if ( textureProperties.__webglTexture ) {
 
-				properties.remove( texture[ i ] );
+				_gl.deleteTexture( textureProperties.__webglTexture );
+				info.memory.textures --;
 
 			}
 
+			properties.remove( texture );
+
 		}
 
-		properties.remove( texture );
 		properties.remove( renderTarget );
 
 	}
@@ -539,7 +522,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 		let mipmap;
 		const mipmaps = texture.mipmaps;
 
-		if ( texture.isDepthTexture ) {
+		if ( texture.format === DepthFormat || texture.format === DepthStencilFormat ) {
 
 			// populate depth texture with dummy data
 
@@ -613,11 +596,9 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 			}
 
-			//
-
-			state.texImage2D( _gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, null );
+		}
 
-		} else if ( texture.isDataTexture ) {
+		if ( texture.isDataTexture ) {
 
 			// use manually created mipmaps if available
 			// if there are no manual mipmaps
@@ -740,15 +721,15 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 		const cubeImage = [];
 
-		for ( let i = 0; i < 6; i ++ ) {
+		for ( let f = 0; f < 6; f ++ ) {
 
 			if ( ! isCompressed && ! isDataTexture ) {
 
-				cubeImage[ i ] = resizeImage( texture.image[ i ], false, true, maxCubemapSize );
+				cubeImage[ f ] = resizeImage( texture.image[ f ], false, true, maxCubemapSize );
 
 			} else {
 
-				cubeImage[ i ] = isDataTexture ? texture.image[ i ].image : texture.image[ i ];
+				cubeImage[ f ] = isDataTexture ? texture.image[ f ].image : texture.image[ f ];
 
 			}
 
@@ -766,9 +747,10 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 		if ( isCompressed ) {
 
-			for ( let i = 0; i < 6; i ++ ) {
+			for ( let f = 0; f < 6; f ++ ) {
 
-				mipmaps = cubeImage[ i ].mipmaps;
+				mipmaps = cubeImage[ f ].mipmaps;
+				const target = _gl.TEXTURE_CUBE_MAP_POSITIVE_X + f;
 
 				for ( let j = 0; j < mipmaps.length; j ++ ) {
 
@@ -778,7 +760,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 						if ( glFormat !== null ) {
 
-							state.compressedTexImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data );
+							state.compressedTexImage2D( target, j, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data );
 
 						} else {
 
@@ -788,7 +770,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 					} else {
 
-						state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
+						state.texImage2D( target, j, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
 
 					}
 
@@ -802,30 +784,31 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 			mipmaps = texture.mipmaps;
 
-			for ( let i = 0; i < 6; i ++ ) {
+			for ( let f = 0; f < 6; f ++ ) {
 
+				const target = _gl.TEXTURE_CUBE_MAP_POSITIVE_X + f;
 				if ( isDataTexture ) {
 
-					state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, cubeImage[ i ].width, cubeImage[ i ].height, 0, glFormat, glType, cubeImage[ i ].data );
+					state.texImage2D( target, 0, glInternalFormat, cubeImage[ f ].width, cubeImage[ f ].height, 0, glFormat, glType, cubeImage[ f ].data );
 
 					for ( let j = 0; j < mipmaps.length; j ++ ) {
 
 						const mipmap = mipmaps[ j ];
-						const mipmapImage = mipmap.image[ i ].image;
+						const mipmapImage = mipmap.image[ f ].image;
 
-						state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, mipmapImage.width, mipmapImage.height, 0, glFormat, glType, mipmapImage.data );
+						state.texImage2D( target, j + 1, glInternalFormat, mipmapImage.width, mipmapImage.height, 0, glFormat, glType, mipmapImage.data );
 
 					}
 
 				} else {
 
-					state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, glFormat, glType, cubeImage[ i ] );
+					state.texImage2D( target, 0, glInternalFormat, glFormat, glType, cubeImage[ f ] );
 
 					for ( let j = 0; j < mipmaps.length; j ++ ) {
 
 						const mipmap = mipmaps[ j ];
 
-						state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, glFormat, glType, mipmap.image[ i ] );
+						state.texImage2D( target, j + 1, glInternalFormat, glFormat, glType, mipmap.image[ f ] );
 
 					}
 
@@ -866,13 +849,12 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 		} else {
 
 			state.texImage2D( textureTarget, 0, glInternalFormat, renderTarget.width, renderTarget.height, 0, glFormat, glType, null );
+			state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+			_gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( texture ).__webglTexture, 0 );
+			state.bindFramebuffer( _gl.FRAMEBUFFER, null );
 
 		}
 
-		state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
-		_gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( texture ).__webglTexture, 0 );
-		state.bindFramebuffer( _gl.FRAMEBUFFER, null );
-
 	}
 
 	// Setup storage for internal depth/stencil buffers and bind to correct framebuffer
@@ -886,15 +868,15 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 			if ( isMultisample ) {
 
-				const depthTexture = renderTarget.depthTexture;
+				const texture = renderTarget.depthTexture;
 
-				if ( depthTexture && depthTexture.isDepthTexture ) {
+				if ( texture && ( texture.format === DepthFormat || texture.format === DepthStencilFormat ) ) {
 
-					if ( depthTexture.type === FloatType ) {
+					if ( texture.type === FloatType ) {
 
 						glInternalFormat = _gl.DEPTH_COMPONENT32F;
 
-					} else if ( depthTexture.type === UnsignedIntType ) {
+					} else if ( texture.type === UnsignedIntType ) {
 
 						glInternalFormat = _gl.DEPTH_COMPONENT24;
 
@@ -934,7 +916,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 		} else {
 
 			// Use the first texture for MRT so far
-			const texture = renderTarget.isWebGLMultipleRenderTargets === true ? renderTarget.texture[ 0 ] : renderTarget.texture;
+			const texture = renderTarget.texture;
 
 			const glFormat = utils.convert( texture.format );
 			const glType = utils.convert( texture.type );
@@ -959,48 +941,76 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 	}
 
 	// Setup resources for a Depth Texture for a FBO (needs an extension)
-	function setupDepthTexture( framebuffer, renderTarget ) {
+	function setupDepthTexture( renderTarget ) {
+
+		const texture = renderTarget.depthTexture;
+		let attachment = undefined;
+		if ( texture.format === DepthFormat ) {
 
-		const isCube = ( renderTarget && renderTarget.isWebGLCubeRenderTarget );
-		if ( isCube ) throw new Error( 'Depth Texture with cube render targets is not supported' );
+			attachment = _gl.DEPTH_ATTACHMENT;
+
+		} else if ( texture.format === DepthStencilFormat ) {
+
+			attachment = _gl.DEPTH_STENCIL_ATTACHMENT;
+
+		} else {
+
+			throw new Error( 'renderTarget.depthTexture.format must be either DepthFormat or DepthStencilFormat' );
+
+		}
 
-		state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+		const __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer;
+		const textureProperties = properties.get( texture );
 
-		if ( ! ( renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture ) ) {
+		if ( textureProperties.__webglTexture === undefined ) {
 
-			throw new Error( 'renderTarget.depthTexture must be an instance of THREE.DepthTexture' );
+			textureProperties.__webglTexture = _gl.createTexture();
+			textureProperties.__version = texture.version;
+			info.memory.textures ++;
 
 		}
 
 		// upload an empty depth texture with framebuffer size
-		if ( ! properties.get( renderTarget.depthTexture ).__webglTexture ||
-				renderTarget.depthTexture.image.width !== renderTarget.width ||
-				renderTarget.depthTexture.image.height !== renderTarget.height ) {
+		if ( texture.image.width !== renderTarget.width ||
+				texture.image.height !== renderTarget.height ) {
 
-			renderTarget.depthTexture.image.width = renderTarget.width;
-			renderTarget.depthTexture.image.height = renderTarget.height;
-			renderTarget.depthTexture.needsUpdate = true;
+			texture.image.width = renderTarget.width;
+			texture.image.height = renderTarget.height;
+			texture.needsUpdate = true;
 
 		}
 
-		setTexture2D( renderTarget.depthTexture, 0 );
+		if ( texture.isCubeTexture ) {
 
-		const webglDepthTexture = properties.get( renderTarget.depthTexture ).__webglTexture;
+			setTextureCube( texture, 0 );
+			for ( let f = 0; f < 6; f ++ ) {
 
-		if ( renderTarget.depthTexture.format === DepthFormat ) {
+				state.bindFramebuffer( _gl.FRAMEBUFFER, __webglFramebuffer[ f ] );
+				const target = _gl.TEXTURE_CUBE_MAP_POSITIVE_X + f;
+				_gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, target, textureProperties.__webglTexture, 0 );
 
-			_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );
+			}
+
+		} else if ( texture.isDataTexture3D ) {
 
-		} else if ( renderTarget.depthTexture.format === DepthStencilFormat ) {
+			throw new Error( 'renderTarget.depthTexture may not be a 3D texture.' );
 
-			_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );
+		} else if ( texture.isDataTexture2DArray ) {
+
+			setTexture2DArray( texture, 0 );
+			state.bindFramebuffer( _gl.FRAMEBUFFER, __webglFramebuffer );
+			_gl.framebufferTextureLayer( _gl.FRAMEBUFFER, attachment, textureProperties.__webglTexture, 0, 0 );
 
 		} else {
 
-			throw new Error( 'Unknown depthTexture format' );
+			setTexture2D( texture, 0 );
+			state.bindFramebuffer( _gl.FRAMEBUFFER, __webglFramebuffer );
+			_gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, _gl.TEXTURE_2D, textureProperties.__webglTexture, 0 );
 
 		}
 
+		state.bindFramebuffer( _gl.FRAMEBUFFER, null );
+
 	}
 
 	// Setup GL resources for a non-texture depth buffer
@@ -1008,35 +1018,23 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 		const renderTargetProperties = properties.get( renderTarget );
 
-		const isCube = ( renderTarget.isWebGLCubeRenderTarget === true );
-
-		if ( renderTarget.depthTexture ) {
-
-			if ( isCube ) throw new Error( 'target.depthTexture not supported in Cube render targets' );
-
-			setupDepthTexture( renderTargetProperties.__webglFramebuffer, renderTarget );
-
-		} else {
-
-			if ( isCube ) {
-
-				renderTargetProperties.__webglDepthbuffer = [];
+		if ( renderTarget.isWebGLCubeRenderTarget ) {
 
-				for ( let i = 0; i < 6; i ++ ) {
+			renderTargetProperties.__webglDepthbuffer = [];
 
-					state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ i ] );
-					renderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer();
-					setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget, false );
+			for ( let f = 0; f < 6; f ++ ) {
 
-				}
+				state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ f ] );
+				renderTargetProperties.__webglDepthbuffer[ f ] = _gl.createRenderbuffer();
+				setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ f ], renderTarget, false );
 
-			} else {
+			}
 
-				state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );
-				renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();
-				setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget, false );
+		} else {
 
-			}
+			state.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );
+			renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();
+			setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget, false );
 
 		}
 
@@ -1047,46 +1045,20 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 	// Set up GL resources for the render target
 	function setupRenderTarget( renderTarget ) {
 
-		const texture = renderTarget.texture;
-
 		const renderTargetProperties = properties.get( renderTarget );
-		const textureProperties = properties.get( texture );
-
 		renderTarget.addEventListener( 'dispose', onRenderTargetDispose );
-
-		if ( renderTarget.isWebGLMultipleRenderTargets !== true ) {
-
-			textureProperties.__webglTexture = _gl.createTexture();
-			textureProperties.__version = texture.version;
-			info.memory.textures ++;
-
-		}
-
-		const isCube = ( renderTarget.isWebGLCubeRenderTarget === true );
-		const isMultipleRenderTargets = ( renderTarget.isWebGLMultipleRenderTargets === true );
-		const isMultisample = ( renderTarget.isWebGLMultisampleRenderTarget === true );
-		const isRenderTarget3D = texture.isDataTexture3D || texture.isDataTexture2DArray;
 		const supportsMips = isPowerOfTwo( renderTarget ) || isWebGL2;
-
-		// Handles WebGL2 RGBFormat fallback - #18858
-
-		if ( isWebGL2 && texture.format === RGBFormat && ( texture.type === FloatType || texture.type === HalfFloatType ) ) {
-
-			texture.format = RGBAFormat;
-
-			console.warn( 'THREE.WebGLRenderer: Rendering to textures with RGB format is not supported. Using RGBA format instead.' );
-
-		}
+		const textures = renderTarget.textures;
 
 		// Setup framebuffer
 
-		if ( isCube ) {
+		if ( renderTarget.isWebGLCubeRenderTarget ) {
 
 			renderTargetProperties.__webglFramebuffer = [];
 
-			for ( let i = 0; i < 6; i ++ ) {
+			for ( let f = 0; f < 6; f ++ ) {
 
-				renderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer();
+				renderTargetProperties.__webglFramebuffer[ f ] = _gl.createFramebuffer();
 
 			}
 
@@ -1094,33 +1066,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 			renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();
 
-			if ( isMultipleRenderTargets ) {
-
-				if ( capabilities.drawBuffers ) {
-
-					const textures = renderTarget.texture;
-
-					for ( let i = 0, il = textures.length; i < il; i ++ ) {
-
-						const attachmentProperties = properties.get( textures[ i ] );
-
-						if ( attachmentProperties.__webglTexture === undefined ) {
-
-							attachmentProperties.__webglTexture = _gl.createTexture();
-
-							info.memory.textures ++;
-
-						}
-
-					}
-
-				} else {
-
-					console.warn( 'THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.' );
-
-				}
-
-			} else if ( isMultisample ) {
+			if ( renderTarget.isWebGLMultisampleRenderTarget ) {
 
 				if ( isWebGL2 ) {
 
@@ -1129,6 +1075,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 					_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer );
 
+					const texture = textures[ 0 ];
 					const glFormat = utils.convert( texture.format );
 					const glType = utils.convert( texture.type );
 					const glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType );
@@ -1159,82 +1106,72 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 		}
 
-		// Setup color buffer
+		if ( textures.length > 1 && ! capabilities.drawBuffers ) {
 
-		if ( isCube ) {
+			console.warn( 'THREE.WebGLRenderer: multiple render targets can only be used with WebGL2 or WEBGL_draw_buffers extension.' );
 
-			state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture );
-			setTextureParameters( _gl.TEXTURE_CUBE_MAP, texture, supportsMips );
-
-			for ( let i = 0; i < 6; i ++ ) {
+		}
 
-				setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i );
+		for ( let i = 0, il = textures.length; i < il; i ++ ) {
 
-			}
+			const texture = textures[ i ];
+			const textureProperties = properties.get( texture );
 
-			if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {
+			if ( textureProperties.__webglTexture === undefined ) {
 
-				generateMipmap( _gl.TEXTURE_CUBE_MAP, texture, renderTarget.width, renderTarget.height );
+				textureProperties.__webglTexture = _gl.createTexture();
+				textureProperties.__version = texture.version;
+				info.memory.textures ++;
 
 			}
 
-			state.bindTexture( _gl.TEXTURE_CUBE_MAP, null );
+			const target =
+				texture.isCubeTexture ? _gl.TEXTURE_CUBE_MAP :
+					texture.isDataTexture3D ? _gl.TEXTURE_3D :
+						texture.isDataTexture2DArray ? _gl.TEXTURE_2D_ARRAY :
+							_gl.TEXTURE_2D;
 
-		} else if ( isMultipleRenderTargets ) {
+			const isRenderTarget3D = texture.isDataTexture3D || texture.isDataTexture2DArray;
+			if ( isRenderTarget3D && ! isWebGL2 ) {
 
-			const textures = renderTarget.texture;
+				console.warn( 'THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.' );
 
-			for ( let i = 0, il = textures.length; i < il; i ++ ) {
-
-				const attachment = textures[ i ];
-				const attachmentProperties = properties.get( attachment );
-
-				state.bindTexture( _gl.TEXTURE_2D, attachmentProperties.__webglTexture );
-				setTextureParameters( _gl.TEXTURE_2D, attachment, supportsMips );
-				setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, attachment, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D );
+			}
+			// Handles WebGL2 RGBFormat fallback - #18858
 
-				if ( textureNeedsGenerateMipmaps( attachment, supportsMips ) ) {
+			if ( isWebGL2 && texture.format === RGBFormat && ( texture.type === FloatType || texture.type === HalfFloatType ) ) {
 
-					generateMipmap( _gl.TEXTURE_2D, attachment, renderTarget.width, renderTarget.height );
+				texture.format = RGBAFormat;
 
-				}
+				console.warn( 'THREE.WebGLRenderer: Rendering to textures with RGB format is not supported. Using RGBA format instead.' );
 
 			}
 
-			state.bindTexture( _gl.TEXTURE_2D, null );
 
-		} else {
-
-			let glTextureType = _gl.TEXTURE_2D;
+			// Setup color buffer
+			state.bindTexture( target, textureProperties.__webglTexture );
+			setTextureParameters( target, texture, supportsMips );
+			if ( texture.isCubeTexture ) {
 
-			if ( isRenderTarget3D ) {
+				for ( let f = 0; f < 6; f ++ ) {
 
-				// Render targets containing layers, i.e: Texture 3D and 2d arrays
+					setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ f ], renderTarget, texture, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + f );
 
-				if ( isWebGL2 ) {
-
-					const isTexture3D = texture.isDataTexture3D;
-					glTextureType = isTexture3D ? _gl.TEXTURE_3D : _gl.TEXTURE_2D_ARRAY;
-
-				} else {
+				}
 
-					console.warn( 'THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.' );
+			} else {
 
-				}
+				setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, texture, _gl.COLOR_ATTACHMENT0 + i, target );
 
 			}
 
-			state.bindTexture( glTextureType, textureProperties.__webglTexture );
-			setTextureParameters( glTextureType, texture, supportsMips );
-			setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType );
-
 			if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {
 
-				generateMipmap( glTextureType, texture, renderTarget.width, renderTarget.height, renderTarget.depth );
+				generateMipmap( target, texture, renderTarget.width, renderTarget.height, renderTarget.depth );
 
 			}
 
-			state.bindTexture( glTextureType, null );
+			state.bindTexture( target, null );
 
 		}
 
@@ -1242,7 +1179,15 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 		if ( renderTarget.depthBuffer ) {
 
-			setupDepthRenderbuffer( renderTarget );
+			if ( renderTarget.depthTexture ) {
+
+				setupDepthTexture( renderTarget );
+
+			} else {
+
+				setupDepthRenderbuffer( renderTarget );
+
+			}
 
 		}
 
@@ -1251,8 +1196,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 	function updateRenderTargetMipmap( renderTarget ) {
 
 		const supportsMips = isPowerOfTwo( renderTarget ) || isWebGL2;
-
-		const textures = renderTarget.isWebGLMultipleRenderTargets === true ? renderTarget.texture : [ renderTarget.texture ];
+		const textures = renderTarget.textures;
 
 		for ( let i = 0, il = textures.length; i < il; i ++ ) {
 
@@ -1260,11 +1204,15 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 			if ( textureNeedsGenerateMipmaps( texture, supportsMips ) ) {
 
-				const target = renderTarget.isWebGLCubeRenderTarget ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D;
 				const webglTexture = properties.get( texture ).__webglTexture;
+				const target =
+					texture.isCubeTexture ? _gl.TEXTURE_CUBE_MAP :
+						texture.isDataTexture3D ? _gl.TEXTURE_3D :
+							texture.isDataTexture2DArray ? _gl.TEXTURE_2D_ARRAY :
+								_gl.TEXTURE_2D;
 
 				state.bindTexture( target, webglTexture );
-				generateMipmap( target, texture, renderTarget.width, renderTarget.height );
+				generateMipmap( target, texture, renderTarget.width, renderTarget.height, renderTarget.depth );
 				state.bindTexture( target, null );
 
 			}
@@ -1358,7 +1306,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils,
 
 			if ( warnedTextureCube === false ) {
 
-				console.warn( 'THREE.WebGLTextures.safeSetTextureCube: don\'t use cube render targets as textures. Use their .texture property instead.' );
+				console.warn( 'THREE.WebGLTextures.safeSetTextureCube: don\'t use cube render targets as textures. Use .textures[0] instead.' );
 				warnedTextureCube = true;
 
 			}
diff --git a/src/textures/CubeTexture.js b/src/textures/CubeTexture.js
index f214911d437316..e839eeae16e0ea 100644
--- a/src/textures/CubeTexture.js
+++ b/src/textures/CubeTexture.js
@@ -19,7 +19,7 @@ class CubeTexture extends Texture {
 
 		// three.js uses a right-handed coordinate system. So environment maps used in three.js appear to have px and nx swapped
 		// and the flag _needsFlipEnvMap controls this conversion. The flip is not required (and thus _needsFlipEnvMap is set to false)
-		// when using WebGLCubeRenderTarget.texture as a cube texture.
+		// when using a cube texture in WebGLCubeRenderTarget.textures.
 
 		this._needsFlipEnvMap = true;