public override void Render()
{
PreRender();
//Ver si cambio el modelo elegido por el usuario
var selectedPath = (string)Modifiers["Mesh"];
if (selectedPath != currentMeshFile)
{
//cargar nuevo modelo
currentMeshFile = selectedPath;
loadMesh(currentMeshFile);
//Actualizar contadores de triangulos y vertices
UserVars.setValue("Vertices", mesh.NumberVertices);
UserVars.setValue("Triangles", mesh.NumberFaces);
}
//Renderizar la malla.
//Hay que renderizar cada subset por separado
for (var i = 0; i < meshMaterials.Length; i++)
{
D3DDevice.Instance.Device.Material = meshMaterials[i];
D3DDevice.Instance.Device.SetTexture(0, meshTextures[i]);
mesh.DrawSubset(i);
}
PostRender();
}
public override void Update()
{
PreUpdate();
physicsExample.Update(Input);
UserVars.setValue("Tgccito_Position", physicsExample.GetCharacterPosition());
PostUpdate();
}
public override void Init()
{
//Triangulo 1.
//Definir array de vertices para el triangulo, del tipo Coordendas (X,Y,Z) + Color
simpleTriangleData = new CustomVertex.PositionColored[3];
//Cargar informacion de vertices. Nesitamos 3 vertices para crear un triangulo
simpleTriangleData[0] = new CustomVertex.PositionColored(-1, 0, 0, Color.Red.ToArgb());
simpleTriangleData[1] = new CustomVertex.PositionColored(1, 0, 0, Color.Green.ToArgb());
simpleTriangleData[2] = new CustomVertex.PositionColored(0, 1, 0, Color.Blue.ToArgb());
//Cargar variables de usuario con alguna informacion util para ver en pantalla
UserVars.addVar("Triangle 1 vertices", simpleTriangleData.Length);
//Triangulo 2.
//Current texture
currentTexurePah = MediaDir + "Texturas\\baldosaFacultad.jpg";
texture = TextureLoader.FromFile(D3DDevice.Instance.Device, currentTexurePah);
//Modifiers
vertex1Modifier = AddVertex3f("vertex1", new TGCVector3(-3, -3, -3), new TGCVector3(3, 3, 3), new TGCVector3(-1, 0, 0));
texCoord1Modifier = AddVertex2f("texCoord1", TGCVector2.Zero, TGCVector2.One, new TGCVector2(1, 0));
color1Modifier = AddColor("color1", Color.White);
vertex2Modifier = AddVertex3f("vertex2", new TGCVector3(-3, -3, -3), new TGCVector3(3, 3, 3), new TGCVector3(1, 0, 0));
texCoord2Modifier = AddVertex2f("texCoord2", TGCVector2.Zero, TGCVector2.One, new TGCVector2(0, 1));
color2Modifier = AddColor("color2", Color.White);
vertex3Modifier = AddVertex3f("vertex3", new TGCVector3(-3, -3, -3), new TGCVector3(3, 3, 3), TGCVector3.Up);
texCoord3Modifier = AddVertex2f("texCoord3", TGCVector2.Zero, TGCVector2.One, TGCVector2.One);
color3Modifier = AddColor("color3", Color.White);
rotationModifier = AddFloat("rotation", -2, 2f, 0f);
textureEnableModifier = AddBoolean("TextureEnable", "Con textura", true);
textureImageModifier = AddTexture("Texture image", currentTexurePah);
//Triangulo 3.
//Crear vertexBuffer
vertexBuffer = new VertexBuffer(typeof(CustomVertex.PositionColored), 3, D3DDevice.Instance.Device, Usage.Dynamic | Usage.WriteOnly, CustomVertex.PositionColored.Format, Pool.Default);
//Cargar informacion de vertices: (X,Y,Z) + Color
var data = new CustomVertex.PositionColored[3];
data[0] = new CustomVertex.PositionColored(-1, 0, 0, Color.Red.ToArgb());
data[1] = new CustomVertex.PositionColored(1, 0, 0, Color.Green.ToArgb());
data[2] = new CustomVertex.PositionColored(0, 1, 0, Color.Blue.ToArgb());
//Almacenar informacion en VertexBuffer
vertexBuffer.SetData(data, 0, LockFlags.None);
//User Vars
UserVars.addVar("Triangle 3 vertices");
UserVars.setValue("Triangle 3 vertices", data.Length);
//Configurar camara en rotacion
Camara = new TgcRotationalCamera(new TGCVector3(0, 0.5f, 0), 7.5f, Input);
}
public override void Update()
{
PreUpdate();
physicsExample.Update();
UserVars.setValue("MeshCount", physicsExample.GetElements());
PostUpdate();
}
public override void Render()
{
PreRender();
//Si hacen clic con el mouse, ver si hay colision RayAABB
if (Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
//Actualizar Ray de colision en base a posicion del mouse
pickingRay.updateRay();
//Testear Ray contra el AABB de todos los meshes
foreach (var box in boxes)
{
var aabb = box.BoundingBox;
//Ejecutar test, si devuelve true se carga el punto de colision collisionPoint
selected = TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, aabb, out collisionPoint);
if (selected)
{
selectedMesh = box;
break;
}
}
}
//Renderizar modelos
foreach (var box in boxes)
{
box.Render();
}
//Renderizar BoundingBox del mesh seleccionado
if (selected)
{
//Render de AABB
selectedMesh.BoundingBox.Render();
//Cargar punto de colision
UserVars.setValue("CollP-X:", collisionPoint.X);
UserVars.setValue("CollP-Y:", collisionPoint.Y);
UserVars.setValue("CollP-Z:", collisionPoint.Z);
//Dibujar caja que representa el punto de colision
collisionPointMesh.Position = collisionPoint;
collisionPointMesh.Transform = TGCMatrix.Translation(collisionPointMesh.Position);
collisionPointMesh.Render();
}
else
{
//Reset de valores
UserVars.setValue("CollP-X:", 0);
UserVars.setValue("CollP-Y:", 0);
UserVars.setValue("CollP-Z:", 0);
}
PostRender();
}
public override void Update()
{
physicsExample.Update(Input, ElapsedTime, TimeBetweenUpdates);
UserVars.setValue("HummerPositionX", physicsExample.getHummer().Position.X);
UserVars.setValue("HummerPositionY", physicsExample.getHummer().Position.Y);
UserVars.setValue("HummerPositionZ", physicsExample.getHummer().Position.Z);
UserVars.setValue("HummerBodyPositionX", physicsExample.getBodyPos().X);
UserVars.setValue("HummerBodyPositionY", physicsExample.getBodyPos().Y);
UserVars.setValue("HummerBodyPositionZ", physicsExample.getBodyPos().Z);
camaraInterna.Target = physicsExample.getHummer().Position;
}
public override void Update()
{
PreUpdate();
physicsExample.Update(Input);
UserVars.setValue("HummerPositionX", physicsExample.getHummer().Position.X);
UserVars.setValue("HummerPositionY", physicsExample.getHummer().Position.Y);
UserVars.setValue("HummerPositionZ", physicsExample.getHummer().Position.Z);
UserVars.setValue("HummerBodyPositionX", physicsExample.getBodyPos().X);
UserVars.setValue("HummerBodyPositionY", physicsExample.getBodyPos().Y);
UserVars.setValue("HummerBodyPositionZ", physicsExample.getBodyPos().Z);
camaraInterna.Target = physicsExample.getHummer().Position;
PostUpdate();
}
/// <summary>
/// Carga una malla estatica de formato TGC
/// </summary>
private void loadMesh(string path)
{
currentPath = path;
//Dispose de escena anterior
if (currentScene != null)
{
currentScene.disposeAll();
}
//Cargar escena con herramienta TgcSceneLoader
var loader = new TgcSceneLoader();
currentScene = loader.loadSceneFromFile(path);
//Ajustar camara en base al tamano del objeto
Camara = new TgcRotationalCamera(currentScene.BoundingBox.calculateBoxCenter(),
currentScene.BoundingBox.calculateBoxRadius() * 2, Input);
//Calcular cantidad de triangulos y texturas
var triangleCount = 0;
var verticesCount = 0;
var texturesCount = 0;
foreach (var mesh in currentScene.Meshes)
{
triangleCount += mesh.NumberTriangles;
verticesCount += mesh.NumberVertices;
texturesCount += mesh.RenderType == TgcMesh.MeshRenderType.VERTEX_COLOR ? 0 : mesh.DiffuseMaps.Length;
}
//UserVars
UserVars.setValue("Name", currentScene.SceneName);
UserVars.setValue("Meshes", currentScene.Meshes.Count);
UserVars.setValue("Textures", texturesCount);
UserVars.setValue("Triangles", triangleCount);
UserVars.setValue("Vertices", verticesCount);
var size = currentScene.BoundingBox.calculateSize();
UserVars.setValue("SizeX", TgcParserUtils.printFloat(size.X));
UserVars.setValue("SizeY", TgcParserUtils.printFloat(size.Y));
UserVars.setValue("SizeZ", TgcParserUtils.printFloat(size.Z));
}
public override void Render()
{
PreRender();
//Actualizar parametros de la caja
updateSphere();
UserVars.setValue("Vertices", sphere.VertexCount);
UserVars.setValue("Triangulos", sphere.TriangleCount);
//Renderizar caja
sphere.render();
//Mostrar Boundingsphere de la caja
var boundingsphere = (bool)Modifiers["boundingsphere"];
if (boundingsphere)
{
sphere.BoundingSphere.render();
}
PostRender();
}
public override void Render()
{
PreRender();
var frustumCullingEnabled = (bool)Modifiers["culling"];
//Renderizar sin ninguna optimizacion
if (!frustumCullingEnabled)
{
tgcScene.renderAll();
UserVars.setValue("Meshes renderizadas", tgcScene.Meshes.Count);
}
//Renderizar con Frustum Culling
else
{
//Analizar cada malla contra el Frustum - con fuerza bruta
var totalMeshes = 0;
foreach (var mesh in tgcScene.Meshes)
{
//Nos ocupamos solo de las mallas habilitadas
if (mesh.Enabled)
{
//Solo mostrar la malla si colisiona contra el Frustum
var r = TgcCollisionUtils.classifyFrustumAABB(TgcFrustum.Instance, mesh.BoundingBox);
if (r != TgcCollisionUtils.FrustumResult.OUTSIDE)
{
mesh.render();
totalMeshes++;
}
}
}
//Actualizar cantidad de meshes dibujadas
UserVars.setValue("Meshes renderizadas", totalMeshes);
}
PostRender();
}
public override void Init()
{
//Crear vertexBuffer
vertexBuffer = new VertexBuffer(typeof(CustomVertex.PositionColored), 3, D3DDevice.Instance.Device,
Usage.Dynamic | Usage.WriteOnly, CustomVertex.PositionColored.Format, Pool.Default);
//Cargar informacion de vertices: (X,Y,Z) + Color
var data = new CustomVertex.PositionColored[3];
data[0] = new CustomVertex.PositionColored(-1, 0, 0, Color.Red.ToArgb());
data[1] = new CustomVertex.PositionColored(1, 0, 0, Color.Green.ToArgb());
data[2] = new CustomVertex.PositionColored(0, 1, 0, Color.Blue.ToArgb());
//Almacenar información en VertexBuffer
vertexBuffer.SetData(data, 0, LockFlags.None);
//Configurar camara en rotacion
Camara = new TgcRotationalCamera(new Vector3(0, 0.5f, 0), 3f);
//User Vars
UserVars.addVar("Vertices");
UserVars.setValue("Vertices", data.Length);
}
public override void Render()
{
PreRender();
//Renderizar modelos
foreach (var box in boxes)
{
box.Render();
}
//Renderizar BoundingBox del mesh seleccionado
if (selected)
{
//Render de AABB
selectedMesh.BoundingBox.Render();
//Cargar punto de colision
UserVars.setValue("CollP-X:", collisionPoint.X);
UserVars.setValue("CollP-Y:", collisionPoint.Y);
UserVars.setValue("CollP-Z:", collisionPoint.Z);
//Dibujar caja que representa el punto de colision
collisionPointMesh.Position = collisionPoint;
collisionPointMesh.Transform = TGCMatrix.Translation(collisionPointMesh.Position);
collisionPointMesh.Render();
}
else
{
//Reset de valores
UserVars.setValue("CollP-X:", 0);
UserVars.setValue("CollP-Y:", 0);
UserVars.setValue("CollP-Z:", 0);
}
PostRender();
}
public override void Render()
{
PreRender();
//Actualizar parametros de la caja
updateSphere();
UserVars.setValue("Vertices", sphere.VertexCount);
UserVars.setValue("Triangulos", sphere.TriangleCount);
//Renderizar esfera
sphere.Transform = TGCMatrix.Scaling(sphere.Radius, sphere.Radius, sphere.Radius) * TGCMatrix.RotationYawPitchRoll(sphere.Rotation.Y, sphere.Rotation.X, sphere.Rotation.Z) * TGCMatrix.Translation(sphere.Position);
sphere.Render();
//Mostrar Boundingsphere de la caja
var boundingsphere = boundingsphereModifier.Value;
if (boundingsphere)
{
sphere.BoundingSphere.Render();
}
PostRender();
}
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 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 override void Update()
{
physicsExample.Update(ElapsedTime, TimeBetweenUpdates);
UserVars.setValue("MeshCount", physicsExample.GetElements());
}
public override void Update()
{
physicsExample.Update(Input, ElapsedTime, TimeBetweenUpdates);
UserVars.setValue("Tgccito_Position", physicsExample.GetCharacterPosition());
}
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");
//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 (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
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);
}
}
//Render mallas que no se interponen
foreach (var mesh in objectsInFront)
{
mesh.render();
if (showBB)
{
mesh.BoundingBox.render();
}
}
//Para las mallas que se interponen a la cámara, solo renderizar su BoundingBox
foreach (var mesh in objectsBehind)
{
mesh.BoundingBox.render();
}
//Render personaje
personaje.animateAndRender(ElapsedTime);
if (showBB)
{
characterSphere.render();
}
//Render linea
directionArrow.render();
//Render SkyBox
skyBox.render();
PostRender();
}
public override void 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();
}
