adrien/zig-multi-thread-raytracer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

End of tuto

Browse Source
This commit is contained in:
Adrien Bouvais 2024-08-21 13:40:52 +02:00
commit 1f5e37de40
9 changed files with 928 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored Normal file
View File

@ -0,0 +1,4 @@
.zig-cache
zig-out
*.png
*.ppm

66
build.zig Normal file
View File

@ -0,0 +1,66 @@
const std = @import("std");
// Although this function looks imperative, note that its job is to
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.Build) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for restricting supported target set are available.
const target = b.standardTargetOptions(.{});
// Standard optimization options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
// set a preferred release mode, allowing the user to decide how to optimize.
const optimize = b.standardOptimizeOption(.{});
const exe = b.addExecutable(.{
.name = "thermal",
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize,
});
// This declares intent for the executable to be installed into the
// standard location when the user invokes the "install" step (the default
// step when running `zig build`).
b.installArtifact(exe);
// This *creates* a Run step in the build graph, to be executed when another
// step is evaluated that depends on it. The next line below will establish
// such a dependency.
const run_cmd = b.addRunArtifact(exe);
// By making the run step depend on the install step, it will be run from the
// installation directory rather than directly from within the cache directory.
// This is not necessary, however, if the application depends on other installed
// files, this ensures they will be present and in the expected location.
run_cmd.step.dependOn(b.getInstallStep());
// This allows the user to pass arguments to the application in the build
// command itself, like this: `zig build run -- arg1 arg2 etc`
if (b.args) |args| {
run_cmd.addArgs(args);
}
// This creates a build step. It will be visible in the `zig build --help` menu,
// and can be selected like this: `zig build run`
// This will evaluate the `run` step rather than the default, which is "install".
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
const exe_unit_tests = b.addTest(.{
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize,
});
const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
// Similar to creating the run step earlier, this exposes a `test` step to
// the `zig build --help` menu, providing a way for the user to request
// running the unit tests.
const test_step = b.step("test", "Run unit tests");
test_step.dependOn(&run_exe_unit_tests.step);
}

72
build.zig.zon Normal file
View File

@ -0,0 +1,72 @@
.{
// This is the default name used by packages depending on this one. For
// example, when a user runs `zig fetch --save <url>`, this field is used
// as the key in the `dependencies` table. Although the user can choose a
// different name, most users will stick with this provided value.
//
// It is redundant to include "zig" in this name because it is already
// within the Zig package namespace.
.name = "thermal",
// This is a [Semantic Version](https://semver.org/).
// In a future version of Zig it will be used for package deduplication.
.version = "0.0.0",
// This field is optional.
// This is currently advisory only; Zig does not yet do anything
// with this value.
//.minimum_zig_version = "0.11.0",
// This field is optional.
// Each dependency must either provide a `url` and `hash`, or a `path`.
// `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
// Once all dependencies are fetched, `zig build` no longer requires
// internet connectivity.
.dependencies = .{
// See `zig fetch --save <url>` for a command-line interface for adding dependencies.
//.example = .{
// // When updating this field to a new URL, be sure to delete the corresponding
// // `hash`, otherwise you are communicating that you expect to find the old hash at
// // the new URL.
// .url = "https://example.com/foo.tar.gz",
//
// // This is computed from the file contents of the directory of files that is
// // obtained after fetching `url` and applying the inclusion rules given by
// // `paths`.
// //
// // This field is the source of truth; packages do not come from a `url`; they
// // come from a `hash`. `url` is just one of many possible mirrors for how to
// // obtain a package matching this `hash`.
// //
// // Uses the [multihash](https://multiformats.io/multihash/) format.
// .hash = "...",
//
// // When this is provided, the package is found in a directory relative to the
// // build root. In this case the package's hash is irrelevant and therefore not
// // computed. This field and `url` are mutually exclusive.
// .path = "foo",
// // When this is set to `true`, a package is declared to be lazily
// // fetched. This makes the dependency only get fetched if it is
// // actually used.
// .lazy = false,
//},
},
// Specifies the set of files and directories that are included in this package.
// Only files and directories listed here are included in the `hash` that
// is computed for this package. Only files listed here will remain on disk
// when using the zig package manager. As a rule of thumb, one should list
// files required for compilation plus any license(s).
// Paths are relative to the build root. Use the empty string (`""`) to refer to
// the build root itself.
// A directory listed here means that all files within, recursively, are included.
.paths = .{
"build.zig",
"build.zig.zon",
"src",
// For example...
//"LICENSE",
//"README.md",
},
}

