public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
Vector3 start = (Vector3)GuiController.Instance.Modifiers["start"];
Vector3 end = (Vector3)GuiController.Instance.Modifiers["end"];
float thickness = (float)GuiController.Instance.Modifiers["thickness"];
Vector2 headSize = (Vector2)GuiController.Instance.Modifiers["headSize"];
Color bodyColor = (Color)GuiController.Instance.Modifiers["bodyColor"];
Color headColor = (Color)GuiController.Instance.Modifiers["headColor"];
//Cargar valores de la flecha
arrow.PStart = start;
arrow.PEnd = end;
arrow.Thickness = thickness;
arrow.HeadSize = headSize;
arrow.BodyColor = bodyColor;
arrow.HeadColor = headColor;
//Actualizar valores para hacerlos efectivos
arrow.updateValues();
//Render
arrow.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()
{
PreRender();
var start = (Vector3)Modifiers["start"];
var end = (Vector3)Modifiers["end"];
var thickness = (float)Modifiers["thickness"];
var headSize = (Vector2)Modifiers["headSize"];
var bodyColor = (Color)Modifiers["bodyColor"];
var headColor = (Color)Modifiers["headColor"];
//Cargar valores de la flecha
arrow.PStart = start;
arrow.PEnd = end;
arrow.Thickness = thickness;
arrow.HeadSize = headSize;
arrow.BodyColor = bodyColor;
arrow.HeadColor = headColor;
//Actualizar valores para hacerlos efectivos
arrow.updateValues();
//Render
arrow.render();
PostRender();
}
/// <summary>
/// rendereo.
/// </summary>
public void Render()
{
AplicarShader(); //para que cambie de color al meter nitro
directionArrow.render();
Mesh.render();
RuedasDelanteras.Render();
RuedasTraseras.Render();
//RuedaMainMesh.render();
/*if (RenderLuces)
* Luces.Update();*/
if (motionBlur != null && finishedLoading)
{
motionBlur.Render();
}
if (tInicioHumo < tFinHumo)
{
humoChoque.Render(false); //si es momento de choque, muestro humito
}
tInicioHumo = tInicioHumo + GameModel.ElapsedTime;
//escenario.BoundingBox.render();
//if (pintarObb)
// obb.render();
//foreach (var mesh in ciudadScene.Meshes)
//{
// //mesh.BoundingBox.render();
//}
humoEscape.Render(nitroActivado);
}
override public void render()
{
if ((bool)GuiController.Instance.Modifiers.getValue("normales"))
{
normalDibujable.render();
}
base.render();
}
public override void Render()
{
PreRender();
//Render
arrow.render();
box.render();
PostRender();
}
public override void Render()
{
PreRender();
quad.render();
if ((bool)Modifiers["showNormal"])
{
normalArrow.render();
}
PostRender();
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
bool showNormal = (bool)GuiController.Instance.Modifiers["showNormal"];
//Actualizar parametros de la caja
updateQuad(showNormal);
quad.render();
if (showNormal)
{
normalArrow.render();
}
}
public override void Render()
{
PreRender();
var showNormal = (bool)Modifiers["showNormal"];
//Actualizar parametros de la caja
updateQuad(showNormal);
quad.render();
if (showNormal)
{
normalArrow.render();
}
PostRender();
}
public override void Render()
{
ClearTextures();
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
D3DDevice.Instance.Device.BeginScene();
time += ElapsedTime;
// animo la pos del avion
var alfa = -time *Geometry.DegreeToRadian(15.0f);
avion.Position = new Vector3(80f * (float)Math.Cos(alfa), 40 - 20 * (float)Math.Sin(alfa),
80f * (float)Math.Sin(alfa));
dir_avion = new Vector3(-(float)Math.Sin(alfa), 0, (float)Math.Cos(alfa));
avion.Transform = CalcularMatriz(avion.Position, avion.Scale, dir_avion);
g_LightPos = (Vector3)Modifiers["LightLookFrom"];
g_LightDir = (Vector3)Modifiers["LightLookAt"] - g_LightPos;
g_LightDir.Normalize();
arrow.PStart = g_LightPos;
arrow.PEnd = g_LightPos + g_LightDir * 20;
// Shadow maps:
D3DDevice.Instance.Device.EndScene(); // termino el thread anterior
Camara.UpdateCamera(ElapsedTime);
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
//Genero el shadow map
RenderShadowMap();
D3DDevice.Instance.Device.BeginScene();
// dibujo la escena pp dicha
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
RenderScene(false);
//Cargar valores de la flecha
arrow.render();
D3DDevice.Instance.Device.EndScene();
D3DDevice.Instance.Device.Present();
}
public override void render(float elapsedTime)
{
Device device = GuiController.Instance.D3dDevice;
Control panel3d = GuiController.Instance.Panel3d;
float aspectRatio = (float)panel3d.Width / (float)panel3d.Height;
time += elapsedTime;
// animo la pos del avion
float alfa = -time *Geometry.DegreeToRadian(15.0f);
avion.Position = new Vector3(80f * (float)Math.Cos(alfa), 40 - 20 * (float)Math.Sin(alfa), 80f * (float)Math.Sin(alfa));
dir_avion = new Vector3(-(float)Math.Sin(alfa), 0, (float)Math.Cos(alfa));
avion.Transform = CalcularMatriz(avion.Position, avion.Scale, dir_avion);
g_LightPos = (Vector3)GuiController.Instance.Modifiers["LightLookFrom"];
g_LightDir = (Vector3)GuiController.Instance.Modifiers["LightLookAt"] - g_LightPos;
g_LightDir.Normalize();
arrow.PStart = g_LightPos;
arrow.PEnd = g_LightPos + g_LightDir * 20;
// Shadow maps:
device.EndScene(); // termino el thread anterior
GuiController.Instance.RotCamera.CameraCenter = new Vector3(0, 0, 0);
GuiController.Instance.RotCamera.CameraDistance = 100;
GuiController.Instance.RotCamera.RotationSpeed = 2f;
GuiController.Instance.CurrentCamera.updateCamera();
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
//Genero el shadow map
RenderShadowMap();
device.BeginScene();
// dibujo la escena pp dicha
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
RenderScene(false);
//Cargar valores de la flecha
arrow.render();
}
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(float elapsedTime)
{
TgcD3dInput d3dInput = GuiController.Instance.D3dInput;
//Calcular proxima posicion de personaje segun Input
float moveForward = 0f;
float rotate = 0;
float jump = 0;
bool moving = false;
bool rotating = false;
bool running = false;
bool jumping = false;
string animationAction = "StandBy";
//obtener velocidades de Modifiers (no deberia estar porque es fijo)
float velocidadCaminar = (float)GuiController.Instance.Modifiers.getValue("VelocidadCaminar");
float velocidadRotacion = (float)GuiController.Instance.Modifiers.getValue("VelocidadRotacion");
//Obtener boolean para saber si hay que mostrar Bounding Box (tampoco deberia estar)
bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
//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))// || d3dInput.XposRelative > 0)
{
rotate = velocidadRotacion;
rotating = true;
}
//Izquierda
if (d3dInput.keyDown(Key.A))// || d3dInput.XposRelative < 0)
{
rotate = -velocidadRotacion;
rotating = true;
}
//Jump
if (d3dInput.keyDown(Key.Space))
{
jump = 30;
moving = true;
}
//Run
if (d3dInput.keyDown(Key.LeftShift))
{
running = true;
moveForward *= 1.5f;
}
if (d3dInput.keyDown(Key.E))
{
animationAction = "Talk";
}
//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
if (running)
{
personaje.playAnimation("Run", true);
}
else if (jumping)
{
personaje.playAnimation("Jump", true);
}
else
{
personaje.playAnimation("Walk", true);
}
}
//Si no se esta moviendo, activar animationAction
else
{
personaje.playAnimation(animationAction, 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);
//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));
//Render linea
if (renderDirectionArrow)
{
directionArrow.render();
}
//Render personaje
personaje.animateAndRender();
if (showBB)
{
characterSphere.render();
}
}
public void render(float elapsedTime)
{
//moverse y rotar son variables que me indican a qué velocidad se moverá o rotará el mesh respectivamente.
//Se inicializan en 0, porque por defecto está quieto.
float moverse = 0f;
float rotar = 0f;
habilitarDecremento = true;
GuiController.Instance.UserVars.setValue("Velocidad", Math.Abs(auto.velocidadActual));
GuiController.Instance.UserVars.setValue("Vida", escalaVida.X);
GuiController.Instance.UserVars.setValue("AngCol", Geometry.RadianToDegree(anguloColision));
GuiController.Instance.UserVars.setValue("AngRot", Geometry.RadianToDegree(anguloARotar));
//aumento de la velocidad de rotacion al derrapar
modificarVelocidadRotacion(auto);
//Procesa las entradas del teclado.
if (entrada.keyDown(Key.Q))
{
finDeJuego = true;
salirConQ = true;
}
if (entrada.keyDown(Key.S))
{
moverse = auto.irParaAtras(elapsedTime);
}
if (entrada.keyDown(Key.W))
{
moverse = auto.irParaAdelante(elapsedTime);
}
if (entrada.keyDown(Key.A) && (auto.velocidadActual > 0.5f || auto.velocidadActual < -0.5f)) //izquierda
{
rotar = -auto.velocidadRotacion;
}
if (entrada.keyDown(Key.D) && (auto.velocidadActual > 0.5f || auto.velocidadActual < -0.5f)) //derecha
{
rotar = auto.velocidadRotacion;
}
if (entrada.keyPressed(Key.M))
{
musica.muteUnmute();
auto.mutearSonido();
}
if (entrada.keyPressed(Key.R)) //boton de reset, el mesh vuelve a la posicion de inicio y restaura todos sus parametros
{
auto.reiniciar();
auto.mesh.move(new Vector3(0, 0, -3100));
auto.mesh.rotateY(-1.57f);
EjemploAlumno.instance.activar_efecto = false;
nivel.reiniciar();
this.reiniciar();
GuiController.Instance.ThirdPersonCamera.resetValues();
GuiController.Instance.ThirdPersonCamera.rotateY(-1.57f);
}
if (entrada.keyPressed(Key.B)) //Modo debug para visualizar BoundingBoxes entre otras cosas que nos sirvan a nosotros
{
Shared.debugMode = !Shared.debugMode;
}
if (entrada.keyPressed(Key.I))
{
modoDios = !modoDios;
}
//Frenado por inercia
if (!entrada.keyDown(Key.W) && !entrada.keyDown(Key.S) && auto.velocidadActual != 0)
{
moverse = auto.frenarPorInercia(elapsedTime);
}
if (moverse > auto.velocidadMaxima)
{
auto.velocidadActual = auto.velocidadMaxima;
}
if (moverse < (-auto.velocidadMaxima))
{
auto.velocidadActual = -auto.velocidadMaxima;
}
int sentidoRotacion = 0; //sentido de rotacion del reajuste de camara
float rotCamara = GuiController.Instance.ThirdPersonCamera.RotationY;
float rotAuto = auto.mesh.Rotation.Y;
float deltaRotacion = rotAuto - rotCamara;
float dif = FastMath.Abs(Geometry.RadianToDegree(deltaRotacion));
float rapidez = 5f; //aceleracion de reajuste de camara
if (rotar != 0)
{
habilitarDecremento = false;
habilitarContador = true;
}
if (dif < 40)
{
if (dif < 30)
{
if (dif < 20)
{
rapidez = 0.8f;
}
else
{
rapidez = 2f;
}
}
else
{
rapidez = 3f;
}
}
if (habilitarContador)
{
pasaronSegundos += elapsedTime;
}
if (deltaRotacion < 0)
{
sentidoRotacion = -1;
}
else
{
sentidoRotacion = 1;
}
if (deltaRotacion != 0 && pasaronSegundos > 0.5f)
{
ajustar = true;
pasaronSegundos = 0f;
habilitarContador = false;
}
float rotAngle = Geometry.DegreeToRadian(rotar * elapsedTime);
if (ajustar)
{
GuiController.Instance.ThirdPersonCamera.rotateY(sentidoRotacion * rapidez * elapsedTime);
}
if (deltaRotacion < 0)
{
sentidoRotacion = -1;
}
else
{
sentidoRotacion = 1;
}
incrementarTiempo(this, elapsedTime, habilitarDecremento);
auto.mesh.rotateY(rotAngle);
auto.obb.rotate(new Vector3(0, rotAngle, 0));
if (FastMath.Abs(Geometry.RadianToDegree(deltaRotacion)) % 360 < 3)
{
GuiController.Instance.ThirdPersonCamera.RotationY = rotAuto;
ajustar = false;
}
if (habilitarDecremento)
{
incrementarTiempo(this, elapsedTime, habilitarDecremento);
}
if (moverse != 0 || auto.velocidadActual != 0) //Si hubo movimiento
{
Vector3 lastPos = auto.mesh.Position;
auto.mesh.moveOrientedY(moverse * elapsedTime);
Vector3 position = auto.mesh.Position;
Vector3 posDiff = position - lastPos;
auto.obb.move(posDiff);
Vector3 direccion = new Vector3(FastMath.Sin(auto.mesh.Rotation.Y) * moverse, 0, FastMath.Cos(auto.mesh.Rotation.Y) * moverse);
auto.direccion.PEnd = auto.obb.Center + Vector3.Multiply(direccion, 50f);
//Detectar colisiones de BoundingBox utilizando herramienta TgcCollisionUtils
bool collide = false;
Vector3[] cornersAuto;
Vector3[] cornersObstaculo;
foreach (ObstaculoRigido obstaculo in nivel.obstaculos)
{
if (Colisiones.testObbObb2(auto.obb, obstaculo.obb)) //chequeo obstáculo por obstáculo si está chocando con auto
{
collide = true;
obstaculoChocado = obstaculo;
Shared.mostrarChispa = true;
if (FastMath.Abs(auto.velocidadActual) > 800)
{
auto.reproducirSonidoChoque(FastMath.Abs(auto.velocidadActual));
auto.deformarMesh(obstaculo.obb, FastMath.Abs(auto.velocidadActual));
}
if (FastMath.Abs(auto.velocidadActual) > 800 && !modoDios)
{
escalaVida.X -= 0.00003f * Math.Abs(auto.velocidadActual) * escalaInicial.X;
if (escalaVida.X > 0.03f)
{
vida.setEscala(new Vector2(escalaVida.X, escalaVida.Y));
}
else
{
finDeJuego = true;
muerte = true;
}
}
break;
}
}
//Si hubo colision, restaurar la posicion anterior (sino sigo de largo)
if (collide)
{
auto.mesh.Position = lastPos;
auto.obb.updateValues();
moverse = auto.chocar(elapsedTime);
if (FastMath.Abs(auto.velocidadActual) > 0)
{
cornersAuto = CalculosVectores.computeCorners(auto);
cornersObstaculo = CalculosVectores.computeCorners(obstaculoChocado);
List <Plane> carasDelObstaculo = CalculosVectores.generarCaras(cornersObstaculo);
Vector3 NormalAuto = direccion;
caraChocada = CalculosVectores.detectarCaraChocada(carasDelObstaculo, auto.puntoChoque);
Vector3 NormalObstaculo = new Vector3(caraChocada.A, caraChocada.B, caraChocada.C);
GuiController.Instance.UserVars.setValue("NormalObstaculoX", NormalObstaculo.X);
GuiController.Instance.UserVars.setValue("NormalObstaculoZ", NormalObstaculo.Z);
float desplazamientoInfinitesimal = 5f;
float constanteDesvio = 1.3f;
//Calculo el angulo entre ambos vectores
anguloColision = CalculosVectores.calcularAnguloEntreVectoresNormalizados(NormalAuto, NormalObstaculo);//Angulo entre ambos vectores
//rota mesh
if (FastMath.Abs(auto.velocidadActual) > 800)
{
if (Geometry.RadianToDegree(anguloColision) < 25) //dado un cierto umbral, el coche rebota sin cambiar su direccion
{
auto.velocidadActual = -auto.velocidadActual;
}
else //el coche choca y cambia su direccion
{
if (NormalObstaculo.Z > 0 && direccion.X > 0 && direccion.Z > 0)
{
anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(0, 0, -10));
colorDeColision = Color.Red;
}
if (NormalObstaculo.X > 0 && direccion.X > 0 && direccion.Z > 0)
{
anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(-5, 0, 0));
colorDeColision = Color.Salmon;
}
if (NormalObstaculo.X > 0 && direccion.X > 0 && direccion.Z < 0)
{
anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
colorDeColision = Color.Blue;
auto.mesh.move(new Vector3(-desplazamientoInfinitesimal, 0, 0));
}
if (NormalObstaculo.Z < 0 && direccion.X > 0 && direccion.Z < 0)
{
anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(0, 0, desplazamientoInfinitesimal));
colorDeColision = Color.Green;
}
if (NormalObstaculo.Z < 0 && direccion.X < 0 && direccion.Z < 0)
{
anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(0, 0, desplazamientoInfinitesimal));
colorDeColision = Color.Pink;
}
if (NormalObstaculo.X < 0 && direccion.X < 0 && direccion.Z < 0)
{
anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(desplazamientoInfinitesimal, 0, 0));
colorDeColision = Color.Silver;
}
if (NormalObstaculo.X < 0 && direccion.X < 0 && direccion.Z > 0)
{
anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(desplazamientoInfinitesimal, 0, 0));
colorDeColision = Color.Aquamarine;
}
if (NormalObstaculo.Z > 0 && direccion.X < 0 && direccion.Z > 0)
{
anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(0, 0, -desplazamientoInfinitesimal));
colorDeColision = Color.Yellow;
}
auto.mesh.rotateY(anguloARotar);
}
}
}
}
foreach (Recursos recurso in nivel.recursos)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(auto.mesh.BoundingBox, recurso.modelo.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
nivel.recursos.Remove(recurso); //Saca el recurso de la lista para que no se renderice más
float puntos = Convert.ToSingle(this.puntos.Text) + 100f;
this.puntos.Text = Convert.ToString(puntos);
break;
}
}
//Chequeo si el auto agarro el checkpoint actual
if (Colisiones.testObbObb2(auto.obb, nivel.checkpointActual.obb))
{
if (nivel.checkpointsRestantes.Text != "1")
{
nivel.checkpoints.Remove(nivel.checkpointActual); //Saca el checkpoint de la lista para que no se renderice más
int restantes = (Convert.ToInt16(nivel.checkpointsRestantes.Text) - 1);
nivel.checkpointsRestantes.Text = restantes.ToString(); //Le resto uno a los restantes
this.tiempoRestante.Text = (Convert.ToSingle(this.tiempoRestante.Text) + 10f).ToString();
nivel.checkpointActual = nivel.checkpoints.ElementAt(0);
}
else
{
finDeJuego = true;
}
}
//Efecto blur
if (FastMath.Abs(auto.velocidadActual) > (auto.velocidadMaxima * 0.5555))
{
EjemploAlumno.instance.activar_efecto = true;
EjemploAlumno.instance.blur_intensity = 0.003f * (float)Math.Round(FastMath.Abs(auto.velocidadActual) / (auto.velocidadMaxima), 5);
}
else
{
EjemploAlumno.instance.activar_efecto = false;
}
}
GuiController.Instance.ThirdPersonCamera.Target = auto.mesh.Position;
//actualizo cam
Vector2 vectorCam = (Vector2)GuiController.Instance.Modifiers["AlturaCamara"];
GuiController.Instance.ThirdPersonCamera.setCamera(auto.mesh.Position, vectorCam.X, vectorCam.Y);
float tope = 1f;
float constanteDerrape = ((tiempoTrans / 2) < tope) ? (tiempoTrans / 2) : tope;
float proporcion = FastMath.Abs(auto.velocidadActual / auto.velocidadMaxima);
if (sentidoAnterior != sentidoRotacion && tiempoTrans != 0)
{
incrementarTiempo(this, elapsedTime * 5, true);
}
if (tiempoTrans == 0)
{
sentidoAnterior = sentidoRotacion;
}
auto.mesh.rotateY(constanteDerrape * sentidoAnterior * proporcion);
auto.render();
auto.obb = TgcObb.computeFromAABB(auto.mesh.BoundingBox);
auto.obb.setRotation(auto.mesh.Rotation);
auto.obb.setRenderColor(colorDeColision);
auto.mesh.rotateY(-constanteDerrape * sentidoAnterior * proporcion);
//dibuja el nivel
nivel.render(elapsedTime);
//AJUSTE DE CAMARA SEGUN COLISION
ajustarCamaraSegunColision(auto, nivel.obstaculos);
//Dibujo checkpoints restantes
nivel.checkpointsRestantes.render();
//Dibujo el puntaje del juego
this.puntos.render();
//CUENTA REGRESIVA
if (this.tiempoRestante.Text == "1")
{
uno.render();
}
if (this.tiempoRestante.Text == "2")
{
dos.render();
}
if (this.tiempoRestante.Text == "3")
{
tres.render();
}
//Actualizo y dibujo el relops
if ((DateTime.Now.Subtract(this.horaInicio).TotalSeconds) > segundosAuxiliares && !modoDios)
{
this.tiempoRestante.Text = (Convert.ToDouble(tiempoRestante.Text) - 1).ToString();
if (this.tiempoRestante.Text == "0") //Si se acaba el tiempo, me muestra el game over y reseetea todo
{
finDeJuego = true;
muerte = true;
}
segundosAuxiliares++;
}
this.tiempoRestante.render();
//Si se le acabo el tiempo o la vida, o apretó "Q"
if (finDeJuego)
{
//corta la música al salir
TgcMp3Player player = GuiController.Instance.Mp3Player;
player.closeFile();
GuiController.Instance.UserVars.clearVars();
//saca el blur
EjemploAlumno.instance.activar_efecto = false;
//reinicia los valores de las cosas del juego
auto.reiniciar();
nivel.reiniciar();
this.reiniciar();
//reinicia la camara
GuiController.Instance.ThirdPersonCamera.resetValues();
if (muerte)
{
EjemploAlu.setPantalla(EjemploAlu.getPantalla(1));
}
else if (salirConQ)
{
EjemploAlumno.getInstance().setPantalla(new PantallaInicio());
}
else
{
EjemploAlu.setPantalla(EjemploAlu.getPantalla(2));
}
}
if (comienzoNivel)
{
if (DateTime.Now.Subtract(this.horaInicio).TotalSeconds < 3)
{
if (auto.nombre == "Luigi")
{
misionLuigi.render();
}
else
{
misionMario.render();
}
}
else
{
comienzoNivel = false;
}
}
else
{
//Dibujo barrita
if (auto.nombre == "Luigi")
{
barra2.render();
}
else
{
barra.render();
}
vida.render();
}
//renderizo utilidades del debugMode
if (Shared.debugMode)
{
Vector2 vectorModifier = (Vector2)GuiController.Instance.Modifiers["PosicionFlechaDebug"];
Vector3 vectorPosicion = new Vector3(vectorModifier.X, 10, vectorModifier.Y);
debugArrow.PStart = vectorPosicion + new Vector3(0, 400f, 0);
debugArrow.PEnd = vectorPosicion;
debugArrow.updateValues();
debugArrow.render();
//renderizo normal al plano chocado
if (obstaculoChocado != null)
{
collisionNormalArrow.PStart = obstaculoChocado.obb.Center;
collisionNormalArrow.PEnd = obstaculoChocado.obb.Center + Vector3.Multiply(new Vector3(caraChocada.A, caraChocada.B, caraChocada.C), 500f);
collisionNormalArrow.updateValues();
collisionNormalArrow.render();
}
}
}
public void renderConEfectos(float elapsedTime)
{
var device = D3DDevice.Instance.Device;
// dibujo la escena una textura
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();
//Dibujamos todos los meshes del escenario
renderScene(elapsedTime, "DefaultTechnique");
//Render personames enemigos
foreach (var m in enemigos)
{
m.render();
}
device.EndScene();
pSurf.Dispose();
// dibujo el glow map
effect.Technique = "DefaultTechnique";
pSurf = g_pGlowMap.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
device.BeginScene();
//Dibujamos SOLO los meshes que tienen glow brillantes
//Render personaje brillante
//Render personames enemigos
foreach (var m in enemigos)
{
m.render();
}
if (TgcD3dInput.Instance.keyDown(Key.F))
{
for (var i = 0; i < cant_balas; ++i)
{
if (timer_firing[i] > 0)
{
var bala = new TgcArrow();
bala.PStart = pos_bala[i];
bala.PEnd = pos_bala[i] + dir_bala[i] * 3;
bala.Thickness = 0.05f;
bala.HeadSize = new Vector2(0.01f, 0.01f);
bala.Effect = effect;
bala.Technique = "DefaultTechnique";
bala.updateValues();
bala.render();
}
}
}
// El resto opacos
renderScene(elapsedTime, "DibujarObjetosOscuros");
device.EndScene();
pSurf.Dispose();
// Hago un blur sobre el glow map
// 1er pasada: downfilter x 4
// -----------------------------------------------------
pSurf = g_pRenderTarget4.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
device.BeginScene();
effect.Technique = "DownFilter4";
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, g_pVBV3D, 0);
effect.SetValue("g_RenderTarget", g_pGlowMap);
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();
pSurf.Dispose();
device.EndScene();
device.DepthStencilSurface = pOldDS;
// Pasadas de blur
for (var P = 0; P < cant_pasadas; ++P)
{
// Gaussian blur Horizontal
// -----------------------------------------------------
pSurf = g_pRenderTarget4Aux.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
// dibujo el quad pp dicho :
device.BeginScene();
effect.Technique = "GaussianBlurSeparable";
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, g_pVBV3D, 0);
effect.SetValue("g_RenderTarget", g_pRenderTarget4);
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();
pSurf.Dispose();
device.EndScene();
pSurf = g_pRenderTarget4.GetSurfaceLevel(0);
device.SetRenderTarget(0, pSurf);
pSurf.Dispose();
// Gaussian blur Vertical
// -----------------------------------------------------
device.BeginScene();
effect.Technique = "GaussianBlurSeparable";
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, g_pVBV3D, 0);
effect.SetValue("g_RenderTarget", g_pRenderTarget4Aux);
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
effect.Begin(FX.None);
effect.BeginPass(1);
device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.EndPass();
effect.End();
device.EndScene();
}
// To Gray Scale
// -----------------------------------------------------
// Ultima pasada vertical va sobre la pantalla pp dicha
device.SetRenderTarget(0, pOldRT);
//pSurf = g_pRenderTarget4Aux.GetSurfaceLevel(0);
//device.SetRenderTarget(0, pSurf);
device.BeginScene();
effect.Technique = "GrayScale";
device.VertexFormat = CustomVertex.PositionTextured.Format;
device.SetStreamSource(0, g_pVBV3D, 0);
effect.SetValue("g_RenderTarget", g_pRenderTarget);
effect.SetValue("g_GlowMap", g_pRenderTarget4Aux);
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();
device.EndScene();
}
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 void render(float elapsedTime)
{
TgcD3dInput d3dInput = GuiController.Instance.D3dInput;
//Calcular proxima posicion de personaje segun Input
float moveForward = 0f;
float moveSide = 0f;
float rotateY = 0;
float rotateX = 0;
float jump = 0;
bool moving = false;
bool rotating = false;
bool rotatingY = false;
bool rotatingX = false;
bool running = false;
bool jumping = false;
string animationAction = "StandBy";
TgcSprite mira;
//Crear Sprite de mira
mira = new TgcSprite();
mira.Texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "\\Kamikaze3D\\mira.png");
//Ubicarlo centrado en la pantalla
Size screenSize = GuiController.Instance.Panel3d.Size;
Size textureSize = mira.Texture.Size;
mira.Position = new Vector2(screenSize.Width / 2 - textureSize.Width / 2, screenSize.Height / 2 - textureSize.Height / 2);
TgcText2d hitCantTextY = new TgcText2d();
hitCantTextY.Position = new Point(0, 0);
hitCantTextY.Color = Color.White;
TgcText2d hitCantTextX = new TgcText2d();
hitCantTextX.Position = new Point(0, 20);
hitCantTextX.Color = Color.White;
//obtener velocidades de Modifiers (no deberia estar porque es fijo)
float velocidadCaminar = (float)GuiController.Instance.Modifiers.getValue("VelocidadCaminar");
//float velocidadMoveSide = (float)GuiController.Instance.Modifiers.getValue("velocidadMoveSide");
float velocidadRotacion = (float)GuiController.Instance.Modifiers.getValue("VelocidadRotacion");
//Obtener boolean para saber si hay que mostrar Bounding Box (tampoco deberia estar)
bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
//Adelante
if (d3dInput.keyDown(Key.W))
{
moveForward = -velocidadCaminar;
moving = true;
}
//Atras
if (d3dInput.keyDown(Key.S))
{
moveForward = velocidadCaminar;
moving = true;
}
//Derecha
if (d3dInput.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT) && d3dInput.XposRelative > 0)
{
if (camara.RotationY < (Math.PI))
{
rotateY = velocidadRotacion;
rotating = true;
rotatingY = true;
}
}
//Mover Derecha
if (d3dInput.keyDown(Key.D))
{
moveSide = -velocidadCaminar;
moving = true;
}
//Izquierda
if (d3dInput.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT) && d3dInput.XposRelative < 0)
{
if (camara.RotationY > -(Math.PI))
{
rotateY = -velocidadRotacion;
rotating = true;
rotatingY = true;
}
}
//Mover Izquierda
if (d3dInput.keyDown(Key.A))
{
moveSide = velocidadCaminar;
moving = true;
}
//Arriba
if (d3dInput.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT) && d3dInput.YposRelative < 0)
{
if (camara.RotationX > -(Math.PI / 3))
{
rotateX = -velocidadRotacion;
rotating = true;
rotatingX = true;
}
}
//Abajo
if (d3dInput.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT) && d3dInput.YposRelative > 0)
{
if (camara.RotationX < (Math.PI / 3))
{
rotateX = velocidadRotacion;
rotating = true;
rotatingX = true;
}
}
//Jump
/* if (d3dInput.keyDown(Key.Space))
* {
* jump = 30;
* moving = true;
* }*/
//Run
if (d3dInput.keyDown(Key.LeftShift))
{
running = true;
moveForward *= 1.5f;
}
if (d3dInput.keyDown(Key.E))
{
animationAction = "WeaponPos";
}
//Si hubo rotacion
if (rotating)
{
if (rotatingY)
{
//Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware
float rotAngleY = Geometry.DegreeToRadian(rotateY * elapsedTime);
personaje.rotateY(rotAngleY);
camara.rotateY(rotAngleY);
}
if (rotatingX)
{
//Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware
float rotAngleX = Geometry.DegreeToRadian(rotateX * elapsedTime);
camara.rotateX(rotAngleX);
}
}
//Si hubo desplazamiento
if (moving)
{
//Activar animacion de caminando
if (running)
{
personaje.playAnimation("Run", true);
}
else if (jumping)
{
personaje.playAnimation("Jump", true);
}
else
{
personaje.playAnimation("Walk", true);
}
}
//Si no se esta moviendo, activar animationAction
else
{
personaje.playAnimation(animationAction, true);
}
//Vector de movimiento
Vector3 movementVector = Vector3.Empty;
if (moving)
{
//Aplicar movimiento, desplazarse en base a la rotacion actual del personaje
//Grupo Kamikaze3D :: Se agrega también al desplazamiento sobre el eje x y eje z, el valor de desplazamiento lateral
movementVector = new Vector3(
(FastMath.Sin(personaje.Rotation.Y) * moveForward) + (FastMath.Cos(personaje.Rotation.Y) * moveSide),
jump,
(FastMath.Cos(personaje.Rotation.Y) * moveForward) + (-FastMath.Sin(personaje.Rotation.Y) * moveSide)
);
}
//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);
//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));
//Render linea
if (renderDirectionArrow)
{
directionArrow.render();
}
//Render personaje
personaje.animateAndRender();
/* //Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
* GuiController.Instance.Drawer2D.beginDrawSprite();
*
* //Dibujar sprite (si hubiese mas, deberian ir todos aquí)
* mira.render();
*
* //Finalizar el dibujado de Sprites
* GuiController.Instance.Drawer2D.endDrawSprite();*/
hitCantTextY.Text = "Y: " + camara.RotationY;
hitCantTextX.Text = "X: " + camara.RotationX;
hitCantTextY.render();
hitCantTextX.render();
if (showBB)
{
characterSphere.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");
//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 void Render()
{
linea.updateValues();
linea.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 override void Render()
{
PreRender();
//Si hacen clic con el mouse, ver si hay colision con el suelo
if (TgcD3dInput.Instance.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
//Actualizar Ray de colisión en base a posición del mouse
pickingRay.updateRay();
//Detectar colisión Ray-AABB
if (TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, suelo.BoundingBox, out newPosition))
{
//Fijar nueva posición destino
applyMovement = true;
collisionPointMesh.Position = newPosition;
directionArrow.PEnd = new Vector3(newPosition.X, 30f, newPosition.Z);
//Rotar modelo en base a la nueva dirección a la que apunta
var direction = Vector3.Normalize(newPosition - mesh.Position);
var angle = FastMath.Acos(Vector3.Dot(originalMeshRot, direction));
var axisRotation = Vector3.Cross(originalMeshRot, direction);
meshRotationMatrix = Matrix.RotationAxis(axisRotation, angle);
}
}
var speed = (float)Modifiers["speed"];
//Interporlar movimiento, si hay que mover
if (applyMovement)
{
//Ver si queda algo de distancia para mover
var posDiff = newPosition - mesh.Position;
var posDiffLength = posDiff.LengthSq();
if (posDiffLength > float.Epsilon)
{
//Movemos el mesh interpolando por la velocidad
var currentVelocity = speed * ElapsedTime;
posDiff.Normalize();
posDiff.Multiply(currentVelocity);
//Ajustar cuando llegamos al final del recorrido
var newPos = mesh.Position + posDiff;
if (posDiff.LengthSq() > posDiffLength)
{
newPos = newPosition;
}
//Actualizar flecha de movimiento
directionArrow.PStart = new Vector3(mesh.Position.X, 30f, mesh.Position.Z);
directionArrow.updateValues();
//Actualizar posicion del mesh
mesh.Position = newPos;
//Como desactivamos la transformacion automatica, tenemos que armar nosotros la matriz de transformacion
mesh.Transform = meshRotationMatrix * Matrix.Translation(mesh.Position);
//Actualizar camara
camaraInterna.Target = mesh.Position;
}
//Se acabo el movimiento
else
{
applyMovement = false;
}
}
//Mostrar caja con lugar en el que se hizo click, solo si hay movimiento
if (applyMovement)
{
collisionPointMesh.render();
directionArrow.render();
}
suelo.render();
mesh.render();
PostRender();
}