source: trunk/VUT/GtpVisibilityPreprocessor/src/RayInfo.cpp @ 432

#include "RayInfo.h"
#include "Ray.h"
#include "VssRay.h"

RayInfo::RayInfo(): mRay(NULL), mMinT(0),
#if USE_FIXEDPOINT_T
#define FIXEDPOINT_ONE 0x7FFE
        // mMaxT(0xFFFF)
        mMaxT(FIXEDPOINT_ONE)
#else
        mMaxT(1.0f)
#endif
{}
                
RayInfo::RayInfo(VssRay *r):mRay(r), mMinT(0),
#if USE_FIXEDPOINT_T
#define FIXEDPOINT_ONE 0x7FFE
        // mMaxT(0xFFFF)
        mMaxT(FIXEDPOINT_ONE)
#else
        mMaxT(1.0f)
#endif
{}
                
RayInfo::RayInfo(VssRay *r,     const float _min, const float _max):
mRay(r) 
{
        SetMinT(_min);
        SetMaxT(_max);
}
                
RayInfo::RayInfo(VssRay *r, const short _min, const float _max):
mRay(r), mMinT(_min) 
{
        SetMaxT(_max);
}
                
RayInfo::RayInfo(VssRay *r,     const float _min, const short _max): 
mRay(r), mMaxT(_max) 
{
        SetMinT(_min);
}
                
float RayInfo::ExtrapOrigin(const int axis) const 
{
        return mRay->GetOrigin(axis) + GetMinT()*mRay->GetDir(axis);
}
                
float RayInfo::ExtrapTermination(const int axis) const 
{
        return mRay->GetOrigin(axis) + GetMaxT()*mRay->GetDir(axis);
}
                
#if USE_FIXEDPOINT_T
        float RayInfo::GetMinT () const 
        { 
                return mMinT/(float)(FIXEDPOINT_ONE); 
        }

        float RayInfo::GetMaxT() const 
        { 
                return mMaxT / (float)(FIXEDPOINT_ONE); 
        }
                
        void RayInfo::SetMinT (const float t) 
        {
                mMinT = (short) (t * (float)(FIXEDPOINT_ONE));
        }
                
        void RayInfo::SetMaxT (const float t) 
        {
                mMaxT = (short) (t*(float)(FIXEDPOINT_ONE));
                ++ mMaxT;
                //      if (mMaxT!=0xFFFF)
                //      mMaxT++;
        }
#else
        float RayInfo::GetMinT () const 
        { 
                return mMinT; 
        }
        
        float RayInfo::GetMaxT () const 
        { 
                return mMaxT; 
        }
                
        void RayInfo::SetMinT (const float t) 
        { 
                mMinT = t; 
        }
        
        void RayInfo::SetMaxT (const float t) 
        { 
                mMaxT = t; 
        }
        
#endif 

int RayInfo::ComputeRayIntersection(const int axis, const float position, float &t) const
{               
        // intersect the ray with the plane
        const float denom = mRay->GetDir(axis);

        if (fabs(denom) < 1e-20)
                //if (denom == 0.0f)
                return (mRay->GetOrigin(axis) > position) ? 1 : -1;

        t = (position - mRay->GetOrigin(axis)) / denom;

        if (t < GetMinT())
                return (denom > 0) ? 1 : -1;

        if (t > GetMaxT())
                return (denom > 0) ? -1 : 1;

        return 0;
}