remove pool

Author: SimonDanisch

src/Trace.jl

@@ -189,30 +189,30 @@ struct Scene{P<:Primitive, L<:NTuple{N, Light} where N}
     end
 end
 
-@inline function intersect!(pool, scene::Scene, ray::Union{Ray,RayDifferentials})
-    intersect!(pool, scene.aggregate, ray)
+@inline function intersect!(scene::Scene, ray::AbstractRay)
+    intersect!(scene.aggregate, ray)
 end
-@inline function intersect_p(pool, scene::Scene, ray::Union{Ray,RayDifferentials})
-    intersect_p(pool, scene.aggregate, ray)
+@inline function intersect_p(scene::Scene, ray::AbstractRay)
+    intersect_p(scene.aggregate, ray)
 end
 
 @inline function spawn_ray(
-    pool, p0::Interaction, p1::Interaction, δ::Float32 = 1f-6,
-)::Ray
+        p0::Interaction, p1::Interaction, δ::Float32 = 1f-6,
+    )::Ray
     direction = p1.p - p0.p
     origin = p0.p .+ δ .* direction
-    return allocate(pool, Ray, (origin, direction, Inf32, p0.time))
+    return Ray(origin, direction, Inf32, p0.time)
 end
 
-@inline function spawn_ray(pool, p0::SurfaceInteraction, p1::Interaction)::Ray
-    spawn_ray(pool, p0.core, p1)
+@inline function spawn_ray(p0::SurfaceInteraction, p1::Interaction)::Ray
+    spawn_ray(p0.core, p1)
 end
 
 @inline function spawn_ray(
-        pool, si::SurfaceInteraction, direction::Vec3f, δ::Float32 = 1f-6,
+        si::SurfaceInteraction, direction::Vec3f, δ::Float32 = 1f-6,
     )::Ray
     origin = si.core.p .+ δ .* direction
-    return default(pool, Ray; o=origin, d=direction, time=si.core.time)
+    return Ray(o=origin, d=direction, time=si.core.time)
 end
 
 include("shapes/Shape.jl")

src/accel/bvh.jl

@@ -210,12 +210,12 @@ end
     length(bvh.nodes) > 0 ? bvh.nodes[1].bounds : Bounds3()
 end
 
-function intersect!(pool, bvh::BVHAccel{P}, ray::MutableRef{<:AbstractRay})::Tuple{Bool, P, SurfaceInteraction} where P
+function intersect!(bvh::BVHAccel{P}, ray::AbstractRay)::Tuple{Bool,P,SurfaceInteraction} where {P}
     hit = false
     interaction = SurfaceInteraction()
     isempty(bvh.nodes) && return hit, nothing, interaction
 
-    check_direction!(ray)
+    ray = check_direction(ray)
     inv_dir = 1f0 ./ ray.d
     dir_is_neg = is_dir_negative(ray.d)
 
@@ -227,13 +227,13 @@ function intersect!(pool, bvh::BVHAccel{P}, ray::MutableRef{<:AbstractRay})::Tup
     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)
+        if intersect_p(ln.bounds, ray, inv_dir, dir_is_neg)
             if ln isa LinearBVHLeaf && ln.n_primitives > 0
                 # Intersect ray with primitives in node.
                 for i in 0:ln.n_primitives-1
                     tmp_primitive = bvh.primitives[ln.primitives_offset+i]
