/// <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> /// 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"); }