11 年之前 · 662eaa17f1
--- a/examples/canvas_ascii_effect.html
+++ b/examples/canvas_ascii_effect.html
@@ -19,9 +19,11 @@
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				 		<script src="js/controls/TrackballControls.js"></script>
			
 
				-
			
 
				 		<script src="js/effects/AsciiEffect.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_camera_orthographic.html
+++ b/examples/canvas_camera_orthographic.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_camera_orthographic2.html
+++ b/examples/canvas_camera_orthographic2.html
@@ -21,8 +21,12 @@
 
				 	<body>
			
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				+
			
 
				 		<script src="js/cameras/CombinedCamera.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<div style="position: absolute; top: 10px; width: 100%; text-align: center; ">
			
--- a/examples/canvas_effects_stereo.html
+++ b/examples/canvas_effects_stereo.html
@@ -17,8 +17,12 @@
 
				 	<body>
			
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				+
			
 
				 		<script src="js/effects/StereoEffect.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_geometry_birds.html
+++ b/examples/canvas_geometry_birds.html
@@ -29,10 +29,14 @@
 
				 		<div id="info"><a href="http://threejs.org" target="_blank">three.js</a> - birds demo</div>
			
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				-		<script src="obj/Bird.js"></script>
			
 
				+
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				 
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				+		<script src="obj/Bird.js"></script>
			
 
				+
			
 
				 		<script>
			
 
				 
			
 
				 			// Based on http://www.openprocessing.org/visuals/?visualID=6910
			
--- a/examples/canvas_geometry_cube.html
+++ b/examples/canvas_geometry_cube.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_geometry_earth.html
+++ b/examples/canvas_geometry_earth.html
@@ -35,6 +35,10 @@
 
				 		<div id="info"><a href="http://threejs.org" target="_blank">three.js</a> - earth demo</div>
			
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				+
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_geometry_hierarchy.html
+++ b/examples/canvas_geometry_hierarchy.html
@@ -18,6 +18,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_geometry_nurbs.html
+++ b/examples/canvas_geometry_nurbs.html
@@ -27,8 +27,13 @@
 
				 		<div id="info"><a href="http://threejs.org" target="_blank">three.js</a> - NURBS curve example</div>
			
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				+
			
 
				 		<script src="js/curves/NURBSCurve.js"></script>
			
 
				 		<script src="js/curves/NURBSUtils.js"></script>
			
 
				+
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_geometry_panorama.html
+++ b/examples/canvas_geometry_panorama.html
@@ -34,6 +34,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script>
			
 
				 
			
 
				 			var camera, scene, renderer;
			
--- a/examples/canvas_geometry_panorama_fisheye.html
+++ b/examples/canvas_geometry_panorama_fisheye.html
@@ -34,6 +34,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script>
			
 
				 
			
 
				 			var camera, scene, renderer;
			
--- a/examples/canvas_geometry_shapes.html
+++ b/examples/canvas_geometry_shapes.html
@@ -26,6 +26,10 @@
 
				 		<div id="info"><a href="http://threejs.org" target="_blank">three.js</a> - shape geometry</div>
			
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				+
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_geometry_terrain.html
+++ b/examples/canvas_geometry_terrain.html
@@ -36,9 +36,13 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				-		<script src="js/ImprovedNoise.js"></script>
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				+		<script src="js/ImprovedNoise.js"></script>
			
 
				+
			
 
				 		<script>
			
 
				 
			
 
				 			var container, stats;
			
--- a/examples/canvas_geometry_text.html
+++ b/examples/canvas_geometry_text.html
@@ -18,6 +18,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<!-- load the font file from canvas-text -->
			
--- a/examples/canvas_interactive_cubes.html
+++ b/examples/canvas_interactive_cubes.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_interactive_cubes_tween.html
+++ b/examples/canvas_interactive_cubes_tween.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 		<script src="js/libs/tween.min.js"></script>
			
 
				 
			
--- a/examples/canvas_interactive_particles.html
+++ b/examples/canvas_interactive_particles.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_interactive_voxelpainter.html
+++ b/examples/canvas_interactive_voxelpainter.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_lights_pointlights.html
+++ b/examples/canvas_lights_pointlights.html
@@ -41,6 +41,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script>
			
 
				 
			
 
				 			var camera, scene, renderer,
			
--- a/examples/canvas_lines.html
+++ b/examples/canvas_lines.html
@@ -20,6 +20,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script>
			
 
				 
			
 
				 			var mouseX = 0, mouseY = 0,
			
--- a/examples/canvas_lines_colors.html
+++ b/examples/canvas_lines_colors.html
@@ -46,6 +46,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/Detector.js"></script>
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 		<script src="js/geometries/hilbert3D.js"></script>
			
--- a/examples/canvas_lines_colors_2d.html
+++ b/examples/canvas_lines_colors_2d.html
@@ -46,6 +46,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/Detector.js"></script>
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 		<script src="js/geometries/hilbert2D.js"></script>
			
--- a/examples/canvas_lines_dashed.html
+++ b/examples/canvas_lines_dashed.html
@@ -33,6 +33,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/geometries/hilbert3D.js"></script>
			
 
				 
			
 
				 		<script src="js/Detector.js"></script>
			
--- a/examples/canvas_lines_sphere.html
+++ b/examples/canvas_lines_sphere.html
@@ -20,6 +20,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script>
			
 
				 
			
 
				 			var SCREEN_WIDTH = window.innerWidth,
			
--- a/examples/canvas_materials.html
+++ b/examples/canvas_materials.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_materials_depth.html
+++ b/examples/canvas_materials_depth.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_materials_normal.html
+++ b/examples/canvas_materials_normal.html
@@ -41,6 +41,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script>
			
 
				 
			
 
				 			var camera, scene, renderer,
			
--- a/examples/canvas_materials_reflection.html
+++ b/examples/canvas_materials_reflection.html
@@ -40,6 +40,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script>
			
 
				 
			
 
				 			var camera, scene, renderer,
			
--- a/examples/canvas_materials_video.html
+++ b/examples/canvas_materials_video.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<video id="video" autoplay style="display:none">
			
--- a/examples/canvas_morphtargets_horse.html
+++ b/examples/canvas_morphtargets_horse.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_particles_floor.html
+++ b/examples/canvas_particles_floor.html
@@ -20,6 +20,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_particles_random.html
+++ b/examples/canvas_particles_random.html
@@ -20,6 +20,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_particles_shapes.html
+++ b/examples/canvas_particles_shapes.html
@@ -18,6 +18,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 		<script src="js/libs/tween.min.js"></script>
			
 
				 		<script src="js/Sparks.js"></script>
			
--- a/examples/canvas_particles_sprites.html
+++ b/examples/canvas_particles_sprites.html
@@ -20,6 +20,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 		<script src="js/libs/tween.min.js"></script>
			
 
				 
			
--- a/examples/canvas_particles_waves.html
+++ b/examples/canvas_particles_waves.html
@@ -19,6 +19,9 @@
 
				 	<body>
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_performance.html
+++ b/examples/canvas_performance.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/canvas_sandbox.html
+++ b/examples/canvas_sandbox.html
@@ -17,6 +17,9 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/css3d_sandbox.html
+++ b/examples/css3d_sandbox.html
@@ -90,7 +90,7 @@
 
				 
			
 
				 				//
			
 
				 
			
 
				-				renderer = new THREE.CanvasRenderer();
			
 
				+				renderer = new THREE.WebGLRenderer();
			
 
				 				renderer.setClearColor( 0xf0f0f0 );
			
 
				 				renderer.setSize( window.innerWidth, window.innerHeight );
			
 
				 				document.body.appendChild( renderer.domElement );
			
--- a/examples/index.html
+++ b/examples/index.html
@@ -97,7 +97,7 @@
 
				 				<h1><a href="http://threejs.org">three.js</a> / examples</h1>
			
 
				 			</div>
			
 
				 		</div>
			
 
				-		<iframe id="viewer"></iframe>
			
 
				+		<iframe id="viewer" allowfullscreen></iframe>
			
 
				 
			
 
				 		<script>
			
 
				 
			
@@ -160,6 +160,7 @@
 
				 				"webgl_interactive_cubes",
			
 
				 				"webgl_interactive_cubes_gpu",
			
 
				 				"webgl_interactive_draggablecubes",
			
 
				+				"webgl_interactive_lines",
			
 
				 				"webgl_interactive_particles",
			
 
				 				"webgl_interactive_raycasting_pointcloud",
			
 
				 				"webgl_interactive_voxelpainter",
			
@@ -322,7 +323,6 @@
 
				 				"canvas_geometry_text",
			
 
				 				"canvas_interactive_cubes",
			
 
				 				"canvas_interactive_cubes_tween",
			
 
				-				"canvas_interactive_lines",
			
 
				 				"canvas_interactive_particles",
			
 
				 				"canvas_interactive_voxelpainter",
			
 
				 				"canvas_lights_pointlights",
			
@@ -348,6 +348,7 @@
 
				 				"raytracing_sandbox"
			
 
				 			],
			
 
				 			"software": [
			
 
				+				"software_geometry_earth",
			
 
				 				"software_sandbox"
			
 
				 			]
			
 
				 		};
			
