Finished adding camera, build demo with three spheres

README.md

@@ -19,3 +19,9 @@ Matrix implementation allow us to cast rays...and intersect them with a sphere
 Phone shading!
 
 ![](images/phong_render_sphere2.png)
+
+## main/phone_render_three_spheres
+
+Multiple object, but they are all spheres...Some are simply scaled to look flat.
+
+![](images/phong_render_three_spheres.png)

main/CMakeLists.txt

@@ -1,10 +1,8 @@
 add_executable(parabola
-        parabola.c
-)
+        parabola.c)
 
 target_link_libraries(parabola PRIVATE
-        module_datastructures
-)
+        module_datastructures)
 
 add_executable(sphere_shadow
         sphere_shadow.c)
@@ -16,4 +14,10 @@ add_executable(phong_render_sphere
         phong_render_sphere.c)
 
 target_link_libraries(phong_render_sphere PRIVATE
-        module_datastructures)
+        module_datastructures)
+
+add_executable(phong_render_three_spheres
+        phong_render_three_spheres.c)
+
+target_link_libraries(phong_render_three_spheres PRIVATE
+        module_datastructures)

main/phong_render_three_spheres.c

@@ -0,0 +1,136 @@
+#include "logger.h"
+
+#include "canvas.h"
+#include "exceptions.h"
+#include "ray.h"
+#include <stdio.h>
+#include <sphere.h>
+#include <camera.h>
+
+#include <math.h>
+#include <assert.h>
+
+void build_world(WORLD_World* world) {
+    SPHERE_Sphere* floor = SPHERE_new();
+    WORLD_add_object(world, floor);
+    MATRIX_Matrix* floor_transform = MATRIX_new_scaling(10, 0.01, 10);
+    MATERIAL_Material* material = MATERIAL_new();
+    TUPLES_init_color(&material->color, 1, 0.9, 0.9);
+    material->specular = 0;
+    SPHERE_set_material(floor, material);
+    SPHERE_set_transform(floor, floor_transform);
+    MATRIX_delete(floor_transform);
+
+    SPHERE_Sphere* left_wall = SPHERE_new();
+    WORLD_add_object(world, left_wall);
+    MATRIX_Matrix* lwtranslation = MATRIX_new_translation(0, 0, 5);
+    MATRIX_Matrix* lwroty = MATRIX_new_rotation_y(-M_PI_4);
+    MATRIX_Matrix* lwrotx = MATRIX_new_rotation_x(M_PI_2);
+    MATRIX_Matrix* lwscaling = MATRIX_new_scaling(10, 0.01, 10);
+    MATRIX_Matrix* tmp1 = MATRIX_multiply(lwtranslation, lwroty);
+    MATRIX_Matrix* tmp2 = MATRIX_multiply(tmp1, lwrotx);
+    MATRIX_Matrix* tmp3 = MATRIX_multiply(tmp2, lwscaling);
+    SPHERE_set_transform(left_wall, tmp3);
+    MATRIX_delete_all(lwtranslation, lwroty, lwrotx, lwscaling, tmp1, tmp2, tmp3);
+    SPHERE_set_material(left_wall, material);
+
+    SPHERE_Sphere* right_wall = SPHERE_new();
+    WORLD_add_object(world, right_wall);
+    MATRIX_Matrix* rwtranslation = MATRIX_new_translation(0, 0, 5);
+    MATRIX_Matrix* rwroty = MATRIX_new_rotation_y(M_PI_4);
+    MATRIX_Matrix* rwrotx = MATRIX_new_rotation_x(M_PI_2);
+    MATRIX_Matrix* rwscaling = MATRIX_new_scaling(10, 0.01, 10);
+    tmp1 = MATRIX_multiply(rwtranslation, rwroty);
+    tmp2 = MATRIX_multiply(tmp1, rwrotx);
+    tmp3 = MATRIX_multiply(tmp2, rwscaling);
+    SPHERE_set_transform(right_wall, tmp3);
+    MATRIX_delete_all(rwtranslation, rwroty, rwrotx, rwscaling, tmp1, tmp2, tmp3);
+    SPHERE_set_material(right_wall, material);
+
+    MATERIAL_delete(material);
+
+    SPHERE_Sphere* middle = SPHERE_new();
+    WORLD_add_object(world, middle);
+    MATRIX_Matrix* middle_transform = MATRIX_new_translation(-0.5, 1, 0.5);
+    SPHERE_set_transform(middle, middle_transform);
+    MATRIX_delete(middle_transform);
+    MATERIAL_Material* middle_material = MATERIAL_new();
+    TUPLES_init_color(&middle_material->color, 0.1, 1, 0.5);
+    middle_material->diffuse = 0.7;
+    middle_material->specular = 0.3;
+    SPHERE_set_material(middle, middle_material);
+    MATERIAL_delete(middle_material);
+
+    SPHERE_Sphere* right = SPHERE_new();
+    WORLD_add_object(world, right);
+    MATRIX_Matrix* right_translation = MATRIX_new_translation(1.5, 0.5, -0.5);
+    MATRIX_Matrix* right_scaling = MATRIX_new_scaling(0.5, 0.5, 0.5);
+    MATRIX_Matrix* right_transform = MATRIX_multiply(right_translation, right_scaling);
+    SPHERE_set_transform(right, right_transform);
+    MATRIX_delete_all(right_translation, right_scaling, right_transform);
+    MATERIAL_Material* right_material = MATERIAL_new();
+    TUPLES_init_color(&right_material->color, 0.5, 1, 0.1);
+    right_material->diffuse = 0.7;
+    right_material->specular = 0.3;
+    SPHERE_set_material(right, right_material);
+    MATERIAL_delete(right_material);
+
+    SPHERE_Sphere* left = SPHERE_new();
+    WORLD_add_object(world, left);
+    MATRIX_Matrix* left_translation = MATRIX_new_translation(-1.5, 0.33, -0.75);
+    MATRIX_Matrix* left_scaling = MATRIX_new_scaling(0.33, 0.33, 0.33);
+    MATRIX_Matrix* left_transform = MATRIX_multiply(left_translation, left_scaling);
+    SPHERE_set_transform(left, left_transform);
+    MATRIX_delete_all(left_translation, left_scaling, left_transform);
+    MATERIAL_Material* left_material = MATERIAL_new();
+    TUPLES_init_color(&left_material->color, 1, 0.8, 0.1);
+    left_material->diffuse = 0.7;
+    left_material->specular = 0.3;
+    SPHERE_set_material(left, left_material);
+    MATERIAL_delete(left_material);
+}
+
+int main(void) {
+    CEXCEPTION_T e;
+    Try {
+                LOGGER_log(LOGGER_INFO, "Building world...\n");
+                TUPLES_Point* light_position = TUPLES_new_point(-10, 10, -10);
+                TUPLES_Color* light_color = TUPLES_new_color(1, 1, 1);
+                LIGHTS_PointLight* light = LIGHTS_new_pointlight(light_position, light_color);
+                TUPLES_delete_all(light_position, light_color);
+
+                CAMERA_Camera* camera = CAMERA_new(1000, 500, M_PI / 3.0);
+                TUPLES_Point* from = TUPLES_new_point(0, 1.5, -5);
+                TUPLES_Point* to = TUPLES_new_point(0, 1, 0);
+                TUPLES_Vector* up = TUPLES_new_vector(0, 1, 0);
+                MATRIX_Matrix* camera_transform = CAMERA_view_transform(from, to, up);
+                CAMERA_set_transform(camera, camera_transform);
+                TUPLES_delete_all(from, to, up);
+                MATRIX_delete(camera_transform);
+
+                WORLD_World* world = WORLD_new(light);
+                build_world(world);
+                LOGGER_log(LOGGER_INFO, "Rendering...\n");
+                CANVAS_Canvas* canvas = CAMERA_render(camera, world);
+
+                char *filename = "phong_render_three_spheres.ppm";
+                LOGGER_log(LOGGER_INFO, "Writing file %s...\n", filename);
+                CANVAS_write_to_file(canvas, filename);
+                LOGGER_log(LOGGER_INFO, "Cleaning up...\n");
+                for (unsigned int ndx = 0; ndx < WORLD_get_object_count(world); ndx++) {
+                    SPHERE_delete(WORLD_get_object(world, ndx));
+                }
+                WORLD_delete(world);
+                LIGHTS_delete_pointlight(light);
+                CAMERA_delete(camera);
+                CANVAS_delete(canvas);
+            } Catch(e) {
+        if (e == E_MALLOC_FAILED)
+            printf("Malloc failed.  Exiting\n");
+        else if (e == E_FILE_FAILED)
+            printf("Failed to open test.ppm\n");
+        else
+            printf("Unknown exception %i occurred\n", e);
+    }
+    return 0;
+}

