 	import aerys.minko.scene.node.Mesh;
 	import aerys.minko.type.animation.SkinningMethod;
 	
-	import flash.geom.Matrix3D;
-	import flash.utils.ByteArray;
-	import flash.utils.Dictionary;
-	
 	internal final class SoftwareSkinningHelper extends AbstractSkinningHelper
 	{
 		private static const TMP_VECTOR : Vector.<uint> = new <uint>[];

					}
					
					var invNormalLength : Number = 1 / Math.sqrt(outNx * outNx + outNy * outNy + outNz * outNz);
					
					fakeData.position = positionOffset;
					fakeData.writeFloat(outX);
					fakeData.writeFloat(outY);
					fakeData.writeFloat(outZ);
					
					fakeData.position = normalOffset;
					fakeData.writeFloat(outNx * invNormalLength);
					fakeData.writeFloat(outNy * invNormalLength);
					fakeData.writeFloat(outNz * invNormalLength);
				}
				
				realStream.unlock(false);
				fakeStream.unlock();
			}
		}
	}

								+ inY * _matrices[uint(matrixOffset + 9)]
								+ inZ * _matrices[uint(matrixOffset + 10)]
								+ _matrices[uint(matrixOffset + 11)]);
						}
					}
										
					fakeDataXYZ.position = positionOffset;
					fakeDataXYZ.writeFloat(outX);
					fakeDataXYZ.writeFloat(outY);
					fakeDataXYZ.writeFloat(outZ);
				}
				
				
				if (streamId == 0)
				{
					format				= realStreamNormal.format;
					dataLength			= realDataNormal.length;
					bytesPerVertex		= format.numBytesPerVertex;
					stride				= format.getBytesOffsetForComponent(VertexComponent.NORMAL);
					getInfluenceStrides(format, TMP_VECTOR);
					numInfluences		= influenceStrides.length;
				}
				
				for (offset = 0; offset < dataLength; offset += bytesPerVertex)
				{
					var normalOffset	: uint		= offset + stride;
					realDataNormal.position = normalOffset;
					var inNx			: Number	= realDataNormal.readFloat();
					var inNy			: Number	= realDataNormal.readFloat();
					var inNz			: Number	= realDataNormal.readFloat();
					
					var outNx			: Number	= 0;
					var outNy			: Number	= 0;
					var outNz			: Number	= 0;
					
					for (influenceId = 0; influenceId < numInfluences; ++influenceId)
					{
						realDataNormal.position = offset + influenceStrides[influenceId];
						
						jointId			= realDataNormal.readFloat();
						jointWeight		= realDataNormal.readFloat();
						matrixOffset	= 16 * jointId;
						
						if (jointWeight != 0)
						{							
							outNx += jointWeight * (inNx * _matrices[uint(matrixOffset + 0)]
								+ inNy * _matrices[uint(matrixOffset + 1)]
								+ inNz * _matrices[uint(matrixOffset + 2)]);
