make BSDFVector immutable

Author: SimonDanisch

src/accel/bvh.jl

@@ -220,7 +220,7 @@ function intersect!(pool, bvh::BVHAccel, ray::MutableRef{<:AbstractRay})
     inv_dir = 1f0 ./ ray.d
     dir_is_neg = is_dir_negative(ray.d)
 
-    to_visit_offset, current_node_i = 1, 1
+    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 while true
@@ -230,7 +230,7 @@ function intersect!(pool, bvh::BVHAccel, ray::MutableRef{<:AbstractRay})
                 # 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!(
+                    tmp_hit, tmp_interaction = intersect_p!(
                         pool, tmp_primitive, ray,
                     )
                     if tmp_hit && !(tmp_interaction isa Vec3)
@@ -244,7 +244,7 @@ function intersect!(pool, bvh::BVHAccel, ray::MutableRef{<:AbstractRay})
                 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 + 1
+                    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

src/materials/bsdf.jl

@@ -1,4 +1,4 @@
-struct _BXDFVector{S<:Spectrum}
+struct BXDFVector{S<:Spectrum}
     bxdf_1::UberBxDF{S}
     bxdf_2::UberBxDF{S}
     bxdf_3::UberBxDF{S}
@@ -10,8 +10,15 @@ struct _BXDFVector{S<:Spectrum}
     last::UInt8
 end
 
-const BXDFVector{S} = MutableRef{_BXDFVector{S}}
+Base.Base.@propagate_inbounds function Base.getindex(b::BXDFVector, i::Int)
+    i > b.last && error("Out of bounds $(i)")
+    return getfield(b, i)
+end
 
+@inline function BXDFVector{S}(sbdfs::Vararg{UberBxDF{S}, N}) where {S<:Spectrum, N}
+    missing_bxdf = ntuple(i -> UberBxDF{S}(), 8 - N)
+    return BXDFVector{S}(sbdfs..., missing_bxdf..., UInt8(N))
+end
 
 struct BSDF{S}
     """
@@ -44,20 +51,24 @@ struct BSDF{S}
     Individual BxDF components. Maximum allowed number of components is 8.
     """
     bxdfs::BXDFVector{S}
+end
 
-    function BSDF(pool, si::SurfaceInteraction, η::Float32 = 1f0)
-        ng = si.core.n
-        ns = si.shading.n
-        ss = normalize(si.shading.∂p∂u)
-        ts = ns × ss
-        bsdfs = allocate(pool, BXDFVector{RGBSpectrum})
-        bsdfs.last = 0
-        new{RGBSpectrum}(
-            η, ng, ns, ss, ts, bsdfs,
-        )
-    end
+function BSDF(si::SurfaceInteraction, sbdfs::Vararg{UberBxDF{S}, N}) where {S<:Spectrum, N}
+    BSDF(si, 1f0, sbdfs...)
 end
 
