Aabb.h

#pragma once
 
#include "Vector3.h"
#include "Plane.h"
 
namespace SharpKmyMath
{
    public ref class Aabb
    {
    public:
        Aabb()
        {
        }
 
        Aabb(const Vector3 min, const Vector3 max)
        {
            construct(min, max);
        }
 
        Aabb(const Aabb^ o)
        {
            center = o->center;
            hsize = o->hsize;
        }
 
        Vector3 getCenter() { return center; }
        void setCenter(Vector3 v) { center = v; }
        Vector3 getSize() { return Vector3(hsize.x * 2, hsize.y * 2, hsize.z * 2); }
        void setSize(Vector3 v) { hsize = v * 0.5f; }
 
        Vector3 getMin() { return center + -hsize; }
        Vector3 getMax() { return center + hsize; }
        float getVolume() { return hsize.x * 2 * hsize.y * 2 * hsize.z * 2; }
 
        void inflate(float v)
        {
            hsize += Vector3(v);
        }
 
        void inflateRate(float r)
        {
            hsize *= r;
        }
 
        bool intersect(Aabb^ p)
        {
            Vector3 min = getMin();
            Vector3 max = getMax();
            Vector3 pmin = p->getMin();
            Vector3 pmax = p->getMax();
 
            return
                (min.x <= pmax.x && max.x >= pmin.x) &&
                (min.y <= pmax.y && max.y >= pmin.y) &&
                (min.z <= pmax.z && max.z >= pmin.z);
        }
 
        bool intersectAabb(Aabb^ p, Aabb^res)
        {
            Vector3 min = getMin();
            Vector3 max = getMax();
            Vector3 pmin = p->getMin();
            Vector3 pmax = p->getMax();
 
            Vector3 _min(0), _max(0);
 
            res->construct(_min, _max);
 
            if (min.x > pmax.x || max.x < pmin.x)
                return (res->getVolume() > 0);
            else
            {
                _min.x = (min.x > pmin.x) ? min.x : pmin.x;
                _max.x = (max.x < pmax.x) ? max.x : pmax.x;
            }
 
            if (min.y > pmax.y || max.y < pmin.y)
                return (res->getVolume() > 0);
            else
            {
                _min.y = (min.y > pmin.y) ? min.y : pmin.y;
                _max.y = (max.y < pmax.y) ? max.y : pmax.y;
            }
 
            if (min.z > pmax.z || max.z < pmin.z)
                return (res->getVolume() > 0);
            else
            {
                _min.z = (min.z > pmin.z) ? min.z : pmin.z;
                _max.z = (max.z < pmax.z) ? max.z : pmax.z;
            }
            res->construct(_min, _max);
            return (res->getVolume() > 0);
        }
 
        bool intersectPlane(Plane^ plane)
        {
            Vector3 min = getMin();
            Vector3 max = getMax();
            array<Vector3>^ points = gcnew array<Vector3>(8);
            points[0] = Vector3(min.x, min.y, min.z);
            points[1] = Vector3(max.x, min.y, min.z);
            points[2] = Vector3(min.x, min.y, max.z);
            points[3] = Vector3(max.x, min.y, max.z);
            points[4] = Vector3(min.x, max.y, min.z);
            points[5] = Vector3(max.x, max.y, min.z);
            points[6] = Vector3(min.x, max.y, max.z);
            points[7] = Vector3(max.x, max.y, max.z);
 
            bool over = false;
            bool under = false;
 
            for (int i = 0; i < 8; i++)
            {
                if (plane->distanceTo(points[i]) > 0)
                    over = true;
                else
                    under = true;
            }
 
            return under && over;
        }
 
        void expand(const Vector3 p)
        {
            Vector3 min = getMin();
            Vector3 max = getMax();
 
            if (p.x < min.x) min.x = p.x;
            if (p.y < min.y) min.x = p.y;
            if (p.z < min.z) min.x = p.z;
 
            if (p.x > max.x) max.x = p.x;
            if (p.y > max.y) max.x = p.y;
            if (p.z > max.z) max.x = p.z;
 
            construct(min, max);
        }
 
        void expand(Aabb^ aabb)
        {
            Vector3 min = getMin();
            Vector3 max = getMax();
            Vector3 amin = aabb->getMin();
            Vector3 amax = aabb->getMax();
 
            if (amin.x < min.x) min.x = amin.x;
            if (amin.y < min.y) min.x = amin.y;
            if (amin.z < min.z) min.x = amin.z;
 
            if (amax.x > max.x) max.x = amax.x;
            if (amax.y > max.y) max.x = amax.y;
            if (amax.z > max.z) max.x = amax.z;
 
            construct(min, max);
        }
 
    private:
 
        void construct(const Vector3 min, const Vector3 max)
        {
            hsize = (max + -min) * 0.5f;
            center = min + hsize;
            hsize = Vector3(fabs(hsize.x), fabs(hsize.y), fabs(hsize.z));
        }
 
        Vector3 center;
        Vector3 hsize;
    };
 
}