Adjust camera to focus at target

.gitattributes

@@ -1 +0,0 @@
-demo.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,4 +1,2 @@
 build/
 *.ff
-*.png
-!demo.png

CMakeLists.txt

@@ -20,10 +20,8 @@ add_library(batomorph
 configure_target(batomorph)
 target_include_directories(batomorph PUBLIC include)
 
-add_executable(demo demo.c)
+add_executable(demo
+  demo.c
+)
 configure_target(demo)
 target_link_libraries(demo PRIVATE batomorph m)
-
-add_executable(rand rand.c)
-configure_target(rand)
-target_link_libraries(rand PRIVATE batomorph m)

README.md

@@ -1,32 +0,0 @@
-# Batomorph
-
-Batomorph is a simple ray tracer, written in C23 for POSIX systems.
-
-![Demo rendering](demo.png)
-
-To build with CMake (there are no dependencies):
-
-```sh
-cmake -B build
-cmake --build build
-```
-
-You may want to adjust the `NTHREADS` definition in `src/render.c` to
-match your system.
-
-The demo programs (`build/demo` and `build/rand`) will write the
-rendered image in sRGB
-[Farbfeld](https://tools.suckless.org/farbfeld/) to `stdout`:
-
-```sh
-build/demo > out.ff           # Produce Farbfeld file
-build/demo | ff2png > out.png # Produce PNG file
-build/demo | feh              # View directly
-```
-
-(Note that `ff2png` and `feh` are third-party programs)
-
-## License
-
-Batomorph is Copyright © Camden Dixie O'Brien, and is available under
-the Komorebi 2.0.0 license.  See [LICENSE.md](LICENSE.md) for details.

demo.c

@@ -3,51 +3,71 @@
 
 #include <unistd.h>
 
-#define W 1920
+#define W 800
-#define H 1080
+#define H 600
+
+#define OBJ_COUNT 32
+
+#define MAX_DIST 100.0
+#define MAX_RAD 10.0
+#define MIN_RAD 1.0
 
 #define FOV 90
-#define APERTURE 0.8
+#define SAMPLES_PER_PIXEL 100
-#define FOCAL_LEN -1
-#define SAMPLES_PER_PIXEL 1000
 
-#define NELEMS(arr) (sizeof(arr) / sizeof(arr[0]))
+static const vec3_t camera_pos = { -100.0, 25.0, -100.0 };
+static const vec3_t target = { 0.0, 0.0, 0.0 };
 
-static const vec3_t camera_pos = { 80.0, 20.0, 60.0 };
+static const vec3_t sky = { 0.6, 0.7, 1.0 };
-static const vec3_t target = { 0.0, 0.0, 10.0 };
-
-static const vec3_t sky_pos = { 0.4, 0.7, 1.0 };
-static const vec3_t sky_neg = { 1.0, 1.0, 1.0 };
 
 static const material_t floor = LAMBERTIAN(1.0, 0.94, 0.80);
-static const material_t light = AREA_LIGHT(1.0, 0.8, 0.5, 3.0);
-static const material_t white = LAMBERTIAN(1.0, 1.0, 1.0);
 static const material_t gold = REFLECTIVE(1.0, 0.9, 0.5, 0.0);
 static const material_t silver = REFLECTIVE(0.9, 0.9, 0.9, 0.0);
+static const material_t bronze = REFLECTIVE(0.9, 0.7, 0.5, 0.0);
 static const material_t glass = DIELECTRIC(1.5);
 
-static obj_t objs[] = {
+static const material_t metals[] = { gold, silver, bronze };
-	SPHERE(0.0, -100'000.0, 0.0, 100'000.0, floor),
+
-	SPHERE(-3000.0, 3000.0, -2000.0, 1000.0, light),
+static obj_t objs[OBJ_COUNT] = {
-	SPHERE(0.0, 10.0, -33.0, 10.0, gold),
+	[0] = SPHERE(0.0, -100000.0, 0.0, 100000.0, floor),
-	SPHERE(0.0, 10.0, -11.0, 10.0, glass),
-	SPHERE(0.0, 10.0, 11.0, 10.0, silver),
-	SPHERE(0.0, 10.0, 33.0, 10.0, white),
 };
 
 static pix_t pixbuf[W * H];
 
+static void rand_obj(obj_t *out, rng_t *rng)
+{
+	material_t material;
+	const uint32_t rand = rng_uint32(rng);
+	if (rand % 2 == 0) {
+		const double r = rng_canon(rng);
+		const double g = rng_canon(rng);
+		const double b = rng_canon(rng);
+		material = (material_t)LAMBERTIAN(r, g, b);
+	} else if (rand % 3 == 0) {
+		material = glass;
+	} else {
+		material = metals[rng_uint32(rng) % 3];
+	}
+
+	const double r = MIN_RAD + (MAX_RAD - MIN_RAD) * rng_canon(rng);
+	const double x = MAX_DIST * rng_disc(rng);
+	const double z = MAX_DIST * rng_disc(rng);
+	*out = (obj_t)SPHERE(x, r, z, r, material);
+}
+
 int main()
 {
+	rng_t rng = rng_init(0);
+	for (int i = 1; i < OBJ_COUNT; ++i)
+		rand_obj(objs + i, &rng);
+
 	img_t img = { .pix = pixbuf };
-	camera_t camera
+	camera_t camera = camera_init(camera_pos, target, FOV, W, H);
-	    = camera_init(camera_pos, target, FOV, W, H, APERTURE, FOCAL_LEN);
 
 	const scene_t scene = {
-		.sky_pos = sky_pos,
+		.sky_colour = sky,
-		.sky_neg = sky_neg,
 		.objs = objs,
-		.obj_count = NELEMS(objs),
+		.obj_count = OBJ_COUNT,
 	};
 	render(&camera, &scene, &img, SAMPLES_PER_PIXEL);
 

include/camera.h

@@ -8,13 +8,11 @@
 typedef struct {
 	vec3_t pos;
 	vec3_t pix_origin, x_step, y_step;
-	vec3_t u_hat, v_hat;
 	uint32_t img_width, img_height;
-	double aperture;
 } camera_t;
 
 camera_t camera_init(
     vec3_t pos, vec3_t target, double fov, uint32_t img_width,
-    uint32_t img_height, double aperture, double focal_len);
+    uint32_t img_height);
 
 #endif

include/material.h

@@ -22,14 +22,6 @@
 		.params = { .dielectric = { .eta = e } }, \
 	}
 
-#define AREA_LIGHT(r, g, b, l) \
-	{ \
-		.scatter = scatter_area_light, \
-		.params = { \
-			.area_light = { .colour = { r, g, b }, .luminosity = l }, \
-		}, \
-	}
-
 typedef struct {
 	vec3_t point, normal;
 	double t;
@@ -49,16 +41,10 @@ typedef struct {
 	double eta;
 } dielectric_params_t;
 
-typedef struct {
-	vec3_t colour;
-	double luminosity;
-} area_light_params_t;
-
 typedef union {
 	lambertian_params_t lambertian;
 	reflective_params_t reflective;
 	dielectric_params_t dielectric;
-	area_light_params_t area_light;
 } material_params_t;
 
 typedef bool scatter_fn_t(
@@ -79,8 +65,5 @@ bool scatter_reflective(
 bool scatter_dielectric(
     material_params_t params, hit_t hit, rng_t *rng, ray_t *ray,
     vec3_t *atten_out);
-bool scatter_area_light(
-    material_params_t params, hit_t hit, rng_t *rng, ray_t *ray,
-    vec3_t *atten_out);
 
 #endif

include/rng.h

@@ -12,9 +12,8 @@ typedef struct {
 rng_t rng_init(unsigned seed);
 uint32_t rng_uint32(rng_t *rng);
 double rng_canon(rng_t *rng);
-double rng_plusminus(rng_t *rng);
+double rng_disc(rng_t *rng);
 vec3_t rng_vec3(rng_t *rng);
-vec3_t rng_xy(rng_t *rng);
 vec3_t rng_gaussian_xy(rng_t *rng, double stddev);
 
 #endif

include/scene.h

@@ -4,7 +4,7 @@
 #include "obj.h"
 
 typedef struct {
-	vec3_t sky_pos, sky_neg;
+	vec3_t sky_colour;
 	obj_t *objs;
 	unsigned obj_count;
 } scene_t;

rand.c

@@ -1,86 +0,0 @@
-#include "ff.h"
-#include "render.h"
-
-#include <unistd.h>
-
-#define W 1280
-#define H 720
-
-#define OBJ_COUNT 32
-
-#define MAX_DIST 100.0
-#define MAX_RAD 10.0
-#define MIN_RAD 1.0
-
-#define FOV 90
-#define APERTURE 0.8
-#define FOCAL_LEN 100
-#define SAMPLES_PER_PIXEL 100
-
-#define NELEMS(arr) (sizeof(arr) / sizeof(arr[0]))
-
-static const vec3_t camera_pos = { -100.0, 30.0, -100.0 };
-static const vec3_t target = { 0.0, 0.0, 0.0 };
-
-static const vec3_t sky_pos = { 0.6, 0.8, 1.0 };
-static const vec3_t sky_neg = { 1.0, 1.0, 1.0 };
-
-static const material_t floor = LAMBERTIAN(1.0, 0.94, 0.80);
-static const material_t light = AREA_LIGHT(1.0, 0.8, 0.1, 4.0);
-static const material_t gold = REFLECTIVE(1.0, 0.9, 0.5, 0.0);
-static const material_t silver = REFLECTIVE(0.9, 0.9, 0.9, 0.0);
-static const material_t bronze = REFLECTIVE(0.9, 0.7, 0.5, 0.0);
-static const material_t glass = DIELECTRIC(1.5);
-
-static const material_t metals[] = { gold, gold, silver, silver, bronze };
-
-static obj_t objs[OBJ_COUNT] = {
-	SPHERE(0.0, -100'000.0, 0.0, 100'000.0, floor),
-	SPHERE(-3000.0, 3000.0, -2000.0, 1000.0, light),
-};
-
-static pix_t pixbuf[W * H];
-
-static void rand_obj(obj_t *out, rng_t *rng)
-{
-	material_t material;
-	const double rand = rng_canon(rng);
-	if (rand < 0.75) {
-		const double r = rng_canon(rng);
-		const double g = rng_canon(rng);
-		const double b = rng_canon(rng);
-		material = (material_t)LAMBERTIAN(r, g, b);
-	} else if (rand < 0.925) {
-		material = glass;
-	} else {
-		material = metals[rng_uint32(rng) % NELEMS(metals)];
-	}
-
-	const double r = MIN_RAD + (MAX_RAD - MIN_RAD) * rng_canon(rng);
-	const double x = MAX_DIST * rng_plusminus(rng);
-	const double z = MAX_DIST * rng_plusminus(rng);
-	*out = (obj_t)SPHERE(x, r, z, r, material);
-}
-
-int main()
-{
-	rng_t rng = rng_init(0);
-	for (int i = 2; i < OBJ_COUNT; ++i)
-		rand_obj(objs + i, &rng);
-
-	img_t img = { .pix = pixbuf };
-	camera_t camera
-	    = camera_init(camera_pos, target, FOV, W, H, APERTURE, FOCAL_LEN);
-
-	const scene_t scene = {
-		.sky_pos = sky_pos,
-		.sky_neg = sky_neg,
-		.objs = objs,
-		.obj_count = OBJ_COUNT,
-	};
-	render(&camera, &scene, &img, SAMPLES_PER_PIXEL);
-
-	ff_write(STDOUT_FILENO, img);
-
-	return 0;
-}

src/camera.c

@@ -10,10 +10,10 @@ static const vec3_t up = { 0.0, 1.0, 0.0 };
 
 camera_t camera_init(
     vec3_t pos, vec3_t target, double fov, uint32_t img_width,
-    uint32_t img_height, double aperture, double focal_len)
+    uint32_t img_height)
 {
-	if (focal_len = -1)
+	const vec3_t target_disp = vec3_sub(target, pos);
-		focal_len = vec3_len(vec3_sub(target, pos));
+	const double focal_len = vec3_len(target_disp);
 
 	const double fov_rad = M_PI * fov / 180.0;
 	const double aspect = (double)img_width / (double)img_height;
@@ -27,9 +27,7 @@ camera_t camera_init(
 	const vec3_t u = vec3_scale(u_hat, viewport_width);
 	const vec3_t v = vec3_scale(v_hat, -viewport_height);
 
-	const vec3_t topleft = vec3_sub(
+	const vec3_t topleft = vec3_sub(target, vec3_scale(vec3_add(u, v), 0.5));
-	    vec3_add(pos, vec3_scale(w_hat, focal_len)),
-	    vec3_scale(vec3_add(u, v), 0.5));
 
 	const vec3_t x_step = vec3_scale(u, 1.0 / (double)img_width);
 	const vec3_t y_step = vec3_scale(v, 1.0 / (double)img_height);
@@ -41,10 +39,7 @@ camera_t camera_init(
 		.pix_origin = pix_origin,
 		.x_step = x_step,
 		.y_step = y_step,
-		.u_hat = u_hat,
-		.v_hat = v_hat,
 		.img_width = img_width,
 		.img_height = img_height,
-		.aperture = aperture,
 	};
 }

src/material.c

@@ -68,16 +68,3 @@ bool scatter_dielectric(
 
 	return true;
 }
-
-bool scatter_area_light(
-    material_params_t params, hit_t hit, rng_t *rng, ray_t *ray,
-    vec3_t *atten_out)
-{
-	(void)hit;
-	(void)rng;
-	(void)ray;
-
-	*atten_out
-	    = vec3_scale(params.area_light.colour, params.area_light.luminosity);
-	return false;
-}

src/render.c

@@ -45,17 +45,14 @@ static vec3_t trace(ray_t ray, const scene_t *scene, rng_t *rng)
 		if (hit.t == DBL_MAX) {
 			const double a = (ray.dir.y + 1.0) / 2.0;
 			const vec3_t bg = vec3_add(
-			    vec3_scale(scene->sky_pos, a),
+			    vec3_scale(scene->sky_colour, a), vec3_scale(white, 1 - a));
-			    vec3_scale(scene->sky_neg, 1 - a));
 			return vec3_hadamard(colour, bg);
 		}
 
 		vec3_t atten;
-		const bool scattered
+		if (!material.scatter(material.params, hit, rng, &ray, &atten))
-		    = material.scatter(material.params, hit, rng, &ray, &atten);
+			return black;
 		colour = vec3_hadamard(colour, atten);
-		if (!scattered)
-			return colour;
 	}
 
 	return black;
@@ -97,19 +94,9 @@ static int render_thread(void *arg)
 				    vec3_scale(camera->y_step, jitter.y));
 				const vec3_t jittered_pix = vec3_add(pix, offset);
 
-				vec3_t source = camera->pos;
-				if (camera->aperture != 0.0) {
-					const vec3_t pos
-					    = vec3_scale(rng_xy(&slice->rng), camera->aperture);
-					const vec3_t offset = vec3_add(
-					    vec3_scale(camera->u_hat, pos.x),
-					    vec3_scale(camera->v_hat, pos.y));
-					source = vec3_add(source, offset);
-				}
-
 				const ray_t ray = {
-					.orig = source,
+					.orig = camera->pos,
-					.dir = vec3_unit(vec3_sub(jittered_pix, source)),
+					.dir = vec3_unit(vec3_sub(jittered_pix, camera->pos)),
 				};
 				const vec3_t sample = trace(ray, slice->scene, &slice->rng);
 

src/rng.c

@@ -30,25 +30,17 @@ double rng_canon(rng_t *rng)
 	return (double)rng_uint32(rng) / (double)UINT32_MAX;
 }
 
-double rng_plusminus(rng_t *rng)
+double rng_disc(rng_t *rng)
 {
 	return 2.0 * rng_canon(rng) - 1.0;
 }
 
 vec3_t rng_vec3(rng_t *rng)
 {
-	const vec3_t v
+	const vec3_t v = { rng_disc(rng), rng_disc(rng), rng_disc(rng) };
-	    = { rng_plusminus(rng), rng_plusminus(rng), rng_plusminus(rng) };
 	return vec3_unit(v);
 }
 
-vec3_t rng_xy(rng_t *rng)
-{
-	const double theta = 2.0 * M_PI * rng_canon(rng);
-	const double mag = rng_canon(rng);
-	return (vec3_t) { .x = mag * cos(theta), .y = mag * sin(theta) };
-}
-
 vec3_t rng_gaussian_xy(rng_t *rng, double stddev)
 {
 	const double r1 = rng_canon(rng);