public static Vector3D GetTransformNormalNormalized(Vector3D vec, ref MatrixD matrix)
{
Vector3D ret;
Vector3D.TransformNormal(ref vec, ref matrix, out ret);
ret = MyUtils.Normalize(ret);
return(ret);
}
public static void GetPolyLineQuad(out MyQuadD retQuad, ref MyPolyLineD polyLine, Vector3D cameraPosition)
{
Vector3D cameraToPoint = MyUtils.Normalize(cameraPosition - polyLine.Point0);
Vector3D sideVector = GetVector3Scaled(Vector3D.Cross(polyLine.LineDirectionNormalized, cameraToPoint), polyLine.Thickness);
retQuad.Point0 = polyLine.Point0 - sideVector;
retQuad.Point1 = polyLine.Point1 - sideVector;
retQuad.Point2 = polyLine.Point1 + sideVector;
retQuad.Point3 = polyLine.Point0 + sideVector;
}
public static Vector3D GetClosestPointOnLine(ref Vector3D linePointA, ref Vector3D linePointB, ref Vector3D point, out double dist)
{
// Create the vector from end point vA to our point vPoint.
Vector3D vector1 = point - linePointA;
// Create a normalized direction vector from end point vA to end point vB
Vector3D vector2 = MyUtils.Normalize(linePointB - linePointA);
// Use the distance formula to find the distance of the line segment (or magnitude)
var d = Vector3D.Distance(linePointA, linePointB);
// Using the dot product, we project the vVector1 onto the vector vVector2.
// This essentially gives us the distance from our projected vector from vA.
var t = Vector3D.Dot(vector2, vector1);
dist = t;
// If our projected distance from vA, "t", is less than or equal to 0, it must
// be closest to the end point vA. We want to return this end point.
if (t <= 0)
{
return(linePointA);
}
// If our projected distance from vA, "t", is greater than or equal to the magnitude
// or distance of the line segment, it must be closest to the end point vB. So, return vB.
if (t >= d)
{
return(linePointB);
}
// Here we create a vector that is of length t and in the direction of vVector2
Vector3D vector3 = vector2 * t;
// To find the closest point on the line segment, we just add vVector3 to the original
// end point vA.
// Return the closest point on the line segment
return(linePointA + vector3);
}
// Return quad whos face is always looking to the camera. This is the real billboard, with perspective distortions!
// Billboard's orientation is calculated by projecting unit sphere's north pole to billboard's plane. From this we can get up/right vectors.
// Idea is this: if camera is in the middle of unit sphere and billboard is touching this sphere at some place (still unit sphere), we
// know billboard's plan is perpendicular to the sphere, so if we want billboard's orientation to be like earth's latitude and Colatitude,
// we need to find billboard's up vector in the direction. This is when projection cames into place.
// Notice that we don't need camera left/up vector. We only need camera position. Because it's about the sphere around the player. Not camera orientation.
// IMPORTANT: One problem of this approach is that if billboard is right above the player, its orientation will swing. Thats because we are projecting
// Rotation is around vector pointing from camera position to center of the billboard.
// the point, but it ends right in the billboard's centre.
// So we not use this for particles. We use it only for background sphere (starts, galaxies) prerender.
// Return false if billboard wasn't for any reason created (e.g. too close to the camera)
public static bool GetBillboardQuadAdvancedRotated(out MyQuadD quad, Vector3D position, float radiusX, float radiusY, float angle, Vector3D cameraPosition)
{
// Optimized: Vector3 dirVector = MyMwcUtils.Normalize(position - cameraPosition);
Vector3D dirVector;
dirVector.X = (position.X - cameraPosition.X);
dirVector.Y = (position.Y - cameraPosition.Y);
dirVector.Z = (position.Z - cameraPosition.Z);
// If distance to camera is really small don't draw it.
if (dirVector.LengthSquared() <= MyMathConstants.EPSILON)
{
// Some empty quad
quad = new MyQuadD();
return(false);
}
dirVector = MyUtils.Normalize(dirVector);
Vector3D projectedPoint;
// Project Up onto plane defined by origin and dirVector
Vector3D.Reject(ref Vector3D.Up, ref dirVector, out projectedPoint);
Vector3D upVector;
if (projectedPoint.LengthSquared() <= MyMathConstants.EPSILON_SQUARED)
{
// If projected point equals to zero, we know billboard is exactly above or bottom of camera
// and we can't calculate proper orientation. So we just select some direction. Good thing we
// know is that billboard's plan ix XY, so we can choose any point on this plane
upVector = Vector3D.Forward;
}
else
{
// Optimized: upVector = MyMwcUtils.Normalize(projectedPoint);
MyUtils.Normalize(ref projectedPoint, out upVector);
}
// Optimized: Vector3 leftVector = MyMwcUtils.Normalize(Vector3.Cross(upVector, dirVector));
Vector3D leftVector;
Vector3D.Cross(ref upVector, ref dirVector, out leftVector);
leftVector = MyUtils.Normalize(leftVector);
// Two main vectors of a billboard rotated around the view axis/vector
float angleCos = (float)Math.Cos(angle);
float angleSin = (float)Math.Sin(angle);
Vector3D billboardAxisX;
billboardAxisX.X = (radiusX * angleCos) * leftVector.X + (radiusY * angleSin) * upVector.X;
billboardAxisX.Y = (radiusX * angleCos) * leftVector.Y + (radiusY * angleSin) * upVector.Y;
billboardAxisX.Z = (radiusX * angleCos) * leftVector.Z + (radiusY * angleSin) * upVector.Z;
Vector3D billboardAxisY;
billboardAxisY.X = (-radiusX * angleSin) * leftVector.X + (radiusY * angleCos) * upVector.X;
billboardAxisY.Y = (-radiusX * angleSin) * leftVector.Y + (radiusY * angleCos) * upVector.Y;
billboardAxisY.Z = (-radiusX * angleSin) * leftVector.Z + (radiusY * angleCos) * upVector.Z;
// Coordinates of four points of a billboard's quad
quad.Point0.X = position.X + billboardAxisX.X + billboardAxisY.X;
quad.Point0.Y = position.Y + billboardAxisX.Y + billboardAxisY.Y;
quad.Point0.Z = position.Z + billboardAxisX.Z + billboardAxisY.Z;
quad.Point1.X = position.X - billboardAxisX.X + billboardAxisY.X;
quad.Point1.Y = position.Y - billboardAxisX.Y + billboardAxisY.Y;
quad.Point1.Z = position.Z - billboardAxisX.Z + billboardAxisY.Z;
quad.Point2.X = position.X - billboardAxisX.X - billboardAxisY.X;
quad.Point2.Y = position.Y - billboardAxisX.Y - billboardAxisY.Y;
quad.Point2.Z = position.Z - billboardAxisX.Z - billboardAxisY.Z;
quad.Point3.X = position.X + billboardAxisX.X - billboardAxisY.X;
quad.Point3.Y = position.Y + billboardAxisX.Y - billboardAxisY.Y;
quad.Point3.Z = position.Z + billboardAxisX.Z - billboardAxisY.Z;
return(true);
}
public MyPlane(ref MyTriangle_Vertexes triangle)
{
Point = triangle.Vertex0;
Normal = MyUtils.Normalize(Vector3.Cross((triangle.Vertex1 - triangle.Vertex0), (triangle.Vertex2 - triangle.Vertex0)));
}
