/**
 * @author mr.doob / http://mrdoob.com/
 * @author supereggbert / http://www.paulbrunt.co.uk/
 */

THREE.Renderer = function() {

	var face3Pool = [],
	face4Pool = [],
	linePool = [],
	particlePool = [],

	vector4 = new THREE.Vector4(),
	matrix = new THREE.Matrix4();

	function painterSort( a, b ) {

		return b.z - a.z;

	}

	this.renderList = null;

	this.project = function (scene, camera) {

		var i, j, vertex, vertex2, face, object, v1, v2, v3, v4,
		face3count = 0, face4count = 0, lineCount = 0, particleCount = 0,
		verticesLength = 0, facesLength = 0;

		this.renderList = [];

		if( camera.autoUpdateMatrix ) {

			camera.updateMatrix();

		}

		for ( i = 0; i < scene.objects.length; i++ ) {

			object = scene.objects[i];

			if( object.autoUpdateMatrix ) {

				object.updateMatrix();

			}

			if ( object instanceof THREE.Mesh ) {

				matrix.multiply( camera.matrix, object.matrix );

				// vertices

				verticesLength = object.geometry.vertices.length;

				for ( j = 0; j < verticesLength; j++ ) {

					vertex = object.geometry.vertices[ j ];
					vertex.screen.copy( vertex.position );

					matrix.transform( vertex.screen );
					camera.projectionMatrix.transform( vertex.screen );

					vertex.__visible = vertex.screen.z > 0 && vertex.screen.z < 1;

				}

				// faces

				facesLength = object.geometry.faces.length;

				for ( j = 0; j < facesLength; j++ ) {

					face = object.geometry.faces[ j ];

					// TODO: Use normals for culling... maybe not?

					if (face instanceof THREE.Face3) {

						v1 = object.geometry.vertices[ face.a ];
						v2 = object.geometry.vertices[ face.b ];
						v3 = object.geometry.vertices[ face.c ];

						if ( v1.__visible && v2.__visible && v3.__visible && ( object.doubleSided ||
						   ( v3.screen.x - v1.screen.x ) * ( v2.screen.y - v1.screen.y ) -
						   ( v3.screen.y - v1.screen.y ) * ( v2.screen.x - v1.screen.x ) > 0 ) ) {

							face.screen.z = Math.max( v1.screen.z, Math.max( v2.screen.z, v3.screen.z ) );

							if ( !face3Pool[ face3count ] ) {

								face3Pool[ face3count ] = new THREE.RenderableFace3();

							}

							face3Pool[ face3count ].v1.x = v1.screen.x;
							face3Pool[ face3count ].v1.y = v1.screen.y;
							face3Pool[ face3count ].v2.x = v2.screen.x;
							face3Pool[ face3count ].v2.y = v2.screen.y;
							face3Pool[ face3count ].v3.x = v3.screen.x;
							face3Pool[ face3count ].v3.y = v3.screen.y;
							face3Pool[ face3count ].z = face.screen.z;

							face3Pool[ face3count ].material = object.material;
							face3Pool[ face3count ].overdraw = object.overdraw;
							face3Pool[ face3count ].uvs = object.geometry.uvs[j];
							face3Pool[ face3count ].color = face.color;

							this.renderList.push(face3Pool[face3count]);

							face3count++;
						}

					} else if ( face instanceof THREE.Face4 ) {

						v1 = object.geometry.vertices[ face.a ];
						v2 = object.geometry.vertices[ face.b ];
						v3 = object.geometry.vertices[ face.c ];
						v4 = object.geometry.vertices[ face.d ];

						if ( v1.__visible && v2.__visible && v3.__visible && v4.__visible && (object.doubleSided ||
						   ( ( v4.screen.x - v1.screen.x ) * ( v2.screen.y - v1.screen.y ) -
						   ( v4.screen.y - v1.screen.y ) * ( v2.screen.x - v1.screen.x ) > 0 ||
						   ( v2.screen.x - v3.screen.x ) * ( v4.screen.y - v3.screen.y ) -
						   ( v2.screen.y - v3.screen.y ) * ( v4.screen.x - v3.screen.x ) > 0 ) ) ) {

							face.screen.z = Math.max( v1.screen.z, Math.max( v2.screen.z, Math.max( v3.screen.z, v4.screen.z ) ) );

							if ( !face4Pool[ face4count ] ) {

								face4Pool[ face4count ] = new THREE.RenderableFace4();

							}

							face4Pool[ face4count ].v1.x = v1.screen.x;
							face4Pool[ face4count ].v1.y = v1.screen.y;
							face4Pool[ face4count ].v2.x = v2.screen.x;
							face4Pool[ face4count ].v2.y = v2.screen.y;
							face4Pool[ face4count ].v3.x = v3.screen.x;
							face4Pool[ face4count ].v3.y = v3.screen.y;
							face4Pool[ face4count ].v4.x = v4.screen.x;
							face4Pool[ face4count ].v4.y = v4.screen.y;
							face4Pool[ face4count ].z = face.screen.z;

							face4Pool[ face4count ].material = object.material;
							face4Pool[ face4count ].overdraw = object.overdraw;
							face4Pool[ face4count ].uvs = object.geometry.uvs[j];
							face4Pool[ face4count ].color = face.color;

							this.renderList.push( face4Pool[ face4count ] );

							face4count++;
						}
					}
				}

			} else if ( object instanceof THREE.Line ) {

				matrix.multiply( camera.matrix, object.matrix );

				verticesLength = object.geometry.vertices.length;

				for ( j = 0; j < verticesLength; j++ ) {

					vertex = object.geometry.vertices[ j ];
					vertex.screen.copy( vertex.position );

					matrix.transform( vertex.screen );
					camera.projectionMatrix.transform( vertex.screen );

					vertex.__visible = vertex.screen.z > 0 && vertex.screen.z < 1;

					if ( j > 0 ) {

						vertex2 = object.geometry.vertices[ j - 1 ];

						if ( vertex.__visible && vertex2.__visible ) {

							if ( !linePool[ lineCount ] ) {

								linePool[ lineCount ] = new THREE.RenderableLine();

							}

							linePool[ lineCount ].v1.x = vertex.screen.x;
							linePool[ lineCount ].v1.y = vertex.screen.y;
							linePool[ lineCount ].v2.x = vertex2.screen.x;
							linePool[ lineCount ].v2.y = vertex2.screen.y;
							linePool[ lineCount ].z = Math.max( vertex.screen.z, vertex2.screen.z );
							linePool[ lineCount ].material = object.material;

							this.renderList.push( linePool[lineCount] );

							lineCount++;

						}
					}
				}

			} else if ( object instanceof THREE.Particle ) {

				vector4.set( object.position.x, object.position.y, object.position.z, 1 );

				camera.matrix.transform( vector4 );
				camera.projectionMatrix.transform( vector4 );

				object.screen.set( vector4.x / vector4.w, vector4.y / vector4.w, vector4.z / vector4.w );

				if ( object.screen.z > 0 && object.screen.z < 1 ) {

					if ( !particlePool[ particleCount ] ) {

						particlePool[ particleCount ] = new THREE.RenderableParticle();

					}

					particlePool[ particleCount ].x = object.screen.x;
					particlePool[ particleCount ].y = object.screen.y;
					particlePool[ particleCount ].z = object.screen.z;

					particlePool[ particleCount ].size = object.size * Math.abs( vector4.x / vector4.w - ( vector4.x + camera.projectionMatrix.n11 ) / ( vector4.w + camera.projectionMatrix.n14 ) );
					particlePool[ particleCount ].material = object.material;
					particlePool[ particleCount ].color = object.color;

					this.renderList.push( particlePool[particleCount] );

					particleCount++;

				}

			}

		}

		this.renderList.sort( painterSort );

	};

};
