frustum.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__FRUSTUM__HPP__
#define __VMML__FRUSTUM__HPP__

#include <vmmlib/matrix.hpp> // used inline
#include <cstring> // memcmp

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

    Frustum( T left, T right, T bottom, T top, T nearPlane, T farPlane );

    Frustum( T field_of_view_y, T aspect_ratio, T nearPlane_, T farPlane );

    Frustum( const Matrix< 4, 4, T >& projection );

    ~Frustum() {}

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

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

    bool equals( const Frustum< T >& other,
                 T tolerance = std::numeric_limits< T >::epsilon( )) const;

    Matrix< 4, 4, T > computePerspectiveMatrix() const;

    Matrix< 4, 4, T > computeOrthoMatrix() const;

    void jitter( const vector< 2, T >& jitter_ );

    void adjustNearPlane( const T nearPlane );

    T& left() { return _array[0]; }
    T left() const { return _array[0]; }

    T& right() { return _array[1]; }
    T right() const { return _array[1]; }

    T& bottom() { return _array[2]; }
    T bottom() const { return _array[2]; }

    T& top() { return _array[3]; }
    T top() const { return _array[3]; }

    T& nearPlane() { return _array[4]; }
    T nearPlane() const { return _array[4]; }

    T& farPlane() { return _array[5]; }
    T farPlane() const { return _array[5]; }

    T getWidth() const;

    T getHeight() const;

    friend std::ostream& operator << ( std::ostream& os, const Frustum& f )
    {
        const std::ios::fmtflags flags = os.flags();
        const int                prec  = os.precision();

        os.setf( std::ios::right, std::ios::adjustfield );
        os.precision( 5 );
        os << "[" << std::setw(10) << f.left() << " "
           << std::setw(10) << f.right()  << " "
           << std::setw(10) << f.bottom() << " "
           << std::setw(10) << f.top()    << " "
           << std::setw(10) << f.nearPlane()   << " "
           << std::setw(10) << f.farPlane()    << "]";
        os.precision( prec );
        os.setf( flags );
        return os;
    };

private:
    T _array[6]; 
};
} // namespace vmml

// - implementation - //

