built bvh i guess

Author: aaalloc

src/lib.rs

@@ -155,7 +155,7 @@ fn init(
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(start))]
 pub async fn run() {
     info!("Starting up");
-    let scale = 1.0;
+    let scale = 2.0;
     let width = 900 * scale as u32;
     let height = 450 * scale as u32;
     let (window, event_loop) = init(width, height);

src/render_context.rs

@@ -179,12 +179,20 @@ impl<'a> RenderContext<'a> {
                 Some("texture buffer"),
             );
 
+            let aabb_buffer = StorageBuffer::new_from_bytes(
+                &device,
+                bytemuck::cast_slice(scene.get_bvh().as_slice()),
+                3_u32,
+                Some("aabb buffer"),
+            );
+
             let scene_bind_group_layout =
                 device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                     entries: &[
                         sphere_buffer.layout(wgpu::ShaderStages::FRAGMENT, true),
                         material_buffer.layout(wgpu::ShaderStages::FRAGMENT, true),
                         texture_buffer.layout(wgpu::ShaderStages::FRAGMENT, true),
+                        aabb_buffer.layout(wgpu::ShaderStages::FRAGMENT, true),
                     ],
                     label: Some("scene layout"),
                 });
@@ -195,6 +203,7 @@ impl<'a> RenderContext<'a> {
                     sphere_buffer.binding(),
                     material_buffer.binding(),
                     texture_buffer.binding(),
+                    aabb_buffer.binding(),
                 ],
                 label: Some("scene bind group"),
             });

src/scene/aabb.rs

@@ -0,0 +1,12 @@
+use glm::Vec3;
+
+use super::Sphere;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct AABB {
+    pub min: Vec3,
+    pub max: Vec3,
+    pub left_child: u32,
+    pub right_child: u32,
+}

src/scene/mod.rs

@@ -4,6 +4,8 @@ pub use camera::{Camera, CameraController, GpuCamera};
 mod material;
 pub use material::{GpuMaterial, Material, Texture};
 
+mod aabb;
+
 #[derive(Clone, Debug)]
 pub struct Scene {
     pub materials: Vec<Material>,
@@ -132,6 +134,90 @@ impl Scene {
             camera_controller,
         }
     }
+
+    pub fn get_bvh(&self) -> Vec<aabb::AABB> {
+        let mut bvh = Vec::new();
+
+        let axis = rand::random::<u32>() % 3;
+        let mut spheres = self.spheres.clone();
+
+        spheres.sort_by(|a, b| {
+            let a = a.get_bounding_box();
+            let b = b.get_bounding_box();
+
+            a.min[axis as usize]
+                .partial_cmp(&b.min[axis as usize])
+                .unwrap()
+        });
+
+        let mut stack = Vec::new();
+        stack.push((0, spheres.len(), 0));
+
+        while let Some((start, end, _)) = stack.pop() {
+            let mut min = glm::vec3(std::f32::INFINITY, std::f32::INFINITY, std::f32::INFINITY);
+            let mut max = glm::vec3(
+                std::f32::NEG_INFINITY,
+                std::f32::NEG_INFINITY,
+                std::f32::NEG_INFINITY,
+            );
+
+            for i in start..end {
+                let sphere = &spheres[i];
+                let aabb = sphere.get_bounding_box();
+
+                min = glm::vec3(
+                    min.x.min(aabb.min.x),
+                    min.y.min(aabb.min.y),
+                    min.z.min(aabb.min.z),
+                );
+
+                max = glm::vec3(
+                    max.x.max(aabb.max.x),
+                    max.y.max(aabb.max.y),
+                    max.z.max(aabb.max.z),
+                );
+            }
+
+            let mid = (start + end) / 2;
+
+            let left_child = if mid - start == 1 {
+                start as u32
+            } else {
+                bvh.len() as u32 + 1
+            };
+
+            let right_child = if end - mid == 1 {
+                mid as u32
+            } else {
+                bvh.len() as u32 + 2
+            };
+
+            bvh.push(aabb::AABB {
+                min,
+                max,
+                left_child,
+                right_child,
+            });
+
+            if mid - start > 1 {
+                stack.push((start, mid, bvh.len() as u32 - 1));
+            }
+
+            if end - mid > 1 {
+                stack.push((mid, end, bvh.len() as u32 - 1));
+            }
+        }
+
+        // DEBUG: traverse bvh and print a tree
+        for (i, aabb) in bvh.iter().enumerate() {
+            println!(
+                "Node: {} min: {:?} max: {:?} left: {} right: {}",
+                i, aabb.min, aabb.max, aabb.left_child, aabb.right_child
+            );
+        }
+
+        bvh
+    }
 }
 
 #[repr(C)]
