src/Triangle.h

Go to the documentation of this file.

#ifndef TRIANGLE_H
#define TRIANGLE_H


#include "Primitive.h"
#include "Ray.h"
#include "Object.h"


class Triangle : public Primitive
{
public:
    Triangle(const Vec3f &  a,
             const Vec3f &  b,
             const Vec3f &  c)
        : Primitive(),
            mA(a),
            mB(b),
            mC(c),
            mEdge1(b - a),
            mEdge2(c - a)
    {
        calcBounds();
    }

    virtual ~Triangle()
    {
    }

    bool intersect(Ray & ray) const
    {
        const Vec3f pvec = ray.dir().cross( mEdge2 );

        const float det = mEdge1.dot(pvec);
        if (fabs(det) < EPSILON)
            return false;

        const float inv_det = 1.0f / det;

        const Vec3f tvec = ray.org() - mA;
        float lambda = tvec.dot(pvec);
        lambda *= inv_det;

        if (lambda < 0.0f || lambda > 1.0f)
            return false;

        const Vec3f qvec = tvec.cross(mEdge1);
        float mue = ray.dir().dot(qvec);
        mue *= inv_det;

        if (mue < 0.0f || mue+lambda > 1.0f)
            return false;

        float f = mEdge2.dot(qvec);
        f = f * inv_det - EPSILON;
        if (ray.t() <= f || f <  EPSILON)
            return false;

        ray.setUV(lambda, mue);
        ray.setHit(this, f);

        return true;
    }

    virtual Vec3f normal(const Ray & ray) const
    {
        assert(ray.hit() == this);
        assert(ray.obj());

        Vec3f e1 = mB - mA;
        Vec3f e2 = mC - mA;
        Vec3f normal = e1.cross(e2);
        ray.obj()->toGlobalCoordinates(normal);
        return normal.normal();
    }

    void axes(const Ray & /*ray*/, Vec3f & x, Vec3f & y) const
    {
/*        Vec3f b1 = ray.hit()->normal(ray);
        Vec3f b2 = b1.cross(ray.dir());
        Vec3f b3 = b1.cross(b2);

        x = b2.normal();
        y = b3.normal();
*/



        //   Vec3f a = mB - mA;
        //Vec3f b = mC - mA;
        
        x = mEdge1.normal();
        y = mEdge2.normal();

    }


protected:
    Vec3f mA, mB, mC;

    Vec3f mEdge1, mEdge2;


    virtual void calcBounds()
    {
        mBounds.extend(mA);
        mBounds.extend(mB);
        mBounds.extend(mC);
    }
};

#endif

---