/// <summary>
/// Carga un Modelo a partir de un objeto TgcKeyFrameMeshData ya parseado
/// </summary>
/// <param name="meshData">Objeto con datos ya parseados</param>
/// <param name="mediaPath">Path a partir del cual hay que buscar las Texturas</param>
/// <returns>Modelo cargado</returns>
public TgcKeyFrameMesh loadMesh(TgcKeyFrameMeshData meshData, string mediaPath)
{
//Cargar Texturas
var materialsArray = new TgcKeyFrameLoaderMaterialAux[meshData.materialsData.Length];
for (var i = 0; i < meshData.materialsData.Length; i++)
{
var materialData = meshData.materialsData[i];
var texturesPath = mediaPath + meshData.texturesDir + "\\";
//Crear StandardMaterial
if (materialData.type.Equals(TgcMaterialData.StandardMaterial))
{
materialsArray[i] = createTextureAndMaterial(materialData, texturesPath);
}
//Crear MultiMaterial
else if (materialData.type.Equals(TgcMaterialData.MultiMaterial))
{
var matAux = new TgcKeyFrameLoaderMaterialAux();
materialsArray[i] = matAux;
matAux.subMaterials = new TgcKeyFrameLoaderMaterialAux[materialData.subMaterials.Length];
for (var j = 0; j < materialData.subMaterials.Length; j++)
{
matAux.subMaterials[j] = createTextureAndMaterial(materialData.subMaterials[j], texturesPath);
}
}
}
//Crear Mesh
TgcKeyFrameMesh tgcMesh = null;
//Crear mesh que no tiene Material, con un color simple
if (meshData.materialId == -1)
{
tgcMesh = crearMeshSoloColor(meshData);
}
//Crear mesh con DiffuseMap
else
{
tgcMesh = crearMeshDiffuseMap(materialsArray, meshData);
}
//Crear BoundingBox, aprovechar lo que viene del XML o crear uno por nuestra cuenta
if (meshData.pMin != null && meshData.pMax != null)
{
tgcMesh.BoundingBox = new TgcBoundingAxisAlignBox(
TgcParserUtils.float3ArrayToVector3(meshData.pMin),
TgcParserUtils.float3ArrayToVector3(meshData.pMax)
);
}
else
{
tgcMesh.createBoundingBox();
}
tgcMesh.Enabled = true;
return(tgcMesh);
}
/// <summary>
/// Crea un mesh sin texturas, solo con VertexColors
/// </summary>
/// <param name="meshData"></param>
private TgcKeyFrameMesh crearMeshSoloColor(TgcKeyFrameMeshData meshData)
{
//Crear Mesh
var mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length,
MeshFlags.Managed, VertexColorVertexElements, D3DDevice.Instance.Device);
//Cargar VertexBuffer
using (var vb = mesh.VertexBuffer)
{
var data = vb.Lock(0, 0, LockFlags.None);
for (var j = 0; j < meshData.coordinatesIndices.Length; j++)
{
var v = new VertexColorVertex();
//vertices
var coordIdx = meshData.coordinatesIndices[j] * 3;
v.Position = new TGCVector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//color
var colorIdx = meshData.colorIndices[j];
v.Color = meshData.verticesColors[colorIdx];
data.Write(v);
}
vb.Unlock();
}
//Cargar indexBuffer en forma plana
using (var ib = mesh.IndexBuffer)
{
var indices = new short[meshData.coordinatesIndices.Length];
for (var i = 0; i < indices.Length; i++)
{
indices[i] = (short)i;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Cargar datos que originales que tienen que mantenerse
var originalData = new OriginalData();
originalData.coordinatesIndices = meshData.coordinatesIndices;
originalData.colorIndices = meshData.colorIndices;
originalData.verticesColors = meshData.verticesColors;
originalData.texCoordinatesIndices = null;
originalData.textureCoordinates = null;
//Crear mesh de TGC
var tgcMesh = new TgcKeyFrameMesh(mesh, meshData.name, TgcKeyFrameMesh.MeshRenderType.VERTEX_COLOR,
originalData);
return(tgcMesh);
}
/// <summary>
/// Levanta la informacion del mesh a partir de un XML
/// </summary>
/// <param name="xmlString">contenido del XML</param>
/// <returns></returns>
public TgcKeyFrameMeshData parseMeshFromString(string xmlString)
{
var dom = new XmlDocument();
dom.LoadXml(xmlString);
var root = dom.DocumentElement;
var meshData = new TgcKeyFrameMeshData();
//Ver si tiene exportacion de texturas
var texturesExportNode = root.GetElementsByTagName("texturesExport")[0];
var texturesExportEnabled = bool.Parse(texturesExportNode.Attributes["enabled"].InnerText);
if (texturesExportEnabled)
{
meshData.texturesDir = texturesExportNode.Attributes["dir"].InnerText;
}
//Parsear Texturas
var materialNodes = root.GetElementsByTagName("materials")[0].ChildNodes;
meshData.materialsData = new TgcMaterialData[materialNodes.Count];
var i = 0;
foreach (XmlElement matNode in materialNodes)
{
//determinar tipo de Material
var material = new TgcMaterialData();
material.type = matNode.Attributes["type"].InnerText;
//Standard Material
if (material.type.Equals(TgcMaterialData.StandardMaterial))
{
parseStandardMaterial(material, matNode);
}
//Multi Material
else if (material.type.Equals(TgcMaterialData.MultiMaterial))
{
material.name = matNode.Attributes["name"].InnerText;
var subMaterialsNodes = matNode.GetElementsByTagName("subM");
material.subMaterials = new TgcMaterialData[subMaterialsNodes.Count];
for (var j = 0; j < subMaterialsNodes.Count; j++)
{
var subMaterial = new TgcMaterialData();
parseStandardMaterial(subMaterial, (XmlElement)subMaterialsNodes[j]);
material.subMaterials[j] = subMaterial;
}
}
meshData.materialsData[i++] = material;
}
//Parsear Mesh
var meshNode = (XmlElement)root.GetElementsByTagName("mesh")[0];
//parser y convertir valores
meshData.name = meshNode.Attributes["name"].InnerText;
meshData.materialId = int.Parse(meshNode.Attributes["matId"].InnerText);
meshData.color = TgcParserUtils.parseFloat3Array(meshNode.Attributes["color"].InnerText);
//TODO: formatear bien visibility
var visibilityStr = meshNode.Attributes["visibility"].InnerText;
//boundingBox, si esta
var boundingBoxNodes = root.GetElementsByTagName("boundingBox");
if (boundingBoxNodes != null && boundingBoxNodes.Count == 1)
{
var boundingBoxNode = boundingBoxNodes[0];
meshData.pMin = TgcParserUtils.parseFloat3Array(boundingBoxNode.Attributes["min"].InnerText);
meshData.pMax = TgcParserUtils.parseFloat3Array(boundingBoxNode.Attributes["max"].InnerText);
}
int count;
//parsear coordinatesIdx
var coordinatesIdxNode = meshNode.GetElementsByTagName("coordinatesIdx")[0];
count = int.Parse(coordinatesIdxNode.Attributes["count"].InnerText);
meshData.coordinatesIndices = TgcParserUtils.parseIntStream(coordinatesIdxNode.InnerText, count);
//parsear textCoordsIdx
var textCoordsIdxNode = meshNode.GetElementsByTagName("textCoordsIdx")[0];
count = int.Parse(textCoordsIdxNode.Attributes["count"].InnerText);
meshData.texCoordinatesIndices = TgcParserUtils.parseIntStream(textCoordsIdxNode.InnerText, count);
//parsear colorsIdx
var colorsIdxNode = meshNode.GetElementsByTagName("colorsIdx")[0];
count = int.Parse(colorsIdxNode.Attributes["count"].InnerText);
meshData.colorIndices = TgcParserUtils.parseIntStream(colorsIdxNode.InnerText, count);
//parsear matIds
if (meshData.materialsData.Length > 0)
{
var matIdsNode = meshNode.GetElementsByTagName("matIds")[0];
count = int.Parse(matIdsNode.Attributes["count"].InnerText);
meshData.materialsIds = TgcParserUtils.parseIntStream(matIdsNode.InnerText, count);
}
//parsear vertices
var verticesNode = meshNode.GetElementsByTagName("vertices")[0];
count = int.Parse(verticesNode.Attributes["count"].InnerText);
meshData.verticesCoordinates = TgcParserUtils.parseFloatStream(verticesNode.InnerText, count);
//parsear texCoords
var texCoordsNode = meshNode.GetElementsByTagName("texCoords")[0];
count = int.Parse(texCoordsNode.Attributes["count"].InnerText);
meshData.textureCoordinates = TgcParserUtils.parseFloatStream(texCoordsNode.InnerText, count);
//parsear colors
var colorsNode = meshNode.GetElementsByTagName("colors")[0];
count = int.Parse(colorsNode.Attributes["count"].InnerText);
var colorsArray = TgcParserUtils.parseFloatStream(colorsNode.InnerText, count);
//convertir a format TV
meshData.verticesColors = new int[count / 3];
for (var j = 0; j < meshData.verticesColors.Length; j++)
{
meshData.verticesColors[j] = Color.FromArgb(
(int)colorsArray[j * 3],
(int)colorsArray[j * 3 + 1],
(int)colorsArray[j * 3 + 2]).ToArgb();
}
return(meshData);
}
/// <summary>
/// Crea un mesh con uno o varios DiffuseMap
/// </summary>
/// <returns></returns>
private TgcKeyFrameMesh crearMeshDiffuseMap(TgcKeyFrameLoaderMaterialAux[] materialsArray,
TgcKeyFrameMeshData meshData)
{
//Crear Mesh
var mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length,
MeshFlags.Managed, DiffuseMapVertexElements, D3DDevice.Instance.Device);
//Cargar VertexBuffer
using (var vb = mesh.VertexBuffer)
{
var data = vb.Lock(0, 0, LockFlags.None);
for (var j = 0; j < meshData.coordinatesIndices.Length; j++)
{
var v = new DiffuseMapVertex();
//vertices
var coordIdx = meshData.coordinatesIndices[j] * 3;
v.Position = new TGCVector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//texture coordinates diffuseMap
var texCoordIdx = meshData.texCoordinatesIndices[j] * 2;
v.Tu = meshData.textureCoordinates[texCoordIdx];
v.Tv = meshData.textureCoordinates[texCoordIdx + 1];
//color
var colorIdx = meshData.colorIndices[j];
v.Color = meshData.verticesColors[colorIdx];
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer
using (var ib = mesh.IndexBuffer)
{
var indices = new short[meshData.coordinatesIndices.Length];
for (var j = 0; j < indices.Length; j++)
{
indices[j] = (short)j;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Configurar Material y Textura para un solo SubSet
var matAux = materialsArray[meshData.materialId];
Material[] meshMaterials;
TgcTexture[] meshTextures;
if (matAux.subMaterials == null)
{
meshMaterials = new[] { matAux.materialId };
meshTextures = new[] { matAux.texture };
}
//Configurar Material y Textura para varios SubSet
else
{
//Cargar attributeBuffer con los id de las texturas de cada triángulo
var attributeBuffer = mesh.LockAttributeBufferArray(LockFlags.None);
Array.Copy(meshData.materialsIds, attributeBuffer, attributeBuffer.Length);
mesh.UnlockAttributeBuffer(attributeBuffer);
//Cargar array de Materials y Texturas
meshMaterials = new Material[matAux.subMaterials.Length];
meshTextures = new TgcTexture[matAux.subMaterials.Length];
for (var m = 0; m < matAux.subMaterials.Length; m++)
{
meshMaterials[m] = matAux.subMaterials[m].materialId;
meshTextures[m] = matAux.subMaterials[m].texture;
}
}
//Cargar datos que originales que tienen que mantenerse
var originalData = new OriginalData();
originalData.coordinatesIndices = meshData.coordinatesIndices;
originalData.colorIndices = meshData.colorIndices;
originalData.verticesColors = meshData.verticesColors;
originalData.texCoordinatesIndices = meshData.texCoordinatesIndices;
originalData.textureCoordinates = meshData.textureCoordinates;
//Crear mesh de TGC
var tgcMesh = new TgcKeyFrameMesh(mesh, meshData.name, TgcKeyFrameMesh.MeshRenderType.DIFFUSE_MAP,
originalData);
tgcMesh.Materials = meshMaterials;
tgcMesh.DiffuseMaps = meshTextures;
return(tgcMesh);
}