almost 0 allocations

Author: SimonDanisch

src/accel/bvh.jl

@@ -47,8 +47,8 @@ struct LinearBVHInterior <: LinearNode
 end
 const LinearBVH = Union{LinearBVHLeaf,LinearBVHInterior}
 
-struct BVHAccel <: AccelPrimitive
-    primitives::Vector{P} where P<:Primitive
+struct BVHAccel{P <: Primitive} <: AccelPrimitive
+    primitives::Vector{P}
     max_node_primitives::UInt8
     nodes::Vector{LinearBVH}
     nodes_to_visit::Vector{Vector{Int32}}
@@ -57,15 +57,15 @@ struct BVHAccel <: AccelPrimitive
         primitives::Vector{P}, max_node_primitives::Integer = 1,
     ) where P<:Primitive
         max_node_primitives = min(255, max_node_primitives)
-        length(primitives) == 0 && return new(primitives, max_node_primitives)
+        isempty(primitives) && return new{P}(primitives, max_node_primitives)
         nodes_to_visit = [zeros(Int32, 64) for _ in 1:Threads.maxthreadid()]
         primitives_info = [
             BVHPrimitiveInfo(i, world_bound(p))
             for (i, p) in enumerate(primitives)
         ]
 
         total_nodes = Ref(0)
