public void renderScene(float elapsedTime, bool cubemap)
{
Device device = GuiController.Instance.D3dDevice;
//Renderizar terreno
if (!cubemap)
{
effect.Technique = "RenderSceneShadows";
terrain.executeRender(effect);
}
else
{
terrain.render();
}
//Renderizar SkyBox
skyBox.render();
barcoUser.render();
bool showQuadtree = (bool)GuiController.Instance.Modifiers["showQuadtree"];
quadtree.render(GuiController.Instance.Frustum, showQuadtree);
/*foreach (Enemigo elemento in enemigos)
* {
* elemento.getBarco().render();
* elemento.getIDBarco().render();
* }*/
if (!cubemap)
{
// dibujo el mesh
ship.Technique = "RenderScene";
ship.render();
}
}
public void renderScene(float elapsedTime, bool cubemap)
{
Device device = GuiController.Instance.D3dDevice;
//Renderizar terreno
terrain.render();
//Renderizar SkyBox
skyBox.render();
// dibujo el bosque
foreach (TgcMesh instance in bosque)
{
instance.render();
}
// avion
//avion.Technique = cubemap ? "RenderCubeMap" : "RenderScene";
avion.render();
if (!cubemap)
{
// dibujo el mesh
mesh.Technique = "RenderCubeMap";
mesh.render();
}
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Renderizar SkyBox
skyBox.render();
}
public void renderSinEfectos(float elapsedTime)
{
Device device = GuiController.Instance.D3dDevice;
Control panel3d = GuiController.Instance.Panel3d;
float aspectRatio = (float)panel3d.Width / (float)panel3d.Height;
// dibujo la escena una textura
effect.Technique = "DefaultTechnique";
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
device.BeginScene();
//Dibujamos todos los meshes del escenario
renderScene(elapsedTime, "DefaultTechnique");
//Render skybox
skyBox.render();
device.EndScene();
}
public void render(float elapsedTime)
{
bool showQuadtree = (bool)GuiController.Instance.Modifiers["showQuadtree"];
TgcThirdPersonCamera camera = GuiController.Instance.ThirdPersonCamera;
quadtree.render(GuiController.Instance.Frustum, showQuadtree);
if (Shared.debugMode)
{
foreach (TgcMesh objeto in objetos)
{
objeto.BoundingBox.render();
}
}
foreach (TgcSimpleTerrain terreno in this.terrenos)
{
terreno.render();
}
foreach (TgcBox caja in this.cajas)
{
caja.render();
}
checkpointActual.render(elapsedTime);
checkpointActual.obb.rotate(new Vector3(0, 5f * elapsedTime, 0));
if (Shared.debugMode)
{
checkpointActual.obb.render();
}
cielo.render();
}
public override void Render()
{
PreRender();
//Obtener boolean para saber si hay que mostrar Bounding Box
var showBB = (bool)Modifiers.getValue("showBoundingBox");
if (collisionManager.Collision)
{
collisionNormalArrow.render();
collisionPoint.render();
}
//Render de mallas
foreach (var mesh in escenario.Meshes)
{
mesh.render();
}
//Render personaje
personaje.animateAndRender(ElapsedTime);
if (showBB)
{
characterSphere.render();
}
//Render linea
directionArrow.render();
//Render SkyBox
skyBox.render();
PostRender();
}
public override void render(float elapsedTime)
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Obtener boolean para saber si hay que mostrar Bounding Box
bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
//obtener velocidades de Modifiers
float velocidadCaminar = (float)GuiController.Instance.Modifiers.getValue("VelocidadCaminar");
float velocidadRotacion = (float)GuiController.Instance.Modifiers.getValue("VelocidadRotacion");
TgcD3dInput d3dInput = GuiController.Instance.D3dInput;
movimientoController.render(elapsedTime);
//Hacer que la camara siga al personaje en su nueva posicion
camara.Target = movimientoController.getPersonaje().Position;
//Ver cual de las mallas se interponen en la visión de la cámara en 3ra persona.
objectsBehind.Clear();
objectsInFront.Clear();
Camara camera = camara;
foreach (TgcMesh mesh in escenario.Meshes)
{
Vector3 q;
if (TgcCollisionUtils.intersectSegmentAABB(camera.Position, camera.Target, mesh.BoundingBox, out q))
{
objectsBehind.Add(mesh);
}
else
{
objectsInFront.Add(mesh);
}
}
//Render mallas que no se interponen
foreach (TgcMesh mesh in objectsInFront)
{
mesh.render();
if (showBB)
{
mesh.BoundingBox.render();
}
}
//Para las mallas que se interponen a la cámara, solo renderizar su BoundingBox
foreach (TgcMesh mesh in objectsBehind)
{
mesh.BoundingBox.render();
}
//Render SkyBox
skyBox.render();
}
private void renderJuego(float elapsedTime, Device d3dDevice)
{
//Poner luz a los meshes
Vector3 posLuz = new Vector3(POS_SHIP.X - 10000, POS_SHIP.Y + 5000, POS_SHIP.Z - 25000);
lightMesh.Position = posLuz;
this.cargarLuces(posLuz);
lightMesh.render();
//Obtener valor modifier
heightOlas = (float)GuiController.Instance.Modifiers["heightOlas"];
//Device device = GuiController.Instance.D3dDevice;
time += elapsedTime;
d3dDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.DarkSlateBlue, 1.0f, 0);
update(elapsedTime, time);
terrain.render();
skyBox.render();
//skyBoundingBox.render();
// Cargar variables de shader, por ejemplo el tiempo transcurrido.
effect.SetValue("time", time);
effect.SetValue("height", heightOlas);
effect.SetValue("menorAltura", terrain.menorVerticeEnY);
effect.SetValue("offset", (float)(terrain.Center.Y * currentScaleY));
effect.SetValue("texHeightmap", TerrenoSimple.toTexture(currentHeightmap));
//GuiController.Instance.Logger.log("OFFSET: " + (terrain.Center.Y * currentScaleY).ToString() + "MENOR ALTURA: " + terrain.menorVerticeEnY);
efectoSombra.SetValue("time", time);
efectoSombra.SetValue("height", heightOlas);
efectoSombra.SetValue("menorAltura", terrain.menorVerticeEnY);
efectoSombra.SetValue("offset", (float)(terrain.Center.Y * currentScaleY));
efectoSombra.SetValue("texHeightmap", TerrenoSimple.toTexture(currentHeightmap));
agua.heightOlas = heightOlas;
agua.AlphaBlendEnable = true;
agua.render();
d3dDevice.Transform.World = Matrix.Identity;
TgcD3dInput input = GuiController.Instance.D3dInput;
if (input.keyPressed(Microsoft.DirectX.DirectInput.Key.L))
{
lloviendo = lloviendo ? false : true;
}
ship.renderizar();
shipContrincante.renderizar();
lluvia.render();
}
public override void Render()
{
PreRender();
DrawText.drawText("Camera pos: " + TgcParserUtils.printVector3(Camara.Position), 5, 20, Color.Red);
//Renderizar SkyBox
skyBox.render();
PostRender();
}
public override void Render()
{
PreRender();
//Renderizar SkyBox
skyBox.render();
PostRender();
}
public void Render(Snipers scene)
{
//suelo.render();
skyBox.render();
heightMap.render();
if ((bool)GuiController.Instance.Modifiers.getValue("showBB"))
{
heightMap.BoundingBox.render();
}
this.UpdateVisibleMeshes();
if ((bool)GuiController.Instance.Modifiers.getValue("showGrilla"))
{
foreach (TgcDebugBox debugBox in grilla.DebugGrillaBoxes())
{
debugBox.render();
}
}
for (int i = 0; i < otrosObjetos.Count; i++)
{
TgcMesh mesh = otrosObjetos[i];
if (mesh.Enabled)
{
// Tres curvas distintas en diferentes etapas, para mayor realismo
if (i % 3 == 0)
{
treeWindEffect.SetValue("wind_wave", wind_wave_1);
}
else if (i % 2 == 0)
{
treeWindEffect.SetValue("wind_wave", wind_wave_2);
}
else
{
treeWindEffect.SetValue("wind_wave", wind_wave_3);
}
mesh.render();
if ((bool)GuiController.Instance.Modifiers.getValue("showBB"))
{
mesh.BoundingBox.render();
}
mesh.Enabled = false;
}
}
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
bool showGrid = (bool)GuiController.Instance.Modifiers["showGrid"];
bool showTerrain = (bool)GuiController.Instance.Modifiers["showTerrain"];
skyBox.render();
if (showTerrain)
{
terreno.render();
}
grilla.render(GuiController.Instance.Frustum, showGrid);
}
public override void Render()
{
PreRender();
var showGrid = (bool)Modifiers["showGrid"];
var showTerrain = (bool)Modifiers["showTerrain"];
skyBox.render();
if (showTerrain)
{
terreno.render();
}
grilla.render(Frustum, showGrid);
PostRender();
}
public override void Render()
{
PreRender();
var showOctree = (bool)Modifiers["showOctree"];
var showTerrain = (bool)Modifiers["showTerrain"];
skyBox.render();
if (showTerrain)
{
terreno.render();
}
octree.render(Frustum, showOctree);
PostRender();
}
public override void Render()
{
PreRender();
var showQuadtree = (bool)Modifiers["showQuadtree"];
var showTerrain = (bool)Modifiers["showTerrain"];
skyBox.render();
if (showTerrain)
{
terreno.render();
}
quadtree.render(TgcFrustum.Instance, showQuadtree);
PostRender();
}
public override void Render()
{
PreRender();
//Obtener boolean para saber si hay que mostrar Bounding Box
var showBB = (bool)Modifiers.getValue("showBoundingBox");
//Render mallas que no se interponen
foreach (var mesh in objectsInFront)
{
mesh.render();
if (showBB)
{
mesh.BoundingBox.render();
}
}
//Para las mallas que se interponen a la cámara, solo renderizar su BoundingBox
foreach (var mesh in objectsBehind)
{
mesh.BoundingBox.render();
}
//Render personaje
personaje.animateAndRender(ElapsedTime);
if (showBB)
{
characterSphere.render();
}
//Render linea
directionArrow.render();
//Render SkyBox
skyBox.render();
PostRender();
}
public override void Render()
{
PreRender();
//Obtener boolean para saber si hay que mostrar Bounding Box
var showBB = (bool)Modifiers.getValue("showBoundingBox");
if (collisionManager.Result.collisionFound)
{
collisionNormalArrow.render();
collisionPoint.Transform = Matrix.RotationYawPitchRoll(collisionPoint.Rotation.Y, collisionPoint.Rotation.X, collisionPoint.Rotation.Z) *
Matrix.Translation(collisionPoint.Position);
collisionPoint.render();
}
//Render de mallas
foreach (var mesh in escenario.Meshes)
{
mesh.render();
}
//Render personaje
personaje.animateAndRender(ElapsedTime);
if (showBB)
{
characterElipsoid.render();
}
//Render linea
directionArrow.render();
//Render SkyBox
skyBox.render();
PostRender();
}
public void Render()
{
foreach (TgcMesh mesh in this.getAllMeshes())
{
//rendereo solo lo que esta dentro del frustrum
var c = TgcCollisionUtils.classifyFrustumAABB(this.env.Frustum, mesh.BoundingBox);
if (c != TgcCollisionUtils.FrustumResult.OUTSIDE)
{
mesh.render();
}
}
//Renderizar suelo
suelo.render();
//calle.render();
//Renderizar SkyBox
skyBox.render();
//Renderizar instancias
// foreach (var mesh in meshes)
// mesh.render();
//Renderizar items
int nroItem = 0;
foreach (var item in items)
{
if (itemsTiempoInvisibilidad[nroItem] < 380)
{
//posEncontrada = nroItem;
itemsTiempoInvisibilidad[nroItem] = itemsTiempoInvisibilidad[nroItem]++;
}
else
{
if (item.Position.Y < 10)
{
item.move(0, 50, 0);
}
}
item.render();
nroItem++;
}
//Renderizado de cordones
foreach (var cordon in cordones)
{
cordon.render();
}
//Renderizado de veredas
foreach (var v in veredas)
{
v.render();
}
//Renderizado de paredes
foreach (var p in paredes)
{
p.render();
}
//Renderizado de calles
foreach (var c in calles)
{
c.render();
}
/* foreach (var vehiculo in vehiculos)
* {
* vehiculo.getMesh().render();
* }*/
//mostrarBounding();
}
/// <summary>
/// main render method
/// </summary>
public override void Render()
{
BorrarPantalla();
if (showMenu)
{
//TODO -> mostrar menu inicial
return;
}
if (!FinishedLoading)
{
return;
}
crono.render(ElapsedTime);
preRenderPointLight(); //render 1
//preRenderNiebla(); //render2, rompe con la luz por eso esta comentado
IniciarScene(); //empiezo main escena
//cilindroBB.render();
//PreRenderPersonalizado(); //para el shadowMapFIX
if (GodModeOn)
{
DibujarDebug();
}
var posCamara = AutoJugador.CamaraAuto.Position;
//foreach (Auto a in Autos)
//{
// foreach (LuzFija luz in LucesLst)
// {
// luz.setValues(a.Mesh, posCamara);
// }
// a.Render();
//}
foreach (TgcMesh mesh in MapScene.Meshes)
{
//rendereo solo lo que esta dentro del frustrum
var c = TgcCollisionUtils.classifyFrustumAABB(Frustum, mesh.BoundingBox);
if (c != TgcCollisionUtils.FrustumResult.OUTSIDE)
{
mesh.render();
}
}
DrawText.drawText(AutoJugador.Velocidad.ToString(), 20, 50, Color.Orange);
//skybox render
//render de menubox solo cuando es necesario.
if (GodModeOn == true && MenuBox != null)
{
MenuBox.Render();
}
//Dibujo los sprites2d en pantalla
Velocimetro.Render();
autoOponente.render();
SkyBox.render();
RenderAxis();
RenderFPS();
AutoJugador.Render();
TerminarScene(); //termino main scene
ImprimirPantalla();
}
public override void Render()
{
ClearTextures();
var device = D3DDevice.Instance.Device;
effect.Technique = "DefaultTechnique";
// guardo el Render target anterior y seteo la textura como render target
var pOldRT = device.GetRenderTarget(0);
var pSurf = g_pRenderTarget.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
// hago lo mismo con el depthbuffer, necesito el que no tiene multisampling
var pOldDS = device.DepthStencilSurface;
device.DepthStencilSurface = g_pDepthStencil;
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
device.BeginScene();
// -------------------------------------
//Renderizar terreno
terrain.Effect = effect;
terrain.Technique = "DefaultTechnique";
terrain.render();
// skybox
skyBox.render();
//Renderizar pista
circuito.render(effect);
//Renderizar auto
car.Effect = effect;
car.Technique = "DefaultTechnique";
car.render();
// -------------------------------------
device.EndScene();
pSurf.Dispose();
// Ultima pasada vertical va sobre la pantalla pp dicha
device.SetRenderTarget(0, pOldRT);
device.DepthStencilSurface = g_pDepthStencilOld;
device.BeginScene();
effect.Technique = "FrameMotionBlur";
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, g_pVBV3D, 0);
effect.SetValue("g_RenderTarget", g_pRenderTarget);
effect.SetValue("g_RenderTarget2", g_pRenderTarget2);
effect.SetValue("g_RenderTarget3", g_pRenderTarget3);
effect.SetValue("g_RenderTarget4", g_pRenderTarget4);
effect.SetValue("g_RenderTarget5", g_pRenderTarget5);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
effect.Begin(FX.None);
effect.BeginPass(0);
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.EndPass();
effect.End();
//TgcDrawText.Instance.drawText("Pos: " + this.Camara.Position, 0, 0, Color.Yellow);
//TgcDrawText.Instance.drawText("Look At: " + CamaraManager.Instance.CurrentCamera.getLookAt(), 500, 0, Color.Yellow);
if (circuito.en_ruta)
{
DrawText.drawText("Tramo:" + circuito.pos_en_ruta, 0, 15, Color.Yellow);
}
//TgcDrawText.Instance.drawText("dist_cam:" + dist_cam + "defY" + desf.Y, 0, 0, Color.Yellow);
//TgcDrawText.Instance.drawText("vel:" + vel, 0, 0, Color.Yellow);
RenderFPS();
RenderAxis();
device.EndScene();
device.Present();
ftime += ElapsedTime;
if (ftime > 0.03f)
{
ftime = 0;
var aux = g_pRenderTarget5;
g_pRenderTarget5 = g_pRenderTarget4;
g_pRenderTarget4 = g_pRenderTarget3;
g_pRenderTarget3 = g_pRenderTarget2;
g_pRenderTarget2 = g_pRenderTarget;
g_pRenderTarget = aux;
}
}
public override void Render()
{
PreRender();
//Obtener boolean para saber si hay que mostrar Bounding Box
var showBB = (bool)Modifiers.getValue("showBoundingBox");
//obtener velocidades de Modifiers
var velocidadCaminar = (float)Modifiers.getValue("VelocidadCaminar");
var velocidadRotacion = (float)Modifiers.getValue("VelocidadRotacion");
var velocidadSalto = (float)Modifiers.getValue("VelocidadSalto");
var tiempoSalto = (float)Modifiers.getValue("TiempoSalto");
//Calcular proxima posicion de personaje segun Input
var moveForward = 0f;
float rotate = 0;
var d3dInput = TgcD3dInput.Instance;
var moving = false;
var rotating = false;
float jump = 0;
//Adelante
if (d3dInput.keyDown(Key.W))
{
moveForward = -velocidadCaminar;
moving = true;
}
//Atras
if (d3dInput.keyDown(Key.S))
{
moveForward = velocidadCaminar;
moving = true;
}
//Derecha
if (d3dInput.keyDown(Key.D))
{
rotate = velocidadRotacion;
rotating = true;
}
//Izquierda
if (d3dInput.keyDown(Key.A))
{
rotate = -velocidadRotacion;
rotating = true;
}
//Jump
if (!jumping && d3dInput.keyPressed(Key.Space))
{
//Se puede saltar solo si hubo colision antes
if (collisionManager.Result.collisionFound)
{
jumping = true;
jumpingElapsedTime = 0f;
jump = 0;
}
}
//Si hubo rotacion
if (rotating)
{
//Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware
var rotAngle = Geometry.DegreeToRadian(rotate * ElapsedTime);
personaje.rotateY(rotAngle);
camaraInterna.rotateY(rotAngle);
}
//Saltando
if (jumping)
{
//Activar animacion de saltando
personaje.playAnimation("Jump", true);
}
//Si hubo desplazamiento
else if (moving)
{
//Activar animacion de caminando
personaje.playAnimation("Walk", true);
}
//Si no se esta moviendo ni saltando, activar animacion de Parado
else
{
personaje.playAnimation("StandBy", true);
}
//Actualizar salto
if (jumping)
{
//El salto dura un tiempo hasta llegar a su fin
jumpingElapsedTime += ElapsedTime;
if (jumpingElapsedTime > tiempoSalto)
{
jumping = false;
}
else
{
jump = velocidadSalto * (tiempoSalto - jumpingElapsedTime);
}
}
//Vector de movimiento
var movementVector = Vector3.Empty;
if (moving || jumping)
{
//Aplicar movimiento, desplazarse en base a la rotacion actual del personaje
movementVector = new Vector3(
FastMath.Sin(personaje.Rotation.Y) * moveForward,
jump,
FastMath.Cos(personaje.Rotation.Y) * moveForward
);
}
//Actualizar valores de gravedad
collisionManager.GravityEnabled = (bool)Modifiers["HabilitarGravedad"];
collisionManager.GravityForce = (Vector3)Modifiers["Gravedad"] /** elapsedTime*/;
collisionManager.SlideFactor = (float)Modifiers["SlideFactor"];
collisionManager.OnGroundMinDotValue = (float)Modifiers["Pendiente"];
//Si esta saltando, desactivar gravedad
if (jumping)
{
collisionManager.GravityEnabled = false;
}
//Mover personaje con detección de colisiones, sliding y gravedad
if ((bool)Modifiers["Collisions"])
{
//Aca se aplica toda la lógica de detección de colisiones del CollisionManager. Intenta mover el Elipsoide
//del personaje a la posición deseada. Retorna la verdadera posicion (realMovement) a la que se pudo mover
var realMovement = collisionManager.moveCharacter(characterElipsoid, movementVector,
objetosColisionables);
personaje.move(realMovement);
//Cargar desplazamiento realizar en UserVar
UserVars.setValue("Movement", TgcParserUtils.printVector3(realMovement));
}
else
{
personaje.move(movementVector);
}
/*
* //Si estaba saltando y hubo colision de una superficie que mira hacia abajo, desactivar salto
* if (jumping && collisionManager.Result.collisionNormal.Y < 0)
* {
* jumping = false;
* }
*/
//Hacer que la camara siga al personaje en su nueva posicion
camaraInterna.Target = personaje.Position;
//Actualizar valores de la linea de movimiento
directionArrow.PStart = characterElipsoid.Center;
directionArrow.PEnd = characterElipsoid.Center + Vector3.Multiply(movementVector, 50);
directionArrow.updateValues();
//Actualizar valores de normal de colision
if (collisionManager.Result.collisionFound)
{
collisionNormalArrow.PStart = collisionManager.Result.collisionPoint;
collisionNormalArrow.PEnd = collisionManager.Result.collisionPoint +
Vector3.Multiply(collisionManager.Result.collisionNormal, 80);
;
collisionNormalArrow.updateValues();
collisionNormalArrow.render();
collisionPoint.Position = collisionManager.Result.collisionPoint;
collisionPoint.render();
}
//Render de mallas
foreach (var mesh in escenario.Meshes)
{
mesh.render();
}
//Render personaje
personaje.animateAndRender(ElapsedTime);
if (showBB)
{
characterElipsoid.render();
}
//Render linea
directionArrow.render();
//Render SkyBox
skyBox.render();
PostRender();
}
public override void render(float elapsedTime)
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Obtener boolean para saber si hay que mostrar Bounding Box
bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
//obtener velocidades de Modifiers
float velocidadCaminar = (float)GuiController.Instance.Modifiers.getValue("VelocidadCaminar");
float velocidadRotacion = (float)GuiController.Instance.Modifiers.getValue("VelocidadRotacion");
//Calcular proxima posicion de personaje segun Input
float moveForward = 0f;
float rotate = 0;
TgcD3dInput d3dInput = GuiController.Instance.D3dInput;
bool moving = false;
bool rotating = false;
float jump = 0;
//Adelante
if (d3dInput.keyDown(Key.W))
{
moveForward = -velocidadCaminar;
moving = true;
}
//Atras
if (d3dInput.keyDown(Key.S))
{
moveForward = velocidadCaminar;
moving = true;
}
//Derecha
if (d3dInput.keyDown(Key.D))
{
rotate = velocidadRotacion;
rotating = true;
}
//Izquierda
if (d3dInput.keyDown(Key.A))
{
rotate = -velocidadRotacion;
rotating = true;
}
//Jump
if (d3dInput.keyDown(Key.Space))
{
jump = 30;
moving = true;
}
//Si hubo rotacion
if (rotating)
{
//Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware
float rotAngle = Geometry.DegreeToRadian(rotate * elapsedTime);
personaje.rotateY(rotAngle);
GuiController.Instance.ThirdPersonCamera.rotateY(rotAngle);
}
//Si hubo desplazamiento
if (moving)
{
//Activar animacion de caminando
personaje.playAnimation("Caminando", true);
}
//Si no se esta moviendo, activar animacion de Parado
else
{
personaje.playAnimation("Parado", true);
}
//Vector de movimiento
Vector3 movementVector = Vector3.Empty;
if (moving)
{
//Aplicar movimiento, desplazarse en base a la rotacion actual del personaje
movementVector = new Vector3(
FastMath.Sin(personaje.Rotation.Y) * moveForward,
jump,
FastMath.Cos(personaje.Rotation.Y) * moveForward
);
}
//Actualizar valores de gravedad
collisionManager.GravityEnabled = (bool)GuiController.Instance.Modifiers["HabilitarGravedad"];
collisionManager.GravityForce = (Vector3)GuiController.Instance.Modifiers["Gravedad"];
collisionManager.SlideFactor = (float)GuiController.Instance.Modifiers["SlideFactor"];
//Mover personaje con detección de colisiones, sliding y gravedad
Vector3 realMovement = collisionManager.moveCharacter(characterSphere, movementVector, objetosColisionables);
personaje.move(realMovement);
//Hacer que la camara siga al personaje en su nueva posicion
GuiController.Instance.ThirdPersonCamera.Target = personaje.Position;
//Actualizar valores de la linea de movimiento
directionArrow.PStart = characterSphere.Center;
directionArrow.PEnd = characterSphere.Center + Vector3.Multiply(movementVector, 50);
directionArrow.updateValues();
//Cargar desplazamiento realizar en UserVar
GuiController.Instance.UserVars.setValue("Movement", TgcParserUtils.printVector3(realMovement));
//Ver cual de las mallas se interponen en la visión de la cámara en 3ra persona.
objectsBehind.Clear();
objectsInFront.Clear();
TgcThirdPersonCamera camera = GuiController.Instance.ThirdPersonCamera;
foreach (TgcMesh mesh in escenario.Meshes)
{
Vector3 q;
if (TgcCollisionUtils.intersectSegmentAABB(camera.Position, camera.Target, mesh.BoundingBox, out q))
{
objectsBehind.Add(mesh);
}
else
{
objectsInFront.Add(mesh);
}
}
//Render mallas que no se interponen
foreach (TgcMesh mesh in objectsInFront)
{
mesh.render();
if (showBB)
{
mesh.BoundingBox.render();
}
}
//Para las mallas que se interponen a la cámara, solo renderizar su BoundingBox
foreach (TgcMesh mesh in objectsBehind)
{
mesh.BoundingBox.render();
}
//Render personaje
personaje.animateAndRender();
if (showBB)
{
characterSphere.render();
}
//Render linea
directionArrow.render();
//Render SkyBox
skyBox.render();
}
public override void render(float elapsedTime)
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Obtener boolean para saber si hay que mostrar Bounding Box
bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
//obtener velocidades de Modifiers
float velocidadCaminar = (float)GuiController.Instance.Modifiers.getValue("VelocidadCaminar");
float velocidadRotacion = (float)GuiController.Instance.Modifiers.getValue("VelocidadRotacion");
float velocidadSalto = (float)GuiController.Instance.Modifiers.getValue("VelocidadSalto");
float tiempoSalto = (float)GuiController.Instance.Modifiers.getValue("TiempoSalto");
//Calcular proxima posicion de personaje segun Input
float moveForward = 0f;
float rotate = 0;
TgcD3dInput d3dInput = GuiController.Instance.D3dInput;
bool moving = false;
bool rotating = false;
float jump = 0;
//Adelante
if (d3dInput.keyDown(Key.W))
{
moveForward = -velocidadCaminar;
moving = true;
}
//Atras
if (d3dInput.keyDown(Key.S))
{
moveForward = velocidadCaminar;
moving = true;
}
//Derecha
if (d3dInput.keyDown(Key.D))
{
rotate = velocidadRotacion;
rotating = true;
}
//Izquierda
if (d3dInput.keyDown(Key.A))
{
rotate = -velocidadRotacion;
rotating = true;
}
//Jump
if (!jumping && d3dInput.keyPressed(Key.Space))
{
if (collisionManager.Collision)
{
jumping = true;
jumpingElapsedTime = 0f;
jump = 0;
}
}
//Si hubo rotacion
if (rotating)
{
//Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware
float rotAngle = Geometry.DegreeToRadian(rotate * elapsedTime);
personaje.rotateY(rotAngle);
GuiController.Instance.ThirdPersonCamera.rotateY(rotAngle);
}
//Si hubo desplazamiento
if (moving)
{
//Activar animacion de caminando
personaje.playAnimation("Caminando", true);
}
//Si no se esta moviendo, activar animacion de Parado
else
{
personaje.playAnimation("Parado", true);
}
//Actualizar salto
if (jumping)
{
jumpingElapsedTime += elapsedTime;
if (jumpingElapsedTime > tiempoSalto)
{
jumping = false;
}
else
{
jump = velocidadSalto;
}
}
//Vector de movimiento
Vector3 movementVector = Vector3.Empty;
if (moving || jumping)
{
//Aplicar movimiento, desplazarse en base a la rotacion actual del personaje
//jump *= elapsedTime;
movementVector = new Vector3(
FastMath.Sin(personaje.Rotation.Y) * moveForward,
jump,
FastMath.Cos(personaje.Rotation.Y) * moveForward
);
}
//Actualizar valores de gravedad
collisionManager.GravityEnabled = (bool)GuiController.Instance.Modifiers["HabilitarGravedad"];
collisionManager.GravityForce = (Vector3)GuiController.Instance.Modifiers["Gravedad"] /** elapsedTime*/;
collisionManager.SlideFactor = (float)GuiController.Instance.Modifiers["SlideFactor"];
collisionManager.OnGroundMinDotValue = (float)GuiController.Instance.Modifiers["Pendiente"];
//Si esta saltando, desactivar gravedad
if (jumping)
{
collisionManager.GravityEnabled = false;
}
//Mover personaje con detección de colisiones, sliding y gravedad
if ((bool)GuiController.Instance.Modifiers["Collisions"])
{
Vector3 realMovement = collisionManager.moveCharacter(characterSphere, movementVector, objetosColisionables);
personaje.move(realMovement);
//Cargar desplazamiento realizar en UserVar
GuiController.Instance.UserVars.setValue("Movement", TgcParserUtils.printVector3(realMovement));
GuiController.Instance.UserVars.setValue("ySign", realMovement.Y);
}
else
{
personaje.move(movementVector);
}
//Si estaba saltando y hubo colision de una superficie que mira hacia abajo, desactivar salto
if (jumping && collisionManager.Collision)
{
jumping = false;
}
//Hacer que la camara siga al personaje en su nueva posicion
GuiController.Instance.ThirdPersonCamera.Target = personaje.Position;
//Actualizar valores de la linea de movimiento
directionArrow.PStart = characterSphere.Center;
directionArrow.PEnd = characterSphere.Center + Vector3.Multiply(movementVector, 50);
directionArrow.updateValues();
//Actualizar valores de normal de colision
if (collisionManager.Collision)
{
collisionNormalArrow.PStart = collisionManager.LastCollisionPoint;
collisionNormalArrow.PEnd = collisionManager.LastCollisionPoint + Vector3.Multiply(collisionManager.LastCollisionNormal, 200);;
collisionNormalArrow.updateValues();
collisionNormalArrow.render();
collisionPoint.Position = collisionManager.LastCollisionPoint;
collisionPoint.render();
}
//Render de mallas
foreach (TgcMesh mesh in escenario.Meshes)
{
mesh.render();
}
//Render personaje
personaje.animateAndRender();
if (showBB)
{
characterSphere.render();
}
//Render linea
directionArrow.render();
//Render SkyBox
skyBox.render();
}
public void render()
{
skyBox.render();
}
public override void Render()
{
ClearTextures();
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
D3DDevice.Instance.Device.BeginScene();
var aspectRatio = D3DDevice.Instance.AspectRatio;
time += ElapsedTime;
if (TgcD3dInput.Instance.keyPressed(Key.C))
{
timer_preview = 0;
camara_rot = !camara_rot;
}
if (TgcD3dInput.Instance.keyPressed(Key.F))
{
if (tipo_vista == 1)
{
tipo_vista = 0;
}
else
{
tipo_vista = 1;
}
ant_vista = tipo_vista;
}
if (TgcD3dInput.Instance.keyPressed(Key.D))
{
if (tipo_vista == 2)
{
tipo_vista = ant_vista;
}
else
{
tipo_vista = 2;
}
}
if (TgcD3dInput.Instance.keyPressed(Key.Space))
{
if (vel_tanque <= 1)
{
vel_tanque = 10;
}
else
{
vel_tanque = 1;
}
}
if (timer_preview > 0)
{
timer_preview -= ElapsedTime;
if (timer_preview < 0)
{
timer_preview = 0;
}
}
// animar tanque
an_tanque -= ElapsedTime * Geometry.DegreeToRadian(vel_tanque);
var alfa = an_tanque;
var x0 = 2000f * (float)Math.Cos(alfa);
var z0 = 2000f * (float)Math.Sin(alfa);
float offset_rueda = 10;
var H = terrain.CalcularAltura(x0, z0) + alto_tanque / 2 - offset_rueda;
if (H < nivel_mar)
{
H = nivel_mar;
}
mesh.Position = new Vector3(x0, H, z0);
// direccion tangente sobre el piso:
var dir_tanque = new Vector2(-(float)Math.Sin(alfa), (float)Math.Cos(alfa));
dir_tanque.Normalize();
// Posicion de la parte de adelante del tanque
var pos2d = new Vector2(x0, z0);
pos2d = pos2d + dir_tanque * (largo_tanque / 2);
var H_frente = terrain.CalcularAltura(pos2d.X, pos2d.Y) + alto_tanque / 2 - offset_rueda;
if (H_frente < nivel_mar - 15)
{
H_frente = nivel_mar - 15;
}
var pos_frente = new Vector3(pos2d.X, H_frente, pos2d.Y);
var Vel = pos_frente - mesh.Position;
Vel.Normalize();
mesh.Transform = CalcularMatriz(mesh.Position, mesh.Scale, Vel);
// animo la canoa en circulos:
alfa = -time *Geometry.DegreeToRadian(10.0f);
x0 = 400f * (float)Math.Cos(alfa);
z0 = 400f * (float)Math.Sin(alfa);
canoa.Position = new Vector3(x0, 150, z0);
dir_canoa = new Vector3(-(float)Math.Sin(alfa), 0, (float)Math.Cos(alfa));
canoa.Transform = CalcularMatriz(canoa.Position, canoa.Scale, dir_canoa);
alfa_sol += ElapsedTime * Geometry.DegreeToRadian(1.0f);
if (alfa_sol > 2.5)
{
alfa_sol = 1.5f;
}
// animo la posicion del sol
//g_LightPos = new Vector3(1500f * (float)Math.Cos(alfa_sol), 1500f * (float)Math.Sin(alfa_sol), 0f);
g_LightPos = new Vector3(2000f * (float)Math.Cos(alfa_sol), 2000f * (float)Math.Sin(alfa_sol),
0f);
g_LightDir = -g_LightPos;
g_LightDir.Normalize();
if (timer_preview > 0)
{
var an = -time *Geometry.DegreeToRadian(10.0f);
LookFrom.X = 1500f * (float)Math.Sin(an);
LookFrom.Z = 1500f * (float)Math.Cos(an);
}
else
{
if (camara_rot)
{
CamaraRot.CameraCenter = mesh.BoundingBox.calculateBoxCenter();
CamaraRot.updateCamera(ElapsedTime); //FIXME, puede que no haga falta esto.
Camara = CamaraRot;
}
else
{
Camara = DefaultCamera;
}
}
// --------------------------------------------------------------------
D3DDevice.Instance.Device.EndScene();
if (g_pCubeMapAgua == null)
{
// solo la primera vez crea el env map del agua
CrearEnvMapAgua();
// ya que esta creado, se lo asigno al effecto:
effect.SetValue("g_txCubeMapAgua", g_pCubeMapAgua);
}
// Creo el env map del tanque:
var g_pCubeMap = new CubeTexture(D3DDevice.Instance.Device, 256, 1, Usage.RenderTarget,
Format.A16B16G16R16F, Pool.Default);
var pOldRT = D3DDevice.Instance.Device.GetRenderTarget(0);
// ojo: es fundamental que el fov sea de 90 grados.
// asi que re-genero la matriz de proyeccion
D3DDevice.Instance.Device.Transform.Projection =
Matrix.PerspectiveFovLH(Geometry.DegreeToRadian(90.0f), 1f, near_plane, far_plane);
// Genero las caras del enviroment map
for (var nFace = CubeMapFace.PositiveX; nFace <= CubeMapFace.NegativeZ; ++nFace)
{
var pFace = g_pCubeMap.GetCubeMapSurface(nFace, 0);
D3DDevice.Instance.Device.SetRenderTarget(0, pFace);
Vector3 Dir, VUP;
Color color;
switch (nFace)
{
default:
case CubeMapFace.PositiveX:
// Left
Dir = new Vector3(1, 0, 0);
VUP = new Vector3(0, 1, 0);
color = Color.Black;
break;
case CubeMapFace.NegativeX:
// Right
Dir = new Vector3(-1, 0, 0);
VUP = new Vector3(0, 1, 0);
color = Color.Red;
break;
case CubeMapFace.PositiveY:
// Up
Dir = new Vector3(0, 1, 0);
VUP = new Vector3(0, 0, -1);
color = Color.Gray;
break;
case CubeMapFace.NegativeY:
// Down
Dir = new Vector3(0, -1, 0);
VUP = new Vector3(0, 0, 1);
color = Color.Yellow;
break;
case CubeMapFace.PositiveZ:
// Front
Dir = new Vector3(0, 0, 1);
VUP = new Vector3(0, 1, 0);
color = Color.Green;
break;
case CubeMapFace.NegativeZ:
// Back
Dir = new Vector3(0, 0, -1);
VUP = new Vector3(0, 1, 0);
color = Color.Blue;
break;
}
//Obtener ViewMatrix haciendo un LookAt desde la posicion final anterior al centro de la camara
var Pos = mesh.Position;
D3DDevice.Instance.Device.Transform.View = Matrix.LookAtLH(Pos, Pos + Dir, VUP);
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, color, 1.0f, 0);
D3DDevice.Instance.Device.BeginScene();
//Renderizar
renderScene(ElapsedTime, true);
D3DDevice.Instance.Device.EndScene();
//string fname = string.Format("face{0:D}.bmp", nFace);
//SurfaceLoader.Save(fname, ImageFileFormat.Bmp, pFace);
}
// restuaro el render target
D3DDevice.Instance.Device.SetRenderTarget(0, pOldRT);
//TextureLoader.Save("test.bmp", ImageFileFormat.Bmp, g_pCubeMap);
//Genero el shadow map
RenderShadowMap();
// Restauro el estado de las transformaciones
if (timer_preview > 0)
{
D3DDevice.Instance.Device.Transform.View = Matrix.LookAtLH(LookFrom, LookAt, new Vector3(0, 1, 0));
}
else
{
D3DDevice.Instance.Device.Transform.View = Camara.getViewMatrix();
}
// TODO FIX IT! esto no se bien para que lo hace aca.
D3DDevice.Instance.Device.Transform.Projection =
Matrix.PerspectiveFovLH(Geometry.DegreeToRadian(45.0f),
aspectRatio, near_plane, far_plane);
// Cargo las var. del shader:
effect.SetValue("g_txCubeMap", g_pCubeMap);
effect.SetValue("fvLightPosition", new Vector4(0, 400, 0, 0));
effect.SetValue("fvEyePosition",
TgcParserUtils.vector3ToFloat3Array(timer_preview > 0
? LookFrom
: Camara.Position));
effect.SetValue("time", time);
// -----------------------------------------------------
// dibujo la escena pp dicha:
D3DDevice.Instance.Device.BeginScene();
if (tipo_vista != 1)
{
// con shaders :
if (tipo_vista == 2)
{
// dibujo en una vista:
D3DDevice.Instance.Device.Viewport = View1;
}
else
{
// dibujo en la pantalla completa
D3DDevice.Instance.Device.Viewport = ViewF;
}
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
// 1ero sin el agua
renderScene(ElapsedTime, false);
// Ahora dibujo el agua
D3DDevice.Instance.Device.RenderState.AlphaBlendEnable = true;
effect.SetValue("aux_Tex", terrain.terrainTexture);
// posicion de la canoa (divido por la escala)
effect.SetValue("canoa_x", x0 / 10.0f);
effect.SetValue("canoa_y", z0 / 10.0f);
piso.Technique = "RenderAgua";
piso.render();
}
if (tipo_vista != 0)
{
// sin shaders
if (tipo_vista == 2)
{
// dibujo en una vista:
D3DDevice.Instance.Device.Viewport = View2;
}
else
{
// dibujo en la pantalla completa
D3DDevice.Instance.Device.Viewport = ViewF;
}
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
//Renderizar terreno
terrain.render();
//Renderizar SkyBox
skyBox.render();
// dibujo el bosque
foreach (var instance in bosque)
{
instance.render();
}
// canoa
canoa.render();
// tanque
mesh.render();
// agua
var ant_src = D3DDevice.Instance.Device.RenderState.SourceBlend;
var ant_dest = D3DDevice.Instance.Device.RenderState.DestinationBlend;
var ant_alpha = D3DDevice.Instance.Device.RenderState.AlphaBlendEnable;
D3DDevice.Instance.Device.RenderState.AlphaBlendEnable = true;
D3DDevice.Instance.Device.RenderState.SourceBlend = Blend.SourceColor;
D3DDevice.Instance.Device.RenderState.DestinationBlend = Blend.InvSourceColor;
piso.render();
D3DDevice.Instance.Device.RenderState.SourceBlend = ant_src;
D3DDevice.Instance.Device.RenderState.DestinationBlend = ant_dest;
D3DDevice.Instance.Device.RenderState.AlphaBlendEnable = ant_alpha;
}
g_pCubeMap.Dispose();
RenderFPS();
RenderAxis();
D3DDevice.Instance.Device.EndScene();
D3DDevice.Instance.Device.Present();
}
/// <summary>
/// Método que se llama cada vez que hay que refrescar la pantalla.
/// Escribir aquí todo el código referido al renderizado.
/// Borrar todo lo que no haga falta
/// </summary>
/// <param name="elapsedTime">Tiempo en segundos transcurridos desde el último frame</param>
public override void render(float elapsedTime)
{
//Device de DirectX para renderizar
Device d3dDevice = GuiController.Instance.D3dDevice;
//sonido
sound_a.render();
///UPDATE de logica/////////////////////////////
//Objetos
water.update(elapsedTime);
foreach (C_Hoja x in hojas)
{
if (x.update(elapsedTime, 550))
{
x.reset();
}
}
ball.update(elapsedTime, hojas, earth, earth2, water, skyBox);
//Camara
GuiController.Instance.ThirdPersonCamera.Target = ball.pos;
if (ball.rotation != 0)
{
GuiController.Instance.ThirdPersonCamera.rotateY(-ball.rotation * 100f);
}
ball.rotation = 0;
//Variables
GuiController.Instance.UserVars.setValue("posX", ball.pos.X);
GuiController.Instance.UserVars.setValue("posY", ball.pos.Y);
GuiController.Instance.UserVars.setValue("posZ", ball.pos.Z);
GuiController.Instance.UserVars.setValue("Dying", ball.dieing?1f:0f);
///RENDER//////////////////
//actualizar las variables de los shaders
updateShaderVars();
//Finalizar escena y guardar superficie de render
Surface pOldScreen = d3dDevice.GetRenderTarget(0);
d3dDevice.EndScene();
//Dibuja el enviromental map
renderEnvMap();
ball.mesh.Effect.SetValue("xCubeTex", g_pCubeMap);
//Dibuja el reflejo del agua
renderWaterReflex();
//Por alguna razon, sin esto, no se ve el enviromental map en la bola ??
d3dDevice.BeginScene();
ball.ex_render(false);
d3dDevice.EndScene();
//Actualizar camara y frustrum
GuiController.Instance.CurrentCamera.updateViewMatrix(d3dDevice);
GuiController.Instance.Frustum.updateVolume(d3dDevice.Transform.View, d3dDevice.Transform.Projection);
//como las matrices de view y proj cambian, tengo que actualizarlas
ball.mesh.Effect.SetValue("xViewProj", d3dDevice.Transform.View * d3dDevice.Transform.Projection);
//renderizo la escena
d3dDevice.SetRenderTarget(0, pOldScreen);
d3dDevice.Clear(ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
d3dDevice.BeginScene();
bool draw_boxes = (bool)GuiController.Instance.Modifiers.getValue("drawBoxes");
ball.ex_render(draw_boxes);
earth.ex_render(draw_boxes);
earth2.ex_render(draw_boxes);
water.ex_render(draw_boxes);
foreach (C_Hoja x in hojas)
{
x.ex_render(draw_boxes);
}
skyBox.render();
}
public void render(float time)
{
d3dDevice.RenderState.AlphaBlendEnable = false;
skyBox.render();
sonido.render(time);
sonido2.render(time);
bool showQuadtree = (bool)GuiController.Instance.Modifiers["showQuadtree"];
bool showTerrain = (bool)GuiController.Instance.Modifiers["showTerrain"];
if (showTerrain)
{
foreach (TgcMesh mesh in terrenoMesh)
{
mesh.render();
}
}
bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
bool frustumCullingEnabled = (bool)GuiController.Instance.Modifiers["culling"];
bool disparando = ControladorJuego.getInstance().personaje.cDisparando;
Vector3 lightPosition = ControladorJuego.getInstance().personaje.disparo.PosicionActual;
Vector3 initialPosition = ControladorJuego.getInstance().personaje.disparo.getPosicionInicial();
//solo aplico shader cuando estoy a cierta distancia del disparo y este existe
Vector3 posicionDisparo = ControladorJuego.getInstance().personaje.disparo.PosicionActual;
quadtree.render(GuiController.Instance.Frustum, showQuadtree);
//Analizar cada malla contra el Frustum - con fuerza bruta
int totalMeshes = 0;
foreach (TgcMeshShader mesh in terreno.Meshes)
{
if (disparando /*&& calcularDistancia(mesh.Position ,posicionDisparo) >500*/)
{
//Cargar variables de shader globales a todos los objetos
mesh.Effect.SetValue("fvLightPosition", TgcParserUtils.vector3ToFloat3Array(lightPosition));
mesh.Effect.SetValue("fvEyePosition", TgcParserUtils.vector3ToFloat3Array(initialPosition));
mesh.Effect.SetValue("fvAmbient", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["AmbientColor"]));
mesh.Effect.SetValue("fvDiffuse", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["DiffuseColor"]));
mesh.Effect.SetValue("fvSpecular", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["SpecularColor"]));
mesh.Effect.SetValue("fSpecularPower", (float)GuiController.Instance.Modifiers["SpecularPower"]);
}
mesh.render();
}
//Render meshes
if (showBB)
{
foreach (TgcMesh mesh in terreno.Meshes)
{
mesh.BoundingBox.render();
}
}
camera.Acercar();
//foreach (TgcMesh mesh in meshes2)
//{
// mesh.render();
//}
//foreach (TgcMesh mesh in meshes3)
//{
// mesh.render();
//}
}
public void renderScene(String technique)
{
Device device = GuiController.Instance.D3dDevice;
// Render Skybox
skyBox.render();
// Render Edificios
// -----------------------------------------------------------------------
Random rnd = new Random(1);
float r0 = R + 22;
float r1 = R - 22;
for (int i = 0; i < cant_edificios; ++i)
{
float an = 2.0f * (float)Math.PI * (float)i / (float)cant_edificios;
float h0 = rnd.Next(10, 40);
float h1 = rnd.Next(10, 40);
if (an >= an_actual && an <= an_actual + 0.5f)
{
int t = (2 * i) % CANT_MODELOS;
edicios[t].Transform = Matrix.Scaling(15, h0, 15) *
Matrix.RotationYawPitchRoll(an, 0, 0) *
Matrix.Translation(r0 * (float)Math.Sin(an), h0 / 2, r0 * (float)Math.Cos(an));
edicios[t].Technique = technique;
edicios[t].render();
t = (2 * i + 1) % CANT_MODELOS;
edicios[t].Transform = Matrix.Scaling(15, h1, 15) *
Matrix.RotationYawPitchRoll(an, 0, 0) *
Matrix.Translation(r1 * (float)Math.Sin(an), h1 / 2, r1 * (float)Math.Cos(an));
edicios[t].Technique = technique;
edicios[t].render();
}
}
// Render ruta
// -----------------------------------------------------------------------
GuiController.Instance.Shaders.setShaderMatrixIdentity(effect);
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, vb, 0);
effect.SetValue("texDiffuseMap", textura_piso);
int numPasses = effect.Begin(0);
for (int n = 0; n < numPasses; n++)
{
effect.BeginPass(n);
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2 * (cant_ptos_ruta - 1));
effect.EndPass();
}
effect.End();
arbol.Effect = effect;
arbol.Technique = technique;
int cant_arboles = 200;
r0 = R + 10;
r1 = R - 10;
for (int i = 0; i < cant_arboles; ++i)
{
float an = 2.0f * (float)Math.PI * (float)i / (float)cant_arboles;
if (an >= an_actual && an <= an_actual + 0.5f)
{
arbol.Position = new Vector3(r1 * (float)Math.Sin(an), -2, r1 * (float)Math.Cos(an));
arbol.render();
arbol.Position = new Vector3(r0 * (float)Math.Sin(an), -2, r0 * (float)Math.Cos(an));
arbol.render();
}
}
}