223
src/camera.zig Normal file
View File

@ -0,0 +1,223 @@
const std = @import("std");
const print = std.debug.print;
const math = std.math;
const vec3 = @Vector(3, f64);
const Ray = @import("hittable.zig").Ray;
const utils = @import("utils.zig");
const toVec3 = utils.toVec3;
const Interval = utils.Interval;
const hit = @import("hittable.zig");
const HittableList = hit.HittableList;
const HitRecord = hit.HitRecord;
const mat_math = @import("mat_math.zig");
const unit_vector = mat_math.unit_vector;
const length = mat_math.length;
const cross = mat_math.cross;
pub const Camera = struct {
aspect_ratio: f64,
image_width: i64,
samples_per_pixel: i64,
max_depth: i64,
vfov: f64,
defocus_angle: f64,
focus_dist: f64,
image_height: i64,
center: vec3,
pixel_samples_scale: f64,
pixel00_loc: vec3,
pixel_delta_u: vec3,
pixel_delta_v: vec3,
defocus_disk_u: vec3,
defocus_disk_v: vec3,
u: vec3,
v: vec3,
w: vec3,
pub fn new() Camera {
const aspect_ratio: f64 = 16.0 / 9.0;
const image_width: i64 = 512; // Possible 128, 256, 512, 1024, 1280, 1920, 2560, 3840, 7680
const samples_per_pixel = 50;
const max_depth = 10;
const vfov = 20;
const lookfrom = vec3{ 13, 2, 3 };
const lookat = vec3{ 0, 0, 0 };
const vup = vec3{ 0, 1, 0 };
const defocus_angle = 0.6;
const focus_dist = 10;
const camera_center = lookfrom;
const image_height: i64 = image_width / aspect_ratio;
const pixel_samples_scale = 1.0 / @as(f64, @floatFromInt(samples_per_pixel));
// Camera
const theta = utils.degrees_to_radians(vfov);
const h = @tan(theta / 2);
const viewport_height: f64 = 2.0 * h * focus_dist;
const viewport_width: f64 = viewport_height * aspect_ratio;
const w = unit_vector(lookfrom - lookat);
const u = unit_vector(cross(vup, w));
const v = cross(w, u);
const viewport_u = toVec3(viewport_width) * u;
const viewport_v = toVec3(viewport_height) * -v;
const pixel_delta_u = viewport_u / toVec3(image_width);
const pixel_delta_v = viewport_v / toVec3(image_height);
const viewport_upper_left = camera_center - toVec3(focus_dist) * w - viewport_u / toVec3(2) - viewport_v / toVec3(2);
const pixel00_loc = viewport_upper_left + toVec3(0.5) * (pixel_delta_u + pixel_delta_v);
const defocus_radius = focus_dist * @tan(utils.degrees_to_radians(defocus_angle / 2));
const defocus_disk_u = u * toVec3(defocus_radius);
const defocus_disk_v = v * toVec3(defocus_radius);
return Camera{
.aspect_ratio = aspect_ratio,
.image_width = image_width,
.samples_per_pixel = samples_per_pixel,
.max_depth = max_depth,
.vfov = vfov,
.focus_dist = focus_dist,
.defocus_angle = defocus_angle,
.u = u,
.v = v,
.w = w,
.defocus_disk_v = defocus_disk_v,
.defocus_disk_u = defocus_disk_u,
.image_height = image_height,
.center = camera_center,
.pixel_samples_scale = pixel_samples_scale,
.pixel00_loc = pixel00_loc,
.pixel_delta_u = pixel_delta_u,
.pixel_delta_v = pixel_delta_v,
};
}
pub fn render(self: Camera, world: HittableList, writer: anytype) !void {
// Write the PPM header
try writer.print("P3\n{} {}\n255\n", .{ self.image_width, self.image_height });
// Write the pixel data
for (0..@as(usize, @intCast(self.image_height))) |i| {
const h = @as(i64, @intCast(i));
pbar(h, self.image_height);
for (0..@as(usize, @intCast(self.image_width))) |j| {
const w = @as(i64, @intCast(j));
var pixel_color = vec3{ 0, 0, 0 };
for (0..@as(usize, @intCast(self.samples_per_pixel))) |_| {
const r = self.get_ray(h, w);
pixel_color += ray_color(r, self.max_depth, world);
}
try writeColor(pixel_color * toVec3(self.pixel_samples_scale), writer);
}
}
}
fn get_ray(self: Camera, h: i64, w: i64) Ray {
// Construct a camera ray originating from the origin and directed at randomly sampled
// point around the pixel location i, j.
const offset = sample_square();
const pixel_sample = self.pixel00_loc +
(toVec3((@as(f64, @floatFromInt(h))) + offset[0]) * self.pixel_delta_v) +
(toVec3((@as(f64, @floatFromInt(w))) + offset[1]) * self.pixel_delta_u);
const ray_origin = if (self.defocus_angle <= 0) self.center else self.defocus_disk_sample();
const ray_direction = pixel_sample - ray_origin;
return Ray{ .orig = ray_origin, .dir = ray_direction };
}
fn defocus_disk_sample(self: Camera) vec3 {
const p = random_in_unit_disk();
return self.center + (toVec3(p[0]) * self.defocus_disk_u) + (toVec3(p[1]) * self.defocus_disk_v);
}
};
fn random_in_unit_disk() vec3 {
while (true) {
const p = vec3{ utils.rand_mm(-1, 1), utils.rand_mm(-1, 1), 0 };
if (mat_math.length_squared(p) < 1)
return p;
}
}
fn ray_color(ray: Ray, depth: i64, world: HittableList) vec3 {
if (depth <= 0) {
return vec3{ 0, 0, 0 };
}
var rec = HitRecord.new();
if (world.hit(ray, Interval{ .min = 0.001, .max = math.inf(f64) }, &rec)) {
var ray_scattered = Ray{ .orig = vec3{ 0, 0, 0 }, .dir = vec3{ 0, 0, 0 } };
var attenuation = vec3{ 0, 0, 0 };
if (rec.material.scatter(ray, &rec, &attenuation, &ray_scattered)) {
return attenuation * ray_color(ray_scattered, depth - 1, world);
}
return vec3{ 0, 0, 0 };
}
const unit_direction = unit_vector(ray.dir);
const a = 0.5 * (unit_direction[1] + 1.0);
return toVec3(1.0 - a) * toVec3(1.0) + toVec3(a) * vec3{ 0.5, 0.7, 1.0 };
}
fn sample_square() vec3 {
return vec3{ utils.rand_01() - 0.5, utils.rand_01() - 0.5, 0 };
}
fn writeColor(color: vec3, writer: anytype) !void {
var r_float = color[0];
var g_float = color[1];
var b_float = color[2];
r_float = utils.linear_to_gamma(r_float);
g_float = utils.linear_to_gamma(g_float);
b_float = utils.linear_to_gamma(b_float);
const intensity = Interval{ .min = 0, .max = 0.99 };
const r: u8 = @intFromFloat(256 * intensity.clamp(r_float));
const g: u8 = @intFromFloat(256 * intensity.clamp(g_float));
const b: u8 = @intFromFloat(256 * intensity.clamp(b_float));
try writer.print("{} {} {}\n", .{ r, g, b });
}
fn pbar(value: i64, max: i64) void {
const used_char = "-";
const number_of_char = 60;
const percent_done: i64 = if (value == max - 1) 100 else @divFloor(value * 100, max);
const full_char: i64 = @divFloor(number_of_char * percent_done, 100);
print("\r|", .{});
var i: usize = 0;
while (i < number_of_char) : (i += 1) {
if (i < full_char) {
print("{s}", .{used_char});
} else {
print(" ", .{});
}
}
print("| {}%", .{percent_done});
if (percent_done == 100) {
print("\n", .{});
}
}

