public static Matrix4by4 operator *(Matrix4by4 matrix1, Matrix4by4 matrix2)
{
//overriden operator for multiplying a matrix by another matrix
Matrix4by4 matrixReturn = new Matrix4by4(new Vector3(0, 0, 0), new Vector3(0, 0, 0), new Vector3(0, 0, 0), new Vector3(0, 0, 0));
matrixReturn.values[0, 0] = matrix1.values[0, 0] * matrix2.values[0, 0] + matrix1.values[0, 1] * matrix2.values[1, 0] + matrix1.values[0, 2] * matrix2.values[2, 0] + matrix1.values[0, 3] * matrix2.values[3, 0];
matrixReturn.values[0, 1] = matrix1.values[0, 0] * matrix2.values[0, 1] + matrix1.values[0, 1] * matrix2.values[1, 1] + matrix1.values[0, 2] * matrix2.values[2, 1] + matrix1.values[0, 3] * matrix2.values[3, 1];
matrixReturn.values[0, 2] = matrix1.values[0, 0] * matrix2.values[0, 2] + matrix1.values[0, 1] * matrix2.values[1, 2] + matrix1.values[0, 2] * matrix2.values[2, 2] + matrix1.values[0, 3] * matrix2.values[3, 2];
matrixReturn.values[0, 3] = matrix1.values[0, 0] * matrix2.values[0, 3] + matrix1.values[0, 1] * matrix2.values[1, 3] + matrix1.values[0, 2] * matrix2.values[2, 3] + matrix1.values[0, 3] * matrix2.values[3, 3];
matrixReturn.values[1, 0] = matrix1.values[1, 0] * matrix2.values[0, 0] + matrix1.values[1, 1] * matrix2.values[1, 0] + matrix1.values[1, 2] * matrix2.values[2, 0] + matrix1.values[1, 3] * matrix2.values[3, 0];
matrixReturn.values[1, 1] = matrix1.values[1, 0] * matrix2.values[0, 1] + matrix1.values[1, 1] * matrix2.values[1, 1] + matrix1.values[1, 2] * matrix2.values[2, 1] + matrix1.values[1, 3] * matrix2.values[3, 1];
matrixReturn.values[1, 2] = matrix1.values[1, 0] * matrix2.values[0, 2] + matrix1.values[1, 1] * matrix2.values[1, 2] + matrix1.values[1, 2] * matrix2.values[2, 2] + matrix1.values[1, 3] * matrix2.values[3, 2];
matrixReturn.values[1, 3] = matrix1.values[1, 0] * matrix2.values[0, 3] + matrix1.values[1, 1] * matrix2.values[1, 3] + matrix1.values[1, 2] * matrix2.values[2, 3] + matrix1.values[1, 3] * matrix2.values[3, 3];
matrixReturn.values[2, 0] = matrix1.values[2, 0] * matrix2.values[0, 0] + matrix1.values[2, 1] * matrix2.values[1, 0] + matrix1.values[2, 2] * matrix2.values[2, 0] + matrix1.values[2, 3] * matrix2.values[3, 0];
matrixReturn.values[2, 1] = matrix1.values[2, 0] * matrix2.values[0, 1] + matrix1.values[2, 1] * matrix2.values[1, 1] + matrix1.values[2, 2] * matrix2.values[2, 1] + matrix1.values[2, 3] * matrix2.values[3, 1];
matrixReturn.values[2, 2] = matrix1.values[2, 0] * matrix2.values[0, 2] + matrix1.values[2, 1] * matrix2.values[1, 2] + matrix1.values[2, 2] * matrix2.values[2, 2] + matrix1.values[2, 3] * matrix2.values[3, 2];
matrixReturn.values[2, 3] = matrix1.values[2, 0] * matrix2.values[0, 3] + matrix1.values[2, 1] * matrix2.values[1, 3] + matrix1.values[2, 2] * matrix2.values[2, 3] + matrix1.values[2, 3] * matrix2.values[3, 3];
matrixReturn.values[3, 0] = matrix1.values[1, 0] * matrix2.values[0, 0] + matrix1.values[3, 1] * matrix2.values[1, 0] + matrix1.values[3, 2] * matrix2.values[2, 0] + matrix1.values[3, 3] * matrix2.values[3, 0];
matrixReturn.values[3, 1] = matrix1.values[1, 0] * matrix2.values[0, 1] + matrix1.values[3, 1] * matrix2.values[1, 1] + matrix1.values[3, 2] * matrix2.values[2, 1] + matrix1.values[3, 3] * matrix2.values[3, 1];
matrixReturn.values[3, 2] = matrix1.values[1, 0] * matrix2.values[0, 2] + matrix1.values[3, 1] * matrix2.values[1, 2] + matrix1.values[3, 2] * matrix2.values[2, 2] + matrix1.values[3, 3] * matrix2.values[3, 2];
matrixReturn.values[3, 3] = matrix1.values[1, 0] * matrix2.values[0, 3] + matrix1.values[3, 1] * matrix2.values[1, 3] + matrix1.values[3, 2] * matrix2.values[2, 3] + matrix1.values[3, 3] * matrix2.values[3, 3];
return(matrixReturn);
}
// Update is called once per frame
void Update()
{
Vector3[] TransformedVertices = new Vector3[ModelSpaceVertices.Length];
Vector3 ParentForward = EulerMaths.ForwardDirection(Parent.Transform.RotationEuler) * Distance;
Matrix4by4 T = new Matrix4by4(new Vector3(1, 0, 0),
new Vector3(0, 1, 0),
new Vector3(0, 0, 1),
new Vector3(ParentForward.x, ParentForward.y, ParentForward.z));
Matrix4by4 S = new Matrix4by4(new Vector3(1, 0, 0) * scale,
new Vector3(0, 1, 0) * scale,
new Vector3(0, 0, 1) * scale, new Vector3(0, 0, 0));
M2 = Parent.Transform.ReturnFinishedMatrix() * T * S;
for (int i = 0; i < TransformedVertices.Length; i++)
{
TransformedVertices[i] = M2 * ModelSpaceVertices[i];
}
MeshFilter MF = GetComponent <MeshFilter>();
MF.mesh.vertices = TransformedVertices;
MF.mesh.RecalculateNormals();
MF.mesh.RecalculateBounds();
}
public static Matrix4by4 operator *(Matrix4by4 lhs, Matrix4by4 rhs)
{
Matrix4by4 rv = Identity;
//vector.w = 1.0f; //Forcing the W component to 1 for translation Matrix.
//As Unity is converting a Vector4 to a Vector3 implicitly, the W component is set to 0 by default.
//With a translation component, the W component must be 1.
rv.values[0, 0] = lhs.values[0, 0] * rhs.values[0, 0] + lhs.values[0, 1] * rhs.values[1, 0] + lhs.values[0, 2] * rhs.values[2, 0] + lhs.values[0, 3] * rhs.values[3, 0];
rv.values[1, 0] = lhs.values[1, 0] * rhs.values[0, 0] + lhs.values[1, 1] * rhs.values[1, 0] + lhs.values[1, 2] * rhs.values[2, 0] + lhs.values[1, 3] * rhs.values[3, 0];
rv.values[2, 0] = lhs.values[2, 0] * rhs.values[0, 0] + lhs.values[2, 1] * rhs.values[1, 0] + lhs.values[2, 2] * rhs.values[2, 0] + lhs.values[2, 3] * rhs.values[3, 0];
rv.values[3, 0] = lhs.values[3, 0] * rhs.values[0, 0] + lhs.values[3, 1] * rhs.values[1, 0] + lhs.values[3, 2] * rhs.values[2, 0] + lhs.values[3, 3] * rhs.values[3, 0];
rv.values[0, 1] = lhs.values[0, 0] * rhs.values[0, 1] + lhs.values[0, 1] * rhs.values[1, 1] + lhs.values[0, 2] * rhs.values[2, 1] + lhs.values[0, 3] * rhs.values[3, 1];
rv.values[1, 1] = lhs.values[1, 0] * rhs.values[0, 1] + lhs.values[1, 1] * rhs.values[1, 1] + lhs.values[1, 2] * rhs.values[2, 1] + lhs.values[1, 3] * rhs.values[3, 1];
rv.values[2, 1] = lhs.values[2, 0] * rhs.values[0, 1] + lhs.values[2, 1] * rhs.values[1, 1] + lhs.values[2, 2] * rhs.values[2, 1] + lhs.values[2, 3] * rhs.values[3, 1];
rv.values[3, 1] = lhs.values[3, 0] * rhs.values[0, 1] + lhs.values[3, 1] * rhs.values[1, 1] + lhs.values[3, 2] * rhs.values[2, 1] + lhs.values[3, 3] * rhs.values[3, 1];
rv.values[0, 2] = lhs.values[0, 0] * rhs.values[0, 2] + lhs.values[0, 1] * rhs.values[1, 2] + lhs.values[0, 2] * rhs.values[2, 2] + lhs.values[0, 3] * rhs.values[3, 2];
rv.values[1, 2] = lhs.values[1, 0] * rhs.values[0, 2] + lhs.values[1, 1] * rhs.values[1, 2] + lhs.values[1, 2] * rhs.values[2, 2] + lhs.values[1, 3] * rhs.values[3, 2];
rv.values[2, 2] = lhs.values[2, 0] * rhs.values[0, 2] + lhs.values[2, 1] * rhs.values[1, 2] + lhs.values[2, 2] * rhs.values[2, 2] + lhs.values[2, 3] * rhs.values[3, 2];
rv.values[3, 2] = lhs.values[3, 0] * rhs.values[0, 2] + lhs.values[3, 1] * rhs.values[1, 2] + lhs.values[3, 2] * rhs.values[2, 2] + lhs.values[3, 3] * rhs.values[3, 2];
rv.values[0, 3] = lhs.values[0, 0] * rhs.values[0, 3] + lhs.values[0, 1] * rhs.values[1, 3] + lhs.values[0, 2] * rhs.values[2, 3] + lhs.values[0, 3] * rhs.values[3, 3];
rv.values[1, 3] = lhs.values[1, 0] * rhs.values[0, 3] + lhs.values[1, 1] * rhs.values[1, 3] + lhs.values[1, 2] * rhs.values[2, 3] + lhs.values[1, 3] * rhs.values[3, 3];
rv.values[2, 3] = lhs.values[2, 0] * rhs.values[0, 3] + lhs.values[2, 1] * rhs.values[1, 3] + lhs.values[2, 2] * rhs.values[2, 3] + lhs.values[2, 3] * rhs.values[3, 3];
rv.values[3, 3] = lhs.values[3, 0] * rhs.values[0, 3] + lhs.values[3, 1] * rhs.values[1, 3] + lhs.values[3, 2] * rhs.values[2, 3] + lhs.values[3, 3] * rhs.values[3, 3];
return(rv);
}
public static Matrix4by4 operator *(Matrix4by4 vector1, Matrix4by4 vector2)
{
Matrix4by4 vecResult = new Matrix4by4();
vecResult.values[0, 0] = vector1.values[0, 0] * vector2.values[0, 0] + vector1.values[0, 1] * vector2.values[1, 0] + vector1.values[0, 2] * vector2.values[2, 0] + vector1.values[0, 3] * vector2.values[3, 0];
vecResult.values[0, 1] = vector1.values[0, 0] * vector2.values[0, 1] + vector1.values[0, 1] * vector2.values[1, 1] + vector1.values[0, 2] * vector2.values[2, 1] + vector1.values[0, 3] * vector2.values[3, 1];
vecResult.values[0, 2] = vector1.values[0, 0] * vector2.values[0, 2] + vector1.values[0, 1] * vector2.values[1, 2] + vector1.values[0, 2] * vector2.values[2, 2] + vector1.values[0, 3] * vector2.values[3, 2];
vecResult.values[0, 3] = vector1.values[0, 0] * vector2.values[0, 3] + vector1.values[0, 1] * vector2.values[1, 3] + vector1.values[0, 2] * vector2.values[2, 3] + vector1.values[0, 3] * vector2.values[3, 3];
vecResult.values[1, 0] = vector1.values[1, 0] * vector2.values[0, 0] + vector1.values[1, 1] * vector2.values[1, 0] + vector1.values[1, 2] * vector2.values[2, 0] + vector1.values[1, 3] * vector2.values[3, 0];
vecResult.values[1, 1] = vector1.values[1, 0] * vector2.values[0, 1] + vector1.values[1, 1] * vector2.values[1, 1] + vector1.values[1, 2] * vector2.values[2, 1] + vector1.values[1, 3] * vector2.values[3, 1];
vecResult.values[1, 2] = vector1.values[1, 0] * vector2.values[0, 2] + vector1.values[1, 1] * vector2.values[1, 2] + vector1.values[1, 2] * vector2.values[2, 2] + vector1.values[1, 3] * vector2.values[3, 2];
vecResult.values[1, 3] = vector1.values[1, 0] * vector2.values[0, 3] + vector1.values[1, 1] * vector2.values[1, 3] + vector1.values[1, 2] * vector2.values[2, 3] + vector1.values[1, 3] * vector2.values[3, 3];
vecResult.values[2, 0] = vector1.values[2, 0] * vector2.values[0, 0] + vector1.values[2, 1] * vector2.values[1, 0] + vector1.values[2, 2] * vector2.values[2, 0] + vector1.values[2, 3] * vector2.values[3, 0];
vecResult.values[2, 1] = vector1.values[2, 0] * vector2.values[0, 1] + vector1.values[2, 1] * vector2.values[1, 1] + vector1.values[2, 2] * vector2.values[2, 1] + vector1.values[2, 3] * vector2.values[3, 1];
vecResult.values[2, 2] = vector1.values[2, 0] * vector2.values[0, 2] + vector1.values[2, 1] * vector2.values[1, 2] + vector1.values[2, 2] * vector2.values[2, 2] + vector1.values[2, 3] * vector2.values[3, 2];
vecResult.values[2, 3] = vector1.values[2, 0] * vector2.values[0, 3] + vector1.values[2, 1] * vector2.values[1, 3] + vector1.values[2, 2] * vector2.values[2, 3] + vector1.values[2, 3] * vector2.values[3, 3];
vecResult.values[3, 0] = vector1.values[3, 0] * vector2.values[0, 0] + vector1.values[3, 1] * vector2.values[1, 0] + vector1.values[3, 2] * vector2.values[2, 0] + vector1.values[3, 3] * vector2.values[3, 0];
vecResult.values[3, 1] = vector1.values[3, 0] * vector2.values[0, 1] + vector1.values[3, 1] * vector2.values[1, 1] + vector1.values[3, 2] * vector2.values[2, 1] + vector1.values[3, 3] * vector2.values[3, 1];
vecResult.values[3, 2] = vector1.values[3, 0] * vector2.values[0, 2] + vector1.values[3, 1] * vector2.values[1, 2] + vector1.values[3, 2] * vector2.values[2, 2] + vector1.values[3, 3] * vector2.values[3, 2];
vecResult.values[3, 3] = vector1.values[3, 0] * vector2.values[0, 3] + vector1.values[3, 1] * vector2.values[1, 3] + vector1.values[3, 2] * vector2.values[2, 3] + vector1.values[3, 3] * vector2.values[3, 3];
return(vecResult);
}
public static Matrix4by4 operator *(Matrix4by4 matrix1,Matrix4by4 matrix2)
{
Matrix4by4 matrixReturn = new Matrix4by4(new Vector3(0, 0, 0), new Vector3(0, 0, 0), new Vector3(0, 0, 0), new Vector3(0, 0, 0));
matrixReturn.values[0, 0] = matrix1.values[0, 0] * matrix2.values[0, 0] + matrix1.values[0, 1] * matrix2.values[1, 0] + matrix1.values[0, 2] * matrix2.values[2, 0] + matrix1.values[0, 3] * matrix2.values[3, 0];
matrixReturn.values[0, 1] = matrix1.values[0, 0] * matrix2.values[0, 1] + matrix1.values[0, 1] * matrix2.values[1, 1] + matrix1.values[0, 2] * matrix2.values[2, 1] + matrix1.values[0, 3] * matrix2.values[3, 1];
matrixReturn.values[0, 2] = matrix1.values[0, 0] * matrix2.values[0, 2] + matrix1.values[0, 1] * matrix2.values[1, 2] + matrix1.values[0, 2] * matrix2.values[2, 2] + matrix1.values[0, 3] * matrix2.values[3, 2];
matrixReturn.values[0, 3] = matrix1.values[0, 0] * matrix2.values[0, 3] + matrix1.values[0, 1] * matrix2.values[1, 3] + matrix1.values[0, 2] * matrix2.values[2, 3] + matrix1.values[0, 3] * matrix2.values[3, 3];
matrixReturn.values[1, 0] = matrix1.values[1, 0] * matrix2.values[0, 0] + matrix1.values[1, 1] * matrix2.values[1, 0] + matrix1.values[1, 2] * matrix2.values[2, 0] + matrix1.values[1, 3] * matrix2.values[3, 0];
matrixReturn.values[1, 1] = matrix1.values[1, 0] * matrix2.values[0, 1] + matrix1.values[1, 1] * matrix2.values[1, 1] + matrix1.values[1, 2] * matrix2.values[2, 1] + matrix1.values[1, 3] * matrix2.values[3, 1];
matrixReturn.values[1, 2] = matrix1.values[1, 0] * matrix2.values[0, 2] + matrix1.values[1, 1] * matrix2.values[1, 2] + matrix1.values[1, 2] * matrix2.values[2, 2] + matrix1.values[1, 3] * matrix2.values[3, 2];
matrixReturn.values[1, 3] = matrix1.values[1, 0] * matrix2.values[0, 3] + matrix1.values[1, 1] * matrix2.values[1, 3] + matrix1.values[1, 2] * matrix2.values[2, 3] + matrix1.values[1, 3] * matrix2.values[3, 3];
matrixReturn.values[2, 0] = matrix1.values[2, 0] * matrix2.values[0, 0] + matrix1.values[2, 1] * matrix2.values[1, 0] + matrix1.values[2, 2] * matrix2.values[2, 0] + matrix1.values[2, 3] * matrix2.values[3, 0];
matrixReturn.values[2, 1] = matrix1.values[2, 0] * matrix2.values[0, 1] + matrix1.values[2, 1] * matrix2.values[1, 1] + matrix1.values[2, 2] * matrix2.values[2, 1] + matrix1.values[2, 3] * matrix2.values[3, 1];
matrixReturn.values[2, 2] = matrix1.values[2, 0] * matrix2.values[0, 2] + matrix1.values[2, 1] * matrix2.values[1, 2] + matrix1.values[2, 2] * matrix2.values[2, 2] + matrix1.values[2, 3] * matrix2.values[3, 2];
matrixReturn.values[2, 3] = matrix1.values[2, 0] * matrix2.values[0, 3] + matrix1.values[2, 1] * matrix2.values[1, 3] + matrix1.values[2, 2] * matrix2.values[2, 3] + matrix1.values[2, 3] * matrix2.values[3, 3];
matrixReturn.values[3, 0] = matrix1.values[1, 0] * matrix2.values[0, 0] + matrix1.values[3, 1] * matrix2.values[1, 0] + matrix1.values[3, 2] * matrix2.values[2, 0] + matrix1.values[3, 3] * matrix2.values[3, 0];
matrixReturn.values[3, 1] = matrix1.values[1, 0] * matrix2.values[0, 1] + matrix1.values[3, 1] * matrix2.values[1, 1] + matrix1.values[3, 2] * matrix2.values[2, 1] + matrix1.values[3, 3] * matrix2.values[3, 1];
matrixReturn.values[3, 2] = matrix1.values[1, 0] * matrix2.values[0, 2] + matrix1.values[3, 1] * matrix2.values[1, 2] + matrix1.values[3, 2] * matrix2.values[2, 2] + matrix1.values[3, 3] * matrix2.values[3, 2];
matrixReturn.values[3, 3] = matrix1.values[1, 0] * matrix2.values[0, 3] + matrix1.values[3, 1] * matrix2.values[1, 3] + matrix1.values[3, 2] * matrix2.values[2, 3] + matrix1.values[3, 3] * matrix2.values[3, 3];
return matrixReturn;
}
public Matrix4by4 GetRow(Vector4 row0, Vector4 row1, Vector4 row2, Vector4 row3)
{
Matrix4by4 rv = Identity;
row0.x = rv.values[0, 0];
row0.y = rv.values[1, 0];
row0.z = rv.values[2, 0];
row0.w = rv.values[3, 0];
row1.x = rv.values[0, 1];
row1.y = rv.values[1, 1];
row1.z = rv.values[2, 1];
row1.w = rv.values[3, 1];
row2.x = rv.values[0, 2];
row2.y = rv.values[1, 2];
row2.z = rv.values[2, 2];
row2.w = rv.values[3, 2];
row3.x = rv.values[0, 3];
row3.y = rv.values[1, 3];
row3.z = rv.values[2, 3];
row3.w = rv.values[3, 3];
return(rv);
}
public static Matrix4by4 operator *(Matrix4by4 lhs, Matrix4by4 rhs)
{
Matrix4by4 tempMatrix = new Matrix4by4(new Vector4(1, 0, 0, 0), new Vector4(0, 1, 0, 0), new Vector4(0, 0, 1, 0), new Vector4(0, 0, 0, 1));
tempMatrix.values[0, 0] = ((rhs.values[0, 0] * lhs.values[0, 0]) + (rhs.values[1, 0] * lhs.values[0, 1]) + (rhs.values[2, 0] * lhs.values[0, 2]) + (rhs.values[3, 0] * lhs.values[0, 3]));
tempMatrix.values[0, 1] = ((rhs.values[0, 1] * lhs.values[0, 0]) + (rhs.values[1, 1] * lhs.values[0, 1]) + (rhs.values[2, 1] * lhs.values[0, 2]) + (rhs.values[3, 1] * lhs.values[0, 3]));
tempMatrix.values[0, 2] = ((rhs.values[0, 2] * lhs.values[0, 0]) + (rhs.values[1, 2] * lhs.values[0, 1]) + (rhs.values[2, 2] * lhs.values[0, 2]) + (rhs.values[3, 2] * lhs.values[0, 3]));
tempMatrix.values[0, 3] = ((rhs.values[0, 3] * lhs.values[0, 0]) + (rhs.values[1, 3] * lhs.values[0, 1]) + (rhs.values[2, 3] * lhs.values[0, 2]) + (rhs.values[3, 3] * lhs.values[0, 3]));
tempMatrix.values[1, 0] = ((rhs.values[0, 0] * lhs.values[1, 0]) + (rhs.values[1, 0] * lhs.values[1, 1]) + (rhs.values[2, 0] * lhs.values[1, 2]) + (rhs.values[3, 0] * lhs.values[1, 3]));
tempMatrix.values[1, 1] = ((rhs.values[0, 1] * lhs.values[1, 0]) + (rhs.values[1, 1] * lhs.values[1, 1]) + (rhs.values[2, 1] * lhs.values[1, 2]) + (rhs.values[3, 1] * lhs.values[1, 3]));
tempMatrix.values[1, 2] = ((rhs.values[0, 2] * lhs.values[1, 0]) + (rhs.values[1, 2] * lhs.values[1, 1]) + (rhs.values[2, 2] * lhs.values[1, 2]) + (rhs.values[3, 2] * lhs.values[1, 3]));
tempMatrix.values[1, 3] = ((rhs.values[0, 3] * lhs.values[1, 0]) + (rhs.values[1, 3] * lhs.values[1, 1]) + (rhs.values[2, 3] * lhs.values[1, 2]) + (rhs.values[3, 3] * lhs.values[1, 3]));
tempMatrix.values[2, 0] = ((rhs.values[0, 0] * lhs.values[2, 0]) + (rhs.values[1, 0] * lhs.values[2, 1]) + (rhs.values[2, 0] * lhs.values[2, 2]) + (rhs.values[3, 0] * lhs.values[2, 3]));
tempMatrix.values[2, 1] = ((rhs.values[0, 1] * lhs.values[2, 0]) + (rhs.values[1, 1] * lhs.values[2, 1]) + (rhs.values[2, 1] * lhs.values[2, 2]) + (rhs.values[3, 1] * lhs.values[2, 3]));
tempMatrix.values[2, 2] = ((rhs.values[0, 2] * lhs.values[2, 0]) + (rhs.values[1, 2] * lhs.values[2, 1]) + (rhs.values[2, 2] * lhs.values[2, 2]) + (rhs.values[3, 2] * lhs.values[2, 3]));
tempMatrix.values[2, 3] = ((rhs.values[0, 3] * lhs.values[2, 0]) + (rhs.values[1, 3] * lhs.values[2, 1]) + (rhs.values[2, 3] * lhs.values[2, 2]) + (rhs.values[3, 3] * lhs.values[2, 3]));
tempMatrix.values[3, 0] = ((rhs.values[0, 0] * lhs.values[3, 0]) + (rhs.values[1, 0] * lhs.values[3, 1]) + (rhs.values[2, 0] * lhs.values[3, 2]) + (rhs.values[3, 0] * lhs.values[3, 3]));
tempMatrix.values[3, 1] = ((rhs.values[0, 1] * lhs.values[3, 0]) + (rhs.values[1, 1] * lhs.values[3, 1]) + (rhs.values[2, 1] * lhs.values[3, 2]) + (rhs.values[3, 1] * lhs.values[3, 3]));
tempMatrix.values[3, 2] = ((rhs.values[0, 2] * lhs.values[3, 0]) + (rhs.values[1, 2] * lhs.values[3, 1]) + (rhs.values[2, 2] * lhs.values[3, 2]) + (rhs.values[3, 2] * lhs.values[3, 3]));
tempMatrix.values[3, 3] = ((rhs.values[0, 3] * lhs.values[3, 0]) + (rhs.values[1, 3] * lhs.values[3, 1]) + (rhs.values[2, 3] * lhs.values[3, 2]) + (rhs.values[3, 3] * lhs.values[3, 3]));
return(tempMatrix);
}
public Matrix4by4 ScaleInverse()
{
Matrix4by4 rv = Identity;
rv.values[0, 0] = 1.0f / values[0, 0]; //Invert the scale in 1/A
rv.values[1, 1] = 1.0f / values[1, 1]; //1/B
rv.values[2, 2] = 1.0f/ values[2, 2]; //1/C
return rv;
}
public Matrix4by4 InverseTrans(Matrix4by4 m)
{
Matrix4by4 mn = Matrix4by4.Identity;
mn.values = m.values;
mn.values[0, 3] = -m.values[0, 3];
mn.values[1, 3] = -m.values[1, 3];
mn.values[2, 3] = -m.values[2, 3];
return mn;
}
//function to return a scale matrix;
Matrix4by4 scale(float sca)
{
Matrix4by4 sMat = Identity();
sMat.values[0, 0] *= sca;
sMat.values[1, 1] *= sca;
sMat.values[2, 2] *= sca;
return(sMat);
}
// Use this for initialization
void Start()
{
MeshFilter MF = GetComponent <MeshFilter>();
ModelSpaceVertices = MF.mesh.vertices;
Matrix4by4 M2 = new Matrix4by4(new Vector3(1, 0, 0),
new Vector3(0, 1, 0),
new Vector3(0, 0, 1), new Vector3(0, 0, 0));
}
//function to return a translation matrix;
Matrix4by4 translate(Vector3 trans)
{
Matrix4by4 tMat = Identity();
tMat.values[0, 3] = trans.x;
tMat.values[1, 3] = trans.y;
tMat.values[2, 3] = trans.z;
return(tMat);
}
public Matrix4by4 TranslationInverse()
{
Matrix4by4 rv = Identity;
rv.values[0, 3] = -values[0, 3];
rv.values[1, 3] = -values[1, 3];
rv.values[2, 3] = -values[2, 3];
return(rv);
}
//function to return a pitch rotation matrix;
Matrix4by4 pitchRot(float ang)
{
Matrix4by4 mat =
new Matrix4by4(new Vector3(1, 0, 0),
new Vector3(0, Mathf.Cos(y), Mathf.Sin(y)),
new Vector3(0, -Mathf.Sin(y), Mathf.Cos(y)),
Vector3.zero);
return(mat);
}
public Matrix4by4 ScaleInverse()
{
Matrix4by4 rv = Identity;
rv.values[0, 0] = 1.0f / values[0, 0];
rv.values[1, 1] = 1.0f / values[1, 1];
rv.values[2, 2] = 1.0f / values[2, 2];
return(rv);
}
//function to return a yaw rotation matrix;
Matrix4by4 yawRot(float ang)
{
Matrix4by4 mat =
new Matrix4by4(new Vector3(Mathf.Cos(g), 0, -Mathf.Sin(g)),
new Vector3(0, 1, 0),
new Vector3(Mathf.Sin(g), 0, Mathf.Cos(g)),
Vector3.zero);
return(mat);
}
public Matrix4by4 InverseTrans(Matrix4by4 m)
{
Matrix4by4 rv = Matrix4by4.Identity; //=// new Matrix4by4(Vector4.zero, Vector4.zero, Vector4.zero, Vector4.zero);
rv.values = m.values;
rv.values[0, 3] = -m.values[0, 3];
rv.values[1, 3] = -m.values[1, 3];
rv.values[2, 3] = -m.values[2, 3];
return(rv);
}
// Use this for initialization
void Start()
{
MeshFilter MF = GetComponent <MeshFilter>();
ModelSpaceVertices = MF.mesh.vertices; //Collect the model vertices
yaw = new Matrix4by4(new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1), new Vector3(0, 0, 0)); //Setup Identity Matrices
roll = new Matrix4by4(new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1), new Vector3(0, 0, 0));
pitch = new Matrix4by4(new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1), new Vector3(0, 0, 0));
M = new Matrix4by4(new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1), new Vector3(0, 0, 0));
}
//function for applying the transformations to the object model
public void transformModel()
{
applyMouseInputs();
Vector3[] TransformedVertices = new Vector3[ModelSpaceVertices.Length];
//set quaternions to rotate by
Quat q1 = new Quat(pitchAng - lastpitchAng, new Vector3(1, 0, 0));
Quat q2 = new Quat(yawAng - lastyawAng, new Vector3(0, 1, 0));
Quat q3 = new Quat(rollAng - lastrollAng, new Vector3(0, 0, 1));
//rotate orientation quaternion by pitch yaw and roll quaternion representations;
q = ((q * q2) * q1) * q3;
for (int i = 0; i < TransformedVertices.Length; i++)
{
//rotate each vertex by the orientation from model space;
Quat K = new Quat(ModelSpaceVertices[i]);
Quat newK = q * K * q.Inverse();
Vector3 newP = newK.GetAxis();
Vector3 quatVert = newP;
//scale each vertex by the scale multiplier;
Matrix4by4 sMatrix = scale(scaleMul);
Vector3 scaVert = sMatrix * quatVert;
//translate the object so it will be a set distance ahead of the player;
Matrix4by4 tMat = translate(new Vector3(0, 0, distanceAhead));
Vector4 ratVert = new Vector4(scaVert.x, scaVert.y, scaVert.z, 1);
Vector4 scatVert = tMat * ratVert;
//rotate the object around the origin(camera), so it is always in front of the camera;
Matrix4by4 yawMatrix = yawRot(g);
Matrix4by4 pitchMatrix = pitchRot(y);
Matrix4by4 pyMatrix = yawMatrix * pitchMatrix;
Vector3 scarotVert = pyMatrix * scatVert;
//translate the object so it is correctly positioned in the world;
Matrix4by4 tMatrix = translate(new Vector3(pos.x, 0, pos.z));
Vector4 tVert = new Vector4(scarotVert.x, scarotVert.y, scarotVert.z, 1);
Vector4 finalVert = tMatrix * tVert;
TransformedVertices[i] = finalVert;
}
//set mesh to the transformed vertices
MeshFilter MF = GetComponent <MeshFilter>();
MF.mesh.vertices = TransformedVertices;
MF.mesh.RecalculateBounds();
MF.mesh.RecalculateNormals();
//sets angles so it doesn't accumulate and increase speed over time;
lastpitchAng = pitchAng;
lastyawAng = yawAng;
lastrollAng = rollAng;
}
void Start()
{
camMat = Identity();
q = new Quat(1, new Vector3(0, 0, 0));
Cursor.visible = false;
Cursor.lockState = CursorLockMode.Locked;
if (!isFake)
{
MeshFilter MF = GetComponent <MeshFilter>();
ModelSpaceVertices = MF.mesh.vertices;
}
placed = false;
}
void Update()
{
MF = GetComponent <MeshFilter>();
ModelSpaceVertices = MF.mesh.vertices;
Vector3[] TransformedVertices = new Vector3[ModelSpaceVertices.Length];
Matrix4by4 rollMatrix = new Matrix4by4(
new Vector3(Mathf.Cos(angle.z), Mathf.Sin(angle.z), 0),
new Vector3(-Mathf.Sin(angle.z), Mathf.Cos(angle.z), 0),
new Vector3(0, 0, 1),
Vector3.zero);
Matrix4by4 pitchMatrix = new Matrix4by4(
new Vector3(1, 0, 0),
new Vector3(0, Mathf.Cos(angle.x), Mathf.Sin(angle.x)),
new Vector3(0, -Mathf.Sin(angle.x), Mathf.Cos(angle.x)),
Vector3.zero);
Matrix4by4 yawMatrix = new Matrix4by4(
new Vector3(Mathf.Cos(angle.y), 0, -Mathf.Sin(angle.y)),
new Vector3(0, 1, 0),
new Vector3(Mathf.Sin(angle.y), 0, Mathf.Cos(angle.y)),
Vector3.zero);
Matrix4by4 S = new Matrix4by4(new Vector3(1, 0, 0) * scale.x, new Vector3(0, 1, 0) * scale.y, new Vector3(0, 0, 1) * scale.z, Vector3.zero);
Matrix4by4 R = yawMatrix * (pitchMatrix * rollMatrix);
Matrix4by4 T = new Matrix4by4(
new Vector3(1, 0, 0),
new Vector3(0, 1, 0),
new Vector3(0, 0, 1),
new Vector3(position.x, position.y, position.y));
Matrix4by4 M = T * (R * S);
for (int i = 0; i < TransformedVertices.Length; i++)
{
TransformedVertices[i] = M * ModelSpaceVertices[i];
}
MF = GetComponent <MeshFilter>();
MF.mesh.vertices = TransformedVertices;
MF.mesh.RecalculateNormals();
}
//function to rotate the camera based on user input;
public void setCam()
{
if (!Input.GetMouseButton(0) && !Input.GetMouseButton(1))
{
g += Input.GetAxis("Mouse X") / 100 * lookSpeed;
if (g > Mathf.PI * 2)
{
g = 0 + (g - Mathf.PI * 2);
}
if (g < 0)
{
g = (2 * Mathf.PI) - g;
}
float t = y;
y -= Input.GetAxis("Mouse Y") / 100 * lookSpeed;
if (y > Mathf.PI * 2)
{
y = 0 + (y - Mathf.PI * 2);
}
if (y < 0)
{
y = (2 * Mathf.PI) - y;
}
if (y >= 1.3f && y <= 5.5f)
{
y = t;
}
Quat yawQ = new Quat(g, new Vector3(0, 1, 0));
Quat pitchQ = new Quat(y, new Vector3(1, 0, 0));
Quat pyQ = yawQ * pitchQ;
camMat = Identity();
//converts quaternion to matrix to get new basis vectors for forward and right directions(for movement)
Matrix4by4 mat1 = new Matrix4by4(new Vector4(pyQ.w, -pyQ.z, pyQ.y, -pyQ.x),
new Vector4(pyQ.z, pyQ.w, -pyQ.x, -pyQ.y),
new Vector4(-pyQ.y, pyQ.x, pyQ.w, pyQ.z),
new Vector4(-pyQ.x, -pyQ.y, -pyQ.z, pyQ.w));
Matrix4by4 mat2 = new Matrix4by4(new Vector4(pyQ.w, -pyQ.z, pyQ.y, pyQ.x),
new Vector4(pyQ.z, pyQ.w, -pyQ.x, pyQ.y),
new Vector4(-pyQ.y, pyQ.x, pyQ.w, -pyQ.z),
new Vector4(pyQ.x, pyQ.y, pyQ.z, pyQ.w));
camMat = (camMat * mat1) * mat2;
cam.transform.rotation = new Quaternion(pyQ.x, pyQ.y, pyQ.z, pyQ.w);
}
}
void Start()
{
//stores information about current mesh
MeshFilter MF = GetComponent <MeshFilter>();
//gets a copy of all vertices
ModelSpaceVertices = MF.mesh.vertices;
Vector3[] TransformedVertices = new Vector3[ModelSpaceVertices.Length];
Matrix4by4 S = new Matrix4by4(new Vector3(1, 0, 0) * Scale, new Vector3(0, 1, 0) * Scale, new Vector3(0, 0, 1) * Scale, Vector3.zero);
for (int i = 0; i < TransformedVertices.Length; i++)
{
TransformedVertices[i] = S * ModelSpaceVertices[i];
}
MF.mesh.vertices = TransformedVertices;
MF.mesh.RecalculateNormals();
MF.mesh.RecalculateBounds();
}
// Update is called once per frame
void Update()
{
if (DoNotTransform == false) //The Sun requires this for its functions, but actually rotates with quaternions, this is a simple check
{
Vector3[] TransformedVertices = new Vector3[ModelSpaceVertices.Length]; //Get Model Vertices
roll = new Matrix4by4
(new Vector3(Mathf.Cos(RotationEuler.x), Mathf.Sin(RotationEuler.x), 0), //Plug in the rotation values set in the editor
new Vector3(-Mathf.Sin(RotationEuler.x), Mathf.Cos(RotationEuler.x), 0),
new Vector3(0, 0, 1),
Vector3.zero);
pitch = new Matrix4by4(
new Vector3(1, 0, 0),
new Vector3(0, Mathf.Cos(RotationEuler.z), Mathf.Sin(RotationEuler.z)),
new Vector3(0, -Mathf.Sin(RotationEuler.z), Mathf.Cos(RotationEuler.z)),
Vector3.zero);
yaw = new Matrix4by4(
new Vector3(Mathf.Cos(RotationEuler.y), 0, -Mathf.Sin(RotationEuler.y)),
new Vector3(0, 1, 0),
new Vector3(Mathf.Sin(RotationEuler.y), 0, Mathf.Cos(RotationEuler.y)),
Vector3.zero);
Matrix4by4 R = yaw * (pitch * roll); //Create one rotation matrix
Matrix4by4 S = new Matrix4by4(new Vector3(1, 0, 0) * Scale.x, new Vector3(0, 1, 0) * Scale.y, new Vector3(0, 0, 1) * Scale.z, Vector3.zero); //Create a scale matrix with the editor scale
Matrix4by4 T = new Matrix4by4(new Vector3(1, 0, 0), new Vector3(0, 1, 0), //Create a translation Matrix with the custom translation values
new Vector3(0, 0, 1),
new Vector3(Position.x, Position.y, Position.z));
M = T * R * S; //Multiply the matrixes in TRS order (No brackets are needed as it multiplys with TRS correctly like this)
for (int i = 0; i < TransformedVertices.Length; i++) //Run through the list and multiply vertices by M
{
TransformedVertices[i] = M * ModelSpaceVertices[i];
}
MeshFilter MF = GetComponent <MeshFilter>();
MF.mesh.vertices = TransformedVertices; //Send these vertices for rendering in Unity
MF.mesh.RecalculateNormals();
MF.mesh.RecalculateBounds();
}
}
//function for applying transformation to the demo object, rotating around to always face the player to make it easier to work out the correct orientation. functions the same as transformModel();
public void transformDemo()
{
Vector3[] TransformedVertices = new Vector3[ModelSpaceVertices.Length];
Quat q1 = new Quat(pitchAng - lastpitchAng, new Vector3(1, 0, 0));
Quat q2 = new Quat(yawAng - lastyawAng, new Vector3(0, 1, 0));
Quat q3 = new Quat(rollAng - lastrollAng, new Vector3(0, 0, 1));
q = ((q * q2) * q1) * q3;
for (int i = 0; i < TransformedVertices.Length; i++)
{
Quat K = new Quat(ModelSpaceVertices[i]);
Quat newK = q * K * q.Inverse();
Vector3 newP = newK.GetAxis();
Vector3 quatVert = newP;
Matrix4by4 sMatrix = scale(scaleMul);
Vector3 scaVert = sMatrix * quatVert;
Matrix4by4 yawMatrix = new Matrix4by4(new Vector3(Mathf.Cos(g), 0, -Mathf.Sin(g)),
new Vector3(0, 1, 0),
new Vector3(Mathf.Sin(g), 0, Mathf.Cos(g)),
Vector3.zero);
Vector3 scarotVert = yawMatrix * scaVert;
Matrix4by4 tMatrix = translate(new Vector3(pos.x, 0, pos.z));
Vector4 tVert = new Vector4(scarotVert.x, scarotVert.y, scarotVert.z, 1);
Vector4 finalVert = tMatrix * tVert;
TransformedVertices[i] = finalVert;
}
MeshFilter MF = GetComponent <MeshFilter>();
MF.mesh.vertices = TransformedVertices;
MF.mesh.RecalculateBounds();
MF.mesh.RecalculateNormals();
lastpitchAng = pitchAng;
lastyawAng = yawAng;
lastrollAng = rollAng;
}
void OrbitPlanet()
{
ye += Time.deltaTime * 3;
Vector3[] orbitVertices = new Vector3[ModelSpaceVertices.Length];
//create translation matrix
Matrix4by4 translationMatrix = new Matrix4by4(
new Vector3(1, 0, 0),
new Vector3(0, 1, 0),
new Vector3(0, 0, 1),
new Vector3(ye * 2, 0, ye));
//transform each individual vertex
for (int i = 0; i < orbitVertices.Length; i++)
{
orbitVertices[i] = translationMatrix * ModelSpaceVertices[i];
}
MeshFilter MF = GetComponent <MeshFilter>();
MF.mesh.vertices = orbitVertices;
MF.mesh.RecalculateNormals();
MF.mesh.RecalculateBounds();
}
//Code for Axis Rotation
void rotate()
{
Vector3[] TransformedVertices = new Vector3[ModelSpaceVertices.Length];
yawAngle += Time.deltaTime * speed;
Matrix4by4 rollMatrix = new Matrix4by4(
new Vector3(Mathf.Cos(0.0f), Mathf.Sin(0.0f), 0),
new Vector3(-Mathf.Sin(0.0f), Mathf.Cos(0.0f), 0),
new Vector3(0, 0, 1),
Vector3.zero);
Matrix4by4 pitchMatrix = new Matrix4by4(
new Vector3(1, 0, 0),
new Vector3(0, Mathf.Cos(yawAngle), Mathf.Sin(yawAngle)),
new Vector3(0, -Mathf.Sin(yawAngle), Mathf.Cos(yawAngle)),
Vector3.zero);
Matrix4by4 yawMatrix = new Matrix4by4(
new Vector3(Mathf.Cos(0.0f), 0, -Mathf.Sin(0.0f)),
new Vector3(0, 1, 0),
new Vector3(Mathf.Sin(0.0f), 0, Mathf.Cos(0.0f)),
Vector3.zero);
Matrix4by4 R = yawMatrix * (pitchMatrix * rollMatrix);
for (int i = 0; i < TransformedVertices.Length; i++)
{
TransformedVertices[i] = R * ModelSpaceVertices[i];
}
MeshFilter MF = GetComponent <MeshFilter>();
MF.mesh.vertices = TransformedVertices;
MF.mesh.RecalculateNormals();
MF.mesh.RecalculateBounds();
}
// Update is called once per frame
void Update()
{
OrbitRotationY += Time.deltaTime * speed;
Vector3[] TransformedVertices = new Vector3[ModelSpaceVertices.Length];
yawangle += Time.deltaTime;
Matrix4by4 rollMatrix = new Matrix4by4
(new Vector3(Mathf.Cos(yawangle), Mathf.Sin(yawangle), 0),
new Vector3(-Mathf.Sin(yawangle), Mathf.Cos(yawangle), 0),
new Vector3(0, 0, 1),
Vector3.zero);
Matrix4by4 pitchmatrix = new Matrix4by4(
new Vector3(1, 0, 0),
new Vector3(0, Mathf.Cos(yawangle), Mathf.Sin(yawangle)),
new Vector3(0, -Mathf.Sin(yawangle), Mathf.Cos(yawangle)),
Vector3.zero);
Matrix4by4 yawmatrix = new Matrix4by4(
new Vector3(Mathf.Cos(yawangle), 0, -Mathf.Sin(yawangle)),
new Vector3(0, 1, 0),
new Vector3(Mathf.Sin(yawangle), 0, Mathf.Cos(yawangle)),
Vector3.zero);
Matrix4by4 OrbitRoll = new Matrix4by4
(new Vector3(Mathf.Cos(OrbitRotationZ), Mathf.Sin(OrbitRotationZ), 0),
new Vector3(-Mathf.Sin(OrbitRotationZ), Mathf.Cos(OrbitRotationZ), 0),
new Vector3(0, 0, 1),
Vector3.zero);
Matrix4by4 OrbitPitch = new Matrix4by4(
new Vector3(1, 0, 0),
new Vector3(0, Mathf.Cos(OrbitRotationX), Mathf.Sin(OrbitRotationX)),
new Vector3(0, -Mathf.Sin(OrbitRotationX), Mathf.Cos(OrbitRotationX)),
Vector3.zero);
Matrix4by4 OrbitYaw = new Matrix4by4(
new Vector3(Mathf.Cos(OrbitRotationY), 0, -Mathf.Sin(OrbitRotationY)),
new Vector3(0, 1, 0),
new Vector3(Mathf.Sin(OrbitRotationY), 0, Mathf.Cos(OrbitRotationY)),
Vector3.zero);
Matrix4by4 RotationOfOrbit = OrbitYaw * (OrbitPitch * OrbitRoll);
Matrix4by4 R = yawmatrix * (pitchmatrix * rollMatrix);
Vector3 offset = RotationOfOrbit * orbitdistance;
actualposition = Transforms.Position + offset;
Matrix4by4 T = new Matrix4by4(new Vector3(1, 0, 0),
new Vector3(0, 1, 0)
, new Vector3(0, 0, 1),
new Vector3(Transforms.Position.x + offset.x, Transforms.Position.y + offset.y, Transforms.Position.z + offset.z));
Matrix4by4 S = new Matrix4by4(new Vector3(1, 0, 0) * scale, new Vector3(0, 1, 0) * scale, new Vector3(0, 0, 1) * scale, Vector3.zero);
Matrix4by4 M = T * (R * S);
//Transforms.Position = actualposition;
for (int i = 0; i < TransformedVertices.Length; i++)
{
TransformedVertices[i] = M * ModelSpaceVertices[i];
}
MeshFilter MF = GetComponent <MeshFilter>();
MF.mesh.vertices = TransformedVertices;
MF.mesh.RecalculateNormals();
MF.mesh.RecalculateBounds();
}
//moons orbit around a planet, and as such need to find the position of the planet they orbit before calculating their orbit path
void OrbitAround()
{
GameObject controller = GameObject.Find("SpeedController");
SpeedControl spController = controller.GetComponent <SpeedControl>();
SpeedScalar = spController.Speed;
worldPos = Planet.transform.position;
OrbitRotation.y += Time.deltaTime * orbitSpeed * SpeedScalar;
Vector3[] TransformedVertices = new Vector3[ModelSpaceVertices.Length];
yawAngle += Time.deltaTime;
//create the first rotation matrix for individual planet rotation
Matrix4by4 rollMatrix = new Matrix4by4
(new Vector3(Mathf.Cos(yawAngle), Mathf.Sin(yawAngle), 0),
new Vector3(-Mathf.Sin(yawAngle), Mathf.Cos(yawAngle), 0),
new Vector3(0, 0, 1),
Vector3.zero);
Matrix4by4 pitchmatrix = new Matrix4by4(
new Vector3(1, 0, 0),
new Vector3(0, Mathf.Cos(yawAngle), Mathf.Sin(yawAngle)),
new Vector3(0, -Mathf.Sin(yawAngle), Mathf.Cos(yawAngle)),
Vector3.zero);
Matrix4by4 yawmatrix = new Matrix4by4(
new Vector3(Mathf.Cos(yawAngle), 0, -Mathf.Sin(yawAngle)),
new Vector3(0, 1, 0),
new Vector3(Mathf.Sin(yawAngle), 0, Mathf.Cos(yawAngle)),
Vector3.zero);
//create second rotation matrix for the planet's orbit
Matrix4by4 OrbitRoll = new Matrix4by4
(new Vector3(Mathf.Cos(OrbitRotation.z), Mathf.Sin(OrbitRotation.z), 0),
new Vector3(-Mathf.Sin(OrbitRotation.z), Mathf.Cos(OrbitRotation.z), 0),
new Vector3(0, 0, 1),
Vector3.zero);
Matrix4by4 OrbitPitch = new Matrix4by4(
new Vector3(1, 0, 0),
new Vector3(0, Mathf.Cos(OrbitRotation.x), Mathf.Sin(OrbitRotation.x)),
new Vector3(0, -Mathf.Sin(OrbitRotation.x), Mathf.Cos(OrbitRotation.x)),
Vector3.zero);
Matrix4by4 OrbitYaw = new Matrix4by4(
new Vector3(Mathf.Cos(OrbitRotation.y), 0, -Mathf.Sin(OrbitRotation.y)),
new Vector3(0, 1, 0),
new Vector3(Mathf.Sin(OrbitRotation.y), 0, Mathf.Cos(OrbitRotation.y)),
Vector3.zero);
Matrix4by4 RotationOfOrbit = OrbitYaw * (OrbitPitch * OrbitRoll);
Matrix4by4 R = yawmatrix * (pitchmatrix * rollMatrix);
offset = RotationOfOrbit * orbitDistance;
newPos = worldPos + offset;
Matrix4by4 T = new Matrix4by4(new Vector3(1, 0, 0),
new Vector3(0, 1, 0)
, new Vector3(0, 0, 1),
new Vector3(newPos.x + offset.x, newPos.y + offset.y, newPos.z + offset.z));
Matrix4by4 S = new Matrix4by4(new Vector3(1, 0, 0) * Scale, new Vector3(0, 1, 0) * Scale, new Vector3(0, 0, 1) * Scale, Vector3.zero);
Matrix4by4 M = T * R * S;
for (int i = 0; i < TransformedVertices.Length; i++)
{
TransformedVertices[i] = M * ModelSpaceVertices[i];
}
MeshFilter MF = GetComponent <MeshFilter>();
MF.mesh.vertices = TransformedVertices;
MF.mesh.RecalculateNormals();
MF.mesh.RecalculateBounds();
}
//function to return an identity matrix;
Matrix4by4 Identity()
{
Matrix4by4 identity = new Matrix4by4(new Vector4(1, 0, 0, 0), new Vector4(0, 1, 0, 0), new Vector4(0, 0, 1, 0), new Vector4(0, 0, 0, 1));
return(identity);
}