-                    tmp_hit, tmp_interaction = intersect_p!(
-                        pool, tmp_primitive, ray,
+                    tmp_hit, ray, tmp_interaction = intersect_p!(
+                        tmp_primitive, ray,
                     )
                     if tmp_hit && !(tmp_interaction isa Vec3)
                         hit = tmp_hit
@@ -263,10 +263,10 @@ function intersect!(pool, bvh::BVHAccel{P}, ray::MutableRef{<:AbstractRay})::Tup
     return hit, primitive, interaction
 end
 
-function intersect_p(pool, bvh::BVHAccel, ray::MutableRef{<:AbstractRay})
+function intersect_p(bvh::BVHAccel, ray::AbstractRay)
     length(bvh.nodes) == 0 && return false
 
-    check_direction!(ray)
+    ray = check_direction(ray)
     inv_dir = 1f0 ./ ray.d
     dir_is_neg = is_dir_negative(ray.d)
 
@@ -276,11 +276,11 @@ function intersect_p(pool, bvh::BVHAccel, ray::MutableRef{<:AbstractRay})
 
     while true
         ln = bvh.nodes[current_node_i]
-        if intersect_p(pool, ln.bounds, ray, inv_dir, dir_is_neg)
+        if intersect_p(ln.bounds, ray, inv_dir, dir_is_neg)
             if ln isa LinearBVHLeaf && ln.n_primitives > 0
                 for i in 0:ln.n_primitives-1
                     intersect_p(
-                        pool, bvh.primitives[ln.primitives_offset+i], ray,
+                        bvh.primitives[ln.primitives_offset+i], ray,
                     ) && return true
                 end
                 to_visit_offset == 1 && break

src/bounds.jl

@@ -152,7 +152,7 @@ function bounding_sphere(b::Bounds3)::Tuple{Point3f,Float32}
     center, radius
 end
 
-function intersect(b::Bounds3, ray::MutableRef{<:AbstractRay})::Tuple{Bool,Float32,Float32}
+function intersect(b::Bounds3, ray::AbstractRay)::Tuple{Bool,Float32,Float32}
     t0, t1 = 0f0, ray.t_max
     @inbounds for i in 1:3
         # Update interval for i-th bbox slab.
@@ -182,9 +182,9 @@ end
 dir_is_negative: 1 -- false, 2 -- true
 """
 function intersect_p(
-    pool, b::Bounds3, ray::MutableRef{<:AbstractRay},
-    inv_dir::Vec3f, dir_is_negative::Point3{UInt8},
-)::Bool
+        b::Bounds3, ray::AbstractRay,
+        inv_dir::Vec3f, dir_is_negative::Point3{UInt8},
+    )::Bool
     tx_min = (b[dir_is_negative[1]][1] - ray.o[1]) * inv_dir[1]
     tx_max = (b[3-dir_is_negative[1]][1] - ray.o[1]) * inv_dir[1]
     ty_min = (b[dir_is_negative[2]][2] - ray.o[2]) * inv_dir[2]

src/camera/camera.jl

@@ -37,30 +37,30 @@ set this value to indicate how much light carries through the lenses,
 based on their optical properties.
 """
 function generate_ray(
-    camera::C, sample::CameraSample,
-)::Tuple{Ray,Float32} where C<:Camera
+        camera::C, sample::CameraSample,
+    )::Tuple{Ray,Float32} where C<:Camera
 end
 """
 Same as `generate_ray`, but also computes rays for pixels shifted one pixel
 in x & y directions on the film plane.
 Useful for anti-aliasing textures.
 """
 function generate_ray_differential(
-    pool::MemoryPool,
-    camera::C, sample::CameraSample,
-)::Tuple{RayDifferentials,Float32} where C<:Camera
-    ray, wt = generate_ray(pool, camera, sample)
+        camera::C, sample::CameraSample,
+    )::Tuple{RayDifferentials,Float32} where C<:Camera
+
+    ray, wt = generate_ray(camera, sample)
     shifted_x = CameraSample(
         sample.film + Point2f(1f0, 0f0), sample.lens, sample.time,
     )
     shifted_y = CameraSample(
         sample.film + Point2f(0f0, 1f0), sample.lens, sample.time,
     )
