BsdfSampleQuery.h

Go to the documentation of this file.

#pragma once
 
#include "Core/SurfaceBehavior/bsdf_query_fwd.h"
#include "Math/TVector3.h"
#include "Core/SurfaceHit.h"
#include "Math/Color/Spectrum.h"
#include "Core/SurfaceBehavior/BsdfQueryContext.h"
 
#include <Common/assertion.h>
 
#include <cmath>
#include <string>
#include <utility>
 
namespace ph
{
 
class BsdfSampleInput final
{
public:
    void set(const BsdfEvalInput& evalInput);
    void set(const SurfaceHit& X, const math::Vector3R& V);
 
    const SurfaceHit& getX() const;
 
    const math::Vector3R& getV() const;
 
private:
    SurfaceHit     m_X;
    math::Vector3R m_V;
#if PH_DEBUG
    bool           m_hasSet{false};
#endif
};
 
class BsdfSampleOutput final
{
public:
    void setL(const math::Vector3R& L);
 
    void setPdfAppliedBsdfCos(
        const math::Spectrum& pdfAppliedBsdfCos,
        real cos,
        bool inferMeasurability = true);
 
    const math::Vector3R& getL() const;
 
    real getCos() const;
 
    math::Spectrum getPdfAppliedBsdf() const;
 
    const math::Spectrum& getPdfAppliedBsdfCos() const;
 
    real getRelativeIor() const;
 
    real getRelativeIor2() const;
 
    bool isMeasurable() const;
 
    void setMeasurability(bool measurability);
 
    void setMeasurability(const math::Spectrum& reference);
 
    void setRelativeIor(real relativeIor);
 
    operator bool () const;
 
private:
    math::Vector3R m_L{0};
    math::Spectrum m_pdfAppliedBsdfCos{0};
    real           m_cos{0};
    real           m_relativeIor{1};
    bool           m_isMeasurable{false};
};
 
class BsdfSampleQuery final
{
public:
    using Input  = BsdfSampleInput;
    using Output = BsdfSampleOutput;
 
    BsdfQueryContext context = BsdfQueryContext{};
    Input            inputs;
    Output           outputs;
 
    BsdfSampleQuery() = default;
    explicit BsdfSampleQuery(BsdfQueryContext context);
};
 
// In-header Implementations:
 
inline BsdfSampleQuery::BsdfSampleQuery(BsdfQueryContext context)
    : BsdfSampleQuery()
{
    this->context = std::move(context);
 
    // (rest of the fields are initialized via setters)
}
 
inline void BsdfSampleInput::set(const SurfaceHit& X, const math::Vector3R& V)
{
    // Not querying from uninitialized surface hit
    PH_ASSERT(!X.getReason().hasExactly(ESurfaceHitReason::Invalid));
 
    PH_ASSERT_IN_RANGE(V.lengthSquared(), 0.9_r, 1.1_r);
 
    m_X = X;
    m_V = V;
 
#if PH_DEBUG
    m_hasSet = true;
#endif
}
 
inline const SurfaceHit& BsdfSampleInput::getX() const
{
    PH_ASSERT(m_hasSet);
 
    return m_X;
}
 
inline const math::Vector3R& BsdfSampleInput::getV() const
{
    PH_ASSERT(m_hasSet);
 
    return m_V;
}
 
inline void BsdfSampleOutput::setL(const math::Vector3R& L)
{
    PH_ASSERT_IN_RANGE(L.lengthSquared(), 0.9_r, 1.1_r);
 
    m_L = L;
}
 
inline void BsdfSampleOutput::setPdfAppliedBsdfCos(
    const math::Spectrum& pdfAppliedBsdfCos,
    const real cos,
    const bool inferMeasurability)
{
    m_pdfAppliedBsdfCos = pdfAppliedBsdfCos;
    m_cos = cos;
 
    if(inferMeasurability)
    {
        setMeasurability(pdfAppliedBsdfCos);
        setMeasurability(isMeasurable() && 0.0_r < cos && cos < 1.1_r);
    }
}
 
inline const math::Vector3R& BsdfSampleOutput::getL() const
{
    PH_ASSERT(isMeasurable());
    PH_ASSERT_IN_RANGE(m_L.lengthSquared(), 0.9_r, 1.1_r);
 
    return m_L;
}
 
inline real BsdfSampleOutput::getCos() const
{
    PH_ASSERT(isMeasurable());
    PH_ASSERT_IN_RANGE_EXCLUSIVE(m_cos, 0.0_r, 1.1_r);
 
    return m_cos;
}
 
inline math::Spectrum BsdfSampleOutput::getPdfAppliedBsdf() const
{
    const auto pdfAppliedBsdf = getPdfAppliedBsdfCos() / getCos();
    return pdfAppliedBsdf.isFinite() ? pdfAppliedBsdf : math::Spectrum(0);
}
 
inline const math::Spectrum& BsdfSampleOutput::getPdfAppliedBsdfCos() const
{
    // When a sample report being measurable, it must not be some crazy values
    PH_ASSERT(isMeasurable());
    PH_ASSERT_MSG(m_pdfAppliedBsdfCos.isFinite(), m_pdfAppliedBsdfCos.toString());
 
    return m_pdfAppliedBsdfCos;
}
 
inline real BsdfSampleOutput::getRelativeIor() const
{
    PH_ASSERT(isMeasurable());
    PH_ASSERT_MSG(std::isfinite(m_relativeIor) && m_relativeIor > 0, std::to_string(m_relativeIor));
 
    return m_relativeIor;
}
 
inline real BsdfSampleOutput::getRelativeIor2() const
{
    const real relativeIor = getRelativeIor();
    return relativeIor * relativeIor;
}
 
inline bool BsdfSampleOutput::isMeasurable() const
{
    return m_isMeasurable;
}
 
inline void BsdfSampleOutput::setMeasurability(const bool measurability)
{
    m_isMeasurable = measurability;
}
 
inline void BsdfSampleOutput::setMeasurability(const math::Spectrum& reference)
{
    setMeasurability(reference.isFinite());
}
 
inline void BsdfSampleOutput::setRelativeIor(const real relativeIor)
{
    m_relativeIor = relativeIor;
}
 
inline BsdfSampleOutput::operator bool () const
{
    return isMeasurable();
}
 
}// end namespace ph