Initial add of lens flare

src/lights/LensFlare.js

+/**
+ * @author Mikael Emtinger
+ */
+ 
+THREE.LensFlare = function ( material, size ) {
+
+	THREE.Object3D.call( this );
+
+	this.positionScreen = new THREE.Vector3();
+	this.lensFlares = [];
+	this.customUpdateCallback = undefined;
+
+	this.addLensFlare( material, size, 0 );
+};
+
+THREE.LensFlare.prototype = new THREE.Object3D();
+THREE.LensFlare.prototype.constructor = THREE.LensFlare;
+THREE.LensFlare.prototype.supr = THREE.Object3D.prototype;
+
+
+/*
+ * Add: adds another flare 
+ */
+
+THREE.LensFlare.prototype.add = function( material, size, distance ) {
+	
+	distance = Math.min( distance, Math.max( 0, distance ));
+
+	lensFlares.push( { material: material, size: size, distance: distance, position: new THREE.Vector3() } );
+}
+
+
+/*
+ * Update lens flares update positions on all flares based on the screen position
+ * Set myLensFlare.customUpdateCallback to alter the flares in your project specific way.
+ */
+
+THREE.LensFlare.updateLensFlares = function() {
+	
+	// todo: update lens halo positions here
+}
+
+
+
+
+
+
+
+
+
+
+
+

src/renderers/WebGLRenderer.js

@@ -2524,17 +2524,61 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 		}
 
+		// render flares
 		
+		if( scene.__webglLensFlares.length ) {
+			
+			renderLensFlares( scene, renderTarget );
+		
+		}
 