107
src/hittable.zig Normal file
View File

@ -0,0 +1,107 @@
const std = @import("std");
const vec3 = @Vector(3, f64);
const utils = @import("utils.zig");
const Interval = utils.Interval;
const toVec3 = utils.toVec3;
const mat_math = @import("mat_math.zig");
const dot = mat_math.dot;
const set_face_normal = mat_math.set_face_normal;
const material_import = @import("material.zig");
const Material = material_import.Material;
const Metal = material_import.Metal;
pub const Ray = struct {
orig: vec3,
dir: vec3,
};
pub const Hittable = union(enum) {
sphere: Sphere,
//cube: Cube,
pub fn hit(self: *const Hittable, ray: Ray, interval: Interval, rec: *HitRecord) bool {
return switch (self.*) {
.sphere => |*s| s.hit(ray, interval, rec),
//.cube => |*c| c.hit(),
};
}
};
pub const HittableList = struct {
list: []const Hittable,
pub fn hit(self: *const HittableList, ray: Ray, ray_t: Interval, rec: *HitRecord) bool {
var temp_rec: HitRecord = HitRecord.new();
var hit_anything = false;
var closest_so_far = ray_t.max;
for (self.list) |obj| {
if (obj.hit(ray, Interval{ .min = ray_t.min, .max = closest_so_far }, &temp_rec)) {
hit_anything = true;
closest_so_far = temp_rec.t;
rec.* = temp_rec;
}
}
return hit_anything;
}
};
pub const HitRecord = struct {
p: vec3,
normal: vec3,
material: Material,
t: f64,
front_face: bool,
pub fn new() HitRecord {
return HitRecord{
.p = vec3{ 0, 0, 0 },
.normal = vec3{ 0, 0, 0 },
.material = Material{ .metal = Metal{ .albedo = vec3{ 0, 0, 0 }, .fuzz = 1.0 } },
.t = 0,
.front_face = false,
};
}
};
pub const Sphere = struct {
center: vec3,
radius: f64,
material: Material,
pub fn hit(self: Sphere, ray: Ray, ray_t: Interval, rec: *HitRecord) bool {
const oc = self.center - ray.orig;
const a = dot(ray.dir, ray.dir);
const h = dot(ray.dir, oc);
const c = dot(oc, oc) - self.radius * self.radius;
const discriminant = h * h - a * c;
if (discriminant < 0) {
return false;
}
const sqrtd = @sqrt(discriminant);
// Find the nearest root that lies in the acceptable range.
const root = (h - sqrtd) / a;
if (!ray_t.surrounds(root)) {
return false;
}
rec.t = root;
rec.p = at(ray, rec.t);
rec.normal = (rec.p - self.center) / toVec3(self.radius);
const outward_normal = (rec.p - self.center) / toVec3(self.radius);
set_face_normal(rec, ray, outward_normal);
rec.material = self.material;
return true;
}
};
fn at(ray: Ray, t: f64) vec3 {
return ray.orig + toVec3(t) * ray.dir;
}

