コード例 #1
0
ファイル: DaeReader.cs プロジェクト: gleblebedev/toe
		//private static Float3 GetFloat3(int index, int stride, Input input, int[] poligonArray)
		//{
		//	return input.SourceData.GetFloat3(poligonArray[index * stride + input.Offset]);
		//}

		private void CopySkin(Scene scene, XElement instance, MeshSkinAndMaterials sam)
		{
			var bind = instance.Element(this.schema.bindMaterialName);
			if (bind != null)
			{
				var technique_common = bind.Element(this.schema.techniqueCommonName);
				if (technique_common != null)
				{
					var ms = new MaterialSet();
					foreach (var instanceMaterial in technique_common.Elements(this.schema.instanceMaterialName))
					{
						var symbol = instanceMaterial.AttributeValue(this.schema.symbolName);
						var target = instanceMaterial.AttributeValue(this.schema.targetName);
						var matId =
							this.collada.Element(this.schema.libraryMaterialsName).ElementByUrl(target).AttributeValue(this.schema.idName);
						ms.Add(symbol, (from m in scene.Materials where m.Id == matId select m).First());
					}
					sam.Materials.Add(ms);
				}
			}
		}
コード例 #2
0
ファイル: DaeReader.cs プロジェクト: gleblebedev/toe
		private void ParseTriangles(
			XElement mesh, MeshSkinAndMaterials skinAndMaterials, SeparateStreamsMesh dstMesh, XElement element)
		{
			var meshInputs = this.ParseInputs(element);
			
			int[] p = new int[meshInputs.Count * meshInputs.Stride * 3];
			this.ParseIntArray(element.ElementValue(this.schema.pName), p);

			var subMesh = dstMesh.CreateSubmesh();
			subMesh.Material = skinAndMaterials.GetAnyMaterialFor(element.AttributeValue(this.schema.materialAttributeName));
			subMesh.VertexSourceType = VertexSourceType.TriangleList;

			var streamList = StreamListOrderedByOffset(meshInputs, subMesh);

			for (int polygonIndex = 0; polygonIndex < meshInputs.Count; ++polygonIndex)
			{
				AddVertex(p, polygonIndex*3, streamList, meshInputs.Stride);
				AddVertex(p, polygonIndex * 3+1, streamList, meshInputs.Stride);
				AddVertex(p, polygonIndex * 3+2, streamList, meshInputs.Stride);
			}
		}
コード例 #3
0
ファイル: DaeReader.cs プロジェクト: gleblebedev/toe
		private void ParsePolylist(
			XElement mesh, MeshSkinAndMaterials skinAndMaterials, SeparateStreamsMesh dstMesh, XElement element)
		{
			var meshInputs = this.ParseInputs(element);

			
			int[] vcount = new int[meshInputs.Count];
			this.ParseIntArray(element.ElementValue(this.schema.vcountName), vcount);
			var points = vcount.Sum(a => a);
			var firstSize = vcount[0];
			bool isAllTheSame = vcount.All(i => i == firstSize);

			int[] p = new int[points * meshInputs.Stride];
			this.ParseIntArray(element.ElementValue(this.schema.pName), p);

			var subMesh = dstMesh.CreateSubmesh();
			subMesh.Material = skinAndMaterials.GetAnyMaterialFor(element.AttributeValue(this.schema.materialAttributeName));

			var streamList = StreamListOrderedByOffset(meshInputs, subMesh);

			//if (isAllTheSame)
			//{
			//	if (firstSize == 3)
			//	{
			//		subMesh.VertexSourceType = VertexSourceType.TrianleList;
			//		this.ParseElements(p, subMesh, meshInputs, points);
			//		return;
			//	}
			//	if (firstSize == 4)
			//	{
			//		subMesh.VertexSourceType = VertexSourceType.QuadList;
			//		this.ParseElements(p, subMesh, meshInputs, points);
			//		return;
			//	}
			//}

			subMesh.VertexSourceType = VertexSourceType.TriangleList;
			int startIndex = 0;
			for (int polygonIndex = 0; polygonIndex < vcount.Length; ++polygonIndex)
			{
				for (int i = 2; i < vcount[polygonIndex]; i++)
				{
					AddVertex(p, 0, streamList, meshInputs.Stride);
					AddVertex(p, i-1, streamList, meshInputs.Stride);
					AddVertex(p, i , streamList, meshInputs.Stride);
				}
				startIndex += vcount[polygonIndex];
			}
		}
コード例 #4
0
ファイル: DaeReader.cs プロジェクト: gleblebedev/toe
		private void ParsePolygons( MeshSkinAndMaterials skinAndMaterials, SeparateStreamsMesh dstMesh, XElement element)
		{
			var meshInputs =  this.ParseInputs(element);
			var subMesh = dstMesh.CreateSubmesh();
			subMesh.Material = skinAndMaterials.GetAnyMaterialFor(element.AttributeValue(this.schema.materialAttributeName));
			subMesh.VertexSourceType = VertexSourceType.TriangleList;

			var streamList = StreamListOrderedByOffset(meshInputs, subMesh);
			foreach (var polygon in element.Elements(this.schema.pName))
			{
				var list = this.ParseIntList(polygon.Value);
				int numElements = list.Count / meshInputs.Stride;

				for (int i=1; i<numElements-1; ++i)
				{
					AddVertex(list, 0, streamList, meshInputs.Stride);
					AddVertex(list, i, streamList, meshInputs.Stride);
					AddVertex(list, i+1, streamList, meshInputs.Stride);
				}
			}
		}
