366 lines
10 KiB
C
366 lines
10 KiB
C
#include "c_cpp_aliases/aliases.h"
|
|
#include "vector/vec.h"
|
|
#include "window/window.h"
|
|
#include <SDL2/SDL_events.h>
|
|
#include <float.h>
|
|
#include <math.h>
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#define ARR_LEN(ARR) sizeof(ARR) / sizeof(ARR[0])
|
|
|
|
typedef struct {
|
|
f32 radius;
|
|
vec3f_t centre;
|
|
colour_t colour;
|
|
f32 specular;
|
|
} sphere_t;
|
|
|
|
typedef enum {
|
|
LIGHT_TYPE_POINT,
|
|
LIGHT_TYPE_DIRECTIONAL,
|
|
LIGHT_TYPE_AMBIENT,
|
|
|
|
COUNT_LIGHT_TYPE,
|
|
} light_type_t;
|
|
|
|
typedef struct {
|
|
light_type_t type;
|
|
f32 intensity;
|
|
union {
|
|
vec3f_t position;
|
|
vec3f_t direction;
|
|
};
|
|
} light_t;
|
|
|
|
typedef struct {
|
|
sphere_t *spheres;
|
|
light_t *lights;
|
|
u32 spheres_count;
|
|
u32 lights_count;
|
|
} scene_t;
|
|
|
|
typedef struct {
|
|
f32 t1;
|
|
f32 t2;
|
|
} solutions_t;
|
|
|
|
typedef struct {
|
|
f32 closest_t;
|
|
sphere_t *closest_sphere;
|
|
} intersection_t;
|
|
|
|
colour_t trace_ray(vec3f_t origin, vec3f_t direction, f32 t_min, f32 t_max,
|
|
const scene_t *scene, colour_t default_colour);
|
|
intersection_t find_closest_intersection(vec3f_t origin, vec3f_t direction,
|
|
f32 t_min, f32 t_max,
|
|
const scene_t *scene);
|
|
f32 calculate_lighting_for_intersection(vec3f_t origin, vec3f_t direction,
|
|
intersection_t intersection,
|
|
const scene_t *scene);
|
|
solutions_t ray_intersects_sphere(vec3f_t origin, vec3f_t direction,
|
|
sphere_t sphere);
|
|
f32 compute_lighting(vec3f_t position, vec3f_t surface_normal,
|
|
vec3f_t view_vector, f32 specular_exponent,
|
|
const scene_t *scene);
|
|
f32 light_diffuse(f32 light_intensity, vec3f_t light_direction,
|
|
vec3f_t surface_normal);
|
|
f32 light_specular(f32 light_intensity, vec3f_t light_direction,
|
|
vec3f_t surface_normal, vec3f_t view_vector,
|
|
f32 specular_exponent);
|
|
f32 cos_angle_between_vectors(vec3f_t v1, vec3f_t v2);
|
|
f32 clamp(f32 value, f32 min, f32 max);
|
|
|
|
i32 main(i32 argc, char *argv[]) {
|
|
colour_t bg =
|
|
(colour_t){.rgba.r = 27, .rgba.g = 38, .rgba.b = 79, .rgba.a = 255};
|
|
vec3f_t camera = {.x = 0.0f, .y = 0.0f, .z = 0.0f};
|
|
vec3f_t viewport = {.x = 1.0f, .y = 1.0f, .z = 1.0f};
|
|
|
|
window_t window = {0};
|
|
|
|
if (!init_window(&window, 800, 800, "CG From Scratch")) {
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
bool running = true;
|
|
SDL_Event event = {0};
|
|
|
|
sphere_t spheres[] = {
|
|
(sphere_t){
|
|
.radius = 1.0f,
|
|
.centre = (vec3f_t){.x = 0.0f, .y = -1.0f, .z = 3.0f},
|
|
.colour =
|
|
(colour_t){
|
|
.rgba.r = 245, .rgba.g = 238, .rgba.b = 158, .rgba.a = 255},
|
|
.specular = 500.0f,
|
|
},
|
|
(sphere_t){
|
|
.radius = 1.0f,
|
|
.centre = (vec3f_t){.x = -2.0f, .y = 0.0f, .z = 4.0f},
|
|
.colour =
|
|
(colour_t){
|
|
.rgba.r = 59, .rgba.g = 142, .rgba.b = 165, .rgba.a = 255},
|
|
.specular = 10.0f,
|
|
},
|
|
(sphere_t){
|
|
.radius = 1.0f,
|
|
.centre = (vec3f_t){.x = 2.0f, .y = 0.0f, .z = 4.0f},
|
|
.colour =
|
|
(colour_t){
|
|
.rgba.r = 171, .rgba.g = 52, .rgba.b = 40, .rgba.a = 255},
|
|
.specular = 500.0f,
|
|
},
|
|
(sphere_t){
|
|
.radius = 5000.0f,
|
|
.centre = (vec3f_t){.x = 0.0f, .y = -5001.0f, .z = 0.0f},
|
|
.colour =
|
|
(colour_t){
|
|
.rgba.r = 255, .rgba.g = 255, .rgba.b = 0, .rgba.a = 255},
|
|
.specular = 1000.0f,
|
|
},
|
|
};
|
|
|
|
light_t lights[] = {
|
|
(light_t){
|
|
.type = LIGHT_TYPE_AMBIENT,
|
|
.intensity = 0.2f,
|
|
},
|
|
(light_t){
|
|
.type = LIGHT_TYPE_POINT,
|
|
.intensity = 0.6f,
|
|
.position = (vec3f_t){.x = 2.0f, .y = 1.0f, .z = 0.0f},
|
|
},
|
|
(light_t){
|
|
.type = LIGHT_TYPE_DIRECTIONAL,
|
|
.intensity = 0.2f,
|
|
.direction = (vec3f_t){.x = 1.0f, .y = 4.0f, .z = 4.0f},
|
|
},
|
|
};
|
|
|
|
scene_t scene = {
|
|
.spheres = spheres,
|
|
.lights = lights,
|
|
.spheres_count = ARR_LEN(spheres),
|
|
.lights_count = ARR_LEN(lights),
|
|
};
|
|
|
|
i32 w_min = ((i32)window.half_width) * -1;
|
|
i32 w_max = (i32)window.half_width;
|
|
i32 h_min = ((i32)window.half_height) * -1;
|
|
i32 h_max = (i32)window.half_height;
|
|
|
|
while (running) {
|
|
while (SDL_PollEvent(&event)) {
|
|
switch (event.type) {
|
|
case SDL_QUIT:
|
|
running = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
clear_window(&window, bg);
|
|
|
|
for (i32 y = h_min; y < h_max; ++y) {
|
|
for (i32 x = w_min; x < w_max; ++x) {
|
|
vec3f_t direction = window_to_viewport(&window, x, y, viewport);
|
|
colour_t colour = trace_ray(camera, direction, 1, INFINITY, &scene, bg);
|
|
set_pixel(&window, x, y, colour);
|
|
}
|
|
}
|
|
|
|
swap_buffers(&window);
|
|
}
|
|
|
|
close_window(&window);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
colour_t trace_ray(vec3f_t origin, vec3f_t direction, f32 t_min, f32 t_max,
|
|
const scene_t *scene, colour_t default_colour) {
|
|
|
|
intersection_t intersection =
|
|
find_closest_intersection(origin, direction, t_min, t_max, scene);
|
|
|
|
if (!intersection.closest_sphere) {
|
|
return default_colour;
|
|
}
|
|
|
|
f32 light = calculate_lighting_for_intersection(origin, direction,
|
|
intersection, scene);
|
|
|
|
f32 r = (f32)(intersection.closest_sphere->colour.rgba.r) * light;
|
|
r = clamp(r, 0.0f, (f32)UINT8_MAX);
|
|
f32 g = (f32)(intersection.closest_sphere->colour.rgba.g) * light;
|
|
g = clamp(g, 0.0f, (f32)UINT8_MAX);
|
|
f32 b = (f32)(intersection.closest_sphere->colour.rgba.b) * light;
|
|
b = clamp(b, 0.0f, (f32)UINT8_MAX);
|
|
|
|
return (colour_t){
|
|
.rgba.r = (u8)r,
|
|
.rgba.g = (u8)g,
|
|
.rgba.b = (u8)b,
|
|
.rgba.a = intersection.closest_sphere->colour.rgba.a,
|
|
};
|
|
}
|
|
|
|
intersection_t find_closest_intersection(vec3f_t origin, vec3f_t direction,
|
|
f32 t_min, f32 t_max,
|
|
const scene_t *scene) {
|
|
f32 closest_t = INFINITY;
|
|
sphere_t *closest_sphere = NULL;
|
|
|
|
for (u32 i = 0; i < scene->spheres_count; ++i) {
|
|
solutions_t solutions =
|
|
ray_intersects_sphere(origin, direction, scene->spheres[i]);
|
|
|
|
if (solutions.t1 >= t_min && solutions.t1 <= t_max &&
|
|
solutions.t1 < closest_t) {
|
|
closest_t = solutions.t1;
|
|
closest_sphere = &(scene->spheres[i]);
|
|
}
|
|
|
|
if (solutions.t2 >= t_min && solutions.t2 <= t_max &&
|
|
solutions.t2 < closest_t) {
|
|
closest_t = solutions.t2;
|
|
closest_sphere = &(scene->spheres[i]);
|
|
}
|
|
}
|
|
|
|
return (intersection_t){closest_t, closest_sphere};
|
|
}
|
|
|
|
f32 calculate_lighting_for_intersection(vec3f_t origin, vec3f_t direction,
|
|
intersection_t intersection,
|
|
const scene_t *scene) {
|
|
vec3f_t position = vec_add(
|
|
vec3f_t, origin, vec_mul_num(vec3f_t, direction, intersection.closest_t));
|
|
|
|
vec3f_t surface_normal =
|
|
vec_sub(vec3f_t, position, intersection.closest_sphere->centre);
|
|
surface_normal = vec_div_num(vec3f_t, surface_normal,
|
|
vec_magnitude(vec3f_t, surface_normal));
|
|
|
|
vec3f_t view_vector = vec_mul_num(vec3f_t, direction, -1.0f);
|
|
|
|
return compute_lighting(position, surface_normal, view_vector,
|
|
intersection.closest_sphere->specular, scene);
|
|
}
|
|
|
|
solutions_t ray_intersects_sphere(vec3f_t origin, vec3f_t direction,
|
|
sphere_t sphere) {
|
|
f32 r = sphere.radius;
|
|
vec3f_t CO = vec_sub(vec3f_t, origin, sphere.centre);
|
|
|
|
f32 a = vec_dot(vec3f_t, direction, direction);
|
|
f32 b = 2.0f * vec_dot(vec3f_t, CO, direction);
|
|
f32 c = vec_dot(vec3f_t, CO, CO) - r * r;
|
|
|
|
f32 discriminant = b * b - 4 * a * c;
|
|
if (discriminant < 0) {
|
|
return (solutions_t){INFINITY, INFINITY};
|
|
}
|
|
|
|
f32 t1 = (-b + sqrtf(discriminant)) / (2 * a);
|
|
f32 t2 = (-b - sqrtf(discriminant)) / (2 * a);
|
|
|
|
return (solutions_t){t1, t2};
|
|
}
|
|
|
|
f32 compute_lighting(vec3f_t position, vec3f_t surface_normal,
|
|
vec3f_t view_vector, f32 specular_exponent,
|
|
const scene_t *scene) {
|
|
f32 I = 0.0f;
|
|
light_t light = {0};
|
|
|
|
for (u32 i = 0; i < scene->lights_count; ++i) {
|
|
light = scene->lights[i];
|
|
|
|
if (light.type == LIGHT_TYPE_AMBIENT) {
|
|
I += light.intensity;
|
|
} else {
|
|
vec3f_t light_direction = {0};
|
|
f32 t_max = FLT_EPSILON;
|
|
|
|
switch (light.type) {
|
|
case LIGHT_TYPE_POINT:
|
|
light_direction = vec_sub(vec3f_t, light.position, position);
|
|
t_max = 1;
|
|
break;
|
|
case LIGHT_TYPE_DIRECTIONAL:
|
|
light_direction = light.direction;
|
|
t_max = INFINITY;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
intersection_t shadow = find_closest_intersection(
|
|
position, light_direction, 0.001f, t_max, scene);
|
|
if (shadow.closest_sphere != NULL) {
|
|
continue;
|
|
}
|
|
|
|
I += light_diffuse(light.intensity, light_direction, surface_normal);
|
|
|
|
if (specular_exponent != -1.0f) {
|
|
I += light_specular(light.intensity, light_direction, surface_normal,
|
|
view_vector, specular_exponent);
|
|
}
|
|
}
|
|
}
|
|
|
|
return I;
|
|
}
|
|
|
|
f32 light_diffuse(f32 light_intensity, vec3f_t light_direction,
|
|
vec3f_t surface_normal) {
|
|
return light_intensity *
|
|
cos_angle_between_vectors(light_direction, surface_normal);
|
|
}
|
|
|
|
f32 light_specular(f32 light_intensity, vec3f_t light_direction,
|
|
vec3f_t surface_normal, vec3f_t view_vector,
|
|
f32 specular_exponent) {
|
|
vec3f_t _2N = vec_mul_num(vec3f_t, surface_normal, 2.0f);
|
|
f32 dot_product = vec_dot(vec3f_t, light_direction, surface_normal);
|
|
|
|
vec3f_t _2N_mul_dot = vec_mul_num(vec3f_t, _2N, dot_product);
|
|
|
|
vec3f_t R = vec_sub(vec3f_t, _2N_mul_dot, light_direction);
|
|
|
|
return light_intensity *
|
|
powf(cos_angle_between_vectors(R, view_vector), specular_exponent);
|
|
}
|
|
|
|
f32 cos_angle_between_vectors(vec3f_t v1, vec3f_t v2) {
|
|
f32 dot_product = vec_dot(vec3f_t, v1, v2);
|
|
|
|
if (dot_product < 0.0f) {
|
|
return 0.0f;
|
|
}
|
|
|
|
f32 divisor = vec_magnitude(vec3f_t, v1) * vec_magnitude(vec3f_t, v2);
|
|
|
|
if (divisor == 0.0f) {
|
|
return 0.0f;
|
|
}
|
|
|
|
return dot_product / divisor;
|
|
}
|
|
|
|
f32 clamp(f32 value, f32 min, f32 max) {
|
|
if (value < min) {
|
|
return min;
|
|
}
|
|
|
|
if (value > max) {
|
|
return max;
|
|
}
|
|
|
|
return value;
|
|
}
|