public Line(RecreateCoordinates A, RecreateCoordinates B, LINETYPE type)
{
this.A = A;
this.B = B;
this.type = type;
v = new RecreateCoordinates(B.x - A.x, B.y - A.y, B.z - A.z);
}
//Create my own Translate
public static RecreateCoordinates Translate(RecreateCoordinates position, RecreateCoordinates facing, RecreateCoordinates vector)
{
if (Distance(new RecreateCoordinates(0, 0, 0), vector) <= 0)
{
return(position);
}
float angle = Angle(vector, facing);
float worldAngle = Angle(vector, new RecreateCoordinates(0, 1, 0));
bool clockwise = false;
if (CrossProduct(vector, facing).z < 0)
{
clockwise = true;
}
vector = Rotate(vector, angle + worldAngle, clockwise);
float xValue = position.x + vector.x;
float yValue = position.y + vector.y;
float zValue = position.z + vector.z;
return(new RecreateCoordinates(xValue, yValue, zValue));
}
public static float Angle(RecreateCoordinates vector1, RecreateCoordinates vector2)
{
float dotDivided = DotProduct(vector1, vector2) / (Distance(new RecreateCoordinates(0, 0, 0), vector1) * Distance(new RecreateCoordinates(0, 0, 0), vector2));
return(Mathf.Acos(dotDivided));
}
public Plane(RecreateCoordinates A, RecreateCoordinates B, RecreateCoordinates C)
{
this.A = A;
this.B = B;
this.C = C;
v = B - A;
u = C - A;
}
public static RecreateCoordinates CrossProduct(RecreateCoordinates vector1, RecreateCoordinates vector2)
{
float xCrossValue = vector1.y * vector2.z - vector1.z * vector2.y;
float yCrossValue = vector1.z * vector2.x - vector1.x * vector2.z;
float zCrossValue = vector1.x * vector2.y - vector1.y * vector2.x;
return(new RecreateCoordinates(xCrossValue, yCrossValue, zCrossValue));
}
public TestPlane(RecreateCoordinates A, RecreateCoordinates B, RecreateCoordinates C)
{
this.A = A;
this.B = B;
this.C = C;
this.v = B - A;
this.u = C - A;
}
public static float Distance(RecreateCoordinates point1, RecreateCoordinates point2)
{
float differenceSquare = Square(point1.x - point2.x)
+ Square(point1.y - point2.y)
+ Square(point1.z - point2.z);
return(Mathf.Sqrt(differenceSquare));
}
//create my own Lerp Behavior
static public RecreateCoordinates Lerp(RecreateCoordinates A, RecreateCoordinates B, float t)
{
t = Mathf.Clamp(t, 0, 1);
RecreateCoordinates v = new RecreateCoordinates(B.x - A.x, B.y - A.y, B.z - A.z);
float xt = A.x + v.x * t;
float yt = A.y + v.y * t;
float zt = A.z + v.z * t;
return(new RecreateCoordinates(xt, yt, zt));
}
public static RecreateCoordinates Normal(RecreateCoordinates vector)
{
float length = Distance(new RecreateCoordinates(0, 0, 0), vector);
vector.x /= length;
vector.y /= length;
vector.z /= length;
return(vector);
}
public static RecreateCoordinates MatrixRotate(RecreateCoordinates position, float angleX, bool clockwiseX, float angleY, bool clockwiseY, float angleZ, bool clockwiseZ)
{
if (clockwiseX)
{
angleX = 2 * Mathf.PI - angleX;
}
if (clockwiseY)
{
angleY = 2 * Mathf.PI - angleY;
}
if (clockwiseZ)
{
angleZ = 2 * Mathf.PI - angleZ;
}
float[] xRollValues =
{
1, 0, 0, 0,
0, Mathf.Cos(angleX), -Mathf.Sin(angleX), 0,
0, Mathf.Sin(angleX), Mathf.Cos(angleX), 0,
0, 0, 0, 1
};
Matrix xRoll = new Matrix(4, 4, xRollValues);
float[] yRollValues =
{
Mathf.Cos(angleY), 0, Mathf.Sin(angleY), 0,
0, 1, 0, 0,
-Mathf.Sin(angleY), 0, Mathf.Cos(angleY), 0,
0, 0, 0, 1
};
Matrix yRoll = new Matrix(4, 4, yRollValues);
float[] zRollValues =
{
Mathf.Cos(angleZ), -Mathf.Sin(angleZ), 0, 0,
Mathf.Sin(angleZ), Mathf.Cos(angleZ), 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
};
Matrix zRoll = new Matrix(4, 4, zRollValues);
Matrix pos = new Matrix(4, 1, position.AsFloats());
Matrix result = zRoll * yRoll * xRoll * pos;
return(result.AsCoordinates());
}
public static RecreateCoordinates Rotate(RecreateCoordinates vector, float angle, bool clockwise)
{
if (clockwise)
{
angle = 2 * Mathf.PI - angle; // this method works in radians and 2 * Math.PI is equal to 360 degress of a circle
}
float xValue = vector.x * Mathf.Cos(angle) - vector.y * Mathf.Sin(angle);
float yValue = vector.x * Mathf.Sin(angle) + vector.y * Mathf.Cos(angle);
return(new RecreateCoordinates(xValue, yValue, 0.0f));
}
public static void DrawLine(RecreateCoordinates startPoint, RecreateCoordinates endPoint, float width, Color color)
{
GameObject line = new GameObject("Line: " + startPoint.ToString() + " , " + endPoint.ToString());
LineRenderer lineRenderer = line.AddComponent <LineRenderer>();
lineRenderer.material = new Material(Shader.Find("Unlit/Color"));
lineRenderer.material.color = color;
lineRenderer.positionCount = 2;
lineRenderer.SetPosition(0, new Vector3(startPoint.x, startPoint.y, startPoint.z));
lineRenderer.SetPosition(1, new Vector3(endPoint.x, endPoint.y, endPoint.z));
lineRenderer.startWidth = width;
lineRenderer.endWidth = width;
}
void MoveArrayPoints()
{
foreach (GameObject p in points)
{
RecreateCoordinates position = new RecreateCoordinates(p.transform.position, 1);
//p.transform.position = RecreateOwnMathematics.MatrixTranslate(position,new RecreateCoordinates(translation.x,translation.y,translation.z,0)).ConvertToVector();
position = RecreateOwnMathematics.MatrixTranslate(position, new RecreateCoordinates(new Vector3(-c.x, -c.y, -c.z), 0));
//p.transform.position = RecreateOwnMathematics.MatrixScale(position,scaling.x,scaling.y,scaling.z).ConvertToVector();
position = RecreateOwnMathematics.MatrixScale(position, scaling.x, scaling.y, scaling.z);
p.transform.position = RecreateOwnMathematics.MatrixTranslate(position, new RecreateCoordinates(c.x, c.y, c.z, 0)).ConvertToVector();
}
}
public static RecreateCoordinates MatrixScale(RecreateCoordinates position, float scaleX, float scaleY, float scaleZ)
{
float[] scaleValues =
{
scaleX, 0, 0, 0,
0, scaleY, 0, 0,
0, 0, scaleZ, 0,
0, 0, 0, 1
};
Matrix scaleMatrix = new Matrix(4, 4, scaleValues);
Matrix pos = new Matrix(4, 1, position.AsFloats());
Matrix result = scaleMatrix * pos;
return(result.AsCoordinates());
}
void RotateArrayPoints()
{
angle = angle * Mathf.Deg2Rad;
foreach (GameObject p in points)
{
RecreateCoordinates position = new RecreateCoordinates(p.transform.position, 1);
position = RecreateOwnMathematics.MatrixTranslate(position, new RecreateCoordinates(new Vector3(-c.x, -c.y, -c.z), 0));
//p.transform.position = RecreateOwnMathematics.MatrixRotate(position,angle.x,true,angle.y,true,angle.z,true).ConvertToVector();
position = RecreateOwnMathematics.MatrixRotate(position, angle.x, true, angle.y, true, angle.z, true);
p.transform.position = RecreateOwnMathematics.MatrixTranslate(position, new RecreateCoordinates(c.x, c.y, c.z, 0)).ConvertToVector();
}
}
//translate for matrix
public static RecreateCoordinates MatrixTranslate(RecreateCoordinates position, RecreateCoordinates vector)
{
float[] translateValues =
{
1, 0, 0, vector.x,
0, 1, 0, vector.y,
0, 0, 1, vector.z,
0, 0, 0, 1
};
Matrix translateMatrix = new Matrix(4, 4, translateValues);
Matrix pos = new Matrix(4, 1, position.AsFloats());
Matrix result = translateMatrix * pos;
return(result.AsCoordinates());
}
public static float Distance(RecreateCoordinates vector1, RecreateCoordinates vector2)
{
float differenceDistance = Square(vector1.x - vector2.x) + Square(vector1.y - vector2.y) + Square(vector1.z - vector2.z);
return(Mathf.Sqrt(differenceDistance));
}
public static RecreateCoordinates Perpendiculare(RecreateCoordinates vector)
{
return(new RecreateCoordinates(-vector.y, vector.x));
}
public Plane(RecreateCoordinates A, Vector3 V, Vector3 U)
{
this.A = A;
v = new RecreateCoordinates(V.x, V.y, V.z);
u = new RecreateCoordinates(U.x, U.y, U.z);
}
//Dot Product
public static float DotProduct(RecreateCoordinates vector1, RecreateCoordinates vector2)
{
return(vector1.x * vector2.x + vector1.y * vector2.y + vector1.z * vector2.z);
}
public static RecreateCoordinates operator-(RecreateCoordinates a, RecreateCoordinates b)
{
RecreateCoordinates c = new RecreateCoordinates(a.x - b.x, a.y - b.y, a.z - b.z);
return(c);
}
public TestLine(RecreateCoordinates A, RecreateCoordinates V)
{
this.A = A;
B = A + V;
this.v = V;
}
public void Draw(float width, Color color)
{
RecreateCoordinates.DrawLine(A, B, width, color);
}
public static float Angle(RecreateCoordinates vector1, RecreateCoordinates vector2)
{
float angle = DotProduct(vector1, vector2) / Distance(new RecreateCoordinates(0, 0, 0), vector1) * Distance(new RecreateCoordinates(0, 0, 0), vector2);
return(Mathf.Acos(angle));
}
