public override void Init()
{
//El framework posee la clase TgcSceneLoader que permite cargar modelos 3D.
//Estos modelos 3D están almacenados en un archivo XML llamado TgcScene.xml.
//Este archivo es un formato a medida hecho para el framework. Y puede ser creado desde herramientas de
//diseño como 3Ds MAX (exportando a traves de un plugin) o con el editor MeshCreator que viene con el framework.
//El framework viene con varios modelos 3D incluidos en la carpeta: TgcViewer\Examples\Media\MeshCreator\Meshes.
//El formato especifica una escena, representada por la clase TgcScene. Una escena puede estar compuesta por varios
//modelos 3D. Cada modelo se representa con la clase TgcMesh.
//En este ejemplo vamos a cargar una escena con un único modelo.
var loader = new TgcSceneLoader();
//De toda la escena solo nos interesa guardarnos el primer modelo (el único que hay en este caso).
mesh = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Meshes\\Vehiculos\\Hummer\\Hummer-TgcScene.xml").Meshes[0];
mesh.AutoTransform = true;
mesh.RotateY(FastMath.QUARTER_PI);
mesh.Move(new TGCVector3(100, 40, -200));
//mesh.Transform = TGCMatrix.RotationY(FastMath.QUARTER_PI) * TGCMatrix.Translation(100,40,-200);
//En este ejemplo no cargamos un solo modelo 3D sino una escena completa, compuesta por varios modelos.
//El framework posee varias escenas ya hechas en la carpeta TgcViewer\Examples\Media\MeshCreator\Scenes.
scene = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Scenes\\Iglesia\\Iglesia-TgcScene.xml");
//Hacemos que la cámara esté centrada sobre el mesh.
Camara = new TgcRotationalCamera(mesh.BoundingBox.calculateBoxCenter(),
mesh.BoundingBox.calculateBoxRadius() * 2, Input);
}
private void eliminarMesh()
{
TGCVector3 posicionDeBorrado = new TGCVector3(0, -4000, 0);
mesh.Move(posicionDeBorrado);
mesh.updateBoundingBox();
mesh.UpdateMeshTransform();
}
internal void HuirDe(Personaje personaje, float elapsedTime)
{
var posicionDeBorrado = new TGCVector3(ghost.Position.X + 2000, ghost.Position.Y, ghost.Position.Z - 5000);
ghost.Move(posicionDeBorrado);
ghost.updateBoundingBox();
ghost.UpdateMeshTransform();
}
private void eliminarMesh()
{
TGCVector3 posicionDeBorrado = new TGCVector3(0, -4000, 0);
mesh.Move(posicionDeBorrado);
mesh.updateBoundingBox();
mesh.UpdateMeshTransform();
//no hago el dispose aca porque sino lo tendria que sacar del TGCScene y no se si quiero hacer eso
}
public void ExecuteCollision(TgcMesh item, TgcMesh bandicoot, Core.Camara.TgcCamera camara, Core.Mathematica.TGCVector3 movimiento)
{
var anguloCamara = bandicoot.Position;
bandicoot.Move(-movimiento);
bandicoot.Transform = TGC.Core.Mathematica.TGCMatrix.Translation(-movimiento);
//Bandicoot.Move(0, direccionSalto * MOVEMENT_SPEED * ElapsedTime, 0);
camara.SetCamera((camara.Position - movimiento), anguloCamara);
}
private void MoverObjetos(TgcMesh mesh, TGCVector3 movementRay)
{
if (mesh.Name == "CajaMadera" && mesh.BoundingBox.PMax.Y >= personajePrincipal.BoundingBox.PMax.Y)
{
var lastCajaPos = mesh.Position;
if (FastMath.Abs(movementRay.X) > FastMath.Abs(movementRay.Z))
{
//personajePrincipal.playAnimation("Empujar", true);
mesh.Move(5 * Math.Sign(movementRay.X) * -1, 0, 0);
DetectarColisionesMovibles(lastCajaPos, mesh);
}
else
if (!(FastMath.Abs(movementRay.X) > FastMath.Abs(movementRay.Z)))
{
//personajePrincipal.playAnimation("Empujar", true);
mesh.Move(0, 0, 5 * Math.Sign(movementRay.Z) * -1);
DetectarColisionesMovibles(lastCajaPos, mesh);
}
}
}
public override void Update(float tiempo)
{
TGCVector3 posicionSiguiente = plataformaMesh.Position + vectorMovimiento;
//Si la plataforma colisiona con una pared, cambiamos el sentido de movimiento.
if (escenario.colisionaCon(plataformaMesh))
{
vectorMovimiento.Multiply(-1);
}
//Desplazamos la plataforma en el sentido correcto.
plataformaMesh.Move(vectorMovimiento);
}
public TgcBoundingAxisAlignBox ColisionY(Character pj, float ElapsedTime)
{
var aabb = Mesh.BoundingBox;
if (Caida)
{
if (Mesh.Position.Y > PosInicial.Y - LongitudCaida)
{
Mesh.Move(new TGCVector3(0f, -ElapsedTime * VelocidadCaida, 0f));
}
return(Escenario.EscenarioManual.testAABBAABB(pj.Mesh.BoundingBox, aabb) ? aabb : null);
}
if (Escenario.EscenarioManual.testAABBAABB(pj.Mesh.BoundingBox, aabb))
{
if (pj.Mesh.BoundingBox.PMin.Y > aabb.PMax.Y - MargenError)
{
pj.SetTipoColisionActual(TiposColision.SinColision);
return(aabb);
}
}
return(null);
}
private void animarPlataformas(float deltaTime)
{
plataforma1.Move(0, velocidadDesplazamientoPlataformas * direccionDeMovimientoActualPlataforma1 * deltaTime, 0);
if (FastMath.Abs(plataforma1.Position.Y) > 300f)
{
direccionDeMovimientoActualPlataforma1 *= -1;
}
plataforma2.Move(0, velocidadDesplazamientoPlataformas * (-direccionDeMovimientoActualPlataforma2) * deltaTime, 0);
if (FastMath.Abs(plataforma2.Position.Y) > 300f)
{
direccionDeMovimientoActualPlataforma2 *= -1;
}
}
public override void Update(float tiempo)
{
TGCVector3 posicionSiguiente = plataformaMesh.Position + vectorMovimiento;
//Si la plataforma colisiona con el piso, cambiamos el sentido de movimiento.
if (escenario.colisionaConPiso(plataformaMesh) || escenario.colisionaConLava(plataformaMesh))
{
cambiarDirMovimiento();
}
//Si la plataforma supera en una cierta cantidad de veces a su altura inicial, cambiamos el sentido de movimiento.
if (posicionSiguiente.Y >= toleranciaLimiteSuperior * posicionInicial.Y)
{
cambiarDirMovimiento();
}
//Desplazamos la plataforma en el sentido correcto.
plataformaMesh.Move(vectorMovimiento);
}
public override void Init()
{
//En este ejemplo primero cargamos una escena 3D entera.
var loader = new TgcSceneLoader();
scene = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Scenes\\Ciudad\\Ciudad-TgcScene.xml");
//Luego cargamos otro modelo aparte que va a hacer el objeto que controlamos con el teclado
var scene2 = loader.loadSceneFromFile(MediaDir + "MeshCreator\\Meshes\\Vehiculos\\Hummer\\Hummer-TgcScene.xml");
//Solo nos interesa el primer modelo de esta escena (tiene solo uno)
mainMesh = scene2.Meshes[0];
mainMesh.AutoTransformEnable = true;
//Movemos el mesh un poco para arriba. Porque sino choca con el piso todo el tiempo y no se puede mover.
mainMesh.Move(0, 5, 0);
//Vamos a utilizar la camara en 3ra persona para que siga al objeto principal a medida que se mueve
camaraInterna = new TgcThirdPersonCamera(mainMesh.Position, 200, 300);
Camara = camaraInterna;
}
private void animarBolasDeCanionYEmisoresDeParticulas(float deltaTime)
{
incrementoBola1 = velocidadDesplazamientoBolasDeCanion * deltaTime * (-1);
incrementoBola2 = velocidadDesplazamientoBolasDeCanion * deltaTime * (-1.5f);
incrementoBola3 = velocidadDesplazamientoBolasDeCanion * deltaTime * (-2);
bolaDeCanion1.Move(0, 0, incrementoBola1);
emisorDeParticulas1.Position = new TGCVector3(emisorDeParticulas1.Position.X, emisorDeParticulas1.Position.Y, emisorDeParticulas1.Position.Z + incrementoBola1);
distanciaRecorridaBola1 = distanciaRecorridaBola1 + incrementoBola1;
if (Math.Abs(distanciaRecorridaBola1) > 3000f)
{
bolaDeCanion1.Position = posicionInicialBolaDeCanion1;
emisorDeParticulas1.Position = posicionInicialEmisorDeParticulas1;
distanciaRecorridaBola1 = 0f;
}
bolaDeCanion2.Move(0, 0, incrementoBola2);
emisorDeParticulas2.Position = new TGCVector3(emisorDeParticulas2.Position.X, emisorDeParticulas2.Position.Y, emisorDeParticulas2.Position.Z + incrementoBola2);
distanciaRecorridaBola2 = distanciaRecorridaBola2 + incrementoBola2;
if (Math.Abs(distanciaRecorridaBola2) > 3000f)
{
bolaDeCanion2.Position = posicionInicialBolaDeCanion2;
emisorDeParticulas2.Position = posicionInicialEmisorDeParticulas2;
distanciaRecorridaBola2 = 0f;
}
bolaDeCanion3.Move(0, 0, incrementoBola3);
emisorDeParticulas3.Position = new TGCVector3(emisorDeParticulas3.Position.X, emisorDeParticulas3.Position.Y, emisorDeParticulas3.Position.Z + incrementoBola3);
distanciaRecorridaBola3 = distanciaRecorridaBola3 + incrementoBola3;
if (Math.Abs(distanciaRecorridaBola3) > 3000f)
{
bolaDeCanion3.Position = posicionInicialBolaDeCanion3;
emisorDeParticulas3.Position = posicionInicialEmisorDeParticulas3;
distanciaRecorridaBola3 = 0f;
}
}
public override void Update()
{
PreUpdate();
//Obtenemos acceso al objeto que maneja input de mouse y teclado del framework
var input = Input;
//Declaramos un vector de movimiento inicializado en cero.
//El movimiento sobre el suelo es sobre el plano XZ.
//Sobre XZ nos movemos con las flechas del teclado o con las letas WASD.
var movement = TGCVector3.Empty;
//Movernos de izquierda a derecha, sobre el eje X.
if (input.keyDown(Key.Left) || input.keyDown(Key.A))
{
movement.X = 1;
}
else if (input.keyDown(Key.Right) || input.keyDown(Key.D))
{
movement.X = -1;
}
//Movernos adelante y atras, sobre el eje Z.
if (input.keyDown(Key.Up) || input.keyDown(Key.W))
{
movement.Z = -1;
}
else if (input.keyDown(Key.Down) || input.keyDown(Key.S))
{
movement.Z = 1;
}
//Guardar posicion original antes de cambiarla
var originalPos = mainMesh.Position;
//Multiplicar movimiento por velocidad y elapsedTime
movement *= MOVEMENT_SPEED * ElapsedTime;
mainMesh.Move(movement);
//Chequear si el objeto principal en su nueva posición choca con alguno de los objetos de la escena.
//Si es así, entonces volvemos a la posición original.
//Cada TgcMesh tiene un objeto llamado BoundingBox. El BoundingBox es una caja 3D que representa al objeto
//de forma simplificada (sin tener en cuenta toda la complejidad interna del modelo).
//Este BoundingBox se utiliza para chequear si dos objetos colisionan entre sí.
//El framework posee la clase TgcCollisionUtils con muchos algoritmos de colisión de distintos tipos de objetos.
//Por ejemplo chequear si dos cajas colisionan entre sí, o dos esferas, o esfera con caja, etc.
var collisionFound = false;
foreach (var mesh in scene.Meshes)
{
//Los dos BoundingBox que vamos a testear
var mainMeshBoundingBox = mainMesh.BoundingBox;
var sceneMeshBoundingBox = mesh.BoundingBox;
//Ejecutar algoritmo de detección de colisiones
var collisionResult = TgcCollisionUtils.classifyBoxBox(mainMeshBoundingBox, sceneMeshBoundingBox);
//Hubo colisión con un objeto. Guardar resultado y abortar loop.
if (collisionResult != TgcCollisionUtils.BoxBoxResult.Afuera)
{
collisionFound = true;
break;
}
}
//Si hubo alguna colisión, entonces restaurar la posición original del mesh
if (collisionFound)
{
mainMesh.Position = originalPos;
}
//Hacer que la camara en 3ra persona se ajuste a la nueva posicion del objeto
camaraInterna.Target = mainMesh.Position;
PostUpdate();
}
public void Move(TGCVector3 desplazamiento) => cajaMesh.Move(desplazamiento);
public override void Update()
{
PreUpdate();
var velocidadCaminar = VELOCIDAD_DESPLAZAMIENTO * ElapsedTime;
//Calcular proxima posicion de personaje segun Input
var moving = false;
var movement = TGCVector3.Empty;
//Adelante
if (Input.keyDown(Key.W))
{
movement.Z = velocidadCaminar;
moving = true;
}
//Atras
if (Input.keyDown(Key.S))
{
movement.Z = -velocidadCaminar;
moving = true;
}
//Derecha
if (Input.keyDown(Key.D))
{
movement.X = velocidadCaminar;
moving = true;
}
//Izquierda
if (Input.keyDown(Key.A))
{
movement.X = -velocidadCaminar;
moving = true;
}
//Salto
if (Input.keyDown(Key.Space))
{
movement.Y = velocidadCaminar;
moving = true;
}
//Agachar
if (Input.keyDown(Key.LeftControl))
{
movement.Y = -velocidadCaminar;
moving = true;
}
//Si hubo desplazamiento
if (moving)
{
//Aplicar movimiento, internamente suma valores a la posicion actual del mesh.
mesh.Move(movement);
}
//Hacer que la camara siga al personaje en su nueva posicion
camaraInterna.Target = mesh.Position;
//Detectar colision con triangulo
if (TgcCollisionUtils.testTriangleAABB(TGCVector3.FromVector3(triangle[0].Position), TGCVector3.FromVector3(triangle[1].Position), TGCVector3.FromVector3(triangle[2].Position),
mesh.BoundingBox))
{
triangle[0].Color = Color.Red.ToArgb();
triangle[1].Color = Color.Red.ToArgb();
triangle[2].Color = Color.Red.ToArgb();
}
else
{
triangle[0].Color = Color.Green.ToArgb();
triangle[1].Color = Color.Green.ToArgb();
triangle[2].Color = Color.Green.ToArgb();
}
//Detectar colision con el otro AABB
if (TgcCollisionUtils.testAABBAABB(mesh.BoundingBox, box2.BoundingBox))
{
box2.Color = Color.Red;
box2.updateValues();
}
else
{
box2.Color = Color.Violet;
box2.updateValues();
}
//Detectar colision con la esfera
if (TgcCollisionUtils.testSphereAABB(boundingSphere, mesh.BoundingBox))
{
boundingSphere.setRenderColor(Color.Red);
}
else
{
boundingSphere.setRenderColor(Color.Yellow);
}
//Detectar colision con la obb
if (TgcCollisionUtils.testObbAABB(obb, mesh.BoundingBox))
{
obb.setRenderColor(Color.Red);
}
else
{
obb.setRenderColor(Color.Yellow);
}
PostUpdate();
}
public override void move(TGCVector3 move)
{
mesh.Move(move);
}