module_datastructures/camera.c

@@ -3,20 +3,41 @@
 #include "matrix.h"
 
 #include <assert.h>
+#include <math.h>
+
+static void calculate_pixel_size(CAMERA_Camera* camera) {
+    assert(camera);
+    double half_view = tan(camera->field_of_view / 2.0);
+    double aspect = camera->hsize / (double) camera->vsize;
+
+    if (aspect >= 1) {
+        camera->half_width = half_view;
+        camera->half_height = half_view / aspect;
+    } else {
+        camera->half_width = half_view * aspect;
+        camera->half_height = half_view;
+    }
+    camera->pixel_size = (camera->half_width * 2.0) / camera->hsize;
+}
 
 CAMERA_Camera* CAMERA_new(unsigned int hsize, unsigned int vsize, double field_of_view) {
+    assert(hsize>0);
+    assert(vsize>0);
     CAMERA_Camera* camera = malloc(sizeof(CAMERA_Camera));
     camera->hsize = hsize;
     camera->vsize = vsize;
     camera->field_of_view = field_of_view;
     camera->transform = MATRIX_new_identity(4);
+    camera->inv_transform = MATRIX_new_identity(4);
+    MATRIX_inverse(camera->inv_transform, camera->transform);
+    calculate_pixel_size(camera);
     return camera;
 }
 
 void CAMERA_delete(CAMERA_Camera* camera) {
     assert(camera);
     assert(camera->transform);
-    MATRIX_delete(camera->transform);
+    MATRIX_delete_all(camera->transform, camera->inv_transform);
     free(camera);
 }
 