176
src/main.zig Normal file
View File

@ -0,0 +1,176 @@
const std = @import("std");
const print = std.debug.print;
const math = std.math;
const vec3 = @Vector(3, f64);
const utils = @import("utils.zig");
const Interval = utils.Interval;
const toVec3 = utils.toVec3;
const hit = @import("hittable.zig");
const Sphere = hit.Sphere;
const Hittable = hit.Hittable;
const HittableList = hit.HittableList;
const HitRecord = hit.HitRecord;
const Ray = hit.Ray;
const mat_math = @import("mat_math.zig");
const unit_vector = mat_math.unit_vector;
const length = mat_math.length;
const cam = @import("camera.zig");
const Camera = cam.Camera;
const mat_import = @import("material.zig");
const Material = mat_import.Material;
const Lambertian = mat_import.Lambertian;
const Metal = mat_import.Metal;
const Dielectric = mat_import.Dielectric;
pub fn main() !void {
const file = try std.fs.cwd().createFile("image.ppm", .{});
defer file.close();
var buffered_writer = std.io.bufferedWriter(file.writer());
const writer = buffered_writer.writer();
const camera = Camera.new();
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const alloc = arena.allocator();
const world = try generateRandomScene(alloc);
const start_time: i64 = std.time.milliTimestamp();
try camera.render(world, &writer);
const end_time: i64 = std.time.milliTimestamp();
const total_time: f64 = @as(f64, @floatFromInt(end_time - start_time)) / 1000;
print("Rendering took {} s\n", .{total_time});
print("Potential FPS: {}\n", .{1 / total_time});
// Flush the buffered writer to ensure all data is written to the file
try buffered_writer.flush();
try run_convert_image();
try run_open_image();
}
pub fn run_convert_image() !void {
const exec_result = try std.process.Child.run(.{
.allocator = std.heap.page_allocator,
.argv = &[_][]const u8{
"convert",
"image.ppm",
"image.png",
},
});
switch (exec_result.term) {
.Exited => |code| {
if (code != 0) {
std.debug.print("Convert image: Command exited with non-zero status code: {}\n", .{code});
}
},
else => {
std.debug.print("Convert image: Command did not exit normally\n", .{});
},
}
}
pub fn run_open_image() !void {
const exec_result = try std.process.Child.run(.{
.allocator = std.heap.page_allocator,
.argv = &[_][]const u8{
"explorer.exe",
"image.png",
},
});
switch (exec_result.term) {
.Exited => |code| {
if (code != 0) {
std.debug.print("Open image: Command exited with non-zero status code: {}\n", .{code});
}
},
else => {
std.debug.print("Open image: Command did not exit normally\n", .{});
},
}
}
pub fn generateRandomScene(alloc: std.mem.Allocator) !HittableList {
var spheres = std.ArrayList(Hittable).init(alloc);
// Ground sphere
try spheres.append(.{
.sphere = Sphere{
.center = vec3{ 0, -1000, 0 },
.radius = 1000,
.material = Material{ .lambertian = Lambertian{ .albedo = vec3{ 0.5, 0.5, 0.5 } } },
},
});
// Smaller spheres
var a: i32 = -11;
while (a < 11) : (a += 1) {
var b: i32 = -11;
while (b < 11) : (b += 1) {
const choose_mat = utils.rand_01();
const center = vec3{
@as(f64, @floatFromInt(a)) + 0.9 * utils.rand_01(),
0.2,
@as(f64, @floatFromInt(b)) + 0.9 * utils.rand_01(),
};
var sphere_material: Material = undefined;
if (choose_mat < 0.5) {
// diffuse
const albedo = utils.rand_vec3_01();
sphere_material = Material{ .lambertian = Lambertian{ .albedo = albedo } };
} else if (choose_mat < 0.8) {
// metal
const albedo = utils.rand_vec3_01();
const fuzz = utils.rand_01() * 0.5;
sphere_material = Material{ .metal = Metal{ .albedo = albedo, .fuzz = fuzz } };
} else {
// glass
sphere_material = Material{ .dielectric = Dielectric{ .refraction_index = 1.5 } };
}
try spheres.append(.{
.sphere = Sphere{
.center = center,
.radius = 0.2,
.material = sphere_material,
},
});
}
}
// Three large spheres
try spheres.append(.{
.sphere = Sphere{
.center = vec3{ 0, 1, 0 },
.radius = 1.0,
.material = Material{ .dielectric = Dielectric{ .refraction_index = 1.5 } },
},
});
try spheres.append(.{
.sphere = Sphere{
.center = vec3{ -4, 1, 0 },
.radius = 1.0,
.material = Material{ .lambertian = Lambertian{ .albedo = vec3{ 0.4, 0.2, 0.1 } } },
},
});
try spheres.append(.{
.sphere = Sphere{
.center = vec3{ 4, 1, 0 },
.radius = 1.0,
.material = Material{ .metal = Metal{ .albedo = vec3{ 0.7, 0.6, 0.5 }, .fuzz = 0.0 } },
},
});
// Convert ArrayList to a slice and create HittableList
return HittableList{ .list = spheres.items };
}

