 		 * the "replace" argument to "true".
 		 * 
 		 * @param streamUsage The StreamUsage for the new vertex stream that stores the normals data.
+		 * If no value is provided, the StreamUsage of the vertex stream holding the VertexComponent.XYZ
+		 * will be used.
+		 * 
 		 * @param replace Whether the existing normals data should be replaced if it exists.
 		 * 
 		 */
-		public function computeNormals(streamUsage : uint, replace : Boolean = false) : Geometry
-		{
-			var indices			: Vector.<uint>		= _indexStream._data;
-			var numTriangles	: int				= _indexStream.length / 3;
-			var numStreams		: int				= _vertexStreams.length;
-			
-			for (var streamId : int = 0; streamId < numStreams; ++streamId)
-			{
-				var stream			: IVertexStream		= _vertexStreams[streamId];
-				var xyzStream		: VertexStream		= stream.getStreamByComponent(VertexComponent.XYZ);
-				var vertexOffset	: int 				= xyzStream.format.getOffsetForComponent(VertexComponent.XYZ);
-				var vertexLength	: int 				= xyzStream.format.size;
-				var vertices		: Vector.<Number>	= xyzStream._data;
-				var numVertices		: int				= vertices.length / vertexLength;
-				var normals			: Vector.<Number>	= new Vector.<Number>(3 * numVertices);
-				var i				: int				= 0;
-				
-				for (i = 0; i < numTriangles; ++i)
-				{
-					var i0	: int 		= indices[int(3 * i)];
-					var i1	: int 		= indices[int(3 * i + 1)];
-					var i2	: int 		= indices[int(3 * i + 2)];
-					
-					var ii0	: int 		= vertexOffset + vertexLength * i0;
-					var ii1	: int		= vertexOffset + vertexLength * i1;
-					var ii2	: int 		= vertexOffset + vertexLength * i2;
-					
-					var x0	: Number 	= vertices[ii0];
-					var y0	: Number 	= vertices[int(ii0 + 1)];
-					var z0	: Number 	= vertices[int(ii0 + 2)];
-					
-					var x1	: Number 	= vertices[ii1];
-					var y1	: Number 	= vertices[int(ii1 + 1)];
-					var z1	: Number 	= vertices[int(ii1 + 2)];
-					
-					var x2	: Number 	= vertices[ii2];
-					var y2	: Number 	= vertices[int(ii2 + 1)];
-					var z2	: Number 	= vertices[int(ii2 + 2)];
-					
-					var nx	: Number 	= (y0 - y2) * (z0 - z1) - (z0 - z2) * (y0 - y1);
-					var ny	: Number 	= (z0 - z2) * (x0 - x1) - (x0 - x2) * (z0 - z1);
-					var nz	: Number 	= (x0 - x2) * (y0 - y1) - (y0 - y2) * (x0 - x1);
-					
-					normals[int(i0 * 3)] += nx;
-					normals[int(i0 * 3 + 1)] += ny;
-					normals[int(i0 * 3 + 2)] += nz;
-					
-					normals[int(i1 * 3)] += nx;
-					normals[int(i1 * 3 + 1)] += ny;
-					normals[int(i1 * 3 + 2)] += nz;
-					
-					normals[int(i2 * 3)] += nx;
-					normals[int(i2 * 3 + 1)] += ny;
-					normals[int(i2 * 3 + 2)] += nz;
-				}
-				
-				
-				for (i = 0; i < numVertices; ++i)
-				{
-					var x	: Number = normals[int(i * 3)];
-					var y	: Number = normals[int(i * 3 + 1)];
-					var z	: Number = normals[int(i * 3 + 2)];
-					
-					var mag	: Number = Math.sqrt(x * x + y * y + z * z);
-					
-					if (mag != 0.)
-					{
-						normals[uint(i * 3)] /= mag;
-						normals[uint(i * 3 + 1)] /= mag;
-						normals[uint(i * 3 + 2)] /= mag;
-					}
-				}
-				
-				pushVertexStream(
-					streamId,
-					new VertexStream(streamUsage, FORMAT_NORMALS, normals),
-					replace
-				);
+		public function computeNormals(streamUsage : uint = 0) : Geometry
+		{
+			var numStreams		: uint			= this.numVertexStreams;
+			var indices			: Vector.<uint>	= indexStream.lock();
+			var numTriangles	: int			= indexStream.length / 3;
+			var stream			: IVertexStream	= null;
+			
+			if (numStreams != 0)
+			{
+				stream = getVertexStream();
+				
+				if (!stream.format.hasComponent(VertexComponent.XYZ))
+					throw new Error('Unable to compute normals without VertexComponent.XYZ');
+				
+				streamUsage ||= stream.getStreamByComponent(VertexComponent.XYZ).usage;
+					
+				for (var streamId : uint = 0; streamId < numStreams; ++streamId)
+				{
+					stream = getVertexStream(streamId);
+					
+					var numVertices		: uint				= stream.length;
+					var xyzStream		: VertexStream		= stream.getStreamByComponent(VertexComponent.XYZ);
+					var normalsStream 	: VertexStream		= stream.getStreamByComponent(VertexComponent.NORMAL);
+					var hasNormals		: Boolean			= normalsStream != null;
+					
+					if (!hasNormals)
+						normalsStream = new VertexStream(streamUsage, FORMAT_NORMALS, new Vector.<Number>(numVertices * 3));
+					
+					fillNormalsData(indices, normalsStream, xyzStream, numVertices);
+					
+					if (!hasNormals)
+						pushVertexStreamInList(streamId, normalsStream);
+				}
 			}
 			
 			return this;

					}
				}
				
				pushVertexStream(
					streamId,
					new VertexStream(streamUsage, withNormals ? FORMAT_TN : FORMAT_TANGENTS, data),
					replace

			}
			
			return this;
		}*/
		
		private function pushVertexStreamInList(index 			: uint,
												vertexStream 	: VertexStream,
												force 			: Boolean	= false) : void
		{
			var stream	: IVertexStream	= _vertexStreams[index];
			