+function BSDF(si::SurfaceInteraction, η::Float32, sbdfs::Vararg{UberBxDF{S},N}) where {S<:Spectrum, N}
+    ng = si.core.n
+    ns = si.shading.n
+    ss = normalize(si.shading.∂p∂u)
+    ts = ns × ss
+    bsdfs = BXDFVector{RGBSpectrum}(sbdfs...)
+    BSDF{RGBSpectrum}(
+        η, ng, ns, ss, ts, bsdfs,
+    )
+end
+
+
 """
 Given the orthonormal vectors s, t, n in world space, the matrix `M`
 that transforms vectors in world space to local reflection space is:
@@ -130,12 +141,14 @@ function sample_f(
     bxdf = nothing
     bxdfs = b.bxdfs
     Base.Cartesian.@nexprs 8 i -> begin
-        _bxdf = bxdfs[i]
-        if _bxdf & type
-            if count == 1
-                bxdf = _bxdf
+        if i <= bxdfs.last
+            _bxdf = bxdfs[i]
+            if _bxdf & type
+                if count == 1
+                    bxdf = _bxdf
+                end
+                count -= 1
             end
-            count -= 1
         end
     end
     @real_assert bxdf ≢ nothing "n bxdfs $(b.n_bxdfs), component $component, count $count"
@@ -173,12 +186,14 @@ function sample_f(
         reflect = ((wi_world ⋅ b.ng) * (wo_world ⋅ b.ng)) > 0
         f = RGBSpectrum(0f0)
         Base.Cartesian.@nexprs 8 i -> begin
-            bxdf = bxdfs[i]
-            if i <= bxdfs.last && ((bxdf & type) && (
-                    (reflect && (bxdf.type & BSDF_REFLECTION != 0)) ||
-                    (!reflect && (bxdf.type & BSDF_TRANSMISSION != 0))
-                ))
-                f += bxdf(wo, wi)
+            if i <= bxdfs.last
+                bxdf = bxdfs[i]
+                if  ((bxdf & type) && (
+                        (reflect && (bxdf.type & BSDF_REFLECTION != 0)) ||
+                        (!reflect && (bxdf.type & BSDF_TRANSMISSION != 0))
+                    ))
+                    f += bxdf(wo, wi)
+                end
             end
         end
     end

src/materials/material.jl

@@ -13,18 +13,11 @@ Compute scattering function.
 Base.Base.@propagate_inbounds  function matte_material(pool, m::UberMaterial, si::SurfaceInteraction, ::Bool, transport)
     # TODO perform bump mapping
     # Evaluate textures and create BSDF.
-    bsdf = BSDF(pool, si)
     r = clamp(m.Kd(si))
     is_black(r) && return
     σ = clamp(m.σ(si), 0f0, 90f0)
-    bsdfs = bsdf.bxdfs
-    if σ ≈ 0f0
-        bsdfs[1] = LambertianReflection(r)
-    else
-        bsdfs[1] = OrenNayar(r, σ)
-    end
-    bsdfs.last = 1
-    return bsdf
+    lambertian = (σ ≈ 0.0f0)
+    return BSDF(si, LambertianReflection(lambertian, r), OrenNayar(!lambertian, r, σ))
 end
 
 const MIRROR_MATERIAL = UInt8(2)
@@ -34,13 +27,9 @@ function MirrorMaterial(Kr::Texture)
 end
 
 Base.Base.@propagate_inbounds function mirror_material(pool, m::UberMaterial, si::SurfaceInteraction, ::Bool, transport)
-    bsdf = BSDF(pool, si)
     r = clamp(m.Kr(si))
     is_black(r) && return
-    bxdfs = bsdf.bxdfs
-    bxdfs[1] = SpecularReflection(r, FresnelNoOp())
-    bxdfs.last = 1
-    return bsdf
+    return BSDF(si, SpecularReflection(!is_black(r), r, FresnelNoOp()))
 end
 
 const GLASS_MATERIAL = UInt8(3)
@@ -58,17 +47,15 @@ Base.Base.@propagate_inbounds function glass_material(pool, g::UberMaterial, si:
     u_roughness = g.u_roughness(si)
     v_roughness = g.v_roughness(si)
 
-    bsdf = BSDF(pool, si, η)
-    bsdfs = bsdf.bxdfs
     r = clamp(g.Kr(si))
     t = clamp(g.Kt(si))
-    is_black(r) && is_black(t) && return
+    r_black = is_black(r)
+    t_black = is_black(t)
+    r_black && t_black && return BSDF(pool, si, η)
 
     is_specular = u_roughness ≈ 0 && v_roughness ≈ 0
     if is_specular && allow_multiple_lobes
-        bsdfs[1] = FresnelSpecular(r, t, 1.0f0, η, transport)
-        bsdfs.last = 1
-        return
+        return BSDF(si, η, FresnelSpecular(true, r, t, 1.0f0, η, transport))
     end
 
     if g.remap_roughness
@@ -78,26 +65,14 @@ Base.Base.@propagate_inbounds function glass_material(pool, g::UberMaterial, si:
     distribution = is_specular ? nothing : TrowbridgeReitzDistribution(
         u_roughness, v_roughness,
     )
-    last = 0
-    if !is_black(r)
-        fresnel = FresnelDielectric(1f0, η)
-        if is_specular
-            bsdfs[1] = SpecularReflection(r, fresnel)
-        else
-            bsdfs[1] = MicrofacetReflection(r, distribution, fresnel, transport)
-        end
-        last = 1
-    end
-    if !is_black(t)
-        last += 1
-        if is_specular
-            bsdfs[last] = SpecularTransmission(t, 1.0f0, η, transport)
-        else
-            bsdfs[last] = MicrofacetTransmission(t, distribution, 1.0f0, η, transport)
-        end
-    end
-    bsdfs.last = last
-    return bsdf
+    fresnel = FresnelDielectric(1f0, η)
+    return BSDF(
+        si, η,
+        SpecularReflection(!r_black && is_specular, r, fresnel),
+        MicrofacetReflection(!r_black && !is_specular, r, distribution, fresnel, transport),
+        SpecularTransmission(!t_black && is_specular, t, 1.0f0, η, transport),
+        MicrofacetTransmission(!t_black && !is_specular, t, distribution, 1.0f0, η, transport)
+    )
 end
 
 const PLASTIC_MATERIAL = UInt8(4)
@@ -111,25 +86,17 @@ end
 Base.Base.@propagate_inbounds function plastic_material(pool, p::UberMaterial,
         si::SurfaceInteraction, ::Bool, transport,
     )
-    bsdf = BSDF(pool, si)
-    bsdfs = bsdf.bxdfs
     # Initialize diffuse componen of plastic material.
     kd = clamp(p.Kd(si))
-    last = 0
-    if !is_black(kd)
-        bsdfs[1] = LambertianReflection(kd)
-        last += 1
-    end
+    bsdf_1 = LambertianReflection(!is_black(kd), kd)
     # Initialize specular component.
     ks = clamp(p.Ks(si))
-    is_black(ks) && return
+    is_black(ks) && return BSDF(si, bsdf_1)
     # Create microfacet distribution for plastic material.
     fresnel = FresnelDielectric(1.5f0, 1f0)
     rough = p.roughness(si)
     p.remap_roughness && (rough = roughness_to_α(rough))
     distribution = TrowbridgeReitzDistribution(rough, rough)
-    last += 1
-    bsdfs[last] = MicrofacetReflection(ks, distribution, fresnel, transport)
-    bsdfs.last = last
-    return bsdf
+    bsdf_2 = MicrofacetReflection(true, ks, distribution, fresnel, transport)
+    return BSDF(si, bsdf_1, bsdf_2)
 end

src/materials/uber-material.jl

@@ -69,51 +69,47 @@ struct UberBxDF{S<:Spectrum}
     transport::UInt8
     type::UInt8
     bxdf_type::UInt8
+    active::Bool
 end
 
-function UberBxDF{S}(bxdf_type::UInt8;
+function Base.:&(b::UberBxDF, type::UInt8)::Bool
+    return b.active && ((b.type & type) == b.type)
+end
+
+UberBxDF{S}() where {S} = UberBxDF{S}(false, UInt8(0))
+
+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_con=nothing,
-        fresnel_di=nothing,
-        fresnel_no=nothing,
+        fresnel=nothing,
         type=UInt8(0),
         transport=UInt8(0)
     ) where {S<:Spectrum}
     used_fresnel = UInt8(0)
-    _fresnel_con = if isnothing(fresnel_con)
-        FresnelConductor()
-    else
-        used_fresnel = UInt8(1)
-        fresnel_con
-    end
-    _fresnel_di = if isnothing(fresnel_di)
-        FresnelDielectric()
-    else
-        used_fresnel = UInt8(2)
-        fresnel_di
-    end
-    _fresnel_no = if isnothing(fresnel_no)
-        FresnelNoOp()
-    else
-        used_fresnel = UInt8(3)
-        fresnel_no
+    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
-    return UberBxDF{S}(_fresnel_con, _fresnel_di, _fresnel_no, used_fresnel, r, t, a, b, η_a, η_b, distribution, transport, type, bxdf_type)
+    _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)
 end
 
 fresnel(f::UberBxDF)= getfield(f, Int(f.which_fresnel))
 
-# @inline function sample_f(
-#     b::UberBxDF, wo::Vec3f, sample::Point2f,
-# )::Tuple{Vec3f,Float32,RGBSpectrum,UInt8}
-#     wi::Vec3f = cosine_sample_hemisphere(sample)
-#     # Flipping the direction if necessary.
-#     wo[3] < 0 && (wi = Vec3f(wi[1], wi[2], -wi[3]))
-#     pdf::Float32 = compute_pdf(b, wo, wi)
-#     wi, pdf, b(wo, wi), UInt8(0)
-# end
+
 @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)
@@ -135,16 +131,12 @@ fresnel(f::UberBxDF)= getfield(f, Int(f.which_fresnel))
     return wi, pdf, s(wo, wi), UInt8(0)
 end
 
-# """
-# Compute PDF value for the given directions.
-# In comparison, `sample_f` computes PDF value for the incident directions *it*
-# chooses given the outgoing direction, while this returns a value of PDF
-# for the given pair of directions.
-# """
-# @inline function compute_pdf(::UberBxDF, wo::Vec3f, wi::Vec3f)::Float32
-#     same_hemisphere(wo, wi) ? abs(cos_θ(wi)) * (1.0f0 / π) : 0.0f0
-# end
-
+"""
+Compute PDF value for the given directions.
+In comparison, `sample_f` computes PDF value for the incident directions *it*
+chooses given the outgoing direction, while this returns a value of PDF
+for the given pair of directions.
+"""
 @inline function compute_pdf(s::UberBxDF, wo::Vec3f, wi::Vec3f)::Float32
     if s.bxdf_type === FRESNEL_SPECULAR
         pdf_fresnel_specular(s, wo, wi)

