public override void init()
{
//FPS Camara
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.setCamera(new Vector3(-140f, 40f, -50f), new Vector3(-140f,40f,-120f));
GuiController.Instance.FpsCamera.MovementSpeed = 200f;
GuiController.Instance.FpsCamera.JumpSpeed = 200f;
//Cargar escena desde archivo ZIP
TgcSceneLoader loader = new TgcSceneLoader();
tgcScene = loader.loadSceneFromZipFile(
"4toPiso-TgcScene.xml",
GuiController.Instance.ExamplesMediaDir + "4toPiso\\4toPiso.zip",
GuiController.Instance.ExamplesMediaDir + "4toPiso\\Extract\\" );
/*
//Version para cargar escena desde carpeta descomprimida
TgcSceneLoader loader = new TgcSceneLoader();
tgcScene = loader.loadSceneFromFile(
GuiController.Instance.ExamplesMediaDir + "4toPiso\\Extract\\4toPiso-TgcScene.xml",
GuiController.Instance.ExamplesMediaDir + "4toPiso\\Extract\\");
*/
//Modifier para habilitar o deshabilitar FrustumCulling
GuiController.Instance.Modifiers.addBoolean("culling", "Frustum culling", true);
//UserVar para contar la cantidad de meshes que se renderizan
GuiController.Instance.UserVars.addVar("Meshes renderizadas");
}
/// <summary>
/// Crear Manager
/// </summary>
/// <param name="scene">Escenario a administrar</param>
public TgcPortalRenderingManager(TgcScene scene)
{
this.scene = scene;
this.cells = new List<TgcPortalRenderingCell>();
this.portals = new List<TgcPortalRenderingPortal>();
this.frustumConvexPolyhedon = new TgcConvexPolyhedron();
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
TgcSceneLoader loader = new TgcSceneLoader();
TgcScene sceneOriginal = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Iglesia\\" + "Iglesia-TgcScene.xml");
TgcScene sceneOriginal2 = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Iglesia\\" + "Iglesia-TgcScene.xml");
//sceneOriginal = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\CajaVerde\\" + "CajaVerde-TgcScene.xml");
//sceneOriginal = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Avion\\" + "Avion-TgcScene.xml");
//sceneOriginal = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Iglesia\\" + "Iglesia-TgcScene.xml");
//TgcScene sceneOriginal = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Box\\" + "Box-TgcScene.xml");
//TgcScene sceneOriginal2 = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "ModelosTgc\\Box\\" + "Box-TgcScene.xml");
string destFolder = GuiController.Instance.ExamplesDir + "\\" + "PruebaExporter";
TgcScene unifiedScene = new TgcScene("PruebaExporter", destFolder);
unifiedScene.Meshes.AddRange(sceneOriginal.Meshes);
unifiedScene.Meshes.AddRange(sceneOriginal2.Meshes);
TgcSceneExporter exporter = new TgcSceneExporter();
//string fileSaved = exporter.exportSceneToXml(unifiedScene, destFolder);
//string fileSaved = exporter.exportAndAppendSceneToXml(unifiedScene, destFolder);
TgcSceneExporter.ExportResult r = exporter.exportAndAppendSceneToXml(sceneOriginal, destFolder);
sceneRecover = loader.loadSceneFromFile(r.filePath);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Cargar escenario
TgcSceneLoader loader = new TgcSceneLoader();
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Scenes\\Deposito\\Deposito-TgcScene.xml");
//Camara en 1ra persona
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.MovementSpeed = 400f;
GuiController.Instance.FpsCamera.JumpSpeed = 300f;
GuiController.Instance.FpsCamera.setCamera(new Vector3(-20, 80, 450), new Vector3(0, 80, 1));
//Mesh para la luz
lightMesh = TgcBox.fromSize(new Vector3(10, 10, 10), Color.Red);
//Modifiers de la luz
GuiController.Instance.Modifiers.addBoolean("lightEnable", "lightEnable", true);
GuiController.Instance.Modifiers.addVertex3f("lightPos", new Vector3(-200, -100, -200), new Vector3(200, 200, 300), new Vector3(60, 35, 250));
GuiController.Instance.Modifiers.addColor("lightColor", Color.White);
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);
//Modifiers de material
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()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Crear loader
TgcSceneLoader loader = new TgcSceneLoader();
//Cargar los mesh:
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir
+ "MeshCreator\\Meshes\\Vehiculos\\TanqueFuturistaRuedas\\TanqueFuturistaRuedas-TgcScene.xml");
mesh = scene.Meshes[0];
mesh.Scale = new Vector3(0.5f, 0.5f, 0.5f);
mesh.Position = new Vector3(0f, 0f, 0f);
//Cargar Shader personalizado
effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Shaders\\BasicShader.fx");
// le asigno el efecto a la malla
mesh.Effect = effect;
// indico que tecnica voy a usar
// Hay effectos que estan organizados con mas de una tecnica.
mesh.Technique = "RenderScene";
//Centrar camara rotacional respecto a este mesh
GuiController.Instance.RotCamera.targetObject(mesh.BoundingBox);
time = 0;
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Malla default
string initialMeshFile = GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\CamionDeAgua\\" + "CamionDeAgua-TgcScene.xml";
//Modifiers
currentScene = null;
currentPath = null;
GuiController.Instance.Modifiers.addFile("Mesh", initialMeshFile, "-TgcScene.xml |*-TgcScene.xml");
GuiController.Instance.Modifiers.addButton("Reload", "Reload", new EventHandler(Reload_ButtonClick));
currentColor = Color.White;
GuiController.Instance.Modifiers.addColor("Color", currentColor);
GuiController.Instance.Modifiers.addBoolean("BoundingBox", "BoundingBox", false);
currentAlphaBlending = false;
GuiController.Instance.Modifiers.addBoolean("AlphaBlending", "AlphaBlending", currentAlphaBlending);
//UserVars
GuiController.Instance.UserVars.addVar("Name");
GuiController.Instance.UserVars.addVar("Meshes");
GuiController.Instance.UserVars.addVar("Textures");
GuiController.Instance.UserVars.addVar("Triangles");
GuiController.Instance.UserVars.addVar("Vertices");
GuiController.Instance.UserVars.addVar("SizeX");
GuiController.Instance.UserVars.addVar("SizeY");
GuiController.Instance.UserVars.addVar("SizeZ");
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Cargar escenario con información especial exportada de PortalRendering
TgcSceneLoader loader = new TgcSceneLoader();
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesDir + "PortalRendering\\EscenarioPortal\\EscenarioPortal-TgcScene.xml");
//Descactivar inicialmente a todos los modelos
scene.setMeshesEnabled(false);
//Camara en 1ra persona
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.MovementSpeed = 800f;
GuiController.Instance.FpsCamera.JumpSpeed = 600f;
GuiController.Instance.FpsCamera.setCamera(new Vector3(0, 0, 0), new Vector3(0, 0, 1));
//Modifiers
GuiController.Instance.Modifiers.addBoolean("portalRendering", "PortalRendering", true);
GuiController.Instance.Modifiers.addBoolean("WireFrame", "WireFrame", false);
GuiController.Instance.Modifiers.addBoolean("showPortals", "Show Portals", false);
//UserVars
GuiController.Instance.UserVars.addVar("MeshCount");
//Crear portales debug
scene.PortalRendering.createDebugPortals(Color.Purple);
}
public override void init()
{
time = 0f;
Device d3dDevice = GuiController.Instance.D3dDevice;
MyMediaDir = GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Media\\";
MyShaderDir = GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Shaders\\";
//Crear loader
TgcSceneLoader loader = new TgcSceneLoader();
// parallax oclussion
scene = loader.loadSceneFromFile(MyMediaDir +"Piso\\Piso-TgcScene.xml");
g_pBaseTexture = TextureLoader.FromFile(d3dDevice, MyMediaDir
+ "Piso\\Textures\\wood.bmp");
g_pHeightmap = TextureLoader.FromFile(d3dDevice, MyMediaDir
+ "Piso\\Textures\\four_NM_height.tga");
g_pBaseTexture2 = TextureLoader.FromFile(d3dDevice, MyMediaDir
+ "Piso\\Textures\\stones.bmp");
g_pHeightmap2 = TextureLoader.FromFile(d3dDevice, MyMediaDir
+ "Piso\\Textures\\stones_NM_height.tga");
g_pBaseTexture3 = TextureLoader.FromFile(d3dDevice, MyMediaDir
+ "Piso\\Textures\\rocks.jpg");
g_pHeightmap3 = TextureLoader.FromFile(d3dDevice, MyMediaDir
+ "Piso\\Textures\\rocks_NM_height.tga");
mesh = scene.Meshes[0];
int[] adj = new int[mesh.D3dMesh.NumberFaces * 3];
mesh.D3dMesh.GenerateAdjacency(0, adj);
mesh.D3dMesh.ComputeNormals(adj);
//Cargar Shader
string compilationErrors;
effect = Effect.FromFile(d3dDevice, MyShaderDir + "Parallax.fx", null, null, ShaderFlags.None, null, out compilationErrors);
if (effect == null)
{
throw new Exception("Error al cargar shader. Errores: " + compilationErrors);
}
GuiController.Instance.Modifiers.addVertex3f("LightDir", new Vector3(-1, -1, -1), new Vector3(1, 1, 1), new Vector3(0, -1, 0));
GuiController.Instance.Modifiers.addFloat("minSample", 1f, 10f, 10f);
GuiController.Instance.Modifiers.addFloat("maxSample", 11f, 50f, 50f);
GuiController.Instance.Modifiers.addFloat("HeightMapScale", 0.001f, 0.5f, 0.1f);
//Centrar camara rotacional respecto a este mesh
GuiController.Instance.RotCamera.targetObject(mesh.BoundingBox);
GuiController.Instance.RotCamera.CameraCenter = new Vector3(0, 0, 0);
GuiController.Instance.RotCamera.CameraDistance = 100;
GuiController.Instance.RotCamera.RotationSpeed = 1000f;
pom = false;
phong = true;
nro_textura = 0;
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//En este ejemplo no cargamos un solo modelo 3D sino una escena completa, compuesta por varios modelos.
//El framework posee varias escenas ya hechas en la carpeta TgcViewer\Examples\Media\MeshCreator\Scenes.
TgcSceneLoader loader = new TgcSceneLoader();
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Scenes\\Iglesia\\Iglesia-TgcScene.xml");
//Hacemos que la cámara esté centrada sobre la escena
GuiController.Instance.RotCamera.targetObject(scene.BoundingBox);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Cargar escenario
TgcSceneLoader loader = new TgcSceneLoader();
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Scenes\\Deposito\\Deposito-TgcScene.xml");
//Camara en 1ra persona
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.MovementSpeed = 400f;
GuiController.Instance.FpsCamera.JumpSpeed = 300f;
GuiController.Instance.FpsCamera.setCamera(new Vector3(-210.0958f, 114.911f, -109.2159f), new Vector3(-209.559f, 114.8029f, -108.3791f));
//Cargar Shader personalizado de MultiDiffuseLights
/*
* Cargar Shader personalizado de MultiDiffuseLights
* Este Shader solo soporta TgcMesh con RenderType DIFFUSE_MAP (que son las unicas utilizadas en este ejemplo)
* El shader toma 4 luces a la vez para iluminar un mesh.
* Pero como hacer 4 veces los calculos en el shader es costoso, de cada luz solo calcula el componente Diffuse.
*/
effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesMediaDir + "Shaders\\MultiDiffuseLights.fx");
//Crear 4 mesh para representar las 4 para la luces. Las ubicamos en distintas posiciones del escenario, cada una con un color distinto.
lightMeshes = new TgcBox[4];
origLightPos = new Vector3[lightMeshes.Length];
Color[] c = new Color[4] { Color.Red, Color.Blue, Color.Green, Color.Yellow };
for (int i = 0; i < lightMeshes.Length; i++)
{
Color co = c[i % c.Length];
lightMeshes[i] = TgcBox.fromSize(new Vector3(10, 10, 10), co);
origLightPos[i] = new Vector3(-40, 20 + i * 20, 400);
}
//Modifiers
GuiController.Instance.Modifiers.addBoolean("lightEnable", "lightEnable", true);
GuiController.Instance.Modifiers.addBoolean("lightMove", "lightMove", true);
GuiController.Instance.Modifiers.addFloat("lightIntensity", 0, 150, 38);
GuiController.Instance.Modifiers.addFloat("lightAttenuation", 0.1f, 2, 0.15f);
GuiController.Instance.Modifiers.addColor("mEmissive", Color.Black);
GuiController.Instance.Modifiers.addColor("mDiffuse", Color.White);
//Interpolador para mover las luces de un lado para el otro
interp = new InterpoladorVaiven();
interp.Min = -200f;
interp.Max = 200f;
interp.Speed = 100f;
interp.Current = 0f;
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
/* Cargar ecena que tiene un modelo configurado con AlphaBlending
* Los modelos fueron exportados en 3Ds MAX con el mapa "Opacity" cargado en el "Material Editor"
* Entonces el TgcSceneLoader automáticamente hace mesh.AlphaBlendEnable(true);
*/
TgcSceneLoader loader = new TgcSceneLoader();
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vegetacion\\Pino\\Pino-TgcScene.xml");
GuiController.Instance.RotCamera.targetObject(scene.BoundingBox);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
for (int i = 0; i < 100; i++)
{
TgcSceneLoader loader = new TgcSceneLoader();
TgcScene scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vegetacion\\Palmera\\Palmera-TgcScene.xml");
scene.disposeAll();
}
TgcSceneLoader loader1 = new TgcSceneLoader();
scene1 = loader1.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vegetacion\\Palmera\\Palmera-TgcScene.xml");
}
public override void init()
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Cargar escena
TgcSceneLoader loader = new TgcSceneLoader();
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Scenes\\Ciudad\\Ciudad-TgcScene.xml");
//Cargar mesh principal
mainMesh = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\Hummer\\Hummer-TgcScene.xml").Meshes[0];
//Movemos el mesh un poco para arriba. Porque sino choca con el piso todo el tiempo y no se puede mover.
mainMesh.move(0, 5, 0);
//Camera en 3ra persona
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.ThirdPersonCamera.setCamera(mainMesh.Position, 200, 300);
}
public override void init()
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//En este ejemplo primero cargamos una escena 3D entera.
TgcSceneLoader loader = new TgcSceneLoader();
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Scenes\\Ciudad\\Ciudad-TgcScene.xml");
//Luego cargamos otro modelo aparte que va a hacer el objeto que controlamos con el teclado
TgcScene scene2 = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\Hummer\\Hummer-TgcScene.xml");
//Solo nos interesa el primer modelo de esta escena (tiene solo uno)
mainMesh = scene2.Meshes[0];
//Vamos a utilizar la cámara en 3ra persona para que siga al objeto principal a medida que se mueve
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.ThirdPersonCamera.setCamera(mainMesh.Position, 200, 300);
}
public void export(List<TgcMesh> meshes, string name, string saveFolderPath)
{
TgcScene exportScene = new TgcScene(name, saveFolderPath);
List<TgcMesh> parents = new List<TgcMesh>();
foreach (TgcMesh m in meshes)
{
if (m.ParentInstance != null && !parents.Contains(m.ParentInstance))
{
parents.Add(m.ParentInstance);
exportScene.Meshes.Add(m.ParentInstance);
}
exportScene.Meshes.Add(m);
}
TgcSceneExporter exporter = new TgcSceneExporter();
exporter.exportSceneToXml(exportScene, saveFolderPath);
}
public Water()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
TgcSceneLoader loader = new TgcSceneLoader();
loader.MeshFactory = new MeshShaderFactory();
scene = loader.loadSceneFromFile(Path.WaterScene);
mesh = (MeshShader)scene.Meshes[0];
mesh.Scale = new Vector3(350f, 0.1f, 2200f);
mesh.Position = new Vector3(0f, -20f, 0f);
string compilationErrors;
effect = Effect.FromFile(d3dDevice, Path.WaterShader, null, null, ShaderFlags.None, null, out compilationErrors);
mesh.effect = effect;
if (effect == null) GuiController.Instance.Logger.log(compilationErrors);
effect.SetValue("textureOffset", 0.1f);
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
MyMediaDir = GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Media\\";
MyShaderDir = GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Shaders\\";
//Crear loader
TgcSceneLoader loader = new TgcSceneLoader();
//Cargar mesh
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir
+ "ModelosTgc\\Teapot\\Teapot-TgcScene.xml");
mesh = scene.Meshes[0];
mesh.Scale = new Vector3(1f, 1f, 1f);
mesh.Position = new Vector3(-100f, -5f, 0f);
// Arreglo las normales
int [] adj = new int[mesh.D3dMesh.NumberFaces*3];
mesh.D3dMesh.GenerateAdjacency(0,adj);
mesh.D3dMesh.ComputeNormals(adj);
//Cargar Shader personalizado
effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Shaders\\ToonShading.fx");
// le asigno el efecto a la malla
mesh.Effect = effect;
mesh.Technique = "DefaultTechnique";
// Creo las instancias de malla
instances = new List<TgcMesh>();
for (int i = -5; i < 5; i++)
for (int j = -5; j < 5; j++)
{
TgcMesh instance = mesh.createMeshInstance(mesh.Name + i);
instance.move(i * 50, (i + j) * 5, j * 50);
instances.Add(instance);
}
GuiController.Instance.Modifiers.addVertex3f("LightPosition", new Vector3(-100, -100, -100), new Vector3(100, 100, 100), new Vector3(0, 40, 0));
GuiController.Instance.Modifiers.addFloat("Ambient", 0, 1, 0.5f);
GuiController.Instance.Modifiers.addFloat("Diffuse", 0, 1, 0.6f);
GuiController.Instance.Modifiers.addFloat("Specular", 0, 1, 0.5f);
GuiController.Instance.Modifiers.addFloat("SpecularPower", 1, 100, 16);
GuiController.Instance.RotCamera.setCamera(new Vector3(20, 20, 0), 200);
GuiController.Instance.RotCamera.CameraDistance = 300;
GuiController.Instance.RotCamera.RotationSpeed = 1.5f;
// Creo un depthbuffer sin multisampling, para que sea compatible con el render to texture
// Nota:
// El render to Texture no es compatible con el multisampling en dx9
// Por otra parte la mayor parte de las placas de ultima generacion no soportan
// mutisampling para texturas de punto flotante con lo cual
// hay que suponer con generalidad que no se puede usar multisampling y render to texture
// Para resolverlo hay que crear un depth buffer que no tenga multisampling,
// (de lo contrario falla el zbuffer y se producen artifacts tipicos de que no tiene zbuffer)
// Si uno quisiera usar el multisampling, la tecnica habitual es usar un RenderTarget
// en lugar de una textura.
// Por ejemplo en c++:
//
// Render Target formato color buffer con multisampling
//
// g_pd3dDevice->CreateRenderTarget(Ancho,Alto,
// D3DFMT_A8R8G8B8, D3DMULTISAMPLE_2_SAMPLES, 0,
// FALSE, &g_pRenderTarget, NULL);
//
// Luego, ese RenderTarget NO ES una textura, y nosotros necesitamos acceder a esos
// pixeles, ahi lo que se hace es COPIAR del rendertartet a una textura,
// para poder trabajar con esos datos en el contexto del Pixel shader:
//
// Eso se hace con la funcion StretchRect:
// copia de rendertarget ---> sceneSurface (que es la superficie asociada a una textura)
// g_pd3dDevice->StretchRect(g_pRenderTarget, NULL, g_pSceneSurface, NULL, D3DTEXF_NONE);
//
// Esta tecnica se llama downsampling
// Y tiene el costo adicional de la transferencia de memoria entre el rendertarget y la
// textura, pero que no traspasa los limites de la GPU. (es decir es muy performante)
// no es lo mismo que lockear una textura para acceder desde la CPU, que tiene el problema
// de transferencia via AGP.
g_pDepthStencil = d3dDevice.CreateDepthStencilSurface(d3dDevice.PresentationParameters.BackBufferWidth,
d3dDevice.PresentationParameters.BackBufferHeight,
DepthFormat.D24S8,
MultiSampleType.None,
0,
true);
// inicializo el render target
g_pRenderTarget = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth
, d3dDevice.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget,
Format.X8R8G8B8, Pool.Default);
effect.SetValue("g_RenderTarget", g_pRenderTarget);
// inicializo el mapa de normales
g_pNormals = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth
, d3dDevice.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget,
Format.A16B16G16R16F, Pool.Default);
effect.SetValue("g_Normals", g_pNormals);
// Resolucion de pantalla
effect.SetValue("screen_dx", d3dDevice.PresentationParameters.BackBufferWidth);
effect.SetValue("screen_dy", d3dDevice.PresentationParameters.BackBufferHeight);
//Se crean 2 triangulos con las dimensiones de la pantalla con sus posiciones ya transformadas
// x = -1 es el extremo izquiedo de la pantalla, x=1 es el extremo derecho
// Lo mismo para la Y con arriba y abajo
// la Z en 1 simpre
CustomVertex.PositionTextured[] vertices = new CustomVertex.PositionTextured[]
{
new CustomVertex.PositionTextured( -1, 1, 1, 0,0),
new CustomVertex.PositionTextured(1, 1, 1, 1,0),
new CustomVertex.PositionTextured(-1, -1, 1, 0,1),
new CustomVertex.PositionTextured(1,-1, 1, 1,1)
};
//vertex buffer de los triangulos
g_pVBV3D = new VertexBuffer(typeof(CustomVertex.PositionTextured),
4, d3dDevice, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
g_pVBV3D.SetData(vertices, 0, LockFlags.None);
efecto_blur = false;
}
public override void init()
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Cargar escenario específico para este ejemplo
TgcSceneLoader loader = new TgcSceneLoader();
escenario = loader.loadSceneFromFile(GuiController.Instance.ExamplesDir + "\\Collision\\SphereCollision\\PatioDeJuegos\\PatioDeJuegos-TgcScene.xml");
//Cargar personaje con animaciones
TgcSkeletalLoader skeletalLoader = new TgcSkeletalLoader();
personaje = skeletalLoader.loadMeshAndAnimationsFromFile(
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\Robot\\" + "Robot-TgcSkeletalMesh.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\Robot\\",
new string[] {
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\Robot\\" + "Caminando-TgcSkeletalAnim.xml",
GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\Robot\\" + "Parado-TgcSkeletalAnim.xml",
});
//Le cambiamos la textura para diferenciarlo un poco
personaje.changeDiffuseMaps(new TgcTexture[] { TgcTexture.createTexture(d3dDevice, GuiController.Instance.ExamplesMediaDir + "SkeletalAnimations\\Robot\\Textures\\" + "uvwGreen.jpg") });
//Configurar animacion inicial
personaje.playAnimation("Parado", true);
//Escalarlo porque es muy grande
personaje.Position = new Vector3(0,500,-100);
//Rotarlo 180° porque esta mirando para el otro lado
personaje.rotateY(Geometry.DegreeToRadian(180f));
//BoundingSphere que va a usar el personaje
personaje.AutoUpdateBoundingBox = false;
characterSphere = new TgcBoundingSphere(personaje.BoundingBox.calculateBoxCenter(), personaje.BoundingBox.calculateBoxRadius());
//Almacenar volumenes de colision del escenario
objetosColisionables.Clear();
foreach (TgcMesh mesh in escenario.Meshes)
{
objetosColisionables.Add(mesh.BoundingBox);
}
//Crear linea para mostrar la direccion del movimiento del personaje
directionArrow = new TgcArrow();
directionArrow.BodyColor = Color.Red;
directionArrow.HeadColor = Color.Green;
directionArrow.Thickness = 1;
directionArrow.HeadSize = new Vector2(10, 20);
//Crear manejador de colisiones
collisionManager = new SphereCollisionManager();
collisionManager.GravityEnabled = true;
//Configurar camara en Tercer Persona
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.ThirdPersonCamera.setCamera(personaje.Position, 100, -400);
GuiController.Instance.ThirdPersonCamera.TargetDisplacement = new Vector3(0, 100, 0);
//Crear SkyBox
skyBox = new TgcSkyBox();
skyBox.Center = new Vector3(0, 0, 0);
skyBox.Size = new Vector3(10000, 10000, 10000);
string texturesPath = GuiController.Instance.ExamplesMediaDir + "Texturas\\Quake\\SkyBox3\\";
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Up, texturesPath + "Up.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Down, texturesPath + "Down.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Left, texturesPath + "Left.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Right, texturesPath + "Right.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Front, texturesPath + "Back.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Back, texturesPath + "Front.jpg");
skyBox.updateValues();
//Modifier para ver BoundingBox
GuiController.Instance.Modifiers.addBoolean("showBoundingBox", "Bouding Box", true);
//Modifiers para desplazamiento del personaje
GuiController.Instance.Modifiers.addFloat("VelocidadCaminar", 0, 100, 16);
GuiController.Instance.Modifiers.addFloat("VelocidadRotacion", 1f, 360f, 150f);
GuiController.Instance.Modifiers.addBoolean("HabilitarGravedad", "Habilitar Gravedad", true);
GuiController.Instance.Modifiers.addVertex3f("Gravedad", new Vector3(-50, -50, -50), new Vector3(50, 50, 50), new Vector3(0, -10, 0));
GuiController.Instance.Modifiers.addFloat("SlideFactor", 1f, 2f, 1.3f);
GuiController.Instance.UserVars.addVar("Movement");
}
/// <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)
{
TgcScene tgcScene = new TgcScene(sceneData.name, null);
//Cargar Texturas
TgcSceneLoaderMaterialAux[] materialsArray = new TgcSceneLoaderMaterialAux[sceneData.materialsData.Length];
for (int i = 0; i < sceneData.materialsData.Length; i++)
{
TgcMaterialData materialData = sceneData.materialsData[i];
string 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))
{
TgcSceneLoaderMaterialAux matAux = new TgcSceneLoaderMaterialAux();
materialsArray[i] = matAux;
matAux.subMaterials = new TgcSceneLoaderMaterialAux[materialData.subMaterials.Length];
for (int j = 0; j < materialData.subMaterials.Length; j++)
{
matAux.subMaterials[j] = createTextureAndMaterial(materialData.subMaterials[j], texturesPath);
}
}
}
//Cargar Meshes
for (int i = 0; i < sceneData.meshesData.Length; i++)
{
TgcMeshData 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
{
List <TgcBoundingBox> boundingBoxes = new List <TgcBoundingBox>();
foreach (TgcMesh 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)
{
TgcPortalRenderingLoader portalLoader = new TgcPortalRenderingLoader();
tgcScene.PortalRendering = portalLoader.loadFromData(tgcScene, sceneData.portalData);
}
return(tgcScene);
}
/// <summary>
/// Carga una malla estatica de formato TGC
/// </summary>
private void loadMesh(string path)
{
currentPath = path;
//Dispose de escena anterior
if (currentScene != null)
{
currentScene.disposeAll();
}
//Cargar escena con herramienta TgcSceneLoader
TgcSceneLoader loader = new TgcSceneLoader();
currentScene = loader.loadSceneFromFile(path);
//Ajustar camara en base al tamaño del objeto
GuiController.Instance.RotCamera.targetObject(currentScene.BoundingBox);
//Calcular cantidad de triangulos y texturas
int triangleCount = 0;
int verticesCount = 0;
int texturesCount = 0;
foreach (TgcMesh mesh in currentScene.Meshes)
{
triangleCount += mesh.NumberTriangles;
verticesCount += mesh.NumberVertices;
texturesCount += mesh.RenderType == TgcMesh.MeshRenderType.VERTEX_COLOR ? 0 : mesh.DiffuseMaps.Length;
}
//UserVars
GuiController.Instance.UserVars.setValue("Name", currentScene.SceneName);
GuiController.Instance.UserVars.setValue("Meshes", currentScene.Meshes.Count);
GuiController.Instance.UserVars.setValue("Textures", texturesCount);
GuiController.Instance.UserVars.setValue("Triangles", triangleCount);
GuiController.Instance.UserVars.setValue("Vertices", verticesCount);
Vector3 size = currentScene.BoundingBox.calculateSize();
GuiController.Instance.UserVars.setValue("SizeX", TgcParserUtils.printFloat(size.X));
GuiController.Instance.UserVars.setValue("SizeY", TgcParserUtils.printFloat(size.Y));
GuiController.Instance.UserVars.setValue("SizeZ", TgcParserUtils.printFloat(size.Z));
}
private void generarArboles(int cantidadArboles)
{
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vegetacion\\" + tipoArboles[0] + "-TgcScene.xml");
arbol = scene.Meshes[0];
for (int i = 0; i < cantidadArboles; i++)
{
TgcMesh instancia = arbol.createMeshInstance("arbol");
TgcBoundingCylinder instanciaCilindro = new TgcBoundingCylinder(this.divisionesPiso[i], 15, 100);
instancia.Scale = new Vector3(3f, 3f, 3f);
instancia.Position = this.divisionesPiso[i];
instancia.AlphaBlendEnable = true;
//Agrego efecto y tecnica
instancia.Effect = efecto;
instancia.Technique = "VientoArbol";
arboles.Add(instancia);
colisionables.Add(instanciaCilindro);
}
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
MyMediaDir = GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Media\\";
MyShaderDir = GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Shaders\\";
//Crear loader
TgcSceneLoader loader = new TgcSceneLoader();
// Cargo la escena del cornell box.
scene = loader.loadSceneFromFile(MyMediaDir + "cornell_box\\cornell_box-TgcScene.xml");
mesh = scene.Meshes[0];
//Cargar Shader personalizado
effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Shaders\\PhongShading.fx");
// Pasos standard:
// le asigno el efecto a la malla
mesh.Effect = effect;
mesh.Technique = "DefaultTechnique";
GuiController.Instance.Modifiers.addVertex3f("LightPosition", new Vector3(-100, -100, -100), new Vector3(100, 100, 100), new Vector3(0, 40, 0));
GuiController.Instance.Modifiers.addFloat("Ambient", 0, 1, 0.5f);
GuiController.Instance.Modifiers.addFloat("Diffuse", 0, 1, 0.6f);
GuiController.Instance.Modifiers.addFloat("Specular", 0, 1, 0.5f);
GuiController.Instance.Modifiers.addFloat("SpecularPower", 1, 100, 16);
//Crear caja para indicar ubicacion de la luz
lightBox = TgcBox.fromSize(new Vector3(5, 5, 5), Color.Yellow);
// Creo 3 viewport, para mostrar una comparativa entre los metodos de iluminacion
GuiController.Instance.RotCamera.setCamera(new Vector3(20, 20, 0), 200);
View1 = new Viewport();
View1.X = 0;
View1.Y = 0;
View1.Width = 400;
View1.Height = 250;
View1.MinZ = 0;
View1.MaxZ = 1;
View2 = new Viewport();
View2.X = 0;
View2.Y = 250;
View2.Width = 400;
View2.Height = 250;
View2.MinZ = 0;
View2.MaxZ = 1;
View3 = new Viewport();
View3.X = 400;
View3.Y = 0;
View3.Width = 400;
View3.Height = 250;
View3.MinZ = 0;
View3.MaxZ = 1;
ViewF = d3dDevice.Viewport;
// Creo la luz para el fixed pipeline
d3dDevice.Lights[0].Type = LightType.Point;
d3dDevice.Lights[0].Diffuse = Color.FromArgb(255, 255, 255, 255);
d3dDevice.Lights[0].Specular = Color.FromArgb(255, 255, 255, 255);
d3dDevice.Lights[0].Attenuation0 = 0.0f;
d3dDevice.Lights[0].Range = 50000.0f;
d3dDevice.Lights[0].Enabled = true;
}
/// <summary>
/// Método que se llama una sola vez, al principio cuando se ejecuta el ejemplo.
/// Escribir aquí todo el código de inicialización: cargar modelos, texturas, modifiers, uservars, etc.
/// Borrar todo lo que no haga falta
/// </summary>
public override void init()
{
EjemploAlumno.Instance = this;
//GuiController.Instance: acceso principal a todas las herramientas del Framework
//Device de DirectX para crear primitivas
Device d3dDevice = GuiController.Instance.D3dDevice;
//Carpeta de archivos Media del alumno
string alumnoMediaFolder = GuiController.Instance.AlumnoEjemplosMediaDir;
//Terreno
currentHeightmap = GuiController.Instance.AlumnoEjemplosMediaDir + "Heightmap3.jpg";
currentTexture = GuiController.Instance.AlumnoEjemplosMediaDir + "TerrainTexture3.jpg";
terrain = new TerrenoSimple();
terrain.loadHeightmap(currentHeightmap, currentScaleXZ, currentScaleY, new Vector3(0, -125, 0));
terrain.loadTexture(currentTexture);
//Agua
agua = new TerrenoSimple();
agua.loadHeightmap(GuiController.Instance.AlumnoEjemplosMediaDir + "18_vertex_texture_02.jpg", 50f, 0.5f, new Vector3(0, -125, 0));
agua.loadTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "4141-diffuse.jpg");
agua.AlphaBlendEnable = true;
//heightOlas = agua.heightOlas;
//Modifier
GuiController.Instance.Modifiers.addFloat("heightOlas", 10, 50, 40);
//Estado
EjemploAlumno.Instance.estado = EstadoDelJuego.SinEmpezar;
menu = new Menu();
// Crear SkyBox:
skyBox = new TgcSkyBox();
skyBox.Center = new Vector3(0, 0, 0);
skyBox.Size = new Vector3(12000, 12000, 12000);
skyboxSoleado(skyBox);
skyBoundingBox = new TgcBox();
skyBoundingBox.Size = skyBox.Size;
skyBoundingBox.Position = skyBox.Center;
skyBoundingBox.AlphaBlendEnable = true;
skyBoundingBox.updateValues();
lloviendo = false;
//Cargar meshes
TgcViewer.Utils.TgcSceneLoader.TgcSceneLoader loader = new TgcViewer.Utils.TgcSceneLoader.TgcSceneLoader();
TgcViewer.Utils.TgcSceneLoader.TgcScene scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\Canoa\\Canoa-TgcScene.xml");
meshShip = scene.Meshes[0];
meshShip.setColor(Color.Chocolate);
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Vehiculos\\Canoa\\Canoa-TgcScene.xml");
meshes.Add(meshShip);
meshShipContrincante = scene.Meshes[0];
meshShipContrincante.setColor(Color.BlueViolet);
meshes.Add(meshShipContrincante);
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Armas\\Canon\\Canon.max-TgcScene.xml");
meshCanion = scene.Meshes[0];
meshes.Add(meshCanion);
scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Armas\\Canon\\Canon.max-TgcScene.xml");
meshCanionContrincante = scene.Meshes[0];
meshes.Add(meshCanionContrincante);
//Shader
effect = TgcShaders.loadEffect(alumnoMediaFolder + "shader agua.fx");
agua.Effect = effect;
agua.Technique = "RenderScene";
time = 0;
agua.AlphaBlendEnable = true;
efectoSombra = TgcShaders.loadEffect(alumnoMediaFolder + "shader agua.fx");
//Creaciones
ship = new Ship(POS_SHIP, meshShip, new Canion(POS_SHIP, 5, meshCanion, true));
shipContrincante = new EnemyShip(ship, POS_CONTRINCANTE, meshShipContrincante, new Canion(POS_CONTRINCANTE, 5, meshCanionContrincante, false));
mainCamera = new MainCamera(ship);
//Crear caja para indicar ubicacion de la luz
lightMesh = TgcBox.fromSize(new Vector3(20, 20, 20), Color.Yellow);
}
/// <summary>
/// Graba una escena entera del tipo TgcScene a un archivo XML de tipo "-TgcScene.xml", que luego
/// puede ser cargado con el TgcSceneLoader
/// </summary>
/// <param name="scene">Escena a exportar</param>
/// <param name="saveFolderPath">Carpeta en la que se quiera guardar el XML</param>
/// <returns>Resultado de exportacion</returns>
public ExportResult exportSceneToXml(TgcScene scene, string saveFolderPath)
{
MeshExport[] meshesExport = exportSceneData(scene);
return saveSceneToXml(scene.SceneName, createSceneBoundingBox(meshesExport), meshesExport, saveFolderPath);
}
/// <summary>
/// Exporta los datos de todas los TgcMesh de una escena. Los exporta a un formato de objetos plano
/// </summary>
/// <param name="scene">Escena a exportar</param>
/// <returns>Datos de la mallas en objetos</returns>
public MeshExport[] exportSceneData(TgcScene scene)
{
MeshExport[] meshesExport = new MeshExport[scene.Meshes.Count];
for (int i = 0; i < scene.Meshes.Count; i++)
{
meshesExport[i] = exportMeshData(scene.Meshes[i], scene.Meshes);
}
return meshesExport;
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//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\\Escenario\\EscenarioLuces-TgcScene.xml";
string mediaPath = GuiController.Instance.ExamplesDir + "Lights\\Escenario\\";
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();
scene = loader.loadScene(sceneData, mediaPath);
//Camara en 1ra persona
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.MovementSpeed = 400f;
GuiController.Instance.FpsCamera.JumpSpeed = 300f;
GuiController.Instance.FpsCamera.setCamera(new Vector3(-20, 80, 450), new Vector3(0, 80, 1));
//Modifiers para variables de luz
GuiController.Instance.Modifiers.addBoolean("lightEnable", "lightEnable", true);
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);
//Modifiers para material
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);
}
/// <summary>
/// Cargar información de PortalRendering
/// </summary>
public TgcPortalRenderingManager loadFromData(TgcScene scene, TgcPortalRenderingData portalRenderingData)
{
TgcPortalRenderingManager manager = new TgcPortalRenderingManager(scene);
//Crear dictionary de nombres de los meshes
Dictionary<string, TgcMesh> meshDictionary = new Dictionary<string, TgcMesh>();
foreach (TgcMesh mesh in scene.Meshes)
{
meshDictionary.Add(mesh.Name, mesh);
}
//Cargar celdas
foreach (TgcPortalRenderingCellData cellData in portalRenderingData.cells)
{
//Crear cuerpo Convexo
TgcConvexPolyhedron convexPoly = new TgcConvexPolyhedron();
convexPoly.Planes = new Plane[cellData.facePlanes.Length / 4];
for (int i = 0; i < convexPoly.Planes.Length; i++)
{
convexPoly.Planes[i] = new Plane(
cellData.facePlanes[i * 4],
cellData.facePlanes[i * 4 + 1],
cellData.facePlanes[i * 4 + 2],
cellData.facePlanes[i * 4 + 3]
);
}
convexPoly.BoundingVertices = new Vector3[cellData.boundingVertices.Length / 3];
for (int i = 0; i < convexPoly.BoundingVertices.Length; i++)
{
convexPoly.BoundingVertices[i] = new Vector3(
cellData.boundingVertices[i * 3],
cellData.boundingVertices[i * 3 + 1],
cellData.boundingVertices[i * 3 + 2]
);
}
//Crear celda
TgcPortalRenderingCell cell = new TgcPortalRenderingCell(cellData.name, convexPoly);
manager.Cells.Add(cell);
//Cargar meshes en celda
for (int i = 0; i < cellData.meshes.Length; i++)
{
TgcMesh mesh = meshDictionary[cellData.meshes[i]];
cell.Meshes.Add(mesh);
}
}
//Cargar portales
foreach (TgcPortalRenderingPortalData portalData in portalRenderingData.portals)
{
//BoundingBox del portal
TgcBoundingBox boundingBox = new TgcBoundingBox(
new Vector3(portalData.pMin[0], portalData.pMin[1], portalData.pMin[2]),
new Vector3(portalData.pMax[0], portalData.pMax[1], portalData.pMax[2])
);
//Crear portal
TgcPortalRenderingPortal portal = new TgcPortalRenderingPortal(portalData.name, boundingBox);
manager.Portals.Add(portal);
//Cargar conexiones para celdas A y B
TgcPortalRenderingCell cellA = manager.Cells[portalData.cellA];
TgcPortalRenderingCell cellB = manager.Cells[portalData.cellB];
//Poligono del portal para la celda A
TgcConvexPolygon polygonA = new TgcConvexPolygon();
polygonA.BoundingVertices = new Vector3[portalData.boundingVerticesA.Length / 3];
for (int i = 0; i < polygonA.BoundingVertices.Length; i++)
{
polygonA.BoundingVertices[i] = new Vector3(
portalData.boundingVerticesA[i * 3],
portalData.boundingVerticesA[i * 3 + 1],
portalData.boundingVerticesA[i * 3 + 2]
);
}
//Plano del portal para la celda A
Plane planeA = TgcParserUtils.float4ArrayToPlane(portalData.planeA);
//Crear conexion A
TgcPortalRenderingConnection connectionA = new TgcPortalRenderingConnection(portal, cellB, polygonA, planeA);
cellA.Connections.Add(connectionA);
//Poligono del portal para la celda B
TgcConvexPolygon polygonB = new TgcConvexPolygon();
polygonB.BoundingVertices = new Vector3[portalData.boundingVerticesB.Length / 3];
for (int i = 0; i < polygonB.BoundingVertices.Length; i++)
{
polygonB.BoundingVertices[i] = new Vector3(
portalData.boundingVerticesB[i * 3],
portalData.boundingVerticesB[i * 3 + 1],
portalData.boundingVerticesB[i * 3 + 2]
);
}
//Plano del portal para la celda B
Plane planeB = TgcParserUtils.float4ArrayToPlane(portalData.planeB);
//Crear conexion B
TgcPortalRenderingConnection connectionB = new TgcPortalRenderingConnection(portal, cellA, polygonB, planeB);
cellB.Connections.Add(connectionB);
}
return manager;
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
MyMediaDir = GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Media\\";
MyShaderDir = GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Shaders\\";
//Crear loader
TgcSceneLoader loader = new TgcSceneLoader();
// ------------------------------------------------------------
//Cargar la escena
scene = loader.loadSceneFromFile(MyMediaDir
+ "shadowTest\\ShadowTest-TgcScene.xml");
scene2 = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir
+ "MeshCreator\\Meshes\\Vehiculos\\AvionCaza\\AvionCaza-TgcScene.xml");
avion = scene2.Meshes[0];
avion.Scale = new Vector3(0.1f, 0.1f, 0.1f);
avion.Position = new Vector3(100f, 100f, 0f);
avion.AutoTransformEnable = false;
dir_avion = new Vector3(0, 0, 1);
GuiController.Instance.RotCamera.CameraDistance = 600;
GuiController.Instance.RotCamera.RotationSpeed = 1.5f;
//Cargar Shader personalizado
effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesDir + "Shaders\\WorkshopShaders\\Shaders\\ShadowMap.fx");
// le asigno el efecto a las mallas
foreach (TgcMesh T in scene.Meshes)
{
T.Scale = new Vector3(1f, 1f, 1f);
T.Effect = effect;
}
avion.Effect = effect;
//--------------------------------------------------------------------------------------
// Creo el shadowmap.
// Format.R32F
// Format.X8R8G8B8
g_pShadowMap = new Texture(d3dDevice, SHADOWMAP_SIZE, SHADOWMAP_SIZE,
1, Usage.RenderTarget, Format.R32F,
Pool.Default);
// tengo que crear un stencilbuffer para el shadowmap manualmente
// para asegurarme que tenga la el mismo tamaño que el shadowmap, y que no tenga
// multisample, etc etc.
g_pDSShadow = d3dDevice.CreateDepthStencilSurface(SHADOWMAP_SIZE,
SHADOWMAP_SIZE,
DepthFormat.D24S8,
MultiSampleType.None,
0,
true);
// por ultimo necesito una matriz de proyeccion para el shadowmap, ya
// que voy a dibujar desde el pto de vista de la luz.
// El angulo tiene que ser mayor a 45 para que la sombra no falle en los extremos del cono de luz
// de hecho, un valor mayor a 90 todavia es mejor, porque hasta con 90 grados es muy dificil
// lograr que los objetos del borde generen sombras
Control panel3d = GuiController.Instance.Panel3d;
float aspectRatio = (float)panel3d.Width / (float)panel3d.Height;
g_mShadowProj = Matrix.PerspectiveFovLH(Geometry.DegreeToRadian(80),
aspectRatio, 50, 5000);
d3dDevice.Transform.Projection =
Matrix.PerspectiveFovLH(Geometry.DegreeToRadian(45.0f),
aspectRatio, near_plane, far_plane);
arrow = new TgcArrow();
arrow.Thickness = 1f;
arrow.HeadSize = new Vector2(2f, 2f);
arrow.BodyColor = Color.Blue;
GuiController.Instance.RotCamera.targetObject(scene.Meshes[0].BoundingBox);
float K = 300;
GuiController.Instance.Modifiers.addVertex3f("LightLookFrom", new Vector3(-K, -K, -K), new Vector3(K, K, K), new Vector3(80, 120, 0));
GuiController.Instance.Modifiers.addVertex3f("LightLookAt", new Vector3(-K, -K, -K), new Vector3(K, K, K), new Vector3(0, 0, 0));
}
/// <summary>
/// Guardar la escena
/// </summary>
private void exportScene(bool askConfirmation, string path)
{
FileInfo fInfo = null;
if (askConfirmation)
{
if (exportSceneSaveDialog.ShowDialog() == DialogResult.OK)
{
fInfo = new FileInfo(exportSceneSaveDialog.FileName);
lastSavePath = exportSceneSaveDialog.FileName;
}
}
else
{
fInfo = new FileInfo(path);
exportSceneSaveDialog.FileName = path;
}
//Obtener directorio y nombre
if (fInfo == null)
return;
string sceneName = fInfo.Name.Split('.')[0];
sceneName = sceneName.Replace("-TgcScene", "");
string saveDir = fInfo.DirectoryName;
//Intentar guardar
try
{
//Convertir todos los objetos del escenario a un TgcMesh y agregarlos a la escena a exportar
TgcScene exportScene = new TgcScene(sceneName, saveDir);
foreach (EditorPrimitive p in meshes)
{
TgcMesh m = p.createMeshToExport();
exportScene.Meshes.Add(m);
}
//Exportar escena
TgcSceneExporter exporter = new TgcSceneExporter();
TgcSceneExporter.ExportResult result;
if (checkBoxAttachExport.Checked)
{
result = exporter.exportAndAppendSceneToXml(exportScene, saveDir);
}
else
{
result = exporter.exportSceneToXml(exportScene, saveDir);
}
//Hacer dispose de los objetos clonados para exportar
exportScene.disposeAll();
exportScene = null;
//Mostrar resultado
if (result.result)
{
if (result.secondaryErrors)
{
MessageBox.Show(this, "La escena se exportó OK pero hubo errores secundarios. " + result.listErrors(), "Export Scene", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show(this, "Scene exported OK.", "Export Scene", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
else
{
MessageBox.Show(this, "Ocurrieron errores al intentar exportar la escena. " + result.listErrors(),
"Export Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
catch (Exception ex)
{
MessageBox.Show(this, "Hubo un error al intenar exportar la escena. Puede ocurrir que esté intentando reemplazar el mismo archivo de escena que tiene abierto ahora. Los archivos de Textura por ejemplo no pueden ser reemplazados si se están utilizando dentro del editor. En ese caso debera guardar en uno nuevo. "
+ "Error: " + ex.Message + " - " + ex.InnerException.Message,
"Export Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Exporta los datos de todas los TgcMesh de una escena. Los exporta a un formato de objetos plano.
/// Unifica todas las Mallas de la escena en una sola, adaptando sus coordendas de textura y Materials.
/// Actualmente no se puede hacer con Mallas que tengan LightMaps.
/// </summary>
/// <param name="scene">Escena a unificar y exportar</param>
/// <returns>Datos de la escena unificada y exportada</returns>
public MeshExport exportAndAppendSceneData(TgcScene scene)
{
MeshExport[] meshesExport = exportSceneData(scene);
return appendAllMeshes(scene.SceneName, meshesExport);
}
/// <summary>
/// Exporta todos los cuartos y paredes a un xml de TgcScene
/// </summary>
private void exportScene(string saveDir, string sceneName)
{
TgcScene scene = new TgcScene(sceneName, saveDir);
foreach (RoomsEditorRoom room in Rooms)
{
foreach (RoomsEditorWall wall in room.Walls)
{
int wallSegId = 0;
foreach (TgcPlaneWall wall3d in wall.WallSegments)
{
scene.Meshes.Add(wall3d.toMesh(room.Name + "-" + wall.Name + "-" + wallSegId));
wallSegId++;
}
}
}
TgcSceneExporter exporter = new TgcSceneExporter();
exporter.exportSceneToXml(scene, saveDir);
MessageBox.Show(this, "Scene export OK", "Export Scene", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
/// <summary>
/// Graba una escena entera del tipo TgcScene a un archivo XML de tipo "-TgcScene.xml", que luego
/// puede ser cargado con el TgcSceneLoader
/// Antes de generar el XML, unifica todas las mallas en una sola, adaptando sus coordendas de textura y Materials.
/// Actualmente no se puede hacer con Mallas que tengan LightMaps.
/// </summary>
/// <param name="scene">Escena a exportar</param>
/// <param name="saveFolderPath">Carpeta en la que se quiera guardar el XML</param>
/// <returns>Resultado de exportacion</returns>
public ExportResult exportAndAppendSceneToXml(TgcScene scene, string saveFolderPath)
{
MeshExport meshExportFinal = exportAndAppendSceneData(scene);
MeshExport[] meshesExport = new MeshExport[] { meshExportFinal };
return saveSceneToXml(scene.SceneName, createSceneBoundingBox(meshesExport), meshesExport, saveFolderPath);
}