Ray.h

Go to the documentation of this file.

#pragma once
 
#include "Math/TVector3.h"
#include "Math/Geometry/TLineSegment.h"
#include "Core/Quantity/Time.h"
 
#include <Common/primitive_type.h>
 
#include <limits>
 
namespace ph
{
 
class Ray final
{
public:
    class Differential;
 
public:
    Ray() = default;
 
    Ray(const math::Vector3R& origin, const math::Vector3R& direction);
 
    Ray(const math::Vector3R& origin, const math::Vector3R& direction, const Time& time);
 
    Ray(const math::Vector3R& origin, const math::Vector3R& direction, real minT, real maxT);
 
    Ray(const math::Vector3R& origin, const math::Vector3R& direction, real minT, real maxT, const Time& time);
 
    Ray(const math::TLineSegment<real>& segment, const Time& time);
 
    Ray& reverse();
 
    void setMinT(real t);
 
    void setMaxT(real t);
 
    void setRange(real minT, real maxT);
 
    void setOrigin(const math::Vector3R& pos);
 
    void setDir(const math::Vector3R& dir);
 
    void setSegment(const math::TLineSegment<real>& segment);
 
    const math::Vector3R& getOrigin() const;
    const math::Vector3R& getDir() const;
    real getMinT() const;
    real getMaxT() const;
    const math::TLineSegment<real>& getSegment() const;
 
    math::Vector3R getTail() const;
 
    math::Vector3R getHead() const;
 
    void setTime(const Time& time);
 
    const Time& getTime() const;
 
private:
    math::TLineSegment<real> m_segment;
    Time                     m_time;
};
 
// In-header Implementations:
 
inline Ray::Ray(const math::TLineSegment<real>& segment, const Time& time)
    : m_segment(segment)
    , m_time(time)
{}
 
inline Ray::Ray(
    const math::Vector3R& origin,
    const math::Vector3R& direction,
    const real minT,
    const real maxT,
    const Time& time)
 
    : Ray(math::TLineSegment<real>(origin, direction, minT, maxT), time)
{}
 
inline Ray::Ray(
    const math::Vector3R& origin, 
    const math::Vector3R& direction, 
    const real minT, 
    const real maxT)
 
    : Ray(origin, direction, minT, maxT, Time{})
{}
 
inline Ray::Ray(const math::Vector3R& origin, const math::Vector3R& direction)
    : Ray(origin, direction, 0, std::numeric_limits<real>::max())
{}
 
inline Ray::Ray(const math::Vector3R& origin, const math::Vector3R& direction, const Time& time)
    : Ray(origin, direction, 0, std::numeric_limits<real>::max(), time)
{}
 
inline Ray& Ray::reverse()
{
    m_segment.flip();
 
    return *this;
}
 
inline void Ray::setMinT(const real t)
{
    m_segment.setMinT(t);
}
 
inline void Ray::setMaxT(const real t)
{
    m_segment.setMaxT(t);
}
 
inline void Ray::setRange(const real minT, const real maxT)
{
    m_segment.setRange(minT, maxT);
}
 
inline void Ray::setOrigin(const math::Vector3R& pos)
{
    m_segment.setOrigin(pos);
}
 
inline void Ray::setDir(const math::Vector3R& dir)
{
    m_segment.setDir(dir);
}
 
inline void Ray::setSegment(const math::TLineSegment<real>& segment)
{
    m_segment = segment;
}
 
inline void Ray::setTime(const Time& time)
{
    m_time = time;
}
 
inline const Time& Ray::getTime() const
{
    return m_time;
}
 
inline const math::Vector3R& Ray::getOrigin() const
{
    return m_segment.getOrigin();
}
 
inline const math::Vector3R& Ray::getDir() const
{
    return m_segment.getDir();
}
 
inline real Ray::getMinT() const
{
    return m_segment.getMinT();
}
 
inline real Ray::getMaxT() const
{
    return m_segment.getMaxT();
}
 
inline const math::TLineSegment<real>& Ray::getSegment() const
{
    return m_segment;
}
 
inline math::Vector3R Ray::getTail() const
{
    return m_segment.getTail();
}
 
inline math::Vector3R Ray::getHead() const
{
    return m_segment.getHead();
}
 
}// end namespace ph