viewport.h

/* Copyright (c) 2006-2010, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *  
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQFABRIC_VIEWPORT_H
#define EQFABRIC_VIEWPORT_H

#include <eq/fabric/api.h>
#include <eq/fabric/types.h>
#include <lunchbox/debug.h>

#include <iostream>

namespace eq
{
namespace fabric
{
    class PixelViewport;
    class Viewport;
    std::ostream& operator << ( std::ostream& os, const Viewport& vp );

    class Viewport 
    {
    public:
        Viewport() : x(0.0f), y(0.0f), w(1.0f), h(1.0f)  {}

        explicit Viewport( const float x_, const float y_,
                           const float w_, const float h_ )
                : x(x_), y(y_), w(w_), h(h_)  {}

        explicit Viewport( const Vector4f& from )
                : x( from[0] ), y( from[1] ), w( from[2] ), h( from[3] )  {}

        void invalidate() { x=0.0f; y=0.0f; w=-1.0f; h=-1.0f; }

        void apply( const Viewport& rhs )
            {
                LBASSERTINFO( isValid(), *this);
                LBASSERTINFO( rhs.isValid(), rhs );                
                x += rhs.x * w;
                y += rhs.y * h;
                w *= rhs.w;
                h *= rhs.h;
            }
            
        void transform( const Viewport& rhs )
            {
                w = w / rhs.w;
                h = h / rhs.h;
                x = ( x - rhs.x ) / rhs.w;
                y = ( y - rhs.y ) / rhs.h;
            }

        bool operator == ( const Viewport& rhs ) const 
            { 
                return ( x==rhs.x && y==rhs.y && w==rhs.w && h==rhs.h);
            }

        bool operator != ( const Viewport& rhs ) const 
            { 
                return ( x!=rhs.x || y!=rhs.y || w!=rhs.w || h!=rhs.h);
            }

        bool isValid() const 
            { return ( x>=0.0f && y>=0.0f && w>=0.0f && h>=0.0f ); }
        
        bool hasArea() const { return (w>0.0f && h>0.0f); }

        float getArea() const { return w*h; }

        float getXEnd() const { return x+w; }

        float getYEnd() const { return y+h; }

        void intersect( const Viewport& rhs )
            {
                if( *this == rhs )
                    return;

                if( !rhs.isValid() || !isValid() )
                {
                    invalidate();
                    return;
                }
                
                if( !rhs.hasArea() || !hasArea() )
                {
                    x = 0;
                    y = 0;
                    w = 0;
                    h = 0;
                    return;
                }
                
                const float sEx = static_cast< float >(     x +     w );
                const float sEy = static_cast< float >(     y +     h );
                const float dEx = static_cast< float >( rhs.x + rhs.w );
                const float dEy = static_cast< float >( rhs.y + rhs.h );
                    
                x = LB_MAX( x, rhs.x );
                y = LB_MAX( y, rhs.y );
                w = LB_MIN( sEx, dEx ) - x;
                h = LB_MIN( sEy, dEy ) - y;
            }

        void unite( const Viewport& rhs )
            {
                const float xEnd = LB_MAX( getXEnd(), rhs.getXEnd( ));
                const float yEnd = LB_MAX( getYEnd(), rhs.getYEnd( ));
                x = LB_MIN( x, rhs.x );
                y = LB_MIN( y, rhs.y );
                w = xEnd - x;
                h = yEnd - y;
            }

        Viewport getCoverage( const Viewport& with ) const
            {
                Viewport coverage( with );
                coverage.intersect( *this ); // intersection
                coverage.transform( *this ); // in our coordinate system

                return coverage;
            }

        EQFABRIC_API void applyView( const Viewport& segmentVP,
                                  const Viewport& viewVP,
                                  const PixelViewport& pvp, 
                                  const Vector4i& overdraw );

        float x; 
        float y; 
        float w; 
        float h; 

        EQFABRIC_API static const Viewport FULL; 
    };

    inline std::ostream& operator << ( std::ostream& os, const Viewport& vp )
    {
        os << "[ " << vp.x << " " << vp.y << " " << vp.w << " " << vp.h << " ]";
        return os;
    }
}
}

#endif // EQFABRIC_VIEWPORT_H