/// <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 TGCVector3(-Size.X / 2, 0, -Size.Y / 2);
var max = new TGCVector3(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(TGCVector3.Dot(ORIGINAL_DIR, Normal));
var axisRotation = TGCVector3.Cross(ORIGINAL_DIR, Normal);
axisRotation.Normalize();
var t = TGCMatrix.RotationAxis(axisRotation, angle) * TGCMatrix.Translation(Center);
//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);
}
/// <summary>
/// Calcular normal del Triángulo
/// </summary>
/// <returns>Normal (esta normalizada)</returns>
public TGCVector3 computeNormal()
{
var n = TGCVector3.Cross(B - A, C - A);
n.Normalize();
return(n);
}
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 void renderStaminaBar()
{
//dibujo un poligono enfrente de la camara
//es medio choto porque lo hago pasar por todas las projecciones y eso, seria mejor dibujar un sprite directamente
//pero tgccore parece no tener nada de eso y va a ser mas rapido programar esto que ver como renderizar un sprite
var bar = new TgcConvexPolygon();
var vertex = new TGCVector3[4];
var forward = g.camera.cameraRotatedTarget * 5f;
var forwardPos = g.camera.eyePosition + forward;
var right = TGCVector3.Cross(g.camera.UpVector, forward) * .1f;
var down = TGCVector3.Cross(right, forward) * .1f;
forwardPos += right * 4f + down * 7.5f;
var lenght = g.camera.stamina / 5000f * 1.5f;
vertex[0] = forwardPos;
vertex[1] = forwardPos + right * lenght;
vertex[2] = forwardPos + right * lenght + down * 0.3f;
vertex[3] = forwardPos + down * 0.3f;
bar.BoundingVertices = vertex;
bar.Color = Color.White;
bar.updateValues();
bar.Render();
}
public TGCMatrix CalcularMatrizUp(TGCVector3 Pos, TGCVector3 Scale, TGCVector3 Dir, TGCVector3 VUP)
{
var matWorld = TGCMatrix.Scaling(Scale);
// determino la orientacion
var U = TGCVector3.Cross(VUP, Dir);
U.Normalize();
var V = TGCVector3.Cross(Dir, U);
TGCMatrix Orientacion = new TGCMatrix();
Orientacion.M11 = U.X;
Orientacion.M12 = U.Y;
Orientacion.M13 = U.Z;
Orientacion.M14 = 0;
Orientacion.M21 = V.X;
Orientacion.M22 = V.Y;
Orientacion.M23 = V.Z;
Orientacion.M24 = 0;
Orientacion.M31 = Dir.X;
Orientacion.M32 = Dir.Y;
Orientacion.M33 = Dir.Z;
Orientacion.M34 = 0;
Orientacion.M41 = 0;
Orientacion.M42 = 0;
Orientacion.M43 = 0;
Orientacion.M44 = 1;
matWorld = matWorld * Orientacion;
// traslado
matWorld = matWorld * TGCMatrix.Translation(Pos);
return(matWorld);
}
private void UpdateArrows()
{
if (dragging)
{
toArrow.PEnd = currentPick;
toArrow.updateValues();
var cross = TGCVector3.Cross(fromDrag, currentPick);
cross.Normalize();
cross.Scale(-radius);
crossArrow.PEnd = cross;
crossArrow.updateValues();
}
else
{
fromArrow.PEnd = currentPick;
fromArrow.updateValues();
toArrow.PEnd = TGCVector3.Empty;
toArrow.updateValues();
toArrow.PEnd = TGCVector3.Empty;
toArrow.updateValues();
}
}
/// <summary>
/// Moves the camera by dx world units to the left or right; dy
/// world units upwards or downwards; and dz world units forwards
/// or backwards.
/// </summary>
private void move(float dx, float dy, float dz)
{
var auxEye = eye;
TGCVector3 forwards;
// Calculate the forwards direction. Can't just use the camera's local
// z axis as doing so will cause the camera to move more slowly as the
// camera's view approaches 90 degrees straight up and down.
forwards = TGCVector3.Cross(xAxis, WORLD_YAXIS);
forwards.Normalize();
auxEye += xAxis * dx;
auxEye += WORLD_YAXIS * dy;
auxEye += forwards * dz;
if (FpsModeEnable)
{
HeadPosition += dy;
float y;
if (Terrain.interpoledHeight(auxEye.X, auxEye.Z, out y))
{
auxEye.Y = y;
auxEye += HeadPosition * WORLD_YAXIS;
}
}
setPosition(auxEye);
}
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;
}
//--------
}
/// <summary>
/// Crear un nuevo Frustum acotado usando como base el portal recorado.
/// La cantidad de planos del nuevo Frustum no tiene por qué ser 6.
/// Depende de la forma que haya quedado en el portal recortado.
/// </summary>
private TGCPlane[] createFrustumPlanes(TGCVector3 cameraPos, TGCPlane[] currentFrustumPlanes, TGCVector3[] portalVerts,
TGCPlane portalPlane)
{
//Hay un plano por cada vértice del polígono + 2 por el near y far plane
var frustumPlanes = new TGCPlane[2 + portalVerts.Length];
//Cargar near y far plane originales
//TODO: habria que usar el portalPlane para acercar el NearPlane hasta el portal
frustumPlanes[0] = currentFrustumPlanes[0];
frustumPlanes[1] = currentFrustumPlanes[1];
//Generar los planos laterales en base al polígono remanente del portal
//Vamos tomando de a dos puntos del polígono + la posición de la cámara y creamos un plano
var lastP = portalVerts[portalVerts.Length - 1];
for (var i = 0; i < portalVerts.Length; i++)
{
var nextP = portalVerts[i];
//Armar el plano para que la normal apunte hacia adentro del Frustum
var a = lastP - cameraPos;
var b = nextP - cameraPos;
var plane = TGCPlane.FromPointNormal(cameraPos, TGCVector3.Cross(b, a));
//Guardar después del near y far plane
frustumPlanes[i + 2] = plane;
lastP = nextP;
}
return(frustumPlanes);
}
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);
}
private float RotationYSign()
{
var bodyToSkyboxCenterVector = TGCVector3.Normalize(Skybox.GetSkyboxCenter() - GetMeshPosition());
var actualDirector = -1 * director;
var normalVector = TGCVector3.Cross(actualDirector, bodyToSkyboxCenterVector);
return(normalVector.Y > 0 ? 1 : -1);
}
private void updateMesh()
{
mesh.Transform =
TGCMatrix.RotationAxis(TGCVector3.Cross(lookAt, lookin),
-(float)Math.Acos(TGCVector3.Dot(lookAt, lookin)))
* TGCMatrix.Scaling(TGCVector3.One * 30)
* TGCMatrix.Translation(pos);
}
public override TGCVector3 GetShootRotation()
{
float angle = GlobalConcepts.GetInstance().AngleBetweenVectors(new TGCVector3(0, 0, 1), direction);
TGCVector3 result = TGCVector3.Cross(direction, new TGCVector3(0, 0, 1));
angle = (result.Y > 0) ? -angle : angle;
return(new TGCVector3(FastMath.PI_HALF, angle, 0));
}
/// <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 renderForShadow()
{
var lightObj = new TGCVector3(g.mostro.lightObjObj.X, g.mostro.flyHeight, g.mostro.lightObjObj.Y);
var lightPos = g.mostro.pos;
var eyeDir = lightObj - lightPos;
eyeDir.Y = 0;//ignorar y
eyeDir.Normalize();
var ortogDir = TGCVector3.Cross(eyeDir, TGCVector3.Up);
float distFactorForward = 0.707f;
float distFactorSide = 0.3f;//para meter chunks que esten lo suficientemente cerca al costado
bool sngx = lightPos.X <= lightObj.X;
bool sngz = lightPos.Z <= lightObj.Z;// <= aca y < en el bucle para que de distinto si justo son iguales
for (int i = 0; ; i++)
{
var along = lightPos + eyeDir * i * chunkLen * distFactorForward;
if ((along.X < lightObj.X) != sngx &&
(along.Z < lightObj.Z) != sngz)//creo que sería seguro probar con un eje nomas
{
break;
}
for (int j = -1; j <= 1; j++)
{
var pos = along
+ ortogDir * chunkLen * j * distFactorSide;
Chunk c = fromCoordinates(pos);
if (c != null)
{
c.renderForShadow();
}
}
}
//traigo los que estan cerca de la camara tambien
var index = toIndexSpace(g.camera.eyePosition, 2);
for (int i = -2; i <= 2; i++)
{
for (int j = -2; j <= 2; j++)
{
chunks[index.i, index.j].renderForShadow();
}
}
//Console.WriteLine(chunksRendered);
}
public float SetDirection(TGCVector3 output, TGCVector3 normal)
{
float angle = GlobalConcepts.GetInstance().AngleBetweenVectors(normal, output);
TGCVector3 result = TGCVector3.Cross(output, normal);
//por la regla de la mano derecha
angle = (result.Y < 0) ? angle + FastMath.PI : angle;
this.Girar(angle);
return(angle);
}
/// <summary>
/// Calcular los 8 vertices del Frustum
/// Basado en: http://www.lighthouse3d.com/tutorials/view-frustum-culling/geometric-approach-implementation/
/// </summary>
/// <param name="position"></param>
/// <param name="lookAt"></param>
/// <param name="aspectRatio"></param>
/// <param name="nearDistance"></param>
/// <param name="farDistance"></param>
/// <param name="fieldOfViewY"></param>
/// <returns>Los 8 vertices del Frustum</returns>
private TGCVector3[] computeFrustumCorners(TGCVector3 position, TGCVector3 lookAt, float aspectRatio, float nearDistance,
float farDistance, float fieldOfViewY)
{
var corners = new TGCVector3[8];
/*
* (ntl)0 ---- 1(ntr)
| | Near-face
| (nbl)2 ---- 3(nbr)
|
| (ftl)4 ---- 5(ftr)
| | Far-face
| (fbl)6 ---- 7(fbr)
*/
var tang = FastMath.Tan(fieldOfViewY * 0.5f);
var nh = nearDistance * tang;
var nw = nh * aspectRatio;
var fh = farDistance * tang;
var fw = fh * aspectRatio;
// compute the Z axis of camera
// this axis points in the opposite direction from
// the looking direction
var Z = TGCVector3.Subtract(position, lookAt);
Z.Normalize();
// X axis of camera with given "up" vector and Z axis
var X = TGCVector3.Cross(UP_VECTOR, Z);
X.Normalize();
// the real "up" vector is the cross product of Z and X
var Y = TGCVector3.Cross(Z, X);
// compute the centers of the near and far planes
var nc = position - Z * nearDistance;
var fc = position - Z * farDistance;
// compute the 4 corners of the frustum on the near plane
corners[0] = nc + Y * nh - X * nw; //ntl
corners[1] = nc + Y * nh + X * nw; //ntr
corners[2] = nc - Y * nh - X * nw; //nbl
corners[3] = nc - Y * nh + X * nw; //nbr
// compute the 4 corners of the frustum on the far plane
corners[4] = fc + Y * fh - X * fw; //ftl
corners[5] = fc + Y * fh + X * fw; //ftr
corners[6] = fc - Y * fh - X * fw; //fbl
corners[7] = fc - Y * fh + X * fw; //fbr
return(corners);
}
public TGCVector3 NormalVectorGivenXZ(float X, float Z)
{
float delta = 0.3f;
InterpoledHeight(X, Z + delta, out float alturaN);
InterpoledHeight(X, Z - delta, out float alturaS);
InterpoledHeight(X + delta, Z, out float alturaE);
InterpoledHeight(X - delta, Z, out float alturaO);
TGCVector3 vectorEO = new TGCVector3(delta * 2, alturaE - alturaO, 0);
TGCVector3 vectorNS = new TGCVector3(0, alturaN - alturaS, delta * 2);
return(TGCVector3.Cross(vectorNS, vectorEO));
}
public static TGCVector3 rotate_vector_by_quaternion(TGCVector3 v, Quaternion q)
{
// Extract the vector part of the quaternion
TGCVector3 u = new TGCVector3(q.X, q.Y, q.Z);
// Extract the scalar part of the quaternion
float s = q.W;
// Do the math
var vprime = 2.0f * TGCVector3.Dot(u, v) * u
+ (s * s - TGCVector3.Dot(u, u)) * v
+ 2.0f * s * TGCVector3.Cross(u, v);
return(vprime);
}
/// <summary>
/// Configura la posicion de la camara, punto de entrada para todas las camaras, con los mismos se calcula la matriz de view.
/// Los vectores son utilizadas por GetViewMatrix.
/// </summary>
/// <param name="pos">Posicion de la camara</param>
/// <param name="lookAt">Punto hacia el cual se quiere ver</param>
public virtual void SetCamera(TGCVector3 pos, TGCVector3 lookAt)
{
//Direccion efectiva de la vista.
TGCVector3 direction = lookAt - pos;
//Se busca el vector que es producto del (0,1,0)Up y la direccion de vista.
TGCVector3 crossDirection = TGCVector3.Cross(TGCVector3.Up, direction);
//El vector de Up correcto dependiendo del LookAt
TGCVector3 finalUp = TGCVector3.Cross(direction, crossDirection);
Position = pos;
LookAt = lookAt;
UpVector = finalUp;
}
private void Chase()
{
LookDirection = TGCVector3.Normalize(GameInstance.Player.Position - Position);
TGCVector3 rotationAxis = TGCVector3.Cross(InitialLookDirection, LookDirection); // Ojo el orden - no es conmutativo
TGCQuaternion rotationQuat = TGCQuaternion.RotationAxis(rotationAxis, MathExtended.AngleBetween(InitialLookDirection, LookDirection));
TGCVector3 nextPosition = Position + LookDirection * chasingSpeed * GameInstance.ElapsedTime;
TGCMatrix translationMatrix = TGCMatrix.Translation(nextPosition);
TGCMatrix rotationMatrix = TGCMatrix.RotationTGCQuaternion(rotationQuat);
TGCMatrix nextTransform = rotationMatrix * translationMatrix;
SimulateAndSetTransformation(nextPosition, nextTransform);
}
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();
}
public void DrawLine(TGCVector3 p0, TGCVector3 p1, TGCVector3 up, float dw, Color color)
{
TGCVector3 v = p1 - p0;
v.Normalize();
TGCVector3 n = TGCVector3.Cross(v, up);
TGCVector3 w = TGCVector3.Cross(n, v);
TGCVector3[] p = new TGCVector3[8];
dw *= 0.5f;
p[0] = p0 - n * dw;
p[1] = p1 - n * dw;
p[2] = p1 + n * dw;
p[3] = p0 + n * dw;
for (int i = 0; i < 4; ++i)
{
p[4 + i] = p[i] + w * dw;
p[i] -= w * dw;
}
int[] index_buffer = { 0, 1, 2, 0, 2, 3,
4, 5, 6, 4, 6, 7,
0, 1, 5, 0, 5, 4,
3, 2, 6, 3, 6, 7 };
VERTEX_POS_COLOR[] pt = new VERTEX_POS_COLOR[index_buffer.Length];
for (int i = 0; i < index_buffer.Length; ++i)
{
int index = index_buffer[i];
pt[i].x = p[index].X;
pt[i].y = p[index].Y;
pt[i].z = p[index].Z;
pt[i].color = color.ToArgb();
}
// dibujo como lista de triangulos
var device = D3DDevice.Instance.Device;
device.VertexFormat = VertexFormats.Position | VertexFormats.Diffuse;
device.DrawUserPrimitives(PrimitiveType.TriangleList, index_buffer.Length / 3, pt);
}
public void setCamera(TGCVector3 eye, TGCVector3 target)
{
this.eye = eye;
this.target = target;
zAxis = target - eye;
zAxis.Normalize();
xAxis = TGCVector3.Cross(up, zAxis);
xAxis.Normalize();
yAxis = TGCVector3.Cross(zAxis, xAxis);
yAxis.Normalize();
forward = TGCVector3.Cross(xAxis, up);
forward.Normalize();
rotationChanged = true;
positionChanged = true;
}
public void Update(TGCVector3 cameraDirection, float elapsedTime)
{
float RotationStep = FastMath.PI * 2.5f * elapsedTime;
CalculateRotationByAtack(RotationStep);
AttackLocked = !(AttackForwardRotation <= 0) && !(AttackSideRotation <= 0);
var localSideAxis = TGCVector3.Cross(TGCVector3.Up, cameraDirection);
localSideAxis.Normalize();
var forwardOffset = cameraDirection * 43;
var sideOffset = localSideAxis * 15;
TGCVector3 newPosition = Camera.Position + forwardOffset + sideOffset;
Mesh.Transform = TGCMatrix.Scaling(scale) *
TGCMatrix.RotationYawPitchRoll(Camera.Latitude - AttackSideRotation,
Camera.Longitude + RotationXOffset - AttackForwardRotation, 0) *
TGCMatrix.Translation(newPosition);
Mesh.BoundingBox.transform(Mesh.Transform);
}
/// <summary>
/// Reconstruct the view TGCMatrix.
/// </summary>
private void reconstructViewTGCMatrix(bool orthogonalizeAxes)
{
if (orthogonalizeAxes)
{
// Regenerate the camera's local axes to orthogonalize them.
zAxis.Normalize();
yAxis = TGCVector3.Cross(zAxis, xAxis);
yAxis.Normalize();
xAxis = TGCVector3.Cross(yAxis, zAxis);
xAxis.Normalize();
viewDir = zAxis;
LookAt = eye + viewDir;
}
// Reconstruct the view TGCMatrix.
viewTGCMatrix.M11 = xAxis.X;
viewTGCMatrix.M21 = xAxis.Y;
viewTGCMatrix.M31 = xAxis.Z;
viewTGCMatrix.M41 = -TGCVector3.Dot(xAxis, eye);
viewTGCMatrix.M12 = yAxis.X;
viewTGCMatrix.M22 = yAxis.Y;
viewTGCMatrix.M32 = yAxis.Z;
viewTGCMatrix.M42 = -TGCVector3.Dot(yAxis, eye);
viewTGCMatrix.M13 = zAxis.X;
viewTGCMatrix.M23 = zAxis.Y;
viewTGCMatrix.M33 = zAxis.Z;
viewTGCMatrix.M43 = -TGCVector3.Dot(zAxis, eye);
viewTGCMatrix.M14 = 0.0f;
viewTGCMatrix.M24 = 0.0f;
viewTGCMatrix.M34 = 0.0f;
viewTGCMatrix.M44 = 1.0f;
}
virtual public void Collide(Vehicle car)
{
var dot = TGCVector3.Dot(car.vectorAdelante, this.outDirection);
var modulusProduct = car.vectorAdelante.Length() * this.outDirection.Length();
var angle = (float)Math.Acos(dot / modulusProduct);
var yCross = TGCVector3.Cross(car.vectorAdelante, this.outDirection).Y;
var giro = (yCross > 0) ? angle : -angle;
car.Girar(giro);
if (!(car is ArtificialIntelligence))
{
Scene.GetInstance().camera.rotateY(giro);
}
if (car.GetVelocidadActual() < 0)
{
car.Girar(FastMath.PI);
if (!(car is ArtificialIntelligence))
{
Scene.GetInstance().camera.rotateY(FastMath.PI);
}
}
}
public void render()
{
updateMesh();
mesh.Effect = Meshc.actualShader;
mesh.Effect.SetValue("type", 2);
mesh.Technique = Meshc.actualTechnique;
mesh.Render();
if (GameModel.debugSqueleton)
{
TgcLine.fromExtremes(cPos, cPos + colDir, Color.Red).Render();
TGCVector3 cross = TGCVector3.Cross(colDir, TGCVector3.Up);
TgcLine.fromExtremes(cPos, cPos + cross * sidePref, Color.Green).Render();
var lightObj = new TGCVector3(g.mostro.lightObj.X, g.mostro.flyHeight, g.mostro.lightObj.Y);
var lightObjObj = new TGCVector3(g.mostro.lightObjObj.X, g.mostro.flyHeight, g.mostro.lightObjObj.Y);
TgcLine.fromExtremes(lightObj - TGCVector3.Up * 10000f, lightObj + TGCVector3.Up * 10000f, Color.Green).Render();
TgcLine.fromExtremes(lightObjObj - TGCVector3.Up * 10000f, lightObjObj + TGCVector3.Up * 10000f, Color.Red).Render();
}
}
public int state = 0;//0 nada 1 mano derecha 2 ambas manos
//estas variables estan para hacer la animacion de levantar la vela si es que la hago,
//por ahora lo dejo para el final
//TGCVector3 rightPos = new TGCVector3(-25f, -10f, -25f);
//TGCVector3 leftPos = new TGCVector3(0, 0, 0);
//con los estados y si las pos.y>k se sabe todo lo necesario
public void renderCandles()
{
/*
if(rightPos.Y> k)
//vela en campo visual, dependiendo del estado ver si poner shaders y si moverla adentro o afuera de la pantalla
//lo mismo para la izquierda, y esta lo de pasar la vela a la otra mano si se apaga la derecha
*/
#if false
var up = g.camera.UpVector;
#else
var up = TGCVector3.Up;
#endif
var forwardPos = g.camera.eyePosition + g.camera.cameraRotatedTarget * 10f;
if (state > 0)
{
var rotatedPos= forwardPos
+ TGCVector3.Cross(g.camera.eyePosition - forwardPos, up) * .4f
+ TGCVector3.Down * 4f;
//Camera.Camera.cameraRotation * iria al principio, pero sacandole los elementos en y
//o construir una matriz de rotacion segun algo
g.map.candleMesh.Transform = TGCMatrix.Scaling(.1f, .2f, .1f) * TGCMatrix.Translation(rotatedPos);
//lo de mirar hacia arriba y que levante la vela no fue intencional pero queda bien
g.map.candleMesh.Render();
}
if (state == 2)
{
var rotatedPos = forwardPos
+ TGCVector3.Cross(g.camera.eyePosition - forwardPos, up) * -.4f
+ TGCVector3.Down * 4f;
//Camera.Camera.cameraRotation * iria al principio, pero sacandole los elementos en y
//o construir una matriz de rotacion segun algo
g.map.candleMesh.Transform = TGCMatrix.Scaling(.1f, .2f, .1f) * TGCMatrix.Translation(rotatedPos);
//lo de mirar hacia arriba y que levante la vela no fue intencional pero queda bien
g.map.candleMesh.Render();
}
}