public void instanciarSpotLight(Personaje personaje, Escenario escenario)
{
//Cargar escenario
var loader = new TgcSceneLoader();
//Configurar MeshFactory customizado
scene = escenario.tgcScene;
//Camara en 1ra persona
Camara = personaje;
//Mesh para la luz
lightMesh = TGCBox.fromSize(new TGCVector3(10, 10, 10), Color.Red);
//Modifiers de la luz
lightEnableModifier = true;
lightPosModifier = new TGCVector3 [3] {
new TGCVector3(-200, -100, -200), new TGCVector3(200, 200, 300), new TGCVector3(-60, 90, 175)
};
/*
* lightDirModifier = AddVertex3f("lightDir", new TGCVector3(-1, -1, -1), TGCVector3.One, new TGCVector3(-0.05f, 0, 0));
* lightColorModifier = AddColor("lightColor", Color.White);
* lightIntensityModifier = AddFloat("lightIntensity", 0, 150, 35);
* lightAttenuationModifier = AddFloat("lightAttenuation", 0.1f, 2, 0.3f);
* specularExModifier = AddFloat("specularEx", 0, 20, 9f);
* spotAngleModifier = AddFloat("spotAngle", 0, 180, 39f);
* spotExponentModifier = AddFloat("spotExponent", 0, 20, 7f);
*
* //Modifiers de material
* mEmissiveModifier = AddColor("mEmissive", Color.Black);
* mAmbientModifier = AddColor("mAmbient", Color.White);
* mDiffuseModifier = AddColor("mDiffuse", Color.White);
* mSpecularModifier = AddColor("mSpecular", Color.White);*/
}
public TgcMesh devolverEscalera(Escenario escenario)
{
escalera = escenario.tgcScene.Meshes.Find(mesh => mesh.Name.Equals("EscaleraMetalMovil"));
//Console.WriteLine(escalera.Name);
return(escalera);
}
public void actualizarEscenario()
{
if (escenarioActual is EscenarioMenu)
{
return;
}
float posicionMeshEjeZ = personaje.Mesh.Transform.Origin.Z;
if (between(posicionMeshEjeZ, -330f, 0f))
{
escenarioActual = escenarios["playa"];
}
if (between(posicionMeshEjeZ, -464f, -330f))
{
escenarioActual = escenarios["plataforma"];
}
if (between(posicionMeshEjeZ, -598f, -464f))
{
escenarioActual = escenarios["hielo"];
}
if (between(posicionMeshEjeZ, -750f, -598f))
{
escenarioActual = escenarios["pozo"];
}
if (between(posicionMeshEjeZ, -850f, -750f))
{
escenarioActual = escenarios["piramide"];
}
}
public void UpdateCamera(Escenario Escenario)
{
var Modelo = Escenario.Env;
if (Modelo.Input.keyPressed(Key.F5))
{
colisiones = !colisiones;
}
if (!colisiones)
{
OffsetForward = Modelo.CameraOffsetForward;
Update(Modelo.ElapsedTime);
return;
}
TGCVector3 NextPos, up, target;
//OffsetHeight = Modelo.CameraOffsetHeight;
this.Update(Modelo.ElapsedTime, out NextPos, out target, out up);
//Detectar colisiones entre el segmento de recta camara-personaje y todos los objetos del escenario
TGCVector3 q;
var minDistSq = FastMath.Pow2(Modelo.CameraOffsetForward);
foreach (var obstaculo in Escenario.listaColisionesConCamara())
{
//Hay colision del segmento camara-personaje y el objeto
if (TgcCollisionUtils.intersectSegmentAABB(target, NextPos, obstaculo, out q))
{
//Si hay colision, guardar la que tenga menor distancia
var distSq = TGCVector3.Subtract(q, target).LengthSq();
//Hay dos casos singulares, puede que tengamos mas de una colision hay que quedarse con el menor offset.
//Si no dividimos la distancia por 2 se acerca mucho al target.
minDistSq = FastMath.Min(distSq, minDistSq);
}
}
//Acercar la camara hasta la minima distancia de colision encontrada (pero ponemos un umbral maximo de cercania)
var newOffsetForward = -FastMath.Sqrt(minDistSq);
this.Update(Modelo.ElapsedTime);
if (FastMath.Abs(newOffsetForward) < 10)
{
newOffsetForward = 10;
}
OffsetForward = newOffsetForward;
this.Update(Modelo.ElapsedTime);
}
public void cargarEscenarios()
{
escenarios = new Dictionary <string, Escenario>();
escenarios["playa"] = new EscenarioPlaya(this, personaje);
escenarios["plataforma"] = new EscenarioPlataforma(this, personaje);
escenarios["playa"].siguiente = escenarios["plataforma"];
//escenarios["camino"] = new EscenarioCamino(this, personaje);
escenarios["pozo"] = new EscenarioPozo(this, personaje);
escenarios["piramide"] = new EscenarioPiramide(this, personaje);
escenarios["hielo"] = new EscenarioHielo(this, personaje);
escenarios["menu"] = new EscenarioMenu(this, personaje);
escenarioActual = escenarios["menu"];
}
/// <summary>
/// Se llama una sola vez, al principio cuando se ejecuta el ejemplo.
/// Escribir aquí todo el código de inicialización: cargar modelos, texturas, estructuras de optimización, todo
/// procesamiento que podemos pre calcular para nuestro juego.
/// Borrar el codigo ejemplo no utilizado.
/// </summary>
public override void Init()
{
NuevaCamara = new TgcThirdPersonCamera(new TGCVector3(0, 0, 0), 20, -75, Input);
Camara = NuevaCamara;
Personaje.Init(this);
Escenario = new Escenario1();
Escenario.Init(this);
Escenarios["Escenario1"] = Escenario;
Escenario = new EscenarioMenu();
Escenarios["Menu"] = Escenario;
Escenario = new EscenarioMuerte();
Escenario.Init(this);
Escenarios["Muerte"] = Escenario;
Escenario = new EscenarioVictoria();
Escenario.Init(this);
Escenarios["Victoria"] = Escenario;
Escenario = new EscenarioBullet1();
Escenario.Init(this);
Escenarios["Bullet1"] = Escenario;
Escenario = Escenarios["Menu"];
Personaje.Init(this);
Escenario.Init(this);
}
public void MoverPersonaje(char key, float elapsedTime, TgcD3dInput input, Escenario escenario, Monster monster)
{
MovementSpeed = 800.0f;
var movimiento = TGCVector3.Empty;
var posicionOriginal = this.Position;
var moving = false;
var estoyFlotando = false;
if (key == key_forward)
{
movimiento.Z = -1;
moving = true;
}
if (key == key_left)
{
movimiento.X = 1;
moving = true;
}
if (key == key_back)
{
movimiento.Z = 1;
moving = true;
}
if (key == key_right)
{
movimiento.X = -1;
moving = true;
}
if (key == ' ')
{
movimiento.Y = 1;
moving = true;
}
if (moving)
{
this.posicionAnterior = this.Position;
var lastPos = meshPersonaje.Position;
movimiento *= MovementSpeed * elapsedTime;
meshPersonaje.Position = meshPersonaje.Position + movimiento;
meshPersonaje.updateBoundingBox();
//COLISIONES
bool chocaron = escenario.tgcScene.Meshes.Any(mesh => TgcCollisionUtils.testAABBAABB(mesh.BoundingBox, meshPersonaje.BoundingBox));
if (chocaron)
{
meshPersonaje.Position = lastPos;
}
bool chocoConMonster = TgcCollisionUtils.testAABBAABB(monster.ghost.BoundingBox, meshPersonaje.BoundingBox);
if (chocoConMonster)
{
meshPersonaje.Position = lastPos;
}
meshPersonaje.Transform = TGCMatrix.Scaling(meshPersonaje.Scale) *
TGCMatrix.RotationYawPitchRoll(meshPersonaje.Rotation.Y, meshPersonaje.Rotation.X, meshPersonaje.Rotation.Z) *
TGCMatrix.Translation(meshPersonaje.Position);
this.Position = meshPersonaje.Position;
//Hacer que la camara siga al personaje en su nueva posicion
//camaraInterna.Target = this.Position;
}
float rotY = input.XposRelative * rotationSpeed;
float rotX = input.YposRelative * rotationSpeed;
eye = this.Position;
target += movimiento;
if (lockMouse)
{
if (rotY != 0.0f || rotX != 0.0f)
{
look(rotX, rotY);
}
Cursor.Position = windowCenter;
}
this.SetCamera(eye, target);
}
/// <summary>
/// Se llama en cada frame.
/// Se debe escribir toda la lógica de computo del modelo, así como también verificar entradas del usuario y reacciones
/// ante ellas.
/// </summary>
public override void Update()
{
PreUpdate();
//Coidigo Ejemplo de como capturar teclas
/*//Capturar Input teclado
* if (base.Input.keyPressed(Key.F))
* {
* BoundingBox = !BoundingBox;
* }*/
if (Input.keyPressed(Key.C))
{
desfase.X -= 5;
}
if (Input.keyPressed(Key.V))
{
desfase.X += 5;
}
if (Input.keyPressed(Key.B))
{
desfase.Y -= 5;
}
if (Input.keyPressed(Key.N))
{
desfase.Y += 5;
}
if (Input.keyPressed(Key.H))
{
desfase.Z -= 5;
}
if (Input.keyPressed(Key.J))
{
desfase.Z += 5;
}
if (Input.keyPressed(Key.G))
{
if (dibujarGlow)
{
dibujarGlow = false;
}
else
{
dibujarGlow = true;
}
}
if (Input.keyPressed(Key.M))
{
if (dibujarShadowMap)
{
dibujarShadowMap = false;
}
else
{
dibujarShadowMap = true;
}
}
if (Input.keyPressed(Key.L))
{
if (dibujarLuces)
{
dibujarLuces = false;
}
else
{
dibujarLuces = true;
}
}
if (Input.keyPressed(Key.E))
{
if (spawnaearEnemigos)
{
spawnaearEnemigos = false;
}
else
{
spawnaearEnemigos = true;
}
}
if (Input.keyPressed(Key.T))
{
if (habilitarDisparosTorres)
{
habilitarDisparosTorres = false;
}
else
{
habilitarDisparosTorres = true;
}
}
if (menu.estaEnMenu)
{
menu.Update(ElapsedTime);
if (playerAmbiente.FileName != pathSonidoMenu)
{
playerAmbiente.closeFile();
playerAmbiente.FileName = pathSonidoMenu;
playerAmbiente.play(true);
}
PostUpdate();
return;
}
else
{
hud.Update(navePrincipal);
}
var movimientoNave = TGCVector3.Empty;
if (!menu.estaEnMenu)
{
if (playerAmbiente.FileName != pathSonidoAmbiente)
{
playerAmbiente.closeFile();
playerAmbiente.FileName = pathSonidoAmbiente;
playerAmbiente.play(true);
}
//Movernos de izquierda a derecha, sobre el eje X.
if (Input.keyDown(Key.Left) || Input.keyDown(Key.A))
{
movimientoNave.X = 1;
}
else if (Input.keyDown(Key.Right) || Input.keyDown(Key.D))
{
movimientoNave.X = -1;
}
//Movimiento para elevarse con E y Control para bajar , todo sobre el eje Y.
if (Input.keyDown(Key.W) || Input.keyDown(Key.UpArrow))
{
movimientoNave.Y = 1;
}
else if (Input.keyDown(Key.S) || Input.keyDown(Key.DownArrow))
{
movimientoNave.Y = -1;
}
//boost de velocidad con shift
if (Input.keyDown(Key.LeftShift))
{
navePrincipal.DoSpeedBoost();
if (navePrincipal.shouldSpeedBoost)
{
navePrincipal.GastarFuel(1.5f, hud);
if (movimientoZ > movimientoMaximoZ)
{
movimientoZ -= factorMovimientoZ * 3;
}
movimientoNave.Z = movimientoZ;
cant_pasadas = 3;
}
else
{
movimientoNave.Z = movimientoBaseZ;
}
}
else
{
cant_pasadas = 2;
}
if (movimientoZ < movimientoBaseZ)
{
movimientoZ += factorMovimientoZ;
}
movimientoNave.Z = movimientoZ;
//Activar rotaciones especiales
if (Input.keyDown(Key.Space))
{
this.navePrincipal.DoBarrelRoll();
}
if (Input.keyDown(Key.Z))
{
this.navePrincipal.DoLeft90Spin();
}
if (Input.keyDown(Key.X))
{
this.navePrincipal.DoRight90Spin();
}
//Disparar
if (Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
if (navePrincipal.Disparar(new TGCVector3((((D3DDevice.Instance.Width / 2) - Input.Xpos) * 10) + navePrincipal.MovementVector.X, navePrincipal.MovementVector.Y, navePrincipal.MovementVector.Z - 5000), pathSonidoDisparo, DirectSound.DsDevice))
{
//Aca va la posicion del disparo creo
}
}
if (Input.keyDown(Key.F))
{
if (navePrincipal.Disparar(pathSonidoDisparo, DirectSound.DsDevice))
{
}
}
if (habilitarDisparosTorres)
{
var torretasEnRango = currentScene.TorresEnRango(navePrincipal.GetPosition());
torretasEnRango.ForEach(torre => { torre.Disparar(navePrincipal.GetPosition(), pathSonidoDisparo, DirectSound.DsDevice); torre.Update(ElapsedTime); });
}
}
NaveEnemiga.resetearPosiciones();
if (!TgcCollisionUtils.testObbAABB(this.navePrincipal.OOB, currentScene.Scene.BoundingBox))
{
int nextSceneIndex = escenarios.FindIndex(es => es.Equals(currentScene)) + 1;
if (nextSceneIndex == escenarios.Count)
{
nextSceneIndex = 0;
}
currentScene.MoveScene(escenarios.Count);
currentScene.MovementVector = currentScene.GetOffsetVectorMoved();
currentScene.UpdateBoundingBox();
currentScene = escenarios[nextSceneIndex];
NaveEnemiga.resetearPosiciones();
// enemigosAlMismoTiempo pueden modificarse para aumentar o disminuir la dificultad, tambien para el modo god
if (spawnaearEnemigos)
{
if (enemigos.FindAll(enemigo => enemigo.EstaViva() && enemigo.EnemigoEstaAdelante()).Count == 0)
{
enemigos.FindAll(enemigo => !enemigo.EstaViva() || !enemigo.EnemigoEstaAdelante()).ForEach(nave => nave.Relocate());
}
}
}
// No permitir que se salga de los limites, el salto que hace para volver es medio brusco, se podria atenuar.
movimientoNave -= TGCVector3.Multiply(currentScene.CheckLimits(navePrincipal, movimientoNave), 10);
//Actualiza la matrix de movimiento de la nave.
this.navePrincipal.Move(movimientoNave * ElapsedTime);
this.navePrincipal.Update(ElapsedTime);
if (spawnaearEnemigos)
{
enemigos.FindAll(enemigo => enemigo.EstaViva() && enemigo.EnemigoEstaAdelante()).ForEach(enemigo =>
{
enemigo.Perseguir(ElapsedTime, pathSonidoDisparo, DirectSound.DsDevice);
enemigo.Update(ElapsedTime);
}
);
}
var naves = enemigos.FindAll(enemigo => enemigo.EstaViva() && enemigo.EnemigoEstaAdelante() && spawnaearEnemigos).Select(e => (NaveEspacial)e).ToList();
naves.Add(navePrincipal);
naves.ForEach(naveActual =>
{
//Colision de todas las naves contra el escenario.
if (currentScene.CheckCollision(naveActual))
{
naveActual.Morir();
}
naves.FindAll(n => n != naveActual).ForEach(otraNave =>
{
//Colision fisica entre naves.
if (TgcCollisionUtils.testObbObb(naveActual.OOB, otraNave.OOB))
{
naveActual.Morir();
otraNave.Morir();
}
//Colision de disparos
if (naveActual.CheckIfMyShotsCollided(otraNave))
{
otraNave.Daniar(naveActual.ArmaPrincipal.Danio);
}
});
currentScene.TorresEnRango(navePrincipal.GetPosition()).ForEach(torre =>
{
if (torre.CheckIfMyShotsCollided(naveActual))
{
naveActual.Daniar(torre.arma.Danio);
}
});
});
if (!navePrincipal.EstaViva())
{
this.navePrincipal.MoveTo(new TGCVector3(1200f, -1100f, 4000f) + currentScene.GetOffsetVectorMoved());
this.skyBox.Center = new TGCVector3(0, 0, -2300f) + currentScene.GetOffsetVectorMoved();
this.navePrincipal.Revivir();
this.sol.Position = new TGCVector3(0, 5000f, 4000f) + currentScene.GetOffsetVectorMoved();
this.menu.estaEnMenu = true;
}
this.skyBox.Center += movimientoNave * ElapsedTime * 1000;
this.sol.Move(new TGCVector3(0, 0, movimientoNave.Z) * ElapsedTime * 1000);
estrellasS.ForEach(e =>
{
e.Position += new TGCVector3(0, 0, movimientoNave.Z) * ElapsedTime * 1000;
});
(this.Camara as CamaraStarWars).Target = this.navePrincipal.GetPosition();
PostUpdate();
}
/// <summary>
/// Se llama una sola vez, al principio cuando se ejecuta el ejemplo.
/// Escribir aquí todo el código de inicialización: cargar modelos, texturas, estructuras de optimización, todo
/// procesamiento que podemos pre calcular para nuestro juego.
/// Borrar el codigo ejemplo no utilizado.
/// </summary>
public override void Init()
{
estrellasS.ForEach(e => e.AutoTransform = true);
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 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;
escena = new Texture(D3DDevice.Instance.Device, D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth,
D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget, Format.X8R8G8B8, Pool.Default);
propulsores = new Texture(D3DDevice.Instance.Device, D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth,
D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget, Format.X8R8G8B8, Pool.Default);
propulsoresBlurAux = new Texture(D3DDevice.Instance.Device, D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth,
D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget, Format.X8R8G8B8, Pool.Default);
propulsoresBlurAux2 = new Texture(D3DDevice.Instance.Device, D3DDevice.Instance.Device.PresentationParameters.BackBufferWidth,
D3DDevice.Instance.Device.PresentationParameters.BackBufferHeight, 1, Usage.RenderTarget, Format.X8R8G8B8, Pool.Default);
//Device de DirectX para crear primitivas.
var d3dDevice = D3DDevice.Instance.Device;
D3DDevice.Instance.Device.Transform.Projection =
Matrix.PerspectiveFovLH(D3DDevice.Instance.FieldOfView,
D3DDevice.Instance.AspectRatio,
D3DDevice.Instance.ZNearPlaneDistance,
D3DDevice.Instance.ZFarPlaneDistance * 1.8f);
this.postProcessMerge = TgcShaders.loadEffect(this.ShadersDir + "PostProcess.fx");
this.blurEffect = TgcShaders.loadEffect(this.ShadersDir + "GaussianBlur.fx");
blurEffect.SetValue("screen_dx", d3dDevice.PresentationParameters.BackBufferWidth);
blurEffect.SetValue("screen_dy", d3dDevice.PresentationParameters.BackBufferHeight);
this.escenarios = new List <Escenario>();
this.enemigos = new List <NaveEnemiga>();
//Crear SkyBox
skyBox = new TgcSkyBox();
skyBox.Center = new TGCVector3(0, 0, -2300f);
skyBox.Size = new TGCVector3(10000, 10000, 18000);
var texturesPath = MediaDir + "XWing\\Textures\\";
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Up, texturesPath + "space.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Down, texturesPath + "space.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Left, texturesPath + "space.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Right, texturesPath + "space.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Front, texturesPath + "space.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Back, texturesPath + "space.jpg");
skyBox.Init();
this.navePrincipal = new NaveEspacial(MediaDir, "xwing-TgcScene.xml", Color.DarkBlue, 10, 250, null, 250f);
this.navePrincipal.ScaleFactor = TGCMatrix.Scaling(0.5f, 0.5f, 0.5f);
this.navePrincipal.RotationVector = new TGCVector3(0, FastMath.PI_HALF, 0);
this.navePrincipal.MovementVector = new TGCVector3(1200f, -1100f, 4000f);
for (int i = 0; i < 5; i++)
{
escenarios.Add(Escenario.GenerarEscenarioDefault(MediaDir, i));
}
for (int i = 0; i < enemigosAlMismoTiempo; i++)
{
enemigos.Add(new NaveEnemiga(MediaDir, "X-Wing-TgcScene.xml", dañoEnemigos, 500, navePrincipal));
enemigos[i].MovementVector = new TGCVector3(0, 0, 500000000000f);
enemigos[i].CreateOOB();
}
//escenarios.ForEach(es => es.generarTorre(MediaDir));
currentScene = escenarios[0];
this.navePrincipal.CreateOOB();
//Suelen utilizarse objetos que manejan el comportamiento de la camara.
//Lo que en realidad necesitamos gráficamente es una matriz de View.
//El framework maneja una cámara estática, pero debe ser inicializada.
//Posición de la camara.
var cameraPosition = new TGCVector3(0, 0, 0);
//Quiero que la camara mire hacia el origen (0,0,0).
var lookAt = new TGCVector3(-50000, -1, 0);
//Configuro donde esta la posicion de la camara y hacia donde mira.
Camara.SetCamera(cameraPosition, lookAt);
//Internamente el framework construye la matriz de view con estos dos vectores.
//Luego en nuestro juego tendremos que crear una cámara que cambie la matriz de view con variables como movimientos o animaciones de escenas.
Camara = new CamaraStarWars(this.navePrincipal.GetPosition(), 20, 100);
sol = TGCBox.fromSize(new TGCVector3(0, 5000, 4000), new TGCVector3(50, 50, 50), Color.Yellow);
sol.AutoTransform = true;
menu = new Menu(MediaDir, Input);
//Cargo sonidos
pathSonidoMenu = MediaDir + "Sound\\musica_menu.mp3";
pathSonidoAmbiente = MediaDir + "Music\\StarWarsMusic.mp3";
pathSonidoDisparo = MediaDir + "Music\\laserSound.wav";
if (menu.playSonidoMenu)
{
playerAmbiente.closeFile();
playerAmbiente.FileName = pathSonidoMenu;
playerAmbiente.play(true);
}
drawer = new Drawer2D();
hud = new Hud(MediaDir, Input);
//ShadowMap
// 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 = TGCMatrix.PerspectiveFovLH(Geometry.DegreeToRadian(50), aspectRatio, 50, 15000);
D3DDevice.Instance.Device.Transform.Projection = TGCMatrix.PerspectiveFovLH(Geometry.DegreeToRadian(45.0f), aspectRatio, near_plane, far_plane).ToMatrix();
}
public void CambiarEscenario(string name)
{
Escenario = Escenarios[name];
Escenario.Reset();
}
public MonsterBlur(Escenario nuestra_scene, GameModel modelo)
{
escenario = nuestra_scene;
gameModel = modelo;
}
public void CambiarEscenario(string nombre)
{
escenarioActual = escenarios[nombre];
}