--- a/examples/js/renderers/CanvasRenderer.js
+++ b/examples/js/renderers/CanvasRenderer.js
@@ -2,6 +2,36 @@
 
				  * @author mrdoob / http://mrdoob.com/
			
 
				  */
			
 
				 
			
 
				+THREE.SpriteCanvasMaterial = function ( parameters ) {
			
 
				+
			
 
				+	THREE.Material.call( this );
			
 
				+
			
 
				+	this.type = 'SpriteCanvasMaterial';
			
 
				+
			
 
				+	this.color = new THREE.Color( 0xffffff );
			
 
				+	this.program = function ( context, color ) {};
			
 
				+
			
 
				+	this.setValues( parameters );
			
 
				+
			
 
				+};
			
 
				+
			
 
				+THREE.SpriteCanvasMaterial.prototype = Object.create( THREE.Material.prototype );
			
 
				+
			
 
				+THREE.SpriteCanvasMaterial.prototype.clone = function () {
			
 
				+
			
 
				+	var material = new THREE.SpriteCanvasMaterial();
			
 
				+
			
 
				+	THREE.Material.prototype.clone.call( this, material );
			
 
				+
			
 
				+	material.color.copy( this.color );
			
 
				+	material.program = this.program;
			
 
				+
			
 
				+	return material;
			
 
				+
			
 
				+};
			
 
				+
			
 
				+//
			
 
				+
			
 
				 THREE.CanvasRenderer = function ( parameters ) {
			
 
				 
			
 
				 	console.log( 'THREE.CanvasRenderer', THREE.REVISION );
			
@@ -12,7 +42,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
				 
			
 
				 	var _this = this,
			
 
				 	_renderData, _elements, _lights,
			
 
				-	_projector = new THREE.Projector(),
			
 
				+	_renderer = new THREE.Renderer(),
			
 
				 
			
 
				 	_canvas = parameters.canvas !== undefined
			
 
				 			 ? parameters.canvas
			
@@ -183,7 +213,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
				 		this.setClearColor( hex, alpha );
			
 
				 
			
 
				 	};
			
 
				-	
			
 
				+
			
 
				 	this.getClearColor = function () {
			
 
				 
			
 
				 		return _clearColor;
			
@@ -270,7 +300,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
				 		_context.setTransform( _viewportWidth / _canvasWidth, 0, 0, - _viewportHeight / _canvasHeight, _viewportX, _canvasHeight - _viewportY );
			
 
				 		_context.translate( _canvasWidthHalf, _canvasHeightHalf );
			
 
				 
			
 
				-		_renderData = _projector.projectScene( scene, camera, this.sortObjects, this.sortElements );
			
 
				+		_renderData = _renderer.projectScene( scene, camera, this.sortObjects, this.sortElements );
			
 
				 		_elements = _renderData.elements;
			
 
				 		_lights = _renderData.lights;
			
 
				 		_camera = camera;
			
--- a/examples/js/renderers/Renderer.js
+++ b/examples/js/renderers/Renderer.js
@@ -0,0 +1,910 @@
 
				+/**
			
 
				+ * @author mrdoob / http://mrdoob.com/
			
 
				+ * @author supereggbert / http://www.paulbrunt.co.uk/
			
 
				+ * @author julianwa / https://github.com/julianwa
			
 
				+ */
			
 
				+
			
 
				+THREE.RenderableObject = function () {
			
 
				+
			
 
				+	this.id = 0;
			
 
				+
			
 
				+	this.object = null;
			
 
				+	this.z = 0;
			
 
				+
			
 
				+};
			
 
				+
			
 
				+//
			
 
				+
			
 
				+THREE.RenderableFace = function () {
			
 
				+
			
 
				+	this.id = 0;
			
 
				+
			
 
				+	this.v1 = new THREE.RenderableVertex();
			
 
				+	this.v2 = new THREE.RenderableVertex();
			
 
				+	this.v3 = new THREE.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;
			
 
				+
			
 
				+};
			
 
				+
			
 
				+//
			
 
				+
			
 
				+THREE.RenderableVertex = function () {
			
 
				+
			
 
				+	this.position = new THREE.Vector3();
			
 
				+	this.positionWorld = new THREE.Vector3();
			
 
				+	this.positionScreen = new THREE.Vector4();
			
 
				+
			
 
				+	this.visible = true;
			
 
				+
			
 
				+};
			
 
				+
			
 
				+THREE.RenderableVertex.prototype.copy = function ( vertex ) {
			
 
				+
			
 
				+	this.positionWorld.copy( vertex.positionWorld );
			
 
				+	this.positionScreen.copy( vertex.positionScreen );
			
 
				+
			
 
				+};
			
 
				+
			
 
				+//
			
 
				+
			
 
				+THREE.RenderableLine = function () {
			
 
				+
			
 
				+	this.id = 0;
			
 
				+
			
 
				+	this.v1 = new THREE.RenderableVertex();
			
 
				+	this.v2 = new THREE.RenderableVertex();
			
 
				+
			
 
				+	this.vertexColors = [ new THREE.Color(), new THREE.Color() ];
			
 
				+	this.material = null;
			
 
				+
			
 
				+	this.z = 0;
			
 
				+
			
 
				+};
			
 
				+
			
 
				+//
			
 
				+
			
 
				+THREE.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;
			
 
				+
			
 
				+};
			
 
				+
			
 
				+//
			
 
				+
			
 
				+THREE.Renderer = function () {
			
 
				+
			
 
				+	var _object, _objectCount, _objectPool = [], _objectPoolLength = 0,
			
 
				+	_vertex, _vertexCount, _vertexPool = [], _vertexPoolLength = 0,
			
 
				+	_face, _faceCount, _facePool = [], _facePoolLength = 0,
			
 
				+	_line, _lineCount, _linePool = [], _linePoolLength = 0,
			
 
				+	_sprite, _spriteCount, _spritePool = [], _spritePoolLength = 0,
			
 
				+
			
 
				+	_renderData = { objects: [], lights: [], elements: [] },
			
 
				+
			
 
				+	_vA = new THREE.Vector3(),
			
 
				+	_vB = new THREE.Vector3(),
			
 
				+	_vC = new THREE.Vector3(),
			
 
				+
			
 
				+	_vector3 = new THREE.Vector3(),
			
 
				+	_vector4 = new THREE.Vector4(),
			
 
				+
			
 
				+	_clipBox = new THREE.Box3( new THREE.Vector3( - 1, - 1, - 1 ), new THREE.Vector3( 1, 1, 1 ) ),
			
 
				+	_boundingBox = new THREE.Box3(),
			
 
				+	_points3 = new Array( 3 ),
			
 
				+	_points4 = new Array( 4 ),
			
 
				+
			
 
				+	_viewMatrix = new THREE.Matrix4(),
			
 
				+	_viewProjectionMatrix = new THREE.Matrix4(),
			
 
				+
			
 
				+	_modelMatrix,
			
 
				+	_modelViewProjectionMatrix = new THREE.Matrix4(),
			
 
				+
			
 
				+	_normalMatrix = new THREE.Matrix3(),
			
 
				+
			
 
				+	_frustum = new THREE.Frustum(),
			
 
				+
			
 
				+	_clippedVertex1PositionScreen = new THREE.Vector4(),
			
 
				+	_clippedVertex2PositionScreen = new THREE.Vector4();
			
 
				+
			
 
				+	var RenderList = function () {
			
 
				+
			
 
				+		var normals = [];
			
 
				+		var uvs = [];
			
 
				+
			
 
				+		var object = null;
			
 
				+		var material = null;
			
 
				+
			
 
				+		var normalMatrix = new THREE.Matrix3();
			
 
				+
			
 
				+		var setObject = function ( value ) {
			
 
				+
			
 
				+			object = value;
			
 
				+			material = object.material;
			
 
				+
			
 
				+			normalMatrix.getNormalMatrix( object.matrixWorld );
			
 
				+
			
 
				+			normals.length = 0;
			
 
				+			uvs.length = 0;
			
 
				+
			
 
				+		};
			
 
				+
			
 
				+		var projectVertex = function ( 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;
			
 
				+
			
 
				+		};
			
 
				+
			
 
				+		var pushVertex = function ( x, y, z ) {
			
 
				+
			
 
				+			_vertex = getNextVertexInPool();
			
 
				+			_vertex.position.set( x, y, z );
			
 
				+
			
 
				+			projectVertex( _vertex );
			
 
				+
			
 
				+		};
			
 
				+
			
 
				+		var pushNormal = function ( x, y, z ) {
			
 
				+
			
 
				+			normals.push( x, y, z );
			
 
				+
			
 
				+		};
			
 
				+
			
 
				+		var pushUv = function ( x, y ) {
			
 
				+
			
 
				+			uvs.push( x, y );
			
 
				+
			
 
				+		};
			
 
				+
			
 
				+		var checkTriangleVisibility = function ( 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.isIntersectionBox( _boundingBox.setFromPoints( _points3 ) );
			
 
				+
			
 
				+		};
			
 
				+
			
 
				+		var checkBackfaceCulling = function ( 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;
			
 
				+
			
 
				+		};
			
 
				+
			
 
				+		var pushLine = function ( a, b ) {
			
 
				+
			
 
				+			var v1 = _vertexPool[ a ];
			
 
				+			var v2 = _vertexPool[ b ];
			
 
				+
			
 
				+			_line = getNextLineInPool();
			
 
				+
			
 
				+			_line.id = object.id;
			
 
				+			_line.v1.copy( v1 );
			
 
				+			_line.v2.copy( v2 );
			
 
				+			_line.z = ( v1.positionScreen.z + v2.positionScreen.z ) / 2;
			
 
				+
			
 
				+			_line.material = object.material;
			
 
				+
			
 
				+			_renderData.elements.push( _line );
			
 
				+
			
 
				+		};
			
 
				+
			
 
				+		var pushTriangle = function ( a, b, c ) {
			
 
				+
			
 
				+			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;
			
 
				+
			
 
				+				for ( var i = 0; i < 3; i ++ ) {
			
 
				+
			
 
				+					var offset = arguments[ i ] * 3;
			
 
				+					var normal = _face.vertexNormalsModel[ i ];
			
 
				+
			
 
				+					normal.set( normals[ offset ], normals[ offset + 1 ], normals[ offset + 2 ] );
			
 
				+					normal.applyMatrix3( normalMatrix ).normalize();
			
 
				+
			
 
				+					var offset2 = arguments[ i ] * 2;
			
 
				+
			
 
				+					var uv = _face.uvs[ i ];
			
 
				+					uv.set( uvs[ offset2 ], uvs[ offset2 + 1 ] );
			
 
				+
			
 
				+				}
			
 
				+
			
 
				+				_face.vertexNormalsLength = 3;
			
 
				+
			
 
				+				_face.material = object.material;
			
 
				+
			
 
				+				_renderData.elements.push( _face );
			
 
				+
			
 
				+			}
			
 
				+
			
 
				+		};
			
 
				+
			
 
				+		return {
			
 
				+			setObject: setObject,
			
 
				+			projectVertex: projectVertex,
			
 
				+			checkTriangleVisibility: checkTriangleVisibility,
			
 
				+			checkBackfaceCulling: checkBackfaceCulling,
			
 
				+			pushVertex: pushVertex,
			
 
				+			pushNormal: pushNormal,
			
 
				+			pushUv: pushUv,
			
 
				+			pushLine: pushLine,
			
 
				+			pushTriangle: pushTriangle
			
 
				+		}
			
 
				+
			
 
				+	};
			
 
				+
			
 
				+	var renderList = new RenderList();
			
 
				+
			
 
				+	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 === undefined ) camera.updateMatrixWorld();
			
 
				+
			
 
				+		_viewMatrix.copy( camera.matrixWorldInverse.getInverse( camera.matrixWorld ) );
			
 
				+		_viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, _viewMatrix );
			
 
				+
			
 
				+		_frustum.setFromMatrix( _viewProjectionMatrix );
			
 
				+
			
 
				+		//
			
 
				+
			
 
				+		_objectCount = 0;
			
 
				+
			
 
				+		_renderData.objects.length = 0;
			
 
				+		_renderData.lights.length = 0;
			
 
				+
			
 
				+		scene.traverseVisible( function ( object ) {
			
 
				+
			
 
				+			if ( object instanceof THREE.Light ) {
			
 
				+
			
 
				+				_renderData.lights.push( object );
			
 
				+
			
 
				+			} else if ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Sprite ) {
			
 
				+
			
 
				+				if ( object.material.visible === false ) return;
			
 
				+
			
 
				+				if ( object.frustumCulled === false || _frustum.intersectsObject( object ) === true ) {
			
 
				+
			
 
				+					_object = getNextObjectInPool();
			
 
				+					_object.id = object.id;
			
 
				+					_object.object = object;
			
 
				+
			
 
				+					if ( object.renderDepth !== null ) {
			
 
				+
			
 
				+						_object.z = object.renderDepth;
			
 
				+
			
 
				+					} else {
			
 
				+
			
 
				+						_vector3.setFromMatrixPosition( object.matrixWorld );
			
 
				+						_vector3.applyProjection( _viewProjectionMatrix );
			
 
				+						_object.z = _vector3.z;
			
 
				+
			
 
				+					}
			
 
				+
			
 
				+					_renderData.objects.push( _object );
			
 
				+
			
 
				+				}
			
 
				+
			
 
				+			}
			
 
				+
			
 
				+		} );
			
 
				+
			
 
				+		if ( sortObjects === true ) {
			
 
				+
			
 
				+			_renderData.objects.sort( painterSort );
			
 
				+
			
 
				+		}
			
 
				+
			
 
				+		//
			
 
				+
			
 
				+		for ( var o = 0, ol = _renderData.objects.length; o < ol; o ++ ) {
			
 
				+
			
 
				+			var object = _renderData.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 attributes = geometry.attributes;
			
 
				+					var offsets = geometry.offsets;
			
 
				+
			
 
				+					if ( attributes.position === undefined ) continue;
			
 
				+
			
 
				+					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.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.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 ( attributes.index !== undefined ) {
			
 
				+
			
 
				+						var indices = attributes.index.array;
			
 
				+
			
 
				+						if ( offsets.length > 0 ) {
			
 
				+
			
 
				+							for ( var o = 0; o < offsets.length; o ++ ) {
			
 
				+
			
 
				+								var offset = offsets[ o ];
			
 
				+								var index = offset.index;
			
 
				+
			
 
				+								for ( var i = offset.start, l = offset.start + offset.count; i < l; i += 3 ) {
			
 
				+
			
 
				+									renderList.pushTriangle( indices[ i ] + index, indices[ i + 1 ] + index, indices[ i + 2 ] + index );
			
 
				+
			
 
				+								}
			
 
				+
			
 
				+							}
			
 
				+
			
 
				+						} else {
			
 
				+
			
 
				+							for ( var i = 0, l = indices.length; i < l; i += 3 ) {
			
 
				+
			
 
				+								renderList.pushTriangle( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] );
			
 
				+
			
 
				+							}
			
 
				+
			
 
				+						}
			
 
				+
			
 
				+					} else {
			
 
				+
			
 
				+						for ( var i = 0, l = positions.length / 3; i < l; i += 3 ) {
			
 
				+
			
 
				+							renderList.pushTriangle( i, i + 1, i + 2 );
			
 
				+
			
 
				+						}
			
 
				+
			
 
				+					}
			
 
				+
			
 
				+				} else if ( geometry instanceof THREE.Geometry ) {
			
 
				+
			
 
				+					var vertices = geometry.vertices;
			
 
				+					var faces = geometry.faces;
			
 
				+					var faceVertexUvs = geometry.faceVertexUvs[ 0 ];
			
 
				+
			
 
				+					_normalMatrix.getNormalMatrix( _modelMatrix );
			
 
				+
			
 
				+					var isFaceMaterial = object.material instanceof THREE.MeshFaceMaterial;
			
 
				+					var objectMaterials = isFaceMaterial === true ? object.material : null;
			
 
				+
			
 
				+					for ( var v = 0, vl = vertices.length; v < vl; v ++ ) {
			
 
				+
			
 
				+						var vertex = vertices[ v ];
			
 
				+						renderList.pushVertex( vertex.x, vertex.y, vertex.z );
			
 
				+
			
 
				+					}
			
 
				+
			
 
				+					for ( var f = 0, fl = faces.length; f < fl; f ++ ) {
			
 
				+
			
 
				+						var face = faces[ f ];
			
 
				+
			
 
				+						var material = isFaceMaterial === true
			
 
				+							 ? objectMaterials.materials[ 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 ( material.morphTargets === true ) {
			
 
				+
			
 
				+							var morphTargets = geometry.morphTargets;
			
 
				+							var morphInfluences = object.morphTargetInfluences;
			
 
				+
			
 
				+							var v1p = v1.position;
			
 
				+							var v2p = v2.position;
			
 
				+							var v3p = v3.position;
			
 
				+
			
 
				+							_vA.set( 0, 0, 0 );
			
 
				+							_vB.set( 0, 0, 0 );
			
 
				+							_vC.set( 0, 0, 0 );
			
 
				+
			
 
				+							for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {
			
 
				+
			
 
				+								var influence = morphInfluences[ t ];
			
 
				+
			
 
				+								if ( influence === 0 ) continue;
			
 
				+
			
 
				+								var targets = morphTargets[ t ].vertices;
			
 
				+
			
 
				+								_vA.x += ( targets[ face.a ].x - v1p.x ) * influence;
			
 
				+								_vA.y += ( targets[ face.a ].y - v1p.y ) * influence;
			
 
				+								_vA.z += ( targets[ face.a ].z - v1p.z ) * influence;
			
 
				+
			
 
				+								_vB.x += ( targets[ face.b ].x - v2p.x ) * influence;
			
 
				+								_vB.y += ( targets[ face.b ].y - v2p.y ) * influence;
			
 
				+								_vB.z += ( targets[ face.b ].z - v2p.z ) * influence;
			
 
				+
			
 
				+								_vC.x += ( targets[ face.c ].x - v3p.x ) * influence;
			
 
				+								_vC.y += ( targets[ face.c ].y - v3p.y ) * influence;
			
 
				+								_vC.z += ( targets[ face.c ].z - v3p.z ) * influence;
			
 
				+
			
 
				+							}
			
 
				+
			
 
				+							v1.position.add( _vA );
			
 
				+							v2.position.add( _vB );
			
 
				+							v3.position.add( _vC );
			
 
				+
			
 
				+							renderList.projectVertex( v1 );
			
 
				+							renderList.projectVertex( v2 );
			
 
				+							renderList.projectVertex( v3 );
			
 
				+
			
 
				+						}
			
 
				+
			
 
				+						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;
			
 
				+
			
 
				+						_renderData.elements.push( _face );
			
 
				+
			
 
				+					}
			
 
				+
			
 
				+				}
			
 
				+
			
 
				+			} else if ( object instanceof THREE.Line ) {
			
 
				+
			
 
				+				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.index !== undefined ) {
			
 
				+
			
 
				+							var indices = attributes.index.array;
			
 
				+
			
 
				+							for ( var i = 0, l = indices.length; i < l; i += 2 ) {
			
 
				+
			
 
				+								renderList.pushLine( indices[ i ], indices[ i + 1 ] );
			
 
				+
			
 
				+							}
			
 
				+
			
 
				+						} else {
			
 
				+
			
 
				+							var step = object.type === THREE.LinePieces ? 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 ) {
			
 
				+
			
 
				+					_modelViewProjectionMatrix.multiplyMatrices( _viewProjectionMatrix, _modelMatrix );
			
 
				+
			
 
				+					var vertices = object.geometry.vertices;
			
 
				+
			
 
				+					if ( vertices.length === 0 ) continue;
			
 
				+
			
 
				+					v1 = getNextVertexInPool();
			
 
				+					v1.positionScreen.copy( vertices[ 0 ] ).applyMatrix4( _modelViewProjectionMatrix );
			
 
				+
			
 
				+					// Handle LineStrip and LinePieces
			
 
				+					var step = object.type === THREE.LinePieces ? 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.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.Sprite ) {
			
 
				+
			
 
				+				_vector4.set( _modelMatrix.elements[ 12 ], _modelMatrix.elements[ 13 ], _modelMatrix.elements[ 14 ], 1 );
			
 
				+				_vector4.applyMatrix4( _viewProjectionMatrix );
			
 
				+
			
 
				+				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.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 );
			
 
				+
			
 
				+				}
			
 
				+
			
 
				+			}
			
 
				+
			
 
				+		}
			
 
				+
			
 
				+		if ( sortElements === true ) {
			
 
				+
			
 
				+			_renderData.elements.sort( painterSort );
			
 
				+
			
 
				+		}
			
 
				+
			
 
				+		return _renderData;
			
 
				+
			
 
				+	};
			
 
				+
			
 
				+	// Pools
			
 
				+
			
 
				+	function getNextObjectInPool() {
			
 
				+
			
 
				+		if ( _objectCount === _objectPoolLength ) {
			
 
				+
			
 
				+			var object = new THREE.RenderableObject();
			
 
				+			_objectPool.push( object );
			
 
				+			_objectPoolLength ++;
			
 
				+			_objectCount ++;
			
 
				+			return object;
			
 
				+
			
 
				+		}
			
 
				+
			
 
				+		return _objectPool[ _objectCount ++ ];
			
 
				+
			
 
				+	}
			
 
				+
			
 
				+	function getNextVertexInPool() {
			
 
				+
			
 
				+		if ( _vertexCount === _vertexPoolLength ) {
			
 
				+
			
 
				+			var vertex = new THREE.RenderableVertex();
			
 
				+			_vertexPool.push( vertex );
			
 
				+			_vertexPoolLength ++;
			
 
				+			_vertexCount ++;
			
 
				+			return vertex;
			
 
				+
			
 
				+		}
			
 
				+
			
 
				+		return _vertexPool[ _vertexCount ++ ];
			
 
				+
			
 
				+	}
			
 
				+
			
 
				+	function getNextFaceInPool() {
			
 
				+
			
 
				+		if ( _faceCount === _facePoolLength ) {
			
 
				+
			
 
				+			var face = new THREE.RenderableFace();
			
 
				+			_facePool.push( face );
			
 
				+			_facePoolLength ++;
			
 
				+			_faceCount ++;
			
 
				+			return face;
			
 
				+
			
 
				+		}
			
 
				+
			
 
				+		return _facePool[ _faceCount ++ ];
			
 
				+
			
 
				+
			
 
				+	}
			
 
				+
			
 
				+	function getNextLineInPool() {
			
 
				+
			
 
				+		if ( _lineCount === _linePoolLength ) {
			
 
				+
			
 
				+			var line = new THREE.RenderableLine();
			
 
				+			_linePool.push( line );
			
 
				+			_linePoolLength ++;
			
 
				+			_lineCount ++
			
 
				+			return line;
			
 
				+
			
 
				+		}
			
 
				+
			
 
				+		return _linePool[ _lineCount ++ ];
			
 
				+
			
 
				+	}
			
 
				+
			
 
				+	function getNextSpriteInPool() {
			
 
				+
			
 
				+		if ( _spriteCount === _spritePoolLength ) {
			
 
				+
			
 
				+			var sprite = new THREE.RenderableSprite();
			
 
				+			_spritePool.push( sprite );
			
 
				+			_spritePoolLength ++;
			
 
				+			_spriteCount ++
			
 
				+			return sprite;
			
 
				+
			
 
				+		}
			
 
				+
			
 
				+		return _spritePool[ _spriteCount ++ ];
			
 
				+
			
 
				+	}
			
 
				+
			
 
				+	//
			
 
				+
			
 
				+	function painterSort( a, b ) {
			
 
				+
			
 
				+		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, alpha2 = 1,
			
 
				+
			
 
				+		// Calculate the boundary coordinate of each vertex for the near and far clip planes,
			
 
				+		// Z = -1 and Z = +1, respectively.
			
 
				+		bc1near =  s1.z + s1.w,
			
 
				+		bc2near =  s2.z + s2.w,
			
 
				+		bc1far =  - s1.z + s1.w,
			
 
				+		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;
			
 
				+
			
 
				+			}
			
 
				+
			
 
				+		}
			
 
				+
			
 
				+	}
			
 
				+
			
 
				+};
			
