/// <summary>
/// Carga una animación a un modelo ya cargado, a partir del string del XML.
/// La animación se agrega al modelo.
/// </summary>
/// <param name="mesh">Modelo ya cargado</param>
/// <param name="xmlString">contenido del XML</param>
public TgcKeyFrameAnimation loadAnimationFromString(TgcKeyFrameMesh mesh, string xmlString)
{
TgcKeyFrameParser parser = new TgcKeyFrameParser();
TgcKeyFrameAnimationData animationData = parser.parseAnimationFromString(xmlString);
return(loadAnimation(mesh, animationData));
}
/// <summary>
/// Carga un modelo y un conjunto de animaciones a partir de varios archivos
/// </summary>
/// <param name="meshFilePath">Ubicacion del archivo XML del modelo</param>
/// <param name="mediaPath">Path a partir del cual hay que buscar las Texturas</param>
/// <param name="animationsFilePath">Array con ubicaciones de los archivos XML de cada animación</param>
/// <returns>Modelo cargado con sus animaciones</returns>
public TgcKeyFrameMesh loadMeshAndAnimationsFromFile(string meshFilePath, string mediaPath, string[] animationsFilePath)
{
TgcKeyFrameMesh mesh = loadMeshFromFile(meshFilePath, mediaPath);
foreach (string animPath in animationsFilePath)
{
loadAnimationFromFile(mesh, animPath);
}
return(mesh);
}
/// <summary>
/// Crea un mesh sin texturas, solo con VertexColors
/// </summary>
/// <param name="meshData"></param>
private TgcKeyFrameMesh crearMeshSoloColor(TgcKeyFrameMeshData meshData)
{
//Crear Mesh
Mesh mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length, MeshFlags.Managed, VertexColorVertexElements, 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++)
{
VertexColorVertex v = new VertexColorVertex();
//vertices
int coordIdx = meshData.coordinatesIndices[j] * 3;
v.Position = new Vector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//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 i = 0; i < indices.Length; i++)
{
indices[i] = (short)i;
}
ib.SetData(indices, 0, LockFlags.None);
}
//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 = null;
originalData.textureCoordinates = null;
//Crear mesh de TGC
TgcKeyFrameMesh tgcMesh = new TgcKeyFrameMesh(mesh, meshData.name, TgcKeyFrameMesh.MeshRenderType.VERTEX_COLOR, originalData);
return(tgcMesh);
}
/// <summary>
/// Carga una animación a un modelo ya cargado, en base a un archivo
/// La animación se agrega al modelo.
/// </summary>
/// <param name="mesh">Modelo ya cargado</param>
/// <param name="filePath">Ubicacion del archivo XML de la animación</param>
public TgcKeyFrameAnimation loadAnimationFromFile(TgcKeyFrameMesh mesh, string filePath)
{
try
{
string xmlString = File.ReadAllText(filePath);
return(loadAnimationFromString(mesh, xmlString));
}
catch (Exception ex)
{
throw new Exception("Error al cargar animacion desde archivo: " + filePath, ex);
}
}
/// <summary>
/// Crea una nueva malla que es una instancia de esta malla original
/// Reutiliza toda la geometría de la malla original sin duplicarla.
/// Solo se puede crear instancias a partir de originales.
/// Se debe crear después de haber agregado todas las animaciones al original.
/// </summary>
/// <param name="name">Nombre de la malla</param>
/// <param name="translation">Traslación respecto de la malla original</param>
/// <param name="rotation">Rotación respecto de la malla original</param>
/// <param name="scale">Escala respecto de la malla original</param>
public TgcKeyFrameMesh createMeshInstance(string name, Vector3 translation, Vector3 rotation, Vector3 scale)
{
if (this.parentInstance != null)
{
throw new Exception("No se puede crear una instancia de otra malla instancia. Hay que partir del original.");
}
//Crear instancia
TgcKeyFrameMesh instance = new TgcKeyFrameMesh(name, this, translation, rotation, scale);
//BoundingBox
instance.boundingBox = new TgcBoundingBox(this.boundingBox.PMin, this.boundingBox.PMax);
instance.updateBoundingBox();
instance.enabled = true;
return(instance);
}
/// <summary>
/// Libera los recursos de la malla
/// </summary>
public void dispose()
{
this.enabled = false;
if (boundingBox != null)
{
boundingBox.dispose();
}
//dejar de utilizar originalData
originalData = null;
//Si es una instancia no liberar nada, lo hace el original.
if (parentInstance != null)
{
parentInstance = null;
return;
}
//hacer dispose de instancias
foreach (TgcKeyFrameMesh meshInstance in meshInstances)
{
meshInstance.dispose();
}
meshInstances = null;
//Dispose de mesh
this.d3dMesh.Dispose();
this.d3dMesh = null;
//Dispose de texturas
if (diffuseMaps != null)
{
for (int i = 0; i < diffuseMaps.Length; i++)
{
diffuseMaps[i].dispose();
}
diffuseMaps = null;
}
//VertexDeclaration
vertexDeclaration.Dispose();
vertexDeclaration = null;
}
/// <summary>
/// Carga una animación a un modelo ya cargado, a partir de un objeto TgcKeyFrameAnimationData ya parseado
/// La animación se agrega al modelo.
/// </summary>
/// <param name="mesh">Modelo ya cargado</param>
/// <param name="animationData">Objeto de animacion con datos ya cargados</param>
public TgcKeyFrameAnimation loadAnimation(TgcKeyFrameMesh mesh, TgcKeyFrameAnimationData animationData)
{
//BoundingBox de la animación, aprovechar lo que viene en el XML o utilizar el de la malla estática
TgcBoundingBox boundingBox = null;
if (animationData.pMin != null && animationData.pMax != null)
{
boundingBox = new TgcBoundingBox(
TgcParserUtils.float3ArrayToVector3(animationData.pMin),
TgcParserUtils.float3ArrayToVector3(animationData.pMax));
}
else
{
boundingBox = mesh.BoundingBox;
}
TgcKeyFrameAnimation animation = new TgcKeyFrameAnimation(animationData, boundingBox);
mesh.Animations.Add(animationData.name, animation);
return animation;
}
/// <summary>
/// Carga una animación a un modelo ya cargado, a partir de un objeto TgcKeyFrameAnimationData ya parseado
/// La animación se agrega al modelo.
/// </summary>
/// <param name="mesh">Modelo ya cargado</param>
/// <param name="animationData">Objeto de animacion con datos ya cargados</param>
public TgcKeyFrameAnimation loadAnimation(TgcKeyFrameMesh mesh, TgcKeyFrameAnimationData animationData)
{
//BoundingBox de la animación, aprovechar lo que viene en el XML o utilizar el de la malla estática
TgcBoundingBox boundingBox = null;
if (animationData.pMin != null && animationData.pMax != null)
{
boundingBox = new TgcBoundingBox(
TgcParserUtils.float3ArrayToVector3(animationData.pMin),
TgcParserUtils.float3ArrayToVector3(animationData.pMax));
}
else
{
boundingBox = mesh.BoundingBox;
}
TgcKeyFrameAnimation animation = new TgcKeyFrameAnimation(animationData, boundingBox);
mesh.Animations.Add(animationData.name, animation);
return(animation);
}
/// <summary>
/// Crea una nueva malla que es una instancia de otra malla original.
/// Reutiliza toda la geometría de la malla original sin duplicarla.
/// Debe crearse luego de haber cargado todas las animaciones en la malla original
/// </summary>
/// <param name="name">Nombre de la malla</param>
/// <param name="parentInstance">Malla original desde la cual basarse</param>
/// <param name="translation">Traslación respecto de la malla original</param>
/// <param name="rotation">Rotación respecto de la malla original</param>
/// <param name="scale">Escala respecto de la malla original</param>
public TgcKeyFrameMesh(string name, TgcKeyFrameMesh parentInstance, Vector3 translation, Vector3 rotation, Vector3 scale)
{
//Cargar iniciales datos en base al original
this.initData(parentInstance.d3dMesh, name, parentInstance.renderType, parentInstance.originalData);
this.diffuseMaps = parentInstance.diffuseMaps;
this.materials = parentInstance.materials;
//Almacenar transformación inicial
this.translation = translation;
this.rotation = rotation;
this.scale = scale;
//Agregar animaciones del original
foreach (KeyValuePair <string, TgcKeyFrameAnimation> entry in parentInstance.animations)
{
this.animations.Add(entry.Key, entry.Value);
}
//almacenar instancia en el padre
this.parentInstance = parentInstance;
parentInstance.meshInstances.Add(this);
}
public override void init()
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Crear loader
TgcKeyFrameLoader loader = new TgcKeyFrameLoader();
//Crear piso
TgcTexture pisoTexture = TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesMediaDir + "Texturas\\tierra.jpg");
piso = TgcBox.fromSize(new Vector3(0, -60, 0), new Vector3(1000, 5, 1000), pisoTexture);
String mediaDir = CommandosUI.Instance.MediaDir;
//Cargar modelo con una animación Key Frame
string pathMesh = mediaDir + "Pez//" + "pez-TgcKeyFrameMesh.xml";
string[] animationsPath = new string[] {
mediaDir + "Pez//Animaciones//nadar-TgcKeyFrameAnim.xml",
mediaDir + "Pez//Animaciones//quieto-TgcKeyFrameAnim.xml"
};
personaje = (TgcKeyFrameMesh)loader.loadMeshAndAnimationsFromFile(pathMesh, animationsPath);
personaje.playAnimation("quieto");
//Sonido
//Cargar sonido
sonidoChapoteo = new TgcStaticSound();
sonidoChapoteo.loadSound(mediaDir+ "Pez//" + "Sound//WATER.WAV");
//Posicion inicial
personaje.Position = new Vector3(0, -45, 0);
personaje.rotateY(Geometry.DegreeToRadian(180f));
GuiController.Instance.Modifiers.addFloat("speed", 10, 100, 40);
//Crear un modifier para un ComboBox con opciones
string[] opciones = new string[] { "Teclas", "Picking"};
GuiController.Instance.Modifiers.addInterval("Controles", opciones, 0);
currentControl = "Teclas";
//Configurar camara en Tercer Persona
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.ThirdPersonCamera.setCamera(personaje.Position, 30, -30);
//Coordenadas mouse
GuiController.Instance.UserVars.addVar("Posicion Mouse");
//Musica :D
GuiController.Instance.Mp3Player.FileName = mediaDir + "Pez//" + "Music//UWSDWF.mp3";
GuiController.Instance.Mp3Player.play(true);
reproduciendo = true;
GuiController.Instance.Modifiers.addBoolean("Musica", "Reproducir", true);
//Picking
pickingRay = new TgcPickingRay();
collisionPointMesh = TgcBox.fromSize(new Vector3(3, 1, 3), Color.Red);
}
/// <summary>
/// Libera los recursos de la malla
/// </summary>
public void dispose()
{
this.enabled = false;
if (boundingBox != null)
{
boundingBox.dispose();
}
//dejar de utilizar originalData
originalData = null;
//Si es una instancia no liberar nada, lo hace el original.
if (parentInstance != null)
{
parentInstance = null;
return;
}
//hacer dispose de instancias
foreach (TgcKeyFrameMesh meshInstance in meshInstances)
{
meshInstance.dispose();
}
meshInstances = null;
//Dispose de mesh
this.d3dMesh.Dispose();
this.d3dMesh = null;
//Dispose de texturas
if (diffuseMaps != null)
{
for (int i = 0; i < diffuseMaps.Length; i++)
{
diffuseMaps[i].dispose();
}
diffuseMaps = null;
}
//VertexDeclaration
vertexDeclaration.Dispose();
vertexDeclaration = null;
}
/// <summary>
/// Crea una nueva malla que es una instancia de otra malla original.
/// Reutiliza toda la geometría de la malla original sin duplicarla.
/// Debe crearse luego de haber cargado todas las animaciones en la malla original
/// </summary>
/// <param name="name">Nombre de la malla</param>
/// <param name="parentInstance">Malla original desde la cual basarse</param>
/// <param name="translation">Traslación respecto de la malla original</param>
/// <param name="rotation">Rotación respecto de la malla original</param>
/// <param name="scale">Escala respecto de la malla original</param>
public TgcKeyFrameMesh(string name, TgcKeyFrameMesh parentInstance, Vector3 translation, Vector3 rotation, Vector3 scale)
{
//Cargar iniciales datos en base al original
this.initData(parentInstance.d3dMesh, name, parentInstance.renderType, parentInstance.originalData);
this.diffuseMaps = parentInstance.diffuseMaps;
this.materials = parentInstance.materials;
//Almacenar transformación inicial
this.translation = translation;
this.rotation = rotation;
this.scale = scale;
//Agregar animaciones del original
foreach (KeyValuePair<string, TgcKeyFrameAnimation> entry in parentInstance.animations)
{
this.animations.Add(entry.Key, entry.Value);
}
//almacenar instancia en el padre
this.parentInstance = parentInstance;
parentInstance.meshInstances.Add(this);
}
/// <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
TgcKeyFrameLoaderMaterialAux[] materialsArray = new TgcKeyFrameLoaderMaterialAux[meshData.materialsData.Length];
for (int i = 0; i < meshData.materialsData.Length; i++)
{
TgcMaterialData materialData = meshData.materialsData[i];
string 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))
{
TgcKeyFrameLoaderMaterialAux matAux = new TgcKeyFrameLoaderMaterialAux();
materialsArray[i] = matAux;
matAux.subMaterials = new TgcKeyFrameLoaderMaterialAux[materialData.subMaterials.Length];
for (int 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 TgcBoundingBox(
TgcParserUtils.float3ArrayToVector3(meshData.pMin),
TgcParserUtils.float3ArrayToVector3(meshData.pMax)
);
}
else
{
tgcMesh.createBoundingBox();
}
tgcMesh.Enabled = true;
return(tgcMesh);
}
/// <summary>
/// Crea una nueva malla que es una instancia de esta malla original
/// Reutiliza toda la geometría de la malla original sin duplicarla.
/// Solo se puede crear instancias a partir de originales.
/// Se debe crear después de haber agregado todas las animaciones al original.
/// </summary>
/// <param name="name">Nombre de la malla</param>
/// <param name="translation">Traslación respecto de la malla original</param>
/// <param name="rotation">Rotación respecto de la malla original</param>
/// <param name="scale">Escala respecto de la malla original</param>
public TgcKeyFrameMesh createMeshInstance(string name, Vector3 translation, Vector3 rotation, Vector3 scale)
{
if (this.parentInstance != null)
{
throw new Exception("No se puede crear una instancia de otra malla instancia. Hay que partir del original.");
}
//Crear instancia
TgcKeyFrameMesh instance = new TgcKeyFrameMesh(name, this, translation, rotation, scale);
//BoundingBox
instance.boundingBox = new TgcBoundingBox(this.boundingBox.PMin, this.boundingBox.PMax);
instance.updateBoundingBox();
instance.enabled = true;
return instance;
}
/// <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 sin texturas, solo con VertexColors
/// </summary>
/// <param name="meshData"></param>
private TgcKeyFrameMesh crearMeshSoloColor(TgcKeyFrameMeshData meshData)
{
//Crear Mesh
Mesh mesh = new Mesh(meshData.coordinatesIndices.Length / 3, meshData.coordinatesIndices.Length, MeshFlags.Managed, VertexColorVertexElements, 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++)
{
VertexColorVertex v = new VertexColorVertex();
//vertices
int coordIdx = meshData.coordinatesIndices[j] * 3;
v.Position = new Vector3(
meshData.verticesCoordinates[coordIdx],
meshData.verticesCoordinates[coordIdx + 1],
meshData.verticesCoordinates[coordIdx + 2]
);
//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 i = 0; i < indices.Length; i++)
{
indices[i] = (short)i;
}
ib.SetData(indices, 0, LockFlags.None);
}
//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 = null;
originalData.textureCoordinates = null;
//Crear mesh de TGC
TgcKeyFrameMesh tgcMesh = new TgcKeyFrameMesh(mesh, meshData.name, TgcKeyFrameMesh.MeshRenderType.VERTEX_COLOR, originalData);
return tgcMesh;
}
/// <summary>
/// Carga una animación a un modelo ya cargado, a partir del string del XML.
/// La animación se agrega al modelo.
/// </summary>
/// <param name="mesh">Modelo ya cargado</param>
/// <param name="xmlString">contenido del XML</param>
public TgcKeyFrameAnimation loadAnimationFromString(TgcKeyFrameMesh mesh, string xmlString)
{
TgcKeyFrameParser parser = new TgcKeyFrameParser();
TgcKeyFrameAnimationData animationData = parser.parseAnimationFromString(xmlString);
return loadAnimation(mesh, animationData);
}
/// <summary>
/// Carga una animación a un modelo ya cargado, en base a un archivo
/// La animación se agrega al modelo.
/// </summary>
/// <param name="mesh">Modelo ya cargado</param>
/// <param name="filePath">Ubicacion del archivo XML de la animación</param>
public TgcKeyFrameAnimation loadAnimationFromFile(TgcKeyFrameMesh mesh, string filePath)
{
try
{
string xmlString = File.ReadAllText(filePath);
return loadAnimationFromString(mesh, xmlString);
}
catch (Exception ex)
{
throw new Exception("Error al cargar animacion desde archivo: " + filePath, ex);
}
}
/// <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);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Paths para archivo XML de la malla
string pathMesh = GuiController.Instance.ExamplesMediaDir + "KeyframeAnimations\\Robot\\Robot-TgcKeyFrameMesh.xml";
//Path para carpeta de texturas de la malla
string mediaPath = GuiController.Instance.ExamplesMediaDir + "KeyframeAnimations\\Robot\\";
//Lista de animaciones disponibles
string[] animationList = new string[]{
"Parado",
"Caminando",
"Correr",
"PasoDerecho",
"PasoIzquierdo",
"Empujar",
"Patear",
"Pegar",
"Arrojar",
};
//Crear rutas con cada animacion
string[] animationsPath = new string[animationList.Length];
for (int i = 0; i < animationList.Length; i++)
{
animationsPath[i] = mediaPath + animationList[i] + "-TgcKeyFrameAnim.xml";
}
//Cargar mesh y animaciones
TgcKeyFrameLoader loader = new TgcKeyFrameLoader();
mesh = loader.loadMeshAndAnimationsFromFile(pathMesh, mediaPath, animationsPath);
//Agregar combo para elegir animacion
GuiController.Instance.Modifiers.addInterval("animation", animationList, 0);
selectedAnim = animationList[0];
//Modifier para especificar si la animación se anima con loop
animateWithLoop = true;
GuiController.Instance.Modifiers.addBoolean("loop", "Loop anim:", animateWithLoop);
//Modifier para color
currentColor = Color.White;
GuiController.Instance.Modifiers.addColor("Color", currentColor);
//Modifier para BoundingBox
GuiController.Instance.Modifiers.addBoolean("BoundingBox", "BoundingBox:", false);
//Elegir animacion Caminando
mesh.playAnimation(selectedAnim, true);
//Configurar camara
GuiController.Instance.RotCamera.setCamera(new Vector3(0, 70, 0), 200);
}
/// <summary>
/// Obtener technique default para un TgcKeyFrameMesh según su MeshRenderType
/// </summary>
/// <param name="renderType">MeshRenderType</param>
/// <returns>Nombre del Technique que le corresponde</returns>
public string getTgcKeyFrameMeshTechnique(TgcKeyFrameMesh.MeshRenderType renderType)
{
switch (renderType)
{
case TgcKeyFrameMesh.MeshRenderType.VERTEX_COLOR:
return "VERTEX_COLOR";
case TgcKeyFrameMesh.MeshRenderType.DIFFUSE_MAP:
return "DIFFUSE_MAP";
}
throw new Exception("RenderType incorrecto");
}
