public void CanCalculateMagnitudeOfVector() { // Arrange var v = new Vector(6, 8, 0); // Act var mag = v.Magnitude; // Assert Assert.AreEqual(10, mag); }
public void CanCalculateMagnitudeOfVector_2() { // Arrange var v = new Vector(1, 1, 1); // Act var mag = v.Magnitude; // Assert Assert.AreEqual(Math.Sqrt(3), mag); }
public void CanCalculateNormalToSphere() { // Arrange var sphere = new Sphere() { Center = new Vector(0, 0, 0), Radius = 1 }; var position = new Vector(1,0,0); // Act var normal = sphere.Normal(position); // Assert Assert.NotNull(normal); Assert.IsTrue(normal.Equals(new Vector(1,0,0))); }
public void CanCalculateCrossProduct() { // Arrange var v1 = new Vector(1, 2, 3); var v2 = new Vector(2, 3, 4); // Act var cross = v1.Cross(v2); var cross_static = Vector.Cross(v1, v2); // Assert Assert.AreEqual(new Vector(-1, 2, -1), cross); Assert.AreEqual(new Vector(-1, 2, -1), cross_static); }
public void CanCalculateDotProduct() { // Arrange var v1 = new Vector(1, 2, 3); var v2 = new Vector(2, 3, 4); // Act var dot = v1.Dot(v2); var dot_static = Vector.Dot(v1, v2); // Assert Assert.AreEqual(20, dot); Assert.AreEqual(20, dot_static); }
public void CanGetRayDirection() { // Arrange var pos = new Vector(0, 0, 0); var dir = new Vector(0, 0, 1); var screen = new Screen(400, 300); var camera = new Camera(pos, dir, screen); // Act var ray = camera.GetRayDirection(100, 100); // Assert Assert.Less(Math.Abs((-1.0 / 8.0) - ray.X), 0.005); Assert.Less(Math.Abs((1.0 / 12.0) - ray.Y), 0.005); Assert.Less(Math.Abs((1.0) - ray.Z), 0.02); }
public void CanAddVectors() { // Arrange var v1 = new Vector(1, 1, 1); var v2 = new Vector(2, 3, 4); // Act var sum_member = v1.Plus(v2); var sum_static = Vector.Plus(v1, v2); var sum_operator = v1 + v2; // Assert var result = new Vector(3,4,5); Assert.IsTrue(sum_member.Equals(result)); Assert.IsTrue(sum_static.Equals(result)); Assert.IsTrue(sum_operator.Equals(result)); }
public void CanConstructNewCamera() { // Arrange var pos = new Vector(0, 0, 0); var dir = new Vector(0, 0, 1); var screen = new Screen(100, 100); // Act var camera = new Camera(pos, dir, screen); // Assert Assert.AreEqual(pos, camera.Position); // Forward is a unit vector pointing in 'lookAt' from 'position' Assert.IsTrue(camera.Forward.Equals(new Vector(0, 0, 1))); // Right Assert.IsTrue(camera.Right.Equals(new Vector(1,0,0))); // Up Assert.IsTrue(camera.Up.Equals(new Vector(0,1,0))); }
/// <summary> /// Subtract a vector from the current vector /// </summary> /// <param name="v">The vector to subtract</param> /// <returns>The resultant vector</returns> public Vector Minus(Vector v) { return new Vector(this.X - v.X, this.Y - v.Y, this.Z - v.Z); }
/// <summary> /// Calculate the cross-product of this vector with another /// </summary> /// <param name="v">The vector to cross with</param> /// <returns>The resultant vector</returns> public Vector Cross(Vector v) { return new Vector(((this.Y * v.Z) - (this.Z * v.Y)), ((this.Z * v.X) - (this.X * v.Z)), ((this.X * v.Y) - (this.Y * v.X))); }
/// <summary> /// Calculate the dot-product of this vector with another /// </summary> /// <param name="v">The vector to dot with</param> /// <returns>The result</returns> public double Dot(Vector v) { return (this.X * v.X) + (this.Y * v.Y) + (this.Z * v.Z); }
/// <summary> /// Add two vectors together /// </summary> /// <param name="v1">The first vector</param> /// <param name="v2">The second vector</param> /// <returns>The resultant vector</returns> public static Vector Plus(Vector v1, Vector v2) { return v1.Plus(v2); }
/// <summary> /// Multiply a vector by a constant value /// </summary> /// <param name="v">The vector to multiply</param> /// <param name="n">The value to multiply by</param> /// <returns>The resultant vector</returns> public static Vector Times(double n, Vector v) { return v.Times(n); }
/// <summary> /// Determinue if two vectors are equal /// </summary> /// <param name="v1">The first vector</param> /// <param name="v2">The second vector</param> /// <returns>True if the vectors are equal</returns> public static bool Equals(Vector v1, Vector v2) { return v1.Equals(v2); }
/// <summary> /// Subtract one vector from another /// </summary> /// <param name="v1">The first vector</param> /// <param name="v2">The second vector</param> /// <returns>The resultant vector</returns> public static Vector Minus(Vector v1, Vector v2) { return v1.Minus(v2); }
/// <summary> /// Get the color of an object at a point of intersection by tracing back to the light sources. /// This creates shadows and adds color if the lights are off-white. /// </summary> /// <param name="element">The object being intersected</param> /// <param name="position">The point of intersection on the object</param> /// <param name="norm">The normal at the point of intersection</param> /// <param name="reflectDirection">The direction of the light reflection off of the surface</param> /// <param name="scene">The scene description</param> /// <returns>The color of the object due to the scenes lighting</returns> private Color GetNaturalColor(SceneObject element, Vector position, Vector norm, Vector reflectDirection, Scene scene) { var ret = new Color(0, 0, 0); foreach (Light light in scene.Lights) { // Direction from the point of intersction to the light source Vector lightDirection = light.Position - position; Vector lightUnitVector = lightDirection.Normalise; // Perform an intersection test in the direction of the light source to determine if we are in a shadow double intersectionDistance = scene.TestRay(new Ray() { Start = position, Direction = lightUnitVector }); bool isInShadow = !((intersectionDistance > lightDirection.Magnitude) || (intersectionDistance == 0)); if (!isInShadow) { // Check the light is shining on the front of the object. Use the angle to determine // the brightness of the light. double angleOfIllumination = Vector.Dot(lightUnitVector, norm); Color lightColor = angleOfIllumination > 0 ? angleOfIllumination * light.Color : new Color(0, 0, 0); // Determine of the light is in the direction of a reflection, leading to a specular effect double specular = Vector.Dot(lightUnitVector, reflectDirection.Normalise); // Calculate color of object based on surface qualities Color specularColor = specular > 0 ? Math.Pow(specular, element.Surface.Roughness) * light.Color : new Color(0, 0, 0); ret = ret + (element.Surface.Diffuse(position) * lightColor) + (element.Surface.Specular(position) * specularColor); } } return ret; }
/// <summary> /// Calculate the dot-product of two vectors /// </summary> /// <param name="v1">The first vector</param> /// <param name="v2">The second vector</param> /// <returns>The result</returns> public static double Dot(Vector v1, Vector v2) { return v1.Dot(v2); }
/// <summary> /// Add a vector to the current vector /// </summary> /// <param name="v">The vector to add</param> /// <returns>The resultant vector</returns> public Vector Plus(Vector v) { return new Vector(this.X + v.X, this.Y + v.Y, this.Z + v.Z); }
public void CanSubtractVectors() { // Arrange var v1 = new Vector(2, 3, 4); var v2 = new Vector(1, 1, 1); // Act var sum_member = v1.Minus(v2); var sum_static = Vector.Minus(v1, v2); var sum_operator = v1 - v2; // Assert var result = new Vector(1, 2, 3); Assert.IsTrue(sum_member.Equals(result)); Assert.IsTrue(sum_static.Equals(result)); Assert.IsTrue(sum_operator.Equals(result)); }
public void CanMultiplyVectorByConstant() { // Arrange var v = new Vector(2, 3, 4); // Act var sum_member = v.Times(2); var sum_static = Vector.Times(2,v); var sum_operator = 2 * v; // Assert var result = new Vector(4, 6, 8); Assert.IsTrue(sum_member.Equals(result)); Assert.IsTrue(sum_static.Equals(result)); Assert.IsTrue(sum_operator.Equals(result)); }
public void DifferentVectorsAreNotEqual() { // Arrange var v1 = new Vector(1, 1, 1); var v2 = new Vector(2, 2, 2); // Act var b = (v1.Equals(v2)); // Assert Assert.IsFalse(b); }
public void IdenticalVectorsAreEqual() { // Arrange var v1 = new Vector(1, 1, 1); var v2 = new Vector(1, 1, 1); // Act var b = (v1.Equals(v2)); // Assert Assert.IsTrue(b); }
public void ObjectAndVectorsAreNotEqual() { // Arrange var v1 = new Vector(1, 1, 1); var obj = new Object(); ; // Act var b = (v1.Equals(obj)); // Assert Assert.IsFalse(b); }
public void IdenticalVectorsAreEqual_Static() { // Arrange var v1 = new Vector(1, 1, 1); var v2 = new Vector(1, 1, 1); // Act var b = Vector.Equals(v1, v2); // Assert Assert.IsTrue(b); }
/// <summary> /// /// </summary> /// <param name="element"></param> /// <param name="position"></param> /// <param name="norm"></param> /// <param name="rayDirection"></param> /// <param name="scene"></param> /// <param name="depth"></param> /// <returns></returns> private Color GetReflectionColor(SceneObject element, Vector position, Vector norm, Vector rayDirection, Scene scene, int depth) { return element.Surface.Reflectiveness(position) * this.TraceRay(new Ray() { Start = position, Direction = rayDirection }, scene, depth + 1); }
public void CanNormaliseVector() { // Arrange var v = new Vector(3, 4, 0); // Act var norm = v.Normalise; // Assert // using * 0.2 so that we get the same double inaccuracy var result = new Vector(3.0 *0.2, 4.0 * 0.2, 0.0); Assert.AreEqual(result, norm); }
public void CanConvertToNiceString() { // Arrange var v1 = new Vector(1, 2, 3); // Act var str = v1.ToString(); // Assert Assert.AreEqual("X=1 Y=2 Z=3", str); }
/// <summary> /// Calculate the cross-product of two vectors /// </summary> /// <param name="v1">The first vector</param> /// <param name="v2">The second vector</param> /// <returns>The resultant vector</returns> public static Vector Cross(Vector v1, Vector v2) { return v1.Cross(v2); }
/// <summary> /// /// </summary> /// <param name="element"></param> /// <param name="position"></param> /// <param name="norm"></param> /// <param name="rayDirection"></param> /// <param name="scene"></param> /// <returns></returns> private Color GetNaturalColor(SceneObject element, Vector position, Vector norm, Vector rayDirection, Scene scene) { var ret = new Color(0, 0, 0); foreach (Light light in scene.Lights) { Vector lightDirection = light.Position - position; Vector lightUnitVector = lightDirection.Normalise; double intersectionDistance = scene.TestRay(new Ray() { Start = position, Direction = lightUnitVector }); bool isInShadow = !((intersectionDistance > lightDirection.Magnitude) || (intersectionDistance == 0)); if (!isInShadow) { double angleOfIllumination = Vector.Dot(lightUnitVector, norm); Color lcolor = angleOfIllumination > 0 ? angleOfIllumination * light.Color : new Color(0, 0, 0); double specular = Vector.Dot(lightUnitVector, rayDirection.Normalise); Color scolor = specular > 0 ? Color.Times(Math.Pow(specular, element.Surface.Roughness), light.Color) : new Color(0, 0, 0); ret = ret + (element.Surface.Diffuse(position) * lcolor) + (element.Surface.Specular(position) * scolor); } } return ret; }
/// <summary> /// Calculate the color being reflected at a point of intersection /// </summary> /// <param name="element">The object being intersected</param> /// <param name="position">The position on the objects surface</param> /// <param name="norm">The normal at the point of intersection</param> /// <param name="reflectDirection">The direction of the reflected ray</param> /// <param name="scene">The scene description</param> /// <param name="depth">The current depth of recursion</param> /// <returns>The color being reflected</returns> private Color GetReflectionColor(SceneObject element, Vector position, Vector norm, Vector reflectDirection, Scene scene, int depth) { // Only calculate reflected color if the surface is reflective var reflectiveness = element.Surface.Reflectiveness(position); if (reflectiveness > 0) { return reflectiveness * this.TraceRay(new Ray() { Start = position, Direction = reflectDirection }, scene, depth + 1); } return new Color(0, 0, 0); }