--- a/examples/js/renderers/SVGRenderer.js
+++ b/examples/js/renderers/SVGRenderer.js
@@ -18,7 +18,7 @@ THREE.SVGRenderer = function () {
 
				 
			
 
				 	var _this = this,
			
 
				 	_renderData, _elements, _lights,
			
 
				-	_projector = new THREE.Projector(),
			
 
				+	_renderer = new THREE.Renderer(),
			
 
				 	_svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg'),
			
 
				 	_svgWidth, _svgHeight, _svgWidthHalf, _svgHeightHalf,
			
 
				 
			
@@ -113,7 +113,7 @@ THREE.SVGRenderer = function () {
 
				 			_svg.removeChild( _svg.childNodes[ 0 ] );
			
 
				 
			
 
				 		}
			
 
				-		
			
 
				+
			
 
				 		_svg.style.backgroundColor = 'rgba(' + ( ( _clearColor.r * 255 ) | 0 ) + ',' + ( ( _clearColor.g * 255 ) | 0 ) + ',' + ( ( _clearColor.b * 255 ) | 0 ) + ',' + _clearAlpha + ')';
			
 
				 
			
 
				 	};
			
@@ -135,7 +135,7 @@ THREE.SVGRenderer = function () {
 
				 		_viewMatrix.copy( camera.matrixWorldInverse.getInverse( camera.matrixWorld ) );
			
 
				 		_viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, _viewMatrix );
			
 
				 
			
 
				-		_renderData = _projector.projectScene( scene, camera, this.sortObjects, this.sortElements );
			
 
				+		_renderData = _renderer.projectScene( scene, camera, this.sortObjects, this.sortElements );
			
 
				 		_elements = _renderData.elements;
			
 
				 		_lights = _renderData.lights;
			
 
				 
			
--- a/examples/js/renderers/SoftwareRenderer.js
+++ b/examples/js/renderers/SoftwareRenderer.js
@@ -45,12 +45,12 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 	var prevrectx1 = Infinity, prevrecty1 = Infinity;
			
 
				 	var prevrectx2 = 0, prevrecty2 = 0;
			
 
				 
			
 
				-	var projector = new THREE.Projector();
			
 
				+	var renderer = new THREE.Renderer();
			
 
				 
			
 
				 	var vector1 = new THREE.Vector3();
			
 
				 	var vector2 = new THREE.Vector3();
			
 
				 	var vector3 = new THREE.Vector3();
			
 
				-	
			
 
				+
			
 
				 	var texCoord1 = new THREE.Vector2();
			
 
				 	var texCoord2 = new THREE.Vector2();
			
 
				 	var texCoord3 = new THREE.Vector2();
			
@@ -82,11 +82,11 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 		viewportXScale =  fixScale * canvasWidth  / 2;
			
 
				 		viewportYScale = -fixScale * canvasHeight / 2;
			
 
				 		viewportZScale =             maxZVal      / 2;
			
 
				-              
			
 
				+
			
 
				 		viewportXOffs  =  fixScale * canvasWidth  / 2 + 0.5;
			
 
				 		viewportYOffs  =  fixScale * canvasHeight / 2 + 0.5;
			
 
				 		viewportZOffs  =             maxZVal      / 2 + 0.5;
			
 
				-        
			
 
				+
			
 
				 		canvas.width = canvasWidth;
			
 
				 		canvas.height = canvasHeight;
			
 
				 
			
@@ -140,7 +140,7 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 
			
 
				 		if ( this.autoClear === true ) this.clear();
			
 
				 
			
 
				-		var renderData = projector.projectScene( scene, camera, false, false );
			
 
				+		var renderData = renderer.projectScene( scene, camera, false, false );
			
 
				 		var elements = renderData.elements;
			
 
				 
			
 
				 		for ( var e = 0, el = elements.length; e < el; e ++ ) {
			
@@ -150,9 +150,9 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 			var shader = getMaterialShader( material );
			
 
				 
			
 
				 			if ( element instanceof THREE.RenderableFace ) {
			
 
				-				
			
 
				+
			
 
				 				if ( !element.uvs ) {
			
 
				-					
			
 
				+
			
 
				 					drawTriangle(
			
 
				 						element.v1.positionScreen,
			
 
				 						element.v2.positionScreen,
			
@@ -161,16 +161,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 						shader, element, material
			
 
				 					);
			
 
				 				} else {
			
 
				-					
			
 
				+
			
 
				 					drawTriangle(
			
 
				 						element.v1.positionScreen,
			
 
				 						element.v2.positionScreen,
			
 
				 						element.v3.positionScreen,
			
 
				 						element.uvs[0], element.uvs[1], element.uvs[2],
			
 
				 						shader, element, material
			
 
				-					);					
			
 
				+					);
			
 
				 				}
			
 
				-				
			
 
				+
			
 
				 
			
 
				 			} else if ( element instanceof THREE.RenderableSprite ) {
			
 
				 
			
@@ -188,13 +188,13 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 				vector3.copy( element );
			
 
				 				vector3.x += scaleX;
			
 
				 				vector3.y += scaleY;
			
 
				-				
			
 
				+
			
 
				 				if ( material.map ) {
			
 
				 
			
 
				 					texCoord1.set( 0, 1 );
			
 
				 					texCoord2.set( 0, 0 );
			
 
				 					texCoord3.set( 1, 1 );
			
 
				-				
			
 
				+
			
 
				 					drawTriangle(
			
 
				 						vector1, vector2, vector3,
			
 
				 						texCoord1, texCoord2, texCoord3,
			
@@ -202,14 +202,14 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 					);
			
 
				 
			
 
				 				} else {
			
 
				-					
			
 
				+
			
 
				 					drawTriangle(
			
 
				 						vector1, vector2, vector3,
			
 
				 						null, null, null,
			
 
				 						shader, element, material
			
 
				 					);
			
 
				 
			
 
				-				}			
			
 
				+				}
			
 
				 
			
 
				 				vector1.copy( element );
			
 
				 				vector1.x += scaleX;
			
@@ -222,7 +222,7 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 				vector3.copy( element );
			
 
				 				vector3.x += scaleX;
			
 
				 				vector3.y -= scaleY;
			
 
				-				
			
 
				+
			
 
				 				if ( material.map ) {
			
 
				 
			
 
				 					texCoord1.set( 1, 1 );
			
@@ -236,14 +236,14 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 					);
			
 
				 
			
 
				 				} else {
			
 
				-					
			
 
				+
			
 
				 					drawTriangle(
			
 
				 						vector1, vector2, vector3,
			
 
				 						null, null, null,
			
 
				 						shader, element, material
			
 
				 					);
			
 
				 
			
 
				-				}				
			
 
				+				}
			
 
				 
			
 
				 			}
			
 
				 
			
@@ -286,11 +286,11 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 		var size = canvasWidth * canvasHeight * 4;
			
 
				 
			
 
				 		for ( var i = 0; i < size; i+=4 ) {
			
 
				-			
			
 
				+
			
 
				 			data[ i ] = clearColor.r * 255 | 0;
			
 
				 			data[ i+1 ] = clearColor.g * 255 | 0;
			
 
				 			data[ i+2 ] = clearColor.b * 255 | 0;
			
 
				-			data[ i+3 ] = 255; 
			
 
				+			data[ i+3 ] = 255;
			
 
				 		}
			
 
				 
			
 
				 		context.fillStyle = clearColor.getStyle();
			
