/**
 * @author mrdoob / http://mrdoob.com/
 * @author supereggbert / http://www.paulbrunt.co.uk/
 * @author julianwa / https://github.com/julianwa
 */

export const installProjector = ({ THREE }) => {
  const RenderableObject = function () {
  	this.id = 0;

  	this.object = null;
  	this.z = 0;
  	this.renderOrder = 0;
  };

  //

  const RenderableFace = function () {
  	this.id = 0;

  	this.v1 = new RenderableVertex();
  	this.v2 = new RenderableVertex();
  	this.v3 = new RenderableVertex();

  	this.normalModel = new THREE.Vector3();

  	this.vertexNormalsModel = [ new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3() ];
  	this.vertexNormalsLength = 0;

  	this.color = new THREE.Color();
  	this.material = null;
  	this.uvs = [ new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2() ];

  	this.z = 0;
  	this.renderOrder = 0;
  };

  //

  const RenderableVertex = function () {
  	this.position = new THREE.Vector3();
  	this.positionWorld = new THREE.Vector3();
  	this.positionScreen = new THREE.Vector4();

  	this.visible = true;
  };

  RenderableVertex.prototype.copy = function (vertex) {
  	this.positionWorld.copy(vertex.positionWorld);
  	this.positionScreen.copy(vertex.positionScreen);
  };

  //

  const RenderableLine = function () {
  	this.id = 0;

  	this.v1 = new RenderableVertex();
  	this.v2 = new RenderableVertex();

  	this.vertexColors = [ new THREE.Color(), new THREE.Color() ];
  	this.material = null;

  	this.z = 0;
  	this.renderOrder = 0;
  };

  //

  const RenderableSprite = function () {
  	this.id = 0;

  	this.object = null;

  	this.x = 0;
  	this.y = 0;
  	this.z = 0;

  	this.rotation = 0;
  	this.scale = new THREE.Vector2();

  	this.material = null;
  	this.renderOrder = 0;
  };

  //

  const Projector = function () {
  	var _object; var _objectCount; var _objectPool = []; var _objectPoolLength = 0;
  		var _vertex; var _vertexCount; var _vertexPool = []; var _vertexPoolLength = 0;
  		var _face; var _faceCount; var _facePool = []; var _facePoolLength = 0;
  		var _line; var _lineCount; var _linePool = []; var _linePoolLength = 0;
  		var _sprite; var _spriteCount; var _spritePool = []; var _spritePoolLength = 0;

  		var _renderData = { objects: [], lights: [], elements: [] };

  		var _vector3 = new THREE.Vector3();
  		var _vector4 = new THREE.Vector4();

  		var _clipBox = new THREE.Box3(new THREE.Vector3(-1, -1, -1), new THREE.Vector3(1, 1, 1));
  		var _boundingBox = new THREE.Box3();
  		var _points3 = new Array(3);

  		var _viewMatrix = new THREE.Matrix4();
  		var _viewProjectionMatrix = new THREE.Matrix4();

  		var _modelMatrix;
  		var _modelViewProjectionMatrix = new THREE.Matrix4();

  		var _normalMatrix = new THREE.Matrix3();

  		var _frustum = new THREE.Frustum();

  		var _clippedVertex1PositionScreen = new THREE.Vector4();
  		var _clippedVertex2PositionScreen = new THREE.Vector4();

  	//

  	this.projectVector = function (vector, camera) {
  		console.warn('THREE.Projector: .projectVector() is now vector.project().');
  		vector.project(camera);
  	};

  	this.unprojectVector = function (vector, camera) {
  		console.warn('THREE.Projector: .unprojectVector() is now vector.unproject().');
  		vector.unproject(camera);
  	};

  	this.pickingRay = function () {
  		console.error('THREE.Projector: .pickingRay() is now raycaster.setFromCamera().');
  	};

  	//

  	var RenderList = function () {
  		var normals = [];
  		var colors = [];
  		var uvs = [];

  		var object = null;
  		var material = null;

  		var normalMatrix = new THREE.Matrix3();

  		function setObject (value) {
  			object = value;
  			material = object.material;

  			normalMatrix.getNormalMatrix(object.matrixWorld);

  			normals.length = 0;
  			colors.length = 0;
  			uvs.length = 0;
  		}

  		function projectVertex (vertex) {
  			var position = vertex.position;
  			var positionWorld = vertex.positionWorld;
  			var positionScreen = vertex.positionScreen;

  			positionWorld.copy(position).applyMatrix4(_modelMatrix);
  			positionScreen.copy(positionWorld).applyMatrix4(_viewProjectionMatrix);

  			var invW = 1 / positionScreen.w;

  			positionScreen.x *= invW;
  			positionScreen.y *= invW;
  			positionScreen.z *= invW;

  			vertex.visible = positionScreen.x >= -1 && positionScreen.x <= 1 &&
  					 positionScreen.y >= -1 && positionScreen.y <= 1 &&
  					 positionScreen.z >= -1 && positionScreen.z <= 1;
  		}

  		function pushVertex (x, y, z) {
  			_vertex = getNextVertexInPool();
  			_vertex.position.set(x, y, z);

  			projectVertex(_vertex);
  		}

  		function pushNormal (x, y, z) {
  			normals.push(x, y, z);
  		}

  		function pushColor (r, g, b) {
  			colors.push(r, g, b);
  		}

  		function pushUv (x, y) {
  			uvs.push(x, y);
  		}

  		function checkTriangleVisibility (v1, v2, v3) {
  			if (v1.visible === true || v2.visible === true || v3.visible === true) return true;

  			_points3[ 0 ] = v1.positionScreen;
  			_points3[ 1 ] = v2.positionScreen;
  			_points3[ 2 ] = v3.positionScreen;

  			return _clipBox.intersectsBox(_boundingBox.setFromPoints(_points3));
  		}

  		function checkBackfaceCulling (v1, v2, v3) {
  			return ((v3.positionScreen.x - v1.positionScreen.x) *
  				    (v2.positionScreen.y - v1.positionScreen.y) -
  				    (v3.positionScreen.y - v1.positionScreen.y) *
  				    (v2.positionScreen.x - v1.positionScreen.x)) < 0;
  		}

  		function pushLine (a, b) {
  			var v1 = _vertexPool[ a ];
  			var v2 = _vertexPool[ b ];

  			// Clip

  			v1.positionScreen.copy(v1.position).applyMatrix4(_modelViewProjectionMatrix);
  			v2.positionScreen.copy(v2.position).applyMatrix4(_modelViewProjectionMatrix);

  			if (clipLine(v1.positionScreen, v2.positionScreen) === true) {
  				// Perform the perspective divide
  				v1.positionScreen.multiplyScalar(1 / v1.positionScreen.w);
  				v2.positionScreen.multiplyScalar(1 / v2.positionScreen.w);

  				_line = getNextLineInPool();
  				_line.id = object.id;
  				_line.v1.copy(v1);
  				_line.v2.copy(v2);
  				_line.z = Math.max(v1.positionScreen.z, v2.positionScreen.z);
  				_line.renderOrder = object.renderOrder;

  				_line.material = object.material;

  				if (object.material.vertexColors === THREE.VertexColors) {
  					_line.vertexColors[ 0 ].fromArray(colors, a * 3);
  					_line.vertexColors[ 1 ].fromArray(colors, b * 3);
  				}

  				_renderData.elements.push(_line);
  			}
  		}

  		function pushTriangle (a, b, c, material) {
  			var v1 = _vertexPool[ a ];
  			var v2 = _vertexPool[ b ];
  			var v3 = _vertexPool[ c ];

  			if (checkTriangleVisibility(v1, v2, v3) === false) return;

  			if (material.side === THREE.DoubleSide || checkBackfaceCulling(v1, v2, v3) === true) {
  				_face = getNextFaceInPool();

  				_face.id = object.id;
  				_face.v1.copy(v1);
  				_face.v2.copy(v2);
  				_face.v3.copy(v3);
  				_face.z = (v1.positionScreen.z + v2.positionScreen.z + v3.positionScreen.z) / 3;
  				_face.renderOrder = object.renderOrder;

  				// face normal
  				_vector3.subVectors(v3.position, v2.position);
  				_vector4.subVectors(v1.position, v2.position);
  				_vector3.cross(_vector4);
  				_face.normalModel.copy(_vector3);
  				_face.normalModel.applyMatrix3(normalMatrix).normalize();

  				for (var i = 0; i < 3; i++) {
  					var normal = _face.vertexNormalsModel[ i ];
  					normal.fromArray(normals, arguments[ i ] * 3);
  					normal.applyMatrix3(normalMatrix).normalize();

  					var uv = _face.uvs[ i ];
  					uv.fromArray(uvs, arguments[ i ] * 2);
  				}

  				_face.vertexNormalsLength = 3;

  				_face.material = material;

  				if (material.vertexColors === THREE.FaceColors || material.vertexColors === THREE.VertexColors) {
  					_face.color.fromArray(colors, a * 3);
  				}

  				_renderData.elements.push(_face);
  			}
  		}

  		return {
  			setObject: setObject,
  			projectVertex: projectVertex,
  			checkTriangleVisibility: checkTriangleVisibility,
  			checkBackfaceCulling: checkBackfaceCulling,
  			pushVertex: pushVertex,
  			pushNormal: pushNormal,
  			pushColor: pushColor,
  			pushUv: pushUv,
  			pushLine: pushLine,
  			pushTriangle: pushTriangle
  		};
  	};

  	var renderList = new RenderList();

  	function projectObject (object) {
  		if (object.visible === false) return;

  		if (object instanceof THREE.Light) {
  			_renderData.lights.push(object);
  		} else if (object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Points) {
  			if (object.material.visible === false) return;
  			if (object.frustumCulled === true && _frustum.intersectsObject(object) === false) return;

  			addObject(object);
  		} else if (object instanceof THREE.Sprite) {
  			if (object.material.visible === false) return;
  			if (object.frustumCulled === true && _frustum.intersectsSprite(object) === false) return;

  			addObject(object);
  		}

  		var children = object.children;

  		for (var i = 0, l = children.length; i < l; i++) {
  			projectObject(children[ i ]);
  		}
  	}

  	function addObject (object) {
  		_object = getNextObjectInPool();
  		_object.id = object.id;
  		_object.object = object;

  		_vector3.setFromMatrixPosition(object.matrixWorld);
  		_vector3.applyMatrix4(_viewProjectionMatrix);
  		_object.z = _vector3.z;
  		_object.renderOrder = object.renderOrder;

  		_renderData.objects.push(_object);
  	}

  	this.projectScene = function (scene, camera, sortObjects, sortElements) {
  		_faceCount = 0;
  		_lineCount = 0;
  		_spriteCount = 0;

  		_renderData.elements.length = 0;

  		if (scene.autoUpdate === true) scene.updateMatrixWorld();
  		if (camera.parent === null) camera.updateMatrixWorld();

  		_viewMatrix.copy(camera.matrixWorldInverse);
  		_viewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, _viewMatrix);

  		_frustum.setFromMatrix(_viewProjectionMatrix);

  		//

  		_objectCount = 0;

  		_renderData.objects.length = 0;
  		_renderData.lights.length = 0;

  		projectObject(scene);

  		if (sortObjects === true) {
  			_renderData.objects.sort(painterSort);
  		}

  		//

  		var objects = _renderData.objects;

  		for (var o = 0, ol = objects.length; o < ol; o++) {
  			var object = objects[ o ].object;
  			var geometry = object.geometry;

  			renderList.setObject(object);

  			_modelMatrix = object.matrixWorld;

  			_vertexCount = 0;

  			if (object instanceof THREE.Mesh) {
  				if (geometry instanceof THREE.BufferGeometry) {
  					var material = object.material;

  					var isMultiMaterial = Array.isArray(material);

  					var attributes = geometry.attributes;
  					var groups = geometry.groups;

  					if (attributes.position === undefined) continue;

  					var positions = attributes.position.array;

  					for (var i = 0, l = positions.length; i < l; i += 3) {
  						var x = positions[ i ];
  						var y = positions[ i + 1 ];
  						var z = positions[ i + 2 ];

  						if (material.morphTargets === true) {
  							var morphTargets = geometry.morphAttributes.position;
  							var morphInfluences = object.morphTargetInfluences;

  							for (var t = 0, tl = morphTargets.length; t < tl; t++) {
  								var influence = morphInfluences[ t ];

  								if (influence === 0) continue;

  								var target = morphTargets[ t ];

  								x += (target.getX(i / 3) - positions[ i ]) * influence;
  								y += (target.getY(i / 3) - positions[ i + 1 ]) * influence;
  								z += (target.getZ(i / 3) - positions[ i + 2 ]) * influence;
  							}
  						}

  						renderList.pushVertex(x, y, z);
  					}

  					if (attributes.normal !== undefined) {
  						var normals = attributes.normal.array;

  						for (var i = 0, l = normals.length; i < l; i += 3) {
  							renderList.pushNormal(normals[ i ], normals[ i + 1 ], normals[ i + 2 ]);
  						}
  					}

  					if (attributes.color !== undefined) {
  						var colors = attributes.color.array;

  						for (var i = 0, l = colors.length; i < l; i += 3) {
  							renderList.pushColor(colors[ i ], colors[ i + 1 ], colors[ i + 2 ]);
  						}
  					}

  					if (attributes.uv !== undefined) {
  						var uvs = attributes.uv.array;

  						for (var i = 0, l = uvs.length; i < l; i += 2) {
  							renderList.pushUv(uvs[ i ], uvs[ i + 1 ]);
  						}
  					}

  					if (geometry.index !== null) {
  						var indices = geometry.index.array;

  						if (groups.length > 0) {
  							for (var g = 0; g < groups.length; g++) {
  								var group = groups[ g ];

  								material = isMultiMaterial === true
  									 ? object.material[ group.materialIndex ]
  									 : object.material;

  								if (material === undefined) continue;

  								for (var i = group.start, l = group.start + group.count; i < l; i += 3) {
  									renderList.pushTriangle(indices[ i ], indices[ i + 1 ], indices[ i + 2 ], material);
  								}
  							}
  						} else {
  							for (var i = 0, l = indices.length; i < l; i += 3) {
  								renderList.pushTriangle(indices[ i ], indices[ i + 1 ], indices[ i + 2 ], material);
  							}
  						}
  					} else {
  						if (groups.length > 0) {
  							for (var g = 0; g < groups.length; g++) {
  								var group = groups[ g ];

  								material = isMultiMaterial === true
  									 ? object.material[ group.materialIndex ]
  									 : object.material;

  								if (material === undefined) continue;

  								for (var i = group.start, l = group.start + group.count; i < l; i += 3) {
  									renderList.pushTriangle(i, i + 1, i + 2, material);
  								}
  							}
  						} else {
  							for (var i = 0, l = positions.length / 3; i < l; i += 3) {
  								renderList.pushTriangle(i, i + 1, i + 2, material);
  							}
  						}
  					}
  				} else if (geometry instanceof THREE.Geometry) {
  					var vertices = geometry.vertices;
  					var faces = geometry.faces;
  					var faceVertexUvs = geometry.faceVertexUvs[ 0 ];

  					_normalMatrix.getNormalMatrix(_modelMatrix);

  					var material = object.material;

  					var isMultiMaterial = Array.isArray(material);

  					for (var v = 0, vl = vertices.length; v < vl; v++) {
  						var vertex = vertices[ v ];

  						_vector3.copy(vertex);

  						if (material.morphTargets === true) {
  							var morphTargets = geometry.morphTargets;
  							var morphInfluences = object.morphTargetInfluences;

  							for (var t = 0, tl = morphTargets.length; t < tl; t++) {
  								var influence = morphInfluences[ t ];

  								if (influence === 0) continue;

  								var target = morphTargets[ t ];
  								var targetVertex = target.vertices[ v ];

  								_vector3.x += (targetVertex.x - vertex.x) * influence;
  								_vector3.y += (targetVertex.y - vertex.y) * influence;
  								_vector3.z += (targetVertex.z - vertex.z) * influence;
  							}
  						}

  						renderList.pushVertex(_vector3.x, _vector3.y, _vector3.z);
  					}

  					for (var f = 0, fl = faces.length; f < fl; f++) {
  						var face = faces[ f ];

  						material = isMultiMaterial === true
  							 ? object.material[ face.materialIndex ]
  							 : object.material;

  						if (material === undefined) continue;

  						var side = material.side;

  						var v1 = _vertexPool[ face.a ];
  						var v2 = _vertexPool[ face.b ];
  						var v3 = _vertexPool[ face.c ];

  						if (renderList.checkTriangleVisibility(v1, v2, v3) === false) continue;

  						var visible = renderList.checkBackfaceCulling(v1, v2, v3);

  						if (side !== THREE.DoubleSide) {
  							if (side === THREE.FrontSide && visible === false) continue;
  							if (side === THREE.BackSide && visible === true) continue;
  						}

  						_face = getNextFaceInPool();

  						_face.id = object.id;
  						_face.v1.copy(v1);
  						_face.v2.copy(v2);
  						_face.v3.copy(v3);

  						_face.normalModel.copy(face.normal);

  						if (visible === false && (side === THREE.BackSide || side === THREE.DoubleSide)) {
  							_face.normalModel.negate();
  						}

  						_face.normalModel.applyMatrix3(_normalMatrix).normalize();

  						var faceVertexNormals = face.vertexNormals;

  						for (var n = 0, nl = Math.min(faceVertexNormals.length, 3); n < nl; n++) {
  							var normalModel = _face.vertexNormalsModel[ n ];
  							normalModel.copy(faceVertexNormals[ n ]);

  							if (visible === false && (side === THREE.BackSide || side === THREE.DoubleSide)) {
  								normalModel.negate();
  							}

  							normalModel.applyMatrix3(_normalMatrix).normalize();
  						}

  						_face.vertexNormalsLength = faceVertexNormals.length;

  						var vertexUvs = faceVertexUvs[ f ];

  						if (vertexUvs !== undefined) {
  							for (var u = 0; u < 3; u++) {
  								_face.uvs[ u ].copy(vertexUvs[ u ]);
  							}
  						}

  						_face.color = face.color;
  						_face.material = material;

  						_face.z = (v1.positionScreen.z + v2.positionScreen.z + v3.positionScreen.z) / 3;
  						_face.renderOrder = object.renderOrder;

  						_renderData.elements.push(_face);
  					}
  				}
  			} else if (object instanceof THREE.Line) {
  				_modelViewProjectionMatrix.multiplyMatrices(_viewProjectionMatrix, _modelMatrix);

  				if (geometry instanceof THREE.BufferGeometry) {
  					var attributes = geometry.attributes;

  					if (attributes.position !== undefined) {
  						var positions = attributes.position.array;

  						for (var i = 0, l = positions.length; i < l; i += 3) {
  							renderList.pushVertex(positions[ i ], positions[ i + 1 ], positions[ i + 2 ]);
  						}

  						if (attributes.color !== undefined) {
  							var colors = attributes.color.array;

  							for (var i = 0, l = colors.length; i < l; i += 3) {
  								renderList.pushColor(colors[ i ], colors[ i + 1 ], colors[ i + 2 ]);
  							}
  						}

  						if (geometry.index !== null) {
  							var indices = geometry.index.array;

  							for (var i = 0, l = indices.length; i < l; i += 2) {
  								renderList.pushLine(indices[ i ], indices[ i + 1 ]);
  							}
  						} else {
  							var step = object instanceof THREE.LineSegments ? 2 : 1;

  							for (var i = 0, l = (positions.length / 3) - 1; i < l; i += step) {
  								renderList.pushLine(i, i + 1);
  							}
  						}
  					}
  				} else if (geometry instanceof THREE.Geometry) {
  					var vertices = object.geometry.vertices;

  					if (vertices.length === 0) continue;

  					v1 = getNextVertexInPool();
  					v1.positionScreen.copy(vertices[ 0 ]).applyMatrix4(_modelViewProjectionMatrix);

  					var step = object instanceof THREE.LineSegments ? 2 : 1;

  					for (var v = 1, vl = vertices.length; v < vl; v++) {
  						v1 = getNextVertexInPool();
  						v1.positionScreen.copy(vertices[ v ]).applyMatrix4(_modelViewProjectionMatrix);

  						if ((v + 1) % step > 0) continue;

  						v2 = _vertexPool[ _vertexCount - 2 ];

  						_clippedVertex1PositionScreen.copy(v1.positionScreen);
  						_clippedVertex2PositionScreen.copy(v2.positionScreen);

  						if (clipLine(_clippedVertex1PositionScreen, _clippedVertex2PositionScreen) === true) {
  							// Perform the perspective divide
  							_clippedVertex1PositionScreen.multiplyScalar(1 / _clippedVertex1PositionScreen.w);
  							_clippedVertex2PositionScreen.multiplyScalar(1 / _clippedVertex2PositionScreen.w);

  							_line = getNextLineInPool();

  							_line.id = object.id;
  							_line.v1.positionScreen.copy(_clippedVertex1PositionScreen);
  							_line.v2.positionScreen.copy(_clippedVertex2PositionScreen);

  							_line.z = Math.max(_clippedVertex1PositionScreen.z, _clippedVertex2PositionScreen.z);
  							_line.renderOrder = object.renderOrder;

  							_line.material = object.material;

  							if (object.material.vertexColors === THREE.VertexColors) {
  								_line.vertexColors[ 0 ].copy(object.geometry.colors[ v ]);
  								_line.vertexColors[ 1 ].copy(object.geometry.colors[ v - 1 ]);
  							}

  							_renderData.elements.push(_line);
  						}
  					}
  				}
  			} else if (object instanceof THREE.Points) {
  				_modelViewProjectionMatrix.multiplyMatrices(_viewProjectionMatrix, _modelMatrix);

  				if (geometry instanceof THREE.Geometry) {
  					var vertices = object.geometry.vertices;

  					for (var v = 0, vl = vertices.length; v < vl; v++) {
  						var vertex = vertices[ v ];

  						_vector4.set(vertex.x, vertex.y, vertex.z, 1);
  						_vector4.applyMatrix4(_modelViewProjectionMatrix);

  						pushPoint(_vector4, object, camera);
  					}
  				} else if (geometry instanceof THREE.BufferGeometry) {
  					var attributes = geometry.attributes;

  					if (attributes.position !== undefined) {
  						var positions = attributes.position.array;

  						for (var i = 0, l = positions.length; i < l; i += 3) {
  							_vector4.set(positions[ i ], positions[ i + 1 ], positions[ i + 2 ], 1);
  							_vector4.applyMatrix4(_modelViewProjectionMatrix);

  							pushPoint(_vector4, object, camera);
  						}
  					}
  				}
  			} else if (object instanceof THREE.Sprite) {
  				object.modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, object.matrixWorld);
  				_vector4.set(_modelMatrix.elements[ 12 ], _modelMatrix.elements[ 13 ], _modelMatrix.elements[ 14 ], 1);
  				_vector4.applyMatrix4(_viewProjectionMatrix);

  				pushPoint(_vector4, object, camera);
  			}
  		}

  		if (sortElements === true) {
  			_renderData.elements.sort(painterSort);
  		}

  		return _renderData;
  	};

  	function pushPoint (_vector4, object, camera) {
  		var invW = 1 / _vector4.w;

  		_vector4.z *= invW;

  		if (_vector4.z >= -1 && _vector4.z <= 1) {
  			_sprite = getNextSpriteInPool();
  			_sprite.id = object.id;
  			_sprite.x = _vector4.x * invW;
  			_sprite.y = _vector4.y * invW;
  			_sprite.z = _vector4.z;
  			_sprite.renderOrder = object.renderOrder;
  			_sprite.object = object;

  			_sprite.rotation = object.rotation;

  			_sprite.scale.x = object.scale.x * Math.abs(_sprite.x - (_vector4.x + camera.projectionMatrix.elements[ 0 ]) / (_vector4.w + camera.projectionMatrix.elements[ 12 ]));
  			_sprite.scale.y = object.scale.y * Math.abs(_sprite.y - (_vector4.y + camera.projectionMatrix.elements[ 5 ]) / (_vector4.w + camera.projectionMatrix.elements[ 13 ]));

  			_sprite.material = object.material;

  			_renderData.elements.push(_sprite);
  		}
  	}

  	// Pools

  	function getNextObjectInPool () {
  		if (_objectCount === _objectPoolLength) {
  			var object = new RenderableObject();
  			_objectPool.push(object);
  			_objectPoolLength++;
  			_objectCount++;
  			return object;
  		}

  		return _objectPool[ _objectCount++ ];
  	}

  	function getNextVertexInPool () {
  		if (_vertexCount === _vertexPoolLength) {
  			var vertex = new RenderableVertex();
  			_vertexPool.push(vertex);
  			_vertexPoolLength++;
  			_vertexCount++;
  			return vertex;
  		}

  		return _vertexPool[ _vertexCount++ ];
  	}

  	function getNextFaceInPool () {
  		if (_faceCount === _facePoolLength) {
  			var face = new RenderableFace();
  			_facePool.push(face);
  			_facePoolLength++;
  			_faceCount++;
  			return face;
  		}

  		return _facePool[ _faceCount++ ];
  	}

  	function getNextLineInPool () {
  		if (_lineCount === _linePoolLength) {
  			var line = new RenderableLine();
  			_linePool.push(line);
  			_linePoolLength++;
  			_lineCount++;
  			return line;
  		}

  		return _linePool[ _lineCount++ ];
  	}

  	function getNextSpriteInPool () {
  		if (_spriteCount === _spritePoolLength) {
  			var sprite = new RenderableSprite();
  			_spritePool.push(sprite);
  			_spritePoolLength++;
  			_spriteCount++;
  			return sprite;
  		}

  		return _spritePool[ _spriteCount++ ];
  	}

  	//

  	function painterSort (a, b) {
  		if (a.renderOrder !== b.renderOrder) {
  			return a.renderOrder - b.renderOrder;
  		} else if (a.z !== b.z) {
  			return b.z - a.z;
  		} else if (a.id !== b.id) {
  			return a.id - b.id;
  		} else {
  			return 0;
  		}
  	}

  	function clipLine (s1, s2) {
  		var alpha1 = 0; var alpha2 = 1;

  			// Calculate the boundary coordinate of each vertex for the near and far clip planes,
  			// Z = -1 and Z = +1, respectively.

  			var bc1near = s1.z + s1.w;
  			var bc2near = s2.z + s2.w;
  			var bc1far = -s1.z + s1.w;
  			var bc2far = -s2.z + s2.w;

  		if (bc1near >= 0 && bc2near >= 0 && bc1far >= 0 && bc2far >= 0) {
  			// Both vertices lie entirely within all clip planes.
  			return true;
  		} else if ((bc1near < 0 && bc2near < 0) || (bc1far < 0 && bc2far < 0)) {
  			// Both vertices lie entirely outside one of the clip planes.
  			return false;
  		} else {
  			// The line segment spans at least one clip plane.

  			if (bc1near < 0) {
  				// v1 lies outside the near plane, v2 inside
  				alpha1 = Math.max(alpha1, bc1near / (bc1near - bc2near));
  			} else if (bc2near < 0) {
  				// v2 lies outside the near plane, v1 inside
  				alpha2 = Math.min(alpha2, bc1near / (bc1near - bc2near));
  			}

  			if (bc1far < 0) {
  				// v1 lies outside the far plane, v2 inside
  				alpha1 = Math.max(alpha1, bc1far / (bc1far - bc2far));
  			} else if (bc2far < 0) {
  				// v2 lies outside the far plane, v2 inside
  				alpha2 = Math.min(alpha2, bc1far / (bc1far - bc2far));
  			}

  			if (alpha2 < alpha1) {
  				// The line segment spans two boundaries, but is outside both of them.
  				// (This can't happen when we're only clipping against just near/far but good
  				//  to leave the check here for future usage if other clip planes are added.)
  				return false;
  			} else {
  				// Update the s1 and s2 vertices to match the clipped line segment.
  				s1.lerp(s2, alpha1);
  				s2.lerp(s1, 1 - alpha2);

  				return true;
  			}
  		}
  	}
  };

  return { Projector, RenderableObject, RenderableFace, RenderableVertex, RenderableLine, RenderableSprite };
};
