raytracer-in-c/plane_sphere_image.c at main · thecatblake/raytracer-in-c · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
//
// Created by ryousuke kaga on 2023/11/02.
//

//
// Created by ryousuke kaga on 2023/10/26.
//
#include <stdlib.h>
#include <stdio.h>
#include "tuple.h"
#include "object.h"
#include "ray.h"
#include "canvas.h"
#include "light.h"
#include "world.h"
#include "camera.h"
#include "plane.h"

int main() {
    stripe_pattern_t stripe = {vector(0, 0, 0), vector(1, 1, 1)};
    pattern_t stripe_pattern;
    stripe_init(&stripe_pattern, &stripe);

    stripe_pattern_t gradient = {vector(0.1803, 0.1921, 0.572549), vector(0.1058, 1, 1)};
    pattern_t gradient_pattern;
    gradient_init(&gradient_pattern, &gradient);
    transform_translate(&gradient_pattern.transform, vector(0, 0, 1));

    stripe_pattern_t check = {vector(0, 0, 0), vector(1, 1, 1)};
    pattern_t check_pattern;
    check_init(&check_pattern, &check);
    transform_scale(&check_pattern.transform, vector(0.2, 0.2, 0.2));

    object_t floor;
    plane_init(&floor);
    floor.material.pattern = check_pattern;
    floor.material.reflective = 0.5;

    object_t back_wall;
    plane_init(&back_wall);
    object_rotate_x(&back_wall, M_PI / 2);
    object_translate(&back_wall, vector(0, 0, 7));
    back_wall.material.pattern = check_pattern;

    object_t left_wall;
    plane_init(&left_wall);
    object_rotate_x(&left_wall, M_PI / 2);
    object_rotate_y(&left_wall, -M_PI / 2);
    object_translate(&left_wall, vector(-5, 0, 0));

    object_t right_wall;
    plane_init(&right_wall);
    object_rotate_x(&right_wall, M_PI / 2);
    object_rotate_y(&right_wall, M_PI / 2);
    object_translate(&right_wall, vector(5, 0, 0));

    object_t middle;
    sphere_init(&middle);
    object_translate(&middle, vector(-0.5, 1, 0.5));
    middle.material.color = vector(1, 0, 0);
    middle.material.diffuse = 0.7;
    middle.material.specular = 0.3;
    middle.material.refractive_index = 1.5;
    middle.material.transparency = 1.0;

    object_t right;
    sphere_init(&right);
    object_translate(&right, vector(1.5, 1, -0.5));
    object_scale(&right, vector(0.5, 0.5, 0.5));
    right.material.color = vector(0, 1, 0);
    right.material.diffuse = 0.7;
    right.material.specular = 0.3;
    right.material.reflective = 1.0;

    object_t left;
    sphere_init(&left);
    object_translate(&left, vector(-4.5, 1, -0.75));
    object_scale(&left, vector(0.33, 0.33, 0.33));
    left.material.color = vector(0, 0, 1);
    left.material.diffuse = 0.7;
    left.material.specular = 0.3;
    left.material.reflective = 1.0;

    world_t world;
    world_init(&world);

    point_light_t light = {point(-3, 3, -3), vector(1, 1, 1)};
    world.light = &light;
    world_add_object(&world, &floor);
    world_add_object(&world, &middle);
    world_add_object(&world, &back_wall);
    world_add_object(&world, &left);
    world_add_object(&world, &right);

    int width = 2000;
    int height = 2000;

    camera_t camera;
    camera_init(&camera, width, height, M_PI / 3);
    camera_transform(&camera, point(0, 2, -5), point(0, 0, 1), vector(0, 1, 0));

    int n_pixels = width * height;

    tuple_t* pixels = malloc(sizeof(tuple_t) * n_pixels);

    camera_render(&camera, &world, pixels);

    FILE* fp = fopen("sphere_plane_image.ppm", "w");
    canvas_write_ppm(width, height, pixels, fp);

    fclose(fp);
    free(pixels);
}