/Users/craigcornelius/Projects/SPRING Mac Release 0.2/boundingbox.h

Go to the documentation of this file.

// $Id: boundingbox.h,v 1.8 2006/05/24 21:08:22 craig Exp $
// $Copyright: (c)2001 National Biocomputation Center, Stanford University $

#ifndef BoundingBox_Header
#define BoundingBox_Header

#include "face.h"
#include "point3d.h"
#include "reallocablearray.h"

// need to know about collision pair struct first, otherwise >2000 compiler errors!!!
typedef struct CollisionBoxPairStruct CollisionBoxPair;


// generic bounding box class 
class BoundingBox {
    friend class BoundingBoxNode;
    friend class BoundingBoxLeaf;
public:
    BoundingBox(BoundingBox* _parent);
    virtual ~BoundingBox();
    
        // static variables to manipulate bounding box trees
        static BoundingBox* createTree(Object* object);
        static BoundingBox* createTree(List<BoundingBoxLeaf*> &bbList);

        // pure virtual functions ("=0"), i.e. must be defined in derived classes
    virtual bool isLeaf() = 0;
        virtual void update() = 0;
        virtual void detectCollisions(BoundingBox* boundingBox, int myLevel, int otherLevel,
                                          ReallocableArray<CollisionBoxPair>* collisionPairs) = 0;
        virtual double collisionDepth(BoundingBox* boundingBox) = 0;
        virtual bool hasMarker() = 0;
        virtual void setMarker(bool marker_) = 0;

    virtual void draw();
        virtual bool overlap(BoundingBox* boundingBox);
        virtual Point3D center();

    inline BoundingBox* getParent() { return parent; }
    inline void setParent(BoundingBox* parent_) { parent = parent_; }
    inline Point3D getMin() { return min; }
    inline Point3D getMax() { return max; }
        inline void setMin(Point3D min_) { min = min_; }
        inline void setMax(Point3D max_) { max = max_; }
        inline Point3D getNormal() { return normal; }
        inline void setNormal(Point3D normal_) { normal = normal_; }
        inline Object* getObject() { return object; }
        inline void setObject(Object* object_) { object = object_; }

        inline double getWidth() { return max.x - min.x; }
        inline double getHeight() { return max.y - min.y; }
        inline double getDepth() { return max.z - min.z; }
        inline double getVolume() { return getWidth() * getHeight() * getDepth(); }
protected:
    BoundingBox* parent;
    Point3D min;
        Point3D max;
        Point3D normal;
        Object* object;
};

// node in a bounding box tree 
class BoundingBoxNode : public BoundingBox {
public:
    BoundingBoxNode(BoundingBox *left_ = NULL, 
                    BoundingBox *right_ = NULL, 
                    BoundingBox *parent_ = NULL);
    ~BoundingBoxNode();
    
    bool isLeaf() { return false; }
    void draw();
    void update();
        void internalUpdate();   // non-recursive self-update
        void detectCollisions(BoundingBox* boundingBox, int myLevel, int otherLevel,
                                  ReallocableArray<CollisionBoxPair>* collisionPairs);
        double collisionDepth(BoundingBox* boundingBox);
        bool hasMarker() { return marker; }
        void setMarker(bool marker_) { marker = marker_; };

    inline BoundingBox* getLeft() { return left; }
    inline BoundingBox* getRight() { return right; }
    inline void setLeft(BoundingBox* left_) { left = left_; }
    inline void setRight(BoundingBox* right_) { right = right_; }
private: 
    BoundingBox *left;
        BoundingBox *right;
        bool marker;
};


// leaf nodes in a tree 
class BoundingBoxLeaf : public BoundingBox {
public:
    BoundingBoxLeaf(Face *face_, BoundingBox *parent_ = NULL);
    ~BoundingBoxLeaf();
    
    bool isLeaf() { return true; }
    void update();
        void detectCollisions(BoundingBox* boundingBox, int myLevel, int otherLevel,
                                  ReallocableArray<CollisionBoxPair>* collisionPairs);
        double collisionDepth(BoundingBox* boundingBox);
        bool hasMarker() { return face->getMarker(); }
        void setMarker(bool marker_) { face->setMarker(marker_); };

    inline Face* getFace() { return face; }
    inline void setFace(Face *face_) { face = face_; }
private:
    Face *face;
};

#endif    // BoundingBox_Header

---