private void DibujarDebug()
{
DrawText.drawText("GodMode = ON", 600, 40, Color.OrangeRed);
DrawText.drawText("F = bounding box.", 0, 20, Color.OrangeRed);
DrawText.drawText("posicion camara: " + TgcParserUtils.printVector3(Camara.Position), 0, 30, Color.OrangeRed);
DrawText.drawText("GodMode = OFF", 0, 40, Color.White);
DrawText.drawText("v=", 0, 50, Color.Orange);
DrawText.drawText(AutoJugador.Velocidad.ToString(), 20, 50, Color.Orange);
//DrawText.drawText("ruedas=", 0, 60, Color.Green);
//DrawText.drawText(AutoJugador.DireccionRuedas.ToString(), 50, 60, Color.Green);
DrawText.drawText("angOrientacionMesh=", 0, 70, Color.White);
DrawText.drawText((AutoJugador.angOrientacionMesh * 180 / (float)Math.PI).ToString(), 160, 70, Color.White);
DrawText.drawText("MeshPosition=", 0, 80, Color.White);
DrawText.drawText(AutoJugador.Mesh.Position.ToString(), 100, 80, Color.White);
DrawText.drawText("scale mesh = ", 0, 160, Color.White);
DrawText.drawText(AutoJugador.Mesh.Scale.ToString(), 100, 160, Color.White);
DrawText.drawText("obb center = ", 0, 220, Color.White);
DrawText.drawText(AutoJugador.obb.Center.ToString(), 100, 220, Color.White);
DrawText.drawText("bounding position = ", 0, 280, Color.White);
DrawText.drawText(AutoJugador.Mesh.BoundingBox.ToString(), 150, 280, Color.White);
//DrawText.drawText("collisionFound = ", 0, 340, Color.White);
//DrawText.drawText(AutoJugador.collisionFound.ToString(), 150, 340, Color.White);
DrawText.drawText("direccionRuedas = ", 0, 400, Color.White);
DrawText.drawText(AutoJugador.DireccionRuedas.ToString(), 150, 400, Color.White);
DrawText.drawText("posicion luz ", 0, 420, Color.White);
DrawText.drawText(pointLuz.lighthPos.ToString(), 150, 420, Color.White);
DrawText.drawText("choco adelante ", 0, 480, Color.White);
DrawText.drawText(AutoJugador.chocoAdelante.ToString(), 150, 480, Color.White);
DrawText.drawText("t= ", 230, 520, Color.White);
DrawText.drawText(autoOponente.tiempoEspera.ToString(), 250, 580, Color.Orange);
/*
* DrawText.drawText("time ", 0, 500, Color.White);
*
*
* DrawText.drawText(minString+":"+ segString, 150, 500, Color.White);*/
if (BoundingBox)
{
//Box.BoundingBox.render();
// Mesh.BoundingBox.render();
AutoJugador.Mesh.BoundingBox.render();
MapScene.BoundingBox.render();
}
}
public override void Render()
{
PreRender();
sceneRecover.renderAll();
DrawText.drawText("Camera pos: " + TgcParserUtils.printVector3(Camara.Position), 5, 20, Color.Red);
DrawText.drawText("Camera LookAt: " + TgcParserUtils.printVector3(Camara.LookAt), 5, 40, Color.Red);
PostRender();
}
public override void Render()
{
PreRender();
DrawText.drawText("Camera pos: " + TgcParserUtils.printVector3(Camara.Position), 5, 20, Color.Red);
//Renderizar SkyBox
skyBox.render();
PostRender();
}
public void Render()
{
RuedaMeshDer.render();
RuedaMeshIzq.render();
if (SonDelanteras)
{
TgcText2D Drawtext = new TgcText2D();
Drawtext.drawText("I = " + TgcParserUtils.printVector3(RuedaMeshIzq.Position), 0, 100, Color.OrangeRed);
Drawtext.drawText("D =" + TgcParserUtils.printVector3(RuedaMeshDer.Position), 0, 120, Color.OrangeRed);
}
}
public override void Render()
{
PreRender();
DrawText.drawText("Camera pos: " + TgcParserUtils.printVector3(Camara.Position), 5, 20, Color.Red);
DrawText.drawText("Camera LookAt: " + TgcParserUtils.printVector3(Camara.LookAt), 5, 40, Color.Red);
//Ver si cambio el heightmap
var selectedHeightmap = (string)Modifiers["heightmap"];
if (currentHeightmap != selectedHeightmap)
{
currentHeightmap = selectedHeightmap;
createHeightMapMesh(D3DDevice.Instance.Device, currentHeightmap, currentScaleXZ, currentScaleY);
}
//Ver si cambio alguno de los valores de escala
var selectedScaleXZ = (float)Modifiers["scaleXZ"];
var selectedScaleY = (float)Modifiers["scaleY"];
if (currentScaleXZ != selectedScaleXZ || currentScaleY != selectedScaleY)
{
currentScaleXZ = selectedScaleXZ;
currentScaleY = selectedScaleY;
createHeightMapMesh(D3DDevice.Instance.Device, currentHeightmap, currentScaleXZ, currentScaleY);
}
//Ver si cambio la textura del terreno
var selectedTexture = (string)Modifiers["texture"];
if (currentTexture != selectedTexture)
{
currentTexture = selectedTexture;
loadTerrainTexture(D3DDevice.Instance.Device, currentTexture);
}
//Render terrain
D3DDevice.Instance.Device.SetTexture(0, terrainTexture);
D3DDevice.Instance.Device.VertexFormat = CustomVertex.PositionTextured.Format;
D3DDevice.Instance.Device.SetStreamSource(0, vbTerrain, 0);
D3DDevice.Instance.Device.DrawPrimitives(PrimitiveType.TriangleList, 0, totalVertices / 3);
PostRender();
}
/// <summary>
/// Se llama cada vez que hay que refrescar la pantalla.
/// Escribir aqu� todo el c�digo referido al renderizado.
/// Borrar todo lo que no haga falta.
/// </summary>
public override void Render()
{
//Inicio el render de la escena, para ejemplos simples. Cuando tenemos postprocesado o shaders es mejor realizar las operaciones seg�n nuestra conveniencia.
PreRender();
//Dibuja un texto por pantalla
DrawText.drawText("Con la tecla F se dibuja el bounding box.", 0, 20, Color.Black);//OrangeRed
DrawText.drawText(
"Con clic izquierdo subimos la camara [Actual]: " + TgcParserUtils.printVector3(Camara.Position), 0, 30,
Color.DarkGreen);
//Siempre antes de renderizar el modelo necesitamos actualizar la matriz de transformacion.
//Debemos recordar el orden en cual debemos multiplicar las matrices, en caso de tener modelos jer�rquicos, tenemos control total.
Box.Transform = Matrix.Scaling(Box.Scale) *
Matrix.RotationYawPitchRoll(Box.Rotation.Y, Box.Rotation.X, Box.Rotation.Z) *
Matrix.Translation(Box.Position);
Box2.Transform = Matrix.Scaling(Box.Scale) *
Matrix.RotationYawPitchRoll(Box.Rotation.Y, Box.Rotation.X, Box.Rotation.Z);
//A modo ejemplo realizamos toda las multiplicaciones, pero aqu� solo nos hacia falta la traslaci�n.
//Finalmente invocamos al render de la caja
Box.render();
Box2.render();
//Cuando tenemos modelos mesh podemos utilizar un m�todo que hace la matriz de transformaci�n est�ndar.
//Es �til cuando tenemos transformaciones simples, pero OJO cuando tenemos transformaciones jer�rquicas o complicadas.
Mesh.UpdateMeshTransform();
//Render del mesh
Mesh.render();
//Render de BoundingBox, muy �til para debug de colisiones.
if (BoundingBox)
{
Box.BoundingBox.render();
Mesh.BoundingBox.render();
}
//Finaliza el render y presenta en pantalla, al igual que el preRender se debe para casos puntuales es mejor utilizar a mano las operaciones de EndScene y PresentScene
PostRender();
}
public override void render(float elapsedTime)
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Obtener boolean para saber si hay que mostrar Bounding Box
bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
//obtener velocidades de Modifiers
float velocidadCaminar = (float)GuiController.Instance.Modifiers.getValue("VelocidadCaminar");
float velocidadRotacion = (float)GuiController.Instance.Modifiers.getValue("VelocidadRotacion");
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();
}
/// <summary>
/// Logea un Vector3 en la consola de mensajes con el color indicado
/// </summary>
public void logVector3(Vector3 v, Color color)
{
log(TgcParserUtils.printVector3(v), color);
}
public static void log(string text, Vector3 v)
{
BigLogger.log(text + ": " + TgcParserUtils.printVector3(v));
}
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";
//Ubicarlo centrado en la pantalla
Size screenSize = GuiController.Instance.Panel3d.Size;
Size textureSize = mira.Texture.Size;
mira.Enabled = false;
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;
*/
if (destroy)
{
goto Rendering;
}
//obtener velocidades de Modifiers
float velocidadCaminar = (float)GuiController.Instance.Modifiers["VelocidadCaminar"];
float velocidadRotacion = (float)GuiController.Instance.Modifiers.getValue("VelocidadRotacion");
//Detonar
if (this.canExplode && d3dInput.keyDown(Key.K))
{
animationAction = "Talk";
this.explosion.detonar();
destroy = true;
}
//Adelante
if (d3dInput.keyDown(Key.W))
{
if (!moving)
{
moveForward = -velocidadCaminar;
}
else
{
moveForward = -velocidadCaminar / 2;
}
moving = true;
}
//Atras
if (d3dInput.keyDown(Key.S))
{
if (!moving)
{
moveForward = velocidadCaminar;
}
else
{
moveForward = velocidadCaminar / 2;
}
moving = true;
}
//Derecha
if (d3dInput.XposRelative > 0 || d3dInput.keyDown(Key.RightArrow))
{
if (d3dInput.XposRelative > 0)
{
rotateY = (velocidadRotacion / 2);
}
else
{
rotateY = velocidadRotacion;
}
rotating = true;
rotatingY = true;
}
//Izquierda
if (d3dInput.XposRelative < 0 || d3dInput.keyDown(Key.LeftArrow))
{
if (d3dInput.XposRelative < 0)
{
rotateY = -(velocidadRotacion / 2);
}
else
{
rotateY = -velocidadRotacion;
}
rotating = true;
rotatingY = true;
}
//Mover Derecha
if (d3dInput.keyDown(Key.D))
{
if (!moving)
{
moveSide = -velocidadCaminar;
}
else
{
moveSide = -velocidadCaminar / 2;
}
moving = true;
}
//Mover Izquierda
if (d3dInput.keyDown(Key.A))
{
if (!moving)
{
moveSide = velocidadCaminar;
}
else
{
moveSide = velocidadCaminar / 2;
}
moving = true;
}
/* //Arriba
* if (d3dInput.YposRelative < 0)
* {
* //if (camara.RotationX > -(Math.PI / 3))
* //{
* rotateX = -velocidadRotacion;
* rotating = true;
* rotatingX = true;
* //}
* }
*
* //Abajo
* if (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) || d3dInput.buttonDown(TgcD3dInput.MouseButtons.BUTTON_RIGHT))
{
mira.Enabled = true;
animationAction = "WeaponPos";
if (d3dInput.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
this.fire();
}
}
//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);
this.personaje.rotateY(rotAngleY);
this.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);
* this.camara.rotateX(rotAngleX);
*
* }*/
}
//Si hubo desplazamiento
if (moving)
{
//Activar animacion de caminando
if (running)
{
this.personaje.playAnimation("Run", true);
}
else if (jumping)
{
this.personaje.playAnimation("Jump", true);
}
else
{
this.personaje.playAnimation("Walk", true);
}
}
//Si no se esta moviendo, activar animationAction
else
{
this.personaje.playAnimation(animationAction, true);
}
if (life <= 0)
{
this.personaje.playAnimation("Muerte", 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(this.personaje.Rotation.Y) * moveForward) + (FastMath.Cos(this.personaje.Rotation.Y) * moveSide),
jump,
(FastMath.Cos(this.personaje.Rotation.Y) * moveForward) + (-FastMath.Sin(this.personaje.Rotation.Y) * moveSide)
);
}
//Mover personaje con detección de colisiones, sliding y gravedad
Vector3 realMovement;
if (collisionWithCharacters(movementVector))
{
realMovement = Vector3.Empty;
}
else
{
realMovement = collisionManager.moveCharacter(this.characterSphere, movementVector, this.objetosColisionables);
}
this.personaje.move(realMovement);
//Actualizar valores de la linea de movimiento
this.directionArrow.PStart = characterSphere.Center;
this.directionArrow.PEnd = characterSphere.Center + Vector3.Multiply(movementVector, 50);
this.directionArrow.updateValues();
//Caargar desplazamiento realizar en UserVar
GuiController.Instance.UserVars.setValue("Movement", TgcParserUtils.printVector3(realMovement));
Rendering:
//Render linea
if (renderDirectionArrow)
{
this.directionArrow.render();
}
this.renderBullets();
//Render personaje
this.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();
}
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 string ToString()
{
return("Index: " + vbIndex + ", Pos: " + TgcParserUtils.printVector3(position));
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
showAcumTime += elapsedTime;
TgcKinectSkeletonData data = tgcKinect.update();
if (data.Active)
{
tgcKinect.DebugSkeleton.render(data.Current.KinectSkeleton);
//Buscar gesto en mano derecha
TgcKinectSkeletonData.AnalysisData rAnalysisData = data.HandsAnalysisData[TgcKinectSkeletonData.RIGHT_HAND];
if (showAcumTime > 0.3f)
{
showAcumTime = 0;
estadisticas = "Diff AvgZ: " + printFloat(rAnalysisData.Z.DiffAvg) + ", AvgZ: " + printFloat(rAnalysisData.Z.Avg) + ", varX: " + printFloat(rAnalysisData.X.Variance) + " varY: " + printFloat(rAnalysisData.Y.Variance);
posicion = "Pos rHand: " + TgcParserUtils.printVector3(data.Current.RightHandSphere.Center);
}
GuiController.Instance.Text3d.drawText(estadisticas, 50, 150, Color.Yellow);
GuiController.Instance.Text3d.drawText(posicion, 50, 200, Color.Yellow);
if (gestoDetectado)
{
acumTime += elapsedTime;
if (acumTime > 1)
{
gestoDetectado = false;
text.Color = Color.Red;
text.Text = "Nada";
}
}
else
{
/*
* if ((rAnalysisData.Z.Max - rAnalysisData.Z.Min) > 10f)
* {
* gestoDetectado = true;
* acumTime = 0;
* text.Color = Color.Green;
* text.Text = "Abriendo cajon";
* }
*/
float diff = (float)GuiController.Instance.Modifiers["diff"];
//Gesto de abrir cajon
if (rAnalysisData.Z.DiffAvg < diff && FastMath.Abs(rAnalysisData.X.Variance) < 5f && FastMath.Abs(rAnalysisData.Y.Variance) < 10f)
{
gestoDetectado = true;
acumTime = 0;
text.Color = Color.Green;
text.Text = "Abriendo cajon";
}
}
}
text.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 string ToString()
{
return("Center " + TgcParserUtils.printVector3(center) + ", Radius " + TgcParserUtils.printVector3(radius));
}
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 Update()
{
PreUpdate();
//obtener velocidades de Modifiers
var velocidadCaminar = (float)Modifiers.getValue("VelocidadCaminar");
var velocidadRotacion = (float)Modifiers.getValue("VelocidadRotacion");
//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.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);
}
//Vector de movimiento
var 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)Modifiers["HabilitarGravedad"];
collisionManager.GravityForce = (Vector3)Modifiers["Gravedad"];
collisionManager.SlideFactor = (float)Modifiers["SlideFactor"];
//Mover personaje con detección de colisiones, sliding y gravedad
var realMovement = collisionManager.moveCharacter(characterSphere, movementVector, objetosColisionables);
personaje.move(realMovement);
//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();
//Cargar desplazamiento realizar en UserVar
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();
foreach (var mesh in escenario.Meshes)
{
Vector3 q;
if (TgcCollisionUtils.intersectSegmentAABB(Camara.Position, camaraInterna.Target,
mesh.BoundingBox, out q))
{
objectsBehind.Add(mesh);
}
else
{
objectsInFront.Add(mesh);
}
}
}
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();
}
/// <summary>
/// Método que se llama cuando se quiere exportar la informacion de la escena a un XML.
///
///
/// MODIFICAR ESTA SECCION PARA ADAPTARSE A LAS NECESIDADES DEL ALUMNO
///
///
///
/// </summary>
internal void exportScene(string savePath)
{
//Crea XML
XmlDocument doc = new XmlDocument();
XmlNode root = doc.CreateElement("SceneEditor-Export");
//Guardar info del terreno
XmlElement terrainNode = doc.CreateElement("Terrain");
TgcSimpleTerrain terrain = modifier.EditorControl.TgcTerrain;
if (terrain != null)
{
terrainNode.SetAttribute("enable", true.ToString());
terrainNode.SetAttribute("heightmap", modifier.EditorControl.heighmap.Text);
terrainNode.SetAttribute("texture", modifier.EditorControl.terrainTexture.Text);
terrainNode.SetAttribute("xzScale", modifier.EditorControl.terrainXZscale.Value.ToString());
terrainNode.SetAttribute("yScale", modifier.EditorControl.terrainYscale.Value.ToString());
terrainNode.SetAttribute("center", TgcParserUtils.printVector3FromString(
modifier.EditorControl.terrainCenterX.Text,
modifier.EditorControl.terrainCenterY.Text,
modifier.EditorControl.terrainCenterZ.Text));
}
else
{
terrainNode.SetAttribute("enable", false.ToString());
}
root.AppendChild(terrainNode);
//Recorrer Meshes del escenario, ordenadas por grupo
List <SceneEditorMeshObject> meshObjects = modifier.EditorControl.getMeshObjectsOrderByGroup();
XmlElement meshesNode = doc.CreateElement("Meshes");
int groupIndex = -1;
XmlElement lastGroupNode = null;
foreach (SceneEditorMeshObject meshObject in meshObjects)
{
//Crear grupo con corte de control
if (meshObject.groupIndex > groupIndex)
{
groupIndex = meshObject.groupIndex;
lastGroupNode = doc.CreateElement("MeshGroup");
lastGroupNode.SetAttribute("groupIndex", groupIndex.ToString());
meshesNode.AppendChild(lastGroupNode);
}
//Guardar info de mesh
TgcMesh mesh = meshObject.mesh;
XmlElement meshNode = doc.CreateElement("Mesh");
meshNode.SetAttribute("name", meshObject.name);
meshNode.SetAttribute("index", meshObject.index.ToString());
meshNode.SetAttribute("file", meshObject.fileName);
meshNode.SetAttribute("folder", meshObject.folderName);
meshNode.SetAttribute("position", TgcParserUtils.printVector3(mesh.Position));
meshNode.SetAttribute("rotation", TgcParserUtils.printVector3(mesh.Rotation));
meshNode.SetAttribute("scale", TgcParserUtils.printVector3(mesh.Scale));
meshNode.SetAttribute("userInfo", meshObject.userInfo);
lastGroupNode.AppendChild(meshNode);
}
root.AppendChild(meshesNode);
//Guardar XML
doc.AppendChild(root);
doc.Save(savePath);
}
public override string ToString()
{
return("Pos: " + TgcParserUtils.printVector3(pos) + ", UV: " + TgcParserUtils.printVector2(uv));
}
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();
}
}