/// <summary>
/// Crea Material y Textura
/// </summary>
private TgcSceneLoaderMaterialAux createTextureAndMaterial(TgcMaterialData materialData, string texturesPath)
{
TgcSceneLoaderMaterialAux matAux = new TgcSceneLoaderMaterialAux();
//Crear material
Material material = new Material();
matAux.materialId = material;
material.AmbientColor = new ColorValue(
materialData.ambientColor[0],
materialData.ambientColor[1],
materialData.ambientColor[2],
materialData.ambientColor[3]);
material.DiffuseColor = new ColorValue(
materialData.diffuseColor[0],
materialData.diffuseColor[1],
materialData.diffuseColor[2],
materialData.diffuseColor[3]);
material.SpecularColor = new ColorValue(
materialData.specularColor[0],
materialData.specularColor[1],
materialData.specularColor[2],
materialData.specularColor[3]);
//TODO ver que hacer con la opacity
//crear textura
texturesDict.Clear();
if (materialData.fileName != null)
{
//revisar que esa imagen no se haya cargado previamente
TgcTexture texture;
if (texturesDict.ContainsKey(materialData.fileName))
{
texture = texturesDict[materialData.fileName];
}
else
{
texture = TgcTexture.createTexture(device, materialData.fileName, texturesPath + "\\" + materialData.fileName);
texturesDict[materialData.fileName] = texture;
//TODO usar para algo el OFFSET y el TILING
}
matAux.texture = texture;
}
else
{
matAux.texture = null;
}
return(matAux);
}
/// <summary>
/// Crea una nueva textura, haciendo el Loading del archivo de imagen especificado.
/// Infiere el nombre de la textura en base al path completo
/// Se utiliza un Pool de Texturas para no cargar mas de una vez el mismo archivo.
/// </summary>
/// <param name="d3dDevice">Device de Direct3D</param>
/// <param name="filePath">Ruta completa de la textura. Ejemplo: C:\Texturas\miTextura.jpg</param>
/// <returns>Textura creada</returns>
public static TgcTexture createTexture(Device d3dDevice, string filePath)
{
FileInfo fInfo = new FileInfo(filePath);
return(TgcTexture.createTexture(d3dDevice, fInfo.Name, filePath));
}
/// <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[] { TgcTexture.createTexture(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
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] = TgcTexture.createTexture(device, matAux.subMaterials[m].textureFileName, matAux.subMaterials[m].texturePath);
}
}
//Crear mesh de TGC
TgcMesh tgcMesh = meshFactory.createNewMesh(mesh, meshData.name, TgcMesh.MeshRenderType.DIFFUSE_MAP);
tgcMesh.Materials = meshMaterials;
tgcMesh.DiffuseMaps = meshTextures;
return(tgcMesh);
}
