AxisAlignedBoundingBox.h

Go to the documentation of this file.

#ifndef GlobeEngine_AxisAlignedBoundingBox_h
#define GlobeEngine_AxisAlignedBoundingBox_h

#include <vmmlib/vmmlib.hpp>

namespace ge {

    template<int DIM, class TYPE> struct Bound
    {
        vmml::vector< DIM, TYPE> min; 
        vmml::vector< DIM, TYPE> max; 
    };

    template <int DIM, class TYPE> class AxisAlignedBoundingBox
    {
    public:
        AxisAlignedBoundingBox() { clear(); };
        AxisAlignedBoundingBox(const vmml::vector< DIM, TYPE>& _min, const vmml::vector< DIM, TYPE>& _side) {
            this->set(_min, _side);
        };

        ~AxisAlignedBoundingBox() {};

        void clear() {
            this->points.min = vmml::vector< DIM, TYPE>::ZERO;
            this->points.max = vmml::vector< DIM, TYPE>::ZERO;
            this->side = vmml::vector< DIM, TYPE>::ZERO;
        }

        void set(const vmml::vector< DIM, TYPE>& _min, const vmml::vector< DIM, TYPE>& _side) {
            this->points.min = _min;
            this->side = _side;
            this->points.max = this->points.min + this->side;
        }

        void setMinMax(const vmml::vector< DIM, TYPE>& _min, const vmml::vector< DIM, TYPE>& _max) {
            this->points.min = _min;
            this->points.max = _max;
            this->setSides();
        }

        void set(const Bound< DIM, TYPE>& _points) {
            this->points.min = _points.min;
            this->points.max = _points.max;
            this->setSides();
        }

        void resetMin(const vmml::vector< DIM, TYPE>& _in) {
            this->points.min = _in;
            this->setSides();
        }

        void resetMax(const vmml::vector< DIM, TYPE>& _in) {
            this->points.max = _in;
            this->setSides();
        }

        vmml::vector< DIM, TYPE> getMin() const { return this->points.min; }
        vmml::vector< DIM, TYPE> getMax() const { return this->points.max; }
        vmml::vector< DIM, TYPE> getSides() const { return this->side; }
        
    private:
        void setSides() {
            this->side = this->points.max - this->points.min;
        }

        // Points describing minimum and maximum
        Bound< DIM, TYPE> points;
        // Sidelenghts of all edges
        vmml::vector< DIM, TYPE> side;
    };

    typedef AxisAlignedBoundingBox<2, float> AxisAlignedBoundingBox2f;
    typedef AxisAlignedBoundingBox<2, double> AxisAlignedBoundingBox2d;
    typedef AxisAlignedBoundingBox<3, float> AxisAlignedBoundingBox3f;
    typedef AxisAlignedBoundingBox<3, double> AxisAlignedBoundingBox3d;

    typedef AxisAlignedBoundingBox<2, float> AABB2f;
    typedef AxisAlignedBoundingBox<2, double> AABB2d;
    typedef AxisAlignedBoundingBox<3, float> AABB3f;
    typedef AxisAlignedBoundingBox<3, double> AABB3d;

}
#endif