src/Box.h

Go to the documentation of this file.

#ifndef BOX_H
#define BOX_H


#include "Vec3f.h"
#include "Ray.h"
#include "Axis.h"
#include "SplitPlane.h"


class Box
{
public:
    Box()
    {
        clear();
    }

    Box(const Vec3f & minVertex, const Vec3f & maxVertex)
        : mMin(minVertex),
            mMax(maxVertex)
    {
    }

    void extend(const Vec3f & a)
    {
        mMin = min(a - Vec3f(EPSILON), mMin);
        mMax = max(a + Vec3f(EPSILON), mMax);
    }

    void extend(const Box & box)
    {
        extend(box.mMin - Vec3f(EPSILON));
        extend(box.mMax + Vec3f(EPSILON));
    }

    void clear()
    {
        mMin = Vec3f(INFINITY, INFINITY, INFINITY);
        mMax = Vec3f(-INFINITY, -INFINITY, -INFINITY);
    }

    std::pair<float, float> intersect(const Ray & ray) const
    {
        float d0 = -INFINITY;
        float d1 = INFINITY;

        if (fabs(ray.dir().x()) > EPSILON)
        {
            d0 = (mMin.x() - ray.org().x()) / ray.dir().x();
            d1 = (mMax.x() - ray.org().x()) / ray.dir().x();
            if (d1 < d0)
                std::swap(d0, d1);
        }

        if (fabs(ray.dir().y()) > EPSILON)
        {
            float t0, t1;
            t0 = (mMin.y() - ray.org().y()) / ray.dir().y();
            t1 = (mMax.y() - ray.org().y()) / ray.dir().y();
            if (t1 < t0)
                std::swap(t0, t1);
            d0 = std::max(d0, t0);
            d1 = std::min(d1, t1);
        }

        if (fabs(ray.dir().z()) > EPSILON)
        {
            float t0, t1;
            t0 = (mMin.z() - ray.org().z()) / ray.dir().z();
            t1 = (mMax.z() - ray.org().z()) / ray.dir().z();
            if (t1 < t0)
                std::swap(t0, t1);
            d0 = std::max(d0, t0);
            d1 = std::min(d1, t1);
        }

        if (d1 < d0 || d0 <= -INFINITY)
            return std::make_pair(INFINITY, -INFINITY);
        else
            return std::make_pair(d0 - EPSILON, d1 + EPSILON);
    }

    inline const Vec3f & minVertex() const
    {
        return mMin;
    }

    inline const Vec3f & maxVertex() const
    {
        return mMax;
    }

    float area(const SplitPlane & plane) const    // FIXME not accurate
    {
        assert(plane.direction() != NO_AXIS);
//        assert(mMin[plane.direction()] <= plane.position() && plane.position() <= mMax[plane.direction()]);

        Vec3f diff = mMax - mMin;
        return (plane.position() - mMin[plane.direction()]) / diff[plane.direction()];
    }

    std::pair<Box, Box> split(const SplitPlane & plane) const
    {
        assert(plane.direction() != NO_AXIS);
//        LOG("[" << mMin << " , " << mMax << "]  " << plane.position() << " " << plane.direction());
//        assert(mMin[plane.direction()] <= plane.position() && plane.position() <= mMax[plane.direction()]);

        switch (plane.direction())
        {
            case X_AXIS:    return std::make_pair(Box(mMin, Vec3f(plane.position() - EPSILON, mMax.y(), mMax.z())),
                                                    Box(Vec3f(plane.position() + EPSILON, mMin.y(), mMin.z()), mMax));
            case Y_AXIS:    return std::make_pair(Box(mMin, Vec3f(mMax.x(), plane.position() - EPSILON, mMax.z())),
                                                    Box(Vec3f(mMin.x(), plane.position() + EPSILON, mMin.z()), mMax));
            case Z_AXIS:    return std::make_pair(Box(mMin, Vec3f(mMax.x(), mMax.y(), plane.position() - EPSILON)),
                                                    Box(Vec3f(mMin.x(), mMin.y(), plane.position() + EPSILON), mMax));
            default:        return std::make_pair(Box(), Box());
        }
    }

    Box clip(const Box & other) const
    {
        return Box(max(mMin, other.mMin), min(mMax, other.mMax));
    }

private:
    Vec3f mMin;

    Vec3f mMax;
};

#endif

---