protected override void RunImpl()
{
var canvas = new Canvas(width, height);
var backgroundColor = new FColor(0, 0, 0);
var pixelColor = new FColor(1, 1, 1);
canvas.SetEveryPixel(backgroundColor);
// 350 pixels straight up makes this hour 12
var point = Tuple3D.Point(0, 350, 0);
DrawPixel(canvas, pixelColor, point);
// this draws the other points in reverse order, so hour 11, 10, ...
var transform = Transformation.RotationZ(Math.PI / 6);
Enumerable.Range(2, 11).ToList().ForEach(_ =>
{
point = transform * point;
DrawPixel(canvas, pixelColor, point);
});
var ppm = canvas.ToPpm();
File.WriteAllText("../../../Chapter4Demo.ppm", ppm);
}
public void DotProduct()
{
var a = Tuple3D.Vector(1, 2, 3);
var b = Tuple3D.Vector(2, 3, 4);
Assert.That(a.DotProduct(b).AboutEqual(20), Is.True, "Dot product should have been " + 20);
}
public void PointEquals()
{
var p = Tuple3D.Point(4, -4, 3);
var tpl = new Tuple3D(4, -4, 3, 1.0);
Assert.That(p, Is.EqualTo(tpl), "point equals");
}
public void VectorEquals()
{
var v = Tuple3D.Vector(4, -4, 3);
var tpl = new Tuple3D(4, -4, 3, 0.0);
Assert.That(v, Is.EqualTo(tpl), "vector equals");
}
public void NegatingTuple()
{
var a = new Tuple3D(1, -2, 3, -4);
var negA = new Tuple3D(-1, 2, -3, 4);
Assert.That(-a, Is.EqualTo(negA));
}
public void TranslationDoesNotAffectVectors()
{
var transform = Transformation.Translation(5, -3, 2);
var v = Tuple3D.Vector(-3, 4, 5);
var actual = transform * v;
Assert.That(actual, Is.EqualTo(v));
}
public void VectorFromZeroVector()
{
var z = Tuple3D.Vector(0, 0, 0);
var v = Tuple3D.Vector(1, -2, 3);
var diff = Tuple3D.Vector(-1, 2, -3);
Assert.That(z - v, Is.EqualTo(diff));
}
public void SubtractPoints()
{
var p1 = Tuple3D.Point(3, 2, 1);
var p2 = Tuple3D.Point(5, 6, 7);
var diff = Tuple3D.Vector(-2, -4, -6);
Assert.That(p1 - p2, Is.EqualTo(diff));
}
public void SubtractVectors()
{
var v1 = Tuple3D.Vector(3, 2, 1);
var v2 = Tuple3D.Vector(5, 6, 7);
var diff = Tuple3D.Vector(-2, -4, -6);
Assert.That(v1 - v2, Is.EqualTo(diff));
}
public void AddPointAndVector()
{
var a1 = Tuple3D.Point(3, -2, 5);
var a2 = Tuple3D.Vector(-2, 3, 1);
var sum = new Tuple3D(1, 1, 6, 1);
Assert.That(a1 + a2, Is.EqualTo(sum));
}
public void MultFraction()
{
var a = new Tuple3D(1, -2, 3, -4);
double scalar = 0.5;
var mult = new Tuple3D(0.5, -1, 1.5, -2);
Assert.That(a * scalar, Is.EqualTo(mult));
}
public void DivideScalar()
{
var a = new Tuple3D(1, -2, 3, -4);
double scalar = 2;
var div = new Tuple3D(0.5, -1, 1.5, -2);
Assert.That(a / scalar, Is.EqualTo(div));
}
public void MultScalar()
{
var a = new Tuple3D(1, -2, 3, -4);
double scalar = 3.5;
var mult = new Tuple3D(3.5, -7, 10.5, -14);
Assert.That(a * scalar, Is.EqualTo(mult));
}
public void MatrixMultIdentityTuple()
{
var idM = Matrix.Identity();
var tplA = new Tuple3D(1, 2, 3, 4);
var mult = idM * tplA;
Assert.That(tplA, Is.EqualTo(mult));
}
public void SubtractPointVector()
{
var p = Tuple3D.Point(3, 2, 1);
var v = Tuple3D.Vector(5, 6, 7);
var diff = Tuple3D.Point(-2, -4, -6);
Assert.That(p - v, Is.EqualTo(diff));
}
public void ShearingMovesZProportionY()
{
var transform = Transformation.Shearing(0, 0, 0, 0, 0, 1);
var p = Tuple3D.Point(2, 3, 4);
var expected = Tuple3D.Point(2, 3, 7);
var actual = transform * p;
Assert.That(actual, Is.EqualTo(expected));
}
public void ScalingPoint()
{
var transform = Transformation.Scaling(2, 3, 4);
var p = Tuple3D.Point(-4, 6, 8);
var expected = Tuple3D.Point(-8, 18, 32);
var actual = transform * p;
Assert.That(actual, Is.EqualTo(expected));
}
public void ScalingVector()
{
var transform = Transformation.Scaling(2, 3, 4);
var v = Tuple3D.Vector(-4, 6, 8);
var expected = Tuple3D.Vector(-8, 18, 32);
var actual = transform * v;
Assert.That(actual, Is.EqualTo(expected));
}
public void CreateAndQuery()
{
var origin = Tuple3D.Point(1, 2, 3);
var direction = Tuple3D.Vector(4, 5, 6);
var ray = new Ray(origin, direction);
Assert.That(ray.OriginPoint, Is.EqualTo(origin), "origin");
Assert.That(ray.DirectionVector, Is.EqualTo(direction), "direction");
}
public void ReflectionIsScalingByNegativeValue()
{
var transform = Transformation.Scaling(-1, 1, 1);
var p = Tuple3D.Point(2, 3, 4);
var expected = Tuple3D.Point(-2, 3, 4);
var actual = transform * p;
Assert.That(actual, Is.EqualTo(expected));
}
public void MultiplyByTranslationMatrix()
{
var transform = Transformation.Translation(5, -3, 2);
var p = Tuple3D.Point(-3, 4, 5);
var expected = Tuple3D.Point(2, 1, 7);
var actual = transform * p;
Assert.That(actual, Is.EqualTo(expected));
}
public void RayMissesSphere()
{
var ray = new Ray(Tuple3D.Point(0, 2, -5), Tuple3D.Vector(0, 0, 1));
var sphere = new Sphere();
var xs = sphere.Intersect(ray);
Assert.That(xs.Count, Is.EqualTo(0), "intersection point count");
}
public void NormalPointOnZ()
{
var sphere = new Sphere();
var pt = Tuple3D.Point(0, 0, 1);
var expected = Tuple3D.Vector(0, 0, 1);
var actual = sphere.NormalAt(pt);
Assert.That(actual, Is.EqualTo(expected));
}
public void IntersectSetsObjectOnIntersection()
{
var r = new Ray(Tuple3D.Point(0, 0, -5), Tuple3D.Vector(0, 0, 1));
var s = new Sphere();
var xs = s.Intersect(r);
Assert.That(xs.Count, Is.EqualTo(2), "list count");
Assert.That(xs[0].TheObject, Is.EqualTo(s), "intersection 1");
Assert.That(xs[1].TheObject, Is.EqualTo(s), "intersection 2");
}
public void NormalIsNormalizedVector()
{
var sphere = new Sphere();
var weirdVal = Math.Sqrt(3) / 3.0;
var pt = Tuple3D.Point(weirdVal, weirdVal, weirdVal);
var actual = sphere.NormalAt(pt);
var actualNormalized = actual.Normalize();
Assert.That(actual, Is.EqualTo(actualNormalized));
}
public void NormalPointOnNonaxialPoint()
{
var sphere = new Sphere();
var weirdVal = Math.Sqrt(3) / 3.0;
var pt = Tuple3D.Point(weirdVal, weirdVal, weirdVal);
var expected = Tuple3D.Vector(weirdVal, weirdVal, weirdVal);
var actual = sphere.NormalAt(pt);
Assert.That(actual, Is.EqualTo(expected));
}
public void IntersectTranslatedSphereWithRay()
{
var ray = new Ray(Tuple3D.Point(0, 0, -5), Tuple3D.Vector(0, 0, 1));
var sphere = new Sphere();
sphere.Transform = Transformation.Translation(5, 0, 0);
var xs = sphere.Intersect(ray);
Assert.That(xs.Count, Is.EqualTo(0), "intersection point count");
}
public void MultiplyByInverseOfTranslationMatrix()
{
var transform = Transformation.Translation(5, -3, 2);
var inv = transform.Inverse();
var p = Tuple3D.Point(-3, 4, 5);
var expected = Tuple3D.Point(-8, 7, 3);
var actual = inv * p;
Assert.That(actual, Is.EqualTo(expected));
}
public void MultiplyByInverseOfScalingMatrix()
{
var transform = Transformation.Scaling(2, 3, 4);
var inv = transform.Inverse();
var v = Tuple3D.Vector(-4, 6, 8);
var expected = Tuple3D.Vector(-2, 2, 2);
var actual = inv * v;
Assert.That(actual, Is.EqualTo(expected));
}
public void InverseOfXRotationGoesInOppositeDirection()
{
var p = Tuple3D.Point(0, 1, 0);
var halfQuarter = Transformation.RotationX(45d.ToRadians());
var inv = halfQuarter.Inverse();
var expected = Tuple3D.Point(0, Math.Sqrt(2) / 2.0, -Math.Sqrt(2) / 2.0);
var actual = inv * p;
Assert.That(actual, Is.EqualTo(expected));
}
