src/Node.h

Go to the documentation of this file.

#ifndef NODE_H
#define NODE_H


#include <vector>
#include <cassert>

#include "Axis.h"
#include "Ray.h"


class Primitive;


class Node
{
public:
    Node()
        : mSplitAxis(NO_AXIS),
            mSplitPlane(INFINITY),
            mLeft(NULL),
            mRight(NULL),
            mPrimitives()
    {
    }
    
    Node(const std::vector<Primitive *> primitives)
        : mSplitAxis(NO_AXIS),
            mSplitPlane(INFINITY),
            mLeft(NULL),
            mRight(NULL),
            mPrimitives(primitives)
    {
    }
    
    ~Node()
    {
        delete mLeft;
        delete mRight;
    }

    Node * left() const
    {
        return mLeft;
    }

    Node * right() const
    {
        return mRight;
    }

    void setLeftRight(Node * newleft, Node * newright)
    {
        assert(newleft);
        assert(newright);

        mLeft   = newleft;
        mRight  = newright;
    }

    Axis splitAxis() const
    {
        return mSplitAxis;
    }

    void setSplitAxis(Axis splitaxis)
    {
        mSplitAxis = splitaxis;
    }

    float splitPlane() const
    {
        return mSplitPlane;
    }

    void setSplitPlane(float plane)
    {
        mSplitPlane = plane;
    } 

    void add(Primitive * primitive)
    {
        mPrimitives.push_back(primitive);
    }

    Primitive * primitive(unsigned int index) const
    {
        return mPrimitives[index];
    }

    void clear_primitives()
    {
        mPrimitives.clear();
    }

    unsigned int primitives_count() const
    {
        return mPrimitives.size();
    }

    bool isLeafNode() const
    {
        return mSplitAxis == NO_AXIS;
    }
    
    bool leafIntersect(Ray & ray, float min, float max) const;
    
    inline void nearFar(const Ray & r, Node *& near, Node *& far) const
    {
        if (mSplitPlane >= r.org()[mSplitAxis])
        {
            near    = mLeft;
            far     = mRight;
        }
        else
        {
            near    = mRight;
            far     = mLeft;
        }
    }
    
    inline float distanceToSplitPlane(const Ray & ray) const
    {
        return (mSplitPlane - ray.org()[mSplitAxis]) / ray.dir()[mSplitAxis];
    }

private:
    Axis                        mSplitAxis;

    float                       mSplitPlane;

    Node *                      mLeft;

    Node *                      mRight;

    std::vector<Primitive *>    mPrimitives;
};


#endif

---