/src/aerys/minko/type/parser/collada/resource/Geometry.as

  1package aerys.minko.type.parser.collada.resource
  2{
  3	import aerys.minko.Minko;
  4	import aerys.minko.ns.minko_collada;
  5	import aerys.minko.ns.minko_stream;
  6	import aerys.minko.render.geometry.GeometrySanitizer;
  7	import aerys.minko.render.geometry.stream.IndexStream;
  8	import aerys.minko.render.geometry.stream.VertexStream;
  9	import aerys.minko.render.geometry.stream.iterator.VertexIterator;
 10	import aerys.minko.render.geometry.stream.iterator.VertexReference;
 11	import aerys.minko.type.loader.parser.ParserOptions;
 12	import aerys.minko.type.parser.collada.ColladaDocument;
 13	import aerys.minko.type.parser.collada.helper.MeshTemplate;
 14	import aerys.minko.type.parser.collada.helper.Source;
 15	import aerys.minko.type.parser.collada.helper.Triangles;
 16	import aerys.minko.type.parser.collada.instance.IInstance;
 17	import aerys.minko.type.parser.collada.instance.InstanceGeometry;
 18	
 19	import flash.utils.ByteArray;
 20	
 21	public class Geometry implements IResource
 22	{
 23		use namespace minko_collada;
 24		
 25		private static const NS : Namespace = new Namespace("http://www.collada.org/2005/11/COLLADASchema");
 26		
 27		private var _document				: ColladaDocument;
 28		
 29		private var _id						: String;
 30		private var _name					: String;
 31		private var _verticesDataSemantics	: Vector.<String>;
 32		private var _verticesDataSources	: Object;
 33		private var _triangleStores			: Vector.<Triangles>;
 34		
 35		private var _meshTemplates			: Vector.<MeshTemplate>;
 36		
 37		public function get id() : String
 38		{
 39			return _id;
 40		}
 41		
 42		minko_collada function get verticesDataSemantics() : Vector.<String>
 43		{
 44			return _verticesDataSemantics;
 45		}
 46		
 47		minko_collada function get verticesDataSources() : Object
 48		{ 
 49			return _verticesDataSources; 
 50		}
 51		
 52		minko_collada function get triangleStores() : Vector.<Triangles>
 53		{
 54			return _triangleStores; 
 55		}
 56		
 57		public function get meshTemplates() : Vector.<MeshTemplate>
 58		{
 59			return _meshTemplates;
 60		}
 61		
 62		public static function fillStoreFromXML(xmlDocument	: XML,
 63												document	: ColladaDocument, 
 64												store		: Object) : void
 65		{
 66			var xmlGeometryLibrary	: XML		= xmlDocument..NS::library_geometries[0];
 67			
 68			if (xmlGeometryLibrary == null)
 69				return;
 70			
 71			var xmlGeometries		: XMLList	= xmlGeometryLibrary.NS::geometry;
 72			
 73			for each (var xmlGeometry : XML in xmlGeometries)
 74			{
 75				var geometry : Geometry = Geometry.createFromXML(xmlGeometry, document);
 76				
 77				if (geometry)
 78					store[geometry.id] = geometry;
 79			}
 80		}
 81		
 82		public static function createFromXML(xmlGeometry : XML, document : ColladaDocument) : Geometry
 83		{
 84			var newGeometry : Geometry = new Geometry();
 85			
 86			newGeometry._document				= document;
 87			newGeometry._id						= xmlGeometry.@id;
 88			newGeometry._name					= xmlGeometry.@name;
 89			
 90			newGeometry._verticesDataSemantics	= new <String>[];
 91			newGeometry._verticesDataSources	= new Object();
 92			newGeometry._triangleStores			= new <Triangles>[];
 93			
 94			var xmlMesh		: XML = xmlGeometry.NS::mesh[0];
 95			
 96			if (!xmlMesh)
 97			{
 98				Minko.log(0, 'Unsupported geometry: \'' + newGeometry._name + '\'.');
 99				
100				return null;
101			}
102			
103			var xmlVertices	: XML = xmlMesh.NS::vertices[0];
104			
105			for each (var input : XML in xmlVertices.NS::input)
106			{
107				var semantic	: String	= String(input.@semantic);
108				var sourceId	: String	= String(input.@source).substr(1);
109				var xmlSource	: XML		= xmlMesh..NS::source.(@id == sourceId)[0];
110				var source		: Source	= Source.createFromXML(xmlSource);
111				
112				newGeometry._verticesDataSemantics.push(semantic);
113				newGeometry._verticesDataSources[semantic] = source;
114			}
115			
116			for each (var child : XML in xmlMesh.children())
117				switch (child.localName())
118				{
119					case 'lines':
120					case 'linestrips':
121					case 'polygons':
122					case 'polylist':
123					case 'triangles':
124					case 'trifans':
125					case 'tristrips':
126						newGeometry._triangleStores.push(new Triangles(child, xmlMesh));
127						break;
128				}
129			
130			return newGeometry;
131		}
132		
133		public function createInstance() : IInstance
134		{
135			return new InstanceGeometry(_document, _id); 
136		}
137		
138		/**
139		 * Generates a vector of MeshTemplate. One instance per triangle store under
140		 * this geometry.
141		 * 
142		 * @param options
143		 */
144		public function computeMeshTemplates(options : ParserOptions, fast : Boolean = false) : void
145		{
146			if (_meshTemplates != null)
147				return;
148			
149			_meshTemplates = new <MeshTemplate>[];
150			
151			for each (var triangleStore : Triangles in _triangleStores)
152			{
153				var materialName	: String = triangleStore.material;
154				var indexData		: Vector.<uint>;
155				var vertexStream	: VertexStream;
156				
157				if (fast)
158				{
159					indexData		= triangleStore.fastComputeIndexStream(_verticesDataSemantics, _verticesDataSources);
160					vertexStream	= triangleStore.fastComputeVertexStream(_verticesDataSemantics, _verticesDataSources);
161				}
162				else
163				{
164					indexData		= triangleStore.computeIndexStream();
165					vertexStream	= triangleStore.computeVertexStream(_verticesDataSemantics, _verticesDataSources);
166				}
167				
168				var vertexData		: ByteArray	= vertexStream.minko_stream::_data;
169				var dwordsPerVertex	: uint		= vertexStream.format.numBytesPerVertex;
170				
171				var meshTemplate	: MeshTemplate	= new MeshTemplate(
172					_name, 
173					vertexData,
174					indexData,
175					materialName,
176					vertexStream.format
177				);
178				
179				_meshTemplates.push(meshTemplate);
180			}
181		}
182	}
183}