/// <summary>
/// Cargar estructura de esqueleto
/// </summary>
private TgcSkeletalBone[] loadSkeleton(TgcSkeletalMeshData meshData)
{
//Crear huesos
var bones = new TgcSkeletalBone[meshData.bones.Length];
for (var i = 0; i < bones.Length; i++)
{
var boneData = meshData.bones[i];
var bone = new TgcSkeletalBone(i, boneData.name,
new TGCVector3(boneData.startPosition[0], boneData.startPosition[1], boneData.startPosition[2]),
new TGCQuaternion(boneData.startRotation[0], boneData.startRotation[1], boneData.startRotation[2],
boneData.startRotation[3])
);
bones[i] = bone;
}
//Cargar padres en huesos
for (var i = 0; i < bones.Length; i++)
{
var boneData = meshData.bones[i];
if (boneData.parentId == -1)
{
bones[i].ParentBone = null;
}
else
{
bones[i].ParentBone = bones[boneData.parentId];
}
}
return(bones);
}
/// <summary>
/// Carga un Modelo a partir de un objeto TgcSkeletalMeshData 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 TgcSkeletalMesh loadMesh(TgcSkeletalMeshData meshData, string mediaPath)
{
//Cargar Texturas
var materialsArray = new TgcSkeletalLoaderMaterialAux[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 TgcSkeletalLoaderMaterialAux();
materialsArray[i] = matAux;
matAux.subMaterials = new TgcSkeletalLoaderMaterialAux[materialData.subMaterials.Length];
for (var j = 0; j < materialData.subMaterials.Length; j++)
{
matAux.subMaterials[j] = createTextureAndMaterial(materialData.subMaterials[j], texturesPath);
}
}
}
//Crear Mesh
TgcSkeletalMesh 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(
TGCVector3.Float3ArrayToVector3(meshData.pMin),
TGCVector3.Float3ArrayToVector3(meshData.pMax)
);
}
else
{
tgcMesh.createBoundingBox();
}
tgcMesh.Enabled = true;
return(tgcMesh);
}
/// <summary>
/// Levanta la informacion del mesh a partir de un XML
/// </summary>
/// <param name="xmlString">contenido del XML</param>
/// <returns></returns>
public TgcSkeletalMeshData parseMeshFromString(string xmlString)
{
var dom = new XmlDocument();
dom.LoadXml(xmlString);
var root = dom.DocumentElement;
var meshData = new TgcSkeletalMeshData();
//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();
}
//parsear normals, si hay
var normalsNodes = meshNode.GetElementsByTagName("normals");
if (normalsNodes != null && normalsNodes.Count == 1)
{
var normalsNode = normalsNodes[0];
count = int.Parse(normalsNode.Attributes["count"].InnerText);
meshData.verticesNormals = TgcParserUtils.parseFloatStream(normalsNode.InnerText, count);
}
//parsear tangents, si hay
var tangentsNodes = meshNode.GetElementsByTagName("tangents");
if (tangentsNodes != null && tangentsNodes.Count == 1)
{
var tangentsNode = tangentsNodes[0];
count = int.Parse(tangentsNode.Attributes["count"].InnerText);
meshData.verticesTangents = TgcParserUtils.parseFloatStream(tangentsNode.InnerText, count);
}
//parsear binormals, si hay
var binormalsNodes = meshNode.GetElementsByTagName("binormals");
if (binormalsNodes != null && binormalsNodes.Count == 1)
{
var binormalsNode = binormalsNodes[0];
count = int.Parse(binormalsNode.Attributes["count"].InnerText);
meshData.verticesBinormals = TgcParserUtils.parseFloatStream(binormalsNode.InnerText, count);
}
//parsear esqueleto
var skeletonNode = meshNode.GetElementsByTagName("skeleton")[0];
var bonesData = new TgcSkeletalBoneData[skeletonNode.ChildNodes.Count];
var boneCount = 0;
foreach (XmlElement boneNode in skeletonNode.ChildNodes)
{
var boneData = new TgcSkeletalBoneData();
boneData.id = int.Parse(boneNode.Attributes["id"].InnerText);
boneData.name = boneNode.Attributes["name"].InnerText;
boneData.parentId = int.Parse(boneNode.Attributes["parentId"].InnerText);
boneData.startPosition = TgcParserUtils.parseFloat3Array(boneNode.Attributes["pos"].InnerText);
boneData.startRotation = TgcParserUtils.parseFloat4Array(boneNode.Attributes["rotQuat"].InnerText);
bonesData[boneCount++] = boneData;
}
meshData.bones = bonesData;
//parsear Weights
var weightsNode = meshNode.GetElementsByTagName("weights")[0];
count = int.Parse(weightsNode.Attributes["count"].InnerText);
meshData.verticesWeights = TgcParserUtils.parseFloatStream(weightsNode.InnerText, count);
return(meshData);
}
/// <summary>
/// Crea un mesh sin texturas, solo con VertexColors
/// </summary>
/// <param name="meshData"></param>
private TgcSkeletalMesh crearMeshSoloColor(TgcSkeletalMeshData meshData)
{
//Crear Mesh
var mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length,
MeshFlags.Managed, VertexColorVertexElements, D3DDevice.Instance.Device);
//Cargar esqueleto
var bones = loadSkeleton(meshData);
var verticesWeights = loadVerticesWeights(meshData, bones);
//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];
//normal
if (meshData.verticesNormals != null)
{
v.Normal = new TGCVector3(
meshData.verticesNormals[coordIdx],
meshData.verticesNormals[coordIdx + 1],
meshData.verticesNormals[coordIdx + 2]
);
}
else
{
v.Normal = TGCVector3.Empty;
}
//tangent
if (meshData.verticesTangents != null)
{
v.Tangent = new TGCVector3(
meshData.verticesTangents[coordIdx],
meshData.verticesTangents[coordIdx + 1],
meshData.verticesTangents[coordIdx + 2]
);
}
else
{
v.Tangent = TGCVector3.Empty;
}
//binormal
if (meshData.verticesBinormals != null)
{
v.Binormal = new TGCVector3(
meshData.verticesBinormals[coordIdx],
meshData.verticesBinormals[coordIdx + 1],
meshData.verticesBinormals[coordIdx + 2]
);
}
else
{
v.Binormal = TGCVector3.Empty;
}
//BlendWeights y BlendIndices
var vWeight = verticesWeights[meshData.coordinatesIndices[j]];
vWeight.createVector4WeightsAndIndices(out v.BlendWeights, out v.BlendIndices);
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);
}
//Crear mesh de TGC
var tgcMesh = MeshFactory.createNewSkeletalMesh(mesh, meshData.name, TgcSkeletalMesh.MeshRenderType.VERTEX_COLOR,
bones);
return(tgcMesh);
}
/// <summary>
/// Crea un mesh con uno o varios DiffuseMap
/// </summary>
/// <returns></returns>
private TgcSkeletalMesh crearMeshDiffuseMap(TgcSkeletalLoaderMaterialAux[] materialsArray,
TgcSkeletalMeshData meshData)
{
//Crear Mesh
var mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length,
MeshFlags.Managed, DiffuseMapVertexElements, D3DDevice.Instance.Device);
//Cargar esqueleto
var bones = loadSkeleton(meshData);
var verticesWeights = loadVerticesWeights(meshData, bones);
//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];
//normal
if (meshData.verticesNormals != null)
{
v.Normal = new TGCVector3(
meshData.verticesNormals[coordIdx],
meshData.verticesNormals[coordIdx + 1],
meshData.verticesNormals[coordIdx + 2]
);
}
else
{
v.Normal = TGCVector3.Empty;
}
//tangent
if (meshData.verticesTangents != null)
{
v.Tangent = new TGCVector3(
meshData.verticesTangents[coordIdx],
meshData.verticesTangents[coordIdx + 1],
meshData.verticesTangents[coordIdx + 2]
);
}
else
{
v.Tangent = TGCVector3.Empty;
}
//binormal
if (meshData.verticesBinormals != null)
{
v.Binormal = new TGCVector3(
meshData.verticesBinormals[coordIdx],
meshData.verticesBinormals[coordIdx + 1],
meshData.verticesBinormals[coordIdx + 2]
);
}
else
{
v.Binormal = TGCVector3.Empty;
}
//BlendWeights y BlendIndices
var vWeight = verticesWeights[meshData.coordinatesIndices[j]];
vWeight.createVector4WeightsAndIndices(out v.BlendWeights, out v.BlendIndices);
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
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;
}
}
//Crear mesh de TGC
var tgcMesh = MeshFactory.createNewSkeletalMesh(mesh, meshData.name, TgcSkeletalMesh.MeshRenderType.DIFFUSE_MAP,
bones);
tgcMesh.Materials = meshMaterials;
tgcMesh.DiffuseMaps = meshTextures;
return(tgcMesh);
}
/// <summary>
/// Cargar Weights de vertices
/// </summary>
/// <param name="meshData"></param>
/// <returns></returns>
private TgcSkeletalVertexWeight[] loadVerticesWeights(TgcSkeletalMeshData meshData, TgcSkeletalBone[] bones)
{
var maxWeights = 4;
var weightComparer = new TgcSkeletalVertexWeight.BoneWeight.GreaterComparer();
//Crear un array de Weights para cada uno de los vertices de la malla
var weights = new TgcSkeletalVertexWeight[meshData.verticesCoordinates.Length / 3];
for (var i = 0; i < weights.Length; i++)
{
weights[i] = new TgcSkeletalVertexWeight();
}
//Cargar los weights de cada vertice
var weightsCount = meshData.verticesWeights.Length / 3;
for (var i = 0; i < weightsCount; i++)
{
var vertexIdx = (int)meshData.verticesWeights[i * 3];
var boneIdx = (int)meshData.verticesWeights[i * 3 + 1];
var weightVal = meshData.verticesWeights[i * 3 + 2];
var bone = bones[boneIdx];
var weight = new TgcSkeletalVertexWeight.BoneWeight(bone, weightVal);
weights[vertexIdx].Weights.Add(weight);
}
//Normalizar weights de cada vertice
for (var i = 0; i < weights.Length; i++)
{
var vertexWeight = weights[i];
//Se soportan hasta 4 weights por vertice. Si hay mas se quitan y se reparten las influencias entre el resto de los huesos
if (vertexWeight.Weights.Count > maxWeights)
{
//Ordenar por weight de menor a mayor y luego revertir, para que quede de mayor a menor peso
vertexWeight.Weights.Sort(weightComparer);
vertexWeight.Weights.Reverse();
//Quitar los ultimos los weight que superan 4
while (vertexWeight.Weights.Count > maxWeights)
{
vertexWeight.Weights.RemoveAt(vertexWeight.Weights.Count - 1);
}
}
//Sumar el total de todos los weights de este vertice
float weightTotal = 0;
foreach (var w in vertexWeight.Weights)
{
weightTotal += w.Weight;
}
//Normalizar cada valor segun el total acumulado en el vertice
foreach (var w in vertexWeight.Weights)
{
w.Weight = w.Weight / weightTotal;
}
}
return(weights);
}
