/// <summary>
/// Actualizar parámetros del plano en base a los valores configurados
/// </summary>
public void updateValues()
{
var vertices = new CustomVertex.PositionColored[6];
//Crear un Quad con dos triángulos sobre XZ con normal default (0, 1, 0)
var min = new Vector3(-Size.X / 2, 0, -Size.Y / 2);
var max = new Vector3(Size.X / 2, 0, Size.Y / 2);
var c = color.ToArgb();
vertices[0] = new CustomVertex.PositionColored(min, c);
vertices[1] = new CustomVertex.PositionColored(min.X, 0, max.Z, c);
vertices[2] = new CustomVertex.PositionColored(max, c);
vertices[3] = new CustomVertex.PositionColored(min, c);
vertices[4] = new CustomVertex.PositionColored(max, c);
vertices[5] = new CustomVertex.PositionColored(max.X, 0, min.Z, c);
//Obtener matriz de rotacion respecto de la normal del plano
normal.Normalize();
var angle = FastMath.Acos(Vector3.Dot(ORIGINAL_DIR, normal));
var axisRotation = Vector3.Cross(ORIGINAL_DIR, normal);
axisRotation.Normalize();
var t = Matrix.RotationAxis(axisRotation, angle) * Matrix.Translation(Center);
//Transformar todos los puntos
for (var i = 0; i < vertices.Length; i++)
{
vertices[i].Position = Vector3.TransformCoordinate(vertices[i].Position, t);
}
//Cargar vertexBuffer
vertexBuffer.SetData(vertices, 0, LockFlags.None);
}
public static void updateObbFromSegment(TgcBoundingOrientedBox obb, TGCVector3 a, TGCVector3 b, float thickness)
{
var lineDiff = b - a;
var lineLength = lineDiff.Length();
var lineVec = TGCVector3.Normalize(lineDiff);
//Obtener angulo y vector de rotacion
var upVec = TGCVector3.Up;
var angle = FastMath.Acos(TGCVector3.Dot(upVec, lineVec));
var axisRotation = TGCVector3.Cross(upVec, lineVec);
axisRotation.Normalize();
//Obtener matriz de rotacion para este eje y angulo
var rotM = TGCMatrix.RotationAxis(axisRotation, angle);
//Actualizar orientacion de OBB en base a matriz de rotacion
obb.Orientation[0] = new TGCVector3(rotM.M11, rotM.M12, rotM.M13);
obb.Orientation[1] = new TGCVector3(rotM.M21, rotM.M22, rotM.M23);
obb.Orientation[2] = new TGCVector3(rotM.M31, rotM.M32, rotM.M33);
//Actualizar extent de OBB segun el thickness del segmento
obb.Extents = new TGCVector3(thickness, lineLength / 2, thickness);
//Actualizar centro del OBB segun centro del segmento
obb.Center = a + TGCVector3.Scale(lineDiff, 0.5f);
//Regenerar OBB
obb.updateValues();
}
public override void Update()
{
currentPick = PerformPicking();
if (PickingInsideSphere())
{
if (dragging)
{
TGCVector3 normalizedTo = currentPick;
normalizedTo.Normalize();
var cross = TGCVector3.Cross(normalizedFrom, normalizedTo);
var newRotation = TGCQuaternion.RotationAxis(cross, FastMath.Acos(TGCVector3.Dot(normalizedFrom, normalizedTo)));
var currentRotation = TGCQuaternion.Multiply(stacked, newRotation);
shark.Transform = baseSharkTransform * TGCMatrix.RotationTGCQuaternion(currentRotation);
if (Input.buttonUp(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
stacked = currentRotation;
shark.Transform = baseSharkTransform * TGCMatrix.RotationTGCQuaternion(stacked);
dragging = false;
}
}
else if (Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
dragging = true;
fromDrag = currentPick;
normalizedFrom = TGCVector3.Normalize(fromDrag);
}
}
UpdateArrows();
}
public static void updateObbFromSegment(TgcObb obb, Vector3 a, Vector3 b, float thickness)
{
Vector3 lineDiff = b - a;
float lineLength = lineDiff.Length();
Vector3 lineVec = Vector3.Normalize(lineDiff);
//Obtener angulo y vector de rotacion
Vector3 upVec = new Vector3(0, 1, 0);
float angle = FastMath.Acos(Vector3.Dot(upVec, lineVec));
Vector3 axisRotation = Vector3.Cross(upVec, lineVec);
axisRotation.Normalize();
//Obtener matriz de rotacion para este eje y angulo
Matrix rotM = Matrix.RotationAxis(axisRotation, angle);
//Actualizar orientacion de OBB en base a matriz de rotacion
obb.Orientation[0] = new Vector3(rotM.M11, rotM.M12, rotM.M13);
obb.Orientation[1] = new Vector3(rotM.M21, rotM.M22, rotM.M23);
obb.Orientation[2] = new Vector3(rotM.M31, rotM.M32, rotM.M33);
//Actualizar extent de OBB segun el thickness del segmento
obb.Extents = new Vector3(thickness, lineLength / 2, thickness);
//Actualizar centro del OBB segun centro del segmento
obb.Center = a + Vector3.Scale(lineDiff, 0.5f);
//Regenerar OBB
obb.updateValues();
}
public float AngleBetweenVectors(TGCVector3 v1, TGCVector3 v2)
{
var dot = TGCVector3.Dot(v1, v2);
var modulusProduct = v1.Length() * v2.Length();
return(FastMath.Acos(dot / modulusProduct));
}
public static float calcularAnguloEntreVectoresNormalizados(Vector3 vector1, Vector3 vector2)
{
vector1 = Vector3.Normalize(vector1);
vector2 = Vector3.Normalize(vector2);
return((float)FastMath.Acos(Vector3.Dot(vector1, vector2)));
}
public void Update(float elapsedTime)
{
TGCQuaternion rotationX = TGCQuaternion.RotationAxis(new TGCVector3(0.0f, 1.0f, 0.0f), Geometry.DegreeToRadian(90f /* + anguloEntreVectores*15*/));
TGCVector3 PosicionA = posicionInicial;
TGCVector3 PosicionB = jugador.GetPosicion();
TGCVector3 DireccionA = new TGCVector3(0, 0, -1);
TGCVector3 DireccionB = PosicionB - PosicionA;
if (DireccionB.Length() >= 15f && PosicionA.Z > PosicionB.Z + 10f)
{
DireccionB.Normalize();
// anguloEntreVectores = (float)Math.Acos(TGCVector3.Dot(DireccionA, DireccionB));
var cross = TGCVector3.Cross(DireccionA, DireccionB);
var newRotation = TGCQuaternion.RotationAxis(cross, FastMath.Acos(TGCVector3.Dot(DireccionA, DireccionB)));
quaternionAuxiliar = rotationX * newRotation;
mainMesh.Transform = baseScaleRotation *
TGCMatrix.RotationTGCQuaternion(rotationX * newRotation) *
baseQuaternionTranslation;
}
else
{
mainMesh.Transform = baseScaleRotation *
TGCMatrix.RotationTGCQuaternion(quaternionAuxiliar) *
baseQuaternionTranslation;
}
//codigo de prueba------
tiempo += .1f + elapsedTime;
if (tiempo > 15f)
{
Disparar(PosicionB);
tiempo = 0f;
}
//--------
}
private TGCQuaternion QuaternionDireccion(TGCVector3 direccionDisparoNormalizado)
{
TGCVector3 DireccionA = new TGCVector3(0, 0, -1);
TGCVector3 cross = TGCVector3.Cross(DireccionA, direccionDisparoNormalizado);
TGCQuaternion newRotation = TGCQuaternion.RotationAxis(cross, FastMath.Acos(TGCVector3.Dot(DireccionA, direccionDisparoNormalizado)));
return(newRotation);
}
/// <summary>
/// Devuelve la rotacion que se debe aplicar a la matriz de transformacion para que la entidad apunte hacia una direccion.
/// </summary>
/// <param name="lookDir">Vector normalizado que define la direccion a la que debe mirar la entidad.</param>
private void LookAt(TGCVector3 lookDir)
{
float angle = FastMath.Acos(TGCVector3.Dot(defaultLookDir, lookDir));
TGCVector3 rotVector = TGCVector3.Cross(defaultLookDir, lookDir);
rotVector.Z = 0;
rotation = TGCQuaternion.RotationAxis(rotVector, angle);
}
public void calcularOrientacion(Vector3 direccion, Vector3 centro, Vector3 normal)
{
float angle = FastMath.Acos(Vector3.Dot(normal, direccion));
Vector3 rotationY = Vector3.Cross(normal, direccion);
rotationY.Normalize();
Matrix Move = Matrix.Translation(centro);
Move.Invert();
m_mRotacion = Move * Matrix.RotationAxis(rotationY, angle) * Matrix.Translation(centro);
}
public static float anguloEntreVectores(TGCVector3 vector1, TGCVector3 vector2)
{
if ((TGCVector3.Length(vector1) * TGCVector3.Length(vector2)) == 0)
{
return(0);
}
float cos = TGCVector3.Dot(vector1, vector2) / (TGCVector3.Length(vector1) * TGCVector3.Length(vector2));
return(FastMath.Acos(cos));
}
public override void calcularTraslacionYRotacion(float elapsedTime, TerrenoSimple agua, float time, Vector3 lastPosition)
{
distance = player.popa() - this.getPosition();
Vector3 iaDirectionVersor = this.vectorDireccion();
iaDirectionVersor.Normalize();
Vector3 lookAtPopaVersor = new Vector3(distance.X, distance.Y, distance.Z);
lookAtPopaVersor.Normalize();
float rotationAngle = FastMath.Acos(Vector3.Dot(iaDirectionVersor, lookAtPopaVersor));
Vector3 cross = Vector3.Cross(lookAtPopaVersor, iaDirectionVersor);
//Vector3 lastPosition = getPosition();
if (cross.Length() > 0.1)
{
if (cross.Y > 0.1)
{
anguloRotacion -= elapsedTime * ROTATION_SPEED;
}
if (cross.Y < -0.1)
{
anguloRotacion += elapsedTime * ROTATION_SPEED;
}
rotacion = Matrix.RotationY(anguloRotacion);
}
if (FastMath.Abs(distance.Length()) > 1000)
{
movementSpeed = Math.Min(movementSpeed + ESCALON_VEL, VEL_MAXIMA);
}
if (FastMath.Abs(distance.Length()) <= 1000)
{
if (FastMath.Abs(distance.Length()) > 400)
{
movementSpeed = Math.Max(movementSpeed - movementSpeed / distance.Length(), 0);
}
else
{
movementSpeed = 0;
}
}
movZ -= movementSpeed * FastMath.Cos(anguloRotacion) * elapsedTime;
movX -= movementSpeed * FastMath.Sin(anguloRotacion) * elapsedTime;
movY = agua.aplicarOlasA(getPosition(), time).Y + AltoBote / 2;
administrarColisiones(lastPosition, new Vector3(movX, movY, movZ));
}
public void updatePlayerPointer()
{
Vector3 currentView = CustomFpsCamera.Instance.getLookAt() - CustomFpsCamera.Instance.getPosition();
Vector2 cur = new Vector2(currentView.X, currentView.Z);
cur.Normalize();
float rot = (float)FastMath.Acos(Vector2.Dot(initialPos, cur));
float cross = Vector2.Ccw(initialPos, cur);
float arc = cross > 0 ? rot : -rot;
playerPointerSprite.Rotation = (float)Math.PI / 2 - arc;
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
// 1) Crear un vector en 3D
Vector3 v = new Vector3(0, 19, -1759.21f);
// 2) Producto escalar entre dos vectores (dot product)
Vector3 v1 = new Vector3(0, 19, -1759.21f);
Vector3 v2 = new Vector3(0, 19, -1759.21f);
float dotResult = Vector3.Dot(v1, v2);
// 3) Producto vectorial entre dos vectores (cross product). El orden de v1 y v2 influye en la orientacion del resultado
Vector3 crossResultVec = Vector3.Cross(v1, v2);
// 4) Distancia entre dos puntos
Vector3 p1 = new Vector3(100, 200, 300);
Vector3 p2 = new Vector3(1000, 2000, 3000);
float distancia = Vector3.Length(p2 - p1);
float distanciaCuadrada = Vector3.LengthSq(p2 - p1); //Es mas eficiente porque evita la raiz cuadrada (pero te da el valor al cuadrado)
// 5) Normalizar vector
Vector3 norm = Vector3.Normalize(v1);
// 6) Obtener el ángulo que hay entre dos vectores que están en XZ, expresion A.B=|A||B|cos(a)
Vector3 v3 = new Vector3(-1, 0, 19);
Vector3 v4 = new Vector3(3, 0, -5);
float angle = FastMath.Acos(Vector3.Dot(Vector3.Normalize(v3), Vector3.Normalize(v4))); //Tienen que estar normalizados
// 7) Tenemos un objeto que rota un cierto ángulo en Y (ej: un auto) y queremos saber los componentes X,Z para donde tiene que avanzar al moverse
float rotacionY = FastMath.PI_HALF;
float componenteX = FastMath.Sin(rotacionY);
float componenteZ = FastMath.Cos(rotacionY);
float velocidadMovimiento = 100; //Ojo que este valor deberia siempre multiplicarse por el elapsedTime
Vector3 movimientoAdelante = new Vector3(componenteX * velocidadMovimiento, 0, componenteZ * velocidadMovimiento);
GuiController.Instance.Text3d.drawText("Este ejemplo no muestra nada por pantalla. Sino que es para leer el código y sus comentarios.", 5, 50, Color.Yellow);
}
public override void Render()
{
PreRender();
// 1) Crear un vector en 3D
var v = new TGCVector3(0, 19, -1759.21f);
// 2) Producto escalar entre dos vectores (dot product)
var v1 = new TGCVector3(0, 19, -1759.21f);
var v2 = new TGCVector3(0, 19, -1759.21f);
var dotResult = TGCVector3.Dot(v1, v2);
// 3) Producto vectorial entre dos vectores (cross product). El orden de v1 y v2 influye en la orientacion del resultado
var crossResultVec = TGCVector3.Cross(v1, v2);
// 4) Distancia entre dos puntos
var p1 = new TGCVector3(100, 200, 300);
var p2 = new TGCVector3(1000, 2000, 3000);
var distancia = TGCVector3.Length(p2 - p1);
var distanciaCuadrada = TGCVector3.LengthSq(p2 - p1);
//Es mas eficiente porque evita la raiz cuadrada (pero te da el valor al cuadrado)
// 5) Normalizar vector
var norm = TGCVector3.Normalize(v1);
// 6) Obtener el angulo que hay entre dos vectores que estan en XZ, expresion A.B=|A||B|cos(a)
var v3 = new TGCVector3(-1, 0, 19);
var v4 = new TGCVector3(3, 0, -5);
var angle = FastMath.Acos(TGCVector3.Dot(TGCVector3.Normalize(v3), TGCVector3.Normalize(v4)));
//Tienen que estar normalizados
// 7) Tenemos un objeto que rota un cierto angulo en Y (ej: un auto) y queremos saber los componentes X,Z para donde tiene que avanzar al moverse
var rotacionY = FastMath.PI_HALF;
var componenteX = FastMath.Sin(rotacionY);
var componenteZ = FastMath.Cos(rotacionY);
float velocidadMovimiento = 100; //Ojo que este valor deberia siempre multiplicarse por el elapsedTime
var movimientoAdelante = new TGCVector3(componenteX * velocidadMovimiento, 0, componenteZ * velocidadMovimiento);
DrawText.drawText(
"Este ejemplo no muestra nada por pantalla. Sino que es para leer el codigo y sus comentarios.", 5, 50,
Color.Yellow);
PostRender();
}
/// <summary>
/// Setear la camara con una determinada posicion y lookAt
/// </summary>
public void lookAt(Vector3 pos, Vector3 lookAt)
{
//TODO: solo funciona bien para hacer un TopView
Vector3 v = pos - lookAt;
float length = Vector3.Length(v);
v.Scale(1 / length);
cameraDistance = length;
upVector = new Vector3(0, 1, 0);
diffX = 0;
diffY = 0.01f;
diffZ = 1;
baseRotX = -FastMath.Acos(Vector3.Dot(new Vector3(0, 0, -1), v));
//baseRotY = FastMath.Acos(Vector3.Dot(new Vector3(0, 0, -1), v));
baseRotY = 0;
cameraCenter = lookAt;
}
/// <summary>
/// Setear la camara con una determinada posicion y lookAt
/// </summary>
public void lookAt(TGCVector3 pos, TGCVector3 lookAt)
{
//TODO: solo funciona bien para hacer un TopView
var v = pos - lookAt;
var length = TGCVector3.Length(v);
v.Scale(1 / length);
CameraDistance = length;
upVector = TGCVector3.Up;
diffX = 0;
diffY = 0.01f;
diffZ = 1;
BaseRotX = -FastMath.Acos(TGCVector3.Dot(new TGCVector3(0, 0, -1), v));
//baseRotY = FastMath.Acos(TGCVector3.Dot(new TGCVector3(0, 0, -1), v));
BaseRotY = 0;
CameraCenter = lookAt;
}
public void Start(Vector3 location, Single Power, Vector3 newUpDirection)
{
if (Power < 15)
{
return;
}
if (Animation != null)
{
Animation.Size = _InitialSize * (_PowerFactor * Power);
Animation.Position = location;// +newUpDirection * (Animation.Size.Y / 2);
Single alfa = FastMath.Acos(Vector3.Dot(newUpDirection, _InitialUpDirection));
if (newUpDirection.X > _InitialUpDirection.X)
{
alfa *= -1;
}
Animation.RotationMatrix = Matrix.RotationZ(alfa);
this.Start();
}
}
public void UpdateInternalValues()
{
frontVector = new TGCVector3(Vector3.TransformNormal(-Vector3.UnitZ, RigidBody.InterpolationWorldTransform));
var velocityVector = new TGCVector3(RigidBody.InterpolationLinearVelocity.X, 0, RigidBody.InterpolationLinearVelocity.Z);
if (velocityVector.Length() < 0.12f)
{
velocityVector = TGCVector3.Empty;
}
var speedAngle = FastMath.Acos(TGCVector3.Dot(frontVector, velocityVector) / (frontVector.Length() * velocityVector.Length()));
velocityVector.Multiply(2f);
currentSpeed = (int)velocityVector.Length();
if (speedAngle >= FastMath.PI_HALF)
{
currentSpeed *= -1;
}
yawPitchRoll = Quat.ToEulerAngles(RigidBody.Orientation);
}
/// <summary>
/// Actualizar parámetros de la pared en base a los valores configurados
/// </summary>
public void updateValues()
{
//Calcular los 4 corners de la pared, segun el tipo de orientacion
Vector3 bLeft = new Vector3(-size.X / 2, 0, -size.Y / 2);
Vector3 tLeft = new Vector3(size.X / 2, 0, -size.Y / 2);
Vector3 bRight = new Vector3(-size.X / 2, 0, size.Y / 2);
Vector3 tRight = new Vector3(size.X / 2, 0, size.Y / 2);
//Auto ajustar UV
float offsetU = this.uvOffset.X;
float offsetV = this.uvOffset.Y;
//Primer triangulo
vertices[0] = new CustomVertex.PositionTextured(bLeft, offsetU + uTile, offsetV + vTile);
vertices[1] = new CustomVertex.PositionTextured(tLeft, offsetU, offsetV + vTile);
vertices[2] = new CustomVertex.PositionTextured(tRight, offsetU, offsetV);
//Segundo triangulo
vertices[3] = new CustomVertex.PositionTextured(bLeft, offsetU + uTile, offsetV + vTile);
vertices[4] = new CustomVertex.PositionTextured(tRight, offsetU, offsetV);
vertices[5] = new CustomVertex.PositionTextured(bRight, offsetU + uTile, offsetV);
//BoundingBox
normal = (origin - GuiController.Instance.CurrentCamera.getLookAt());
normal.Normalize();
float angle = FastMath.Acos(Vector3.Dot(ORIGINAL_DIR, normal));
Vector3 axisRotation = Vector3.Cross(ORIGINAL_DIR, normal);
axisRotation.Normalize();
Matrix t = Matrix.RotationAxis(axisRotation, angle) * Matrix.Translation(origin);
//Transformar todos los puntos
for (int i = 0; i < vertices.Length; i++)
{
vertices[i].Position = Vector3.TransformCoordinate(vertices[i].Position, t);
}
}
//Ángulo entre la dirección a la que apunta el auto IA y otro vector
public float AnguloAlVector(TGCVector2 vector)
{
return(FastMath.ToDeg(FastMath.Acos((VersorDirector.X * vector.X + VersorDirector.Z * vector.Y) / (ModuloVector(new TGCVector2(VersorDirector.X, VersorDirector.Z)) * ModuloVector(vector)))));
}
public void MoverHaciaObjetivo(float tiempoRenderizado, Vector3 posicionObjetivo)
{
if (this.Modelo.Enabled)
{
//Resto los dos vectores para hallar el vector distancia
Vector3 Distancia = Vector3.Subtract(posicionObjetivo, this.Modelo.Position);
//Otro vector, con valores absolutos para hallar la componente maxima
Vector3 DistanciaAbs = TgcVectorUtils.abs(Distancia);
//Calculo matriz de rotacion
Vector3 DireccionObjetivo = Vector3.Normalize(posicionObjetivo - this.Modelo.Position);
float angulo = FastMath.Acos(Vector3.Dot(RotacionOriginal, DireccionObjetivo));
Vector3 axisRotation = Vector3.Cross(this.Modelo.Rotation, DireccionObjetivo);
MatrizRotacion = Matrix.RotationAxis(axisRotation, angulo);
float cantidadDeMovimiento = this.VelocidadMovimiento * tiempoRenderizado;
float giro = this.Modelo.Rotation.Y - angulo;
if (giro < -0.1)
{
this.Modelo.rotateY(Geometry.DegreeToRadian(-giro * 100 * tiempoRenderizado));
return;
}
else if (giro > 0.1)
{
this.Modelo.rotateY(Geometry.DegreeToRadian(-giro * 100 * tiempoRenderizado));
return;
}
if (DistanciaAbs.X + DistanciaAbs.Y + DistanciaAbs.Z > 700f)
{
//Hallo la componente de mayor valor y me muevo en esa direccion. VER SENTIDO.
if (DistanciaAbs.X >= DistanciaAbs.Y)
{
if (DistanciaAbs.X >= DistanciaAbs.Z)
{
// MOVER EN X
if (Distancia.X > cantidadDeMovimiento)
{
this.Modelo.move(cantidadDeMovimiento, 0, 0);
}
else
{
this.Modelo.move(cantidadDeMovimiento * -1, 0, 0);
}
}
else
{
// MOVER EN Z
if (Distancia.Z > 0)
{
this.Modelo.move(0, 0, cantidadDeMovimiento);
}
else
{
this.Modelo.move(0, 0, cantidadDeMovimiento * -1);
}
}
}
else
{
if (DistanciaAbs.Y >= DistanciaAbs.Z)
{
// MOVER EN Y
if (Distancia.Y > 0)
{
this.Modelo.move(0, cantidadDeMovimiento, 0);
}
else
{
this.Modelo.move(0, cantidadDeMovimiento * -1, 0);
}
}
else
{
// MOVER EN Z
if (Distancia.Z > 0)
{
this.Modelo.move(0, 0, cantidadDeMovimiento);
}
else
{
this.Modelo.move(0, 0, cantidadDeMovimiento * -1);
}
}
}
}
else
{
//Disparar. Tambien deberia rotar para que el disparo vaya bien
if (TiempoParado == 0 || TiempoParado >= TiempoRecarga)
{
Disparo disparo = new Disparo(this.Modelo, MatrizRotacion);
Disparos.Add(disparo);
TiempoParado = 0f;
}
TiempoParado = TiempoParado + tiempoRenderizado * 4;
}
}
}
/// <summary>
/// Add new BoxLine mesh
/// </summary>
public void addBoxLine(TGCVector3 pStart, TGCVector3 pEnd, float thickness, Color color)
{
const int vertexCount = 36;
checkAndFlush(vertexCount);
var initIdx = idx;
var c = color.ToArgb();
//Crear caja en vertical en Y con longitud igual al módulo de la recta.
var lineVec = TGCVector3.Subtract(pEnd, pStart);
var lineLength = lineVec.Length();
var min = new TGCVector3(-thickness, 0, -thickness);
var max = new TGCVector3(thickness, lineLength, thickness);
//Vértices de la caja con forma de linea
// Front face
addTriangle(
new CustomVertex.PositionColored(min.X, max.Y, max.Z, c),
new CustomVertex.PositionColored(min.X, min.Y, max.Z, c),
new CustomVertex.PositionColored(max.X, max.Y, max.Z, c)
);
addTriangle(
new CustomVertex.PositionColored(min.X, min.Y, max.Z, c),
new CustomVertex.PositionColored(max.X, min.Y, max.Z, c),
new CustomVertex.PositionColored(max.X, max.Y, max.Z, c)
);
// Back face (remember this is facing *away* from the camera, so vertices should be clockwise order)
addTriangle(
new CustomVertex.PositionColored(min.X, max.Y, min.Z, c),
new CustomVertex.PositionColored(max.X, max.Y, min.Z, c),
new CustomVertex.PositionColored(min.X, min.Y, min.Z, c)
);
addTriangle(
new CustomVertex.PositionColored(min.X, min.Y, min.Z, c),
new CustomVertex.PositionColored(max.X, max.Y, min.Z, c),
new CustomVertex.PositionColored(max.X, min.Y, min.Z, c)
);
// Top face
addTriangle(
new CustomVertex.PositionColored(min.X, max.Y, max.Z, c),
new CustomVertex.PositionColored(max.X, max.Y, min.Z, c),
new CustomVertex.PositionColored(min.X, max.Y, min.Z, c)
);
addTriangle(
new CustomVertex.PositionColored(min.X, max.Y, max.Z, c),
new CustomVertex.PositionColored(max.X, max.Y, max.Z, c),
new CustomVertex.PositionColored(max.X, max.Y, min.Z, c)
);
// Bottom face (remember this is facing *away* from the camera, so vertices should be clockwise order)
addTriangle(
new CustomVertex.PositionColored(min.X, min.Y, max.Z, c),
new CustomVertex.PositionColored(min.X, min.Y, min.Z, c),
new CustomVertex.PositionColored(max.X, min.Y, min.Z, c)
);
addTriangle(
new CustomVertex.PositionColored(min.X, min.Y, max.Z, c),
new CustomVertex.PositionColored(max.X, min.Y, min.Z, c),
new CustomVertex.PositionColored(max.X, min.Y, max.Z, c)
);
// Left face
addTriangle(
new CustomVertex.PositionColored(min.X, max.Y, max.Z, c),
new CustomVertex.PositionColored(min.X, min.Y, min.Z, c),
new CustomVertex.PositionColored(min.X, min.Y, max.Z, c)
);
addTriangle(
new CustomVertex.PositionColored(min.X, max.Y, min.Z, c),
new CustomVertex.PositionColored(min.X, min.Y, min.Z, c),
new CustomVertex.PositionColored(min.X, max.Y, max.Z, c)
);
// Right face (remember this is facing *away* from the camera, so vertices should be clockwise order)
addTriangle(
new CustomVertex.PositionColored(max.X, max.Y, max.Z, c),
new CustomVertex.PositionColored(max.X, min.Y, max.Z, c),
new CustomVertex.PositionColored(max.X, min.Y, min.Z, c)
);
addTriangle(
new CustomVertex.PositionColored(max.X, max.Y, min.Z, c),
new CustomVertex.PositionColored(max.X, max.Y, max.Z, c),
new CustomVertex.PositionColored(max.X, min.Y, min.Z, c)
);
//Obtener matriz de rotacion respecto del vector de la linea
lineVec.Normalize();
var angle = FastMath.Acos(TGCVector3.Dot(BOX_LINE_ORIGINAL_DIR, lineVec));
var axisRotation = TGCVector3.Cross(BOX_LINE_ORIGINAL_DIR, lineVec);
axisRotation.Normalize();
var t = TGCMatrix.RotationAxis(axisRotation, angle) * TGCMatrix.Translation(pStart);
//Transformar todos los puntos
for (var i = initIdx; i < initIdx + vertexCount; i++)
{
vertices[i].Position = TGCVector3.TransformCoordinate(TGCVector3.FromVector3(vertices[i].Position), t);
}
}
public static float AngleBetweenVectors(TGCVector3 vectorA, TGCVector3 vectorB)
{
var dotProduct = TGCVector3.Dot(vectorA, vectorB) / (vectorA.Length() * vectorB.Length());
return(dotProduct < 1 ? FastMath.Acos(dotProduct) : 0);
}
/// <summary>
/// Actualizar parámetros de la línea en base a los valores configurados
/// </summary>
public void updateValues()
{
var c = color.ToArgb();
var vertices = new CustomVertex.PositionColored[36];
//Crear caja en vertical en Y con longitud igual al módulo de la recta.
var lineVec = Vector3.Subtract(PEnd, PStart);
var lineLength = lineVec.Length();
var min = new Vector3(-Thickness, 0, -Thickness);
var max = new Vector3(Thickness, lineLength, Thickness);
//Vértices de la caja con forma de linea
// Front face
vertices[0] = new CustomVertex.PositionColored(min.X, max.Y, max.Z, c);
vertices[1] = new CustomVertex.PositionColored(min.X, min.Y, max.Z, c);
vertices[2] = new CustomVertex.PositionColored(max.X, max.Y, max.Z, c);
vertices[3] = new CustomVertex.PositionColored(min.X, min.Y, max.Z, c);
vertices[4] = new CustomVertex.PositionColored(max.X, min.Y, max.Z, c);
vertices[5] = new CustomVertex.PositionColored(max.X, max.Y, max.Z, c);
// Back face (remember this is facing *away* from the camera, so vertices should be clockwise order)
vertices[6] = new CustomVertex.PositionColored(min.X, max.Y, min.Z, c);
vertices[7] = new CustomVertex.PositionColored(max.X, max.Y, min.Z, c);
vertices[8] = new CustomVertex.PositionColored(min.X, min.Y, min.Z, c);
vertices[9] = new CustomVertex.PositionColored(min.X, min.Y, min.Z, c);
vertices[10] = new CustomVertex.PositionColored(max.X, max.Y, min.Z, c);
vertices[11] = new CustomVertex.PositionColored(max.X, min.Y, min.Z, c);
// Top face
vertices[12] = new CustomVertex.PositionColored(min.X, max.Y, max.Z, c);
vertices[13] = new CustomVertex.PositionColored(max.X, max.Y, min.Z, c);
vertices[14] = new CustomVertex.PositionColored(min.X, max.Y, min.Z, c);
vertices[15] = new CustomVertex.PositionColored(min.X, max.Y, max.Z, c);
vertices[16] = new CustomVertex.PositionColored(max.X, max.Y, max.Z, c);
vertices[17] = new CustomVertex.PositionColored(max.X, max.Y, min.Z, c);
// Bottom face (remember this is facing *away* from the camera, so vertices should be clockwise order)
vertices[18] = new CustomVertex.PositionColored(min.X, min.Y, max.Z, c);
vertices[19] = new CustomVertex.PositionColored(min.X, min.Y, min.Z, c);
vertices[20] = new CustomVertex.PositionColored(max.X, min.Y, min.Z, c);
vertices[21] = new CustomVertex.PositionColored(min.X, min.Y, max.Z, c);
vertices[22] = new CustomVertex.PositionColored(max.X, min.Y, min.Z, c);
vertices[23] = new CustomVertex.PositionColored(max.X, min.Y, max.Z, c);
// Left face
vertices[24] = new CustomVertex.PositionColored(min.X, max.Y, max.Z, c);
vertices[25] = new CustomVertex.PositionColored(min.X, min.Y, min.Z, c);
vertices[26] = new CustomVertex.PositionColored(min.X, min.Y, max.Z, c);
vertices[27] = new CustomVertex.PositionColored(min.X, max.Y, min.Z, c);
vertices[28] = new CustomVertex.PositionColored(min.X, min.Y, min.Z, c);
vertices[29] = new CustomVertex.PositionColored(min.X, max.Y, max.Z, c);
// Right face (remember this is facing *away* from the camera, so vertices should be clockwise order)
vertices[30] = new CustomVertex.PositionColored(max.X, max.Y, max.Z, c);
vertices[31] = new CustomVertex.PositionColored(max.X, min.Y, max.Z, c);
vertices[32] = new CustomVertex.PositionColored(max.X, min.Y, min.Z, c);
vertices[33] = new CustomVertex.PositionColored(max.X, max.Y, min.Z, c);
vertices[34] = new CustomVertex.PositionColored(max.X, max.Y, max.Z, c);
vertices[35] = new CustomVertex.PositionColored(max.X, min.Y, min.Z, c);
//Obtener matriz de rotacion respecto del vector de la linea
lineVec.Normalize();
var angle = FastMath.Acos(Vector3.Dot(ORIGINAL_DIR, lineVec));
var axisRotation = Vector3.Cross(ORIGINAL_DIR, lineVec);
axisRotation.Normalize();
var t = Matrix.RotationAxis(axisRotation, angle) * Matrix.Translation(PStart);
//Transformar todos los puntos
for (var i = 0; i < vertices.Length; i++)
{
vertices[i].Position = Vector3.TransformCoordinate(vertices[i].Position, t);
}
//Cargar vertexBuffer
vertexBuffer.SetData(vertices, 0, LockFlags.None);
}
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();
}
public float ObtenerRotacion(TGCVector3 a, TGCVector3 b)
{
return(FastMath.Acos(TGCVector3.Dot(a, b) / (a.Length() * b.Length())));
}
/// <summary>
/// Actualizar parámetros de la flecha en base a los valores configurados
/// </summary>
public void updateValues()
{
var vertices = new CustomVertex.PositionColored[54];
//Crear caja en vertical en Y con longitud igual al módulo de la recta.
var lineVec = TGCVector3.Subtract(PEnd, PStart);
var lineLength = lineVec.Length();
var min = new TGCVector3(-Thickness, 0, -Thickness);
var max = new TGCVector3(Thickness, lineLength, Thickness);
//Vertices del cuerpo de la flecha
var bc = bodyColor.ToArgb();
// Front face
vertices[0] = new CustomVertex.PositionColored(min.X, max.Y, max.Z, bc);
vertices[1] = new CustomVertex.PositionColored(min.X, min.Y, max.Z, bc);
vertices[2] = new CustomVertex.PositionColored(max.X, max.Y, max.Z, bc);
vertices[3] = new CustomVertex.PositionColored(min.X, min.Y, max.Z, bc);
vertices[4] = new CustomVertex.PositionColored(max.X, min.Y, max.Z, bc);
vertices[5] = new CustomVertex.PositionColored(max.X, max.Y, max.Z, bc);
// Back face (remember this is facing *away* from the camera, so vertices should be clockwise order)
vertices[6] = new CustomVertex.PositionColored(min.X, max.Y, min.Z, bc);
vertices[7] = new CustomVertex.PositionColored(max.X, max.Y, min.Z, bc);
vertices[8] = new CustomVertex.PositionColored(min.X, min.Y, min.Z, bc);
vertices[9] = new CustomVertex.PositionColored(min.X, min.Y, min.Z, bc);
vertices[10] = new CustomVertex.PositionColored(max.X, max.Y, min.Z, bc);
vertices[11] = new CustomVertex.PositionColored(max.X, min.Y, min.Z, bc);
// Top face
vertices[12] = new CustomVertex.PositionColored(min.X, max.Y, max.Z, bc);
vertices[13] = new CustomVertex.PositionColored(max.X, max.Y, min.Z, bc);
vertices[14] = new CustomVertex.PositionColored(min.X, max.Y, min.Z, bc);
vertices[15] = new CustomVertex.PositionColored(min.X, max.Y, max.Z, bc);
vertices[16] = new CustomVertex.PositionColored(max.X, max.Y, max.Z, bc);
vertices[17] = new CustomVertex.PositionColored(max.X, max.Y, min.Z, bc);
// Bottom face (remember this is facing *away* from the camera, so vertices should be clockwise order)
vertices[18] = new CustomVertex.PositionColored(min.X, min.Y, max.Z, bc);
vertices[19] = new CustomVertex.PositionColored(min.X, min.Y, min.Z, bc);
vertices[20] = new CustomVertex.PositionColored(max.X, min.Y, min.Z, bc);
vertices[21] = new CustomVertex.PositionColored(min.X, min.Y, max.Z, bc);
vertices[22] = new CustomVertex.PositionColored(max.X, min.Y, min.Z, bc);
vertices[23] = new CustomVertex.PositionColored(max.X, min.Y, max.Z, bc);
// Left face
vertices[24] = new CustomVertex.PositionColored(min.X, max.Y, max.Z, bc);
vertices[25] = new CustomVertex.PositionColored(min.X, min.Y, min.Z, bc);
vertices[26] = new CustomVertex.PositionColored(min.X, min.Y, max.Z, bc);
vertices[27] = new CustomVertex.PositionColored(min.X, max.Y, min.Z, bc);
vertices[28] = new CustomVertex.PositionColored(min.X, min.Y, min.Z, bc);
vertices[29] = new CustomVertex.PositionColored(min.X, max.Y, max.Z, bc);
// Right face (remember this is facing *away* from the camera, so vertices should be clockwise order)
vertices[30] = new CustomVertex.PositionColored(max.X, max.Y, max.Z, bc);
vertices[31] = new CustomVertex.PositionColored(max.X, min.Y, max.Z, bc);
vertices[32] = new CustomVertex.PositionColored(max.X, min.Y, min.Z, bc);
vertices[33] = new CustomVertex.PositionColored(max.X, max.Y, min.Z, bc);
vertices[34] = new CustomVertex.PositionColored(max.X, max.Y, max.Z, bc);
vertices[35] = new CustomVertex.PositionColored(max.X, min.Y, min.Z, bc);
//Vertices del cuerpo de la flecha
var hc = headColor.ToArgb();
var hMin = new TGCVector3(-HeadSize.X, lineLength, -HeadSize.X);
var hMax = new TGCVector3(HeadSize.X, lineLength + HeadSize.Y, HeadSize.X);
//Bottom face
vertices[36] = new CustomVertex.PositionColored(hMin.X, hMin.Y, hMax.Z, hc);
vertices[37] = new CustomVertex.PositionColored(hMin.X, hMin.Y, hMin.Z, hc);
vertices[38] = new CustomVertex.PositionColored(hMax.X, hMin.Y, hMin.Z, hc);
vertices[39] = new CustomVertex.PositionColored(hMin.X, hMin.Y, hMax.Z, hc);
vertices[40] = new CustomVertex.PositionColored(hMax.X, hMin.Y, hMin.Z, hc);
vertices[41] = new CustomVertex.PositionColored(hMax.X, hMin.Y, hMax.Z, hc);
//Left face
vertices[42] = new CustomVertex.PositionColored(hMin.X, hMin.Y, hMin.Z, hc);
vertices[43] = new CustomVertex.PositionColored(0, hMax.Y, 0, hc);
vertices[44] = new CustomVertex.PositionColored(hMin.X, hMin.Y, hMax.Z, hc);
//Right face
vertices[45] = new CustomVertex.PositionColored(hMax.X, hMin.Y, hMin.Z, hc);
vertices[46] = new CustomVertex.PositionColored(0, hMax.Y, 0, hc);
vertices[47] = new CustomVertex.PositionColored(hMax.X, hMin.Y, hMax.Z, hc);
//Back face
vertices[48] = new CustomVertex.PositionColored(hMin.X, hMin.Y, hMin.Z, hc);
vertices[49] = new CustomVertex.PositionColored(0, hMax.Y, 0, hc);
vertices[50] = new CustomVertex.PositionColored(hMax.X, hMin.Y, hMin.Z, hc);
//Front face
vertices[51] = new CustomVertex.PositionColored(hMin.X, hMin.Y, hMax.Z, hc);
vertices[52] = new CustomVertex.PositionColored(0, hMax.Y, 0, hc);
vertices[53] = new CustomVertex.PositionColored(hMax.X, hMin.Y, hMax.Z, hc);
//Obtener matriz de rotacion respecto del vector de la linea
lineVec.Normalize();
var angle = FastMath.Acos(TGCVector3.Dot(ORIGINAL_DIR, lineVec));
var axisRotation = TGCVector3.Cross(ORIGINAL_DIR, lineVec);
axisRotation.Normalize();
var t = TGCMatrix.RotationAxis(axisRotation, angle) * TGCMatrix.Translation(PStart);
//Transformar todos los puntos
for (var i = 0; i < vertices.Length; i++)
{
vertices[i].Position = TGCVector3.TransformCoordinate(TGCVector3.FromVector3(vertices[i].Position), t);
}
//Cargar vertexBuffer
vertexBuffer.SetData(vertices, 0, LockFlags.None);
}
public static float AngleBetween(TGCVector3 v1, TGCVector3 v2)
{
float cosine = TGCVector3.Dot(v1, v2) / (TGCVector3.Length(v1) * TGCVector3.Length(v2));
return(FastMath.Acos(cosine));
}
public float AnguloEntreVectores(TGCVector3 v1, TGCVector3 v2)
{
var angle = FastMath.Acos(TGCVector3.Dot(TGCVector3.Normalize(v1), TGCVector3.Normalize(v2)));
return(angle);
}