@@ -50,3 +71,54 @@ MATRIX_Matrix* CAMERA_view_transform(const TUPLES_Point* from, const TUPLES_Poin
     MATRIX_delete(translation);
     return view;
 }
+
+void CAMERA_set_transform(CAMERA_Camera* camera, MATRIX_Matrix* transform) {
+    assert(camera);
+    assert(transform);
+    assert(MATRIX_is_invertible(transform));
+    MATRIX_copy(camera->transform, transform);
+    MATRIX_inverse(camera->inv_transform, camera->transform);
+}
+
+void CAMERA_ray_for_pixel(RAY_Ray* dest, const CAMERA_Camera* camera, unsigned int px, unsigned int py) {
+    assert(dest);
+    assert(camera);
+    assert(px < camera->hsize);
+    assert(py < camera->vsize);
+
+    double xoffset = (px + 0.5) * camera->pixel_size;
+    double yoffset = (py + 0.5) * camera->pixel_size;
+
+    double world_x = camera->half_width - xoffset;
+    double world_y = camera->half_height - yoffset;
+
+    TUPLES_Point ptmp, pixel, origin;
+    TUPLES_init_point(&ptmp, world_x, world_y, -1.0);
+    MATRIX_multiply_tuple(&pixel, camera->inv_transform, &ptmp);
+
+    TUPLES_init_point(&ptmp, 0, 0, 0);
+    MATRIX_multiply_tuple(&origin, camera->inv_transform, &ptmp);
+
+    TUPLES_Vector direction;
+    TUPLES_subtract(&direction, &pixel, &origin);
+    TUPLES_normalize(&direction);
+
+    RAY_init_from_tuples(dest, &origin, &direction);
+}
+
+CANVAS_Canvas* CAMERA_render(const CAMERA_Camera* camera, const WORLD_World* world) {
+    assert(camera);
+    assert(world);
+    CANVAS_Canvas* canvas = CANVAS_new(camera->hsize, camera->vsize);
+    for (uint y = 0; y < camera->vsize - 1; y++) {
+        for (uint x = 0; x < camera->hsize - 1; x++) {
+            RAY_Ray ray;
+            TUPLES_Color color;
+
+            CAMERA_ray_for_pixel(&ray, camera, x, y);
+            WORLD_color_at(&color, world, &ray);
+            CANVAS_write_pixel(canvas, x, y, &color);
+        }
+    }
+    return canvas;
+}

