Added DepthPassPlugin.

This is required for SSAO. Unfortunately scene.overrideMaterial is not enough for proper depth pass. Like for shadow maps, shader animated objects (like morphs) need different depth materials than static objects.

examples/js/ShaderExtras.js

@@ -1410,7 +1410,9 @@ THREE.ShaderExtras = {
 			"fogNear":		{ type: "f", value: 5 },
 			"fogFar":		{ type: "f", value: 100 },
 			"fogEnabled":	{ type: "i", value: 0 },
-			"aoClamp":		{ type: "f", value: 0.3 }
+			"onlyAO":		{ type: "i", value: 0 },
+			"aoClamp":		{ type: "f", value: 0.3 },
+			"lumInfluence":	{ type: "f", value: 0.9 }
 
 		},
 
@@ -1436,10 +1438,13 @@ THREE.ShaderExtras = {
 			"uniform float fogNear;",
 			"uniform float fogFar;",
 
-			"uniform bool fogEnabled;",
+			"uniform bool fogEnabled;",		// attenuate AO with linear fog
+			"uniform bool onlyAO;", 		// use only ambient occlusion pass?
 
-			"uniform vec2 size;",		// texture width, height
-			"uniform float aoClamp;", 	// depth clamp - reduces haloing at screen edges
+			"uniform vec2 size;",			// texture width, height
+			"uniform float aoClamp;", 		// depth clamp - reduces haloing at screen edges
+
+			"uniform float lumInfluence;",  // how much luminance affects occlusion
 
 			"uniform sampler2D tDiffuse;",
 			"uniform sampler2D tDepth;",
@@ -1465,13 +1470,14 @@ THREE.ShaderExtras = {
 			"const float radius = 5.0;", 	// ao radius
 
 			"const bool useNoise = false;", 		 // use noise instead of pattern for sample dithering
-			"const float noiseAmount = 0.0002;", // dithering amount
+			"const float noiseAmount = 0.0003;", // dithering amount
 
 			"const float diffArea = 0.4;", 		// self-shadowing reduction
 			"const float gDisplace = 0.4;", 	// gauss bell center
 
-			"const bool onlyAO = false;", 		// use only ambient occlusion pass?
-			"const float lumInfluence = 0.3;",  // how much luminance affects occlusion
+			"const vec3 onlyAOColor = vec3( 1.0, 0.7, 0.5 );",
+			//"const vec3 onlyAOColor = vec3( 1.0, 1.0, 1.0 );",
+
 
 			// RGBA depth
 
@@ -1626,7 +1632,7 @@ THREE.ShaderExtras = {
 
 				"if ( onlyAO ) {",
 
-					"final = vec3( mix( vec3( ao ), vec3( 1.0 ), luminance * lumInfluence ) );", // ambient occlusion only
+					"final = onlyAOColor * vec3( mix( vec3( ao ), vec3( 1.0 ), luminance * lumInfluence ) );", // ambient occlusion only
 
 				"}",
 

src/extras/renderers/plugins/DepthPassPlugin.js

+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.DepthPassPlugin = function ( ) {
+
+	this.enabled = false;
+	this.renderTarget = null;
+
+	var _gl,
+	_renderer,
+	_depthMaterial, _depthMaterialMorph,
+
+	_frustum = new THREE.Frustum(),
+	_projScreenMatrix = new THREE.Matrix4();
+
+	this.init = function ( renderer ) {
+
+		_gl = renderer.context;
+		_renderer = renderer;
+
+		var depthShader = THREE.ShaderLib[ "depthRGBA" ];
+		var depthUniforms = THREE.UniformsUtils.clone( depthShader.uniforms );
+
+		_depthMaterial = new THREE.ShaderMaterial( { fragmentShader: depthShader.fragmentShader, vertexShader: depthShader.vertexShader, uniforms: depthUniforms } );
+		_depthMaterialMorph = new THREE.ShaderMaterial( { fragmentShader: depthShader.fragmentShader, vertexShader: depthShader.vertexShader, uniforms: depthUniforms, morphTargets: true } );
+
+		_depthMaterial._shadowPass = true;
+		_depthMaterialMorph._shadowPass = true;
+
+	};
+
+	this.render = function ( scene, camera ) {
+
+		if ( ! this.enabled ) return;
+
+		this.update( scene, camera );
+
+	};
+
+	this.update = function ( scene, camera ) {
+
+		var i, il, j, jl, n,
+
+		program, buffer, material,
+		webglObject, object, light,
+		renderList,
+
+		fog = null;
+
+		// set GL state for depth map
+
+		_gl.clearColor( 1, 1, 1, 1 );
+		_gl.disable( _gl.BLEND );
+
+		_renderer.setDepthTest( true );
+
+		// render depth map
+
+		if ( _renderer.autoUpdateScene ) scene.updateMatrixWorld();
+
+		camera.matrixWorldInverse.getInverse( camera.matrixWorld );
+
+		if ( ! camera._viewMatrixArray ) camera._viewMatrixArray = new Float32Array( 16 );
+		camera.matrixWorldInverse.flattenToArray( camera._viewMatrixArray );
+
+		if ( ! camera._projectionMatrixArray ) camera._projectionMatrixArray = new Float32Array( 16 );
+		camera.projectionMatrix.flattenToArray( camera._projectionMatrixArray );
+
+		_projScreenMatrix.multiply( camera.projectionMatrix, camera.matrixWorldInverse );
+		_frustum.setFromMatrix( _projScreenMatrix );
+
+		_renderer.setRenderTarget( this.renderTarget );
+		_renderer.clear();
+
+		// set matrices & frustum culling
+
+		renderList = scene.__webglObjects;
+
+		for ( j = 0, jl = renderList.length; j < jl; j ++ ) {
+
+			webglObject = renderList[ j ];
+			object = webglObject.object;
+
+			webglObject.render = false;
+
+			if ( object.visible ) {
+
+				if ( ! ( object instanceof THREE.Mesh ) || ! ( object.frustumCulled ) || _frustum.contains( object ) ) {
+
+					object.matrixWorld.flattenToArray( object._objectMatrixArray );
+					object._modelViewMatrix.multiplyToArray( camera.matrixWorldInverse, object.matrixWorld, object._modelViewMatrixArray );
+
+					webglObject.render = true;
+
+				}
+
+			}
+
+		}
+
+		// render regular objects
+
+		for ( j = 0, jl = renderList.length; j < jl; j ++ ) {
+
+			webglObject = renderList[ j ];
+
+			if ( webglObject.render ) {
+
+				object = webglObject.object;
+				buffer = webglObject.buffer;
+
+				_renderer.setObjectFaces( object );
+
+				if ( object.customDepthMaterial ) {
+
+					material = object.customDepthMaterial;
+
+				} else if ( object.geometry.morphTargets.length ) {
+
+					material = _depthMaterialMorph;
+
+				} else {
+
+					material = _depthMaterial;
+
+				}
+
+				if ( buffer instanceof THREE.BufferGeometry ) {
+
+					_renderer.renderBufferDirect( camera, scene.__lights, fog, material, buffer, object );
+
+				} else {
+
+					_renderer.renderBuffer( camera, scene.__lights, fog, material, buffer, object );
+
+				}
+
+			}
+
+		}
+
+		// set matrices and render immediate objects
+
+		renderList = scene.__webglObjectsImmediate;
+
+		for ( j = 0, jl = renderList.length; j < jl; j ++ ) {
+
+			webglObject = renderList[ j ];
+			object = webglObject.object;
+
+			if ( object.visible && object.castShadow ) {
+
+				if( object.matrixAutoUpdate ) {
+
+					object.matrixWorld.flattenToArray( object._objectMatrixArray );
+
+				}
+
+				object._modelViewMatrix.multiplyToArray( camera.matrixWorldInverse, object.matrixWorld, object._modelViewMatrixArray );
+
+				_renderer.renderImmediateObject( camera, scene.__lights, fog, _depthMaterial, object );
+
+			}
+
+		}
+
+		// restore GL state
+
+		var clearColor = _renderer.getClearColor(),
+		clearAlpha = _renderer.getClearAlpha();
+
+		_gl.clearColor( clearColor.r, clearColor.g, clearColor.b, clearAlpha );
+		_gl.enable( _gl.BLEND );
+
+	};
+
+};
+

utils/build.py

@@ -135,6 +135,7 @@ EXTRAS_FILES = [
 'extras/renderers/plugins/LensFlarePlugin.js',
 'extras/renderers/plugins/ShadowMapPlugin.js',
 'extras/renderers/plugins/SpritePlugin.js',
+'extras/renderers/plugins/DepthPassPlugin.js',
 'extras/renderers/AnaglyphWebGLRenderer.js',
 'extras/renderers/CrosseyedWebGLRenderer.js',
 'extras/shaders/ShaderFlares.js',