-    ray_x, wt_x = generate_ray(pool, camera, shifted_x)
-    ray_y, wt_y = generate_ray(pool, camera, shifted_y)
-    rayd = allocate(pool, RayDifferentials,
-        (ray.o, ray.d, ray.t_max, ray.time,
-        true, ray_x.o, ray_y.o, ray_x.d, ray_y.d)
+    ray_x, wt_x = generate_ray(camera, shifted_x)
+    ray_y, wt_y = generate_ray(camera, shifted_y)
+    rayd = RayDifferentials(
+        ray.o, ray.d, ray.t_max, ray.time,
+        true, ray_x.o, ray_y.o, ray_x.d, ray_y.d
     )
     rayd, wt
 end

src/camera/perspective.jl

@@ -82,15 +82,13 @@ end
 
 @inline get_film(c::PerspectiveCamera)::Film = c.core.core.film
 
-function generate_ray(
-    pool::MemoryPool,
-    camera::PerspectiveCamera, sample::CameraSample,
-)::Tuple{Ray,Float32}
+@inline function generate_ray(
+        camera::PerspectiveCamera, sample::CameraSample,
+    )::Tuple{Ray,Float32}
     # Compute raster & camera sample positions.
     p_film = Point3f(sample.film[1], sample.film[2], 0f0)
     p_camera = camera.core.raster_to_camera(p_film)
-
-    ray = default(pool, Ray; o=Point3f(0), d=normalize(Vec3f(p_camera)))
+    ray = Ray(o=Point3f(0), d=normalize(Vec3f(p_camera)))
     # Modify ray for depth of field.
     if camera.core.lens_radius > 0
         # Sample points on lens.
@@ -103,13 +101,13 @@ function generate_ray(
         ray.d = normalize(Vec3f(p_focus - ray.o))
     end
 
-    ray.time = lerp(
+    time = lerp(
         camera.core.core.shutter_open,
         camera.core.core.shutter_close,
         sample.time,
     )
     # TODO add medium
-    apply!(camera.core.core.camera_to_world, ray)
-    ray.d = normalize(ray.d)
+    ray = apply(camera.core.core.camera_to_world, ray)
+    Ray(ray, d=normalize(ray.d))
     ray, 1f0
 end

src/integrators/sampler.jl

@@ -6,15 +6,14 @@ struct WhittedIntegrator{C<: Camera, S <: AbstractSampler} <: SamplerIntegrator
     max_depth::Int64
 end
 
-@noinline function sample_kernel_inner(pool, i, scene, t_sampler, film, film_tile, camera, pixel, spp_sqr)
+@noinline function sample_kernel_inner(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)
+        ray, ω = generate_ray_differential(camera, camera_sample)
+        ray = scale_differentials(ray, spp_sqr)
         l = RGBSpectrum(0f0)
         if ω > 0.0f0
-            l = li(pool, i, ray, scene, 1)
+            l = li(i, ray, scene, 1)
         end
         # TODO check l for invalid values
         if isnan(l)
@@ -25,14 +24,12 @@ end
     end
 end
 
-@noinline function sample_kernel(mempools, i, camera, scene, film, film_tile, tile_bounds)
-
-    pool = mempools[Threads.threadid()]
+@noinline function sample_kernel(i, camera, scene, film, film_tile, tile_bounds)
     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)
+        sample_kernel_inner(i, scene, t_sampler, film, film_tile, camera, pixel, spp_sqr)
     end
     merge_film_tile!(film, film_tile)
 end
@@ -51,7 +48,6 @@ function (i::SamplerIntegrator)(scene::Scene)
     total_tiles = width * height - 1
     bar = Progress(total_tiles, 1)
     @info "Utilizing $(Threads.nthreads()) threads"
-    mempools = [MemoryPool(round(Int, 3*16384)) for _ in 1:Threads.maxthreadid()]
     film = get_film(i.camera)
     camera = i.camera
     filter_radius = film.filter.radius
@@ -70,20 +66,20 @@ function (i::SamplerIntegrator)(scene::Scene)
             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)
+            sample_kernel(i, camera, scene, film, film_tile, tile_bounds)
         end
         next!(bar)
     end
     save(film)
 end
 
 function li(
-        pool, i::WhittedIntegrator, ray::RayDifferentials, scene::Scene, depth::Int64,
+        i::WhittedIntegrator, ray::RayDifferentials, scene::Scene, depth::Int64,
     )::RGBSpectrum
 
     l = RGBSpectrum(0f0)
     # Find closest ray intersection or return background radiance.
-    hit, primitive, si = intersect!(pool, scene, ray)
+    hit, primitive, si = intersect!(scene, ray)
     if !hit
         for light in scene.lights
             l += le(light, ray)
@@ -96,10 +92,10 @@ function li(
     n = si.shading.n
     wo = core.wo
     # Compute scattering functions for surface interaction.
-    si, bsdf = compute_scattering!(pool, primitive, si, ray)
+    si, bsdf = compute_scattering!(primitive, si, ray)
     if bsdf.bxdfs.last == 0
         return li(
-            pool, spawn_ray(pool, si, ray.d),
+            spawn_ray(si, ray.d),
             scene, i.sampler, depth,
         )
     end
@@ -108,7 +104,7 @@ function li(
     # Add contribution of each light source.
     for light in scene.lights
         sampled_li, wi, pdf, visibility_tester = sample_li(
-            pool, light, core, get_2d(i.sampler),
+            light, core, get_2d(i.sampler),
         )
         (is_black(sampled_li) || pdf ≈ 0f0) && continue
         f = bsdf(wo, wi)
@@ -118,14 +114,14 @@ function li(
     end
     if depth + 1 ≤ i.max_depth
         # Trace rays for specular reflection & refraction.
-        l += specular_reflect(pool, bsdf, i, ray, si, scene, depth)
-        l += specular_transmit(pool, bsdf, i, ray, si, scene, depth)
+        l += specular_reflect(bsdf, i, ray, si, scene, depth)
+        l += specular_transmit(bsdf, i, ray, si, scene, depth)
     end
     l
 end
 
 function specular_reflect(
-        pool, bsdf, i::I, ray::RayDifferentials,
+        bsdf, i::I, ray::RayDifferentials,
         surface_intersect::SurfaceInteraction, scene::Scene, depth::Int64,
     ) where I<:SamplerIntegrator
 
@@ -142,11 +138,10 @@ function specular_reflect(
         return RGBSpectrum(0f0)
     end
     # Compute ray differential for specular reflection.
-    rd = allocate(pool, RayDifferentials, spawn_ray(pool, surface_intersect, wi))
+    rd = RayDifferentials(spawn_ray(surface_intersect, wi))
     if ray.has_differentials
-        rd.has_differentials = true
-        rd.rx_origin = surface_intersect.core.p + surface_intersect.∂p∂x
-        rd.ry_origin = surface_intersect.core.p + surface_intersect.∂p∂y
+        rx_origin = surface_intersect.core.p + surface_intersect.∂p∂x
+        ry_origin = surface_intersect.core.p + surface_intersect.∂p∂y
         # Compute differential reflected directions.
         ∂n∂x = (
             surface_intersect.shading.∂n∂u * surface_intersect.∂u∂x
@@ -162,14 +157,15 @@ function specular_reflect(
         ∂wo∂y = -ray.ry_direction - wo
         ∂dn∂x = ∂wo∂x ⋅ ns + wo ⋅ ∂n∂x
         ∂dn∂y = ∂wo∂y ⋅ ns + wo ⋅ ∂n∂y
-        rd.rx_direction = wi - ∂wo∂x + 2f0 * (wo ⋅ ns) * ∂n∂x + ∂dn∂x * ns
-        rd.ry_direction = wi - ∂wo∂y + 2f0 * (wo ⋅ ns) * ∂n∂y + ∂dn∂y * ns
+        rx_direction = wi - ∂wo∂x + 2f0 * (wo ⋅ ns) * ∂n∂x + ∂dn∂x * ns
+        ry_direction = wi - ∂wo∂y + 2f0 * (wo ⋅ ns) * ∂n∂y + ∂dn∂y * ns
+        rd = RayDifferentials(rd, rx_origin=rx_origin, ry_origin=ry_origin, rx_direction=rx_direction, ry_direction=ry_direction)
     end
-    return f * li(pool, i, rd, scene, depth + 1) * abs(wi ⋅ ns) / pdf
+    return f * li(i, rd, scene, depth + 1) * abs(wi ⋅ ns) / pdf
 end
 
 function specular_transmit(
-        pool, bsdf, i::S, ray::RayDifferentials,
+        bsdf, i::S, ray::RayDifferentials,
         surface_intersect::SurfaceInteraction, scene::Scene, depth::Int64,
     ) where S<:SamplerIntegrator
 
@@ -185,11 +181,10 @@ function specular_transmit(
         return RGBSpectrum(0f0)
     end
     # TODO shift in ray direction instead of normal?
-    rd = allocate(pool, RayDifferentials, spawn_ray(pool, surface_intersect, wi))
+    rd = RayDifferentials(spawn_ray(surface_intersect, wi))
     if ray.has_differentials
-        rd.has_differentials = true
-        rd.rx_origin = surface_intersect.core.p + surface_intersect.∂p∂x
-        rd.ry_origin = surface_intersect.core.p + surface_intersect.∂p∂y
+        rx_origin = surface_intersect.core.p + surface_intersect.∂p∂x
+        ry_origin = surface_intersect.core.p + surface_intersect.∂p∂y
         # Compute differential transmitted directions.
         ∂n∂x = (
             surface_intersect.shading.∂n∂u * surface_intersect.∂u∂x
@@ -219,8 +214,9 @@ function specular_transmit(
         ν = η - (η^2 * (wo ⋅ ns)) / abs(wi ⋅ ns)
         ∂μ∂x = ν * ∂dn∂x
         ∂μ∂y = ν * ∂dn∂y
-        rd.rx_direction = wi - η * ∂wo∂x + μ * ∂n∂x + ∂μ∂x * ns
-        rd.ry_direction = wi - η * ∂wo∂y + μ * ∂n∂y + ∂μ∂y * ns
+        rx_direction = wi - η * ∂wo∂x + μ * ∂n∂x + ∂μ∂x * ns
+        ry_direction = wi - η * ∂wo∂y + μ * ∂n∂y + ∂μ∂y * ns
+        rd = RayDifferentials(rd, rx_origin=rx_origin, ry_origin=ry_origin, rx_direction=rx_direction, ry_direction=ry_direction)
     end
-    f * li(pool, i, rd, scene, depth + 1) * abs(wi ⋅ ns) / pdf
+    f * li(i, rd, scene, depth + 1) * abs(wi ⋅ ns) / pdf
 end