use metada instead of material/prim index

Author: SimonDanisch

docs/src/raytracing-core.jl

@@ -47,33 +47,12 @@ function Raycore.to_gpu(Arr, ctx::RenderContext)
     return RenderContext(to_gpu(Arr, ctx.lights), to_gpu(Arr, ctx.materials), ctx.ambient)
 end
 
-function render_context(; glass_cat=false)
-    # Create lights and materials
-    lights = [
+function default_lights()
+    return [
         PointLight(Point3f(3, 4, -2), 50.0f0, RGB(1.0f0, 0.9f0, 0.8f0)),
         PointLight(Point3f(-3, 2, 0), 20.0f0, RGB(0.7f0, 0.8f0, 1.0f0)),
         PointLight(Point3f(0, 5, 5), 15.0f0, RGB(1.0f0, 1.0f0, 1.0f0))
     ]
-
-    # Material: base_color, metallic, roughness, ior, transmission
-    cat_material = if glass_cat
-        # Glass cat: clear glass with slight green tint, ior=1.5
-        Material(RGB(0.95f0, 1.0f0, 0.95f0), 0.0f0, 0.0f0, 1.5f0, 1.0f0)
-    else
-        # Original diffuse cat
-        Material(RGB(0.8f0, 0.6f0, 0.4f0), 0.0f0, 0.8f0, 1.0f0, 0.0f0)
-    end
-
-    materials = [
-        cat_material,                                                    # cat (index 1)
-        Material(RGB(0.3f0, 0.5f0, 0.3f0), 0.0f0, 0.9f0, 1.0f0, 0.0f0),  # floor - diffuse
-        Material(RGB(0.8f0, 0.6f0, 0.5f0), 0.8f0, 0.05f0, 1.0f0, 0.0f0), # back wall - metallic
-        Material(RGB(0.7f0, 0.7f0, 0.8f0), 0.0f0, 0.8f0, 1.0f0, 0.0f0),  # left wall - diffuse
-        Material(RGB(0.9f0, 0.9f0, 0.9f0), 0.8f0, 0.02f0, 1.0f0, 0.0f0), # sphere1 - metallic
-        Material(RGB(0.3f0, 0.6f0, 0.9f0), 0.5f0, 0.3f0, 1.0f0, 0.0f0),  # sphere2 - semi-metallic
-    ]
-
-    return RenderContext(lights, materials, 0.1f0)
 end
 
 function compute_light(
@@ -211,9 +190,27 @@ function example_scene(; glass_cat=false)
     sphere1 = Tesselation(Sphere(Point3f(-2, -1.5 + 0.8, 2), 0.8f0), 64)
     sphere2 = Tesselation(Sphere(Point3f(2, -1.5 + 0.6, 1), 0.6f0), 64)
 
-    # Build our BVH acceleration structure
-    scene_geometry = [cat_mesh, floor, back_wall, left_wall, sphere1, sphere2]
-    return scene_geometry, render_context(glass_cat=glass_cat)
+    # Material: base_color, metallic, roughness, ior, transmission
+    cat_material = if glass_cat
+        Material(RGB(0.95f0, 1.0f0, 0.95f0), 0.0f0, 0.0f0, 1.5f0, 1.0f0)
+    else
+        Material(RGB(0.8f0, 0.6f0, 0.4f0), 0.0f0, 0.8f0, 1.0f0, 0.0f0)
+    end
+
+    # (geometry, material) pairs
+    scene = [
+        (cat_mesh,   cat_material),
+        (floor,      Material(RGB(0.3f0, 0.5f0, 0.3f0), 0.0f0, 0.9f0, 1.0f0, 0.0f0)),
+        (back_wall,  Material(RGB(0.8f0, 0.6f0, 0.5f0), 0.8f0, 0.05f0, 1.0f0, 0.0f0)),
+        (left_wall,  Material(RGB(0.7f0, 0.7f0, 0.8f0), 0.0f0, 0.8f0, 1.0f0, 0.0f0)),
+        (sphere1,    Material(RGB(0.9f0, 0.9f0, 0.9f0), 0.8f0, 0.02f0, 1.0f0, 0.0f0)),
+        (sphere2,    Material(RGB(0.3f0, 0.6f0, 0.9f0), 0.5f0, 0.3f0, 1.0f0, 0.0f0)),
+    ]
+
+    bvh, materials = MaterialScene(scene)
+    lights = default_lights()
+    ctx = RenderContext(lights, materials, 0.1f0)
+    return bvh, ctx
 end
 
 function example_scene_glass_cat()

docs/src/test_wavefront.jl

@@ -14,27 +14,29 @@ using BenchmarkTools
 include("raytracing-core.jl")
 include("wavefront-renderer.jl")
 
-geom, ctx = example_scene()
-bvh = BVH(geom)
-ibvh = Raycore.InstancedBVH(geom)
+bvh, ctx = example_scene()
+# ibvh = Raycore.InstancedBVH(geom)
 begin
-    img = fill(RGBf(0, 0, 0), 1024, 2048)
+    img = fill(RGBf(0, 0, 0), 400, 720)
     renderer = WavefrontRenderer(img, bvh, ctx)
     @btime render!(renderer)
     nothing
 end
 renderer.framebuffer
 renderer_instanced.framebuffer
 begin
-    img = fill(RGBf(0, 0, 0), 1024, 2048)
+    img = fill(RGBf(0, 0, 0), 400, 720)
     renderer_instanced = WavefrontRenderer(
-        img, ibvh, ctx;
+        img, bvh, ctx;
         camera_pos=Point3f(0, -0.9, -2.5),
         fov=45.0f0,
         sky_color=RGB{Float32}(0.5f0, 0.7f0, 1.0f0),
         samples_per_pixel=4
     )
     @btime render!(renderer_instanced)
+    # on windows + ryzen 395 max
+    # 381.034 ms (1200456 allocations: 90.13 MiB)
+
     nothing
 end
 using ImageShow
@@ -43,8 +45,9 @@ using FileIO
 save("wavefront.png", map(col -> mapc(c -> clamp(c, 0f0, 1f0), col), renderer.framebuffer))
 
 using AMDGPU
-amd_renderer = to_gpu(ROCArray, renderer_instanced);
+amd_renderer = to_gpu(ROCArray, renderer);
 Array(@btime render!(amd_renderer))
+# 36ms on windows + amd 8060s
 
 using pocl_jll, OpenCL
 amd_renderer = to_gpu(CLArray, renderer);

docs/src/wavefront-renderer.jl

@@ -5,6 +5,44 @@ using KernelAbstractions
 using KernelAbstractions: @kernel, @index, @Const
 import KernelAbstractions as KA
 using Statistics
+
+# ============================================================================
+# MaterialScene Helper
+# ============================================================================
+
+"""
+    MaterialScene(geometry_material_pairs) -> (bvh, materials)
+
+Create a BVH and materials array from a vector of (geometry, material) tuples.
+
+# Arguments
+- `geometry_material_pairs`: Vector of `(mesh, material)` tuples
+
+# Returns
+- `bvh`: BVH with material indices as triangle metadata
+- `materials`: Vector of materials
+
+# Example
+```julia
+scene = [
+    (sphere_mesh, Material(...)),
+    (floor_mesh, Material(...)),
+]
+bvh, materials = MaterialScene(scene)
+```
+"""
+function MaterialScene(geometry_material_pairs::Vector{<:Tuple{<:Any, M}}) where {M}
+    meshes = [p[1] for p in geometry_material_pairs]
+    materials = M[p[2] for p in geometry_material_pairs]
+
+    # Create BVH with material index as metadata
+    function metadata_fn(mesh_idx, _tri_idx)
+        return Int32(mesh_idx)
+    end
+    bvh = Raycore.BVH(meshes, metadata_fn)
+    return bvh, materials
+end
+
 # ============================================================================
 # SoA Access Macros
 # ============================================================================
@@ -123,11 +161,12 @@ struct ReflectionRayWork
     hit_idx::Int32  # Index back to primary hit
 end
 
-struct ReflectionHitWork{T}
+struct ReflectionHitWork
     hit_found::Bool
-    tri_idx::T  # Store triangle index instead of full triangle
+    material_idx::Int32  # Store material index (triangle metadata)
     dist::Float32
     bary::Vec3f
+    normal::Vec3f  # Store interpolated normal
     ray::Raycore.Ray
     primary_hit_idx::Int32
 end
@@ -308,7 +347,7 @@ end
             normal = Vec3f(normalize(v0 * u + v1 * v + v2 * w))
 
             # Get material
-            mat = ctx.materials[tri.material_idx]
+            mat = ctx.materials[tri.metadata]
             base_color = Vec3f(mat.base_color.r, mat.base_color.g, mat.base_color.b)
             # Start with ambient
             total_color = base_color * ctx.ambient
@@ -363,7 +402,7 @@ end
         dummy_ray = Raycore.Ray(o=Point3f(0, 0, 0), d=Vec3f(0, 0, 1), t_max=0.0f0)
 
         if hit_found
-            mat = ctx.materials[tri.material_idx]
+            mat = ctx.materials[tri.metadata]
             if mat.metallic > 0.0f0
                 # Compute reflection
                 hit_point = ray.o + ray.d * dist
@@ -413,10 +452,18 @@ end
 
         if ray.t_max > 0.0f0
             hit_found, tri, dist, bary = Raycore.closest_hit(bvh, ray)
-            # Write to SoA using @set
-            @set reflection_hit_soa[idx] = (hit_found=hit_found, tri_idx=tri.primitive_idx,
-                dist=dist, bary=Vec3f(bary),
-                ray=ray, primary_hit_idx=hit_idx)
+            if hit_found
+                # Compute normal here so we don't need to store the triangle
+                v0, v1, v2 = Raycore.normals(tri)
+                u, v, w = bary[1], bary[2], bary[3]
+                normal = Vec3f(normalize(v0 * u + v1 * v + v2 * w))
+                # Write to SoA using @set
+                @set reflection_hit_soa[idx] = (hit_found=true, material_idx=tri.metadata,
+                    dist=dist, bary=Vec3f(bary), normal=normal,
+                    ray=ray, primary_hit_idx=hit_idx)
+            else
+                reflection_hit_soa.hit_found[idx] = false
+            end
         else
             # Write only hit_found as false for dummy rays
             reflection_hit_soa.hit_found[idx] = false
@@ -431,7 +478,6 @@ end
 @kernel function shade_reflections_and_blend!(
     @Const(hit_queue),
     @Const(reflection_hit_soa),  # SoA version: NamedTuple of arrays
-    @Const(bvh_triangles),        # Need original triangles for material lookup
     @Const(ctx),
     @Const(sky_color),
     shading_queue  # In/out: update with reflection contribution
@@ -444,21 +490,17 @@ end
         @get hit_found, tri, pixel_x, pixel_y, sample_idx = hit_queue[idx]
 
         if hit_found
-            mat = ctx.materials[tri.material_idx]
+            mat = ctx.materials[tri.metadata]
 
             if mat.metallic > 0.0f0
-                # Access from SoA directly (using different variable names for clarity)
-                @get hit_found, tri_idx, dist, bary, ray = reflection_hit_soa[idx]
+                # Access from SoA directly
+                @get hit_found, material_idx, dist, bary, normal, ray = reflection_hit_soa[idx]
                 # Compute reflection color (simplified - no recursive shadows for performance)
                 reflection_color = if hit_found
                     refl_point = ray.o + ray.d * dist
-                    # Get triangle from BVH using stored index
-                    refl_tri = bvh_triangles[tri_idx]
-                    v0, v1, v2 = Raycore.normals(refl_tri)
-                    u, v, w = bary
-                    refl_normal = Vec3f(normalize(v0 * u + v1 * v + v2 * w))
+                    refl_normal = normal
 
-                    refl_mat = ctx.materials[refl_tri.material_idx]
+                    refl_mat = ctx.materials[material_idx]
                     refl_base_color = Vec3f(refl_mat.base_color.r, refl_mat.base_color.g, refl_mat.base_color.b)
 
                     # Simplified lighting (ambient + first light only, no shadows)
@@ -614,7 +656,7 @@ function WavefrontRenderer(
     shadow_ray_queue = similar_soa(img, ShadowRayWork, num_shadow_rays)
     shadow_result_queue = similar_soa(img, ShadowResult, num_shadow_rays)
     reflection_ray_soa = similar_soa(img, ReflectionRayWork, num_rays)
-    reflection_hit_soa = similar_soa(img, ReflectionHitWork{Int32}, num_rays)
+    reflection_hit_soa = similar_soa(img, ReflectionHitWork, num_rays)
     shading_queue = similar_soa(img, ShadedResult, num_rays)
     sample_accumulator = similar(img, Vec3f, num_rays)
     active_count = similar(img, Int32, 1)
@@ -749,7 +791,6 @@ function render!(renderer::WavefrontRenderer)
     refl_shade_kernel!(
         renderer.primary_hit_queue,
         renderer.reflection_hit_soa,
-        renderer.bvh.primitives,
         renderer.ctx,
         renderer.sky_color,
         renderer.shading_queue,