public static PVector FromAngle(float angle, PVector target)
{
if (target == null)
{
target = new PVector();
}
float x = (float)Math.Cos(angle);
float y = (float)Math.Sin(angle);
target.Set(x, y);
return(target);
}
public float AngleBetween(PVector v)
{
if (isAllComponentsZero(this) || isAllComponentsZero(v))
{
return(0.0f);
}
float dotProduct = Dot(v);
float thisMagnitude = Mag();
float vMagnitude = v.Mag();
float cosAngle = dotProduct / (thisMagnitude * vMagnitude);
float angle = (float)Math.Acos(cosAngle);
return(angle);
}
public static PVector Cross(PVector v1, PVector v2, PVector target)
{
PVector crossProduct = v1.Cross(v2);
if (target == null)
{
target = crossProduct;
}
else
{
target.Set(crossProduct.X, crossProduct.Y, crossProduct.Z);
}
return(target);
}
public PVector Cross(PVector v, PVector target)
{
float xCrossComponent = Y * v.Z - Z * v.Y;
float yCrossComponent = Z * v.X - X * v.Z;
float zCrossComponent = X * v.Y - Y * v.X;
if (target == null)
{
target = new PVector(xCrossComponent, yCrossComponent, zCrossComponent);
}
else
{
target.Set(xCrossComponent, yCrossComponent, zCrossComponent);
}
return(target);
}
public static PVector Div(PVector vectorA, float scalar, PVector target)
{
PVector resultVector;
if (target == null)
{
resultVector = vectorA.Copy();
}
else
{
target.X = vectorA.X;
target.Y = vectorA.Y;
target.Z = vectorA.Z;
resultVector = target;
}
return(resultVector.Div(scalar));
}
public static PVector Add(PVector vectorA, PVector vectorB, PVector target)
{
PVector resultVector;
if (target == null)
{
resultVector = vectorA.Copy();
}
else
{
target.X = vectorA.X;
target.Y = vectorA.Y;
target.Z = vectorA.Z;
resultVector = target;
}
return(resultVector.Add(vectorB));
}
public static PVector Random2D(PVector target, Random random)
{
if (random == null)
{
random = new Random();
}
float randomAngle = (float)(random.NextDouble() * Math.PI * 2);
if (target == null)
{
target = FromAngle(randomAngle);
}
else
{
PVector vectorFromAngle = FromAngle(randomAngle);
target.Set(vectorFromAngle.X, vectorFromAngle.Y);
}
return(target);
}
public static PVector Random3D(PVector target, Random random)
{
const int maxValue = 1000;
if (random == null)
{
random = new Random();
}
float randomX = (float)((random.NextDouble() * 2 - 1) * maxValue);
float randomY = (float)((random.NextDouble() * 2 - 1) * maxValue);
float randomZ = (float)((random.NextDouble() * 2 - 1) * maxValue);
if (target == null)
{
target = new PVector(randomX, randomY, randomZ);
}
else
{
target.Set(randomX, randomY, randomZ);
}
target.Normalize();
return(target);
}
public virtual void Text(string text, float x, float y, float z)
{
PVector transformedPosition = transformation.GetTransformedVector(x, y, z);
drawTextImpl(transformedPosition, text.ToCharArray());
}
public virtual void Vertex(float x, float y)
{
PVector position = transformation.GetTransformedVector(x, y);
addVertexImpl(position);
}
public virtual void Ellipse(float x, float y, float width, float height)
{
PVector transformedPosition = transformation.GetTransformedVector(x - width, y - height);
drawEllipseImpl(transformedPosition, width, height);
}
public virtual void Rect(float x, float y, float width, float heigth)
{
PVector transformedPosition = transformation.GetTransformedVector(x, y);
drawRectImpl(transformedPosition, width, heigth);
}
protected virtual void drawTextImpl(PVector position, char[] chars)
{
}
protected virtual void drawLineImpl(PVector p1, PVector p2)
{
}
public static PVector Lerp(PVector v1, PVector v2, float ammount)
{
PVector resultVector = v1.Copy();
return(resultVector.Lerp(v2, ammount));
}
protected virtual void drawEllipseImpl(PVector position, float width, float height)
{
}
protected virtual void drawPointImpl(PVector position)
{
}
public static PVector Random3D(PVector target)
{
return(Random3D(target, null));
}
protected virtual void addVertexImpl(PVector position)
{
}
public PVector Set(PVector v)
{
return(Set(v.X, v.Y, v.Z));
}
public virtual void Circle(float x, float y, float radius)
{
PVector transformedPosition = transformation.GetTransformedVector(x - radius, y - radius);
drawCircleImpl(transformedPosition, radius);
}
private bool isAllComponentsZero(PVector testVector)
{
return(testVector.X == 0 && testVector.Y == 0 && testVector.Z == 0);
}
public virtual void Square(float x, float y, float sideLength)
{
PVector transformedPosition = transformation.GetTransformedVector(x, y);
drawSquareImpl(transformedPosition, sideLength);
}
public Transformation()
{
origin = new PVector(0, 0, 0);
Angle = 0;
}
public virtual void Point(int x, int y)
{
PVector transformedPosition = transformation.GetTransformedVector(x, y);
drawPointImpl(transformedPosition);
}
protected virtual void drawCircleImpl(PVector position, float radius)
{
}
public virtual void Text(char c, float x, float y, float z)
{
PVector transformedPosition = transformation.GetTransformedVector(x, y, z);
drawTextImpl(transformedPosition, new char[] { c });
}
protected virtual void drawRectImpl(PVector position, float width, float heigth)
{
}
public virtual void Text(int num, float x, float y, float z)
{
PVector transformedPosition = transformation.GetTransformedVector(x, y, z);
drawTextImpl(transformedPosition, num.ToString().ToCharArray());
}
protected virtual void drawSquareImpl(PVector position, float sideLength)
{
}
