270 lines
7.3 KiB
C
270 lines
7.3 KiB
C
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
|
|
#include "tuples.h"
|
|
#include "runner.h"
|
|
|
|
static bool tuple_test_0(const char ** scenario)
|
|
{
|
|
*scenario = "A tuple with w=1.0 is a point";
|
|
|
|
struct tuple a = tuple(4.3f, -4.2f, 3.1f, 1.0f);
|
|
return
|
|
a.x == 4.3f &&
|
|
a.y == -4.2f &&
|
|
a.z == 3.1f &&
|
|
a.w == 1.0f &&
|
|
tuple_is_point(a) &&
|
|
!tuple_is_vector(a)
|
|
;
|
|
}
|
|
|
|
static bool tuple_test_1(const char ** scenario)
|
|
{
|
|
*scenario = "A tuple with w=0.0 is a vector";
|
|
|
|
struct tuple a = tuple(4.3f, -4.2f, 3.1f, 0.0f);
|
|
return
|
|
a.x == 4.3f &&
|
|
a.y == -4.2f &&
|
|
a.z == 3.1f &&
|
|
a.w == 0.0f &&
|
|
!tuple_is_point(a) &&
|
|
tuple_is_vector(a)
|
|
;
|
|
}
|
|
|
|
static bool tuple_test_2(const char ** scenario)
|
|
{
|
|
*scenario = "point() creates tuples with w=1.0";
|
|
struct tuple v = point(4.0f, -4.0f, 3.0f);
|
|
return tuple_equal(v, tuple(4.0f, -4.0f, 3.0f, 1.0f));
|
|
}
|
|
|
|
static bool tuple_test_3(const char ** scenario)
|
|
{
|
|
*scenario = "vector() creates tuples with w=0.0";
|
|
struct tuple v = vector(4.0f, -4.0f, 3.0f);
|
|
return tuple_equal(v, tuple(4.0f, -4.0f, 3.0f, 0.0f));
|
|
}
|
|
|
|
static bool tuple_test_4(const char ** scenario)
|
|
{
|
|
*scenario = "Adding two tuples";
|
|
struct tuple a1 = tuple(3.0f, -2.0f, 5.0f, 1.0f);
|
|
struct tuple a2 = tuple(-2.0f, 3.0f, 1.0f, 0.0f);
|
|
return tuple_equal(tuple_add(a1, a2), point(1.0f, 1.0f, 6.0f));
|
|
}
|
|
|
|
static bool tuple_test_5(const char ** scenario)
|
|
{
|
|
*scenario = "Subtracting two points";
|
|
struct tuple p1 = point(3.0f, 2.0f, 1.0f);
|
|
struct tuple p2 = point(5.0f, 6.0f, 7.0f);
|
|
return tuple_equal(tuple_sub(p1, p2), vector(-2.0f, -4.0f, -6.0f));
|
|
}
|
|
|
|
static bool tuple_test_6(const char ** scenario)
|
|
{
|
|
*scenario = "Subtracting a vector from a point";
|
|
struct tuple p = point(3.0f, 2.0f, 1.0f);
|
|
struct tuple v = vector(5.0f, 6.0f, 7.0f);
|
|
return tuple_equal(tuple_sub(p, v), point(-2.0f, -4.0f, -6.0f));
|
|
}
|
|
|
|
static bool tuple_test_7(const char ** scenario)
|
|
{
|
|
*scenario = "Subtracting two vectors";
|
|
struct tuple v1 = vector(3.0f, 2.0f, 1.0f);
|
|
struct tuple v2 = vector(5.0f, 6.0f, 7.0f);
|
|
return tuple_equal(tuple_sub(v1, v2), vector(-2.0f, -4.0f, -6.0f));
|
|
}
|
|
|
|
static bool tuple_test_8(const char ** scenario)
|
|
{
|
|
*scenario = "Subtracting a vector from the zero vector";
|
|
struct tuple zero = vector(0.0f, 0.0f, 0.0f);
|
|
struct tuple v = vector(1.0f, -2.0f, 3.0f);
|
|
return tuple_equal(tuple_sub(zero, v), vector(-1.0f, 2.0f, -3.0f));
|
|
}
|
|
|
|
static bool tuple_test_9(const char ** scenario)
|
|
{
|
|
*scenario = "Negating a tuple";
|
|
struct tuple a = tuple(1.0f, -2.0f, 3.0f, -4.0f);
|
|
return tuple_equal(tuple_neg(a), tuple(-1.0f, 2.0f, -3.0f, 4.0f));
|
|
}
|
|
|
|
static bool tuple_test_10(const char ** scenario)
|
|
{
|
|
*scenario = "Multiplying a tuple by a scalar";
|
|
struct tuple a = tuple(1.0f, -2.0f, 3.0f, -4.0f);
|
|
return tuple_equal(tuple_mul(a, 3.5f), tuple(3.5f, -7.0f, 10.5f, -14.0f));
|
|
}
|
|
|
|
static bool tuple_test_11(const char ** scenario)
|
|
{
|
|
*scenario = "Multiplying a tuple by a fraction";
|
|
struct tuple a = tuple(1.0f, -2.0f, 3.0f, -4.0f);
|
|
return tuple_equal(tuple_mul(a, 0.5f), tuple(0.5f, -1.0f, 1.5f, -2.0f));
|
|
}
|
|
|
|
static bool tuple_test_12(const char ** scenario)
|
|
{
|
|
*scenario = "Dividing a tuple by a scalar";
|
|
struct tuple a = tuple(1.0f, -2.0f, 3.0f, -4.0f);
|
|
return tuple_equal(tuple_div(a, 2.0f), tuple(0.5f, -1.0f, 1.5f, -2.0f));
|
|
}
|
|
|
|
static bool tuple_test_13(const char ** scenario)
|
|
{
|
|
*scenario = "Computing the magnitude of vector(1, 0, 0)";
|
|
struct tuple a = vector(1.0f, 0.0f, 0.0f);
|
|
return float_equal(tuple_magnitude(a), 1.0f);
|
|
}
|
|
|
|
static bool tuple_test_14(const char ** scenario)
|
|
{
|
|
*scenario = "Computing the magnitude of vector(0, 1, 0)";
|
|
struct tuple a = vector(0.0f, 1.0f, 0.0f);
|
|
return float_equal(tuple_magnitude(a), 1.0f);
|
|
}
|
|
|
|
static bool tuple_test_15(const char ** scenario)
|
|
{
|
|
*scenario = "Computing the magnitude of vector(0, 0, 1)";
|
|
struct tuple a = vector(0.0f, 0.0f, 1.0f);
|
|
return float_equal(tuple_magnitude(a), 1.0f);
|
|
}
|
|
|
|
static bool tuple_test_16(const char ** scenario)
|
|
{
|
|
*scenario = "Computing the magnitude of vector(1, 2, 3)";
|
|
struct tuple a = vector(1.0f, 2.0f, 3.0f);
|
|
return float_equal(tuple_magnitude(a), 3.7416573867739413);
|
|
}
|
|
|
|
static bool tuple_test_17(const char ** scenario)
|
|
{
|
|
*scenario = "Computing the magnitude of vector(-1, -2, -3)";
|
|
struct tuple a = vector(-1.0f, -2.0f, -3.0f);
|
|
return float_equal(tuple_magnitude(a), 3.7416573867739413);
|
|
}
|
|
|
|
static bool tuple_test_18(const char ** scenario)
|
|
{
|
|
*scenario = "Normalizing vector(4, 0, 0)";
|
|
struct tuple v = vector(4.0f, 0.0f, 0.0f);
|
|
return tuple_equal(tuple_normalize(v), vector(1.0f, 0.0f, 0.0f));
|
|
}
|
|
|
|
static bool tuple_test_19(const char ** scenario)
|
|
{
|
|
*scenario = "Normalizing vector(1, 2, 3)";
|
|
struct tuple v = vector(1.0f, 2.0f, 3.0f);
|
|
return tuple_equal(tuple_normalize(v), vector(0.2672612419124244,
|
|
0.5345224838248488,
|
|
0.8017837257372732));
|
|
}
|
|
|
|
static bool tuple_test_20(const char ** scenario)
|
|
{
|
|
*scenario = "The magnitude of a normalized vector";
|
|
struct tuple v = vector(1.0f, 2.0f, 3.0f);
|
|
struct tuple norm = tuple_normalize(v);
|
|
return float_equal(tuple_magnitude(norm), 1.0f);
|
|
}
|
|
|
|
static bool tuple_test_21(const char ** scenario)
|
|
{
|
|
*scenario = "The dot product of two tuples";
|
|
struct tuple a = vector(1.0f, 2.0f, 3.0f);
|
|
struct tuple b = vector(2.0f, 3.0f, 4.0f);
|
|
return float_equal(tuple_dot(a, b), 20.0f);
|
|
}
|
|
|
|
static bool tuple_test_22(const char ** scenario)
|
|
{
|
|
*scenario = "The cross product of two vectors";
|
|
struct tuple a = vector(1.0f, 2.0f, 3.0f);
|
|
struct tuple b = vector(2.0f, 3.0f, 4.0f);
|
|
return
|
|
tuple_equal(tuple_cross(a, b), vector(-1.0f, 2.0f, -1.0f)) &&
|
|
tuple_equal(tuple_cross(b, a), vector( 1.0f, -2.0f, 1.0f))
|
|
;
|
|
}
|
|
|
|
static bool tuple_test_23(const char ** scenario)
|
|
{
|
|
*scenario = "Colors are (red, green, blue) tuples";
|
|
struct tuple c = color(-0.5, 0.4, 1.7);
|
|
return
|
|
float_equal(c.r, -0.5) &&
|
|
float_equal(c.g, 0.4) &&
|
|
float_equal(c.b, 1.7);
|
|
}
|
|
|
|
static bool tuple_test_24(const char ** scenario)
|
|
{
|
|
*scenario = "Adding colors";
|
|
struct tuple c1 = color(0.9f, 0.6f, 0.75f);
|
|
struct tuple c2 = color(0.7f, 0.1f, 0.25f);
|
|
return tuple_equal(tuple_add(c1, c2), color(1.6f, 0.7f, 1.0f));
|
|
}
|
|
|
|
static bool tuple_test_25(const char ** scenario)
|
|
{
|
|
*scenario = "Subtracting colors";
|
|
struct tuple c1 = color(0.9f, 0.6f, 0.75f);
|
|
struct tuple c2 = color(0.7f, 0.1f, 0.25f);
|
|
return tuple_equal(tuple_sub(c1, c2), color(0.2f, 0.5f, 0.5f));
|
|
}
|
|
|
|
static bool tuple_test_26(const char ** scenario)
|
|
{
|
|
*scenario = "Multiplying a color by a scalar";
|
|
struct tuple c = color(0.2f, 0.3f, 0.4f);
|
|
return tuple_equal(tuple_mul(c, 2.0f), color(0.4f, 0.6f, 0.8f));
|
|
}
|
|
|
|
static bool tuple_test_27(const char ** scenario)
|
|
{
|
|
*scenario = "Multiplying colors";
|
|
struct tuple c1 = color(1.0f, 0.2f, 0.4f);
|
|
struct tuple c2 = color(0.9f, 1.0f, 0.1f);
|
|
return tuple_equal(hadmard_product(c1, c2), color(0.9f, 0.2f, 0.04f));
|
|
}
|
|
|
|
test_t tuple_tests[] = {
|
|
tuple_test_0,
|
|
tuple_test_1,
|
|
tuple_test_2,
|
|
tuple_test_3,
|
|
tuple_test_4,
|
|
tuple_test_5,
|
|
tuple_test_6,
|
|
tuple_test_7,
|
|
tuple_test_8,
|
|
tuple_test_9,
|
|
tuple_test_10,
|
|
tuple_test_11,
|
|
tuple_test_12,
|
|
tuple_test_13,
|
|
tuple_test_14,
|
|
tuple_test_15,
|
|
tuple_test_16,
|
|
tuple_test_17,
|
|
tuple_test_18,
|
|
tuple_test_19,
|
|
tuple_test_20,
|
|
tuple_test_21,
|
|
tuple_test_22,
|
|
tuple_test_23,
|
|
tuple_test_24,
|
|
tuple_test_25,
|
|
tuple_test_26,
|
|
tuple_test_27,
|
|
};
|
|
|
|
RUNNER(tuple_tests)
|