src/Ray.h

Go to the documentation of this file.

#ifndef RAY_H
#define RAY_H


#include <cassert>
#include <iosfwd>

#include "Vec3f.h"
#include "defines.h"


class Primitive;
class Object;


class Ray
{
public:
    Ray()
        : mOrg(),
            mDir(),
            mT(INFINITY),
            mHit(NULL),
            mHitObj(NULL),
            mU(0.0f),
            mV(0.0f),
            mInfluence(1.0f),
            mRecursionDeep(0)
    {
    }

    void init(  const Vec3f &   origin,
                const Vec3f &   direction,
                float           t = INFINITY )
    {
        assert(0.0f <= t);
        mOrg            = origin;
        mDir            = direction.normal();
        mT              = t + EPSILON;
        mHit            = NULL;
        mHitObj         = NULL;
        mU              = 0.0f;
        mV              = 0.0f;
        mInfluence      = 1.0f;
        mRecursionDeep  = 0;
    }

    const Vec3f & org() const
    {
        return mOrg;
    }

    const Vec3f & dir() const
    {
        return mDir;
    }

    float t() const
    {
        return mT;
    }

    Vec3f hitPoint(float eps) const
    {
        return mOrg + (mT + eps) * mDir;
    }

    const Primitive * hit() const
    {
        return mHit;
    }

    void setHit(const Primitive * hit, float t)
    {
        mHit    = hit;
        mT      = t;
    }

    const Object * obj() const
    {
        return mHitObj;
    }

    void setObj(const Object * object)
    {
        assert(mHit || !object);
        mHitObj = object;
    }

    float u() const
    {
        return mU;
    }

    float v() const
    {
        return mV;
    }

    void setUV(float u, float v)
    {
        mU = u;
        mV = v;
    }

    float influence() const
    {
        return mInfluence;
    }

    int recDeep() const
    {
        return mRecursionDeep;
    }

    void setInfluence(float infl, int recursionDeep)
    {
        assert(0.0f <= infl && infl <= 1.0f);
        assert(0 <= recursionDeep);
        mInfluence      = infl;
        mRecursionDeep  = recursionDeep;
    }

    void updateInfluence(const Ray & ray, float infl = 1.0f)
    {
        assert(0.0f <= infl && infl <= 1.0f);
        mInfluence      = ray.influence() * infl;
        mRecursionDeep  = ray.recDeep() + 1;
    }

private:
    Vec3f               mOrg;

    Vec3f               mDir;

    float               mT;

    const Primitive *   mHit;

    const Object *      mHitObj;

    float               mU;

    float               mV;

    float               mInfluence;

    int                 mRecursionDeep;
};


std::ostream & operator<<(std::ostream & o, const Ray & ray);


#endif

---