-        ordered_primitives = Vector{P}(undef, 0)
+        ordered_primitives = P[]
         root = _init(
             primitives, primitives_info, 1, length(primitives),
             total_nodes, ordered_primitives, max_node_primitives,
@@ -76,7 +76,7 @@ struct BVHAccel <: AccelPrimitive
         _unroll(flattened, root, offset)
         @real_assert total_nodes[] + 1 == offset[]
 
-        new(ordered_primitives, max_node_primitives, flattened, nodes_to_visit)
+        new{P}(ordered_primitives, max_node_primitives, flattened, nodes_to_visit)
     end
 end
 
@@ -210,19 +210,21 @@ end
     length(bvh.nodes) > 0 ? bvh.nodes[1].bounds : Bounds3()
 end
 
-function intersect!(pool, bvh::BVHAccel, ray::MutableRef{<:AbstractRay})
+function intersect!(pool, bvh::BVHAccel{P}, ray::MutableRef{<:AbstractRay})::Tuple{Bool, P, SurfaceInteraction} where P
     hit = false
     interaction = SurfaceInteraction()
-    primitive::Maybe{GeometricPrimitive} = nothing
-    length(bvh.nodes) == 0 && return hit, primitive, interaction
+    isempty(bvh.nodes) && return hit, nothing, interaction
 
     check_direction!(ray)
     inv_dir = 1f0 ./ ray.d
     dir_is_neg = is_dir_negative(ray.d)
 
     to_visit_offset::Int32, current_node_i::Int32 = 1, 1
     @inbounds nodes_to_visit = bvh.nodes_to_visit[Threads.threadid()]
-    nodes_to_visit .= 0
+    @inbounds for i in eachindex(nodes_to_visit)
+        nodes_to_visit[i] = Int32(0)
+    end
+    primitive::P = first(bvh.primitives)
     @inbounds while true
         ln = bvh.nodes[current_node_i]
         if intersect_p(pool, ln.bounds, ray, inv_dir, dir_is_neg)
@@ -240,21 +242,21 @@ function intersect!(pool, bvh::BVHAccel, ray::MutableRef{<:AbstractRay})
                     end
                 end
                 to_visit_offset == 1 && break
-                to_visit_offset -= 1
+                to_visit_offset -= Int32(1)
                 current_node_i = nodes_to_visit[to_visit_offset]
             else
                 if dir_is_neg[ln.split_axis] == 2
                     nodes_to_visit[to_visit_offset] = current_node_i + Int32(1)
                     current_node_i = ln.second_child_offset
                 else
                     nodes_to_visit[to_visit_offset] = ln.second_child_offset
-                    current_node_i += 1
+                    current_node_i += Int32(1)
                 end
-                to_visit_offset += 1
+                to_visit_offset += Int32(1)
             end
         else
             to_visit_offset == 1 && break
-            to_visit_offset -= 1
+            to_visit_offset -= Int32(1)
             current_node_i = nodes_to_visit[to_visit_offset]
         end
     end

src/bounds.jl

@@ -90,11 +90,15 @@ function area(b::Bounds2)
 end
 
 @inline function sides(b::Union{Bounds2,Bounds3})
-    [abs(b1 - b0) for (b1, b0) in zip(b.p_max, b.p_min)]
+    return map(b.p_max, b.p_min) do b1, b0
+        return abs(b1 - b0)
+    end
 end
 
 @inline function inclusive_sides(b::Union{Bounds2,Bounds3})
-    [abs(b1 - (b0 - 1f0)) for (b1, b0) in zip(b.p_max, b.p_min)]
+    return map(b.p_max, b.p_min) do b1, b0
+        abs(b1 - (b0 - 1.0f0))
+    end
 end
 
 function volume(b::Bounds3)

src/film.jl

@@ -102,30 +102,47 @@ struct FilmTile{Pixels<:AbstractMatrix{<:FilmTilePixel}}
     filter_table_width::Int32
     pixels::Pixels
 
-    function FilmTile(
-            bounds::Bounds2, filter_radius::Point2f,
-            filter_table_width::Int32,
-        )
-        tile_res = (Int32.(inclusive_sides(bounds)))
-        contrib_sum = fill(RGBSpectrum(), tile_res[2], tile_res[1])
-        filter_weight_sum = fill(0.0f0, tile_res[2], tile_res[1])
-        pixels = StructArray{FilmTilePixel{RGBSpectrum}}((contrib_sum, filter_weight_sum))
-        new{typeof(pixels)}(
-            bounds, filter_radius, 1f0 ./ filter_radius,
-            filter_table_width,
-            pixels,
-        )
-    end
+end
+
+function FilmTile(
+        bounds::Bounds2, filter_radius::Point2f,
+        filter_table_width::Int32,
+    )
+    tile_res = (Int32.(inclusive_sides(bounds))) .+ 2
+    contrib_sum = fill(RGBSpectrum(), tile_res[2], tile_res[1])
+    filter_weight_sum = fill(0.0f0, tile_res[2], tile_res[1])
+    pixels = StructArray{FilmTilePixel{RGBSpectrum}}((contrib_sum, filter_weight_sum))
+    FilmTile{typeof(pixels)}(
+        bounds, filter_radius, 1.0f0 ./ filter_radius,
+        filter_table_width,
+        pixels,
+    )
 end
 
 """
 Bounds should start from 1 not 0.
 """
-function FilmTile(f::Film, sample_bounds::Bounds2)
-    p0 = ceil.(sample_bounds.p_min .- 0.5f0 .- f.filter.radius)
-    p1 = floor.(sample_bounds.p_max .- 0.5f0 .+ f.filter.radius) .+ 1f0
+function FilmTile(f::Film, sample_bounds::Bounds2, radius)
+    p0 = ceil.(sample_bounds.p_min .- 0.5f0 .- radius)
+    p1 = floor.(sample_bounds.p_max .- 0.5f0 .+ radius) .+ 1f0
     tile_bounds = Bounds2(p0, p1) ∩ f.crop_bounds
-    FilmTile(tile_bounds, f.filter.radius, f.filter_table_width)
+    FilmTile(tile_bounds, radius, f.filter_table_width)
+end
+
+function reset!(tile::FilmTile)
+    tile.pixels.contrib_sum .= (RGBSpectrum(0f0),)
+    tile.pixels.filter_weight_sum .= 0f0
+end
+
+function update_bounds!(f::Film, tile::FilmTile, sample_bounds::Bounds2)
+    reset!(tile)
+    radius = tile.filter_radius
+    p0 = ceil.(sample_bounds.p_min .- 0.5f0 .- radius)
+    p1 = floor.(sample_bounds.p_max .- 0.5f0 .+ radius) .+ 1.0f0
+    bounds = Bounds2(p0, p1) ∩ f.crop_bounds
+    tile_res = (Int32.(inclusive_sides(bounds)))
+    @assert all(reverse(tile_res) .<= size(tile.pixels)) "$(reverse(tile_res)) != $(size(tile.pixels)) $(sample_bounds)"
+    FilmTile(bounds, radius, tile.inv_filter_radius, tile.filter_table_width, tile.pixels)
 end
 
 function filter_offset!(offsets, start, stop, discrete_point, inv_filter_radius, filter_table_width)

src/integrators/sampler.jl

@@ -1,61 +1,78 @@
 abstract type SamplerIntegrator <: Integrator end
 
-struct WhittedIntegrator <: SamplerIntegrator
-    camera::C where C<:Camera
-    sampler::S where S<:AbstractSampler
+struct WhittedIntegrator{C<: Camera, S <: AbstractSampler} <: SamplerIntegrator
+    camera::C
+    sampler::S
     max_depth::Int64
 end
 
+@noinline function sample_kernel_inner(pool, i, scene, t_sampler, film, film_tile, camera, pixel, spp_sqr)
+    while has_next_sample(t_sampler)
+        free_all(pool) # clear memory pool
+        camera_sample = get_camera_sample(t_sampler, pixel)
+        ray, ω = generate_ray_differential(pool, camera, camera_sample)
+        scale_differentials!(ray, spp_sqr)
+        l = RGBSpectrum(0f0)
+        if ω > 0.0f0
+            l = li(pool, i, ray, scene, 1)
+        end
+        # TODO check l for invalid values
+        if isnan(l)
+            l = RGBSpectrum(0f0)
+        end
+        add_sample!(film, film_tile, camera_sample.film, l, ω)
+        start_next_sample!(t_sampler)
+    end
+end
+
+@noinline function sample_kernel(mempools, i, camera, scene, film, film_tile, tile_bounds)
+    pool = mempools[Threads.threadid()]
+    t_sampler = deepcopy(i.sampler)
+    spp_sqr = 1f0 / √Float32(t_sampler.samples_per_pixel)
+    for pixel in tile_bounds
+        start_pixel!(t_sampler, pixel)
+        sample_kernel_inner(pool, i, scene, t_sampler, film, film_tile, camera, pixel, spp_sqr)
+    end
+    merge_film_tile!(film, film_tile)
+end
 
 """
 Render scene.
 """
 function (i::SamplerIntegrator)(scene::Scene)
-
     sample_bounds = get_sample_bounds(get_film(i.camera))
     sample_extent = diagonal(sample_bounds)
     tile_size = 16
-    n_tiles::Point2 = Int64.(floor.((sample_extent .+ tile_size) ./ tile_size))
-
+    n_tiles = Int64.(floor.((sample_extent .+ tile_size) ./ tile_size))
     # TODO visualize tile bounds to see if they overlap
     width, height = n_tiles
     total_tiles = width * height - 1
     bar = Progress(total_tiles, 1)
-
     @info "Utilizing $(Threads.nthreads()) threads"
-    mempools = [MemoryPool(round(Int, 2*16384)) for _ in 1:Threads.maxthreadid()]
+    mempools = [MemoryPool(round(Int, 3*16384)) for _ in 1:Threads.maxthreadid()]
     film = get_film(i.camera)
+    camera = i.camera
+    filter_radius = film.filter.radius
+
+    _tile = Point2f(0f0)
+    _tb_min = sample_bounds.p_min .+ _tile .* tile_size
+    _tb_max = min.(_tb_min .+ (tile_size - 1), sample_bounds.p_max)
+    _tile_bounds = Bounds2(_tb_min, _tb_max)
+    filmtiles = [FilmTile(film, _tile_bounds, filter_radius) for _ in 1:Threads.maxthreadid()]
     Threads.@threads for k in 0:total_tiles
         x, y = k % width, k ÷ width
         tile = Point2f(x, y)
-        t_sampler = deepcopy(i.sampler)
-
         tb_min = sample_bounds.p_min .+ tile .* tile_size
         tb_max = min.(tb_min .+ (tile_size - 1), sample_bounds.p_max)
-        tile_bounds = Bounds2(tb_min, tb_max)
-
-        film_tile = FilmTile(film, tile_bounds)
-        spp_sqr = 1f0 / √Float32(t_sampler.samples_per_pixel)
-        pool = mempools[Threads.threadid()]
-        for pixel in tile_bounds
-            start_pixel!(t_sampler, pixel)
-            while has_next_sample(t_sampler)
-                free_all(pool) # clear memory pool
-                camera_sample = get_camera_sample(t_sampler, pixel)
-                ray, ω = generate_ray_differential(pool, i.camera, camera_sample)
-                scale_differentials!(ray, spp_sqr)
-                l = RGBSpectrum(0f0)
-                ω > 0.0f0 && (l = li(pool, i, ray, scene, 1))
-                # TODO check l for invalid values
-                isnan(l) && (l = RGBSpectrum(0f0))
-                add_sample!(film, film_tile, camera_sample.film, l, ω)
-                start_next_sample!(t_sampler)
-            end
+        if tb_min[1] < tb_max[1] && tb_min[2] < tb_max[2]
+            tile_bounds = Bounds2(tb_min, tb_max)
+            film_tile = filmtiles[Threads.threadid()]
+            film_tile = update_bounds!(film, film_tile, tile_bounds)
+            sample_kernel(mempools, i, camera, scene, film, film_tile, tile_bounds)
         end
-        merge_film_tile!(get_film(i.camera), film_tile)
         next!(bar)
     end
-    save(get_film(i.camera))
+    save(film)
 end
 
 function li(

src/lights/spot.jl

@@ -44,8 +44,9 @@ end
 end
 
 function sample_le(
-    pool, s::SpotLight, u1::Point2f, ::Point2f, ::Float32,
-)::Tuple{RGBSpectrum,Ray,Normal3f,Float32,Float32}
+        pool, s::SpotLight, u1::Point2f, ::Point2f, ::Float32,
+    )::Tuple{RGBSpectrum,Ray,Normal3f,Float32,Float32}
+
     w = s.light_to_world(uniform_sample_cone(u1, s.cos_total_width))
     ray = default(pool, Ray; o=s.position, d=w)
     light_normal = Normal3f(ray.d)

src/materials/uber-material.jl

@@ -19,32 +19,36 @@ struct TrowbridgeReitzDistribution <: MicrofacetDistribution
 end
 
 
-abstract type Fresnel end
-struct FresnelConductor{S<:Spectrum} <: Fresnel
-    ηi::S
-    ηt::S
-    k::S
+const FRESNEL_CONDUCTOR = UInt8(1)
+const FRESNEL_DIELECTRIC = UInt8(2)
+const FRESNEL_NO_OP = UInt8(3)
+
+struct Fresnel
+    ηi::RGBSpectrum
+    ηt::RGBSpectrum
+    k::RGBSpectrum
+    type::UInt8
 end
-FresnelConductor() = FresnelConductor(RGBSpectrum(0f0), RGBSpectrum(0f0), RGBSpectrum(0f0))
-struct FresnelDielectric <: Fresnel
-    ηi::Float32
-    ηt::Float32
+
+FresnelConductor(ni, nt, k) = Fresnel(ni, nt, k, FRESNEL_CONDUCTOR)
+FresnelDielectric(ni::Float32, nt::Float32) = Fresnel(RGBSpectrum(ni), RGBSpectrum(nt), RGBSpectrum(0.0f0), FRESNEL_DIELECTRIC)
+FresnelNoOp() = Fresnel(RGBSpectrum(0.0f0), RGBSpectrum(0.0f0), RGBSpectrum(0.0f0), FRESNEL_NO_OP)
+
+function (f::Fresnel)(cos_θi::Float32)
+    if f.type === FRESNEL_CONDUCTOR
+        return fresnel_conductor(cos_θi, f.ηi, f.ηt, f.k)
+    elseif f.type === FRESNEL_DIELECTRIC
+        return fresnel_dielectric(cos_θi, f.ηi[1], f.ηt[1])
+    end
+    return RGBSpectrum(1.0f0)
 end
-FresnelDielectric() = FresnelDielectric(0f0, 0f0)
-struct FresnelNoOp <: Fresnel end
-(f::FresnelConductor)(cos_θi::Float32) = fresnel_conductor(cos_θi, f.ηi, f.ηt, f.k)
-(f::FresnelDielectric)(cos_θi::Float32) = fresnel_dielectric(cos_θi, f.ηi, f.ηt)
-(f::FresnelNoOp)(::Float32) = RGBSpectrum(1.0f0)
+
 
 struct UberBxDF{S<:Spectrum}
     """
     Describes fresnel properties.
     """
-    fresnel_con::FresnelConductor{S}
-    fresnel_di::FresnelDielectric
-    fresnel_no::FresnelNoOp
-    which_fresnel::UInt8 # selected fresnel
-
+    fresnel::Fresnel
     """
     Spectrum used to scale the reflected color.
     """
@@ -82,34 +86,14 @@ function UberBxDF{S}(active::Bool, bxdf_type::UInt8;
         r=Trace.RGBSpectrum(1f0), t=Trace.RGBSpectrum(1f0),
         a=0f0, b=0f0, η_a=0f0, η_b=0f0,
         distribution=TrowbridgeReitzDistribution(),
-        fresnel=nothing,
+        fresnel=FresnelNoOp(),
         type=UInt8(0),
         transport=UInt8(0)
     ) where {S<:Spectrum}
-    used_fresnel = UInt8(0)
-    fresnel_con = FresnelConductor()
-    fresnel_di = FresnelDielectric()
-    fresnel_no = FresnelNoOp()
-
-    if !isnothing(fresnel)
-        if fresnel isa FresnelConductor
-            fresnel_con = fresnel
-            used_fresnel = UInt8(1)
-        elseif fresnel isa FresnelDielectric
-            fresnel_di = fresnel
-            used_fresnel = UInt8(2)
-        elseif fresnel isa FresnelNoOp
-            fresnel_no = fresnel
-            used_fresnel = UInt8(3)
-        end
-    end
     _distribution = distribution isa TrowbridgeReitzDistribution ? distribution : TrowbridgeReitzDistribution()
-    return UberBxDF{S}(fresnel_con, fresnel_di, fresnel_no, used_fresnel, r, t, a, b, η_a, η_b, _distribution, transport, type, bxdf_type, active)
+    return UberBxDF{S}(fresnel, r, t, a, b, η_a, η_b, _distribution, transport, type, bxdf_type, active)
 end
 
-fresnel(f::UberBxDF)= getfield(f, Int(f.which_fresnel))
-
-
 @inline function sample_f(s::UberBxDF, wo::Vec3f, sample::Point2f)::Tuple{Vec3f,Float32,RGBSpectrum,UInt8}
     if s.bxdf_type === SPECULAR_REFLECTION
         return sample_specular_reflection(s, wo, sample)

src/reflection/microfacet.jl

@@ -213,7 +213,7 @@ function distribution_microfacet_reflection(m::UberBxDF{S}, wo::Vec3f, wi::Vec3f
     (cosθi ≈ 0 || cosθo ≈ 0) && return S(0f0)
     wh ≈ Vec3f(0) && return S(0f0)
     wh = normalize(wh)
-    f = fresnel(m)(wi ⋅ face_forward(wh, Vec3f(0, 0, 1)))
+    f = m.fresnel(wi ⋅ face_forward(wh, Vec3f(0, 0, 1)))
     return m.r * D(m.distribution, wh) * G(m.distribution, wo, wi) *
         f / (4f0 * cosθi * cosθo)
 end