module_datastructures/camera.h

@@ -3,17 +3,36 @@
 
 #include "tuples.h"
 #include "matrix.h"
+#include "ray.h"
+#include "world.h"
+#include "canvas.h"
 
 typedef struct CAMERA_Camera {
-    unsigned int hsize;
-    unsigned int vsize;
-    double field_of_view;
-    MATRIX_Matrix* transform;
+    unsigned int   hsize;           /** horizontal size in pixels */
+    unsigned int   vsize;           /** vertical size in pixels   */
+    double         half_width;
+    double         half_height;
+    double         field_of_view;   /** field of view in radians  */
+    double         pixel_size;      /** pixel size in world units */
+    MATRIX_Matrix* transform;       /** view transform            */
+    MATRIX_Matrix* inv_transform;   /** inverse view transform    */
 } CAMERA_Camera;
 
 CAMERA_Camera* CAMERA_new(unsigned int hsize, unsigned int vsize, double field_of_view);
 void CAMERA_delete(CAMERA_Camera* camera);
 
+/**
+ * Constructs and allocates a transformation matrix from 2 points and a vector pointing up
+ * @param from
+ * @param to
+ * @param up
+ * @return
+ */
 MATRIX_Matrix* CAMERA_view_transform(const TUPLES_Point* from, const TUPLES_Point* to, const TUPLES_Vector* up);
+void CAMERA_set_transform(CAMERA_Camera* camera, MATRIX_Matrix* transform);
+
+void CAMERA_ray_for_pixel(RAY_Ray* dest, const CAMERA_Camera* camera, unsigned int px, unsigned int py);
+
+CANVAS_Canvas* CAMERA_render(const CAMERA_Camera* camera, const WORLD_World* world);
 
 #endif //DATA_STRUCTURES_CAMERA_H

module_datastructures/canvas.h

@@ -14,6 +14,13 @@ void CANVAS_init(CANVAS_Canvas* canvas, uint width, uint height);
 void CANVAS_destroy(CANVAS_Canvas* canvas);
 void CANVAS_delete(CANVAS_Canvas* canvas);
 
+/**
+ * Returns a ptr to color of the pixel in the canvas.  Should not be freed - canvas will free when deleted.
+ * @param canvas
+ * @param x
+ * @param y
+ * @return
+ */
 TUPLES_Color* CANVAS_read_pixel(const CANVAS_Canvas* canvas, uint x, uint y);
 void CANVAS_write_pixel(CANVAS_Canvas* canvas, uint x, uint y, const TUPLES_Color* color);
 char* CANVAS_get_ppm_header_string(const CANVAS_Canvas* canvas);

module_utilities/CMakeLists.txt

