#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <canvas.h>

#include <render.h>

#include <obj_loader.h>

#define CANVAS_W 400

#define CANVAS_H 400

#define THREADS_NUM 1

#define BACKGROUND_COLOR rgb(255, 255, 255)

#define MAX_OBJECTS_NUMBER 10000

#define MAX_LIGHT_SOURCES_NUMBER 5

#define MAX_SERPINSKY_PYRAMID_LEVEL 6

Camera *

create_camera(void);

void

create_serpinsky_pyramid(Scene * scene,

int level);

void add_serpinsky_pyramid(Scene * scene,

Color color);

void

add_pyramid(Scene * scene,

Color color);

void

generate_random_spheres(Scene * scene,

int count);

int

main(void) {

Camera * camera = create_camera();

Canvas * canvas = new_canvas(CANVAS_W,

CANVAS_H);

int i;

for(i = 0; i < MAX_SERPINSKY_PYRAMID_LEVEL; i++) {

Scene * scene = new_scene(MAX_OBJECTS_NUMBER,

MAX_LIGHT_SOURCES_NUMBER,

BACKGROUND_COLOR);

create_serpinsky_pyramid(scene, i);

// Randomness causes unreproducible results

// But in general - results are similar to Serpinsky pyramid

//generate_random_spheres(scene, i * 400);

prepare_scene(scene);

printf("Number of polygons: %i. ", scene->last_object_index + 1);

render_scene(scene,

camera,

canvas,

THREADS_NUM);

release_scene(scene);

}

release_canvas(canvas);

release_camera(camera);

return 0;

}

Camera *

create_camera(void) {

Point3d camera_location = point3d(-70, 200, 50);

Float focus = 320;

Float x_angle = -1.57;

Float y_angle = 0;

Float z_angle = 3.14;

Camera * camera = new_camera(camera_location,

x_angle,

y_angle,

z_angle,

focus);

return camera;

}

void

create_serpinsky_pyramid(Scene * scene,

int level) {

Float pyramid_edge = 200;

Float dx = -100;

Float dy = -40;

add_serpinsky_pyramid(scene,

level,

point3d(-pyramid_edge/2 + dx, -pyramid_edge * 0.87 / 2 + dy, 0),

point3d(pyramid_edge/2 + dx, -pyramid_edge * 0.87 / 2 + dy, 0),

point3d(dx, pyramid_edge * 0.87 / 2 + dy, 0),

point3d(dx, dy, pyramid_edge * 0.87),

material(1, 5, 0, 0, 0, 0), rgb(240, 210, 40));

}

void add_serpinsky_pyramid(Scene * scene,

Color color) {

if(depth) {

Point3d p1p2 = point3d((p1.x + p2.x) / 2, (p1.y + p2.y) / 2, (p1.z + p2.z) / 2);

Point3d p1p3 = point3d((p1.x + p3.x) / 2, (p1.y + p3.y) / 2, (p1.z + p3.z) / 2);

Point3d p1p4 = point3d((p1.x + p4.x) / 2, (p1.y + p4.y) / 2, (p1.z + p4.z) / 2);

Point3d p2p3 = point3d((p2.x + p3.x) / 2, (p2.y + p3.y) / 2, (p2.z + p3.z) / 2);

Point3d p2p4 = point3d((p2.x + p4.x) / 2, (p2.y + p4.y) / 2, (p2.z + p4.z) / 2);

Point3d p3p4 = point3d((p3.x + p4.x) / 2, (p3.y + p4.y) / 2, (p3.z + p4.z) / 2);

add_serpinsky_pyramid(scene, depth - 1, p1, p1p2, p1p3, p1p4, material, color);

add_serpinsky_pyramid(scene, depth - 1, p2, p1p2, p2p3, p2p4, material, color);

add_serpinsky_pyramid(scene, depth - 1, p3, p1p3, p2p3, p3p4, material, color);

add_serpinsky_pyramid(scene, depth - 1, p4, p1p4, p2p4, p3p4, material, color);

} else {

add_pyramid(scene, p1, p2, p3, p4, material, color);

}

}

void

add_pyramid(Scene * scene,

Color color) {

add_object(scene, new_triangle(p1, p2, p3, color, material));

add_object(scene, new_triangle(p1, p2, p4, color, material));

add_object(scene, new_triangle(p2, p3, p4, color, material));

add_object(scene, new_triangle(p3, p1, p4, color, material));

}

void

generate_random_spheres(Scene * scene,

int count) {

srand(time(NULL));

int i;

for(i = 0; i < count; i++) {

int x = (rand() % 200) - (rand() % 200);

int y = (rand() % 200) - (rand() % 200);

int z = (rand() % 200) - (rand() % 200);

int r = (rand() % 40);

add_object(scene, new_sphere(point3d(x, y, z), r, rgb(255, 0, 0), material(1, 5, 0, 0, 0, 0)));

}

}