aabb.hpp

/*
 * Copyright (c) 2006-2016, Visualization and Multimedia Lab,
 *                          University of Zurich <http://vmml.ifi.uzh.ch>,
 *                          Eyescale Software GmbH,
 *                          Blue Brain Project, EPFL
 *
 * This file is part of VMMLib <https://github.com/VMML/vmmlib/>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.  Redistributions in binary
 * form must reproduce the above copyright notice, this list of conditions and
 * the following disclaimer in the documentation and/or other materials provided
 * with the distribution.  Neither the name of the Visualization and Multimedia
 * Lab, University of Zurich nor the names of its contributors may be used to
 * endorse or promote products derived from this software without specific prior
 * written permission.
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef __VMML__AXIS_ALIGNED_BOUNDING_BOX__HPP__
#define __VMML__AXIS_ALIGNED_BOUNDING_BOX__HPP__

#include <vmmlib/vector.hpp>
#include <limits>

namespace lunchbox { template< class T > void byteswap( T& ); }

namespace vmml
{
template< typename T > class AABB
{
public:
    AABB();

    AABB( const vector< 3, T >& pMin, const vector< 3, T >& pMax );

    AABB( const vector< 4, T >& sphere );

    bool isIn( const vector< 3, T >& point ) const;

    bool isIn( const vector< 4, T >& sphere ) const;

    bool isInFront( const vector< 4, T >& plane ) const;

    const vector< 3, T >& getMin() const;

    const vector< 3, T >& getMax() const;

    void merge( const AABB< T >& aabb );

    void merge( const vector< 3, T >& point );

    void reset();

    bool isEmpty() const;

    bool operator==( const AABB< T >& other ) const;

    bool operator!=( const AABB< T >& other ) const;

    vector< 3, T > getCenter() const;

    vector< 3, T > getSize() const;

    void computeNearFar( const vector< 4, T >& plane, vector< 3, T >& nearPoint,
                         vector< 3, T >& farPoint ) const;

    static AABB< T > makeUnitBox();

private:
    vector< 3, T > _min;
    vector< 3, T > _max;
    template< class U > friend void lunchbox::byteswap( U& );
};

template< typename T > inline
std::ostream& operator << ( std::ostream& os, const AABB< T >& aabb )
{
    return os << aabb.getMin() << " - " << aabb.getMax();
}

template< typename T > AABB< T >::AABB()
    : _min( std::numeric_limits< T >::max( ))
    , _max( std::numeric_limits< T >::min( ))
{}

template<> inline AABB< float >::AABB()
    : _min( std::numeric_limits< float >::max( ))
    , _max( -std::numeric_limits< float >::max( ))
{}

template<> inline AABB< double >::AABB()
    : _min( std::numeric_limits< double >::max( ))
    , _max( -std::numeric_limits< double >::max( ))
{}

template< typename T >
AABB< T >::AABB( const vector< 3, T >& pMin, const vector< 3, T >& pMax)
    : _min( vector< 3, T >( std::min( pMin[0], pMax[0] ),
                            std::min( pMin[1], pMax[1] ),
                            std::min( pMin[2], pMax[2] )))
    , _max( vector< 3, T >( std::max( pMin[0], pMax[0] ),
                            std::max( pMin[1], pMax[1] ),
                            std::max( pMin[2], pMax[2] )))
{}

template< typename T > AABB< T >::AABB( const vector< 4, T >& sphere )
{
    _max = _min = sphere.getCenter();
    _max += sphere.getRadius();
    _min -= sphere.getRadius();
}

template< typename T > inline bool AABB< T >::isIn( const vector< 3, T >& pos ) const
{
    if ( pos.x() > _max.x() || pos.y() > _max.y() || pos.z() > _max.z() ||
         pos.x() < _min.x() || pos.y() < _min.y() || pos.z() < _min.z( ))
    {
        return false;
    }
    return true;
}

template< typename T > inline
bool AABB< T >::isIn( const vector< 4, T >& sphere ) const
{
    const vector< 3, T >& sv = sphere.getCenter();
    sv += sphere.getRadius();
    if ( sv.x() > _max.x() || sv.y() > _max.y() || sv.z() > _max.z() )
        return false;
    sv -= sphere.getRadius() * 2.0f;
    if ( sv.x() < _min.x() || sv.y() < _min.y() || sv.z() < _min.z() )
        return false;
    return true;
}

template< typename T > inline
bool AABB< T >::isInFront( const vector< 4, T >& plane ) const
{
    const auto& extent = getSize() * 0.5f;
    const float d = plane.dot( getCenter() );
    const float n = extent.x() * std::abs( plane.x( )) +
                    extent.y() * std::abs( plane.y( )) +
                    extent.z() * std::abs( plane.z( ));

    return !( d - n >= 0 || d + n > 0 );
}

template< typename T > inline const vector< 3, T >& AABB< T >::getMin() const
{
    return _min;
}

template< typename T > inline const vector< 3, T >& AABB< T >::getMax() const
{
    return _max;
}

template< typename T > inline
bool AABB< T >::operator==( const AABB< T >& other ) const
{
    return _min == other._min && _max == other._max;
}

template< typename T > inline
bool AABB< T >::operator!=( const AABB< T >& other ) const
{
    return _min != other._min || _max != other._max;
}

template< typename T > vector< 3, T > AABB< T >::getCenter() const
{
    return ( _min + _max ) * 0.5f;
}

template< typename T > vector< 3, T > AABB< T >::getSize() const
{
    return _max - _min;
}

template< typename T >
void AABB< T >::merge( const AABB<T>& aabb )
{
    const vector< 3, T >& min = aabb.getMin();
    const vector< 3, T >& max = aabb.getMax();

    if ( min.x() < _min.x() )
        _min.x() = min.x();
    if ( min.y() < _min.y() )
        _min.y() = min.y();
    if ( min.z() < _min.z() )
        _min.z() = min.z();

    if ( max.x() > _max.x() )
        _max.x() = max.x();
    if ( max.y() > _max.y() )
        _max.y() = max.y();
    if ( max.z() > _max.z() )
        _max.z() = max.z();
}

template< typename T >
void AABB< T >::merge( const vector< 3, T >& point )
{
    if ( point.x() < _min.x() )
        _min.x() = point.x();
    if ( point.y() < _min.y() )
        _min.y() = point.y();
    if ( point.z() < _min.z() )
        _min.z() = point.z();

    if ( point.x() > _max.x() )
        _max.x() = point.x();
    if ( point.y() > _max.y() )
        _max.y() = point.y();
    if ( point.z() > _max.z() )
        _max.z() = point.z();
}

template< typename T > inline void AABB< T >::reset()
{
    _min = std::numeric_limits< T >::max();
    _max = -std::numeric_limits< T >::max();
}

template< typename T > inline bool AABB< T >::isEmpty() const
{
    return _min.x() >= _max.x() || _min.y() >= _max.y() || _min.z() >= _max.x();
}

template< typename T > inline void
AABB< T >::computeNearFar( const vector< 4, T >& plane,
                           vector< 3, T >& nearPoint,
                           vector< 3, T >& farPoint ) const
{
    for( size_t i = 0; i < 3; ++i )
    {
        if( plane[ i ] >= 0.0 )
        {
            nearPoint[ i ] = _min[ i ];
            farPoint[ i ] = _max[ i ];
        }
        else
        {
            nearPoint[ i ] = _max[ i ];
            farPoint[ i ] = _min[ i ];
        }
    }
}

template< typename T > AABB< T > AABB< T >::makeUnitBox()
{
    return AABB( vector< 3, T >(), vector< 3, T >( 1 ));
}

}

#endif