66
src/mat_math.zig Normal file
View File

@ -0,0 +1,66 @@
const vec3 = @Vector(3, f64);
const std = @import("std");
const math = std.math;
const utils = @import("utils.zig");
const toVec3 = utils.toVec3;
const hit = @import("hittable.zig");
const HitRecord = hit.HitRecord;
const Ray = hit.Ray;
pub fn dot(u: vec3, v: vec3) f64 {
return u[0] * v[0] + u[1] * v[1] + u[2] * v[2];
}
pub fn length(v: vec3) f64 {
return math.sqrt(math.pow(f64, v[0], 2) + math.pow(f64, v[1], 2) + math.pow(f64, v[2], 2));
}
pub fn length_squared(v: vec3) f64 {
return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
}
pub fn unit_vector(v: vec3) vec3 {
return v / toVec3(length(v));
}
pub fn random_in_unit_sphere() vec3 {
while (true) {
const p = utils.rand_vec3_mm(-1, 1);
if (length_squared(p) < 1.0) {
return p;
}
}
}
pub fn random_on_hemisphere(normal: vec3) vec3 {
const on_unit_sphere = random_unit_vector();
if (dot(on_unit_sphere, normal) > 0.0) {
return on_unit_sphere;
} else {
return -on_unit_sphere;
}
}
pub fn random_unit_vector() vec3 {
return unit_vector(random_in_unit_sphere());
}
pub fn set_face_normal(rec: *HitRecord, ray: Ray, outward_normal: vec3) void {
rec.front_face = dot(ray.dir, outward_normal) < 0;
rec.normal = if (rec.front_face) outward_normal else -outward_normal;
}
pub fn near_zero(v: vec3) bool {
const s = 1e-8;
return ((@abs(v[0]) < s) and (@abs(v[1]) < s) and (@abs(v[2]) < s));
}
pub fn cross(u: vec3, v: vec3) vec3 {
return vec3{
u[1] * v[2] - u[2] * v[1],
u[2] * v[0] - u[0] * v[2],
u[0] * v[1] - u[1] * v[0],
};
}