namespace vmml
{

template< typename T > Frustum< T >::Frustum()
{
    _array[0] = -1;
    _array[1] = 1;
    _array[2] = -1;
    _array[3] = 1;
    _array[4] = 0.1f;
    _array[5] = 100;
}

template < typename T >
Frustum<T>::Frustum( const T _left, const T _right, const T _bottom,
                     const T _top, const T _near, const T _far )
{
    _array[0] = _left;
    _array[1] = _right;
    _array[2] = _bottom;
    _array[3] = _top;
    _array[4] = _near;
    _array[5] = _far;
}

template < typename T >
Frustum<T>::Frustum( const T fov_y, const T aspect_ratio, const T nearPlane_,
                     const T farPlane_ )
{
    _array[2] = std::tan( 0.5 * fov_y * M_PI / 180.0 ) * nearPlane_;
    _array[3] = -_array[2];
    // depend on _array[2,3]:
    _array[0] = bottom() * aspect_ratio;
    _array[1] = top() * aspect_ratio;
    _array[4] = nearPlane_;
    _array[5] = farPlane_;
}

template < typename T >
Frustum<T>::Frustum( const Matrix< 4, 4, T >& projection )
{
    _array[4] = projection( 2, 3 ) / (projection( 2, 2 ) - 1.0);
    _array[5] = projection( 2, 3 ) / (projection( 2, 2 ) + 1.0);
    _array[2] = nearPlane() * ( projection( 1, 2 ) - 1.0 ) / projection( 1, 1 );
    _array[3] = nearPlane() * ( projection( 1, 2 ) + 1.0 ) / projection( 1, 1 );
    _array[0] = nearPlane() * ( projection( 0, 2 ) - 1.0 ) / projection( 0, 0 );
    _array[1] = nearPlane() * ( projection( 0, 2 ) + 1.0 ) / projection( 0, 0 );
}

template < typename T >
bool Frustum<T>::operator==( const Frustum< T >& other ) const
{
    return ::memcmp( _array, other._array, sizeof( _array )) == 0;
}

template < typename T >
bool Frustum<T>::operator!=( const Frustum< T >& other ) const
{
    return ::memcmp( _array, other._array, sizeof( _array )) != 0;
}

template < typename T >
bool Frustum<T>::equals( const Frustum< T >& other, const T tolerance ) const
{
    return std::abs( _array[0] - other._array[0] ) <= tolerance &&
           std::abs( _array[1] - other._array[1] ) <= tolerance &&
           std::abs( _array[2] - other._array[2] ) <= tolerance &&
           std::abs( _array[3] - other._array[3] ) <= tolerance &&
           std::abs( _array[4] - other._array[4] ) <= tolerance &&
           std::abs( _array[5] - other._array[5] ) <= tolerance;
}

template < typename T >
Matrix< 4, 4, T > Frustum<T>::computePerspectiveMatrix() const
{
    Matrix< 4, 4, T > M;

    M( 0,0 ) = 2.0 * nearPlane() / ( right() - left() );
    M( 0,1 ) = 0.0;
    M( 0,2 ) = ( right() + left() ) / ( right() - left() );
    M( 0,3 ) = 0.0;

    M( 1,0 ) = 0.0;
    M( 1,1 ) = 2.0 * nearPlane() / ( top() - bottom() );
    M( 1,2 ) = ( top() + bottom() ) / ( top() - bottom() );
    M( 1,3 ) = 0.0;

    M( 2,0 ) = 0.0;
    M( 2,1 ) = 0.0;
    // NOTE: Some glfrustum man pages say wrongly '(far + near) / (far - near)'
    M( 2,2 ) = -( farPlane() + nearPlane() ) / ( farPlane() - nearPlane( ));
    M( 2,3 ) = -2.0 * farPlane() * nearPlane() / (farPlane() - nearPlane());

    M( 3,0 ) = 0.0;
    M( 3,1 ) = 0.0;
    M( 3,2 ) = -1.0;
    M( 3,3 ) =  0.0;

    return M;
}

template < typename T >
Matrix< 4, 4, T > Frustum< T >::computeOrthoMatrix() const
{
    Matrix< 4, 4, T > M;

    M( 0,0 ) = 2.0 / ( right() - left() );
    M( 0,1 ) = 0.0;
    M( 0,2 ) = 0.0;
    M( 0,3 ) = -( right() + left() ) / ( right() - left() );

    M( 1,0 ) = 0.0;
    M( 1,1 ) = 2.0 / ( top() - bottom() );
    M( 1,2 ) = 0.0f;
    M( 1,3 ) = -( top() + bottom() ) / ( top() - bottom() );

    M( 2,0 ) = 0.0;
    M( 2,1 ) = 0.0;
    M( 2,2 ) = -2.0 / ( farPlane() - nearPlane() );
    M( 2,3 ) = -( farPlane() + nearPlane() ) / ( farPlane() - nearPlane() );

    M( 3,0 ) = 0.0;
    M( 3,1 ) = 0.0;
    M( 3,2 ) = 0.0;
    M( 3,3 ) = 1.0f;

    return M;
}

template < typename T >
void Frustum< T >::jitter( const vector< 2, T >& jitter_ )
{
    left()   = left() + jitter_.x();
    right()  = right() + jitter_.x();
    bottom() = bottom() + jitter_.y();
    top()    = top() + jitter_.y();
}

template < typename T > void Frustum<T>::adjustNearPlane( const T new_near )
{
    if( new_near == nearPlane() )
        return;

    const T ratio = new_near / nearPlane();
    right()     *= ratio;
    left()      *= ratio;
    top()       *= ratio;
    bottom()    *= ratio;
    nearPlane()  = new_near;
}

template< typename T > inline T Frustum< T >::getWidth() const
{
    return std::abs( right() - left( ));
}

template< typename T > inline T Frustum< T >::getHeight() const
{
    return std::abs( top() - bottom( ));
}


} //namespace vmml

#endif