public override void Init()
{
var d3dDevice = D3DDevice.Instance.Device;
#region configurarEfecto
Texture alphaMap = TextureLoader.FromFile(d3dDevice, GameModel.mediaDir + "texturas\\terrain\\Heightmap3_1.jpg");
efecto = TgcShaders.loadEffect(GameModel.shadersDir + "shaderTierra.fx");
efecto.SetValue("alphaMap", alphaMap);
Texture mainText = TextureLoader.FromFile(d3dDevice, GameModel.mediaDir + "texturas\\terrain\\terreno.jpg");
efecto.SetValue("mainText", mainText);
#endregion
#region configurarObjeto
terrain.loadTexture(GameModel.mediaDir + "texturas\\terrain\\TerrainTexture1.jpg");
terrain.loadHeightmap(GameModel.mediaDir + "texturas\\terrain\\Heightmap3.jpg", 255f, 1.6f, new TGCVector3(0, -100, 0));
terrain.Effect = efecto;
terrain.Technique = "RenderScene";
tecnica = "RenderScene";
objetos.Add(terrain);
#endregion
PostProcess.agregarPostProcessObject(this);
}
public override void Init()
{
var d3dDevice = D3DDevice.Instance.Device;
efecto = TgcShaders.loadEffect(GameModel.shadersDir + "shaderPlanta.fx");
#region configurarObjetos
helicoptero = new TgcSceneLoader().loadSceneFromFile(GameModel.mediaDir + "modelos\\heliX-TgcScene.xml").Meshes[0];
helicoptero.Scale = new TGCVector3(10.5f, 10.5f, 10.5f);
helicoptero.Position = new TGCVector3(5000f, 200f, 500f);
helicoptero.RotateY(90);
helicoptero.Effect = efecto;
helicoptero.Technique = "RenderScene";
objetos.Add(helicoptero);
helice = new TgcSceneLoader().loadSceneFromFile(GameModel.mediaDir + "modelos\\heliceCero-TgcScene.xml").Meshes[0];
helice.Scale = new TGCVector3(10.5f, 10.5f, 10.5f);
helice.Position = new TGCVector3(5000f, 200f, 420f);
helice.RotateY(90);
helice.Effect = efecto;
helice.Technique = "RenderScene";
objetos.Add(helice);
#endregion
}
public MenuItem(TGCVector3 posicion, string caption)
{
var d3dDevice = D3DDevice.Instance.Device;
#region configurarEfecto
efecto = TgcShaders.loadEffect(GameModel.shadersDir + "shaderPlanta.fx");
#endregion
#region configurarMesh
mesh = new TgcSceneLoader().loadSceneFromFile(GameModel.mediaDir + "modelos\\Tag-TgcScene.xml").Meshes[0];
mesh.Scale = new TGCVector3(200.5f, 75.5f, 85.5f);
mesh.Position = posicion;
mesh.Effect = efecto;
mesh.Technique = "RenderScene";
mesh.BoundingBox.setRenderColor(Color.Red);
mesh.AutoTransform = true;
#endregion
#region texto
//Crear texto 2, especificando color, alineacion, posicion, tamano y fuente.
texto.Text = caption;
texto.Color = Color.ForestGreen;
texto.Align = TgcText2D.TextAlign.LEFT;
texto.Position = new Point((int)posicion.X + 300, (int)posicion.Y - 200);
texto.Size = new Size(800, 20);
texto.changeFont(new System.Drawing.Font("Console", 45, FontStyle.Bold | FontStyle.Italic));
#endregion
}
public Zombie(TGCVector3 posicion, GameLogic logica)
{
body = FactoryBody.crearBodyZombie(new TGCVector3(posicion.X, posicion.Y + 350, posicion.Z));
callback = new CollisionCallbackZombie(logica, this);
#region configurarEfecto
var d3dDevice = D3DDevice.Instance.Device;
efecto = TgcShaders.loadEffect(GameModel.shadersDir + "shaderPlanta.fx");
//Texture bumpMap = TextureLoader.FromFile(d3dDevice, GameModel.mediaDir + "texturas\\terrain\\NormalMapNieve2.jpg");
//efecto.SetValue("NormalMap", bumpMap);
#endregion
#region configurarObjeto
zombie = new TgcSceneLoader().loadSceneFromFile(GameModel.mediaDir + "modelos\\Zombie7-TgcScene.xml").Meshes[0];
zombie.Scale = new TGCVector3(55.5f, 55.5f, 55.5f);
zombie.Position = posicion;
zombie.Effect = efecto;
zombie.Technique = "RenderScene";
objetos.Add(zombie);
globo = new TgcSceneLoader().loadSceneFromFile(GameModel.mediaDir + "modelos\\GLOBO-TgcScene.xml").Meshes[0];
globo.Scale = new TGCVector3(40.5f, 40.5f, 40.5f);
globo.Position = posicion;
globo.Effect = efecto;
globo.Technique = "RenderZombie";
objetos.Add(globo);
#endregion
PostProcess.agregarPostProcessObject(this);
}
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 void Init(TgcD3dInput input)
{
gameObjects.ForEach(g => g.Init());
#region configurarEfecto
var d3dDevice = D3DDevice.Instance.Device;
efecto = TgcShaders.loadEffect(GameModel.shadersDir + "shaderPlanta.fx");
#endregion
#region configurarObjeto
zombie = new TgcSceneLoader().loadSceneFromFile(GameModel.mediaDir + "modelos\\Zombie7-TgcScene.xml").Meshes[0];
zombie.Scale = new TGCVector3(55.5f, 55.5f, 55.5f);
zombie.Position = new TGCVector3(0, 360, 0);
zombie.Effect = efecto;
zombie.Technique = "RenderScene";
globo = new TgcSceneLoader().loadSceneFromFile(GameModel.mediaDir + "modelos\\GLOBO-TgcScene.xml").Meshes[0];
globo.Scale = new TGCVector3(40.5f, 40.5f, 40.5f);
globo.Position = new TGCVector3(0, 760, 0);;
globo.Effect = efecto;
globo.Technique = "RenderZombie";
#endregion
}
public void Init(TgcD3dInput Input)
{
crearTableroPicking(5, 9);
pickingRay = new TgcPickingRay(Input);
//Crear caja para marcar en que lugar hubo colision
collisionPointMesh = TGCBox.fromSize(new TGCVector3(3, 3, 3), Color.Red);
collisionPointMesh.AutoTransform = true;
selected = false;
#region configurarEfecto
efecto = TgcShaders.loadEffect(GameModel.shadersDir + "shaderPlanta.fx");
#endregion
#region contenedor
contenedor = new TgcSceneLoader().loadSceneFromFile(GameModel.mediaDir + "modelos\\contenedor-TgcScene.xml").Meshes[0];
contenedor.Scale = new TGCVector3(45.5f, 45.5f, 45.5f);
contenedor.Position = new TGCVector3(-2000f, 400f, -800f);
contenedor.Effect = efecto;
contenedor.Technique = "RenderSceneProgresivo";
objetos.Add(contenedor);
//glowObjects.Add(contenedor);
#endregion
//este body seria del tablero o isla principal
body = FactoryBody.crearBodyIsla();
callback = new CollisionCallbackIsla(logica);
logica.addBulletObject(this);
PostProcess.agregarPostProcessObject(this);
}
public override void Init()
{
var d3dDevice = D3DDevice.Instance.Device;
efecto = TgcShaders.loadEffect(GameModel.shadersDir + "shaderCielo.fx");
tecnica = "RenderScene";
#region configurarObjeto
skybox.Center = TGCVector3.Empty;
skybox.Size = new TGCVector3(50000, 10000, 50000);
var texturesPath = GameModel.mediaDir + "texturas\\skybox\\";
//Configurar las texturas para cada una de las 6 caras
skybox.setFaceTexture(SkyboxShader.SkyFaces.Up, texturesPath + "up1.jpg");
skybox.setFaceTexture(SkyboxShader.SkyFaces.Down, texturesPath + "down1.jpg");
skybox.setFaceTexture(SkyboxShader.SkyFaces.Left, texturesPath + "left1.jpg");
skybox.setFaceTexture(SkyboxShader.SkyFaces.Right, texturesPath + "rigth1.jpg");
skybox.setFaceTexture(SkyboxShader.SkyFaces.Front, texturesPath + "front1.jpg");
skybox.setFaceTexture(SkyboxShader.SkyFaces.Back, texturesPath + "back1.jpg");
skybox.SkyEpsilon = 25f;
skybox.Init();
objetos.Add(skybox);
#endregion
}
public ReflejoLuzEnAuto(TgcMesh autoMesh)
{
meshDeAuto = autoMesh;
effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesDir + "Media\\Shaders\\BumpMapping.fx");
ConfigReflection();
isConfigInitialize = true;
}
public override void Init()
{
//Cargar shader de este ejemplo
effect = TgcShaders.loadEffect(ShadersDir + "EjemploGetZBuffer.fx");
//Cargamos un escenario
var loader = new TgcSceneLoader();
var scene = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Scenes\\Deposito\\Deposito-TgcScene.xml");
meshes = scene.Meshes;
foreach (var mesh in meshes)
{
mesh.Effect = effect;
}
//Crear textura para almacenar el zBuffer. Es una textura que se usa como RenderTarget y que tiene un formato de 1 solo float de 32 bits.
//En cada pixel no vamos a guardar un color sino el valor de Z de la escena
//La creamos con un solo nivel de mipmap (el original)
zBufferTexture = new Texture(D3DDevice.Instance.Device, D3DDevice.Instance.Device.Viewport.Width,
D3DDevice.Instance.Device.Viewport.Height, 1,
Usage.RenderTarget, Format.R32F, Pool.Default);
//Camara en 1ra persona
Camara = new TgcFpsCamera(new Vector3(-20, 80, 450), 400f, 300f);
}
private void cargarShaders()
{
TecnicaOriginal = this.getMesh().Technique;
efectoOriginal = this.getMesh().Effect;
efectoShaderChoque = TgcShaders.loadEffect(this.env.ShadersDir + "EfectoMetal_ConChoque.fx");
this.getMesh().Technique = "RenderScene";
}
//TGCSphere vida; //si uso sphere funciona, con mesh no
public Vida( )
{
body = FactoryBody.crearBodyEsfericoEstatico(new TGCVector3(1300f, 360f, 1500f), radio);
#region configurarEfecto
efecto = TgcShaders.loadEffect(GameModel.shadersDir + "shaderPlanta.fx");
#endregion
#region configurarObjeto
vida = new TgcSceneLoader().loadSceneFromFile(GameModel.mediaDir + "modelos\\vida-TgcScene.xml").Meshes[0];
vida.Scale = new TGCVector3(20.5f, 10.5f, 20.5f);
vida.Effect = efecto;
vida.Technique = "RenderScene";
vida.RotateY(90);
//vida.Transform = new TGCMatrix(body.InterpolationWorldTransform);
//vida.UpdateMeshTransform();
//var texture = TgcTexture.createTexture(D3DDevice.Instance.Device, GameModel.mediaDir + "texturas\\terrain\\NormalMapMar.png");
//vida = new TGCSphere(1, texture.Clone(), TGCVector3.Empty);
////Tgc no crea el vertex buffer hasta invocar a update values.
//vida.updateValues();
objetos.Add(vida);
//glowObjects.Add(vida);
#endregion
}
public override void Init()
{
//Crear loader
var loader = new TgcSceneLoader();
//Cargar los mesh:
scene =
loader.loadSceneFromFile(MediaDir +
"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(ShadersDir + "WorkshopShaders\\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
Camara = new TgcRotationalCamera(mesh.BoundingBox.calculateBoxCenter(),
mesh.BoundingBox.calculateBoxRadius() * 5, Input);
time = 0;
}
public static void Cargar()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
// Cargo el shader que tiene los efectos de postprocesado
Shader = TgcShaders.loadEffect(GuiController.Instance.AlumnoEjemplosMediaDir + "RenderGroup\\shaders\\postProcess.fx");
// Creo el quad que va a ocupar toda la pantalla
CustomVertex.PositionTextured[] screenQuadVertices = 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)
};
ScreenQuad = new VertexBuffer(typeof(CustomVertex.PositionTextured),
4, GuiController.Instance.D3dDevice, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
ScreenQuad.SetData(screenQuadVertices, 0, LockFlags.None);
// Creamos un render targer sobre el cual se va a dibujar la pantalla
RenderTargetPostprocesado = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth
, d3dDevice.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget,
Format.X8R8G8B8, Pool.Default);
#region VALORES DE INTERPOLACION
intVaivenOscurecer = new InterpoladorVaiven();
intVaivenOscurecer.Min = 1;
intVaivenOscurecer.Max = 15;
intVaivenOscurecer.Speed = 40f;
intVaivenOscurecer.reset();
#endregion
}
public override void Init()
{
//Color de fondo
//GuiController.Instance.BackgroundColor = Color.DarkGray;
//Camara en 1ra persona
//GuiController.Instance.FpsCamera.Enable = true;
//GuiController.Instance.FpsCamera.MovementSpeed = 100f;
//GuiController.Instance.FpsCamera.JumpSpeed = 50f;
//GuiController.Instance.FpsCamera.setCamera(new Vector3(40, 30, 35), new Vector3(0, 0, 0));
this.effect = TgcShaders.loadEffect(this.pathRecursos + "Shaders\\ParcialPixelShader.fx");
//Piso
this.boxFloor = TgcBox.fromSize(new Vector3(0, 0, 0), new Vector3(30, 0, 30), Color.DarkSeaGreen);
this.boxFloor.Effect = this.effect;
//Pared
this.boxWall = TgcBox.fromSize(new Vector3(0, 10, -15), new Vector3(30, 20, 0), Color.Red);
this.boxWall.Effect = this.effect;
//Figura
this.boxFigure = TgcBox.fromSize(new Vector3(0, 5, 0), new Vector3(10, 10, 5), Color.SteelBlue);
this.boxFigure.Effect = this.effect;
//Luz
this.boxLuz = TgcBox.fromSize(new Vector3(0, 20, 20), new Vector3(2, 2, 2), Color.LightYellow);
this.CrearTetera();
this.CrearBuggy();
}
protected void InitializeShadersAndEffects()
{
// Toon Shader
toonFX = TgcShaders.loadEffect(Game.Default.ShadersDirectory + "ToonShading.fx");
// Explosion Shader
explosionFX = TgcShaders.loadEffect(Game.Default.ShadersDirectory + "Explosion.fx");
}
public void CreateMesh(TgcMesh mesh)
{
this.mesh = mesh;
this.mesh.AutoTransform = false;
this.Transform();
this.mesh.Effect = TgcShaders.loadEffect(GlobalConcepts.GetInstance().GetShadersDir() + "Portal.fx");
this.mesh.Technique = "Portal";
}
private void cargarShaders()
{
efectoOlas = TgcShaders.loadEffect(GuiController.Instance.AlumnoEjemplosMediaDir + "RenderGroup\\shaders\\shaderOlas.fx");
terrain.Effect = efectoOlas;
terrain.Technique = "RenderScene";
efectoCascada = TgcShaders.loadEffect(GuiController.Instance.AlumnoEjemplosMediaDir + "RenderGroup\\shaders\\shaderCascada.fx");
terrain2.Effect = efectoCascada;
terrain2.Technique = "RenderScene";
}
public override void Init()
{
//Se crean 2 triangulos (o Quad) 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[] screenQuadVertices =
{
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
screenQuadVB = new VertexBuffer(typeof(CustomVertex.PositionTextured), 4, D3DDevice.Instance.Device, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
screenQuadVB.SetData(screenQuadVertices, 0, LockFlags.None);
//Creamos un Render Targer sobre el cual se va a dibujar la pantalla
renderTarget2D = new Texture(D3DDevice.Instance.Device, D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth,
D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget, Format.X8R8G8B8, Pool.Default);
//Creamos un DepthStencil que debe ser compatible con nuestra definicion de renderTarget2D.
depthStencil = D3DDevice.Instance.Device.CreateDepthStencilSurface(D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth,
D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight, DepthFormat.D24S8, MultiSampleType.None, 0, true);
depthStencilOld = D3DDevice.Instance.Device.DepthStencilSurface;
//Cargar shader con efectos de Post-Procesado
effect = TgcShaders.loadEffect(ShadersDir + "PostProcess.fx");
//Configurar Technique dentro del shader
effect.Technique = "AlarmaTechnique";
//Cargar textura que se va a dibujar arriba de la escena del Render Target
alarmTexture = TgcTexture.createTexture(D3DDevice.Instance.Device, MediaDir + "Texturas\\efecto_alarma.png");
//Interpolador para efecto de variar la intensidad de la textura de alarma
intVaivenAlarm = new InterpoladorVaiven();
intVaivenAlarm.Min = 0;
intVaivenAlarm.Max = 1;
intVaivenAlarm.Speed = 5;
intVaivenAlarm.reset();
//Cargamos un escenario
var loader = new TgcSceneLoader();
var scene = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Scenes\\Deposito\\Deposito-TgcScene.xml");
meshes = scene.Meshes;
//Camara en primera personas
Camara = new TgcFpsCamera(new TGCVector3(250, 160, -570), Input);
//Modifier para activar/desactivar efecto de alarma
activarEfectoModifier = AddBoolean("activar_efecto", "Activar efecto", true);
//Modifier para activar/desactivar stensil para ver como el ejemplo se rompe.
activarStencilModifier = AddBoolean("activar_stencil", "Activar stensil", true);
}
public void Init(GameLogic logica, Plataforma plataformaSeleccionada)
{
this.logica = logica;
plataforma = plataformaSeleccionada;
#region configurarEfecto
efecto = TgcShaders.loadEffect(GameModel.shadersDir + "shaderPlanta.fx");
#endregion
}
public override void init()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Activamos el renderizado customizado. De esta forma el framework nos delega control total sobre como dibujar en pantalla
//La responsabilidad cae toda de nuestro lado
GuiController.Instance.CustomRenderEnabled = true;
//Se crean 2 triangulos (o Quad) 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[] screenQuadVertices = 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
screenQuadVB = new VertexBuffer(typeof(CustomVertex.PositionTextured),
4, d3dDevice, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
screenQuadVB.SetData(screenQuadVertices, 0, LockFlags.None);
//Creamos un Render Targer sobre el cual se va a dibujar la pantalla
renderTarget2D = new Texture(d3dDevice, d3dDevice.PresentationParameters.BackBufferWidth
, d3dDevice.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget,
Format.X8R8G8B8, Pool.Default);
//Cargar shader con efectos de Post-Procesado
effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesMediaDir + "Shaders\\PostProcess.fx");
//Configurar Technique dentro del shader
effect.Technique = "OndasTechnique";
//Cargamos un escenario
TgcSceneLoader loader = new TgcSceneLoader();
TgcScene scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Scenes\\Deposito\\Deposito-TgcScene.xml");
meshes = scene.Meshes;
//Camara en primera personas
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.setCamera(new Vector3(-182.3816f, 82.3252f, -811.9061f), new Vector3(-182.0957f, 82.3147f, -810.9479f));
//Modifier para variar tamaño de ondas
GuiController.Instance.Modifiers.addBoolean("activar_efecto", "Activar efecto", true);
GuiController.Instance.Modifiers.addFloat("wave_length", 0, 300, 200);
GuiController.Instance.Modifiers.addFloat("wave_size", 0.01f, 1, 0.01f);
}
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 ShadowMap(GameModel gm)
{
effect = TgcShaders.loadEffect(gm.ShadersDir + "ShadowMap.fx");
gameModel = gm;
mapScene = gm.MapScene;
Camara = gm.Camara;
foreach (var m in mapScene.Meshes)
{
m.Effect = effect;
m.Technique = "RenderShadow";
}
//--------------------------------------------------------------------------------------
// Creo el shadowmap.
// Format.R32F
// Format.X8R8G8B8
g_pShadowMap = new Texture(D3DDevice.Instance.Device, 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 tamano que el shadowmap, y que no tenga
// multisample, etc etc.
g_pDSShadow = D3DDevice.Instance.Device.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
var aspectRatio = D3DDevice.Instance.AspectRatio;
g_mShadowProj = Matrix.PerspectiveFovLH(Geometry.DegreeToRadian(80), aspectRatio, 50, 5000);
D3DDevice.Instance.Device.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;
//donde esta y a donde apunta la luz
lightLookFrom = new Vector3(80, 120, 0);
g_LightPos = lightLookFrom;
lightLookAt = new Vector3(0, 0, 0);
g_LightDir = lightLookAt;
float K = 300;
}
public ManejoIluminacion()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
string alumnoMediaFolder = GuiController.Instance.AlumnoEjemplosDir;
effectSpotYPoint = TgcShaders.loadEffect(alumnoMediaFolder + "CucarachaJugosita\\spotYPoint.fx");
effectPointYPoint = TgcShaders.loadEffect(alumnoMediaFolder + "CucarachaJugosita\\pointYPoint.fx");
//effectSpotYPoint = GuiController.Instance.Shaders.TgcMeshPointLightShader; ;
//effect.Technique = "MultiplesLuces";
}
public SmartTerrain()
{
enabled = true;
alphaBlendEnable = false;
//Shader
Effect = TgcShaders.loadEffect(GuiController.Instance.ExamplesDir + "TerrainEditor\\Shaders\\EditableTerrain.fx");
Technique = "PositionColoredTextured";
aabb = new TgcBoundingBox();
}
public PuntoDeLuz(TwistedMetal env, Vector3 Posicion)
{
this.env = env;
lighthPos = Posicion;
float t = 10f;
lightMesh = TgcBox.fromSize(lighthPos, new Vector3(t, t, t), Color.White);
lightMesh.AutoTransformEnable = false;
lightMesh.updateValues();
//currentShader = TgcShaders.Instance.TgcMeshPointLightShader;
currentShader = TgcShaders.loadEffect(this.env.ShadersDir + "TgcMeshSpotLightShader.fx");
}
private void AplicarShaders(String shaderDir)
{
efectoOlas = TgcShaders.loadEffect(shaderDir + "ShaderOlas.fx");
foreach (TgcMesh mesh in aguas)
{
mesh.Effect = efectoOlas;
mesh.Technique = "Olas";
}
efectoOlas.SetValue("screen_dx", resolucionX);
efectoOlas.SetValue("screen_dy", resolucionY);
}
public override void Init()
{
//Cargar escenario
var loader = new TgcSceneLoader();
scene =
loader.loadSceneFromFile(MediaDir + "MeshCreator\\Scenes\\Deposito\\Deposito-TgcScene.xml");
//Camara en 1ra persona
Camara = new TgcFpsCamera(new Vector3(260f, 170f, 390f), 400f, 300f, Input);
//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(ShadersDir + "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];
var c = new Color[4] {
Color.Red, Color.Blue, Color.Green, Color.Yellow
};
for (var i = 0; i < lightMeshes.Length; i++)
{
var co = c[i % c.Length];
lightMeshes[i] = TgcBox.fromSize(new Vector3(10, 10, 10), co);
lightMeshes[i].AutoTransformEnable = true;
origLightPos[i] = new Vector3(-40, 20 + i * 20, 400);
}
//Modifiers
Modifiers.addBoolean("lightEnable", "lightEnable", true);
Modifiers.addBoolean("lightMove", "lightMove", true);
Modifiers.addFloat("lightIntensity", 0, 150, 38);
Modifiers.addFloat("lightAttenuation", 0.1f, 2, 0.15f);
Modifiers.addColor("mEmissive", Color.Black);
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()
{
//Se crean 2 triangulos (o Quad) 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[] screenQuadVertices =
{
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
screenQuadVB = new VertexBuffer(typeof(CustomVertex.PositionTextured),
4, D3DDevice.Instance.Device, Usage.Dynamic | Usage.WriteOnly,
CustomVertex.PositionTextured.Format, Pool.Default);
screenQuadVB.SetData(screenQuadVertices, 0, LockFlags.None);
//Creamos un Render Targer sobre el cual se va a dibujar la pantalla
renderTarget2D = new Texture(D3DDevice.Instance.Device,
D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth
, D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget,
Format.X8R8G8B8, Pool.Default);
//Creamos un DepthStencil que debe ser compatible con nuestra definicion de renderTarget2D.
depthStencil =
D3DDevice.Instance.Device.CreateDepthStencilSurface(
D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth,
D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight,
DepthFormat.D24S8, MultiSampleType.None, 0, true);
//Cargar shader con efectos de Post-Procesado
effect = TgcShaders.loadEffect(ShadersDir + "PostProcess.fx");
//Configurar Technique dentro del shader
effect.Technique = "OndasTechnique";
//Cargamos un escenario
var loader = new TgcSceneLoader();
var scene = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Scenes\\Deposito\\Deposito-TgcScene.xml");
meshes = scene.Meshes;
//Camara en primera personas
Camara = new TgcFpsCamera(new Vector3(250, 160, -570), Input);
//Modifier para variar tamano de ondas
Modifiers.addBoolean("activar_efecto", "Activar efecto", true);
Modifiers.addFloat("wave_length", 0, 300, 200);
Modifiers.addFloat("wave_size", 0.01f, 1, 0.01f);
}
private void AplicarShaders(String shaderDir)
{
efectoOlas = TgcShaders.loadEffect(shaderDir + "ShaderOlas.fx");
efectoTeleport = TgcShaders.loadEffect(shaderDir + "RobotRoomChange.fx");
foreach (TgcMesh mesh in dangerPlaces)
{
mesh.Effect = efectoOlas;
mesh.Technique = "Olas";
}
efectoOlas.SetValue("screen_dx", resolucionX);
efectoOlas.SetValue("screen_dy", resolucionY);
}