111
src/material.zig Normal file
View File

@ -0,0 +1,111 @@
const vec3 = @Vector(3, f64);
const utils = @import("utils.zig");
const Interval = utils.Interval;
const toVec3 = utils.toVec3;
const hit = @import("hittable.zig");
const Sphere = hit.Sphere;
const Hittable = hit.Hittable;
const HittableList = hit.HittableList;
const HitRecord = hit.HitRecord;
const Ray = hit.Ray;
const mat_math = @import("mat_math.zig");
const near_zero = mat_math.near_zero;
const unit_vector = mat_math.unit_vector;
const random_unit_vector = mat_math.random_unit_vector;
const dot = mat_math.dot;
const length_squared = mat_math.length_squared;
const math = @import("std").math;
// Mother struct
pub const Material = union(enum) {
lambertian: Lambertian,
metal: Metal,
dielectric: Dielectric,
pub fn scatter(self: *const Material, ray_in: Ray, rec: *HitRecord, attenuation: *vec3, ray_scattered: *Ray) bool {
return switch (self.*) {
.lambertian => |s| s.scatter(rec, attenuation, ray_scattered),
.metal => |s| s.scatter(ray_in, rec, attenuation, ray_scattered),
.dielectric => |s| s.scatter(ray_in, rec, attenuation, ray_scattered),
};
}
};
// Materiaux
pub const Lambertian = struct {
albedo: vec3,
pub fn scatter(self: *const Lambertian, rec: *HitRecord, attenuation: *vec3, ray_scattered: *Ray) bool {
var scatter_direction = rec.*.normal + random_unit_vector();
if (near_zero(scatter_direction)) {
scatter_direction = rec.*.normal;
}
ray_scattered.* = Ray{ .orig = rec.*.p, .dir = scatter_direction };
attenuation.* = self.albedo;
return true;
}
};
pub const Metal = struct {
albedo: vec3,
fuzz: f64,
pub fn scatter(self: *const Metal, r_in: Ray, rec: *HitRecord, attenuation: *vec3, ray_scattered: *Ray) bool {
var reflected = reflect(r_in.dir, rec.*.normal);
reflected = unit_vector(reflected) + (toVec3(self.fuzz) * random_unit_vector());
ray_scattered.* = Ray{ .orig = rec.p, .dir = reflected };
attenuation.* = self.albedo;
return (dot(ray_scattered.dir, rec.normal) > 0);
}
};
pub const Dielectric = struct {
refraction_index: f64,
pub fn scatter(self: *const Dielectric, r_in: Ray, rec: *HitRecord, attenuation: *vec3, ray_scattered: *Ray) bool {
attenuation.* = vec3{ 1, 1, 1 };
const ri = if (rec.front_face) (1.0 / self.refraction_index) else self.refraction_index;
const unit_direction = unit_vector(r_in.dir);
const cos_theta = @min(dot(-unit_direction, rec.normal), 1.0);
const sin_theta = @sqrt(1.0 - cos_theta * cos_theta);
const cannot_refract = ri * sin_theta > 1.0;
var direction = vec3{ 0, 0, 0 };
if ((cannot_refract) and (reflectance(cos_theta, ri) > utils.rand_01())) {
direction = reflect(unit_direction, rec.normal);
} else {
direction = refract(unit_direction, rec.normal, ri);
}
ray_scattered.* = Ray{ .orig = rec.p, .dir = direction };
return true;
}
};
// Physics
fn reflect(v: vec3, n: vec3) vec3 {
return v - toVec3(2 * dot(v, n)) * n;
}
fn refract(uv: vec3, n: vec3, etai_over_etat: f64) vec3 {
const cos_theta = @min(dot(-uv, n), 1.0);
const r_out_perp = toVec3(etai_over_etat) * (uv + toVec3(cos_theta) * n);
const r_out_parallel = toVec3(-@sqrt(@abs(1.0 - length_squared(r_out_perp)))) * n;
return r_out_perp + r_out_parallel;
}
fn reflectance(cosine: f64, refraction_index: f64) f64 {
var r0 = (1 - refraction_index) / (1 + refraction_index);
r0 = r0 * r0;
return r0 + (1 - r0) * math.pow(f64, (1 - cosine), 5);
}