-		//////////////////////// stencil shadows begin //////////////////////
-		// method: we're rendering the world in light, then the shadow
-		//         volumes into the stencil and last a big darkening 
-		//         quad over the whole thing. This is NOT how you're
-		//         supposed to do stencil shadows but is much faster
-		//
+
+		// render stencil shadows
 
 		if( scene.__webglShadowVolumes.length && scene.lights.length ) {
 
+			renderStencilShadows( scene );
+		
+		}
+
+
+		// Generate mipmap if we're using any kind of mipmap filtering
+
+		if ( renderTarget && renderTarget.minFilter !== THREE.NearestFilter && renderTarget.minFilter !== THREE.LinearFilter ) {
+
+			updateRenderTargetMipmap( renderTarget );
+
+		}
+
+	};
+
+
+	/*
+	 * Render lens flares
+	 * Method: renders 9 0xff00ff-colored points scattered over the light source area, 
+	 *         reads these back and calculates occlusion.  
+	 *         Then LensFlare.updateLensFlares() is called to re-position and 
+	 *         update transparency of flares. Then they are rendered.
+	 * 
+	 */
+
+	function renderLensFlares() {
+		
+		
+	}
+
+
+	/*
+	 * Stencil Shadows
+	 * method: we're rendering the world in light, then the shadow
+	 *         volumes into the stencil and last a big darkening 
+	 *         quad over the whole thing. This is not how "you're
+	 *	       supposed to" do stencil shadows but is much faster
+	 * 
+	 */
+
+	function renderStencilShadows( scene ) {
+			
 		// setup stencil
 
 		_gl.enable( _gl.POLYGON_OFFSET_FILL );
@@ -2548,19 +2592,17 @@ THREE.WebGLRenderer = function ( parameters ) {
 		_gl.stencilOpSeparate( _gl.FRONT, _gl.KEEP, _gl.DECR, _gl.KEEP );
 
 		
-			
 		// loop through all directional lights
 		
 		var l, ll = scene.lights.length;
 		var p;
-			var light, geometryGroup;
+		var light, lights = scene.lights, geometryGroup;
 		var dirLight = [];			
 		var	program;
 		var p_uniforms;
 	    var m_uniforms;
 	    var attributes;
-	
-			ol = scene.__webglShadowVolumes.length;
+		var o, ol = scene.__webglShadowVolumes.length;
 		
 		for( l = 0; l < ll; l++ ) {
 			
@@ -2575,14 +2617,14 @@ THREE.WebGLRenderer = function ( parameters ) {
 				
 				// render all volumes
 				
-					for ( o = 0; o < ol; o++ ) {
+				for( o = 0; o < ol; o++ ) {
 		
 					object        = scene.__webglShadowVolumes[ o ].object;
 					geometryGroup = scene.__webglShadowVolumes[ o ].buffer;
 					material      = object.materials[ 0 ];
 
 
-						if ( !material.program ) _this.initMaterial( material, lights, fog, object );
+					if ( !material.program ) _this.initMaterial( material, lights, undefined, object );
 
 					program = material.program,
 		  			p_uniforms = program.uniforms,
@@ -2602,10 +2644,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 
 					object.matrixWorld.flattenToArray( object._objectMatrixArray );
-						//object._modelViewMatrix.multiplyToArray( camera.matrixWorldInverse, object.matrixWorld, object._modelViewMatrixArray );
-
 					_gl.uniformMatrix4fv( p_uniforms.objectMatrix, false, object._objectMatrixArray );
-						//_gl.uniformMatrix4fv( p_uniforms.modelViewMatrix, false, object._modelViewMatrixArray );
 
 
 					_gl.bindBuffer( _gl.ARRAY_BUFFER, geometryGroup.__webGLVertexBuffer );
@@ -2628,8 +2667,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 		}
 
-	
-			// draw darkening polygon	
+		// setup color+stencil
 
 		_gl.disable( _gl.POLYGON_OFFSET_FILL );
 		_gl.colorMask( true, true, true, true );
@@ -2637,10 +2675,8 @@ THREE.WebGLRenderer = function ( parameters ) {
 		_gl.stencilOp( _gl.KEEP, _gl.KEEP, _gl.KEEP );
 	    _gl.disable( _gl.DEPTH_TEST );
 
-			_gl.enable( _gl.BLEND );
-			_gl.blendFunc( _gl.ONE, _gl.ONE_MINUS_SRC_ALPHA );
-			_gl.blendEquation( _gl.FUNC_ADD );
 
+		// draw darkening polygon	
 
 		_oldBlending = "";
 		_oldProgram = _shadow.program;
@@ -2652,6 +2688,10 @@ THREE.WebGLRenderer = function ( parameters ) {
 		_gl.vertexAttribPointer( _shadow.vertexLocation, 3, _gl.FLOAT, false, 0, 0 );
 		_gl.enableVertexAttribArray( _shadow.vertexLocation );
 
+		_gl.enable( _gl.BLEND );
+		_gl.blendFunc( _gl.ONE, _gl.ONE_MINUS_SRC_ALPHA );
+		_gl.blendEquation( _gl.FUNC_ADD );
+			
 		_gl.bindBuffer( _gl.ELEMENT_ARRAY_BUFFER, _shadow.elementBuffer );
 		_gl.drawElements( _gl.TRIANGLES, 6, _gl.UNSIGNED_SHORT, 0 );
 
@@ -2665,19 +2705,6 @@ THREE.WebGLRenderer = function ( parameters ) {
 	}
 
 
-		//////////////////////// stencil shadows end //////////////////////
-
-
-		// Generate mipmap if we're using any kind of mipmap filtering
-
-		if ( renderTarget && renderTarget.minFilter !== THREE.NearestFilter && renderTarget.minFilter !== THREE.LinearFilter ) {
-
-			updateRenderTargetMipmap( renderTarget );
-
-		}
-
-	};
-
 	function setupMatrices ( object, camera ) {
 
 		object._modelViewMatrix.multiplyToArray( camera.matrixWorldInverse, object.matrixWorld, object._modelViewMatrixArray );
@@ -2692,6 +2719,7 @@ THREE.WebGLRenderer = function ( parameters ) {
 			scene.__webglObjects = [];
 			scene.__webglObjectsImmediate = [];
 			scene.__webglShadowVolumes = [];
+			scene.__webglLensFlares = [];
 		}
 
 		while ( scene.__objectsAdded.length ) {
@@ -2722,6 +2750,11 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 		}
 		
+		for ( var o = 0, ol = scene.__webglLensFlares.length; o < ol; o ++ ) {
+
+			updateObject( scene.__webglLensFlares[ o ].object, scene );
+
+		}
 
 	};