make li(...) iterative (normal raytracing broken)

Author: SimonDanisch

src/gpu-support.jl

@@ -33,13 +33,14 @@ function to_gpu(ArrayType, m::Trace.UberMaterial; 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)
+    f_tex = to_gpu(ArrayType, Trace.Texture(zeros(Float32, 1, 1)); preserve=preserve)
     no_tex_f = typeof(f_tex)()
     return Trace.UberMaterial(
         Kd,
         Trace.no_texture(m.Ks) ? no_tex_s : to_gpu(ArrayType, m.Ks; preserve=preserve),
         Trace.no_texture(m.Kr) ? no_tex_s : to_gpu(ArrayType, m.Kr; preserve=preserve),
         Trace.no_texture(m.Kt) ? no_tex_s : to_gpu(ArrayType, m.Kt; preserve=preserve),
+
         Trace.no_texture(m.σ) ? no_tex_f : to_gpu(ArrayType, m.σ; preserve=preserve),
         Trace.no_texture(m.roughness) ? no_tex_f : to_gpu(ArrayType, m.roughness; preserve=preserve),
         Trace.no_texture(m.u_roughness) ? no_tex_f : to_gpu(ArrayType, m.u_roughness; preserve=preserve),

src/integrators/sampler.jl

@@ -81,6 +81,8 @@ function get_material(scene::Scene, shape::Triangle)
     get_material(scene.aggregate, shape)
 end
 
+using KernelAbstractions.Extras.LoopInfo: @unroll
+
 function li(
         sampler, max_depth, ray::RayDifferentials, scene::Scene, depth::Int64,
     )::RGBSpectrum
@@ -138,13 +140,121 @@ function li(
     l
 end
 
+
+function only_light(lights, ray)
+    l = RGBSpectrum(0.0f0)
+    Base.Cartesian.@nexprs 8 i -> begin
+        if i <= length(lights)
+            light = lights[i]
+            l += le(light, ray)
+        end
+    end
+    return l
+end
+
+function li_iterative(scene, sampler, ray, lights)
+    l = RGBSpectrum(0.0f0)
+    srf = RGBSpectrum(1.0f0)
+    stf = RGBSpectrum(1.0f0)
+    i = Int32(0)
+    max_depth = Int32(3)
+    reflect = false
+    transmit = false
+    recursion_depth = Int32(0)
+    last_ray = ray
+    while i ≤ max_depth
+        i += Int32(1)
+        if reflect && i == max_depth
+            # i = recursion_depth
+            reflect = false
+            srf = RGBSpectrum(1.0f0)
+            ray = last_ray
+        end
+        if transmit && i == max_depth
+            # i = recursion_depth
+            transmit = false
+            stf = RGBSpectrum(1.0f0)
+        end
+        l *= srf
+        l *= stf
+        # Find closest ray intersection or return background radiance.
+        hit, shape, si = intersect!(scene, ray)
+        if !hit
+            l = only_light(lights, ray)
+            break
+        end
+        f, _ray, bsdf = li_norec(shape, sampler, ray, scene, si)
+        l += f
+        if _ray !== ray
+            last_ray = ray
+            ray = _ray
+
+            continue
+        end
+        # Trace rays for specular reflection & refraction.
+        srf, rayr = specular_reflect(bsdf, sampler, ray, si)
+        if rayr !== ray
+            last_ray = ray
+            ray = rayr
+            reflect = true
+            # recursion_depth = i
+            continue
+        end
+        stf, rayt = specular_transmit(bsdf, sampler, ray, si)
+        if rayt !== ray
+            ray = rayt
+            transmit = true
+            recursion_depth = i
+            continue
+        end
+    end
+    return l
+end
+
+function li_norec(
+        shape, sampler, ray::RayDifferentials, scene::Scene, si::SurfaceInteraction
+    )
+
+    l = RGBSpectrum(0.0f0)
+    lights = scene.lights
+    bsdf = BSDF()
+    # Compute emmited & reflected light at ray intersection point.
+    # Initialize common variables for Whitted integrator.
+    core = si.core
+    n = si.shading.n
+    wo = core.wo
+    # Compute scattering functions for surface interaction.
+    si = compute_differentials(si, ray)
+    m = get_material(scene, shape)
+    if m.type === NO_MATERIAL
+        return l, RayDifferentials(spawn_ray(si, ray.d)), bsdf
+    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.
+    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 ≈ 0.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
+    return l, ray, bsdf
+end
+
 @inline function specular_reflect(
-        bsdf, sampler, max_depth, ray::RayDifferentials,
-        si::SurfaceInteraction, scene::Scene, depth::Int64,
+        bsdf, sampler, ray::RayDifferentials, si::SurfaceInteraction
     )
 
     # Compute specular reflection direction `wi` and BSDF value.
-
     wo = si.core.wo
     type = BSDF_REFLECTION | BSDF_SPECULAR
     wi, f, pdf, sampled_type = sample_f(
@@ -153,7 +263,7 @@ end
     # Return contribution of specular reflection.
     ns = si.shading.n
     if !(pdf > 0f0 && !is_black(f) && abs(wi ⋅ ns) != 0f0)
-        return RGBSpectrum(0f0)
+        return RGBSpectrum(1f0), ray
     end
     # # Compute ray differential for specular reflection.
     rd = RayDifferentials(spawn_ray(si, wi))
@@ -179,12 +289,12 @@ end
         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(sampler, max_depth, rd, scene, depth + 1) * abs(wi ⋅ ns) / pdf
+    return f * abs(wi ⋅ ns) / pdf, rd
 end
 
 @inline function specular_transmit(
-        bsdf, sampler, max_depth, ray::RayDifferentials,
-        surface_intersect::SurfaceInteraction, scene::Scene, depth::Int64,
+        bsdf, sampler, ray::RayDifferentials,
+        surface_intersect::SurfaceInteraction
     )
 
     # Compute specular reflection direction `wi` and BSDF value.
@@ -196,7 +306,7 @@ end
 
     ns = surface_intersect.shading.n
     if !(pdf > 0f0 && !is_black(f) && abs(wi ⋅ ns) != 0f0)
-        return RGBSpectrum(0f0)
+        return RGBSpectrum(1f0), ray
     end
     # TODO shift in ray direction instead of normal?
     rd = RayDifferentials(spawn_ray(surface_intersect, wi))
@@ -236,5 +346,5 @@ end
         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(sampler, max_depth, rd, scene, depth + 1) * abs(wi ⋅ ns) / pdf
+    f * abs(wi ⋅ ns) / pdf, rd
 end

src/materials/uber-material.jl

@@ -34,13 +34,14 @@ 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
+function (f::Fresnel)(cos_θi::Float32)::Float32
+    # if f.type === FRESNEL_CONDUCTOR
+    #     return fresnel_conductor(cos_θi, f.ηi, f.ηt, f.k)
+    # else
+    if f.type === FRESNEL_DIELECTRIC
         return fresnel_dielectric(cos_θi, f.ηi[1], f.ηt[1])
     end
-    return RGBSpectrum(1.0f0)
+    return 1f0
 end
 
 

src/reflection/bxdf.jl

@@ -92,5 +92,5 @@ function fresnel_conductor(
     t3 = cos_θi2 * a2_plus_b2 + sin_θi2 * sin_θi2
     t4 = t2 * sin_θi2
     r_parallel = r_perp * (t3 - t4) / (t3 + t4)
-    0.5f0 * (r_parallel + r_perp)
+    return 0.5f0 * (r_parallel + r_perp)
 end

src/spectrum.jl

@@ -33,8 +33,8 @@ lerp(c1::C, c2::C, t::Float32) where C<:Spectrum = (1f0 - t) * c1 + t * c2
 Base.getindex(c::C, i) where C<:Spectrum = c.c[i]
 
 function Base.clamp(
-    c::C, low::Float32 = 0f0, high::Float32 = Inf32,
-) where C<:Spectrum
+        c::C, low::Float32 = 0f0, high::Float32 = Inf32,
+    ) where C<:Spectrum
     C(clamp.(c.c, low, high))
 end
 

src/textures/basic.jl

@@ -26,13 +26,10 @@ function Base.convert(::Type{Texture{ElType,N,T}}, ::NoTexture) where {ElType,N,
 end
 
 function (c::Texture{T})(si::SurfaceInteraction)::T where {T<:TextureType}
-    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)
-        @inbounds return c.data[idx...]
-    end
+    c.isconst && return c.const_value
+    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)
+    @inbounds return c.data[idx...]
 end