103
src/utils.zig Normal file
View File

@ -0,0 +1,103 @@
const std = @import("std");
const math = std.math;
const vec3 = @Vector(3, f64);
pub const Interval = struct {
min: f64,
max: f64,
pub fn inf() Interval {
return Interval{
.min = -math.inf(f64),
.max = math.inf(f64),
};
}
pub fn new(min: f64, max: f64) Interval {
return Interval{
.min = min,
.max = max,
};
}
pub fn size(self: Interval) f64 {
return self.max - self.min;
}
pub fn contains(self: Interval, x: f64) bool {
return ((self.min <= x) and (x <= self.max));
}
pub fn surrounds(self: Interval, x: f64) bool {
return ((self.min < x) and (x < self.max));
}
pub fn clamp(self: Interval, x: f64) f64 {
if (x < self.min) {
return self.min;
}
if (x > self.max) {
return self.max;
}
return x;
}
};
pub fn toVec3(x: anytype) vec3 {
switch (@TypeOf(x)) {
comptime_float => {
const x_float = @as(f64, x);
return vec3{ x_float, x_float, x_float };
},
i64 => {
const x_float = @as(f64, @floatFromInt(x));
return vec3{ x_float, x_float, x_float };
},
comptime_int => {
const x_float = @as(f64, @floatFromInt(x));
return vec3{ x_float, x_float, x_float };
},
f64 => {
return vec3{ x, x, x };
},
@Vector(3, f64) => {
return x;
},
usize => {
const x_float = @as(f64, @floatFromInt(@as(i64, @intCast(x))));
return vec3{ x_float, x_float, x_float };
},
else => {
@panic("Unknow type passed through toVec3\n\n");
},
}
}
var rnd = std.rand.DefaultPrng.init(0);
pub fn rand_01() f64 {
return rnd.random().float(f64);
}
pub fn rand_mm(min: f64, max: f64) f64 {
return rnd.random().float(f64) * (max - min) + min;
}
pub fn rand_vec3_01() vec3 {
return vec3{ rand_01(), rand_01(), rand_01() };
}
pub fn rand_vec3_mm(min: f64, max: f64) vec3 {
return vec3{ rand_mm(min, max), rand_mm(min, max), rand_mm(min, max) };
}
pub fn linear_to_gamma(linear_component: f64) f64 {
if (linear_component > 0) {
return @sqrt(linear_component);
}
return 0;
}
pub fn degrees_to_radians(degrees: f64) f64 {
return degrees * math.pi / 180;
}