@@ -1,6 +1,6 @@
 add_library(module_utilities STATIC
 		exceptions.h
-	simple_logger.c simple_logger.h utilities.h utilities.c)
+		logger.c logger.h utilities.h utilities.c)
 
 target_include_directories(module_utilities PUBLIC
         ${CMAKE_CURRENT_LIST_DIR}

module_utilities/logger.c

@@ -1,27 +1,34 @@
 #include <stdio.h>
 #include <stdarg.h>
+#include <time.h>
 
-#include "simple_logger.h"
+#include "logger.h"
 
 /**
  * Based on https://github.com/VKoskiv/c-ray/blob/master/src/utils/logging.c
  */
-void SIMPLE_LOGGER_log(LogLevel level, const char* fmt, ...) {
+void LOGGER_log(LOGGER_LEVEL level, const char* fmt, ...) {
+    time_t local_time; /* calendar time */
+    local_time=time(NULL); /* get current cal time */
+    char timestamp[26];
+    asctime_r(localtime(&local_time), timestamp);
+    printf("%.19s  ", timestamp);
+
     //Bold
     printf("\x1b[1m");
     switch(level) {
-        case ERROR:
+        case LOGGER_ERROR:
             //Red
             printf("\x1b[31mError: ");
             break;
-        case WARN:
+        case LOGGER_WARN:
             //Yellow
             printf("\x1b[33mWarning: ");
             break;
-        case INFO:
+        case LOGGER_INFO:
             printf("Info: ");
             break;
-        case DEBUG:
+        case LOGGER_DEBUG:
             printf("Debug: ");
             break;
     }

module_utilities/logger.h

@@ -1,18 +1,18 @@
 #ifndef UTILITIES_SIMPLE_LOGGER_H
 #define UTILITIES_SIMPLE_LOGGER_H
 
-typedef enum {
-    ERROR,
-    WARN,
-    INFO,
-    DEBUG
-} LogLevel;
+typedef enum LOGGER_LEVEL {
+    LOGGER_ERROR,
+    LOGGER_WARN,
+    LOGGER_INFO,
+    LOGGER_DEBUG
+} LOGGER_LEVEL;
 
 /**
  * Logs a "pretty" message to the terminal, this is simple & stupid
  * @param level A member of the LogLevel enum used to colorize terminal output
  * @param msg The null terminated string
  */
-void SIMPLE_LOGGER_log(LogLevel level, const char* fmt, ...);
+void LOGGER_log(LOGGER_LEVEL level, const char* fmt, ...);
 
 #endif //UTILITIES_SIMPLE_LOGGER_H

test/module_datastructures/test_camera.c

@@ -1,6 +1,9 @@
 #include <unity.h>
 #include <tuples.h>
 #include <camera.h>
+#include <ray.h>
+#include <canvas.h>
+#include "test_world_utils.h"
 
 void setUp() {}
 void tearDown() {}
@@ -70,6 +73,95 @@ void test_construct_a_camera() {
     MATRIX_Matrix* expected = MATRIX_new_identity(4);
     TEST_ASSERT_TRUE(MATRIX_is_equal(expected, camera->transform));
     CAMERA_delete(camera);
+    MATRIX_delete(expected);
+}
+
+void test_pixel_size_for_horizontal_canvas() {
+    CAMERA_Camera* camera = CAMERA_new(200, 125, M_PI_2);
+    TEST_ASSERT_EQUAL_DOUBLE(0.01, camera->pixel_size);
+    CAMERA_delete(camera);
+}
+
+void test_pixel_size_for_vertical_canvas() {
+    CAMERA_Camera* camera = CAMERA_new(125, 200, M_PI_2);
+    TEST_ASSERT_EQUAL_DOUBLE(0.01, camera->pixel_size);
+    CAMERA_delete(camera);
+}
+
+void test_get_ray_through_center_of_canvas() {
+    CAMERA_Camera* camera = CAMERA_new(201, 101, M_PI_2);
+    RAY_Ray r;
+    CAMERA_ray_for_pixel(&r, camera, 100, 50);
+
+    TUPLES_Point origin_expected;
+    TUPLES_Vector direction_expected;
+    TUPLES_init_point(&origin_expected, 0, 0, 0);
+    TUPLES_init_vector(&direction_expected, 0, 0, -1);
+
+    TEST_ASSERT_TRUE(TUPLES_is_equal(&origin_expected, &r.origin));
+    TEST_ASSERT_TRUE(TUPLES_is_equal(&direction_expected, &r.direction));
+    CAMERA_delete(camera);
+}
+
+void test_get_ray_through_corner_of_canvas() {
+    CAMERA_Camera* camera = CAMERA_new(201, 101, M_PI_2);
+    RAY_Ray r;
+    CAMERA_ray_for_pixel(&r, camera, 0, 0);
+
+    TUPLES_Point origin_expected;
+    TUPLES_Vector direction_expected;
+    TUPLES_init_point(&origin_expected, 0, 0, 0);
+    TUPLES_init_vector(&direction_expected, 0.66519, 0.33259, -0.66851);
+
+    TEST_ASSERT_TRUE(TUPLES_is_equal(&origin_expected, &r.origin));
+    TEST_ASSERT_TRUE(TUPLES_is_equal(&direction_expected, &r.direction));
+    CAMERA_delete(camera);
+}
+
+void test_get_ray_when_camera_is_transformed() {
+    CAMERA_Camera* camera = CAMERA_new(201, 101, M_PI_2);
+    MATRIX_Matrix* rotation = MATRIX_new_rotation_y(M_PI_4);
+    MATRIX_Matrix* translation = MATRIX_new_translation(0, -2, 5);
+    MATRIX_Matrix* transform = MATRIX_multiply(rotation, translation);
+    CAMERA_set_transform(camera, transform);
+    RAY_Ray r;
+    CAMERA_ray_for_pixel(&r, camera, 100, 50);
+
+    TUPLES_Point origin_expected;
+    TUPLES_Vector direction_expected;
+    TUPLES_init_point(&origin_expected, 0, 2, -5);
+    TUPLES_init_vector(&direction_expected, sqrt(2)/2.0, 0, -sqrt(2)/2.0);
+
+    TEST_ASSERT_TRUE(TUPLES_is_equal(&origin_expected, &r.origin));
+    TEST_ASSERT_TRUE(TUPLES_is_equal(&direction_expected, &r.direction));
+    MATRIX_delete_all(rotation, translation, transform);
+    CAMERA_delete(camera);
+}
+
+void test_redering_world_with_a_camera() {
+    WORLD_World* world = construct_test_world();
+    CAMERA_Camera* camera = CAMERA_new(11, 11, M_PI_2);
+    TUPLES_Point from, to;
+    TUPLES_Vector up;
+    TUPLES_init_point(&from, 0, 0, -5);
+    TUPLES_init_point(&to, 0, 0, 0);
+    TUPLES_init_vector(&up, 0, 1, 0);
+
+    MATRIX_Matrix* transform = CAMERA_view_transform(&from, &to, &up);
+    CAMERA_set_transform(camera, transform);
+    MATRIX_delete(transform);
+
+    CANVAS_Canvas* canvas = CAMERA_render(camera, world);
+
+    TUPLES_Color* c = CANVAS_read_pixel(canvas, 5, 5);
+    TUPLES_Color expected;
+    TUPLES_init_color(&expected, 0.38066, 0.47583, 0.2855);
+    TEST_ASSERT_TRUE(TUPLES_is_equal(&expected, c));
+    TUPLES_delete(c);
+
+    destruct_test_world(world);
+    CAMERA_delete(camera);
+    CANVAS_delete(canvas);
 }
 
 int main(void) {
@@ -79,5 +171,10 @@ int main(void) {
     RUN_TEST(test_transformation_moves_the_world);
     RUN_TEST(test_arbitrary_view_transformation);
     RUN_TEST(test_construct_a_camera);
+    RUN_TEST(test_pixel_size_for_horizontal_canvas);
+    RUN_TEST(test_pixel_size_for_vertical_canvas);
+    RUN_TEST(test_get_ray_through_center_of_canvas);
+    RUN_TEST(test_get_ray_through_corner_of_canvas);
+    RUN_TEST(test_get_ray_when_camera_is_transformed);
     UNITY_END();
-}
+}

test/module_datastructures/test_world.c

@@ -2,14 +2,11 @@
 #include <intersections.h>
 #include "world.h"
 #include "lights.h"
+#include "test_world_utils.h"
 
 void setUp() {}
 void tearDown() {}
 
-SPHERE_Sphere* s1;
-SPHERE_Sphere* s2;
-LIGHTS_PointLight* pl;
-
 void test_world_creation() {
     LIGHTS_PointLight pl;
     TUPLES_Point pl_origin;
@@ -24,46 +21,6 @@ void test_world_creation() {
     WORLD_delete(world);
 }
 
-WORLD_World* construct_test_world() {
-    TUPLES_Point pl_origin;
-    TUPLES_Color pl_color;
-
-    TUPLES_init_point(&pl_origin, -10, 10, -10);
-    TUPLES_init_color(&pl_color, 1, 1, 1);
-
-    pl = LIGHTS_new_pointlight(&pl_origin, &pl_color);
-
-    WORLD_World* world = WORLD_new(pl);
-
-    s1 = SPHERE_new();
-    MATERIAL_Material* s1_material = MATERIAL_new();
-    TUPLES_init_color(&s1_material->color, 0.8, 1.0, 0.6);
-    s1_material->diffuse = 0.7;
-    s1_material->specular = 0.2;
-    SPHERE_set_material(s1, s1_material);
-    MATERIAL_delete(s1_material);
-    WORLD_add_object(world, s1);
-
-    s2 = SPHERE_new();
-    MATRIX_Matrix* s2_transform = MATRIX_new_scaling(0.5, 0.5, 0.5);
-    SPHERE_set_transform(s2, s2_transform);
-    MATRIX_delete(s2_transform);
-    WORLD_add_object(world, s2);
-
-    return world;
-}
-
-void destruct_test_world(WORLD_World* world) {
-    TEST_ASSERT_NOT_NULL(world);
-    LIGHTS_delete_pointlight(pl);
-    TEST_ASSERT_EQUAL_UINT(2, WORLD_get_object_count(world));
-    TEST_ASSERT_NOT_NULL(WORLD_get_object(world, 0));
-    TEST_ASSERT_NOT_NULL(WORLD_get_object(world, 1));
-    SPHERE_delete(s1);
-    SPHERE_delete(s2);
-    WORLD_delete(world);
-}
-
 void test_construct_default_world() {
     WORLD_World* world = construct_test_world();
     TEST_ASSERT_EQUAL_PTR(pl, WORLD_get_light(world));

test/module_datastructures/test_world_utils.h

@@ -0,0 +1,51 @@
+#ifndef DATA_STRUCTURES_TEST_WORLD_UTILS_H
+#define DATA_STRUCTURES_TEST_WORLD_UTILS_H
+
+#include "unity.h"
+#include "world.h"
+
+SPHERE_Sphere* s1;
+SPHERE_Sphere* s2;
+LIGHTS_PointLight* pl;
+
+WORLD_World* construct_test_world() {
+    TUPLES_Point pl_origin;
+    TUPLES_Color pl_color;
+
+    TUPLES_init_point(&pl_origin, -10, 10, -10);
+    TUPLES_init_color(&pl_color, 1, 1, 1);
+
+    pl = LIGHTS_new_pointlight(&pl_origin, &pl_color);
+
+    WORLD_World* world = WORLD_new(pl);
+
+    s1 = SPHERE_new();
+    MATERIAL_Material* s1_material = MATERIAL_new();
+    TUPLES_init_color(&s1_material->color, 0.8, 1.0, 0.6);
+    s1_material->diffuse = 0.7;
+    s1_material->specular = 0.2;
+    SPHERE_set_material(s1, s1_material);
+    MATERIAL_delete(s1_material);
+    WORLD_add_object(world, s1);
+
+    s2 = SPHERE_new();
+    MATRIX_Matrix* s2_transform = MATRIX_new_scaling(0.5, 0.5, 0.5);
+    SPHERE_set_transform(s2, s2_transform);
+    MATRIX_delete(s2_transform);
+    WORLD_add_object(world, s2);
+
+    return world;
+}
+
+void destruct_test_world(WORLD_World* world) {
+    TEST_ASSERT_NOT_NULL(world);
+    LIGHTS_delete_pointlight(pl);
+    TEST_ASSERT_EQUAL_UINT(2, WORLD_get_object_count(world));
+    TEST_ASSERT_NOT_NULL(WORLD_get_object(world, 0));
+    TEST_ASSERT_NOT_NULL(WORLD_get_object(world, 1));
+    SPHERE_delete(s1);
+    SPHERE_delete(s2);
+    WORLD_delete(world);
+}
+
+#endif //DATA_STRUCTURES_TEST_WORLD_UTILS_H

test/module_utilities/test_simple_logger.c

@@ -3,7 +3,7 @@
 //
 
 #include <unity.h>
-#include "simple_logger.h"
+#include "logger.h"
 
 void setUp(void) {
 }
@@ -12,9 +12,9 @@ void tearDown(void) {
 }
 
 void test_dummytest() {
-    SIMPLE_LOGGER_log(ERROR, "This is an error (%s)\n", "asdf");
-    SIMPLE_LOGGER_log(WARN, "This is a warn (%s)\n", "asdf");
-    SIMPLE_LOGGER_log(INFO, "This is an info (%s)\n", "asdf");
+    LOGGER_log(LOGGER_ERROR, "This is an error (%s)\n", "asdf");
+    LOGGER_log(LOGGER_WARN, "This is a warn (%s)\n", "asdf");
+    LOGGER_log(LOGGER_INFO, "This is an info (%s)\n", "asdf");
 }
 
 int main(void)