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)
{
TgcModifiers modifiers = GuiController.Instance.Modifiers;
Vector2 size = (Vector2)modifiers.getValue("size");
Vector3 position = (Vector3)modifiers.getValue("position");
Vector3 rotation = (Vector3)modifiers.getValue("rotation");
collider.Center = position;
collider.Rotation = rotation;
collider.Radius = size.X;
collider.Length = size.Y;
collider.updateValues();
if (TgcCollisionUtils.testSphereCylinder(collisionableSphere, collider))
{
collisionableSphere.setRenderColor(collisionColor);
}
else
{
collisionableSphere.setRenderColor(noCollisionColor);
}
collider.render();
collisionableSphere.render();
}
public override void Render(Item item, Effect shader)
{
if (Game.Current.IsColliderVisible)
{
//TODO:Sphere.Effect = shader;
Sphere.render();
}
}
public override void Render()
{
PreRender();
var size = (Vector2)Modifiers.getValue("size");
var position = (Vector3)Modifiers.getValue("position");
var rotation = (Vector3)Modifiers.getValue("rotation");
collider.Center = position;
collider.Rotation = rotation;
collider.Radius = size.X;
collider.Length = size.Y;
collider.updateValues();
if (TgcCollisionUtils.testSphereCylinder(collisionableSphere, collider))
{
collisionableSphere.setRenderColor(collisionColor);
}
else
{
collisionableSphere.setRenderColor(noCollisionColor);
}
if (pickingTimeLeft > 0)
{
pickingTimeLeft -= ElapsedTime;
}
else
{
collider.setRenderColor(noCollisionColor);
}
if (TgcD3dInput.Instance.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
var pickingRay = new TgcPickingRay();
pickingRay.updateRay();
if (TgcCollisionUtils.testRayCylinder(pickingRay.Ray, collider))
{
pickingTimeLeft = PICKING_TIME;
collider.setRenderColor(pickingColor);
}
}
collider.render();
collisionableSphere.render();
PostRender();
}
public void Render(Snipers scene)
{
enemigo.render();
if (hp < 100)
{
emisorDeParticulas.render();
}
if ((bool)GuiController.Instance.Modifiers.getValue("showBB"))
{
enemigo.BoundingBox.render();
cabeza.render();
}
}
public override void render(float elapsedTime)
{
TgcModifiers modifiers = GuiController.Instance.Modifiers;
Vector2 size = (Vector2)modifiers.getValue("size");
Vector3 position = (Vector3)modifiers.getValue("position");
Vector3 rotation = (Vector3)modifiers.getValue("rotation");
collider.Center = position;
collider.Rotation = rotation;
collider.Radius = size.X;
collider.Length = size.Y;
collider.updateValues();
if (TgcCollisionUtils.testSphereCylinder(collisionableSphere, collider))
{
collisionableSphere.setRenderColor(collisionColor);
}
else
{
collisionableSphere.setRenderColor(noCollisionColor);
}
if (pickingTimeLeft > 0)
{
pickingTimeLeft -= elapsedTime;
}
else
{
collider.setRenderColor(noCollisionColor);
}
if (GuiController.Instance.D3dInput.buttonPressed(TgcViewer.Utils.Input.TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
TgcPickingRay pickingRay = new TgcPickingRay();
pickingRay.updateRay();
if (TgcCollisionUtils.testRayCylinder(pickingRay.Ray, collider))
{
pickingTimeLeft = PICKING_TIME;
collider.setRenderColor(pickingColor);
}
}
collider.render();
collisionableSphere.render();
}
public override void Render()
{
PreRender();
//Bounding volumes.
//Los bounding volumes realizan un update de los vertices en momento de render, por ello pueden ser mas lentos que utilizar transformadas.
if ((bool)Modifiers["fixedY"])
{
colliderCylinderFixedY.render();
}
else
{
colliderCylinder.render();
}
//Render personaje
personaje.Transform =
Matrix.Scaling(personaje.Scale)
* Matrix.RotationYawPitchRoll(personaje.Rotation.Y, personaje.Rotation.X, personaje.Rotation.Z)
* Matrix.Translation(personaje.Position);
personaje.animateAndRender(ElapsedTime);
if ((bool)Modifiers["showBoundingBox"])
{
personaje.BoundingBox.render();
}
//Render de objetos estaticos
collisionableSphere.render();
collisionableMeshAABB.BoundingBox.render();
collisionableCylinder.render();
//Dibujar todo mallas.
//Una vez actualizadas las diferentes posiciones internas solo debemos asignar la matriz de world.
collisionableMeshAABB.Transform =
Matrix.Scaling(collisionableMeshAABB.Scale)
* Matrix.Translation(collisionableMeshAABB.Position);
collisionableMeshAABB.render();
PostRender();
}
public override void Render()
{
PreRender();
//Dibujar todo.
//Una vez actualizadas las diferentes posiciones internas solo debemos asignar la matriz de world.
mesh.Transform =
Matrix.Scaling(mesh.Scale)
* Matrix.RotationYawPitchRoll(mesh.Rotation.Y, mesh.Rotation.X, mesh.Rotation.Z)
* Matrix.Translation(mesh.Position);
mesh.render();
//Actualmente los bounding box se actualizan solos en momento de hacer render, esto no es recomendado ya que trae overhead
//Igualmente aqui podemos tener un objeto debug de nuestro mesh.
mesh.BoundingBox.render();
box2.Transform =
Matrix.Scaling(box2.Scale)
* Matrix.RotationYawPitchRoll(box2.Rotation.Y, box2.Rotation.X, box2.Rotation.Z)
* Matrix.Translation(box2.Position);
box2.render();
//Los bounding volume por la forma actual de framework no realizan transformaciones entonces podemos hacer esto:
//D3DDevice.Instance.Device.Transform.World =
// Matrix.Scaling(new Vector3(sphere.Radius, sphere.Radius, sphere.Radius))
// * Matrix.Identity //No tienen sentido las rotaciones con la esfera.
// * Matrix.Translation(sphere.Position);
boundingSphere.render();
//Las mesh por defecto tienen el metodo UpdateMeshTransform que realiza el set por defecto.
//Esto es igual que utilizar AutoTransform en true, con lo cual no es recomendado para casos complejos.
meshObb.UpdateMeshTransform();
meshObb.render();
//La implementacion de Obb por el momento reconstruye el obb debug siempre. Practica no recomendada.
obb.render();
//triangulo
D3DDevice.Instance.Device.Transform.World = Matrix.Identity;
D3DDevice.Instance.Device.VertexFormat = CustomVertex.PositionColored.Format;
D3DDevice.Instance.Device.DrawUserPrimitives(PrimitiveType.TriangleList, 1, triangle);
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 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 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();
var velocidadCaminar = 50f * ElapsedTime;
//Calcular proxima posicion de personaje segun Input
var d3dInput = TgcD3dInput.Instance;
var moving = false;
var movement = new Vector3(0, 0, 0);
//Adelante
if (d3dInput.keyDown(Key.W))
{
movement.Z = velocidadCaminar;
moving = true;
}
//Atras
if (d3dInput.keyDown(Key.S))
{
movement.Z = -velocidadCaminar;
moving = true;
}
//Derecha
if (d3dInput.keyDown(Key.D))
{
movement.X = velocidadCaminar;
moving = true;
}
//Izquierda
if (d3dInput.keyDown(Key.A))
{
movement.X = -velocidadCaminar;
moving = true;
}
//Salto
if (d3dInput.keyDown(Key.Space))
{
movement.Y = velocidadCaminar;
moving = true;
}
//Agachar
if (d3dInput.keyDown(Key.LeftControl))
{
movement.Y = -velocidadCaminar;
moving = true;
}
//Si hubo desplazamiento
if (moving)
{
//Aplicar movimiento
box.move(movement);
}
//Hacer que la camara siga al personaje en su nueva posicion
camaraInterna.Target = box.Position;
//Detectar colision con triangulo
if (TgcCollisionUtils.testTriangleAABB(triangle[0].Position, triangle[1].Position, triangle[2].Position,
box.BoundingBox))
{
box.BoundingBox.render();
triagleAABB.render();
}
//Detectar colision con el otro AABB
if (TgcCollisionUtils.testAABBAABB(box.BoundingBox, box2.BoundingBox))
{
box.BoundingBox.render();
box2.BoundingBox.render();
}
//Detectar colision con la esfera
if (TgcCollisionUtils.testSphereAABB(sphere, box.BoundingBox))
{
box.BoundingBox.render();
sphere.setRenderColor(Color.Red);
}
else
{
sphere.setRenderColor(Color.Yellow);
}
//Detectar colision con la obb
if (TgcCollisionUtils.testObbAABB(obb, box.BoundingBox))
{
box.BoundingBox.render();
obb.setRenderColor(Color.Red);
}
else
{
obb.setRenderColor(Color.Yellow);
}
//Dibujar
box.render();
box2.render();
sphere.render();
obb.render();
//triangulo
D3DDevice.Instance.Device.Transform.World = Matrix.Identity;
D3DDevice.Instance.Device.VertexFormat = CustomVertex.PositionColored.Format;
D3DDevice.Instance.Device.DrawUserPrimitives(PrimitiveType.TriangleList, 1, triangle);
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();
}
}