@@ -302,9 +302,9 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 		var diffuseG = material.ambient.g + material.color.g * 255;
			
 
				 		var diffuseB = material.ambient.b + material.color.b * 255;
			
 
				 		var palette = new Uint8Array(256*3);
			
 
				-		
			
 
				+
			
 
				 		if ( bSimulateSpecular ) {
			
 
				-			
			
 
				+
			
 
				 			var i = 0, j = 0;
			
 
				 			while(i < 204) {
			
 
				 				var r = i * diffuseR / 204;
			
@@ -333,15 +333,15 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 					g = 255;
			
 
				 				if(b > 255)
			
 
				 					b = 255;
			
 
				-				
			
 
				+
			
 
				 				palette[j++] = r;
			
 
				 				palette[j++] = g;
			
 
				 				palette[j++] = b;
			
 
				 				++i;
			
 
				 			}
			
 
				-			
			
 
				+
			
 
				 		} else {
			
 
				-			
			
 
				+
			
 
				 			var i = 0, j = 0;
			
 
				 			while(i < 256) {
			
 
				 				var r = i * diffuseR / 255;
			
@@ -359,14 +359,14 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 				palette[j++] = b;
			
 
				 				++i;
			
 
				 			}
			
 
				-			
			
 
				+
			
 
				 		}
			
 
				-		
			
 
				+
			
 
				 		return palette;
			
 
				 	}
			
 
				-	
			
 
				+
			
 
				 	function basicMaterialShader( buffer, depthBuf, offset, depth, u, v, n, face, material ) {
			
 
				-	
			
 
				+
			
 
				 		var colorOffset = offset * 4;
			
 
				 
			
 
				 		if ( material.needsUpdate && !material.texture.data ) {
			
@@ -381,7 +381,7 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 		var tbound = tdim - 1;
			
 
				 		var tdata = material.texture.data;
			
 
				 		var tIndex = (((v * tdim) & tbound) * tdim + ((u * tdim) & tbound)) * 4;
			
 
				-		
			
 
				+
			
 
				 		if ( !isTransparent ) {
			
 
				 			buffer[ colorOffset ] = tdata[tIndex];
			
 
				 			buffer[ colorOffset + 1 ] = tdata[tIndex+1];
			
@@ -389,25 +389,25 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 			buffer[ colorOffset + 3 ] = material.opacity * 255;
			
 
				 			depthBuf[ offset ] = depth;
			
 
				 		}
			
 
				-		else { 
			
 
				+		else {
			
 
				 			var opaci = tdata[tIndex+3] * material.opacity;
			
 
				 			var texel = (tdata[tIndex] << 16) + (tdata[tIndex+1] << 8) + tdata[tIndex+2];
			
 
				 			if(opaci < 250) {
			
 
				 				var backColor = (buffer[colorOffset] << 16) + (buffer[colorOffset + 1] << 8) + buffer[colorOffset + 2];
			
 
				-				texel = texel * opaci + backColor * (1-opaci);						 
			
 
				-			} 
			
 
				-			
			
 
				+				texel = texel * opaci + backColor * (1-opaci);
			
 
				+			}
			
 
				+
			
 
				 			buffer[ colorOffset ] = (texel & 0xff0000) >> 16;
			
 
				 			buffer[ colorOffset + 1 ] = (texel & 0xff00) >> 8;
			
 
				 			buffer[ colorOffset + 2 ] = texel & 0xff;
			
 
				 			buffer[ colorOffset + 3 ] = material.opacity * 255;
			
 
				 		}
			
 
				 	}
			
 
				-	
			
 
				+
			
 
				 	function lightingMaterialShader( buffer, depthBuf, offset, depth, u, v, n, face, material ) {
			
 
				-		
			
 
				+
			
 
				 		var colorOffset = offset * 4;
			
 
				-		
			
 
				+
			
 
				 		if ( material.map.needsUpdate && !material.texture.data ) {
			
 
				 			material.texture.CreateFromImage( material.map.image );
			
 
				 		}
			
@@ -421,51 +421,51 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 		var tbound = tdim - 1;
			
 
				 		var tdata = material.texture.data;
			
 
				 		var tIndex = (((v * tdim) & tbound) * tdim + ((u * tdim) & tbound)) * 4;
			
 
				-		
			
 
				+
			
 
				 		if ( !isTransparent ) {
			
 
				 			buffer[ colorOffset ] = (material.palette[cIndex] * tdata[tIndex]) >> 8;
			
 
				 			buffer[ colorOffset + 1 ] = (material.palette[cIndex+1] * tdata[tIndex+1]) >> 8;
			
 
				 			buffer[ colorOffset + 2 ] = (material.palette[cIndex+2] * tdata[tIndex+2]) >> 8;
			
 
				-			buffer[ colorOffset + 3 ] = material.opacity * 255;			
			
 
				+			buffer[ colorOffset + 3 ] = material.opacity * 255;
			
 
				 			depthBuf[ offset ] = depth;
			
 
				-		} else { 
			
 
				+		} else {
			
 
				 			var opaci = tdata[tIndex+3] * material.opacity;
			
 
				-			var foreColor = ((material.palette[cIndex] * tdata[tIndex]) << 16) 
			
 
				+			var foreColor = ((material.palette[cIndex] * tdata[tIndex]) << 16)
			
 
				 							+ ((material.palette[cIndex+1] * tdata[tIndex+1]) << 8 )
			
 
				 							+ (material.palette[cIndex+2] * tdata[tIndex+2]);
			
 
				-			
			
 
				+
			
 
				 			if(opaci < 250) {
			
 
				 			var backColor = buffer[ colorOffset ] << 24 + buffer[ colorOffset + 1 ] << 16 + buffer[ colorOffset + 2 ] << 8;
			
 
				-			foreColor = foreColor * opaci + backColor * (1-opaci);							
			
 
				-			} 
			
 
				-			
			
 
				+			foreColor = foreColor * opaci + backColor * (1-opaci);
			
 
				+			}
			
 
				+
			
 
				 			buffer[ colorOffset ] = (foreColor & 0xff0000) >> 16;
			
 
				 			buffer[ colorOffset + 1 ] = (foreColor & 0xff00) >> 8;
			
 
				 			buffer[ colorOffset + 2 ] = (foreColor & 0xff);
			
 
				 			buffer[ colorOffset + 3 ] = material.opacity * 255;
			
 
				 		}
			
 
				-		
			
 
				+
			
 
				 	}
			
 
				-	
			
 
				+
			
 
				 	function getMaterialShader( material ) {
			
 
				 
			
 
				 		var id = material.id;
			
 
				 		var shader = shaders[ id ];
			
 
				 
			
 
				 		if ( shaders[ id ] === undefined ) {
			
 
				-			
			
 
				+
			
 
				 			if ( material instanceof THREE.MeshBasicMaterial ||
			
 
				 				 material instanceof THREE.MeshLambertMaterial ||
			
 
				 				 material instanceof THREE.MeshPhongMaterial ||
			
 
				 				 material instanceof THREE.SpriteMaterial ) {
			
 
				 
			
 
				-				if ( material instanceof THREE.MeshLambertMaterial ) {			 
			
 
				+				if ( material instanceof THREE.MeshLambertMaterial ) {
			
 
				 					// Generate color palette
			
 
				 					if ( !material.palette ) {
			
 
				 						material.palette = getPalette( material, false );
			
 
				 					}
			
 
				-					
			
 
				-				} else if ( material instanceof THREE.MeshPhongMaterial ) {			 
			
 
				+
			
 
				+				} else if ( material instanceof THREE.MeshPhongMaterial ) {
			
 
				 					// Generate color palette
			
 
				 					if ( !material.palette ) {
			
 
				 						material.palette = getPalette( material, true );
			
@@ -473,24 +473,24 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 				}
			
 
				 
			
 
				 				var string;
			
 
				-				
			
 
				+
			
 
				 				if ( material.map ) {
			
 
				-					
			
 
				+
			
 
				 					var texture = new THREE.SoftwareRenderer.Texture();
			
 
				-					material.texture = texture;					
			
 
				-					 
			
 
				-					if ( material instanceof THREE.MeshBasicMaterial 
			
 
				-						|| material instanceof THREE.SpriteMaterial ) { 
			
 
				-						
			
 
				+					material.texture = texture;
			
 
				+
			
 
				+					if ( material instanceof THREE.MeshBasicMaterial
			
 
				+						|| material instanceof THREE.SpriteMaterial ) {
			
 
				+
			
 
				 						shader = basicMaterialShader;
			
 
				 					} else {
			
 
				-						
			
 
				+
			
 
				 						shader = lightingMaterialShader;
			
 
				 					}
			
 
				-					
			
 
				-					
			
 
				+
			
 
				+
			
 
				 				} else {
			
 
				-					
			
 
				+
			
 
				 					if ( material.vertexColors === THREE.FaceColors ) {
			
 
				 
			
 
				 						string = [
			
@@ -514,9 +514,9 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 						].join('\n');
			
 
				 
			
 
				 					}
			
 
				-					
			
 
				+
			
 
				 					shader = new Function( 'buffer, depthBuf, offset, depth, u, v, n, face, material', string );
			
 
				-				}			
			
 
				+				}
			
 
				 
			
 
				 			} else {
			
 
				 
			
@@ -589,37 +589,37 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 		var z1 = (v1.z * viewportZScale + viewportZOffs) | 0;
			
 
				 		var z2 = (v2.z * viewportZScale + viewportZOffs) | 0;
			
 
				 		var z3 = (v3.z * viewportZScale + viewportZOffs) | 0;
			
 
				-		
			
 
				+
			
 
				 		// UV values
			
 
				 		var bHasUV = false;
			
 
				 		var tu1, tv1, tu2, tv2, tu3, tv3;
			
 
				-		
			
 
				+
			
 
				 		if ( uv1 && uv2 && uv3 ) {
			
 
				 			bHasUV = true;
			
 
				-			
			
 
				-			tu1 = uv1.x; 
			
 
				-			tv1 = 1-uv1.y; 
			
 
				-			tu2 = uv2.x; 
			
 
				-			tv2 = 1-uv2.y; 
			
 
				-			tu3 = uv3.x; 
			
 
				-			tv3 = 1-uv3.y; 
			
 
				-		}			 
			
 
				-		
			
 
				+
			
 
				+			tu1 = uv1.x;
			
 
				+			tv1 = 1-uv1.y;
			
 
				+			tu2 = uv2.x;
			
 
				+			tv2 = 1-uv2.y;
			
 
				+			tu3 = uv3.x;
			
 
				+			tv3 = 1-uv3.y;
			
 
				+		}
			
 
				+
			
 
				 		// Normal values
			
 
				 		var bHasNormal = false;
			
 
				 		var n1, n2, n3, nz1, nz2, nz3;
			
 
				-		
			
 
				-		if ( face.vertexNormalsModel ) {			
			
 
				+
			
 
				+		if ( face.vertexNormalsModel ) {
			
 
				 			bHasNormal = true;
			
 
				-			
			
 
				+
			
 
				 			n1 = face.vertexNormalsModel[0];
			
 
				 			n2 = face.vertexNormalsModel[1];
			
 
				-			n3 = face.vertexNormalsModel[2]; 
			
 
				+			n3 = face.vertexNormalsModel[2];
			
 
				 			nz1 = n1.z * 255;
			
 
				 			nz2 = n2.z * 255;
			
 
				 			nz3 = n3.z * 255;
			
 
				 		}
			
 
				-		
			
 
				+
			
 
				 		// Deltas
			
 
				 
			
 
				 		var dx12 = x1 - x2, dy12 = y2 - y1;
			
@@ -684,7 +684,7 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 		var fixscale = (1 << subpixelBits);
			
 
				 		dzdx = (dzdx * fixscale) | 0;
			
 
				 		dzdy = (dzdy * fixscale) | 0;
			
 
				-		
			
 
				+
			
 
				 		var dtvdx, dtvdy, cbtu, cbtv;
			
 
				 		if ( bHasUV ) {
			
 
				 			// UV interpolation setup
			
@@ -693,34 +693,34 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 			var dtudy = (invDet * (dtu12*dx31 - dx12*dtu31)); // dtu per one subpixel step in y
			
 
				 			var dtv12 = tv1 - tv2, dtv31 = tv3 - tv1;
			
 
				 			dtvdx = (invDet * (dtv12*dy31 - dtv31*dy12)); // dtv per one subpixel step in x
			
 
				-			dtvdy = (invDet * (dtv12*dx31 - dx12*dtv31)); // dtv per one subpixel step in y	 
			
 
				-			
			
 
				+			dtvdy = (invDet * (dtv12*dx31 - dx12*dtv31)); // dtv per one subpixel step in y
			
 
				+
			
 
				 			// UV at top/left corner of rast area
			
 
				 			cbtu = ( tu1 + (minXfixscale - x1) * dtudx + (minYfixscale - y1) * dtudy );
			
 
				 			cbtv = ( tv1 + (minXfixscale - x1) * dtvdx + (minYfixscale - y1) * dtvdy );
			
 
				-			
			
 
				-			// UV pixel steps			
			
 
				+
			
 
				+			// UV pixel steps
			
 
				 			dtudx = dtudx * fixscale;
			
 
				-			dtudy = dtudy * fixscale;		
			
 
				+			dtudy = dtudy * fixscale;
			
 
				 			dtvdx = dtvdx * fixscale;
			
 
				 			dtvdy = dtvdy * fixscale;
			
 
				-		}				
			
 
				+		}
			
 
				 
			
 
				 		var dnxdx, dnzdy, cbnz;
			
 
				 		if ( bHasNormal ) {
			
 
				-			 // Normal interpolation setup		
			
 
				+			 // Normal interpolation setup
			
 
				 			var dnz12 = nz1 - nz2, dnz31 = nz3 - nz1;
			
 
				 			var dnzdx = (invDet * (dnz12*dy31 - dnz31*dy12)); // dnz per one subpixel step in x
			
 
				 			var dnzdy = (invDet * (dnz12*dx31 - dx12*dnz31)); // dnz per one subpixel step in y
			
 
				-			
			
 
				-			// Normal at top/left corner of rast area		 
			
 
				+
			
 
				+			// Normal at top/left corner of rast area
			
 
				 			cbnz = ( nz1 + (minXfixscale - x1) * dnzdx + (minYfixscale - y1) * dnzdy );
			
 
				 
			
 
				 			// Normal pixel steps
			
 
				 			dnzdx = (dnzdx * fixscale);
			
 
				 			dnzdy = (dnzdy * fixscale);
			
 
				 		}
			
 
				-		
			
 
				+
			
 
				 		// Set up min/max corners
			
 
				 		var qm1 = q - 1; // for convenience
			
 
				 		var nmin1 = 0, nmax1 = 0;
			
@@ -749,18 +749,18 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 		var e2x = qstep * dy23;
			
 
				 		var e3x = qstep * dy31;
			
 
				 		var ezx = qstep * dzdx;
			
 
				-		
			
 
				-		var etux, etvx; 
			
 
				+
			
 
				+		var etux, etvx;
			
 
				 		if ( bHasUV ) {
			
 
				 			etux = qstep * dtudx;
			
 
				 			etvx = qstep * dtvdx;
			
 
				 		}
			
 
				 
			
 
				-		var enzx; 
			
 
				+		var enzx;
			
 
				 		if ( bHasNormal ) {
			
 
				 			enzx = qstep * dnzdx;
			
 
				 		}
			
 
				-				
			
 
				+
			
 
				 		var x0 = minx;
			
 
				 
			
 
				 		for ( var y0 = miny; y0 < maxy; y0 += q ) {
			
@@ -773,16 +773,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 				cb2 += e2x;
			
 
				 				cb3 += e3x;
			
 
				 				cbz += ezx;
			
 
				-				
			
 
				+
			
 
				 				if ( bHasUV ) {
			
 
				 					cbtu += etux;
			
 
				 					cbtv += etvx;
			
 
				 				}
			
 
				-				
			
 
				+
			
 
				 				if ( bHasNormal ) {
			
 
				 					cbnz += enzx;
			
 
				-				}				
			
 
				-				
			
 
				+				}
			
 
				+
			
 
				 			}
			
 
				 
			
 
				 			// Okay, we're now in a block we know is outside. Reverse direction and go into main loop.
			
@@ -791,15 +791,15 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 			e2x = -e2x;
			
 
				 			e3x = -e3x;
			
 
				 			ezx = -ezx;
			
 
				-			
			
 
				-			if ( bHasUV ) {				
			
 
				+
			
 
				+			if ( bHasUV ) {
			
 
				 				etux = -etux;
			
 
				 				etvx = -etvx;
			
 
				 			}
			
 
				-			 
			
 
				+
			
 
				 			if ( bHasNormal ) {
			
 
				 				enzx = -enzx;
			
 
				-			}			
			
 
				+			}
			
 
				 
			
 
				 			while ( 1 ) {
			
 
				 
			
@@ -809,15 +809,15 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 				cb2 += e2x;
			
 
				 				cb3 += e3x;
			
 
				 				cbz += ezx;
			
 
				-				
			
 
				+
			
 
				 				if ( bHasUV ) {
			
 
				 					cbtu += etux;
			
 
				 					cbtv += etvx;
			
 
				 				}
			
 
				-				 
			
 
				+
			
 
				 				if ( bHasNormal ) {
			
 
				 					cbnz += enzx;
			
 
				-				}				
			
 
				+				}
			
 
				 
			
 
				 				// We're done with this block line when at least one edge completely out
			
 
				 				// If an edge function is too small and decreasing in the current traversal
			
@@ -843,7 +843,7 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 
			
 
				 				// Offset at top-left corner
			
 
				 				var offset = x0 + y0 * canvasWidth;
			
 
				-				
			
 
				+
			
 
				 				// Accept whole block when fully covered
			
 
				 				if ( cb1 >= nmin1 && cb2 >= nmin2 && cb3 >= nmin3 ) {
			
 
				 
			
@@ -853,58 +853,58 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 					var cy1 = cb1;
			
 
				 					var cy2 = cb2;
			
 
				 					var cyz = cbz;
			
 
				-					
			
 
				-					var cytu, cytv;					
			
 
				+
			
 
				+					var cytu, cytv;
			
 
				 					if ( bHasUV ) {
			
 
				 						cytu = cbtu;
			
 
				 						cytv = cbtv;
			
 
				 					}
			
 
				-					
			
 
				+
			
 
				 					var cynz;
			
 
				 					if ( bHasNormal ) {
			
 
				 						cynz = cbnz;
			
 
				 					}
			
 
				-					
			
 
				+
			
 
				 
			
 
				 					for ( var iy = 0; iy < q; iy ++ ) {
			
 
				 
			
 
				 						var cx1 = cy1;
			
 
				 						var cx2 = cy2;
			
 
				 						var cxz = cyz;
			
 
				-						
			
 
				+
			
 
				 						var cxtu;
			
 
				-						var cxtv;						
			
 
				+						var cxtv;
			
 
				 						if ( bHasUV ) {
			
 
				 							cxtu = cytu;
			
 
				 							cxtv = cytv;
			
 
				 						}
			
 
				-						
			
 
				-						var cxnz; 
			
 
				+
			
 
				+						var cxnz;
			
 
				 						if ( bHasNormal ) {
			
 
				-							cxnz = cynz; 
			
 
				-						}												 
			
 
				+							cxnz = cynz;
			
 
				+						}
			
 
				 
			
 
				 						for ( var ix = 0; ix < q; ix ++ ) {
			
 
				 
			
 
				 							var z = cxz;
			
 
				-							 
			
 
				-							if ( z < zbuffer[ offset ] ) {		 
			
 
				-								shader( data, zbuffer, offset, z, cxtu, cxtv, cxnz, face, material );								
			
 
				+
			
 
				+							if ( z < zbuffer[ offset ] ) {
			
 
				+								shader( data, zbuffer, offset, z, cxtu, cxtv, cxnz, face, material );
			
 
				 							}
			
 
				 
			
 
				 							cx1 += dy12;
			
 
				 							cx2 += dy23;
			
 
				 							cxz += dzdx;
			
 
				-							
			
 
				+
			
 
				 							if ( bHasUV ) {
			
 
				 								cxtu += dtudx;
			
 
				 								cxtv += dtvdx;
			
 
				 							}
			
 
				-							
			
 
				+
			
 
				 							if ( bHasNormal ) {
			
 
				 								cxnz += dnzdx;
			
 
				-							}							
			
 
				-							
			
 
				+							}
			
 
				+
			
 
				 							offset++;
			
 
				 
			
 
				 						}
			
@@ -912,16 +912,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 						cy1 += dx12;
			
 
				 						cy2 += dx23;
			
 
				 						cyz += dzdy;
			
 
				-						
			
 
				+
			
 
				 						if ( bHasUV ) {
			
 
				 							cytu += dtudy;
			
 
				 							cytv += dtvdy;
			
 
				 						}
			
 
				-						
			
 
				+
			
 
				 						if ( bHasNormal ) {
			
 
				 							cynz += dnzdy;
			
 
				-						}						
			
 
				-						
			
 
				+						}
			
 
				+
			
 
				 						offset += linestep;
			
 
				 
			
 
				 					}
			
@@ -932,17 +932,17 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 					var cy2 = cb2;
			
 
				 					var cy3 = cb3;
			
 
				 					var cyz = cbz;
			
 
				-					
			
 
				+
			
 
				 					var cytu, cytv;
			
 
				 					if ( bHasUV ) {
			
 
				 						cytu = cbtu;
			
 
				 						cytv = cbtv;
			
 
				 					}
			
 
				-					
			
 
				+
			
 
				 					var cynz;
			
 
				 					if ( bHasNormal ) {
			
 
				 						cynz = cbnz;
			
 
				-					}					
			
 
				+					}
			
 
				 
			
 
				 					for ( var iy = 0; iy < q; iy ++ ) {
			
 
				 
			
@@ -950,26 +950,26 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 						var cx2 = cy2;
			
 
				 						var cx3 = cy3;
			
 
				 						var cxz = cyz;
			
 
				-						
			
 
				+
			
 
				 						var cxtu;
			
 
				-						var cxtv;							
			
 
				+						var cxtv;
			
 
				 						if ( bHasUV ) {
			
 
				 							cxtu = cytu;
			
 
				 							cxtv = cytv;
			
 
				 						}
			
 
				-						
			
 
				-						var cxnz;						
			
 
				+
			
 
				+						var cxnz;
			
 
				 						if ( bHasNormal ) {
			
 
				-							cxnz = cynz;	 
			
 
				-						}						 
			
 
				+							cxnz = cynz;
			
 
				+						}
			
 
				 
			
 
				 						for ( var ix = 0; ix < q; ix ++ ) {
			
 
				 
			
 
				 							if ( ( cx1 | cx2 | cx3 ) >= 0 ) {
			
 
				 
			
 
				-								var z = cxz;								
			
 
				+								var z = cxz;
			
 
				 
			
 
				-								if ( z < zbuffer[ offset ] ) {						 
			
 
				+								if ( z < zbuffer[ offset ] ) {
			
 
				 									shader( data, zbuffer, offset, z, cxtu, cxtv, cxnz, face, material );
			
 
				 								}
			
 
				 
			
@@ -979,16 +979,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 							cx2 += dy23;
			
 
				 							cx3 += dy31;
			
 
				 							cxz += dzdx;
			
 
				-							
			
 
				+
			
 
				 							if ( bHasUV ) {
			
 
				 								cxtu += dtudx;
			
 
				 								cxtv += dtvdx;
			
 
				 							}
			
 
				-							
			
 
				+
			
 
				 							if ( bHasNormal ) {
			
 
				 								cxnz += dnzdx;
			
 
				 							}
			
 
				-							
			
 
				+
			
 
				 							offset++;
			
 
				 
			
 
				 						}
			
@@ -997,16 +997,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 						cy2 += dx23;
			
 
				 						cy3 += dx31;
			
 
				 						cyz += dzdy;
			
 
				-						
			
 
				+
			
 
				 						if ( bHasUV ) {
			
 
				 							cytu += dtudy;
			
 
				 							cytv += dtvdy;
			
 
				 						}
			
 
				-						
			
 
				+
			
 
				 						if ( bHasNormal ) {
			
 
				 							cynz += dnzdy;
			
 
				-						}						
			
 
				-						
			
 
				+						}
			
 
				+
			
 
				 						offset += linestep;
			
 
				 
			
 
				 					}
			
@@ -1020,16 +1020,16 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 			cb2 += q*dx23;
			
 
				 			cb3 += q*dx31;
			
 
				 			cbz += q*dzdy;
			
 
				-			
			
 
				+
			
 
				 			if ( bHasUV ) {
			
 
				 				cbtu += q*dtudy;
			
 
				 				cbtv += q*dtvdy;
			
 
				 			}
			
 
				-			
			
 
				+
			
 
				 			if ( bHasNormal ) {
			
 
				 				cbnz += q*dnzdy;
			
 
				-			}			
			
 
				-			
			
 
				+			}
			
 
				+
			
 
				 		}
			
 
				 
			
 
				 	}
			
