/// <summary>
/// Crea un mesh con uno o varios DiffuseMap
/// </summary>
/// <returns></returns>
private TgcSkeletalMesh crearMeshDiffuseMap(TgcSkeletalLoaderMaterialAux[] materialsArray, TgcSkeletalMeshData meshData)
{
//Crear Mesh
Mesh mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length, MeshFlags.Managed, DiffuseMapVertexElements, device);
//Cargar esqueleto
TgcSkeletalBone[] bones = loadSkeleton(meshData);
TgcSkeletalVertexWeight[] verticesWeights = loadVerticesWeights(meshData, bones);
//Cargar VertexBuffer
using (VertexBuffer vb = mesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
for (int j = 0; j < meshData.coordinatesIndices.Length; j++)
{
DiffuseMapVertex v = new DiffuseMapVertex();
//vertices
int coordIdx = meshData.coordinatesIndices[j] * 3;
v.Position = new Vector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//texture coordinates diffuseMap
int texCoordIdx = meshData.texCoordinatesIndices[j] * 2;
v.Tu = meshData.textureCoordinates[texCoordIdx];
v.Tv = meshData.textureCoordinates[texCoordIdx + 1];
//color
int colorIdx = meshData.colorIndices[j];
v.Color = meshData.verticesColors[colorIdx];
//normal
if (meshData.verticesNormals != null)
{
v.Normal = new Vector3(
meshData.verticesNormals[coordIdx],
meshData.verticesNormals[coordIdx + 1],
meshData.verticesNormals[coordIdx + 2]
);
}
else
{
v.Normal = new Vector3(0, 0, 0);
}
//tangent
if (meshData.verticesTangents != null)
{
v.Tangent = new Vector3(
meshData.verticesTangents[coordIdx],
meshData.verticesTangents[coordIdx + 1],
meshData.verticesTangents[coordIdx + 2]
);
}
else
{
v.Tangent = new Vector3(0, 0, 0);
}
//binormal
if (meshData.verticesBinormals != null)
{
v.Binormal = new Vector3(
meshData.verticesBinormals[coordIdx],
meshData.verticesBinormals[coordIdx + 1],
meshData.verticesBinormals[coordIdx + 2]
);
}
else
{
v.Binormal = new Vector3(0, 0, 0);
}
//BlendWeights y BlendIndices
TgcSkeletalVertexWeight vWeight = verticesWeights[meshData.coordinatesIndices[j]];
vWeight.createVector4WeightsAndIndices(out v.BlendWeights, out v.BlendIndices);
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = mesh.IndexBuffer)
{
short[] indices = new short[meshData.coordinatesIndices.Length];
for (int j = 0; j < indices.Length; j++)
{
indices[j] = (short)j;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Configurar Material y Textura para un solo SubSet
TgcSkeletalLoaderMaterialAux matAux = materialsArray[meshData.materialId];
Material[] meshMaterials;
TgcTexture[] meshTextures;
if (matAux.subMaterials == null)
{
meshMaterials = new Material[] { matAux.materialId };
meshTextures = new TgcTexture[] { matAux.texture };
}
//Configurar Material y Textura para varios SubSet
else
{
//Cargar attributeBuffer con los id de las texturas de cada triángulo
int[] 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 (int m = 0; m < matAux.subMaterials.Length; m++)
{
meshMaterials[m] = matAux.subMaterials[m].materialId;
meshTextures[m] = matAux.subMaterials[m].texture;
}
}
//Crear mesh de TGC
TgcSkeletalMesh tgcMesh = meshFactory.createNewMesh(mesh, meshData.name, TgcSkeletalMesh.MeshRenderType.DIFFUSE_MAP, bones);
tgcMesh.Materials = meshMaterials;
tgcMesh.DiffuseMaps = meshTextures;
return tgcMesh;
}
/// <summary>
/// Crea un mesh con uno o varios DiffuseMap
/// </summary>
/// <returns></returns>
private TgcMesh crearMeshDiffuseMap(TgcSceneLoaderMaterialAux[] materialsArray, TgcMeshData 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 Vector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//normals
//puede haber una normal compartida para cada vertice del mesh
if (meshData.verticesNormals.Length == meshData.verticesCoordinates.Length)
{
v.Normal = new Vector3(
meshData.verticesNormals[coordIdx],
meshData.verticesNormals[coordIdx + 1],
meshData.verticesNormals[coordIdx + 2]
);
}
//o una normal propia por cada vertice de cada triangulo (version mejorada del exporter)
else
{
var normalIdx = j * 3;
v.Normal = new Vector3(
meshData.verticesNormals[normalIdx],
meshData.verticesNormals[normalIdx + 1],
meshData.verticesNormals[normalIdx + 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 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[]
{ TgcTexture.createTexture(D3DDevice.Instance.Device, matAux.textureFileName, matAux.texturePath) };
}
//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] = TgcTexture.createTexture(D3DDevice.Instance.Device,
matAux.subMaterials[m].textureFileName,
matAux.subMaterials[m].texturePath);
}
}
//Crear mesh de TGC
var tgcMesh = MeshFactory.createNewMesh(mesh, meshData.name, TgcMesh.MeshRenderType.DIFFUSE_MAP);
tgcMesh.Materials = meshMaterials;
tgcMesh.DiffuseMaps = meshTextures;
return(tgcMesh);
}
/// <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);
}
/// <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>
/// Crea un mesh con uno o varios DiffuseMap
/// </summary>
/// <returns></returns>
private TgcKeyFrameMesh crearMeshDiffuseMap(TgcKeyFrameLoaderMaterialAux[] materialsArray, TgcKeyFrameMeshData meshData)
{
//Crear Mesh
Mesh mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length, MeshFlags.Managed, DiffuseMapVertexElements, device);
//Cargar VertexBuffer
using (VertexBuffer vb = mesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
for (int j = 0; j < meshData.coordinatesIndices.Length; j++)
{
DiffuseMapVertex v = new DiffuseMapVertex();
//vertices
int coordIdx = meshData.coordinatesIndices[j] * 3;
v.Position = new Vector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//texture coordinates diffuseMap
int texCoordIdx = meshData.texCoordinatesIndices[j] * 2;
v.Tu = meshData.textureCoordinates[texCoordIdx];
v.Tv = meshData.textureCoordinates[texCoordIdx + 1];
//color
int colorIdx = meshData.colorIndices[j];
v.Color = meshData.verticesColors[colorIdx];
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer
using (IndexBuffer ib = mesh.IndexBuffer)
{
short[] indices = new short[meshData.coordinatesIndices.Length];
for (int j = 0; j < indices.Length; j++)
{
indices[j] = (short)j;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Configurar Material y Textura para un solo SubSet
TgcKeyFrameLoaderMaterialAux matAux = materialsArray[meshData.materialId];
Material[] meshMaterials;
TgcTexture[] meshTextures;
if (matAux.subMaterials == null)
{
meshMaterials = new Material[] { matAux.materialId };
meshTextures = new TgcTexture[] { matAux.texture };
}
//Configurar Material y Textura para varios SubSet
else
{
//Cargar attributeBuffer con los id de las texturas de cada triángulo
int[] 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 (int 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
TgcKeyFrameMesh.OriginalData originalData = new TgcKeyFrameMesh.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
TgcKeyFrameMesh tgcMesh = new TgcKeyFrameMesh(mesh, meshData.name, TgcKeyFrameMesh.MeshRenderType.DIFFUSE_MAP, originalData);
tgcMesh.Materials = meshMaterials;
tgcMesh.DiffuseMaps = meshTextures;
return tgcMesh;
}
/// <summary>
/// Crea un mesh con uno o varios DiffuseMap
/// </summary>
/// <returns></returns>
private TgcMesh crearMeshDiffuseMap(TgcSceneLoaderMaterialAux[] materialsArray, TgcMeshData meshData)
{
//Crear Mesh
Mesh mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length, MeshFlags.Managed, DiffuseMapVertexElements, device);
//Cargar VertexBuffer
using (VertexBuffer vb = mesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
for (int j = 0; j < meshData.coordinatesIndices.Length; j++)
{
DiffuseMapVertex v = new DiffuseMapVertex();
//vertices
int coordIdx = meshData.coordinatesIndices[j] * 3;
v.Position = new Vector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//normals
//puede haber una normal compartida para cada vertice del mesh
if (meshData.verticesNormals.Length == meshData.verticesCoordinates.Length)
{
v.Normal = new Vector3(
meshData.verticesNormals[coordIdx],
meshData.verticesNormals[coordIdx + 1],
meshData.verticesNormals[coordIdx + 2]
);
}
//o una normal propia por cada vertice de cada triangulo (version mejorada del exporter)
else
{
int normalIdx = j * 3;
v.Normal = new Vector3(
meshData.verticesNormals[normalIdx],
meshData.verticesNormals[normalIdx + 1],
meshData.verticesNormals[normalIdx + 2]
);
}
//texture coordinates diffuseMap
int texCoordIdx = meshData.texCoordinatesIndices[j] * 2;
v.Tu = meshData.textureCoordinates[texCoordIdx];
v.Tv = meshData.textureCoordinates[texCoordIdx + 1];
//color
int colorIdx = meshData.colorIndices[j];
v.Color = meshData.verticesColors[colorIdx];
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = mesh.IndexBuffer)
{
short[] indices = new short[meshData.coordinatesIndices.Length];
for (int j = 0; j < indices.Length; j++)
{
indices[j] = (short)j;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Configurar Material y Textura para un solo SubSet
TgcSceneLoaderMaterialAux matAux = materialsArray[meshData.materialId];
Material[] meshMaterials;
TgcTexture[] meshTextures;
if (matAux.subMaterials == null)
{
meshMaterials = new Material[] { matAux.materialId };
meshTextures = new TgcTexture[] { matAux.texture };
}
//Configurar Material y Textura para varios SubSet
else
{
//Cargar attributeBuffer con los id de las texturas de cada triángulo
int[] 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 (int m = 0; m < matAux.subMaterials.Length; m++)
{
meshMaterials[m] = matAux.subMaterials[m].materialId;
meshTextures[m] = matAux.subMaterials[m].texture;
}
}
//Crear mesh de TGC
TgcMesh tgcMesh = meshFactory.createNewMesh(mesh, meshData.name, TgcMesh.MeshRenderType.DIFFUSE_MAP);
tgcMesh.Materials = meshMaterials;
tgcMesh.DiffuseMaps = meshTextures;
return tgcMesh;
}
/// <summary>
/// Crea un mesh con uno o varios DiffuseMap
/// </summary>
/// <returns></returns>
private TgcSkeletalMesh crearMeshDiffuseMap(TgcSkeletalLoaderMaterialAux[] materialsArray, TgcSkeletalMeshData meshData)
{
//Crear Mesh
Mesh mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length, MeshFlags.Managed, DiffuseMapVertexElements, device);
//Cargar VertexBuffer
using (VertexBuffer vb = mesh.VertexBuffer)
{
GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
for (int j = 0; j < meshData.coordinatesIndices.Length; j++)
{
DiffuseMapVertex v = new DiffuseMapVertex();
//vertices
int coordIdx = meshData.coordinatesIndices[j] * 3;
v.Position = new Vector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//texture coordinates diffuseMap
int texCoordIdx = meshData.texCoordinatesIndices[j] * 2;
v.Tu = meshData.textureCoordinates[texCoordIdx];
v.Tv = meshData.textureCoordinates[texCoordIdx + 1];
//color
int colorIdx = meshData.colorIndices[j];
v.Color = meshData.verticesColors[colorIdx];
data.Write(v);
}
vb.Unlock();
}
//Cargar IndexBuffer en forma plana
using (IndexBuffer ib = mesh.IndexBuffer)
{
short[] indices = new short[meshData.coordinatesIndices.Length];
for (int j = 0; j < indices.Length; j++)
{
indices[j] = (short)j;
}
ib.SetData(indices, 0, LockFlags.None);
}
//Configurar Material y Textura para un solo SubSet
TgcSkeletalLoaderMaterialAux matAux = materialsArray[meshData.materialId];
Material[] meshMaterials;
TgcTexture[] meshTextures;
if (matAux.subMaterials == null)
{
meshMaterials = new Material[] { matAux.materialId };
meshTextures = new TgcTexture[] { matAux.texture };
}
//Configurar Material y Textura para varios SubSet
else
{
//Cargar attributeBuffer con los id de las texturas de cada triángulo
int[] 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 (int m = 0; m < matAux.subMaterials.Length; m++)
{
meshMaterials[m] = matAux.subMaterials[m].materialId;
meshTextures[m] = matAux.subMaterials[m].texture;
}
}
//Cargar esqueleto
TgcSkeletalBone[] bones = loadSkeleton(meshData);
TgcSkeletalVertexWeight[] verticesWeights = loadVerticesWeights(meshData, bones);
//Cargar datos de meshData que interesan mantener como originales
TgcSkeletalMesh.OriginalData origData = new TgcSkeletalMesh.OriginalData();
origData.coordinatesIndices = meshData.coordinatesIndices;
origData.verticesCoordinates = meshData.verticesCoordinates;
origData.colorIndices = meshData.colorIndices;
origData.verticesColors = meshData.verticesColors;
origData.texCoordinatesIndices = meshData.texCoordinatesIndices;
origData.textureCoordinates = meshData.textureCoordinates;
//Crear mesh de TGC
TgcSkeletalMesh tgcMesh = meshFactory.createNewMesh(mesh, meshData.name, TgcSkeletalMesh.MeshRenderType.DIFFUSE_MAP, origData, bones, verticesWeights);
tgcMesh.Materials = meshMaterials;
tgcMesh.DiffuseMaps = meshTextures;
return(tgcMesh);
}
