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