/// <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
var materialsArray = new TgcKeyFrameLoaderMaterialAux[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 TgcKeyFrameLoaderMaterialAux();
materialsArray[i] = matAux;
matAux.subMaterials = new TgcKeyFrameLoaderMaterialAux[materialData.subMaterials.Length];
for (var 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 TgcBoundingAxisAlignBox(
TgcParserUtils.float3ArrayToVector3(meshData.pMin),
TgcParserUtils.float3ArrayToVector3(meshData.pMax)
);
}
else
{
tgcMesh.createBoundingBox();
}
tgcMesh.Enabled = true;
return(tgcMesh);
}
//OBB
private List <TgcObb> cargarObbObjetos()
{
string filePath = GuiController.Instance.AlumnoEjemplosMediaDir + "TheC#\\Auto\\\\pistaObbs-TgcScene.xml";
string mediaPath = filePath.Substring(0, filePath.LastIndexOf('\\') + 1);
string xmlString = File.ReadAllText(filePath);
List <TgcObb> objetos = new List <TgcObb>();
XmlDocument dom = new XmlDocument();
dom.LoadXml(xmlString);
XmlElement root = dom.DocumentElement;
//Parsear obbs
XmlNodeList obbNodes = root.GetElementsByTagName("obbs")[0].ChildNodes;
foreach (XmlElement obbNode in obbNodes)
{
Vector3 center = TgcParserUtils.float3ArrayToVector3(TgcParserUtils.parseFloat3Array(obbNode.Attributes["center"].InnerText));
Vector3 extents = TgcParserUtils.float3ArrayToVector3(TgcParserUtils.parseFloat3Array(obbNode.Attributes["extents"].InnerText));
Vector3 orientation0 = TgcParserUtils.float3ArrayToVector3(TgcParserUtils.parseFloat3Array(obbNode.Attributes["orientation0"].InnerText));
Vector3 orientation1 = TgcParserUtils.float3ArrayToVector3(TgcParserUtils.parseFloat3Array(obbNode.Attributes["orientation1"].InnerText));
Vector3 orientation2 = TgcParserUtils.float3ArrayToVector3(TgcParserUtils.parseFloat3Array(obbNode.Attributes["orientation2"].InnerText));
Vector3[] orientation = new Vector3[] { orientation0, orientation1, orientation2 };
TgcObb minObb = new TgcObb();
minObb.Center = center;
minObb.Extents = extents;
minObb.Orientation = orientation;
objetos.Add(minObb);
}
return(objetos);
}
public override void Init()
{
//Cargar escenario, pero inicialmente solo hacemos el parser, para separar los objetos que son solo luces y no meshes
var scenePath = MediaDir + "Escenario\\EscenarioLuces-TgcScene.xml";
var mediaPath = MediaDir + "Escenario\\";
var parser = new TgcSceneParser();
var sceneData = parser.parseSceneFromString(File.ReadAllText(scenePath));
//Separar modelos reales de las luces, segun layer "Lights"
lights = new List <LightData>();
var realMeshData = new List <TgcMeshData>();
for (var i = 0; i < sceneData.meshesData.Length; i++)
{
var meshData = sceneData.meshesData[i];
//Es una luz, no cargar mesh, solo importan sus datos
if (meshData.layerName == "Lights")
{
//Guardar datos de luz
var light = new LightData();
light.color = Color.FromArgb((int)meshData.color[0], (int)meshData.color[1],
(int)meshData.color[2]);
light.aabb = new TgcBoundingAxisAlignBox(TgcParserUtils.float3ArrayToVector3(meshData.pMin),
TgcParserUtils.float3ArrayToVector3(meshData.pMax));
light.pos = light.aabb.calculateBoxCenter();
lights.Add(light);
}
//Es un mesh real, agregar a array definitivo
else
{
realMeshData.Add(meshData);
}
}
//Reemplazar array original de meshData de sceneData por el definitivo
sceneData.meshesData = realMeshData.ToArray();
//Ahora si cargar meshes reales
var loader = new TgcSceneLoader();
scene = loader.loadScene(sceneData, mediaPath);
//Camara en 1ra persona
Camara = new TgcFpsCamera(new Vector3(-20, 80, 450), 400f, 300f, Input);
//Modifiers para variables de luz
Modifiers.addBoolean("lightEnable", "lightEnable", true);
Modifiers.addFloat("lightIntensity", 0, 150, 20);
Modifiers.addFloat("lightAttenuation", 0.1f, 2, 0.3f);
Modifiers.addFloat("specularEx", 0, 20, 9f);
//Modifiers para material
Modifiers.addColor("mEmissive", Color.Black);
Modifiers.addColor("mAmbient", Color.White);
Modifiers.addColor("mDiffuse", Color.White);
Modifiers.addColor("mSpecular", Color.White);
}
/// <summary>
/// Cargar estructura de animacion
/// </summary>
private TgcSkeletalAnimation loadAnimation(TgcSkeletalMesh mesh, TgcSkeletalAnimationData animationData)
{
//Crear array para todos los huesos, tengan o no keyFrames
var boneFrames = new List <TgcSkeletalAnimationFrame> [mesh.Bones.Length];
//Cargar los frames para los huesos que si tienen
for (var i = 0; i < animationData.bonesFrames.Length; i++)
{
var boneData = animationData.bonesFrames[i];
//Crear frames
for (var j = 0; j < boneData.keyFrames.Length; j++)
{
var frameData = boneData.keyFrames[j];
var frame = new TgcSkeletalAnimationFrame(
frameData.frame,
new Vector3(frameData.position[0], frameData.position[1], frameData.position[2]),
new Quaternion(frameData.rotation[0], frameData.rotation[1], frameData.rotation[2],
frameData.rotation[3])
);
//Agregar a lista de frames del hueso
if (boneFrames[boneData.id] == null)
{
boneFrames[boneData.id] = new List <TgcSkeletalAnimationFrame>();
}
boneFrames[boneData.id].Add(frame);
}
}
//BoundingBox de la animación, aprovechar lo que viene en el XML o utilizar el de la malla estática
TgcBoundingAxisAlignBox boundingBox = null;
if (animationData.pMin != null && animationData.pMax != null)
{
boundingBox = new TgcBoundingAxisAlignBox(
TgcParserUtils.float3ArrayToVector3(animationData.pMin),
TgcParserUtils.float3ArrayToVector3(animationData.pMax));
}
else
{
boundingBox = mesh.BoundingBox;
}
//Crear animacion
var animation = new TgcSkeletalAnimation(animationData.name, animationData.frameRate,
animationData.framesCount, boneFrames, boundingBox);
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
TgcBoundingAxisAlignBox boundingBox = null;
if (animationData.pMin != null && animationData.pMax != null)
{
boundingBox = new TgcBoundingAxisAlignBox(
TgcParserUtils.float3ArrayToVector3(animationData.pMin),
TgcParserUtils.float3ArrayToVector3(animationData.pMax));
}
else
{
boundingBox = mesh.BoundingBox;
}
var animation = new TgcKeyFrameAnimation(animationData, boundingBox);
mesh.Animations.Add(animationData.name, animation);
return(animation);
}
/// <summary>
/// Carga la escena a partir de un objeto TgcSceneData ya parseado
/// </summary>
/// <param name="sceneData">Objeto con datos de la escena ya parseados</param>
/// <param name="mediaPath">Path a partir del cual hay que buscar los recursos de escena (Texturas, LightMaps, etc.)</param>
/// <returns></returns>
public TgcScene loadScene(TgcSceneData sceneData, string mediaPath)
{
var tgcScene = new TgcScene(sceneData.name, null);
//Cargar Texturas
var materialsArray = new TgcSceneLoaderMaterialAux[sceneData.materialsData.Length];
for (var i = 0; i < sceneData.materialsData.Length; i++)
{
var materialData = sceneData.materialsData[i];
var texturesPath = mediaPath + sceneData.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 TgcSceneLoaderMaterialAux();
materialsArray[i] = matAux;
matAux.subMaterials = new TgcSceneLoaderMaterialAux[materialData.subMaterials.Length];
for (var j = 0; j < materialData.subMaterials.Length; j++)
{
matAux.subMaterials[j] = createTextureAndMaterial(materialData.subMaterials[j], texturesPath);
}
}
}
//Cargar Meshes
for (var i = 0; i < sceneData.meshesData.Length; i++)
{
var meshData = sceneData.meshesData[i];
TgcMesh tgcMesh = null;
//Crear malla original
if (meshData.instanceType.Equals(TgcMeshData.ORIGINAL))
{
//Crear mesh que no tiene Material, con un color simple
if (meshData.materialId == -1)
{
tgcMesh = crearMeshSoloColor(meshData);
}
//Para los que si tienen Material
else
{
//Crear MeshFormat que soporte LightMaps
if (meshData.lightmapEnabled)
{
tgcMesh = crearMeshDiffuseMapLightmap(sceneData, mediaPath, materialsArray, meshData);
}
//Formato de Mesh con Textura pero sin Lightmap
else
{
tgcMesh = crearMeshDiffuseMap(materialsArray, meshData);
}
}
}
//Crear malla instancia
else if (meshData.instanceType.Equals(TgcMeshData.INSTANCE))
{
tgcMesh = crearMeshInstance(meshData, tgcScene.Meshes);
}
//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),
tgcMesh.Position,
tgcMesh.Scale
);
}
else
{
tgcMesh.createBoundingBox();
}
//Cargar layer
tgcMesh.Layer = meshData.layerName;
//Cargar AlphaBlending
tgcMesh.AlphaBlendEnable = meshData.alphaBlending;
//agregar mesh a escena
tgcMesh.Enabled = true;
tgcScene.Meshes.Add(tgcMesh);
//Cargar userProperties, si hay
tgcMesh.UserProperties = meshData.userProperties;
}
//BoundingBox del escenario, utilizar el que viene del XML o crearlo nosotros
if (sceneData.pMin != null && sceneData.pMax != null)
{
tgcScene.BoundingBox = new TgcBoundingBox(
new Vector3(sceneData.pMin[0], sceneData.pMin[1], sceneData.pMin[2]),
new Vector3(sceneData.pMax[0], sceneData.pMax[1], sceneData.pMax[2])
);
}
else
{
var boundingBoxes = new List <TgcBoundingBox>();
foreach (var mesh in tgcScene.Meshes)
{
boundingBoxes.Add(mesh.BoundingBox);
}
tgcScene.BoundingBox = TgcBoundingBox.computeFromBoundingBoxes(boundingBoxes);
}
//Cargar parte de PortalRendering, solo hay información
if (sceneData.portalData != null)
{
var portalLoader = new TgcPortalRenderingLoader();
tgcScene.PortalRendering = portalLoader.loadFromData(tgcScene, sceneData.portalData);
}
return(tgcScene);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Cargar textura de CubeMap para Environment Map, fijo para todos los meshes
cubeMap = TextureLoader.FromCubeFile(d3dDevice, GuiController.Instance.ExamplesMediaDir + "Shaders\\CubeMap.dds");
//Cargar Shader personalizado de EnvironmentMap
effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesMediaDir + "Shaders\\EnvironmentMap_Integrador2.fx");
//Cargar escenario, pero inicialmente solo hacemos el parser, para separar los objetos que son solo luces y no meshes
string scenePath = GuiController.Instance.ExamplesDir + "Lights\\NormalMapRoom\\NormalMapRoom-TgcScene.xml";
string mediaPath = GuiController.Instance.ExamplesDir + "Lights\\NormalMapRoom\\";
TgcSceneParser parser = new TgcSceneParser();
TgcSceneData sceneData = parser.parseSceneFromString(File.ReadAllText(scenePath));
//Separar modelos reales de las luces, segun layer "Lights"
lights = new List <LightData>();
List <TgcMeshData> realMeshData = new List <TgcMeshData>();
for (int i = 0; i < sceneData.meshesData.Length; i++)
{
TgcMeshData meshData = sceneData.meshesData[i];
//Es una luz, no cargar mesh, solo importan sus datos
if (meshData.layerName == "Lights")
{
//Guardar datos de luz
LightData light = new LightData();
light.color = Color.FromArgb((int)meshData.color[0], (int)meshData.color[1], (int)meshData.color[2]);
light.aabb = new TgcBoundingBox(TgcParserUtils.float3ArrayToVector3(meshData.pMin), TgcParserUtils.float3ArrayToVector3(meshData.pMax));
light.pos = light.aabb.calculateBoxCenter();
lights.Add(light);
}
//Es un mesh real, agregar a array definitivo
else
{
realMeshData.Add(meshData);
}
}
//Reemplazar array original de meshData de sceneData por el definitivo
sceneData.meshesData = realMeshData.ToArray();
//Ahora si cargar meshes reales
TgcSceneLoader loader = new TgcSceneLoader();
TgcScene scene = loader.loadScene(sceneData, mediaPath);
//Separar meshes con bumpMapping de los comunes
List <TgcMeshBumpMapping> bumpMeshes = new List <TgcMeshBumpMapping>();
commonMeshes = new List <TgcMesh>();
foreach (TgcMesh mesh in scene.Meshes)
{
//Mesh con BumpMapping
if (mesh.Layer == "BumpMap")
{
//Por convencion de este ejemplo el NormalMap se llama igual que el DiffuseMap (y cada mesh tiene una sola)
string path = mesh.DiffuseMaps[0].FilePath;
string[] split = path.Split('.');
path = split[0] + "_NormalMap.png";
//Convertir TgcMesh a TgcMeshBumpMapping
TgcTexture normalMap = TgcTexture.createTexture(path);
TgcTexture[] normalMapArray = new TgcTexture[] { normalMap };
TgcMeshBumpMapping bumpMesh = TgcMeshBumpMapping.fromTgcMesh(mesh, normalMapArray);
bumpMesh.Effect = effect;
bumpMesh.Technique = "ThreeLightsTechnique";
bumpMeshes.Add(bumpMesh);
//Liberar original
mesh.dispose();
}
//Mesh normal
else
{
commonMeshes.Add(mesh);
}
}
//Pre-calculamos las 3 luces mas cercanas de cada mesh
meshesWithLight = new List <MeshLightData>();
foreach (TgcMeshBumpMapping mesh in bumpMeshes)
{
MeshLightData meshData = new MeshLightData();
meshData.mesh = mesh;
Vector3 meshCeter = mesh.BoundingBox.calculateBoxCenter();
meshData.lights[0] = getClosestLight(meshCeter, null, null);
meshData.lights[1] = getClosestLight(meshCeter, meshData.lights[0], null);
meshData.lights[2] = getClosestLight(meshCeter, meshData.lights[0], meshData.lights[1]);
meshesWithLight.Add(meshData);
}
//Camara en 1ra persona
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.setCamera(new Vector3(0, 50, 100), new Vector3(0, 50, -1));
//Modifiers
GuiController.Instance.Modifiers.addBoolean("lightEnable", "lightEnable", true);
GuiController.Instance.Modifiers.addFloat("reflection", 0, 1, 0.2f);
GuiController.Instance.Modifiers.addFloat("bumpiness", 0, 2, 1f);
GuiController.Instance.Modifiers.addFloat("lightIntensity", 0, 150, 20);
GuiController.Instance.Modifiers.addFloat("lightAttenuation", 0.1f, 2, 0.3f);
GuiController.Instance.Modifiers.addFloat("specularEx", 0, 20, 9f);
GuiController.Instance.Modifiers.addColor("mEmissive", Color.Black);
GuiController.Instance.Modifiers.addColor("mAmbient", Color.White);
GuiController.Instance.Modifiers.addColor("mDiffuse", Color.White);
GuiController.Instance.Modifiers.addColor("mSpecular", Color.White);
}
public override void Init()
{
//Cargar textura de CubeMap para Environment Map, fijo para todos los meshes
cubeMap = TextureLoader.FromCubeFile(D3DDevice.Instance.Device,
MediaDir + "CubeMap.dds");
//Cargar Shader personalizado de EnvironmentMap
effect = TgcShaders.loadEffect(ShadersDir + "EnvironmentMap.fx");
//Cargar escenario, pero inicialmente solo hacemos el parser, para separar los objetos que son solo luces y no meshes
var scenePath = MediaDir + "NormalMapRoom\\NormalMapRoom-TgcScene.xml";
var mediaPath = MediaDir + "NormalMapRoom\\";
var parser = new TgcSceneParser();
var sceneData = parser.parseSceneFromString(File.ReadAllText(scenePath));
//Separar modelos reales de las luces, segun layer "Lights"
lights = new List <LightData>();
var realMeshData = new List <TgcMeshData>();
for (var i = 0; i < sceneData.meshesData.Length; i++)
{
var meshData = sceneData.meshesData[i];
//Es una luz, no cargar mesh, solo importan sus datos
if (meshData.layerName == "Lights")
{
//Guardar datos de luz
var light = new LightData();
light.color = Color.FromArgb((int)meshData.color[0], (int)meshData.color[1],
(int)meshData.color[2]);
light.aabb = new TgcBoundingAxisAlignBox(TgcParserUtils.float3ArrayToVector3(meshData.pMin),
TgcParserUtils.float3ArrayToVector3(meshData.pMax));
light.pos = light.aabb.calculateBoxCenter();
lights.Add(light);
}
//Es un mesh real, agregar a array definitivo
else
{
realMeshData.Add(meshData);
}
}
//Reemplazar array original de meshData de sceneData por el definitivo
sceneData.meshesData = realMeshData.ToArray();
//Ahora si cargar meshes reales
var loader = new TgcSceneLoader();
var scene = loader.loadScene(sceneData, mediaPath);
//Separar meshes con bumpMapping de los comunes
bumpMeshes = new List <TgcMeshBumpMapping>();
commonMeshes = new List <TgcMesh>();
foreach (var mesh in scene.Meshes)
{
//Mesh con BumpMapping
if (mesh.Layer == "BumpMap")
{
//Por convencion de este ejemplo el NormalMap se llama igual que el DiffuseMap (y cada mesh tiene una sola)
var path = mesh.DiffuseMaps[0].FilePath;
var split = path.Split('.');
path = split[0] + "." + split[1] + "_NormalMap.png";
//Convertir TgcMesh a TgcMeshBumpMapping
var normalMap = TgcTexture.createTexture(path);
TgcTexture[] normalMapArray = { normalMap };
var bumpMesh = TgcMeshBumpMapping.fromTgcMesh(mesh, normalMapArray);
bumpMesh.Effect = effect;
bumpMesh.Technique = "EnvironmentMapTechnique";
bumpMeshes.Add(bumpMesh);
//Liberar original
mesh.dispose();
}
//Mesh normal
else
{
commonMeshes.Add(mesh);
}
}
//Camara en 1ra persona
Camara = new TgcFpsCamera(new Vector3(0, 50, 100), Input);
//Modifiers
Modifiers.addFloat("reflection", 0, 1, 0.2f);
Modifiers.addFloat("bumpiness", 0, 2, 1f);
Modifiers.addFloat("lightIntensity", 0, 150, 20);
Modifiers.addFloat("lightAttenuation", 0.1f, 2, 0.3f);
Modifiers.addFloat("specularEx", 0, 20, 9f);
Modifiers.addColor("mEmissive", Color.Black);
Modifiers.addColor("mAmbient", Color.White);
Modifiers.addColor("mDiffuse", Color.White);
Modifiers.addColor("mSpecular", Color.White);
}
