// Obj Importer v0.1
// Tomasz Kulczycki / Janmedia 2008

package com.jm.import3d{

	import flash.display.MovieClip;
	import flash.net.URLLoader;
	import flash.net.URLRequest;
	import flash.events.*;


	import org.papervision3d.core.geom.*;
	import org.papervision3d.core.math.*;
	import org.papervision3d.core.proto.MaterialObject3D;
	import org.papervision3d.core.proto.GeometryObject3D;
	import org.papervision3d.core.proto.DisplayObjectContainer3D;
	import org.papervision3d.core.geom.renderables.*;
	import org.papervision3d.events.FileLoadEvent;
	import org.papervision3d.materials.*;
	import org.papervision3d.objects.DisplayObject3D;

	public class Obj3D extends DisplayObject3D {

		var fileObj:String;

		var obj:DisplayObject3D = new DisplayObject3D();
		var obj_material:MaterialObject3D;
		
		public var mesh:TriangleMesh3D;
		public var loaded :Boolean;
		
		private var _container  :DisplayObjectContainer3D;
		private var _geometries :Object;
		private var _loader     :URLLoader;
		private var _filename   :String;
		private var _materials  :MaterialObject3D;
		
		public function Obj3D(url:String, mat:MaterialObject3D=null,  initObject:Object=null) {

			super(null, null, initObject);
			trace("Loading OBJ data: " + url);
			obj_material = mat;
			this._materials = mat || new MaterialObject3D();
			this._filename = url;
			this._container = this;
			this.loaded = false;
			loadObj();			
		}
		
		private function loadObj():void
		{
			this._loader = new URLLoader();
			this._loader.addEventListener( Event.COMPLETE, onComplete );
			this._loader.addEventListener(IOErrorEvent.IO_ERROR, handleIOError);
			this._loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, handleSecurityLoadError);
			this._loader.addEventListener( ProgressEvent.PROGRESS, handleLoadProgress );
			this._loader.load( new URLRequest( this._filename ) );
		}
		
		private function handleLoadProgress( e:ProgressEvent ):void
		{
			var progressEvent:FileLoadEvent = new FileLoadEvent( FileLoadEvent.LOAD_PROGRESS, this._filename, e.bytesLoaded, e.bytesTotal);
			dispatchEvent( progressEvent );
		}
		
		private function handleIOError(e:IOErrorEvent):void
		{
			trace("OBJ file load error", e.text);
			dispatchEvent(new FileLoadEvent(FileLoadEvent.LOAD_ERROR,this._filename,0,0,e.text));
		}
		
		private function handleSecurityLoadError(e:SecurityErrorEvent):void
		{
			trace("OBJ file security load error", e.text);
			dispatchEvent(new FileLoadEvent(FileLoadEvent.SECURITY_LOAD_ERROR,this._filename, 0, 0, e.text));
		}
		
		private function onComplete(evt:Event):void{
			fileObj = _loader.data;
	
			buildObj();
		}
		
		private function buildObj():void {
			var newObj:TriangleMesh3D = new TriangleMesh3D(null, null, null);
			parseObj(newObj, this._container);
	
			var fileEvent:FileLoadEvent = new FileLoadEvent( FileLoadEvent.LOAD_COMPLETE, _filename );
			this.dispatchEvent( fileEvent );
	
			this.loaded = true;
		}
		
		private function parseObj(newObj:DisplayObject3D, parent:DisplayObjectContainer3D):void {

			var instance:DisplayObject3D = parent.addChild(newObj, "obj");
			
			instance.addGeometry(new GeometryObject3D());
			var points3d:Array = instance.geometry.vertices = new Array();
			var triangles3d:Array = instance.geometry.faces = new Array();
			
			var tmp_verts:String;
			var indS:Number = fileObj.indexOf('\n'+"v ", 0);
			var indN:Number;
			var indE:Number = fileObj.lastIndexOf('\n'+"v ");
			var verts:Array = new Array();

			while (indS <= indE) {
				indN = fileObj.indexOf('\n'+"v ", indS+1);
				if (indN == -1) {
					indN = fileObj.indexOf('\n', indS+1);
					tmp_verts = fileObj.slice(indS+3,indN-1);
				} else {

					tmp_verts = fileObj.slice(indS+3,indN-1);
				}
				verts.push(tmp_verts);
				indS = indN;
			}
			indS = fileObj.indexOf('\n'+"vt ", 0);
			var triangles:Array = new Array();
			if (indS > 0) {
				indE = fileObj.lastIndexOf('\n'+"f ");
				while (indS <= indE) {
					indN = fileObj.indexOf('\n', indS+1);
					tmp_verts = fileObj.slice(indS+1,indN-1);
					triangles.push(tmp_verts);
					indS = indN;
				}
			} else {
				indS = fileObj.indexOf('\n'+"f ", 0);
				indE = fileObj.lastIndexOf('\n'+"f ");
				
				while (indS <= indE) {
					indN = fileObj.indexOf('\n'+"f ", indS+1);
					if (indN == -1) {
						indN = fileObj.indexOf('\n', indS+1);
						tmp_verts = fileObj.slice(indS+3,indN-1);
					} else {
						tmp_verts = fileObj.slice(indS+3,indN-1);
					}
					triangles.push(tmp_verts);
					indS = indN;
				}
			}
			points3d = parsePoints(verts);
			triangles3d = parseTriangles(instance, triangles, points3d);
			
			instance.geometry.ready = true;
	
			instance.material = MaterialObject3D.DEFAULT;
	
			instance.visible  = true;
			newObj = new TriangleMesh3D(obj_material, points3d, triangles3d);
			instance = parent.addChild(newObj, "obj");
			
		}
		private function parsePoints(pts:Array):Array {
			var vts:Array = new Array();
			var pX, pY, pZ:Number;
			var indS:Number;
			var indE:Number;
			for (var i:Number=0; i<pts.length; i++) {
				indS = pts[i].indexOf(' ', 0);
				indE = pts[i].lastIndexOf(' ');
				pX = Number(pts[i].slice(0, indS))*(-1);
				pY = Number(pts[i].slice(indS, indE));
				pZ = Number(pts[i].slice(indE));
				vts.push(new Vertex3D(pX,pY,pZ));
			}
			trace("Points number: " + vts.length);
			return vts;
		}
		private function parseTriangles(instance:DisplayObject3D, trsL:Array, pts:Array):Array {
			var poligons:Array = new Array();
			var p1s, p2s, p3s:String;
			var uv1, uv2:Number;
			var indS:Number;
			var indE:Number;
			var indP:Number;
			var cord1, cord2, cord3:Object;
			var str:String;
			var uvcords:Array = new Array();
			for (var i:Number=0; i<trsL.length; i++) {
				
				str = trsL[i].slice(0,1)
				if (str == 'f') {
					indS = trsL[i].indexOf(' ', 2);
					indE = trsL[i].lastIndexOf(' ');
					p1s = trsL[i].slice(2, indS);
					cord1 = parseCord(p1s);
					p2s = trsL[i].slice(indS, indE);
					cord2 = parseCord(p2s);
					p3s = trsL[i].slice(indE);
					cord3 = parseCord(p3s);
					poligons.push(new Triangle3D(instance, new Array(pts[cord1.point-1], pts[cord2.point-1], pts[cord3.point-1]), obj_material, new Array(uvcords[cord3.uv-1],uvcords[cord2.uv-1],uvcords[cord1.uv-1])));
					uvcords = new Array();
				} else {
					indS = trsL[i].indexOf(' ', 3);
					uv1 = Number(trsL[i].slice(3, indS));
					uv2 = Number(trsL[i].slice(indS));
					uvcords.push(new NumberUV(uv1,uv2));
				}
			}
			trace("Poligons number: " + poligons.length);
			trace(" ");
			return(poligons);
		}
		private function parseCord(crd:String):Object {
			var cord:Object = new Object();
			cord.point = new Number();
			cord.uv = new Number();

			var indP:Number = crd.indexOf('/', 0);
			if (indP != -1) {
				cord.point = Number(crd.slice(0, indP));
				cord.uv = Number(crd.slice(indP+2));
				
			} else {
				cord.point = Number(crd);
				cord.uv = null;
			}
			return cord;
		}
	}
}