SurfaceTracer.h

Go to the documentation of this file.

#pragma once
 
#include "World/Scene.h"
#include "Core/HitProbe.h"
#include "Core/SurfaceHit.h"
#include "Core/LTA/lta.h"
#include "Core/LTA/SidednessAgreement.h"
#include "Core/LTA/SurfaceHitRefinery.h"
#include "Core/SurfaceBehavior/BsdfSampleQuery.h"
#include "Core/SurfaceBehavior/BsdfEvalQuery.h"
#include "Core/SurfaceBehavior/BsdfPdfQuery.h"
#include "Core/Ray.h"
#include "Math/TVector3.h"
#include "Math/Color/Spectrum.h"
#include "Core/Intersection/Primitive.h"
#include "Core/Intersection/PrimitiveMetadata.h"
#include "Core/SurfaceBehavior/SurfaceBehavior.h"
#include "Core/SurfaceBehavior/SurfaceOptics.h"
#include "Core/Emitter/Emitter.h"
 
#include <Common/assertion.h>
 
#include <limits>
 
namespace ph { class SampleFlow; }
 
namespace ph::lta
{
 
class SurfaceTracer final
{
public:
    explicit SurfaceTracer(const Scene* scene);
 
    bool traceNextSurface(
        const Ray&                ray, 
        const SidednessAgreement& sidedness, 
        SurfaceHit*               out_X) const;
 
    bool traceNextSurfaceFrom(
        const SurfaceHit&         X,
        const Ray&                ray, 
        const SidednessAgreement& sidedness, 
        SurfaceHit*               out_X) const;
 
    bool bsdfSampleNextSurface(
        BsdfSampleQuery& bsdfSample,
        SampleFlow&      sampleFlow,
        SurfaceHit*      out_X) const;
 
    bool doBsdfSample(BsdfSampleQuery& bsdfSample, SampleFlow& sampleFlow) const;
 
    bool doBsdfSample(
        BsdfSampleQuery& bsdfSample, 
        SampleFlow&      sampleFlow, 
        Ray*             out_sampledRay) const;
    
    bool doBsdfEvaluation(BsdfEvalQuery& bsdfEval) const;
 
    bool doBsdfPdfQuery(BsdfPdfQuery& bsdfPdfQuery) const;
 
    bool sampleZeroBounceEmission(
        const SurfaceHit&         Xe, 
        const SidednessAgreement& sidedness,
        math::Spectrum*           out_Le) const;
    
private:
    const Scene& getScene() const;
    
    const Scene* m_scene;
};
 
// In-header Implementations:
 
inline SurfaceTracer::SurfaceTracer(const Scene* const scene)
    : m_scene(scene)
{
    PH_ASSERT(scene);
}
 
inline bool SurfaceTracer::traceNextSurface(
    const Ray&                ray,
    const SidednessAgreement& sidedness,
    SurfaceHit* const         out_X) const
{
    PH_ASSERT(out_X);
 
    HitProbe probe;
    if(!getScene().isIntersecting(ray, &probe))
    {
        return false;
    }
 
    *out_X = SurfaceHit(ray, probe, SurfaceHitReason(ESurfaceHitReason::IncidentRay));
    sidedness.adjustForSidednessAgreement(*out_X);
 
    return sidedness.isSidednessAgreed(*out_X, ray.getDir());
}
 
inline bool SurfaceTracer::traceNextSurfaceFrom(
    const SurfaceHit&         X,
    const Ray&                ray, 
    const SidednessAgreement& sidedness, 
    SurfaceHit* const         out_X) const
{
    // Not tracing from uninitialized surface hit
    PH_ASSERT(!X.getReason().hasExactly(ESurfaceHitReason::Invalid));
 
    const Ray refinedRay = SurfaceHitRefinery{X}.escape(ray.getDir());
    return traceNextSurface(refinedRay, sidedness, out_X);
}
 
inline bool SurfaceTracer::bsdfSampleNextSurface(
    BsdfSampleQuery&  bsdfSample,
    SampleFlow&       sampleFlow,
    SurfaceHit* const out_X) const
{
    Ray sampledRay;
    if(!doBsdfSample(bsdfSample, sampleFlow, &sampledRay))
    {
        return false;
    }
 
    return traceNextSurfaceFrom(
        bsdfSample.inputs.getX(), 
        sampledRay, 
        bsdfSample.context.sidedness, 
        out_X);
}
 
inline bool SurfaceTracer::doBsdfSample(BsdfSampleQuery& bsdfSample, SampleFlow& sampleFlow) const
{
    const SurfaceHit& X = bsdfSample.inputs.getX();
    const SurfaceOptics* const optics = X.getSurfaceOptics();
    if(!optics)
    {
        return false;
    }
 
    optics->genBsdfSample(bsdfSample, sampleFlow);
 
    return bsdfSample.outputs.isMeasurable();
}
 
inline bool SurfaceTracer::doBsdfSample(
    BsdfSampleQuery& bsdfSample,
    SampleFlow&      sampleFlow,
    Ray* const       out_sampledRay) const
{
    if(!doBsdfSample(bsdfSample, sampleFlow))
    {
        return false;
    }
 
    PH_ASSERT(out_sampledRay);
    *out_sampledRay = Ray(
        bsdfSample.inputs.getX().getPos(),
        bsdfSample.outputs.getL(),
        0,
        std::numeric_limits<real>::max(),
        bsdfSample.inputs.getX().getTime());
 
    return true;
}
 
inline bool SurfaceTracer::doBsdfEvaluation(BsdfEvalQuery& bsdfEval) const
{
    const SurfaceHit& X = bsdfEval.inputs.getX();
    const SurfaceOptics* const optics = X.getSurfaceOptics();
    if(!optics)
    {
        return false;
    }
 
    optics->calcBsdf(bsdfEval);
 
    return bsdfEval.outputs.isMeasurable();
}
 
inline bool SurfaceTracer::doBsdfPdfQuery(BsdfPdfQuery& bsdfPdfQuery) const
{
    const SurfaceHit& X = bsdfPdfQuery.inputs.getX();
    const SurfaceOptics* const optics = X.getSurfaceOptics();
    if(!optics)
    {
        return false;
    }
 
    optics->calcBsdfPdf(bsdfPdfQuery);
 
    return bsdfPdfQuery.outputs;
}
 
inline bool SurfaceTracer::sampleZeroBounceEmission(
    const SurfaceHit&         Xe, 
    const SidednessAgreement& sidedness,
    math::Spectrum* const     out_Le) const
{
    PH_ASSERT(out_Le);
 
    const auto* const emitter = Xe.getSurfaceEmitter();
 
    // Sidedness agreement between real geometry and shading normal
    // (do not check for hemisphere--emitter may be back-emitting and this is judged by the emitter)
    if(!emitter ||
       emitter->getFeatureSet().hasNo(EEmitterFeatureSet::ZeroBounceSample) ||
       !sidedness.isSidednessAgreed(Xe, Xe.getIncidentRay().getDir()))
    {
        return false;
    }
 
    emitter->evalEmittedEnergy(Xe, out_Le);
    return true;
}
 
inline const Scene& SurfaceTracer::getScene() const
{
    PH_ASSERT(m_scene);
 
    return *m_scene;
}
 
}// end namespace ph::lta