@@ -191,4 +277,15 @@ impl Sphere {
             _padding: [0; 2],
         }
     }
+    pub fn get_bounding_box(&self) -> aabb::AABB {
+        let radius = glm::vec3(self.radius, self.radius, self.radius);
+        let center = self.center.xyz();
+
+        aabb::AABB {
+            min: center - radius,
+            max: center + radius,
+            left_child: 0,
+            right_child: 0,
+        }
+    }
 }

src/shader/raytracing.wgsl

@@ -25,6 +25,7 @@ const MAX_T = 1000f;
 @group(1) @binding(0) var<storage, read> spheres: array<Sphere>;
 @group(1) @binding(1) var<storage, read> materials: array<Material>;
 @group(1) @binding(2) var<storage, read> textures: array<array<f32, 3>>;
+@group(1) @binding(3) var<storage, read> aabbs: array<AABB>;
 
 @vertex
 fn vs_main(
@@ -155,6 +156,13 @@ struct Ray {
     direction: vec3<f32>,
 };
 
+struct AABB {
+    min: vec3<f32>,
+    max: vec3<f32>,
+    left_child: u32,
+    right_child: u32,
+};
+
 struct Sphere {
     center: vec4<f32>,
     radius: f32,
@@ -276,22 +284,6 @@ fn get_ray(rngState: ptr<function, u32>, x: f32, y: f32) -> Ray {
 
 
 
-// pub fn from_linear_rgb(c: [f32; 3]) -> Color {
-//     let f = |x: f32| -> u32 {
-//         let y = if x > 0.0031308 {
-//             let a = 0.055;
-//             (1.0 + a) * x.powf(-2.4) - a
-//         } else {
-//             12.92 * x
-//         };
-//         (y * 255.0).round() as u32
-//     };
-//     f(c[0]) << 16 | f(c[1]) << 8 | f(c[2])
-// }
-
-
-
-
 fn ray_color(first_ray: Ray, rngState: ptr<function, u32>) -> vec3<f32> {
     var ray = first_ray;
     var sky_color = vec3(0.0);
@@ -316,6 +308,24 @@ fn ray_color(first_ray: Ray, rngState: ptr<function, u32>) -> vec3<f32> {
 }
 
 
+fn rayIntersectBV(ray: ptr<function, Ray>, aabb: ptr<function, AABB>) -> bool {
+    let t0 = ((*aabb).min - (*ray).origin) / (*ray).direction;
+    let t1 = ((*aabb).max - (*ray).origin) / (*ray).direction;
+    let tmin = min(t0, t1);
+    let tmax = max(t0, t1);
+    let maxMinT = max(tmin.x, max(tmin.y, tmin.z));
+    let minMaxT = min(tmax.x, min(tmax.y, tmax.z));
+    return maxMinT < minMaxT;
+}
+
+fn rayIntersectBVH(
+    ray: Ray,
+    hit: ptr<function, HitRecord>,
+) -> bool {
+    // TODO: Implement BVH traversal
+    return true;
+}
+
 
 fn scatter(ray: Ray, hit: HitRecord, material: Material, rngState: ptr<function, u32>) -> Scatter {
     switch (material.id)