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)); }