PrimitivePosSampleQuery.h

Go to the documentation of this file.

#pragma once
 
#include "Math/TVector3.h"
#include "Core/Ray.h"
#include "Core/Quantity/Time.h"
#include "Core/LTA/PDF.h"
 
#include <Common/assertion.h>
#include <Common/primitive_type.h>
#include <Common/logging.h>
 
#include <optional>
 
namespace ph { class DirectEnergySampleInput; }
 
namespace ph
{
 
class PrimitivePosSampleInput final
{
public:
    void set(
        const DirectEnergySampleInput& directInput,
        const math::Vector3R& uvw = {0, 0, 0},
        const lta::PDF& uvwPdf = {},
        bool suggestDir = false);
 
    void set(
        const Time& time,
        const std::optional<math::Vector3R>& observationPos = std::nullopt,
        const math::Vector3R& uvw = {0, 0, 0},
        const lta::PDF& uvwPdf = {},
        bool suggestDir = false);
 
    const Time& getTime() const;
 
    const std::optional<math::Vector3R>& getObservationPos() const;
 
    const math::Vector3R& getUvw() const;
 
    const lta::PDF& getUvwPdf() const;
 
    bool suggestDir() const;
 
private:
    Time                          m_time;
    std::optional<math::Vector3R> m_observationPos;
    math::Vector3R                m_uvw;
    lta::PDF                      m_uvwPdf;
    bool                          m_suggestDir;
#if PH_DEBUG
    bool                          m_hasSet{false};
#endif
};
 
class PrimitivePosSampleOutput final
{
public:
    void setPos(const math::Vector3R& pos);
    void setPdfPos(const lta::PDF& pdfPos);
    void setPdfDir(const lta::PDF& pdfDir);
    void setObservationRay(const Ray& observationRay);
 
    const math::Vector3R& getPos() const;
 
    const math::Vector3R& getDir() const;
 
    real getPdfA() const;
    real getPdfW() const;
    const lta::PDF& getPdfPos() const;
    const lta::PDF& getPdfDir() const;
 
    const Ray& getObservationRay() const;
 
    operator bool () const;
 
private:
    math::Vector3R m_pos{0};
    lta::PDF       m_pdfPos{};
    lta::PDF       m_pdfDir{};
    Ray            m_observationRay{};
};
 
class PrimitivePosSampleQuery final
{
public:
    using Input  = PrimitivePosSampleInput;
    using Output = PrimitivePosSampleOutput;
 
    Input  inputs;
    Output outputs;
 
    PrimitivePosSampleQuery() = default;
};
 
// In-header Implementations:
 
inline void PrimitivePosSampleInput::set(
    const Time& time,
    const std::optional<math::Vector3R>& observationPos,
    const math::Vector3R& uvw,
    const lta::PDF& uvwPdf,
    const bool suggestDir)
{
    m_time = time;
    m_observationPos = observationPos;
    m_uvw = uvw;
    m_uvwPdf = uvwPdf;
    m_suggestDir = suggestDir;
 
#if PH_DEBUG
    m_hasSet = true;
 
    if(observationPos && suggestDir)
    {
        PH_DEFAULT_LOG(WarningOnce,
            "Requesting suggested direction in `PrimitivePosSampleInput` has no effect when "
            "observation position is present.");
    }
#endif
}
 
inline const Time& PrimitivePosSampleInput::getTime() const
{
    PH_ASSERT(m_hasSet);
    return m_time;
}
 
inline const std::optional<math::Vector3R>& PrimitivePosSampleInput::getObservationPos() const
{
    PH_ASSERT(m_hasSet);
    return m_observationPos;
}
 
inline const math::Vector3R& PrimitivePosSampleInput::getUvw() const
{
    PH_ASSERT(m_hasSet);
    return m_uvw;
}
 
inline const lta::PDF& PrimitivePosSampleInput::getUvwPdf() const
{
    PH_ASSERT(m_hasSet);
    return m_uvwPdf;
}
 
inline bool PrimitivePosSampleInput::suggestDir() const
{
    PH_ASSERT(m_hasSet);
    return m_suggestDir;
}
 
inline void PrimitivePosSampleOutput::setObservationRay(const Ray& observationRay)
{
    m_observationRay = observationRay;
}
 
inline void PrimitivePosSampleOutput::setPos(const math::Vector3R& pos)
{
    m_pos = pos;
}
 
inline void PrimitivePosSampleOutput::setPdfPos(const lta::PDF& pdfPos)
{
    m_pdfPos = pdfPos;
}
 
inline void PrimitivePosSampleOutput::setPdfDir(const lta::PDF& pdfDir)
{
    m_pdfDir = pdfDir;
}
 
inline const Ray& PrimitivePosSampleOutput::getObservationRay() const
{
    PH_ASSERT(*this);
    return m_observationRay;
}
 
inline const math::Vector3R& PrimitivePosSampleOutput::getPos() const
{
    PH_ASSERT(*this);
    PH_ASSERT(!m_pdfPos.isEmpty());
    return m_pos;
}
 
inline const math::Vector3R& PrimitivePosSampleOutput::getDir() const
{
    PH_ASSERT(!m_pdfDir.isEmpty());
    return getObservationRay().getDir();
}
 
inline real PrimitivePosSampleOutput::getPdfA() const
{
    return getPdfPos().getPdfA();
}
 
inline real PrimitivePosSampleOutput::getPdfW() const
{
    return getPdfDir().getPdfW();
}
 
inline const lta::PDF& PrimitivePosSampleOutput::getPdfPos() const
{
    PH_ASSERT(*this);
    return m_pdfPos;
}
 
inline const lta::PDF& PrimitivePosSampleOutput::getPdfDir() const
{
    PH_ASSERT(*this);
    return m_pdfDir;
}
 
inline PrimitivePosSampleOutput::operator bool () const
{
    return m_pdfPos;
}
 
}// end namespace ph