Parse Unreal .psk file to Stage3d VertexBuffer3D and IndexBuffer3D. Currently only read position and uv data.

PskParser.as3

package  
{
	import flash.display3D.Context3D;
	import flash.display3D.IndexBuffer3D;
	import flash.display3D.VertexBuffer3D;
	import flash.utils.ByteArray;
	import flash.utils.Endian;
	/**
	 * ...
	 * @author Wisher
         * @email hustitecwisher@gmail.com
	 */
	public class PskParser 
	{
		private var mContext3d:Context3D;
		private var mRawContent:ByteArray;
		private var mPointsArray:Array;
		private var mWedgesArray:Array;
		private var mFacesArray:Array;
		
		private var _posBuff:VertexBuffer3D;
		private var _uvBuff:VertexBuffer3D;
		private var _idxBuff:IndexBuffer3D;
		private var _idxLength:uint;
		
		public function PskParser(pskFile:Class, context3d:Context3D) 
		{
			var i:uint = 0;
			mRawContent = readFile(pskFile);
			
			readHead(mRawContent);
			
			i = readHead(mRawContent);
			mPointsArray = readPoints(mRawContent, i);
			
			i = readHead(mRawContent);
			mWedgesArray = readWedges(mRawContent, i);
			
			i = readHead(mRawContent);
			mFacesArray = readFaces(mRawContent, i);
			
			createBuff(context3d, mFacesArray, mWedgesArray, mPointsArray);
			
		}
		
		private function createBuff(c:Context3D, f:Array, w:Array, p:Array):void
		{	
			var pos:Vector.<Number> = new Vector.<Number>();
			var uv:Vector.<Number> = new Vector.<Number>();
			var idx:Vector.<uint> = new Vector.<uint>();
			var p_idx:uint;
			var i:uint = 0;
			
			for (i = 0; i < w.length; i++)
			{
				p_idx = w[i].idx;
				pos.push(p[p_idx].y, p[p_idx].z, p[p_idx].x);
				uv.push(w[i].u, w[i].v);
			}
			
			for (i = 0; i < f.length; i++)
			{
				idx.push(f[i].p1, f[i].p2, f[i].p3);
			}
			
			_posBuff = c.createVertexBuffer(pos.length / 3, 3);
			_uvBuff = c.createVertexBuffer(uv.length / 2, 2);
			
			_posBuff.uploadFromVector(pos, 0, pos.length / 3);
			_uvBuff.uploadFromVector(uv, 0, uv.length / 2);
			
			_idxBuff = c.createIndexBuffer(f.length * 3);
			_idxBuff.uploadFromVector(idx, 0, idx.length);
			_idxLength = f.length;

		}
		
		private function readFaces(b:ByteArray, i:uint):Array 
		{
			var p:Array = new Array();
			for (; i > 0; i--) 
			{
				p.push( { p1:b.readUnsignedShort(),
					p2:b.readUnsignedShort(),
					p3:b.readUnsignedShort(),
					matIdx:b.readUnsignedByte(),
					matIdx2:b.readUnsignedByte(),
					sg:b.readUnsignedInt() } );
			}
			return p;
		}
		
		private function readWedges(b:ByteArray, i:uint):Array 
		{
			var p:Array = new Array();
			for (; i > 0; i--) 
			{
				p.push( { idx:b.readUnsignedInt(), 
					u:b.readFloat(), 
					v:b.readFloat(),
					matIdx:b.readUnsignedByte() } );
				b.readMultiByte(3, "us-ascii");
			}
			return p;
		}
		
		private function readPoints(b:ByteArray, i:uint):Array 
		{
			var p:Array = new Array();
			for (; i > 0; i--) 
			{
				p.push( { x:b.readFloat(), 
					y:b.readFloat(), 
					z:b.readFloat()});
			}
			return p;
		}
		
		private function readHead(mRawContent:ByteArray):uint 
		{
			mRawContent.readMultiByte(28, "us-ascii");
			return mRawContent.readUnsignedInt();
		}
		
		private function readFile(pskFile:Class):ByteArray 
		{
			var b:ByteArray = new pskFile();
			b.readMultiByte(b.bytesAvailable, "us-ascii");
			b.endian = Endian.LITTLE_ENDIAN;
			b.position = 0;
			return b;
		}
		
		public function get posBuff():VertexBuffer3D 
		{
			return _posBuff;
		}
		
		public function get uvBuff():VertexBuffer3D 
		{
			return _uvBuff;
		}
		
		public function get idxBuff():IndexBuffer3D 
		{
			return _idxBuff;
		}
		
		public function get idxLength():uint 
		{
			return _idxLength;
		}
		
	}

}