@@ -1088,12 +1088,12 @@ THREE.SoftwareRenderer = function ( parameters ) {
 
				 
			
 
				 THREE.SoftwareRenderer.Texture = function() {
			
 
				 	var canvas = null;
			
 
				-	
			
 
				+
			
 
				 	this.CreateFromImage = function( image ) {
			
 
				-		
			
 
				+
			
 
				 		if( !image || image.width <=0 || image.height <=0 )
			
 
				 			return;
			
 
				-	
			
 
				+
			
 
				 		var isCanvasClean = false;
			
 
				 		var canvas = THREE.SoftwareRenderer.Texture.canvas;
			
 
				 		if ( !canvas ) {
			
--- a/examples/misc_animation_keys.html
+++ b/examples/misc_animation_keys.html
@@ -41,36 +41,36 @@
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
 
				-			
			
 
				+
			
 
				 			if ( ! Detector.webgl ) Detector.addGetWebGLMessage();
			
 
				-			
			
 
				+
			
 
				 			var container, stats;
			
 
				 			var scene, camera, renderer;
			
 
				 			var clock = new THREE.Clock();
			
 
				-			
			
 
				+
			
 
				 			var init = function(){
			
 
				-				
			
 
				+
			
 
				 				container = document.getElementById( 'container' );
			
 
				-				
			
 
				+
			
 
				 				camera = new THREE.PerspectiveCamera( 53, window.innerWidth / window.innerHeight, 1, 1000 );
			
 
				 				camera.position.x = 0;
			
 
				 				camera.position.y = 0;
			
 
				 				camera.position.z = 100;
			
 
				 				camera.lookAt(new THREE.Vector3( 0, 0, 0 ));
			
 
				-				
			
 
				-				renderer = new THREE.CanvasRenderer( { antialias: false } );
			
 
				+
			
 
				+				renderer = new THREE.WebGLRenderer();
			
 
				 				renderer.setSize( window.innerWidth, window.innerHeight );
			
 
				 				renderer.setClearColor( 0x555555, 1 );
			
 
				 				container.appendChild( renderer.domElement );
			
 
				-				
			
 
				+
			
 
				 				stats = new Stats();
			
 
				 				stats.domElement.style.position = 'absolute';
			
 
				 				stats.domElement.style.top = '0px';
			
 
				 				container.appendChild( stats.domElement );
			
 
				-				
			
 
				+
			
 
				 				window.addEventListener( 'resize', onWindowResize, false );
			
 
				 			};
			
 
				-			
			
 
				+
			
 
				 			var onWindowResize = function () {
			
 
				 
			
 
				 				windowHalfX = window.innerWidth / 2;
			
@@ -82,24 +82,24 @@
 
				 				renderer.setSize( window.innerWidth, window.innerHeight );
			
 
				 
			
 
				 			}
			
 
				-			
			
 
				+
			
 
				 			var createScene = function(){
			
 
				-				
			
 
				+
			
 
				 				scene = new THREE.Scene();
			
 
				-				
			
 
				+
			
 
				 				var axisHelper = new THREE.AxisHelper( 1 );
			
 
				 				scene.add( axisHelper );
			
 
				-				
			
 
				+
			
 
				 				// SphereGeometry
			
 
				 				var sphereGeometry = new THREE.SphereGeometry( 5, 32, 32 );
			
 
				 				var material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
			
 
				 				var sphereMesh = new THREE.Mesh( sphereGeometry, material );
			
 
				-				
			
 
				+
			
 
				 				// Setup animation
			
 
				 				var animationData = {
			
 
				 					"name"      : "Action",
			
 
				 					"fps"       : 25,
			
 
				-					"length"    : 2.0, 
			
 
				+					"length"    : 2.0,
			
 
				 					"hierarchy" : [
			
 
				 						{
			
 
				 							"parent" : -1, //root
			
@@ -125,14 +125,14 @@
 
				 				};
			
 
				 
			
 
				 				ensureLoop( animationData );
			
 
				-				
			
 
				+
			
 
				 				var sphereMeshAnimation = new THREE.Animation( sphereMesh, animationData );
			
 
				 				sphereMeshAnimation.play();
			
 
				-				
			
 
				+
			
 
				 				scene.add( sphereMesh );
			
 
				 
			
 
				 			};
			
 
				-			
			
 
				+
			
 
				 			var ensureLoop = function( animation ) {
			
 
				 
			
 
				 				for ( var i = 0; i < animation.hierarchy.length; i ++ ) {
			
@@ -149,17 +149,17 @@
 
				 				}
			
 
				 
			
 
				 			};
			
 
				-			
			
 
				+
			
 
				 			var animate = function () {
			
 
				 				requestAnimationFrame( animate );
			
 
				-				
			
 
				+
			
 
				 				var delta = clock.getDelta();
			
 
				 
			
 
				 				THREE.AnimationHandler.update( delta );
			
 
				-				
			
 
				+
			
 
				 				render();
			
 
				 			};
			
 
				-			
			
 
				+
			
 
				 			var render = function () {
			
 
				 				renderer.render( scene, camera );
			
 
				 				stats.update();
			
@@ -168,9 +168,8 @@
 
				 			init();
			
 
				 			createScene();
			
 
				 			animate();
			
 
				-		
			
 
				+
			
 
				 		</script>
			
 
				 
			
 
				 	</body>
			
 
				 </html>
			
 
				-
			
--- a/examples/misc_geometry2_sandbox.html
+++ b/examples/misc_geometry2_sandbox.html
@@ -1,191 +0,0 @@
 
				-<!DOCTYPE html>
			
 
				-<html lang="en">
			
 
				-	<head>
			
 
				-		<title>three.js canvas - geometry2 - sandbox</title>
			
 
				-		<meta charset="utf-8">
			
 
				-		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
			
 
				-		<style>
			
 
				-			body {
			
 
				-				font-family: Monospace;
			
 
				-				background-color: #f0f0f0;
			
 
				-				margin: 0px;
			
 
				-				overflow: hidden;
			
 
				-			}
			
 
				-		</style>
			
 
				-	</head>
			
 
				-	<body>
			
 
				-
			
 
				-		<script src="../build/three.min.js"></script>
			
 
				-
			
 
				-		<script src="js/wip/PlaneGeometry.js"></script>
			
 
				-
			
 
				-		<script src="js/wip/Geometry2.js"></script>
			
 
				-		<script src="js/wip/BoxGeometry2.js"></script>
			
 
				-		<script src="js/wip/PlaneGeometry2.js"></script>
			
 
				-		<script src="js/wip/PlaneGeometry2b.js"></script>
			
 
				-
			
 
				-		<script src="js/wip/Geometry3.js"></script>
			
 
				-		<script src="js/wip/PlaneGeometry3.js"></script>
			
 
				-
			
 
				-		<script src="js/wip/Geometry5.js"></script>
			
 
				-		<script src="js/wip/PlaneGeometry5.js"></script>
			
 
				-
			
 
				-		<script src="js/wip/IndexedGeometry5.js"></script>
			
 
				-		<script src="js/wip/IndexedPlaneGeometry5.js"></script>
			
 
				-
			
 
				-		<script src="js/wip/PlaneBufferGeometry.js"></script>
			
 
				-		<script src="js/wip/PlaneGeometry6.js"></script>
			
 
				-
			
 
				-		<script src="js/wip/PlaneGeometry99.js"></script>
			
 
				-
			
 
				-		<script src="js/libs/stats.min.js"></script>
			
 
				-
			
 
				-		<script>
			
 
				-
			
 
				-			var container, stats;
			
 
				-
			
 
				-			var camera, scene, renderer;
			
 
				-
			
 
				-			var cube, plane;
			
 
				-
			
 
				-			init();
			
 
				-			animate();
			
 
				-
			
 
				-			var test = new THREE.PlaneGeometry99( 200, 200, 200, 200 );
			
 
				-
			
 
				-			function init() {
			
 
				-
			
 
				-				container = document.createElement( 'div' );
			
 
				-				document.body.appendChild( container );
			
 
				-
			
 
				-				camera = new THREE.PerspectiveCamera( 70, window.innerWidth / window.innerHeight, 1, 1000 );
			
 
				-				camera.position.y = 150;
			
 
				-				camera.position.z = 500;
			
 
				-
			
 
				-				scene = new THREE.Scene();
			
 
				-
			
 
				-				var light = new THREE.PointLight( 0xffffff );
			
 
				-				light.position.set( 0, 200, - 50 );
			
 
				-				scene.add( light );
			
 
				-
			
 
				-				//
			
 
				-
			
 
				-				addGeometries( 'PlaneGeometry', 'BoxGeometry', -100 );
			
 
				-				// addGeometries( 'IndexedPlaneGeometry5', 'BoxGeometry', 0 );
			
 
				-				// addGeometries( 'PlaneGeometry2', 'BoxGeometry2', 0 );
			
 
				-				// addGeometries( 'PlaneGeometry3', 'BoxGeometry2', 0 );
			
 
				-				addGeometries( 'PlaneGeometry5', 'BoxGeometry2', -50 );
			
 
				-				addGeometries( 'PlaneBufferGeometry', 'BoxGeometry2', 0 );
			
 
				-				addGeometries( 'PlaneGeometry6', 'BoxGeometry2', 50 );
			
 
				-				addGeometries( 'PlaneGeometry99', 'BoxGeometry2', 100 );
			
 
				-
			
 
				-				//
			
 
				-
			
 
				-				renderer = new THREE.WebGLRenderer();
			
 
				-				renderer.setClearColor( 0xf0f0f0 );
			
 
				-				renderer.setSize( window.innerWidth, window.innerHeight );
			
 
				-
			
 
				-				container.appendChild( renderer.domElement );
			
 
				-
			
 
				-				stats = new Stats();
			
 
				-				stats.domElement.style.position = 'absolute';
			
 
				-				stats.domElement.style.top = '0px';
			
 
				-				container.appendChild( stats.domElement );
			
 
				-
			
 
				-				//
			
 
				-
			
 
				-				window.addEventListener( 'resize', onWindowResize, false );
			
 
				-
			
 
				-				/*
			
 
				-				setInterval( function () {
			
 
				-
			
 
				-					console.log( '---' );
			
 
				-
			
 
				-					createGeometry( 'PlaneGeometry' );
			
 
				-					createGeometry( 'PlaneGeometry2' );
			
 
				-					createGeometry( 'PlaneGeometry2b' );
			
 
				-					createGeometry( 'PlaneGeometry5' );
			
 
				-					createGeometry( 'PlaneGeometryB' );
			
 
				-
			
 
				-				}, 2000 );
			
 
				-*/
			
 
				-
			
 
				-			}
			
 
				-
			
 
				-			function createGeometry( primitive ) {
			
 
				-
			
 
				-				console.time( primitive );
			
 
				-
			
 
				-				new THREE[ primitive ]( 200, 200, 60, 60 );
			
 
				-
			
 
				-				console.timeEnd( primitive );
			
 
				-
			
 
				-			}
			
 
				-
			
 
				-			function addGeometries( PlaneGeometry, BoxGeometry, y ) {
			
 
				-
			
 
				-				// Plane
			
 
				-
			
 
				-				console.time( PlaneGeometry );
			
 
				-				var geometry = new THREE[ PlaneGeometry ]( 200, 200, 200, 200 );
			
 
				-				console.timeEnd( PlaneGeometry );
			
 
				-
			
 
				-				geometry.applyMatrix( new THREE.Matrix4().makeRotationX( - Math.PI / 2 ) );
			
 
				-
			
 
				-				var material = new THREE.MeshPhongMaterial( { color: 0xff0000/*, wireframe: true*/ } );
			
 
				-
			
 
				-				plane = new THREE.Mesh( geometry, material );
			
 
				-				plane.position.y = y;
			
 
				-				scene.add( plane );
			
 
				-
			
 
				-				/*
			
 
				-				// Cube
			
 
				-
			
 
				-				var geometry = new THREE[ BoxGeometry ]( 200, 200, 200, 10, 10, 10 );
			
 
				-
			
 
				-				var material = new THREE.MeshBasicMaterial( { color: 0x000000, wireframe: true } );
			
 
				-
			
 
				-				cube = new THREE.Mesh( geometry, material );
			
 
				-				cube.position.y = 150;
			
 
				-				plane.add( cube );
			
 
				-				*/
			
 
				-
			
 
				-			}
			
 
				-
			
 
				-			function onWindowResize() {
			
 
				-
			
 
				-				camera.aspect = window.innerWidth / window.innerHeight;
			
 
				-				camera.updateProjectionMatrix();
			
 
				-
			
 
				-				renderer.setSize( window.innerWidth, window.innerHeight );
			
 
				-
			
 
				-			}
			
 
				-
			
 
				-			//
			
 
				-
			
 
				-			function animate() {
			
 
				-
			
 
				-				requestAnimationFrame( animate );
			
 
				-
			
 
				-				render();
			
 
				-				stats.update();
			
 
				-
			
 
				-			}
			
 
				-
			
 
				-			function render() {
			
 
				-
			
 
				-				for ( var i = 0, l = scene.children.length; i < l; i ++ ) {
			
 
				-
			
 
				-					var object = scene.children[ i ];
			
 
				-					object.rotation.y = Date.now() * 0.001;
			
 
				-
			
 
				-				}
			
 
				-
			
 
				-				renderer.render( scene, camera );
			
 
				-
			
 
				-			}
			
 
				-
			
 
				-		</script>
			
 
				-
			
 
				-	</body>
			
 
				-</html>
			
--- a/examples/misc_lights_test.html
+++ b/examples/misc_lights_test.html
@@ -26,6 +26,10 @@
 
				 	<body>
			
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				+
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script>
			
--- a/examples/misc_ubiquity_test.html
+++ b/examples/misc_ubiquity_test.html
@@ -16,8 +16,11 @@
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				 		<script src="js/renderers/SVGRenderer.js"></script>
			
 
				 		<script src="js/renderers/SoftwareRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<script src="obj/Qrcode.js"></script>
			
--- a/examples/misc_ubiquity_test2.html
+++ b/examples/misc_ubiquity_test2.html
@@ -15,6 +15,10 @@
 
				 	<body>
			
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				+
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				+		<script src="js/renderers/CanvasRenderer.js"></script>
			
 
				+
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
 
				 
			
 
				 		<div id='container1' style='float: left '></div>
			
@@ -127,7 +131,7 @@
 
				 
			
 
				 					var material = new THREE.SpriteMaterial( { map: texture3 } );
			
 
				 					material.rotation = 2 * Math.PI * ( Math.random() - 0.5 );
			
 
				-					
			
 
				+
			
 
				 					var sprite = new THREE.Sprite( material );
			
 
				 
			
 
				 					sprite.position.x = Math.random() * 1000 - 500;
			
--- a/examples/software_geometry_earth.html
+++ b/examples/software_geometry_earth.html
@@ -35,9 +35,12 @@
 
				 		<div id="info"><a href="http://threejs.org" target="_blank">three.js</a> - earth demo</div>
			
 
				 
			
 
				 		<script src="../build/three.min.js"></script>
			
 
				-		<script src="js/libs/stats.min.js"></script>
			
 
				+
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				 		<script src="js/renderers/SoftwareRenderer.js"></script>
			
 
				 
			
 
				+		<script src="js/libs/stats.min.js"></script>
			
 
				+
			
 
				 		<script>
			
 
				 
			
 
				 			var container, stats;
			
--- a/examples/software_sandbox.html
+++ b/examples/software_sandbox.html
@@ -18,6 +18,8 @@
 
				 		<script src="../build/three.min.js"></script>
			
 
				 
			
 
				 		<script src="js/controls/TrackballControls.js"></script>
			
 
				+
			
 
				+		<script src="js/renderers/Renderer.js"></script>
			
 
				 		<script src="js/renderers/SoftwareRenderer.js"></script>
			
 
				 
			
 
				 		<script src="js/libs/stats.min.js"></script>
			
--- a/examples/canvas_interactive_lines.html
+++ b/examples/canvas_interactive_lines.html
@@ -1,7 +1,7 @@
 
				 <!DOCTYPE html>
			
 
				 <html lang="en">
			
 
				 	<head>
			
 
				-		<title>three.js canvas - interactive lines</title>
			
 
				+		<title>three.js webgl - interactive lines</title>
			
 
				 		<meta charset="utf-8">
			
 
				 		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
			
 
				 		<style>
			
@@ -58,12 +58,7 @@
 
				 
			
 
				 				}
			
 
				 
			
 
				-				sphereInter = new THREE.Sprite(
			
 
				-					new THREE.SpriteCanvasMaterial( {
			
 
				-						color: 0xff0000,
			
 
				-						program: program }
			
 
				-					)
			
 
				-				);
			
 
				+				sphereInter = new THREE.Sprite( new THREE.SpriteMaterial( { color: 0xff0000 } ) );
			
 
				 				sphereInter.scale.x = sphereInter.scale.y = 10;
			
 
				 				sphereInter.visible = false;
			
 
				 				scene.add( sphereInter );
			
@@ -103,7 +98,7 @@
 
				 
			
 
				 					var type = Math.random() > 0.5 ? THREE.LineStrip : THREE.LinePieces;
			
 
				 					var object = new THREE.Line( geometry, new THREE.LineBasicMaterial( { color: Math.random() * 0xffffff } ), type );
			
 
				-					
			
 
				+
			
 
				 					object.position.x = Math.random() * 400 - 200;
			
 
				 					object.position.y = Math.random() * 400 - 200;
			
 
				 					object.position.z = Math.random() * 400 - 200;
			
@@ -126,7 +121,7 @@
 
				 				raycaster = new THREE.Raycaster();
			
 
				 				raycaster.linePrecision = 3;
			
 
				 
			
 
				-				renderer = new THREE.CanvasRenderer();
			
 
				+				renderer = new THREE.WebGLRenderer();
			
 
				 				renderer.setClearColor( 0xf0f0f0 );
			
 
				 				renderer.setSize( window.innerWidth, window.innerHeight );
			
 
				 
			
--- a/src/core/Projector.js
+++ b/src/core/Projector.js
@@ -1,64 +1,36 @@
 
				 /**
			
 
				  * @author mrdoob / http://mrdoob.com/
			
 
				- * @author supereggbert / http://www.paulbrunt.co.uk/
			
 
				- * @author julianwa / https://github.com/julianwa
			
 
				  */
			
 
				 
			
 
				 THREE.Projector = function () {
			
 
				 
			
 
				-	var _object, _objectCount, _objectPool = [], _objectPoolLength = 0,
			
 
				-	_vertex, _vertexCount, _vertexPool = [], _vertexPoolLength = 0,
			
 
				-	_face, _faceCount, _facePool = [], _facePoolLength = 0,
			
 
				-	_line, _lineCount, _linePool = [], _linePoolLength = 0,
			
 
				-	_sprite, _spriteCount, _spritePool = [], _spritePoolLength = 0,
			
 
				-
			
 
				-	_renderData = { objects: [], lights: [], elements: [] },
			
 
				-
			
 
				-	_vA = new THREE.Vector3(),
			
 
				-	_vB = new THREE.Vector3(),
			
 
				-	_vC = new THREE.Vector3(),
			
 
				-
			
 
				-	_vector3 = new THREE.Vector3(),
			
 
				-	_vector4 = new THREE.Vector4(),
			
 
				-
			
 
				-	_clipBox = new THREE.Box3( new THREE.Vector3( - 1, - 1, - 1 ), new THREE.Vector3( 1, 1, 1 ) ),
			
 
				-	_boundingBox = new THREE.Box3(),
			
 
				-	_points3 = new Array( 3 ),
			
 
				-	_points4 = new Array( 4 ),
			
 
				-
			
 
				-	_viewMatrix = new THREE.Matrix4(),
			
 
				-	_viewProjectionMatrix = new THREE.Matrix4(),
			
 
				-
			
 
				-	_modelMatrix,
			
 
				-	_modelViewProjectionMatrix = new THREE.Matrix4(),
			
 
				+	this.projectVector = function ( vector, camera ) {
			
 
				 
			
 
				-	_normalMatrix = new THREE.Matrix3(),
			
 
				+		var viewProjectionMatrix = new THREE.Matrix4();
			
 
				 
			
 
				-	_frustum = new THREE.Frustum(),
			
 
				+		return function ( vector, camera ) {
			
 
				 
			
 
				-	_clippedVertex1PositionScreen = new THREE.Vector4(),
			
 
				-	_clippedVertex2PositionScreen = new THREE.Vector4();
			
 
				+			camera.matrixWorldInverse.getInverse( camera.matrixWorld );
			
 
				 
			
 
				-	this.projectVector = function ( vector, camera ) {
			
 
				+			viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );
			
 
				 
			
 
				-		camera.matrixWorldInverse.getInverse( camera.matrixWorld );
			
 
				+			return vector.applyProjection( viewProjectionMatrix );
			
 
				 
			
 
				-		_viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );
			
 
				-
			
 
				-		return vector.applyProjection( _viewProjectionMatrix );
			
 
				+		};
			
 
				 
			
 
				-	};
			
 
				+	}();
			
 
				 
			
 
				 	this.unprojectVector = function () {
			
 
				 
			
 
				 		var projectionMatrixInverse = new THREE.Matrix4();
			
 
				+		var viewProjectionMatrix = new THREE.Matrix4();
			
 
				 
			
 
				 		return function ( vector, camera ) {
			
 
				 
			
 
				 			projectionMatrixInverse.getInverse( camera.projectionMatrix );
			
 
				-			_viewProjectionMatrix.multiplyMatrices( camera.matrixWorld, projectionMatrixInverse );
			
 
				+			viewProjectionMatrix.multiplyMatrices( camera.matrixWorld, projectionMatrixInverse );
			
 
				 
			
 
				-			return vector.applyProjection( _viewProjectionMatrix );
			
 
				+			return vector.applyProjection( viewProjectionMatrix );
			
 
				 
			
 
				 		};
			
 
				 
			
@@ -80,784 +52,4 @@ THREE.Projector = function () {
 
				 
			
 
				 	};
			
 
				 
			
 
				-	var RenderList = function () {
			
 
				-
			
 
				-		var normals = [];
			
 
				-		var uvs = [];
			
 
				-
			
 
				-		var object = null;
			
 
				-		var material = null;
			
 
				-
			
 
				-		var normalMatrix = new THREE.Matrix3();
			
 
				-
			
 
				-		var setObject = function ( value ) {
			
 
				-
			
 
				-			object = value;
			
 
				-			material = object.material;
			
 
				-
			
 
				-			normalMatrix.getNormalMatrix( object.matrixWorld );
			
 
				-
			
 
				-			normals.length = 0;
			
 
				-			uvs.length = 0;
			
 
				-
			
 
				-		};
			
 
				-
			
 
				-		var projectVertex = function ( 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;
			
 
				-
			
 
				-		};
			
 
				-
			
 
				-		var pushVertex = function ( x, y, z ) {
			
 
				-
			
 
				-			_vertex = getNextVertexInPool();
			
 
				-			_vertex.position.set( x, y, z );
			
 
				-
			
 
				-			projectVertex( _vertex );
			
 
				-
			
 
				-		};
			
 
				-
			
 
				-		var pushNormal = function ( x, y, z ) {
			
 
				-
			
 
				-			normals.push( x, y, z );
			
 
				-
			
 
				-		};
			
 
				-
			
 
				-		var pushUv = function ( x, y ) {
			
 
				-
			
 
				-			uvs.push( x, y );
			
 
				-
			
 
				-		};
			
 
				-
			
 
				-		var checkTriangleVisibility = function ( 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.isIntersectionBox( _boundingBox.setFromPoints( _points3 ) );
			
 
				-
			
 
				-		};
			
 
				-
			
 
				-		var checkBackfaceCulling = function ( 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;
			
 
				-
			
 
				-		};
			
 
				-
			
 
				-		var pushLine = function ( a, b ) {
			
 
				-
			
 
				-			var v1 = _vertexPool[ a ];
			
 
				-			var v2 = _vertexPool[ b ];
			
 
				-
			
 
				-			_line = getNextLineInPool();
			
 
				-
			
 
				-			_line.id = object.id;
			
 
				-			_line.v1.copy( v1 );
			
 
				-			_line.v2.copy( v2 );
			
 
				-			_line.z = ( v1.positionScreen.z + v2.positionScreen.z ) / 2;
			
 
				-
			
 
				-			_line.material = object.material;
			
 
				-
			
 
				-			_renderData.elements.push( _line );
			
 
				-
			
 
				-		};
			
 
				-
			
 
				-		var pushTriangle = function ( a, b, c ) {
			
 
				-
			
 
				-			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;
			
 
				-
			
 
				-				for ( var i = 0; i < 3; i ++ ) {
			
 
				-
			
 
				-					var offset = arguments[ i ] * 3;
			
 
				-					var normal = _face.vertexNormalsModel[ i ];
			
 
				-
			
 
				-					normal.set( normals[ offset ], normals[ offset + 1 ], normals[ offset + 2 ] );
			
 
				-					normal.applyMatrix3( normalMatrix ).normalize();
			
 
				-
			
 
				-					var offset2 = arguments[ i ] * 2;
			
 
				-
			
 
				-					var uv = _face.uvs[ i ];
			
 
				-					uv.set( uvs[ offset2 ], uvs[ offset2 + 1 ] );
			
 
				-
			
 
				-				}
			
 
				-
			
 
				-				_face.vertexNormalsLength = 3;
			
 
				-
			
 
				-				_face.material = object.material;
			
 
				-
			
 
				-				_renderData.elements.push( _face );
			
 
				-
			
 
				-			}
			
 
				-
			
 
				-		};
			
 
				-
			
 
				-		return {
			
 
				-			setObject: setObject,
			
 
				-			projectVertex: projectVertex,
			
 
				-			checkTriangleVisibility: checkTriangleVisibility,
			
 
				-			checkBackfaceCulling: checkBackfaceCulling,
			
 
				-			pushVertex: pushVertex,
			
 
				-			pushNormal: pushNormal,
			
 
				-			pushUv: pushUv,
			
 
				-			pushLine: pushLine,
			
 
				-			pushTriangle: pushTriangle
			
 
				-		}
			
 
				-
			
 
				-	};
			
 
				-
			
 
				-	var renderList = new RenderList();
			
 
				-
			
 
				-	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 === undefined ) camera.updateMatrixWorld();
			
 
				-
			
 
				-		_viewMatrix.copy( camera.matrixWorldInverse.getInverse( camera.matrixWorld ) );
			
 
				-		_viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, _viewMatrix );
			
 
				-
			
 
				-		_frustum.setFromMatrix( _viewProjectionMatrix );
			
 
				-
			
 
				-		//
			
 
				-
			
 
				-		_objectCount = 0;
			
 
				-
			
 
				-		_renderData.objects.length = 0;
			
 
				-		_renderData.lights.length = 0;
			
 
				-
			
 
				-		scene.traverseVisible( function ( object ) {
			
 
				-
			
 
				-			if ( object instanceof THREE.Light ) {
			
 
				-
			
 
				-				_renderData.lights.push( object );
			
 
				-
			
 
				-			} else if ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Sprite ) {
			
 
				-
			
 
				-				if ( object.material.visible === false ) return;
			
 
				-
			
 
				-				if ( object.frustumCulled === false || _frustum.intersectsObject( object ) === true ) {
			
 
				-
			
 
				-					_object = getNextObjectInPool();
			
 
				-					_object.id = object.id;
			
 
				-					_object.object = object;
			
 
				-
			
 
				-					if ( object.renderDepth !== null ) {
			
 
				-
			
 
				-						_object.z = object.renderDepth;
			
 
				-
			
 
				-					} else {
			
 
				-
			
 
				-						_vector3.setFromMatrixPosition( object.matrixWorld );
			
 
				-						_vector3.applyProjection( _viewProjectionMatrix );
			
 
				-						_object.z = _vector3.z;
			
 
				-
			
 
				-					}
			
 
				-
			
 
				-					_renderData.objects.push( _object );
			
 
				-
			
 
				-				}
			
 
				-
			
 
				-			}
			
 
				-
			
 
				-		} );
			
 
				-
			
 
				-		if ( sortObjects === true ) {
			
 
				-
			
 
				-			_renderData.objects.sort( painterSort );
			
 
				-
			
 
				-		}
			
 
				-
			
 
				-		//
			
 
				-
			
 
				-		for ( var o = 0, ol = _renderData.objects.length; o < ol; o ++ ) {
			
 
				-
			
 
				-			var object = _renderData.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 attributes = geometry.attributes;
			
 
				-					var offsets = geometry.offsets;
			
 
				-
			
 
				-					if ( attributes.position === undefined ) continue;
			
 
				-
			
 
				-					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.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.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 ( attributes.index !== undefined ) {
			
 
				-
			
 
				-						var indices = attributes.index.array;
			
 
				-
			
 
				-						if ( offsets.length > 0 ) {
			
 
				-
			
 
				-							for ( var o = 0; o < offsets.length; o ++ ) {
			
 
				-
			
 
				-								var offset = offsets[ o ];
			
 
				-								var index = offset.index;
			
 
				-
			
 
				-								for ( var i = offset.start, l = offset.start + offset.count; i < l; i += 3 ) {
			
 
				-
			
 
				-									renderList.pushTriangle( indices[ i ] + index, indices[ i + 1 ] + index, indices[ i + 2 ] + index );
			
 
				-
			
 
				-								}
			
 
				-
			
 
				-							}
			
 
				-
			
 
				-						} else {
			
 
				-
			
 
				-							for ( var i = 0, l = indices.length; i < l; i += 3 ) {
			
 
				-
			
 
				-								renderList.pushTriangle( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] );
			
 
				-
			
 
				-							}
			
 
				-
			
 
				-						}
			
 
				-
			
 
				-					} else {
			
 
				-
			
 
				-						for ( var i = 0, l = positions.length / 3; i < l; i += 3 ) {
			
 
				-
			
 
				-							renderList.pushTriangle( i, i + 1, i + 2 );
			
 
				-
			
 
				-						}
			
 
				-
			
 
				-					}
			
 
				-
			
 
				-				} else if ( geometry instanceof THREE.Geometry ) {
			
 
				-
			
 
				-					var vertices = geometry.vertices;
			
 
				-					var faces = geometry.faces;
			
 
				-					var faceVertexUvs = geometry.faceVertexUvs[ 0 ];
			
 
				-
			
 
				-					_normalMatrix.getNormalMatrix( _modelMatrix );
			
 
				-
			
 
				-					var isFaceMaterial = object.material instanceof THREE.MeshFaceMaterial;
			
 
				-					var objectMaterials = isFaceMaterial === true ? object.material : null;
			
 
				-
			
 
				-					for ( var v = 0, vl = vertices.length; v < vl; v ++ ) {
			
 
				-
			
 
				-						var vertex = vertices[ v ];
			
 
				-						renderList.pushVertex( vertex.x, vertex.y, vertex.z );
			
 
				-
			
 
				-					}
			
 
				-
			
 
				-					for ( var f = 0, fl = faces.length; f < fl; f ++ ) {
			
 
				-
			
 
				-						var face = faces[ f ];
			
 
				-
			
 
				-						var material = isFaceMaterial === true
			
 
				-							 ? objectMaterials.materials[ 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 ( material.morphTargets === true ) {
			
 
				-
			
 
				-							var morphTargets = geometry.morphTargets;
			
 
				-							var morphInfluences = object.morphTargetInfluences;
			
 
				-
			
 
				-							var v1p = v1.position;
			
 
				-							var v2p = v2.position;
			
 
				-							var v3p = v3.position;
			
 
				-
			
 
				-							_vA.set( 0, 0, 0 );
			
 
				-							_vB.set( 0, 0, 0 );
			
 
				-							_vC.set( 0, 0, 0 );
			
 
				-
			
 
				-							for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {
			
 
				-
			
 
				-								var influence = morphInfluences[ t ];
			
 
				-
			
 
				-								if ( influence === 0 ) continue;
			
 
				-
			
 
				-								var targets = morphTargets[ t ].vertices;
			
 
				-
			
 
				-								_vA.x += ( targets[ face.a ].x - v1p.x ) * influence;
			
 
				-								_vA.y += ( targets[ face.a ].y - v1p.y ) * influence;
			
 
				-								_vA.z += ( targets[ face.a ].z - v1p.z ) * influence;
			
 
				-
			
 
				-								_vB.x += ( targets[ face.b ].x - v2p.x ) * influence;
			
 
				-								_vB.y += ( targets[ face.b ].y - v2p.y ) * influence;
			
 
				-								_vB.z += ( targets[ face.b ].z - v2p.z ) * influence;
			
 
				-
			
 
				-								_vC.x += ( targets[ face.c ].x - v3p.x ) * influence;
			
 
				-								_vC.y += ( targets[ face.c ].y - v3p.y ) * influence;
			
 
				-								_vC.z += ( targets[ face.c ].z - v3p.z ) * influence;
			
 
				-
			
 
				-							}
			
 
				-
			
 
				-							v1.position.add( _vA );
			
 
				-							v2.position.add( _vB );
			
 
				-							v3.position.add( _vC );
			
 
				-
			
 
				-							renderList.projectVertex( v1 );
			
 
				-							renderList.projectVertex( v2 );
			
 
				-							renderList.projectVertex( v3 );
			
 
				-
			
 
				-						}
			
 
				-
			
 
				-						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;
			
 
				-
			
 
				-						_renderData.elements.push( _face );
			
 
				-
			
 
				-					}
			
 
				-
			
 
				-				}
			
 
				-
			
 
				-			} else if ( object instanceof THREE.Line ) {
			
 
				-
			
 
				-				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.index !== undefined ) {
			
 
				-
			
 
				-							var indices = attributes.index.array;
			
 
				-
			
 
				-							for ( var i = 0, l = indices.length; i < l; i += 2 ) {
			
 
				-
			
 
				-								renderList.pushLine( indices[ i ], indices[ i + 1 ] );
			
 
				-
			
 
				-							}
			
 
				-
			
 
				-						} else {
			
 
				-
			
 
				-							var step = object.type === THREE.LinePieces ? 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 ) {
			
 
				-
			
 
				-					_modelViewProjectionMatrix.multiplyMatrices( _viewProjectionMatrix, _modelMatrix );
			
 
				-
			
 
				-					var vertices = object.geometry.vertices;
			
 
				-
			
 
				-					if ( vertices.length === 0 ) continue;
			
 
				-
			
 
				-					v1 = getNextVertexInPool();
			
 
				-					v1.positionScreen.copy( vertices[ 0 ] ).applyMatrix4( _modelViewProjectionMatrix );
			
 
				-
			
 
				-					// Handle LineStrip and LinePieces
			
 
				-					var step = object.type === THREE.LinePieces ? 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.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.Sprite ) {
			
 
				-
			
 
				-				_vector4.set( _modelMatrix.elements[ 12 ], _modelMatrix.elements[ 13 ], _modelMatrix.elements[ 14 ], 1 );
			
 
				-				_vector4.applyMatrix4( _viewProjectionMatrix );
			
 
				-
			
 
				-				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.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 );
			
 
				-
			
 
				-				}
			
 
				-
			
 
				-			}
			
 
				-
			
 
				-		}
			
 
				-
			
 
				-		if ( sortElements === true ) {
			
 
				-
			
 
				-			_renderData.elements.sort( painterSort );
			
 
				-
			
 
				-		}
			
 
				-
			
 
				-		return _renderData;
			
 
				-
			
 
				-	};
			
 
				-
			
 
				-	// Pools
			
 
				-
			
 
				-	function getNextObjectInPool() {
			
 
				-
			
 
				-		if ( _objectCount === _objectPoolLength ) {
			
 
				-
			
 
				-			var object = new THREE.RenderableObject();
			
 
				-			_objectPool.push( object );
			
 
				-			_objectPoolLength ++;
			
 
				-			_objectCount ++;
			
 
				-			return object;
			
 
				-
			
 
				-		}
			
 
				-
			
 
				-		return _objectPool[ _objectCount ++ ];
			
 
				-
			
 
				-	}
			
 
				-
			
 
				-	function getNextVertexInPool() {
			
 
				-
			
 
				-		if ( _vertexCount === _vertexPoolLength ) {
			
 
				-
			
 
				-			var vertex = new THREE.RenderableVertex();
			
 
				-			_vertexPool.push( vertex );
			
 
				-			_vertexPoolLength ++;
			
 
				-			_vertexCount ++;
			
 
				-			return vertex;
			
 
				-
			
 
				-		}
			
 
				-
			
 
				-		return _vertexPool[ _vertexCount ++ ];
			
 
				-
			
 
				-	}
			
 
				-
			
 
				-	function getNextFaceInPool() {
			
 
				-
			
 
				-		if ( _faceCount === _facePoolLength ) {
			
 
				-
			
 
				-			var face = new THREE.RenderableFace();
			
 
				-			_facePool.push( face );
			
 
				-			_facePoolLength ++;
			
 
				-			_faceCount ++;
			
 
				-			return face;
			
 
				-
			
 
				-		}
			
 
				-
			
 
				-		return _facePool[ _faceCount ++ ];
			
 
				-
			
 
				-
			
 
				-	}
			
 
				-
			
 
				-	function getNextLineInPool() {
			
 
				-
			
 
				-		if ( _lineCount === _linePoolLength ) {
			
 
				-
			
 
				-			var line = new THREE.RenderableLine();
			
 
				-			_linePool.push( line );
			
 
				-			_linePoolLength ++;
			
 
				-			_lineCount ++
			
 
				-			return line;
			
 
				-
			
 
				-		}
			
 
				-
			
 
				-		return _linePool[ _lineCount ++ ];
			
 
				-
			
 
				-	}
			
 
				-
			
 
				-	function getNextSpriteInPool() {
			
 
				-
			
 
				-		if ( _spriteCount === _spritePoolLength ) {
			
 
				-
			
 
				-			var sprite = new THREE.RenderableSprite();
			
 
				-			_spritePool.push( sprite );
			
 
				-			_spritePoolLength ++;
			
 
				-			_spriteCount ++
			
 
				-			return sprite;
			
 
				-
			
 
				-		}
			
 
				-
			
 
				-		return _spritePool[ _spriteCount ++ ];
			
 
				-
			
 
				-	}
			
 
				-
			
 
				-	//
			
 
				-
			
 
				-	function painterSort( a, b ) {
			
 
				-
			
 
				-		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, alpha2 = 1,
			
 
				-
			
 
				-		// Calculate the boundary coordinate of each vertex for the near and far clip planes,
			
 
				-		// Z = -1 and Z = +1, respectively.
			
 
				-		bc1near =  s1.z + s1.w,
			
 
				-		bc2near =  s2.z + s2.w,
			
 
				-		bc1far =  - s1.z + s1.w,
			
 
				-		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;
			
 
				-
			
 
				-			}
			
 
				-
			
 
				-		}
			
 
				-
			
 
				-	}
			
 
				-
			
 
				 };
			
