public void CreationFromList()
{
var x = 2.0;
var y = 3.0;
var z = 5.0;
var w = 7.0;
var v2 = new Vect2(new[] { x, y });
Assert.AreEqual(x, v2.X, Delta);
Assert.AreEqual(y, v2.Y, Delta);
var v3 = new Vect3(new[] { x, y, z });
Assert.AreEqual(x, v3.X, Delta);
Assert.AreEqual(y, v3.Y, Delta);
Assert.AreEqual(z, v3.Z, Delta);
var v4 = new Vect4(new[] { x, y, z, w });
Assert.AreEqual(x, v4.X, Delta);
Assert.AreEqual(y, v4.Y, Delta);
Assert.AreEqual(z, v4.Z, Delta);
Assert.AreEqual(w, v4.W, Delta);
}
public static void UVect4ToVect4(this Vector4 self, ref Vect4 vect)
{
vect.x = self.x;
vect.y = self.y;
vect.z = self.z;
vect.w = self.w;
}
public float DotProduct(Vect4 v1, Vect4 v2)
{
float result = 0;
result = v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
return(result);
}
public void Scale()
{
Vect4 scalingVector = UiControl.GetScalingVector();
Mat4 scalingMatrix = new Mat4(MatType.scale, scalingVector);
modelVisual.ApplyTransformation(scalingMatrix, true);
}
public Vect4 Normalize()
{
float mag = Magnitude();
Vect4 result = new Vect4(this.x / mag, this.y / mag, this.z / mag);
return(result);
}
public void CreationFromDoubles()
{
var x = 2.0;
var y = 3.0;
var z = 5.0;
var w = 7.0;
var v2 = new Vect2(x, y);
Assert.AreEqual(x, v2.X, Delta);
Assert.AreEqual(y, v2.Y, Delta);
var v3 = new Vect3(x, y, z);
Assert.AreEqual(x, v3.X, Delta);
Assert.AreEqual(y, v3.Y, Delta);
Assert.AreEqual(z, v3.Z, Delta);
var v4 = new Vect4(x, y, z, w);
Assert.AreEqual(x, v4.X, Delta);
Assert.AreEqual(y, v4.Y, Delta);
Assert.AreEqual(z, v4.Z, Delta);
Assert.AreEqual(w, v4.W, Delta);
}
public Mat4(MatType type, Vect4 change)
{
InitializeArray();
switch (type)
{
case MatType.scale:
{
members[0, 0] = change.x;
members[1, 1] = change.y;
members[2, 2] = change.z;
members[3, 3] = 1;
break;
}
case MatType.translation:
{
members[3, 0] = change.x;
members[3, 1] = change.y;
members[3, 2] = change.z;
members[0, 0] = 1;
members[1, 1] = 1;
members[2, 2] = 1;
members[3, 3] = 1;
break;
}
}
}
public static void QuaternionToVect4(this Quaternion self, ref Vect4 vect)
{
vect.x = self.x;
vect.y = self.y;
vect.z = self.z;
vect.w = self.w;
}
public void ApplyTransformation(Mat4 transformationMatrix, bool shouldAnimate)
{
//First we move object to global center 0,0,0
TranslateToGlobalCenter();
//Then we Perform transformation
foreach (Triangle face in drawedTriangles)
{
Vect4[] points = face.GetCurrentVertices();
for (int i = 0; i < 3; i++)
{
//apply transformation to current point
Vect4 CurrentPoint = transformationMatrix.Multiply(points[i]);
//update the current point
face.UpdateVertex(i, CurrentPoint);
}
}
//Now we move object back to local point
TranslateToLocalCenter();
//Draw it <- includes calculating light and backface culling
foreach (Triangle face in drawedTriangles)
{
if (shouldAnimate)
{
//TODO ANIMATE
face.RedrawTriangle();
}
else
{
face.RedrawTriangle();
}
//simply display object or animate the transformation
}
}
public void LengthResult()
{
var v4 = new Vect4(2.0, 3.0, 5.0, 7.0);
Assert.AreEqual(87, v4.LengthSquared, Constants.Delta);
Assert.AreEqual(9.32737905308, v4.Length, Constants.Delta);
}
public Vect4 CrossProduct(Vect4 v1, Vect4 v2)
{
float x = v1.y * v2.z - v2.y * v1.z;
float y = (v1.x * v2.z - v2.x * v1.z) * -1;
float z = v1.x * v2.y - v2.x * v1.y;
return(new Vect4(x, y, z));
}
public void Translate()
{
Vect4 translationVector = UiControl.GetTranslationVector();
Mat4 translationMatrix = new Mat4(MatType.translation, translationVector);
modelVisual.ApplyTransformation(translationMatrix, true);
modelVisual.ChangeLocalCenter(translationVector);
}
public void BackFaceCulling(Vect4 normal, Vect4 view)
{
if (normal.DotProduct(normal, view) >= 0)
{
//Dont draw triangle
mr.enabled = false;
}
}
public Vect4 Substraction(Vect4 toSubVect)
{
Vect4 result = new Vect4(this.x, this.y, this.z);
result.x -= toSubVect.x;
result.y -= toSubVect.y;
result.z -= toSubVect.z;
return(result);
}
public Vect4 Invert()
{
Vect4 result = new Vect4(this.x, this.y, this.z);
result.x *= -1;
result.y *= -1;
result.z *= -1;
return(result);
}
public Vect4 Addition(Vect4 toAddVect)
{
Vect4 result = new Vect4(this.x, this.y, this.z);
result.x += toAddVect.x;
result.y += toAddVect.y;
result.z += toAddVect.z;
return(result);
}
public static dynamic Swizzle(this Vect4 v)
{
var s = new Swizzle <double>();
s.Add('X', v.X);
s.Add('Y', v.Y);
s.Add('Z', v.Z);
s.Add('W', v.W);
return(s);
}
public void SwizzleVect3()
{
var v2 = new Vect2(2.0, 3.0);
var v3 = new Vect3(2.0, 3.0, 5.0);
var v4 = new Vect4(2.0, 3.0, 5.0, 7.0);
Assert.AreEqual(v2, v3.Swizzle.XY);
Assert.AreEqual(v2, v4.Swizzle.XY);
Assert.AreEqual(new Vect3(2.0, 2.0, 2.0), v3.Swizzle.XXX);
Assert.AreEqual(new Vect3(2.0, 2.0, 2.0), v4.Swizzle.XXX);
}
public void ResetModel()
{
ka = 0.2f;
kd = 0.4f;
ks = 0.3f;
h = 2;
materialColor = Color.grey;
light = new Vect4(0, 1, 0).Normalize();
lightType = "Blinn";
modelVisual.ResetLocalCenter();
modelVisual.DrawMesh(name, loadedVertices, loadedIndices);
}
public void CreationFromDoubles()
{
var x = 2.0;
var y = 3.0;
var z = 5.0;
var w = 7.0;
var v4 = new Vect4(x, y, z, w);
Assert.AreEqual(x, v4.X, Constants.Delta);
Assert.AreEqual(y, v4.Y, Constants.Delta);
Assert.AreEqual(z, v4.Z, Constants.Delta);
Assert.AreEqual(w, v4.W, Constants.Delta);
}
public void CalculateBlinnPhongLight(Vect4 light, Vect4 view, float ka, float kd, float ks, float h)
{
//Check if face is visible
if (mr.enabled == true)
{
float Ia = ka * 1;
float Id = kd * normal.DotProduct(normal, light);
Vect4 H = view.Addition(light);
H.Normalize();
float Is = ks * Mathf.Pow(H.DotProduct(H, normal), h);
float I = Ia + Id + Is;
mr.material.SetColor("_Color", IndexedFace.Instance.materialColor * I);
}
}
public void CreationFromListTooLong()
{
try
{
var v = new Vect4(new[] { 2.0, 3.0, 5.0, 7.0, 7.0 });
Assert.Fail(); // If it gets to this line, no exception was thrown
}
catch (ArgumentException)
{
}
catch (Exception)
{
Assert.Fail();
}
}
public void Rotate()
{
//We apply rotation one by one starting with X
Vect4 rotationVector = UiControl.GetRotationVector();
Mat4 rotxMatrix = new Mat4(MatType.rotx, rotationVector.x);
modelVisual.ApplyTransformation(rotxMatrix, true);
Mat4 rotyMatrix = new Mat4(MatType.roty, rotationVector.y);
modelVisual.ApplyTransformation(rotyMatrix, true);
Mat4 rotzMatrix = new Mat4(MatType.rotz, rotationVector.z);
modelVisual.ApplyTransformation(rotzMatrix, true);
}
public void LengthResult()
{
var v2 = new Vect2(2.0, 3.0);
Assert.AreEqual(13.0, v2.LengthSquared, Delta);
Assert.AreEqual(3.60555127546, v2.Length, Delta);
var v3 = new Vect3(2.0, 3.0, 5.0);
Assert.AreEqual(38, v3.LengthSquared, Delta);
Assert.AreEqual(6.16441400297, v3.Length, Delta);
var v4 = new Vect4(2.0, 3.0, 5.0, 7.0);
Assert.AreEqual(87, v4.LengthSquared, Delta);
Assert.AreEqual(9.32737905308, v4.Length, Delta);
}
public void SwizzleTypes()
{
var vd = new Vect4(5, 6, 7, 8);
var vf = new Vect4f(5, 6, 7, 8);
Assert.AreEqual(typeof(double), vd.Swizzle().X.GetType());
Assert.AreEqual(typeof(Vect2), vd.Swizzle().XX.GetType());
Assert.AreEqual(typeof(Vect3), vd.Swizzle().XXX.GetType());
Assert.AreEqual(typeof(Vect4), vd.Swizzle().XXXX.GetType());
Assert.AreEqual(typeof(Vect), vd.Swizzle().XXXXX.GetType());
Assert.AreEqual(typeof(float), vf.Swizzle().X.GetType());
Assert.AreEqual(typeof(Vect2f), vf.Swizzle().XX.GetType());
Assert.AreEqual(typeof(Vect3f), vf.Swizzle().XXX.GetType());
Assert.AreEqual(typeof(Vect4f), vf.Swizzle().XXXX.GetType());
Assert.AreEqual(typeof(Vectf), vf.Swizzle().XXXXX.GetType());
}
public void DrawMesh(string name, List <Vect4> vertices, List <int> indices)
{
if (activeModel != null)
{
Destroy(activeModel);
drawedTriangles = new List <Triangle>();
}
activeModel = new GameObject(name);
for (int i = 0; i < indices.Count; i += 3)
{
Vect4 p1 = vertices[indices[i] - 1];
Vect4 p2 = vertices[indices[i + 1] - 1];
Vect4 p3 = vertices[indices[i + 2] - 1];
drawedTriangles.Add(Instantiate(trianglePrefab, activeModel.transform).GetComponent <Triangle>().CreateTriangle(p1, p2, p3));
}
//We apply this transformation just to get the object to view
ApplyTransformation(new Mat4(MatType.identity), false);
}
public void CalculatePhongLight(Vect4 light, Vect4 view, float ka, float kd, float ks, float h)
{
//Check if face is visible
if (mr.enabled == true)
{
float Ia = ka * 1;
float Id = kd * normal.DotProduct(normal, light);
//calculate Reflection vector
//dot product of Light * normal
float dp = light.DotProduct(normal, light) * 2;
Vect4 R = new Vect4(normal.x * dp, normal.y * dp, normal.z * dp);
R = R.Substraction(light);
R.Normalize();
float Is = ks * Mathf.Pow(R.DotProduct(R, view), h);
float I = Ia + Id + Is;
mr.material.SetColor("_Color", IndexedFace.Instance.materialColor * I);
}
}
public Vect4 Multiply(Vect4 other)
{
Vect4 result = new Vect4(0, 0, 0);
float[] tempResult = new float[] { 0, 0, 0, 0 };
float[] tempOther = new float[] { other.x, other.y, other.z, other.w };
for (int i = 0; i < 4; i++)
{
for (int d = 0; d < 4; d++)
{
tempResult[i] += (this.members[d, i] * tempOther[d]);
}
}
result.x = tempResult[0];
result.y = tempResult[1];
result.z = tempResult[2];
result.w = tempResult[3];
return(result);
}
public void Vect4Equality()
{
var a = new Vect4(2.0, 3.0, 5.0, 6.0);
var b = new Vect4(2.0, 3.0, 5.0, 6.0);
var c = new Vect4(3.0, 3.0, 6.0, 7.0);
var d = a;
Assert.IsTrue(a.Equals(b));
Assert.IsFalse(a.Equals(c));
Assert.IsTrue(a.Equals(d));
Assert.AreEqual(a, b);
Assert.AreNotEqual(a, c);
Assert.AreEqual(a, d);
Assert.IsTrue(a == b);
Assert.IsTrue(a != c);
Assert.IsTrue(a != null);
}
public void TranslateToLocalCenter()
{
if (localCenter.x != 0 || localCenter.y != 0 || localCenter.z != 0)
{
Debug.Log("Moving to local center");
Mat4 translationMatrix = new Mat4(MatType.translation, localCenter);
foreach (Triangle face in drawedTriangles)
{
//get the Vertices
Vect4[] points = face.GetCurrentVertices();
for (int i = 0; i < 3; i++)
{
//apply transformation to current vertex
Vect4 CurrentPoint = translationMatrix.Multiply(points[i]);
//update the current vertex
face.UpdateVertex(i, CurrentPoint);
}
}
}
}
public Vert(Vect3 position, Vect3 normal, Vect4 colour)
{
Position = position;
Normal = normal;
Colour = colour;
}
