private void UpdateArrows()
{
if (dragging)
{
toArrow.PEnd = currentPick;
toArrow.updateValues();
var cross = TGCVector3.Cross(fromDrag, currentPick);
cross.Normalize();
cross.Scale(-radius);
crossArrow.PEnd = cross;
crossArrow.updateValues();
}
else
{
fromArrow.PEnd = currentPick;
fromArrow.updateValues();
toArrow.PEnd = TGCVector3.Empty;
toArrow.updateValues();
toArrow.PEnd = TGCVector3.Empty;
toArrow.updateValues();
}
}
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();
}
private void CrearEjes()
{
Vector3 centroEjes = new Vector3(50, 10, 0);
TgcArrow normalX = new TgcArrow();
normalX.PStart = centroEjes;
normalX.PEnd = centroEjes + new Vector3(10, 0, 0);
normalX.updateValues();
this.normales.Add(normalX);
TgcArrow normalY = new TgcArrow();
normalY.PStart = centroEjes;
normalY.PEnd = centroEjes + new Vector3(0, 10, 0);
normalY.updateValues();
this.normales.Add(normalY);
TgcArrow normalZ = new TgcArrow();
normalZ.PStart = centroEjes;
normalZ.PEnd = centroEjes + new Vector3(0, 0, 10);
normalZ.updateValues();
this.normales.Add(normalZ);
}
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();
}
/// <summary>
/// Actualiza los parámetros de la caja en base a lo cargado por el usuario
/// </summary>
private void updateQuad(bool showNormal)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
Vector2 size = (Vector2)GuiController.Instance.Modifiers["size"];
Vector3 normal = (Vector3)GuiController.Instance.Modifiers["normal"];
Vector3 center = (Vector3)GuiController.Instance.Modifiers["center"];
Color color = (Color)GuiController.Instance.Modifiers["color"];
//Cargar valores del quad.
quad.Center = center;
quad.Size = size;
quad.Normal = normal;
quad.Color = color;
//Actualizar valors para hacerlos efectivos
quad.updateValues();
//Actualizar valores de la flecha
if (showNormal)
{
normalArrow.PStart = quad.Center;
normalArrow.PEnd = quad.Center + quad.Normal * 10;
normalArrow.updateValues();
}
}
/// <summary>
/// Actualiza los parametros de la caja en base a lo cargado por el usuario
/// </summary>
private void updateQuad()
{
var size = (Vector2)Modifiers["size"];
var normal = (Vector3)Modifiers["normal"];
var center = (Vector3)Modifiers["center"];
var color = (Color)Modifiers["color"];
//Cargar valores del quad.
quad.Center = center;
quad.Size = size;
quad.Normal = normal;
quad.Color = color;
//Actualizar valors para hacerlos efectivos
//Los quad actualizan el vertexBuffer, al ser solo 2 triangulos no tiene gran costo recalcular los valores,
//pero es mas recomendado utilizar transformaciones
quad.updateValues();
//Actualizar valores de la flecha
if ((bool)Modifiers["showNormal"])
{
normalArrow.PStart = quad.Center;
normalArrow.PEnd = quad.Center + quad.Normal * 10;
normalArrow.updateValues();
}
}
public override void Update()
{
var start = startModifier.Value;
var end = endModifier.Value;
var thickness = thicknessModifier.Value;
var headSize = headSizeModifier.Value;
var bodyColor = bodyColorModifier.Value;
var headColor = headColorModifier.Value;
var offset = new TGCVector3(10, 0, 0);
//Cargar valores de la flecha
arrow.PStart = start - offset;
arrow.PEnd = end - offset;
arrow.Thickness = thickness;
arrow.HeadSize = headSize;
arrow.BodyColor = bodyColor;
arrow.HeadColor = headColor;
//Actualizar valores para hacerlos efectivos, ADVERTENCIA verificar que estemetodo crea los vertices nuevamente.
//Recomendado de ser posible realizar transformaciones!!!
arrow.updateValues();
var boxColor = boxColorModifier.Value;
//Cargar valores de la linea
box.PMin = start + offset;
box.PMax = end + offset;
box.Thickness = thickness;
box.Color = boxColor;
//Actualizar valores para hacerlos efectivos, ADVERTENCIA verificar que estemetodo crea los vertices nuevamente.
//Recomendado de ser posible realizar transformaciones!!!
box.updateValues();
}
private void CrearPlanos()
{
Vector3 centroOriginal = new Vector3(0, 0, 0);
Vector3 centroActual = centroOriginal;
for (int i = 0; i < 20; i++)
{
centroActual = new Vector3(i * 5, 0, 0);
for (int j = 0; j < 20; j++)
{
centroActual = centroActual + new Vector3(0, 0, 5);
//Crear un quad (pequeño plano) con la clase TgcQuad para poder dibujar el plano que contiene al triangulo
TgcQuad quad = new TgcQuad();
quad.Center = centroActual;
quad.Color = this.AdaptColorRandom(Color.SteelBlue);
quad.Size = new Vector2(5, 5);
quad.Effect = this.effect;
quad.Technique = "VS1";
quad.updateValues();
this.planos.Add(quad);
TgcArrow normal = new TgcArrow();
normal.PStart = quad.Center;
normal.PEnd = quad.Center + quad.Normal * 2;
normal.updateValues();
this.normales.Add(normal);
}
}
}
private void CreateArrow()
{
this.effectVectorArrow = new TgcArrow();
effectVectorArrow.HeadColor = Color.Blue;
effectVectorArrow.BodyColor = Color.Red;
effectVectorArrow.Thickness = 1;
effectVectorArrow.Enabled = false;
effectVectorArrow.HeadSize = new TGCVector2(1, 1);
effectVectorArrow.updateValues();
}
private void initVector()
{
this.arrow = new TgcArrow();
arrow.HeadColor = Color.Blue;
arrow.BodyColor = Color.Red;
arrow.Thickness = 1;
arrow.Enabled = false;
arrow.HeadSize = new TGCVector2(1, 1);
arrow.updateValues();
this.effectVector = new TGCVector3(1, 1, 1);
}
//define un update overrideable para todos los barcos
override public void update()
{
this.flotar();
if ((bool)GuiController.Instance.Modifiers.getValue("normales"))
{
//calculos para poder dibujar la flecha que indica la normal
normalDibujable.PStart = this.Position;
normalDibujable.PEnd = this.Position + Vector3.Multiply(normal, 200);
normalDibujable.updateValues();
}
}
public void Render(TgcScene scene)
{
D3DDevice.Instance.Device.BeginScene(); //BEGIN1================================================================
// Calculo la matriz de view de la luz
effect.SetValue("g_vLightPos", new Vector4(g_LightPos.X, g_LightPos.Y, g_LightPos.Z, 1));
effect.SetValue("g_vLightDir", new Vector4(g_LightDir.X, g_LightDir.Y, g_LightDir.Z, 1));
g_LightView = Matrix.LookAtLH(g_LightPos, g_LightPos + g_LightDir, new Vector3(0, 0, 1));
arrow.PStart = g_LightPos;
arrow.PEnd = g_LightPos + g_LightDir * 20f;
arrow.updateValues();
D3DDevice.Instance.Device.EndScene(); //END1================================================================
// inicializacion standard:
effect.SetValue("g_mProjLight", g_mShadowProj);
effect.SetValue("g_mViewLightProj", g_LightView * g_mShadowProj);
// Primero genero el shadow map, para ello dibujo desde el pto de vista de luz
// a una textura, con el VS y PS que generan un mapa de profundidades.
pOldRT = D3DDevice.Instance.Device.GetRenderTarget(0);
var pShadowSurf = g_pShadowMap.GetSurfaceLevel(0);
D3DDevice.Instance.Device.SetRenderTarget(0, pShadowSurf);
pOldDS = D3DDevice.Instance.Device.DepthStencilSurface;
D3DDevice.Instance.Device.DepthStencilSurface = g_pDSShadow;
//D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
D3DDevice.Instance.Device.BeginScene(); //BEGIN2 ================================================================
// Hago el render de la escena pp dicha
effect.SetValue("g_txShadow", g_pShadowMap);
foreach (TgcMesh M in mapScene.Meshes)
{
RenderMesh(M, true);
}
// Termino
//D3DDevice.Instance.Device.EndScene();
//TextureLoader.Save("shadowmap.bmp", ImageFileFormat.Bmp, g_pShadowMap);
// restuaro el render target y el stencil
//D3DDevice.Instance.Device.DepthStencilSurface = pOldDS;
//D3DDevice.Instance.Device.SetRenderTarget(0, pOldRT);
//arrow.render();
}
public void RenderShadowMap()
{
// Calculo la matriz de view de la luz
effect.SetValue("g_vLightPos", new TGCVector4(g_LightPos.X, g_LightPos.Y, g_LightPos.Z, 1));
effect.SetValue("g_vLightDir", new TGCVector4(g_LightDir.X, g_LightDir.Y, g_LightDir.Z, 1));
g_LightView = TGCMatrix.LookAtLH(g_LightPos, g_LightPos + g_LightDir, new TGCVector3(0, 0, 1));
arrow.PStart = g_LightPos;
arrow.PEnd = g_LightPos + g_LightDir * 20f;
arrow.updateValues();
// inicializacion standard:
effect.SetValue("g_mProjLight", g_mShadowProj.ToMatrix());
effect.SetValue("g_mViewLightProj", (g_LightView * g_mShadowProj).ToMatrix());
//frustumShadow.updateVolume(TGCMatrix.FromMatrix(D3DDevice.Instance.Device.Transform.View),
// TGCMatrix.FromMatrix(D3DDevice.Instance.Device.Transform.Projection));
// Primero genero el shadow map, para ello dibujo desde el pto de vista de luz
// a una textura, con el VS y PS que generan un mapa de profundidades.
var pOldRT = D3DDevice.Instance.Device.GetRenderTarget(0);
var pShadowSurf = g_pShadowMap.GetSurfaceLevel(0);
D3DDevice.Instance.Device.SetRenderTarget(0, pShadowSurf);
var pOldDS = D3DDevice.Instance.Device.DepthStencilSurface;
D3DDevice.Instance.Device.DepthStencilSurface = g_pDSShadow;
D3DDevice.Instance.Device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Gray, 1.0f, 0);
//D3DDevice.Instance.Device.BeginScene();
// Hago el render de la escena pp dicha
effect.SetValue("g_txShadow", g_pShadowMap);
//RenderScene(true,g_LightView, g_mShadowProj);
RenderScene2(true);
//Termino
//D3DDevice.Instance.Device.EndScene();
TextureLoader.Save("shadowmap.bmp", ImageFileFormat.Bmp, g_pShadowMap);
// restuaro el render target y el stencil
D3DDevice.Instance.Device.DepthStencilSurface = pOldDS;
D3DDevice.Instance.Device.SetRenderTarget(0, pOldRT);
}
public static List <TgcArrow> PrepareClosestCheckPoint(Vector3 position, Checkpoint lastCheckPoint, out Checkpoint updatedChekPoint)
{
updatedChekPoint = GetClosestCheckPoint(position);
if (lastCheckPoint != updatedChekPoint)
{
lastCheckPoint = updatedChekPoint;
lastCheckPointArrows = updatedChekPoint.Neighbors.Select(c =>
{
TgcArrow arrow = new TgcArrow();
arrow.PStart = lastCheckPoint.Position;
arrow.PEnd = c.Position;
arrow.BodyColor = Color.Black;
arrow.HeadColor = Color.White;
arrow.Thickness = 0.4f;
arrow.HeadSize = new Vector2(8, 10);
arrow.updateValues();
return(arrow);
}).ToList();
}
return(lastCheckPointArrows);
}
/// <summary>
/// Actualiza los parámetros de la caja en base a lo cargado por el usuario
/// </summary>
private void updateQuad(bool showNormal)
{
var size = (Vector2)Modifiers["size"];
var normal = (Vector3)Modifiers["normal"];
var center = (Vector3)Modifiers["center"];
var color = (Color)Modifiers["color"];
//Cargar valores del quad.
quad.Center = center;
quad.Size = size;
quad.Normal = normal;
quad.Color = color;
//Actualizar valors para hacerlos efectivos
quad.updateValues();
//Actualizar valores de la flecha
if (showNormal)
{
normalArrow.PStart = quad.Center;
normalArrow.PEnd = quad.Center + quad.Normal * 10;
normalArrow.updateValues();
}
}
public override void Update()
{
PreUpdate();
//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 moving = false;
var rotating = false;
float jump = 0;
//Adelante
if (Input.keyDown(Key.W))
{
moveForward = -velocidadCaminar;
moving = true;
}
//Atras
if (Input.keyDown(Key.S))
{
moveForward = velocidadCaminar;
moving = true;
}
//Derecha
if (Input.keyDown(Key.D))
{
rotate = velocidadRotacion;
rotating = true;
}
//Izquierda
if (Input.keyDown(Key.A))
{
rotate = -velocidadRotacion;
rotating = true;
}
//Jump
if (!jumping && Input.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
var rotAngle = Geometry.DegreeToRadian(rotate * ElapsedTime);
personaje.rotateY(rotAngle);
camaraInterna.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
var 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)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"])
{
var realMovement = collisionManager.moveCharacter(characterSphere, movementVector, objetosColisionables);
personaje.move(realMovement);
//Cargar desplazamiento realizar en UserVar
UserVars.setValue("Movement", TgcParserUtils.printVector3(realMovement));
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
camaraInterna.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, 80);
collisionNormalArrow.updateValues();
collisionPoint.Position = collisionManager.LastCollisionPoint;
collisionPoint.render();
}
}
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 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.UpdateMeshTransform();
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.UpdateMeshTransform();
m.Render();
}
if (Input.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 TGCVector2(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 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();
}
}
private void CrearEjes()
{
Vector3 centroEjes = new Vector3(50, 10, 0);
TgcArrow normalX = new TgcArrow();
normalX.PStart = centroEjes;
normalX.PEnd = centroEjes + new Vector3(10, 0, 0);
normalX.updateValues();
this.normales.Add(normalX);
TgcArrow normalY = new TgcArrow();
normalY.PStart = centroEjes;
normalY.PEnd = centroEjes + new Vector3(0, 10, 0);
normalY.updateValues();
this.normales.Add(normalY);
TgcArrow normalZ = new TgcArrow();
normalZ.PStart = centroEjes;
normalZ.PEnd = centroEjes + new Vector3(0, 0, 10);
normalZ.updateValues();
this.normales.Add(normalZ);
}
public override void Update()
{
PreUpdate();
//obtener velocidades de Modifiers
var velocidadCaminar = velocidadCaminarModifier.Value;
var velocidadRotacion = velocidadRotacionModifier.Value;
//Calcular proxima posicion de personaje segun Input
var moveForward = 0f;
float rotate = 0;
var moving = false;
var rotating = false;
float jump = 0;
//Adelante
if (Input.keyDown(Key.W))
{
moveForward = -velocidadCaminar;
moving = true;
}
//Atras
if (Input.keyDown(Key.S))
{
moveForward = velocidadCaminar;
moving = true;
}
//Derecha
if (Input.keyDown(Key.D))
{
rotate = velocidadRotacion;
rotating = true;
}
//Izquierda
if (Input.keyDown(Key.A))
{
rotate = -velocidadRotacion;
rotating = true;
}
//Jump
if (Input.keyUp(Key.Space) && jumping < 30)
{
jumping = 30;
}
if (Input.keyUp(Key.Space) || jumping > 0)
{
jumping -= 30 * ElapsedTime;
jump = jumping;
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
var rotAngle = Geometry.DegreeToRadian(rotate * ElapsedTime);
personaje.Rotation += new TGCVector3(0, rotAngle, 0);
camaraInterna.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
var movementVector = TGCVector3.Empty;
if (moving)
{
//Aplicar movimiento, desplazarse en base a la rotacion actual del personaje
movementVector = new TGCVector3(FastMath.Sin(personaje.Rotation.Y) * moveForward, jump,
FastMath.Cos(personaje.Rotation.Y) * moveForward);
}
//Actualizar valores de gravedad
collisionManager.GravityEnabled = habilitarGravedadModifier.Value;
collisionManager.GravityForce = gravedadModifier.Value;
collisionManager.SlideFactor = slideFactorModifier.Value;
//Mover personaje con detección de colisiones, sliding y gravedad
var realMovement = collisionManager.moveCharacter(characterSphere, movementVector, objetosColisionables);
personaje.Position += realMovement;
personaje.Transform = TGCMatrix.Scaling(personaje.Scale) *
TGCMatrix.RotationYawPitchRoll(personaje.Rotation.Y, personaje.Rotation.X, personaje.Rotation.Z) *
TGCMatrix.Translation(personaje.Position);
//Hacer que la camara siga al personaje en su nueva posicion
camaraInterna.Target = personaje.Position;
//Actualizar valores de la linea de movimiento
directionArrow.PStart = characterSphere.Center;
directionArrow.PEnd = characterSphere.Center + TGCVector3.Multiply(movementVector, 50);
directionArrow.updateValues();
//Cargar desplazamiento realizar en UserVar
UserVars.setValue("Movement", TGCVector3.PrintVector3(realMovement));
//Ver cual de las mallas se interponen en la visión de la cámara en 3ra persona.
objectsBehind.Clear();
objectsInFront.Clear();
foreach (var mesh in escenario.Meshes)
{
TGCVector3 q;
if (TgcCollisionUtils.intersectSegmentAABB(Camara.Position, camaraInterna.Target,
mesh.BoundingBox, out q))
{
objectsBehind.Add(mesh);
}
else
{
objectsInFront.Add(mesh);
}
}
PostUpdate();
}
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();
}
private void ProcesarColisiones()
{
collisionFound = false;
chocoAdelante = false;
//TgcCollisionUtils.testobbTest choque cilindro
var ray = new TgcRay.RayStruct();
var x1 = -largo *FastMath.Sin(anguloFinal);
var z1 = -largo *FastMath.Cos(anguloFinal);
var x2 = x1 * 1.2;
var z2 = z1 * 1.2;
//var a = Mesh.Position.TransformCoordinate(Matrix.Identity);
ray.origin = new Vector3(
Mesh.Position.X + x1,
Mesh.Position.Y,
Mesh.Position.Z + z1);
ray.direction = new Vector3(
newPosicion.X + (float)x2,
newPosicion.Y,
newPosicion.Z + (float)z2
);
directionArrow = new TgcArrow();
directionArrow.Thickness = 5;
directionArrow.HeadSize = new Vector2(10, 10);
//directionArrow.PEnd = ray.origin;
directionArrow.PStart = ray.origin;
directionArrow.PEnd = ray.direction;
directionArrow.updateValues();
//-FastMath.Sin(anguloFinal), 0, 350 * -FastMath.Cos(anguloFinal)
//ray.direction = eMovementVector;
foreach (var sceneMesh in ciudadScene.Meshes)
{
var escenaAABB = sceneMesh.BoundingBox;
var collisionResult = TgcCollisionUtils.testObbAABB(obb, escenaAABB);
//2 -si lo hizo, salgo del foreach.
if (collisionResult)
{
collisionFound = true;
//if (intersectRayAABB(ray, escenaAABB))//, out t, out p) || t > 1.0f)
float t;
Vector3 p;
chocoAdelante = (intersectRayAABB(ray, escenaAABB, out t, out p) || t > 1.0f);
break;
}
}
//3 - si chocó, pongo el bounding box en rojo (apretar F para ver el bb).
if (collisionFound)
{
if (Mesh.Position.Y == 5 || Mesh.Position.Y >= 25)
{
obb.setRenderColor(Color.Red);
//efectoShaderNitroHummer.SetValue("Velocidad", 4 * Velocidad);
PosicionRollback();
}
}
else
{
obb.setRenderColor(Color.Yellow);
}
if (Mesh.Position.Y == 5)
{
ManejarColisionCamara();
}
velocimetro.Update(Velocidad, marchaAtras);
}
public void Update()
{
// Update listener
//gameModel.DirectSound.UpdateListener3d();
// Manejar los inputs del teclado y joystick
ManageInputs(gameModel);
var sm = gameModel.SoundManager;
// Condiciones de fin de partida (ademas de presionar ESC)
if (!endMatch)
{
if (world.player1.hitPoints <= 0 || matchTime <= 0)
{
endMatch = true;
gameOverLose = true;
sm.LoadMp3(youLoseSong);
sm.Mp3Player.play(false);
}
else if (world.enemy.hitPoints <= 0)
{
endMatch = true;
gameOverWin = true;
sm.LoadMp3(youWinSong);
sm.Mp3Player.play(false);
}
}
// Si pausado o match terminado no computo nada mas
if (paused || endMatch)
{
return;
}
// Actualizar la posición y rotación de la cámara para que apunte a nuestro Player 1
camaraInterna.Target = new TGCVector3(world.player1.RigidBody.CenterOfMassPosition);
var rightStick = gameModel.Input.JoystickRightStick();
float grades = 0;
if (FastMath.Abs(rightStick) > 1800)
{
grades = ((FastMath.Abs(rightStick) - 1800f) / 81000f) * (FastMath.Abs(rightStick) / rightStick);
}
var angular = sma(world.player1.RigidBody.InterpolationAngularVelocity.Y) * 0.055f;
camaraInterna.RotationY = world.player1.yawPitchRoll.Y + anguloCamara + halfsPI + grades - angular + (mirarHaciaAtras ? FastMath.PI : 0);
// Actualizar el Vector UP si se dibuja
if (drawUpVector)
{
//directionArrow.PStart = new TGCVector3(world.player1.RigidBody.CenterOfMassPosition);
//directionArrow.PEnd = directionArrow.PStart + new TGCVector3(Vector3.TransformNormal(Vector3.UnitY, world.player1.RigidBody.InterpolationWorldTransform)) * 3.5f;
var asd = Matrix.Translation(-world.player1.Mesh.BoundingBox.calculateAxisRadius().X, 0, 0) * world.player1.RigidBody.CenterOfMassTransform;
directionArrow.PStart = new TGCVector3(asd.Origin);
directionArrow.PEnd = new TGCVector3(asd.Origin) + TGCVector3.Up * 3.5f;
directionArrow.updateValues();
}
// Actualizar el mundo físico
world.Update(gameModel, camaraInterna, modoCamara);
// Actualizar los stats
var p1 = world.player1;
if (p1.turbo)
{
p1.specialPoints = FastMath.Max(0f, p1.specialPoints - p1.costTurbo * gameModel.ElapsedTime);
}
if (p1.specialPoints < p1.maxSpecialPoints)
{
p1.specialPoints = FastMath.Min(p1.maxSpecialPoints, p1.specialPoints + p1.specialPointsGain * gameModel.ElapsedTime);
}
var e = world.enemy;
if (e.turbo)
{
e.specialPoints = FastMath.Max(0f, e.specialPoints - e.costTurbo * gameModel.ElapsedTime);
}
if (e.specialPoints < e.maxSpecialPoints)
{
e.specialPoints = FastMath.Min(p1.maxSpecialPoints, e.specialPoints + e.specialPointsGain * gameModel.ElapsedTime);
}
// Actualizar el tiempo
matchTime -= gameModel.ElapsedTime;
// Actualizar el HUD
hud.Update(matchTime);
}
public override void Update()
{
PreUpdate();
//obtener velocidades de Modifiers
var velocidadCaminar = velocidadCaminarModifier.Value;
var velocidadRotacion = velocidadRotacionModifier.Value;
var velocidadSalto = velocidadSaltoModifier.Value;
var tiempoSalto = tiempoSaltoModifier.Value;
//Calcular proxima posicion de personaje segun Input
var moveForward = 0f;
float rotate = 0;
var moving = false;
var rotating = false;
float jump = 0;
//Adelante
if (Input.keyDown(Key.W))
{
moveForward = -velocidadCaminar;
moving = true;
}
//Atras
if (Input.keyDown(Key.S))
{
moveForward = velocidadCaminar;
moving = true;
}
//Derecha
if (Input.keyDown(Key.D))
{
rotate = velocidadRotacion;
rotating = true;
}
//Izquierda
if (Input.keyDown(Key.A))
{
rotate = -velocidadRotacion;
rotating = true;
}
//Jump
if (!jumping && Input.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 = TGCVector3.Empty;
if (moving || jumping)
{
//Aplicar movimiento, desplazarse en base a la rotacion actual del personaje
movementVector = new TGCVector3(FastMath.Sin(personaje.Rotation.Y) * moveForward, jump, FastMath.Cos(personaje.Rotation.Y) * moveForward);
}
//Actualizar valores de gravedad
collisionManager.GravityEnabled = habilitarGravedadModifier.Value;
collisionManager.GravityForce = gravedadModifier.Value /** elapsedTime*/;
collisionManager.SlideFactor = slideFactorModifier.Value;
collisionManager.OnGroundMinDotValue = pendienteModifier.Value;
//Si esta saltando, desactivar gravedad
if (jumping)
{
collisionManager.GravityEnabled = false;
}
//Mover personaje con detección de colisiones, sliding y gravedad
if (collisionsModifier.Value)
{
//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", TGCVector3.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 + TGCVector3.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 + TGCVector3.Multiply(collisionManager.Result.collisionNormal, 80);
collisionNormalArrow.updateValues();
collisionPoint.Position = collisionManager.Result.collisionPoint;
collisionPoint.updateValues();
}
PostUpdate();
}
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 PantallaJuego(Auto autito)
{
/*En PantallaInicio le paso a Pantalla juego con qué auto jugar. Acá lo asigno a la pantalla, cargo el coso
* que capta el teclado, creo el Nivel1 y lo pongo en la lista de renderizables, para que sepa con qué
* escenario cargarse */
this.auto = autito;
auto.mesh.move(new Vector3(0, 0, -3100));
auto.mesh.rotateY(-1.57f);
this.entrada = GuiController.Instance.D3dInput;
this.nivel = EjemploAlumno.getInstance().getNiveles(0);
//Barrita de vida
vida = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\vidaPersonaje\\vida.jpg");
barra = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\vidaPersonaje\\fondobarra.png");
barra2 = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\vidaPersonaje\\fondobarra2.png");
vida.setEscala(escalaInicial);
barra.setEscala(new Vector2(6.81f, 1f));
barra2.setEscala(new Vector2(6.81f, 1f));
Vector2 posicionbarra = new Vector2(10, 5);
vida.setPosicion(new Vector2(155f, 9.3f));
//CUENTA REGRESIVA
uno = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\cuentaRegresiva\\1.png");
uno.setCentrarYEscalar();
dos = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\cuentaRegresiva\\2.png");
dos.setCentrarYEscalar();
tres = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\cuentaRegresiva\\3.png");
tres.setCentrarYEscalar();
//Instrucción de misión del juego
misionMario = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\Mision\\m_mario.png");
misionMario.setCentrarYEscalar();
misionLuigi = new Imagen(GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\Mision\\m_luigi.png");
misionLuigi.setCentrarYEscalar();
// CAMARA TERCERA PERSONA
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.ThirdPersonCamera.resetValues();
Vector2 vectorCam = (Vector2)GuiController.Instance.Modifiers["AlturaCamara"];
GuiController.Instance.ThirdPersonCamera.setCamera(auto.mesh.Position, vectorCam.X, vectorCam.Y);
GuiController.Instance.ThirdPersonCamera.rotateY(auto.mesh.Rotation.Y);
//CARGAR MÚSICA.
Musica track = new Musica("ramones.mp3");
this.musica = track;
musica.playMusica();
musica.setVolume(35);
Shared.debugMode = false;
//Puntos de juego
puntos = new TgcText2d();
puntos.Text = "0";
puntos.Color = Color.DarkRed;
puntos.Align = TgcText2d.TextAlign.RIGHT;
puntos.Position = new Point(30, 30);
puntos.Size = new Size(100, 50);
puntos.changeFont(new System.Drawing.Font("TimesNewRoman", 25, FontStyle.Bold));
//Reloxxxx
this.horaInicio = DateTime.Now;
this.tiempoRestante = new TgcText2d();
this.tiempoRestante.Text = "65";
this.tiempoRestante.Color = Color.Green;
this.tiempoRestante.Align = TgcText2d.TextAlign.RIGHT;
this.tiempoRestante.Position = new Point(300, 30);
this.tiempoRestante.Size = new Size(100, 50);
this.tiempoRestante.changeFont(new System.Drawing.Font("TimesNewRoman", 25, FontStyle.Bold));
this.comienzoNivel = true;
//FLECHA NORMAL colision
collisionNormalArrow = new TgcArrow();
collisionNormalArrow.BodyColor = Color.Blue;
collisionNormalArrow.HeadColor = Color.Yellow;
collisionNormalArrow.Thickness = 1.4f;
collisionNormalArrow.HeadSize = new Vector2(10, 20);
//FLECHA debug (la usamos para conocer posiciones donde querramos posicionar meshes)
debugArrow = new TgcArrow();
debugArrow.BodyColor = Color.Purple;
debugArrow.HeadColor = Color.Yellow;
debugArrow.Thickness = 3f;
debugArrow.HeadSize = new Vector2(10, 20);
debugArrow.PStart = new Vector3(0, 400f, 0);
debugArrow.PEnd = new Vector3(0, 10f, 0);
debugArrow.updateValues();
//USER VARS
GuiController.Instance.UserVars.addVar("DistMinima");
GuiController.Instance.UserVars.addVar("Velocidad");
GuiController.Instance.UserVars.addVar("Vida");
GuiController.Instance.UserVars.addVar("AngCol");
GuiController.Instance.UserVars.addVar("AngRot");
GuiController.Instance.UserVars.addVar("NormalObstaculoX");
GuiController.Instance.UserVars.addVar("NormalObstaculoZ");
}
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(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 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();
}
private void CrearPlanos()
{
Vector3 centroOriginal = new Vector3(0, 0, 0);
Vector3 centroActual = centroOriginal;
for (int i = 0; i < 20; i++)
{
centroActual = new Vector3(i * 5, 0, 0);
for (int j = 0; j < 20; j++)
{
centroActual = centroActual + new Vector3(0, 0, 5);
//Crear un quad (pequeño plano) con la clase TgcQuad para poder dibujar el plano que contiene al triangulo
TgcQuad quad = new TgcQuad();
quad.Center = centroActual;
quad.Color = this.AdaptColorRandom(Color.SteelBlue);
quad.Size = new Vector2(5, 5);
quad.Effect = this.effect;
quad.Technique = "VS1";
quad.updateValues();
this.planos.Add(quad);
TgcArrow normal = new TgcArrow();
normal.PStart = quad.Center;
normal.PEnd = quad.Center + quad.Normal * 2;
normal.updateValues();
this.normales.Add(normal);
}
}
}
public void Render()
{
linea.updateValues();
linea.render();
}