--- a/src/materials/SpriteCanvasMaterial.js
+++ b/src/materials/SpriteCanvasMaterial.js
@@ -1,42 +0,0 @@
 
				-/**
			
 
				- * @author mrdoob / http://mrdoob.com/
			
 
				- *
			
 
				- * parameters = {
			
 
				- *  color: <hex>,
			
 
				- *  program: <function>,
			
 
				- *  opacity: <float>,
			
 
				- *  blending: THREE.NormalBlending
			
 
				- * }
			
 
				- */
			
 
				-
			
 
				-THREE.SpriteCanvasMaterial = function ( parameters ) {
			
 
				-
			
 
				-	THREE.Material.call( this );
			
 
				-
			
 
				-	this.type = 'SpriteCanvasMaterial';
			
 
				-
			
 
				-	this.color = new THREE.Color( 0xffffff );
			
 
				-	this.program = function ( context, color ) {};
			
 
				-
			
 
				-	this.setValues( parameters );
			
 
				-
			
 
				-};
			
 
				-
			
 
				-THREE.SpriteCanvasMaterial.prototype = Object.create( THREE.Material.prototype );
			
 
				-
			
 
				-THREE.SpriteCanvasMaterial.prototype.clone = function () {
			
 
				-
			
 
				-	var material = new THREE.SpriteCanvasMaterial();
			
 
				-
			
 
				-	THREE.Material.prototype.clone.call( this, material );
			
 
				-
			
 
				-	material.color.copy( this.color );
			
 
				-	material.program = this.program;
			
 
				-
			
 
				-	return material;
			
 
				-
			
 
				-};
			
 
				-
			
 
				-// backwards compatibility
			
 
				-
			
 
				-THREE.ParticleCanvasMaterial = THREE.SpriteCanvasMaterial;
			