src/mempool.jl

@@ -138,10 +138,6 @@ function Base.getindex(mref::MutableRef{T}) where {T}
     return unsafe_load(Ptr{T}(getfield(mref, :ptr)))
 end
 
-function Base.show(io::IO, mref::MutableRef)
-    show(io, mref[])
-end
-
 function LifeCycle(f::Function, pool)
     try
         f(pool)

src/primitive.jl

@@ -9,9 +9,9 @@ struct GeometricPrimitive{T<:AbstractShape,M<:UberMaterial} <: Primitive
     end
 end
 
-function intersect!(
+function intersect_p!(
         pool, p::GeometricPrimitive{T}, ray::Union{Ray,RayDifferentials},
-    ) where T<:AbstractShape
+    )::Tuple{Bool, SurfaceInteraction} where T<:AbstractShape
 
     shape = p.shape
     intersects, t_hit, interaction = intersect(pool, shape, ray)
@@ -20,7 +20,7 @@ function intersect!(
     return true, interaction
 end
 
-@inline function intersect_p(
+@noinline function intersect_p(
         pool, p::GeometricPrimitive, ray::Union{Ray,RayDifferentials},
     )
     intersect_p(pool, p.shape, ray)

src/reflection/bxdf.jl

@@ -6,9 +6,6 @@ const BSDF_GLOSSY = UInt8(0b01000)
 const BSDF_SPECULAR = UInt8(0b10000)
 const BSDF_ALL = UInt8(0b11111)
 
-function Base.:&(b::UberBxDF, type::UInt8)::Bool
-    (b.type & type) == b.type
-end
 
 @inline function same_hemisphere(w::Vec3f, wp::Union{Vec3f,Normal3f})::Bool
     w[3] * wp[3] > 0