public override void Update()
{
PreUpdate();
//Si hacen clic con el mouse, ver si hay colision con el suelo
if (Input.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
//primera vez
if (!selecting)
{
//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 initSelectionPoint))
{
selecting = true;
modelosSeleccionados.Clear();
}
}
//Si se está seleccionado, generar box de seleccion
else
{
//Detectar nuevo punto de colision con el piso
pickingRay.updateRay();
TGCVector3 collisionPoint;
if (TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, suelo.BoundingBox, out collisionPoint))
{
//Obtener extremos del rectángulo de selección
var min = TGCVector3.Minimize(initSelectionPoint, collisionPoint);
var max = TGCVector3.Maximize(initSelectionPoint, collisionPoint);
min.Y = 0;
max.Y = SELECTION_BOX_HEIGHT;
//Configurar BOX
selectionBox.setExtremes(min, max);
selectionBox.updateValues();
}
}
}
//Solto el clic del mouse, terminar la selección
if (Input.buttonUp(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
selecting = false;
//Ver que modelos quedaron dentro del area de selección seleccionados
foreach (var mesh in modelos)
{
//Colisión de AABB entre área de selección y el modelo
if (TgcCollisionUtils.testAABBAABB(selectionBox.BoundingBox, mesh.BoundingBox))
{
modelosSeleccionados.Add(mesh);
}
}
}
PostUpdate();
}
private void _Pick()
{
var input = GuiController.Instance.D3dInput;
var left = TgcD3dInput.MouseButtons.BUTTON_LEFT;
var right = TgcD3dInput.MouseButtons.BUTTON_RIGHT;
if (input.buttonPressed(left))
{
_PickingRay.updateRay();
var ray = _PickingRay.Ray;
var picked = _Actives.FirstOrDefault(i => i.Intercepts(ray));
if (picked != null)
{
Remove(picked);
}
else if (_Menu.Intercepts(ray))
{
picked = _Menu.Pick(ray);
}
_Selected = picked;
}
else if (input.buttonPressed(right))
{
_PickingRay.updateRay();
var ray = _PickingRay.Ray;
var picked = _Actives.FirstOrDefault(i => i.Intercepts(ray));
if (picked != null)
{
_Menu.Add(Remove(picked));
}
}
}
public bool IntersectsWithObject(TgcBoundingAxisAlignBox objectAABB, float distance)
{
pickingRay.updateRay();
bool intersected = TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, objectAABB, out TGCVector3 collisionPoint);
bool inSight = Math.Sqrt(TGCVector3.LengthSq(pickingRay.Ray.Origin, collisionPoint)) < distance;
return(intersected && inSight);
}
/// <summary>
/// Detectar el eje seleccionado
/// </summary>
public void detectSelectedAxis(TgcPickingRay pickingRay)
{
pickingRay.updateRay();
TGCVector3 collP;
//Buscar colision con eje con Picking
if (TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, boxX.BoundingBox, out collP))
{
SelectedAxis = Axis.X;
selectedAxisBox = boxX;
}
else if (TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, boxY.BoundingBox, out collP))
{
SelectedAxis = Axis.Y;
selectedAxisBox = boxY;
}
else if (TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, boxZ.BoundingBox, out collP))
{
SelectedAxis = Axis.Z;
selectedAxisBox = boxZ;
}
else
{
SelectedAxis = Axis.None;
selectedAxisBox = null;
}
//Desplazamiento inicial
if (SelectedAxis != Axis.None)
{
initMouseP = new TGCVector2(input.XposRelative, input.YposRelative);
}
}
public void Update(TgcD3dInput Input)
{
efecto.SetValue("_Time", GameModel.time);
efecto.SetValue("alturaEnY", GameLogic.cantidadZombiesMuertos * 10);
#region chequeoDeColision
//Si hacen clic con el mouse, ver si hay colision RayAABB
if (Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
pickingRay.updateRay();
//Testear Ray contra el AABB de todos los meshes
foreach (var unaPlataforma in plataformas)//.Where(p => !p.ocupado).ToList())
{
var aabb = unaPlataforma.mesh.BoundingBox;
//Ejecutar test, si devuelve true se carga el punto de colision collisionPoint
selected = TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, aabb, out collisionPoint);
if (selected)
{
plataformaSeleccionada = unaPlataforma;
unaPlataforma.mesh.BoundingBox.setRenderColor(Color.LightBlue);
break;
}
}
}
#endregion
}
public void Update(TgcD3dInput Input)
{
#region chequeoDeColision
//Si hacen clic con el mouse, ver si hay colision RayAABB
if (Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
pickingRay.updateRay();
//Testear Ray contra el AABB de todos los meshes
foreach (var unItem in items)//.Where(p => !p.ocupado).ToList())
{
var aabb = unItem.mesh.BoundingBox;
//Ejecutar test, si devuelve true se carga el punto de colision collisionPoint
selected = TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, aabb, out collisionPoint);
if (selected)
{
itemSeleccionado = unItem;
unItem.mesh.BoundingBox.setRenderColor(Color.LightBlue);
itemSeleccionado.manejarEvento();
break;
}
}
}
#endregion
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Si hacen clic con el mouse, ver si hay colision RayAABB
if (GuiController.Instance.D3dInput.buttonPressed(TgcViewer.Utils.Input.TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
//Actualizar Ray de colisión en base a posición del mouse
pickingRay.updateRay();
//Testear Ray contra el AABB de todos los meshes
foreach (TgcBox box in boxes)
{
TgcBoundingBox 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 (TgcBox box in boxes)
{
box.render();
}
//Renderizar BoundingBox del mesh seleccionado
if (selected)
{
//Render de AABB
selectedMesh.BoundingBox.render();
//Cargar punto de colision
GuiController.Instance.UserVars.setValue("CollP-X:", collisionPoint.X);
GuiController.Instance.UserVars.setValue("CollP-Y:", collisionPoint.Y);
GuiController.Instance.UserVars.setValue("CollP-Z:", collisionPoint.Z);
//Dibujar caja que representa el punto de colision
collisionPointMesh.Position = collisionPoint;
collisionPointMesh.render();
}
else
{
//Reset de valores
GuiController.Instance.UserVars.setValue("CollP-X:", 0);
GuiController.Instance.UserVars.setValue("CollP-Y:", 0);
GuiController.Instance.UserVars.setValue("CollP-Z:", 0);
}
}
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();
}
private TGCVector3 PerformPicking()
{
pickingRay.updateRay();
var ray = pickingRay.Ray;
float distance = 0.0f;
TGCVector3 point = TGCVector3.Empty;
TgcCollisionUtils.intersectRaySphere(ray, boundingSphere, out distance, out point);
return(point);
}
/// <summary>
/// Retorna la posicion del mouse en el terreno, usando el metodo de picking configurado.
/// </summary>
/// <param name="position"></param>
/// <returns></returns>
public bool mousePositionInTerrain(out Vector3 position)
{
pickingRay.updateRay();
if (PlanePicking)
{
return(Terrain.intersectRayPlane(pickingRay.Ray, out position));
}
else
{
return(Terrain.intersectRay(pickingRay.Ray, out position));
}
}
public bool DetectarClick(TgcPickingRay pickingRay)
{
pickingRay.updateRay();
var output = TGCVector3.One;
if (TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, mesh.BoundingBox, out output))
{
return(true);
}
return(false);
}
public override void Render()
{
PreRender();
var size = (Vector2)Modifiers.getValue("size");
var position = (Vector3)Modifiers.getValue("position");
var rotation = (Vector3)Modifiers.getValue("rotation");
collider.Center = position;
collider.Rotation = rotation;
collider.Radius = size.X;
collider.Length = size.Y;
collider.updateValues();
if (TgcCollisionUtils.testSphereCylinder(collisionableSphere, collider))
{
collisionableSphere.setRenderColor(collisionColor);
}
else
{
collisionableSphere.setRenderColor(noCollisionColor);
}
if (pickingTimeLeft > 0)
{
pickingTimeLeft -= ElapsedTime;
}
else
{
collider.setRenderColor(noCollisionColor);
}
if (TgcD3dInput.Instance.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
var pickingRay = new TgcPickingRay();
pickingRay.updateRay();
if (TgcCollisionUtils.testRayCylinder(pickingRay.Ray, collider))
{
pickingTimeLeft = PICKING_TIME;
collider.setRenderColor(pickingColor);
}
}
collider.render();
collisionableSphere.render();
PostRender();
}
/// <summary>
/// Hacer picking y seleccionar modelo si hay colision
/// </summary>
private void findSelectedMeshWithPicking()
{
pickingRay.updateRay();
Vector3 collisionP;
//Hacer picking sobre todos los modelos y quedarse con el mas cerca
float minDistance = float.MaxValue;
SceneEditorMeshObject collisionMeshObj = null;
foreach (SceneEditorMeshObject meshObj in meshObjects)
{
if (!meshObj.visible)
{
continue;
}
//Si ya está seleccionado ignorar
if (isMeshObjectSelected(meshObj))
{
continue;
}
TgcBoundingBox aabb = meshObj.mesh.BoundingBox;
bool result = TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, aabb, out collisionP);
if (result)
{
float lengthSq = Vector3.Subtract(collisionP, pickingRay.Ray.Origin).LengthSq();
if (lengthSq < minDistance)
{
minDistance = lengthSq;
collisionMeshObj = meshObj;
}
}
}
//Seleccionar objeto
if (collisionMeshObj != null)
{
//Deseleccionar todo
for (int i = 0; i < dataGridMeshList.Rows.Count; i++)
{
dataGridMeshList.Rows[i].Selected = false;
}
//Seleccionar objeto del dataGrid
dataGridMeshList.Rows[collisionMeshObj.index].Selected = true;
dataGridMeshList_RowEnter(null, null);
}
}
public override void render(float elapsedTime)
{
TgcModifiers modifiers = GuiController.Instance.Modifiers;
Vector2 size = (Vector2)modifiers.getValue("size");
Vector3 position = (Vector3)modifiers.getValue("position");
Vector3 rotation = (Vector3)modifiers.getValue("rotation");
collider.Center = position;
collider.Rotation = rotation;
collider.Radius = size.X;
collider.Length = size.Y;
collider.updateValues();
if (TgcCollisionUtils.testSphereCylinder(collisionableSphere, collider))
{
collisionableSphere.setRenderColor(collisionColor);
}
else
{
collisionableSphere.setRenderColor(noCollisionColor);
}
if (pickingTimeLeft > 0)
{
pickingTimeLeft -= elapsedTime;
}
else
{
collider.setRenderColor(noCollisionColor);
}
if (GuiController.Instance.D3dInput.buttonPressed(TgcViewer.Utils.Input.TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
TgcPickingRay pickingRay = new TgcPickingRay();
pickingRay.updateRay();
if (TgcCollisionUtils.testRayCylinder(pickingRay.Ray, collider))
{
pickingTimeLeft = PICKING_TIME;
collider.setRenderColor(pickingColor);
}
}
collider.render();
collisionableSphere.render();
}
private TgcMesh pickVegetation(TgcTerrainEditor editor)
{
TgcPickingRay ray = new TgcPickingRay();
ray.updateRay();
float minT = -1;
TgcMesh closerMesh = null;
foreach (TgcMesh v in editor.Vegetation)
{
Vector3 q;
if (TgcCollisionUtils.intersectRayAABB(ray.Ray, v.BoundingBox, out q))
{
float t = 0;
if (q != ray.Ray.Origin)
{
if (ray.Ray.Direction.X != 0)
{
t = (q.X - ray.Ray.Origin.X) / ray.Ray.Direction.X;
}
else if (ray.Ray.Direction.Y != 0)
{
t = (q.Y - ray.Ray.Origin.Y) / ray.Ray.Direction.Y;
}
else if (ray.Ray.Direction.Z != 0)
{
t = (q.Z - ray.Ray.Origin.Z) / ray.Ray.Direction.Z;
}
}
if (minT == -1 || t < minT)
{
minT = t;
closerMesh = v;
}
}
}
if (closerMesh != null)
{
editor.removeVegetation(closerMesh);
}
return(closerMesh);
}
private void CheckClick()
{
bool click = Input.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT);
if (click)
{
ray.updateRay();
// me fijo si hubo colision con nave ---> NO SE ESTA USANDO
/*List<TgcMesh> meshesNave = Nave.Instance().obtenerMeshes();
* foreach (TgcMesh mesh in meshesNave)
* {
* var aabb = mesh.BoundingBox;
*
* var selected = TgcCollisionUtils.intersectRayAABB(ray.Ray, aabb, out collisionPoint);
* if (selected)
* {
* Nave.Instance().Interact();
* break;
* }
* }*/
List <Entity> entities = Entities.GetEntities();
foreach (Entity entity in entities)
{
var aabb = entity.GetMesh().BoundingBox;
var selected = TgcCollisionUtils.intersectRayAABB(ray.Ray, aabb, out collisionPoint);
if (selected)
{
var distance = TGCVector3.Length(entity.Position() - Camara.Position);
if (distance <= entity.GetMaxClickDistance())
{
entity.Interact();
}
break;
}
}
}
}
private void obtenerCajaCollisionada()
{
selected = false;
//Si hacen clic con el mouse, ver si hay colision RayAABB
if (GuiController.Instance.D3dInput.buttonPressed(TgcViewer.Utils.Input.TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
//Actualizar Ray de colisión en base a posición del mouse
pickingRay.updateRay();
bool valida = false;
//Testear Ray contra el AABB de todos los meshes
selectedMeshAux = null;
foreach (BoundingBoxExtendida box in boxes)
{
TgcBoundingBox aabb = box.BoundingBox;
//Ejecutar test, si devuelve true se carga el punto de colision collisionPoint
valida = TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, aabb, out collisionPoint);
if (valida)
{
if (selectedMeshAux == null)
{
selectedMesh = box;
selectedMeshAux = box;
selected = true;
}
else
{
if (this.evaluarDistancia(box, selectedMeshAux))
{
selectedMesh = box;
selectedMeshAux = box;
}
}
}
}
}
}
public override void Update()
{
//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;
}
}
}
}
public override void Renderizar()
{
if (contexto.Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
pickingRay.updateRay();
foreach (var boton in botones)
{
TGCVector3 collisionPoint;
var selected = TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, boton.AABB, out collisionPoint);
if (selected)
{
boton.Accion();
break;
}
}
}
foreach (var boton in botones)
{
boton.Render(contexto);
}
}
public override void Render()
{
if (Env.Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
//Actualizar Ray de colision en base a posicion del mouse
pickingRay.updateRay();
foreach (var button in buttons)
{
var aabb = button.AABB();
TGCVector3 collisionPoint;
var selected = TgcCollisionUtils.intersectRayAABB(pickingRay.Ray, aabb, out collisionPoint);
if (selected)
{
button.Click();
break;
}
}
}
preRender3D();
baseRender();
hasMuerto.render();
foreach (var plano in ListaPlanos)
{
plano.Render();
}
foreach (var button in buttons)
{
button.Render(Env);
}
foreach (var plano in ListaPlanoAcido)
{
plano.Render();
}
postRender3D();
render2D();
}
/// <summary>
/// Actualizar eventos
/// </summary>
public void update()
{
TgcD3dInput input = GuiController.Instance.D3dInput;
TgcPickingRay pickingRay = editablePoly.Control.PickingRay;
switch (currentState)
{
case State.Init:
acumMovement = Vector3.Empty;
gizmoMesh.unSelect();
//Iniciar seleccion de eje
if (input.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
//Buscar colision con ejes del gizmo
pickingRay.updateRay();
gizmoMesh.selectAxisByPicking(pickingRay.Ray);
if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.X)
{
initMouseP3d = editablePoly.Control.Grid.getPickingX(pickingRay.Ray, gizmoMesh.GizmoCenter);
}
else if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.Y)
{
initMouseP3d = editablePoly.Control.Grid.getPickingY(pickingRay.Ray, gizmoMesh.GizmoCenter);
}
else if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.Z)
{
initMouseP3d = editablePoly.Control.Grid.getPickingZ(pickingRay.Ray, gizmoMesh.GizmoCenter);
}
else if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.XZ)
{
initMouseP3d = editablePoly.Control.Grid.getPickingXZ(pickingRay.Ray, gizmoMesh.GizmoCenter);
}
else if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.XY)
{
initMouseP3d = editablePoly.Control.Grid.getPickingXY(pickingRay.Ray, gizmoMesh.GizmoCenter);
}
else if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.YZ)
{
initMouseP3d = editablePoly.Control.Grid.getPickingYZ(pickingRay.Ray, gizmoMesh.GizmoCenter);
}
//Si eligio un eje, iniciar dragging
if (gizmoMesh.SelectedAxis != TranslateGizmoMesh.Axis.None)
{
currentState = State.Dragging;
}
else
{
if (input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
bool additive = input.keyDown(Microsoft.DirectX.DirectInput.Key.LeftControl) || input.keyDown(Microsoft.DirectX.DirectInput.Key.RightControl);
editablePoly.CurrentState = EditablePoly.State.SelectObject;
editablePoly.doDirectSelection(additive);
}
}
}
//Hacer mouse over sobre los ejes
else
{
//Buscar colision con eje con Picking
pickingRay.updateRay();
gizmoMesh.selectAxisByPicking(pickingRay.Ray);
}
break;
case State.Dragging:
//Mover
if (input.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
pickingRay.updateRay();
Vector3 endMouseP3d = initMouseP3d;
//Solo se mueve un eje
Vector3 currentMove = new Vector3(0, 0, 0);
if (gizmoMesh.isSingleAxis(gizmoMesh.SelectedAxis))
{
//Desplazamiento en eje X
if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.X)
{
endMouseP3d = editablePoly.Control.Grid.getPickingX(pickingRay.Ray, gizmoMesh.GizmoCenter);
currentMove.X = endMouseP3d.X - initMouseP3d.X;
}
//Desplazamiento en eje Y
else if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.Y)
{
endMouseP3d = editablePoly.Control.Grid.getPickingY(pickingRay.Ray, gizmoMesh.GizmoCenter);
currentMove.Y = endMouseP3d.Y - initMouseP3d.Y;
}
//Desplazamiento en eje Z
else if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.Z)
{
endMouseP3d = editablePoly.Control.Grid.getPickingZ(pickingRay.Ray, gizmoMesh.GizmoCenter);
currentMove.Z = endMouseP3d.Z - initMouseP3d.Z;
}
}
//Desplazamiento en dos ejes
else
{
//Plano XZ
if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.XZ)
{
endMouseP3d = editablePoly.Control.Grid.getPickingXZ(pickingRay.Ray, gizmoMesh.GizmoCenter);
currentMove.X = endMouseP3d.X - initMouseP3d.X;
currentMove.Z = endMouseP3d.Z - initMouseP3d.Z;
}
//Plano XY
else if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.XY)
{
endMouseP3d = editablePoly.Control.Grid.getPickingXY(pickingRay.Ray, gizmoMesh.GizmoCenter);
currentMove.X = endMouseP3d.X - initMouseP3d.X;
currentMove.Y = endMouseP3d.Y - initMouseP3d.Y;
}
//Plano YZ
else if (gizmoMesh.SelectedAxis == TranslateGizmoMesh.Axis.YZ)
{
endMouseP3d = editablePoly.Control.Grid.getPickingYZ(pickingRay.Ray, gizmoMesh.GizmoCenter);
currentMove.Y = endMouseP3d.Y - initMouseP3d.Y;
currentMove.Z = endMouseP3d.Z - initMouseP3d.Z;
}
}
//Actualizar pos del mouse 3D para proximo cuadro
initMouseP3d = endMouseP3d;
//Ajustar currentMove con Snap to grid
if (editablePoly.Control.SnapToGridEnabled)
{
snapMovementToGrid(ref currentMove.X, ref acumMovement.X, editablePoly.Control.SnapToGridCellSize);
snapMovementToGrid(ref currentMove.Y, ref acumMovement.Y, editablePoly.Control.SnapToGridCellSize);
snapMovementToGrid(ref currentMove.Z, ref acumMovement.Z, editablePoly.Control.SnapToGridCellSize);
}
if (currentMove.LengthSq() > 0.1f)
{
//Mover objetos
foreach (EditPolyPrimitive p in editablePoly.SelectionList)
{
p.move(currentMove);
}
//Mover ejes
gizmoMesh.moveGizmo(currentMove);
//Actualizar mesh
editablePoly.setDirtyValues(false);
//Actualizar datos de modify
//Control.updateModifyPanel();
}
}
//Soltar movimiento
else if (input.buttonUp(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
currentState = State.Init;
gizmoMesh.unSelect();
}
break;
}
//Ajustar tamaño de ejes
gizmoMesh.setCenter(gizmoMesh.GizmoCenter, editablePoly.Control.Camera);
}
public override void Update()
{
var velocidadCaminar = 25f * 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;
}
//Si hubo desplazamiento
if (moving)
{
//Aplicar movimiento
colliderCylinder.Center += movement;
colliderCylinderFixedY.Center += movement;
personaje.Position += movement;
//Activar animacion de caminando
personaje.playAnimation("Caminando", true);
}
else
{
//Si no se esta moviendo, activar animacion de Parado
personaje.playAnimation("Parado", true);
}
var size = sizeModifier.Value;
var rotation = rotationModifier.Value;
//Se tienen dos coliders, un cilindro con rotacion y otro orientado al eje Y.
colliderCylinder.Rotation = rotation;
colliderCylinder.Radius = size.X;
colliderCylinder.Length = size.Y;
//Actualizar este cilindro es mas costoso.
colliderCylinder.updateValues();
//Cilindro sin rotacion, para ser utilizado con personajes.
colliderCylinderFixedY.Radius = size.X;
colliderCylinderFixedY.Length = size.Y;
//Un cilindro orientado es facil de actualizar.
colliderCylinderFixedY.updateValues();
if (fixedYModifier.Value)
{
//Test de colisiones del cilindro orientado en Y, al ser mucho mas simple tiene mas test soportados por el framework.
if (TgcCollisionUtils.testSphereCylinder(collisionableSphere, colliderCylinderFixedY))
{
collisionableSphere.setRenderColor(collisionColor);
}
else
{
collisionableSphere.setRenderColor(noCollisionColor);
}
if (TgcCollisionUtils.testAABBCylinder(collisionableMeshAABB.BoundingBox, colliderCylinderFixedY))
{
collisionableMeshAABB.BoundingBox.setRenderColor(collisionColor);
}
else
{
collisionableMeshAABB.BoundingBox.setRenderColor(noCollisionColor);
}
if (TgcCollisionUtils.testCylinderCylinder(collisionableCylinder, colliderCylinderFixedY))
{
collisionableCylinder.setRenderColor(collisionColor);
}
else
{
collisionableCylinder.setRenderColor(noCollisionColor);
}
if (pickingTimeLeft > 0)
{
pickingTimeLeft -= ElapsedTime;
}
else
{
colliderCylinderFixedY.setRenderColor(noCollisionColor);
}
if (Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
var pickingRay = new TgcPickingRay(Input);
pickingRay.updateRay();
if (TgcCollisionUtils.testRayCylinder(pickingRay.Ray, colliderCylinderFixedY))
{
pickingTimeLeft = PICKING_TIME;
colliderCylinderFixedY.setRenderColor(pickingColor);
}
}
}
else
{
//Test de colisiones del cilindro, la cantidad de test que tiene el framewor es acotada.
if (TgcCollisionUtils.testSphereCylinder(collisionableSphere, colliderCylinder))
{
collisionableSphere.setRenderColor(collisionColor);
}
else
{
collisionableSphere.setRenderColor(noCollisionColor);
}
if (pickingTimeLeft > 0)
{
pickingTimeLeft -= ElapsedTime;
}
else
{
colliderCylinder.setRenderColor(noCollisionColor);
}
if (Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
var pickingRay = new TgcPickingRay(Input);
pickingRay.updateRay();
if (TgcCollisionUtils.testRayCylinder(pickingRay.Ray, colliderCylinder))
{
pickingTimeLeft = PICKING_TIME;
colliderCylinder.setRenderColor(pickingColor);
}
}
}
//Hacer que la camara siga al personaje en su nueva posicion
camaraInterna.Target = personaje.Position;
}
/// <summary>
/// método que detecta el input del usuario y realiza acciones en base a eso
/// </summary>
private void detectUserInput()
{
if (Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
pickingRay.updateRay();
testPicking();
}
else if (Input.keyPressed(Key.LeftArrow))
{
Player1.selectPreviousItem();
soundPlayer.playActionSound(SoundPlayer.Actions.Menu_Next);
}
else if (Input.keyPressed(Key.Space))
{
soundPlayer.playActionSound(SoundPlayer.Actions.Jump);
}
else if (Input.keyPressed(Key.RightArrow))
{
Player1.selectNextItem();
soundPlayer.playActionSound(SoundPlayer.Actions.Menu_Next);
}
else if (Input.keyPressed(Key.E))
{
if (null != Player1.SelectedItem && Player1.SelectedItem.isEquippable())
{
soundPlayer.playActionSound(SoundPlayer.Actions.Menu_Select);
Player1.equipSelectedItem();
}
else
{
//intento consumir el item ya que no era equipable
if (null != Player1.SelectedItem && Player1.consumeItem())
{
soundPlayer.playActionSound(SoundPlayer.Actions.Drink);
}
else
{
soundPlayer.playActionSound(SoundPlayer.Actions.Menu_Wrong);
}
}
}
else if (Input.keyPressed(Key.Q))
{
Player1.removeInventoryObject(Player1.SelectedItem);
soundPlayer.playActionSound(SoundPlayer.Actions.Menu_Discard);
}
else if (Input.keyPressed(Key.Z))
{
Player1.selectForCombination(Player1.SelectedItem);
soundPlayer.playActionSound(SoundPlayer.Actions.Menu_Select);
}
else if (Input.keyPressed(Key.C))
{
if (!InventoryObject.combineObjects(Player1, Player1.combinationSelection))
{
//falló la combinación
soundPlayer.playActionSound(SoundPlayer.Actions.Menu_Wrong);
}
else
{
//comb ok
soundPlayer.playActionSound(SoundPlayer.Actions.Success);
}
}
else if (Input.keyPressed(Key.RightShift))
{
//god mode!
if (!GodMode)
{
GodMode = true;
MyCamera.WalkingSpeed = MyCamera.WalkingSpeed * 5;
MyCamera.RunningSpeed = MyCamera.RunningSpeed * 5;
Player1.Stamina = 9999;
Player1.BaseDamage = 100;
setTopRightText("Modo Dios Activado");
}
else
{
GodMode = false;
MyCamera.WalkingSpeed = MyCamera.WalkingSpeed / 5;
MyCamera.RunningSpeed = MyCamera.RunningSpeed / 5;
Player1.Stamina = 100;
Player1.BaseDamage = 1;
setTopRightText("Modo Dios Desactivado");
}
}
}
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();
}