--- a/src/renderers/renderables/RenderableFace.js
+++ b/src/renderers/renderables/RenderableFace.js
@@ -1,24 +0,0 @@
 
				-/**
			
 
				- * @author mrdoob / http://mrdoob.com/
			
 
				- */
			
 
				-
			
 
				-THREE.RenderableFace = function () {
			
 
				-
			
 
				-	this.id = 0;
			
 
				-
			
 
				-	this.v1 = new THREE.RenderableVertex();
			
 
				-	this.v2 = new THREE.RenderableVertex();
			
 
				-	this.v3 = new THREE.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;
			
 
				-
			
 
				-};
			
--- a/src/renderers/renderables/RenderableLine.js
+++ b/src/renderers/renderables/RenderableLine.js
@@ -1,17 +0,0 @@
 
				-/**
			
 
				- * @author mrdoob / http://mrdoob.com/
			
 
				- */
			
 
				-
			
 
				-THREE.RenderableLine = function () {
			
 
				-
			
 
				-	this.id = 0;
			
 
				-
			
 
				-	this.v1 = new THREE.RenderableVertex();
			
 
				-	this.v2 = new THREE.RenderableVertex();
			
 
				-
			
 
				-	this.vertexColors = [ new THREE.Color(), new THREE.Color() ];
			
 
				-	this.material = null;
			
 
				-
			
 
				-	this.z = 0;
			
 
				-
			
 
				-};
			
