this repo has no description
small changes
+38
-35
+10
-17
src/BVH.zig
+10
-17
src/BVH.zig
···
8
8
const Ray = @import("Ray.zig");
9
9
const util = @import("util.zig");
10
10
11
+
const log = std.log.scoped(.BVH);
12
+
11
13
pub const BVH = @This();
12
14
13
15
const Ast = struct {
···
41
43
objects: []Hittable,
42
44
bbox: AABB,
43
45
44
-
pub inline fn hit(self: *Leaf, r: *Ray, ray_t: IntervalF32) ?HitRecord {
46
+
pub fn hit(self: *Leaf, r: *Ray, ray_t: IntervalF32) ?HitRecord {
45
47
var rec: ?HitRecord = null;
46
48
var interval = ray_t;
47
49
for (self.objects) |obj| {
48
-
if (@constCast(&obj).hit(r, interval)) |res| {
50
+
if (obj.hit(r, interval)) |res| {
49
51
interval = IntervalF32.init(ray_t.min, res.t);
50
52
rec = res;
51
53
}
···
123
125
}
124
126
}
125
127
126
-
pub inline fn bbox(self: *Node) AABB {
127
-
switch (self.*) {
128
-
.ast => |*a| return a.bbox,
129
-
.leaf => |*l| return l.bbox,
130
-
}
128
+
pub fn bbox(self: *Node) AABB {
129
+
return self.bbox;
131
130
}
132
131
133
132
pub inline fn hit(self: *Node, r: *Ray, ray_t: IntervalF32) ?HitRecord {
···
197
196
198
197
pub fn init(allocator: std.mem.Allocator, objects: hittable.HittableList, max_depth: usize) !BVH {
199
198
defer @constCast(&objects).deinit();
200
-
std.log.info("Creating BVH Tree with {} objects", .{objects.list.items.len});
199
+
log.info("Creating BVH Tree with {} objects", .{objects.list.items.len});
201
200
202
201
const root = try allocator.create(Node);
203
202
try root.init(allocator, objects.list.items, max_depth, 0);
204
203
const bbox = root.recomputeBbox();
205
204
206
-
std.log.debug("Reached depth of: {}, max objects: {}", .{ reached_depth, max_objects });
205
+
log.debug("Reached depth of: {}, max objects: {}", .{ reached_depth, max_objects });
207
206
208
207
// root.print(0, 0);
209
208
return .{
···
218
217
}
219
218
220
219
pub inline fn hit(self: *BVH, r: *Ray, ray_t: IntervalF32) ?HitRecord {
221
-
if (self.bbox.hit(r, ray_t)) {
222
-
return self.root.hit(r, ray_t);
223
-
}
224
-
225
-
return null;
220
+
return self.root.hit(r, ray_t);
226
221
}
227
222
228
223
inline fn boxCompare(a: *Hittable, b: *Hittable, axis_index: i32) bool {
229
-
const a_axis_interval = a.boundingBox().axisInterval(axis_index);
230
-
const b_axis_interval = b.boundingBox().axisInterval(axis_index);
231
-
return a_axis_interval.min < b_axis_interval.min;
224
+
return a.boundingBox().axisInterval(axis_index).min < b.boundingBox().axisInterval(axis_index).min;
232
225
}
233
226
234
227
fn boxXCompare(_: @TypeOf(.{}), a: Hittable, b: Hittable) bool {
+2
-2
src/hittable.zig
+2
-2
src/hittable.zig
···
33
33
34
34
pub fn boundingBox(self: *Hittable) AABB {
35
35
switch (self.*) {
36
-
inline else => |*n| return n[0].boundingBox(),
36
+
inline else => |*n| return n[0].bbox,
37
37
}
38
38
}
39
39
···
43
43
}
44
44
}
45
45
46
-
pub inline fn hit(self: *Hittable, r: *Ray, ray_t: IntervalF32) ?HitRecord {
46
+
pub fn hit(self: *const Hittable, r: *Ray, ray_t: IntervalF32) ?HitRecord {
47
47
switch (self.*) {
48
48
inline else => |*n| return n[0].hit(r, ray_t),
49
49
}
+20
-10
src/hittable/sphere.zig
+20
-10
src/hittable/sphere.zig
···
13
13
mat: *Material,
14
14
is_moving: bool = false,
15
15
center_vec: zm.Vec = zm.f32x4s(0),
16
-
bbox: ?AABB = null,
16
+
bbox: AABB,
17
+
18
+
pub fn init(center: zm.Vec, radius: f32, mat: *Material) Sphere {
19
+
const rvec = zm.f32x4s(radius);
20
+
return Sphere{
21
+
.center = center,
22
+
.radius = @max(0, radius),
23
+
.mat = mat,
24
+
.bbox = AABB.initP(center - rvec, center + rvec),
25
+
};
26
+
}
17
27
18
28
pub fn initMoving(center1: zm.Vec, center2: zm.Vec, radius: f32, mat: *Material) Sphere {
19
29
const rvec = zm.f32x4s(radius);
···
31
41
}
32
42
33
43
pub inline fn boundingBox(self: *Sphere) AABB {
34
-
if (self.bbox) |bbox| {
35
-
return bbox;
36
-
} else {
37
-
const rvec = zm.f32x4s(self.radius);
38
-
self.bbox = AABB.initP(self.center - rvec, self.center + rvec);
39
-
return self.bbox.?;
40
-
}
44
+
// if (self.bbox) |bbox| {
45
+
return self.bbox;
46
+
// } else {
47
+
// const rvec = zm.f32x4s(self.radius);
48
+
// self.bbox = AABB.initP(self.center - rvec, self.center + rvec);
49
+
// return self.bbox.?;
50
+
// }
41
51
}
42
52
43
-
pub inline fn hit(self: *Sphere, r: *Ray, ray_t: IntervalF32) ?HitRecord {
53
+
pub fn hit(self: *const Sphere, r: *Ray, ray_t: IntervalF32) ?HitRecord {
44
54
const center = blk: {
45
55
if (self.is_moving) {
46
56
break :blk self.sphereCenter(r.tm);
···
77
87
return rec;
78
88
}
79
89
80
-
pub inline fn sphereCenter(self: *Sphere, time: f32) zm.Vec {
90
+
pub inline fn sphereCenter(self: *const Sphere, time: f32) zm.Vec {
81
91
return self.center + zm.f32x4s(time) * self.center_vec;
82
92
}
+6
-6
src/scences/in_one_weekend.zig
+6
-6
src/scences/in_one_weekend.zig
···
15
15
16
16
const material_ground = try allocator.create(Material);
17
17
material_ground.* = Material.lambertian(zm.f32x4(0.5, 0.5, 0.5, 1.0));
18
-
try world.add(Hittable.sphere("Ground", Sphere{ .center = zm.f32x4(0, -1000, 0, 0), .radius = 1000, .mat = material_ground }));
18
+
try world.add(Hittable.sphere("Ground", Sphere.init(zm.f32x4(0, -1000, 0, 0), 1000, material_ground)));
19
19
20
20
const a_max = 50;
21
21
const b_max = 50;
···
47
47
const albedo = rayray.util.randomVec3M(0.5, 1) + zm.f32x4(0, 0, 0, 1);
48
48
const fuzz = rayray.util.randomF32M(0, 0.5);
49
49
material.* = Material.metal(albedo, fuzz);
50
-
try world.add(Hittable.sphere("Metal", Sphere{ .center = center, .radius = 0.2, .mat = material }));
50
+
try world.add(Hittable.sphere("Metal", Sphere.init(center, 0.2, material)));
51
51
} else {
52
52
// glass
53
53
material.* = Material.dielectric(1.5);
54
-
try world.add(Hittable.sphere("Dielectric", Sphere{ .center = center, .radius = 0.2, .mat = material }));
54
+
try world.add(Hittable.sphere("Dielectric", Sphere.init(center, 0.2, material)));
55
55
}
56
56
}
57
57
}
···
63
63
64
64
const material2 = try allocator.create(Material);
65
65
material2.* = Material.lambertian(zm.f32x4(0.4, 0.2, 0.1, 1));
66
-
try world.add(Hittable.sphere("Two: Lambertian", Sphere{ .center = zm.f32x4(-4, 1, 0, 0), .radius = 1, .mat = material1 }));
66
+
try world.add(Hittable.sphere("Two: Lambertian", Sphere.init(zm.f32x4(-4, 1, 0, 0), 1, material1)));
67
67
68
68
const material3 = try allocator.create(Material);
69
69
material3.* = Material.metal(zm.f32x4(0.7, 0.6, 0.5, 1), 0);
70
-
try world.add(Hittable.sphere("Three: Metal", Sphere{ .center = zm.f32x4(4, 1, 0, 0), .radius = 1, .mat = material3 }));
70
+
try world.add(Hittable.sphere("Three: Metal", Sphere.init(zm.f32x4(4, 1, 0, 0), 1, material3)));
71
71
72
-
try world.add(Hittable.sphere("One: Dielectric", Sphere{ .center = zm.f32x4(0, 1, 0, 0), .radius = 1, .mat = material2 }));
72
+
try world.add(Hittable.sphere("One: Dielectric", Sphere.init(zm.f32x4(0, 1, 0, 0), 1, material2)));
73
73
74
74
return .{ .allocator = allocator, .world = world };
75
75
}