src/rcrt/Intersection.cpp

Go to the documentation of this file.

#include "Intersection.h"

#include <limits>
#include "primitives/Primitive.h"

using namespace std;

namespace rcrt
{


Intersection::Intersection() : distance(numeric_limits<float>::infinity()),prim(0),position(0),lastIOR(1,0)
{       
}

Intersection::Intersection(const float dist, const Primitive* p, const Point3D& pos,
                const float param1, const float param2, bool bs)
: distance(dist),prim(p),position(pos), parameters(param1,param2),
shadingNormal(0,0,0), geomNormal(0,0,0), uv(0,0),
initSNo(false), initGNo(false),
initSNoL(false), initGNoL(false), initUV(false), backside(bs),
lastIOR(1,0)
{
        
}


Intersection::~Intersection()
{
}

void Intersection::setUV(const Point2D& uvs)
{
        uv = uvs;
}

bool Intersection::isValid() const
{
        return prim != 0;
}

float Intersection::getDistance() const
{
        return distance;
}
const Primitive* const Intersection::getPrimitive() const
{
        return prim;
}

const Point3D& Intersection::getPosition() const
{
        return position;
}

const Vec3D& Intersection::getSNormalW()
{
        if(!initSNo){
                initSNo = true;
                if(initSNoL){//transform existing shading normals, needed if we can't reconstruct them
                        shadingNormal = prim->normalToWorld(shadingNormalLocal);
                }else{
                        shadingNormal = prim->getSNormalWorld(parameters.x(), parameters.y());
                }
        }
        
        return shadingNormal;
}

const Vec3D& Intersection::getGNormalW()
{
        if(!initGNo){
                initGNo = true;
                if(initGNoL)//transform existing geometry normals, useful if we can't reconstruct them easily
                        //from parameterization
                        geomNormal = prim->normalToWorld(geomNormalLocal);
                else
                        geomNormal = prim->getGNormalWorld(parameters.x(), parameters.y());
        }
        return geomNormal;
}


const Vec3D& Intersection::getSNormalL()
{
        if(!initSNoL){
                initSNoL = true;
                shadingNormalLocal = prim->getSNormal(parameters.x(), parameters.y());
        }
        return shadingNormalLocal;
}

const Vec3D& Intersection::getGNormalL()
{
        if(!initGNoL){
                initGNoL = true;
                geomNormalLocal = prim->getGNormal(parameters.x(), parameters.y());
        }
        return geomNormalLocal;
}

void Intersection::setSNormalW(const Vec3D& no)
{
        initSNo = true;
        shadingNormal = no;
}

void Intersection::setGNormalW(const Vec3D& no)
{
        initGNo = true;
        geomNormal = no;
}

void Intersection::setSNormalL(const Vec3D& no)
{
        initSNoL = true;
        shadingNormalLocal= no;
}

void Intersection::setGNormalL(const Vec3D& no)
{
        initGNoL = true;
        geomNormalLocal = no;
}

void Intersection::setPrimitive(const Primitive* p)
{
        prim = p;
}

const Point2D& Intersection::getUV()
{
        if(!initUV){
                initUV = true;
                uv = prim->getUV(parameters.x(), parameters.y());
        }
        return uv;
}

const Point2D& Intersection::getParams() const
{
        return parameters;
}

const bool& Intersection::backSide() const
{
        return backside;
}

void Intersection::setLastIOR(const complex<float>& ior)
{
        lastIOR = ior;
}


void Intersection::setLastIOR(const float& real, const float& imag)
{
        lastIOR = std::complex<float>(real,imag);
}

const complex<float>& Intersection::getLastIOR() const
{
        return lastIOR;
}

}

---