--- a/src/renderers/renderables/RenderableObject.js
+++ b/src/renderers/renderables/RenderableObject.js
@@ -1,12 +0,0 @@
 
				-/**
			
 
				- * @author mrdoob / http://mrdoob.com/
			
 
				- */
			
 
				-
			
 
				-THREE.RenderableObject = function () {
			
 
				-
			
 
				-	this.id = 0;
			
 
				-
			
 
				-	this.object = null;
			
 
				-	this.z = 0;
			
 
				-
			
 
				-};
			
--- a/src/renderers/renderables/RenderableSprite.js
+++ b/src/renderers/renderables/RenderableSprite.js
@@ -1,20 +0,0 @@
 
				-/**
			
 
				- * @author mrdoob / http://mrdoob.com/
			
 
				- */
			
 
				-
			
 
				-THREE.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;
			
 
				-
			
 
				-};
			
--- a/src/renderers/renderables/RenderableVertex.js
+++ b/src/renderers/renderables/RenderableVertex.js
@@ -1,20 +0,0 @@
 
				-/**
			
 
				- * @author mrdoob / http://mrdoob.com/
			
 
				- */
			
 
				-
			
 
				-THREE.RenderableVertex = function () {
			
 
				-
			
 
				-	this.position = new THREE.Vector3();
			
 
				-	this.positionWorld = new THREE.Vector3();
			
 
				-	this.positionScreen = new THREE.Vector4();
			
 
				-
			
 
				-	this.visible = true;
			
 
				-
			
 
				-};
			
 
				-
			
 
				-THREE.RenderableVertex.prototype.copy = function ( vertex ) {
			
 
				-
			
 
				-	this.positionWorld.copy( vertex.positionWorld );
			
 
				-	this.positionScreen.copy( vertex.positionScreen );
			
 
				-
			
 
				-};
			
--- a/utils/build/includes/common.json
+++ b/utils/build/includes/common.json
@@ -63,7 +63,6 @@
 
				 	"src/materials/ShaderMaterial.js",
			
 
				 	"src/materials/RawShaderMaterial.js",
			
 
				 	"src/materials/SpriteMaterial.js",
			
 
				-	"src/materials/SpriteCanvasMaterial.js",
			
 
				 	"src/textures/Texture.js",
			
 
				 	"src/textures/CubeTexture.js",
			
 
				 	"src/textures/CompressedTexture.js",
			
@@ -82,7 +81,6 @@
 
				 	"src/scenes/Scene.js",
			
 
				 	"src/scenes/Fog.js",
			
 
				 	"src/scenes/FogExp2.js",
			
 
				-	"src/renderers/CanvasRenderer.js",
			
 
				 	"src/renderers/shaders/ShaderChunk.js",
			
 
				 	"src/renderers/shaders/ShaderChunk/alphatest_fragment.glsl",
			
 
				 	"src/renderers/shaders/ShaderChunk/lights_lambert_vertex.glsl",
			
@@ -143,10 +141,5 @@
 
				 	"src/renderers/WebGLRenderTarget.js",
			
 
				 	"src/renderers/WebGLRenderTargetCube.js",
			
 
				 	"src/renderers/webgl/WebGLProgram.js",
			
 
				-	"src/renderers/webgl/WebGLShader.js",
			
 
				-	"src/renderers/renderables/RenderableVertex.js",
			
 
				-	"src/renderers/renderables/RenderableFace.js",
			
 
				-	"src/renderers/renderables/RenderableObject.js",
			
 
				-	"src/renderers/renderables/RenderableSprite.js",
			
 
				-	"src/renderers/renderables/RenderableLine.js"
			
 
				+	"src/renderers/webgl/WebGLShader.js"
			
 
				 ]
			
--- a/utils/build/includes/webgl.json
+++ b/utils/build/includes/webgl.json
@@ -134,11 +134,6 @@
 
				 	"src/renderers/WebGLRenderTargetCube.js",
			
 
				 	"src/renderers/webgl/WebGLProgram.js",
			
 
				 	"src/renderers/webgl/WebGLShader.js",
			
 
				-	"src/renderers/renderables/RenderableVertex.js",
			
 
				-	"src/renderers/renderables/RenderableFace.js",
			
 
				-	"src/renderers/renderables/RenderableObject.js",
			
 
				-	"src/renderers/renderables/RenderableSprite.js",
			
 
				-	"src/renderers/renderables/RenderableLine.js",
			
 
				 	"src/extras/core/Gyroscope.js",
			
 
				 	"src/extras/helpers/CameraHelper.js",
			
 
				 	"src/extras/helpers/DirectionalLightHelper.js",
			
@@ -152,4 +147,3 @@
 
				 	"src/extras/renderers/plugins/SpritePlugin.js",
			
 
				 	"src/extras/shaders/ShaderFlares.js"
			
 
				 ]
			
 
				-