three.js/src/renderers/Renderer.js

THREE.Renderer = function() {

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

	matrix = new THREE.Matrix4();

	this.renderList;

	function sort(a, b) {
	
		return a.screenZ - b.screenZ;
	}

	this.project = function (scene, camera) {
	
		var i, j, vertex, face, object, v1, v2, v3, v4,
		face3count = 0, face4count = 0, particleCount = 0,
		camerafocus = camera.focus, focuszoom = camera.focus * camera.zoom,
		verticesLength = 0, facesLength = 0;

		this.renderList = [];

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

			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);

					vertex.screen.z = focuszoom / (camerafocus + vertex.screen.z);

					vertex.visible = vertex.screen.z > 0;					

					vertex.screen.x *= vertex.screen.z;
					vertex.screen.y *= vertex.screen.z; 
				}

				// faces

				facesLength = object.geometry.faces.length;

				for (j = 0; j < facesLength; j++) {
				
					face = object.geometry.faces[j];
					
					// TODO: Use normals for culling

					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 = (v1.screen.z + v2.screen.z + v3.screen.z) * 0.3;
							
							if (face3Pool[face3count] == null)
								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].screenZ = face.screen.z;
							
							face3Pool[face3count].color = face.color;
							face3Pool[face3count].material = object.material;

							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 = (v1.screen.z + v2.screen.z + v3.screen.z + v4.screen.z) * 0.25;

							if (face4Pool[face4count] == null)
								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].screenZ = face.screen.z;
							
							face4Pool[face4count].color = face.color;
							face4Pool[face4count].material = object.material;

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

							face4count++;
						}
					}
				}
				
			} else if (object instanceof THREE.Particle) {
			
				object.screen.copy(object.position);
				
				camera.matrix.transform(object.screen);
				
				object.screen.z = focuszoom / (camerafocus + object.screen.z);

				if (object.screen.z < 0) {
				
					continue;
				}

				object.screen.x *= object.screen.z;
				object.screen.y *= object.screen.z;

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

				particlePool[particleCount].x = object.screen.x;
				particlePool[particleCount].y = object.screen.y;
				particlePool[particleCount].screenZ = object.screen.z;
				
				particlePool[particleCount].size = object.size;				
				particlePool[particleCount].material = object.material;
				particlePool[particleCount].color = object.color;

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

		this.renderList.sort(sort);
	}
}