コード例 #5
0
ファイル: DaeReader.cs プロジェクト: gleblebedev/toe
		private void ParseMesh(Scene scene, XElement mesh, MeshSkinAndMaterials skinAndMaterials, SeparateStreamsMesh dstMesh)
		{
			Dictionary<string, StreamKey> knownStreams = new Dictionary<string, StreamKey>();
			Dictionary<StreamKey, string> knownSemantics = new Dictionary<StreamKey, string>();
			foreach (var element in mesh.Elements())
			{
				foreach (var subElement in element.Elements().Where(x=>x.Name == this.schema.inputName))
				{
					var semanticAttribute = subElement.Attribute(schema.semanticName);
					var semantic = (semanticAttribute == null)?null:semanticAttribute.Value;
					var setAttribute = subElement.Attribute(schema.setName);
					var set = (setAttribute==null)?0:int.Parse(setAttribute.Value, CultureInfo.InvariantCulture);
					var sourceAttribute = subElement.Attribute(schema.sourceAttributeName);
					var source = (sourceAttribute == null)?null:sourceAttribute.Value;
					var key = new StreamKey(semantic, set);
					StreamKey knownStreamKey;
					if (!knownStreams.TryGetValue(source, out knownStreamKey))
					{
						knownStreams.Add(source,key);
					}
					else if (knownStreamKey != key)
					{
						throw new NotImplementedException();
					}

					string knownSemanticsKey;
					if (!knownSemantics.TryGetValue(key, out knownSemanticsKey))
					{
						knownSemantics.Add(key, source);
					}
					else if (knownSemanticsKey != source)
					{
						throw new NotImplementedException();
					}
				}
			}
			foreach (var streamName in knownStreams)
			{
				var s = mesh.ElementByUrl(streamName.Key);
				if (s != null)
				{
					if (s.Name == schema.verticesName)
					{
						
					}
					else
					{
						var source = ParseSource(s, schema);
						dstMesh.SetStream(streamName.Value.Key, streamName.Value.Channel, CreateMeshStream(source, streamName.Value.Key));
					}
				}
			}
			foreach (var element in mesh.Elements())
			{
				if (element.Name == this.schema.polygonsName)
				{
					this.ParsePolygons(skinAndMaterials, dstMesh, element);
				}
				else if (element.Name == this.schema.polylistName)
				{
					this.ParsePolylist(mesh, skinAndMaterials, dstMesh, element);
				}
				else if (element.Name == this.schema.trianglesName)
				{
					this.ParseTriangles(mesh, skinAndMaterials, dstMesh, element);
				}
				else if (element.Name == this.schema.verticesName || element.Name == this.schema.sourceName)
				{
				}
				else
				{
					throw new DaeException(message: "Unknown mesh element " + element.Name.LocalName);
				}
			}
		}
コード例 #6
0
ファイル: DaeReader.cs プロジェクト: gleblebedev/toe
		private MeshSkinAndMaterials FindContext(Scene scene, XElement geometry)
		{
			var sam = new MeshSkinAndMaterials();

			var geometryId = "#" + geometry.AttributeValue(this.schema.idName);

			var controllers = this.collada.Element(this.schema.libraryControllersName);
			if (controllers != null)
			{
				sam.SkinController = (from controller in controllers.Elements(this.schema.controllerName)
				                      let skin = controller.Element(this.schema.skinName)
				                      where skin != null && skin.AttributeValue(this.schema.sourceAttributeName) == geometryId
				                      select controller).FirstOrDefault();
			}

			string controllerId = "#";

			if (sam.SkinController != null)
			{
				controllerId = "#" + sam.SkinController.AttributeValue(this.schema.idName);
			}

			var libScenes = this.collada.Element(this.schema.libraryVisualScenesName);
			if (libScenes != null)
			{
				foreach (var visualScene in libScenes.Elements(this.schema.visualSceneName))
				{
					foreach (var node in visualScene.Descendants(this.schema.nodeName))
					{
						var instanceGeo = node.Element(this.schema.instanceGeometryName);
						if (instanceGeo != null && instanceGeo.AttributeValue(this.schema.urlName) == geometryId)
						{
							this.CopySkin(scene, instanceGeo, sam);
						}
						var instanceCtrl = node.Element(this.schema.instanceControllerName);
						if (instanceCtrl != null && instanceCtrl.AttributeValue(this.schema.urlName) == controllerId)
						{
							this.CopySkin(scene, instanceCtrl, sam);
						}
					}
				}
			}
			return sam;
		}