some more fixes

Author: SimonDanisch

src/Trace.jl

@@ -180,14 +180,14 @@ struct Scene{P<:Primitive, L<:NTuple{N, Light} where N}
     lights::L
     aggregate::P
     bound::Bounds3
+end
 
-    function Scene(
-        lights::Vector{L}, aggregate::P,
-    ) where L<:Light where P<:Primitive
-        # TODO preprocess for lights
-        ltuple = Tuple(lights)
-        new{P,typeof(ltuple)}(ltuple, aggregate, world_bound(aggregate))
-    end
+function Scene(
+        lights::Union{Tuple,AbstractVector}, aggregate::P,
+    ) where {P<:Primitive}
+    # TODO preprocess for lights
+    ltuple = Tuple(lights)
+    Scene{P,typeof(ltuple)}(ltuple, aggregate, world_bound(aggregate))
 end
 
 @inline function intersect!(scene::Scene, ray::AbstractRay)

src/gpu-support.jl

@@ -24,9 +24,15 @@ function to_gpu(ArrayType, m::Trace.Texture; preserve=[])
 end
 
 function to_gpu(ArrayType, m::Trace.UberMaterial; preserve=[])
-    @assert !Trace.no_texture(m.Kd)
-    Kd = to_gpu(ArrayType, m.Kd; preserve=preserve)
-    no_tex_s = typeof(Kd)()
+    if !Trace.no_texture(m.Kd)
+        Kd = to_gpu(ArrayType, m.Kd; preserve=preserve)
+        no_tex_s = typeof(Kd)()
+        Kr = Trace.no_texture(m.Kr) ? no_tex_s : to_gpu(ArrayType, m.Kr; preserve=preserve)
+    else
+        Kr = to_gpu(ArrayType, m.Kr; preserve=preserve)
+        no_tex_s = typeof(Kr)()
+        Kd = Trace.no_texture(m.Kd) ? no_tex_s : to_gpu(ArrayType, m.Kd; preserve=preserve)
+    end
     f_tex = to_gpu(ArrayType, Trace.Texture(ArrayType(zeros(Float32, 1, 1))); preserve=preserve)
     no_tex_f = typeof(f_tex)()
     return Trace.UberMaterial(
@@ -52,3 +58,8 @@ function to_gpu(ArrayType, bvh::Trace.BVHAccel; preserve=[])
     materials = to_gpu(ArrayType, to_gpu.((ArrayType,), bvh.materials; preserve=preserve); preserve=preserve)
     return Trace.BVHAccel(primitives, materials, bvh.max_node_primitives, nodes)
 end
+
+function to_gpu(ArrayType, scene::Trace.Scene; preserve=[])
+    bvh = to_gpu(ArrayType, scene.aggregate; preserve=preserve)
+    return Trace.Scene(scene.lights, bvh, scene.bound)
+end

src/integrators/sampler.jl

@@ -6,30 +6,27 @@ struct WhittedIntegrator{C<: Camera, S <: AbstractSampler} <: SamplerIntegrator
     max_depth::Int64
 end
 
-
 function sample_kernel_inner(i::A, scene::B, t_sampler::C, film::D, film_tile::E, camera::F, pixel::G, spp_sqr::H) where {A, B, C, D, E, F, G, H}
-    while has_next_sample(t_sampler)
+    for _ in 1:t_sampler.samples_per_pixel
         camera_sample = get_camera_sample(t_sampler, pixel)
         ray, ω = generate_ray_differential(camera, camera_sample)
         ray = scale_differentials(ray, spp_sqr)
         l = RGBSpectrum(0f0)
         if ω > 0.0f0
-            l = li(i, ray, scene, 1)
+            l = li(t_sampler, i.max_depth, 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(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(i, scene, t_sampler, film, film_tile, camera, pixel, spp_sqr)
     end
     merge_film_tile!(film, film_tile)
@@ -73,18 +70,19 @@ function (i::SamplerIntegrator)(scene::Scene, film)
 end
 
 function get_material(bvh::BVHAccel, shape::Triangle)
+    materials = bvh.materials
     @inbounds if shape.material_idx == 0
-        return bvh.materials[1]
+        return materials[1]
     else
-        return bvh.materials[shape.material_idx]
+        return materials[shape.material_idx]
     end
 end
 function get_material(scene::Scene, shape::Triangle)
     get_material(scene.aggregate, shape)
 end
 
 function li(
-        i::WhittedIntegrator, ray::RayDifferentials, scene::Scene, depth::Int64,
+        sampler, max_depth, ray::RayDifferentials, scene::Scene, depth::Int64,
     )::RGBSpectrum
 
     l = RGBSpectrum(0f0)
@@ -106,64 +104,69 @@ function li(
     m = get_material(scene, shape)
     if m.type === NO_MATERIAL
         return li(
-            i, RayDifferentials(spawn_ray(si, ray.d)),
+            sampler, max_depth, RayDifferentials(spawn_ray(si, ray.d)),
             scene, depth,
         )
     end
     bsdf = m(si, false, Radiance)
     # Compute emitted light if ray hit an area light source.
     l += le(si, wo)
     # Add contribution of each light source.
-    for light in scene.lights
-        sampled_li, wi, pdf, visibility_tester = sample_li(
-            light, core, get_2d(i.sampler),
-        )
-        (is_black(sampled_li) || pdf ≈ 0f0) && continue
-        f = bsdf(wo, wi)
-        if !is_black(f) && unoccluded(visibility_tester, scene)
-            l += f * sampled_li * abs(wi ⋅ n) / pdf
+    lights = scene.lights
+    Base.Cartesian.@nexprs 8 i -> begin
+        if i <= length(lights)
+            light = lights[i]
+            sampled_li, wi, pdf, visibility_tester = sample_li(
+                light, core, get_2d(sampler),
+            )
+            if !(is_black(sampled_li) || pdf ≈ 0f0)
+                f = bsdf(wo, wi)
+                if !is_black(f) && unoccluded(visibility_tester, scene)
+                    l += f * sampled_li * abs(wi ⋅ n) / pdf
+                end
+            end
         end
     end
-    if depth + 1 ≤ i.max_depth
+    if depth + 1 ≤ max_depth
         # Trace rays for specular reflection & refraction.
-        l += specular_reflect(bsdf, i, ray, si, scene, depth)
-        l += specular_transmit(bsdf, i, ray, si, scene, depth)
+        l += specular_reflect(bsdf, sampler, max_depth, ray, si, scene, depth)
+        l += specular_transmit(bsdf, sampler, max_depth, ray, si, scene, depth)
     end
     l
 end
 
-function specular_reflect(
-        bsdf, i::I, ray::RayDifferentials,
-        surface_intersect::SurfaceInteraction, scene::Scene, depth::Int64,
-    ) where I<:SamplerIntegrator
+@inline function specular_reflect(
+        bsdf, sampler, max_depth, ray::RayDifferentials,
+        si::SurfaceInteraction, scene::Scene, depth::Int64,
+    )
 
     # Compute specular reflection direction `wi` and BSDF value.
 
-    wo = surface_intersect.core.wo
+    wo = si.core.wo
     type = BSDF_REFLECTION | BSDF_SPECULAR
     wi, f, pdf, sampled_type = sample_f(
-        bsdf, wo, get_2d(i.sampler), type,
+        bsdf, wo, get_2d(sampler), type,
     )
     # Return contribution of specular reflection.
-    ns = surface_intersect.shading.n
+    ns = si.shading.n
     if !(pdf > 0f0 && !is_black(f) && abs(wi ⋅ ns) != 0f0)
         return RGBSpectrum(0f0)
     end
     # Compute ray differential for specular reflection.
-    rd = RayDifferentials(spawn_ray(surface_intersect, wi))
+    rd = RayDifferentials(spawn_ray(si, wi))
     if ray.has_differentials
-        rx_origin = surface_intersect.core.p + surface_intersect.∂p∂x
-        ry_origin = surface_intersect.core.p + surface_intersect.∂p∂y
+        rx_origin = si.core.p + si.∂p∂x
+        ry_origin = si.core.p + si.∂p∂y
         # Compute differential reflected directions.
         ∂n∂x = (
-            surface_intersect.shading.∂n∂u * surface_intersect.∂u∂x
+            si.shading.∂n∂u * si.∂u∂x
             +
-            surface_intersect.shading.∂n∂v * surface_intersect.∂v∂x
+            si.shading.∂n∂v * si.∂v∂x
         )
         ∂n∂y = (
-            surface_intersect.shading.∂n∂u * surface_intersect.∂u∂y
+            si.shading.∂n∂u * si.∂u∂y
             +
-            surface_intersect.shading.∂n∂v * surface_intersect.∂v∂y
+            si.shading.∂n∂v * si.∂v∂y
         )
         ∂wo∂x = -ray.rx_direction - wo
         ∂wo∂y = -ray.ry_direction - wo
@@ -173,19 +176,19 @@ function specular_reflect(
         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(i, rd, scene, depth + 1) * abs(wi ⋅ ns) / pdf
+    return f * li(sampler, max_depth, rd, scene, depth + 1) * abs(wi ⋅ ns) / pdf
 end
 
-function specular_transmit(
-        bsdf, i::S, ray::RayDifferentials,
+@inline function specular_transmit(
+        bsdf, sampler, max_depth, ray::RayDifferentials,
         surface_intersect::SurfaceInteraction, scene::Scene, depth::Int64,
-    ) where S<:SamplerIntegrator
+    )
 
     # Compute specular reflection direction `wi` and BSDF value.
     wo = surface_intersect.core.wo
     type = BSDF_TRANSMISSION | BSDF_SPECULAR
     wi, f, pdf, sampled_type = sample_f(
-        bsdf, wo, get_2d(i.sampler), type,
+        bsdf, wo, get_2d(sampler), type,
     )
 
     ns = surface_intersect.shading.n
@@ -223,12 +226,12 @@ function specular_transmit(
         ∂dn∂x = ∂wo∂x ⋅ ns + wo ⋅ ∂n∂x
         ∂dn∂y = ∂wo∂y ⋅ ns + wo ⋅ ∂n∂y
         μ = η * (wo ⋅ ns) - abs(wi ⋅ ns)
-        ν = η - (η^2 * (wo ⋅ ns)) / abs(wi ⋅ ns)
+        ν = η - (η * η * (wo ⋅ ns)) / abs(wi ⋅ ns)
         ∂μ∂x = ν * ∂dn∂x
         ∂μ∂y = ν * ∂dn∂y
         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(i, rd, scene, depth + 1) * abs(wi ⋅ ns) / pdf
+    f * li(sampler, max_depth, rd, scene, depth + 1) * abs(wi ⋅ ns) / pdf
 end

src/materials/bsdf.jl

@@ -142,7 +142,7 @@ function sample_f(
     # Get BxDF for chosen component.
     count = component
     component -= 1
-    bxdf = nothing
+    bxdf = UberBxDF{RGBSpectrum}()
     bxdfs = b.bxdfs
     Base.Cartesian.@nexprs 8 i -> begin
         if i <= bxdfs.last
@@ -155,7 +155,7 @@ function sample_f(
             end
         end
     end
-    @real_assert !isnothing(bxdf) "n bxdfs $(b.n_bxdfs), component $component, count $count"
+    @real_assert bxdf.active "n bxdfs $(b.n_bxdfs), component $component, count $count"
     # Remap BxDF sample u to [0, 1)^2.
     u_remapped = Point2f(
         min(u[1] * matching_components - component, 1f0), u[2],

src/materials/material.jl

@@ -1,4 +1,4 @@
-MATTE_MATERIAL = UInt8(1)
+const MATTE_MATERIAL = UInt8(1)
 
 
 """

src/reflection/microfacet.jl

@@ -76,8 +76,8 @@ correspond to near-perfect specular reflection, rather than by specifying
 @inline function roughness_to_α(roughness::Float32)::Float32
     roughness = max(1f-3, roughness)
     x = log(roughness)
-    1.62142f0 + 0.819955f0 * x + 0.1734f0 * x^2 +
-    0.0171201f0 * x^3 + 0.000640711f0 * x^4
+    1.62142f0 + 0.819955f0 * x + 0.1734f0 * x*x +
+    0.0171201f0 * x*x*x + 0.000640711f0 * x*x*x*x
 end
 
 @inline function G1(m::MicrofacetDistribution, w::Vec3f)::Float32
@@ -273,7 +273,7 @@ function distribution_microfacet_transmission(m::UberBxDF{S}, wo::Vec3f, wi::Vec
     )
 end
 
-@inline function sample_microfacet_transmission(m::UberBxDF{S}, wo::Vec3f, u::Point2f)::S where {S<:Spectrum}
+@inline function sample_microfacet_transmission(m::UberBxDF{S}, wo::Vec3f, u::Point2f) where {S<:Spectrum}
 
     wo[3] ≈ 0 && return Vec3f(0f0), 0f0, S(0f0), UInt8(0)
     wh = sample_wh(m.distribution, wo, u)

src/sampler/sampler.jl

@@ -155,7 +155,7 @@ function get_2d(ps::PixelSampler)::Point2f
 end
 
 
-mutable struct UniformSampler <: AbstractSampler
+struct UniformSampler <: AbstractSampler
     current_sample::Int64
     samples_per_pixel::Int64
     UniformSampler(samples_per_pixel::Integer) = new(1, samples_per_pixel)

src/textures/basic.jl

@@ -26,13 +26,13 @@ function Base.convert(::Type{Texture{ElType,N,T}}, ::NoTexture) where {ElType,N,
 end
 
 function (c::Texture{T})(si::SurfaceInteraction)::T where {T<:TextureType}
-    @inbounds if c.isconst
+    if c.isconst
         return c.const_value
     else
         uv = Vec2f(1f0 - si.uv[2], si.uv[1])
         s = unsafe_trunc.(Int32, size(c.data))
         idx = map(x -> unsafe_trunc(Int32, x), Int32(1) .+ ((s .- Int32(1)) .* uv))
         idx = clamp.(idx, Int32(1), s)
-        return c.data[idx...]
+        @inbounds return c.data[idx...]
     end
 end