pixelViewport.h

/* Copyright (c) 2006-2015, 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_PIXELVIEWPORT_H
#define EQFABRIC_PIXELVIEWPORT_H

#include <eq/fabric/viewport.h> // used in inline method
#include <eq/fabric/pixel.h>    // used in inline method
#include <eq/fabric/zoom.h>     // used in inline method

#include <lunchbox/debug.h>

#include <limits>

namespace eq
{
namespace fabric
{
class PixelViewport
{
public:
    PixelViewport() : x(0), y(0), w(-1), h(-1)  {}

    PixelViewport( const int32_t x_, const int32_t y_,
                   const int32_t w_,const int32_t h_ )
        : x(x_), y(y_), w(w_), h(h_)  {}

    explicit PixelViewport( const int32_t pvp[4] )
        : x( pvp[0] ), y( pvp[1] ), w( pvp[2] ), h( pvp[3] )  {}

    void invalidate() { x = 0; y = 0; w = -1; h = -1; }

    bool isValid() const { return (w>=0 && h>=0); }

    bool hasArea() const { return (w>0 && h>0); }

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

    bool isInside( const int32_t pX, const int32_t pY ) const
    {
        if( pX < x || pY < y || pX > (x+w) || pY > (y+h) )
            return false;
        return true;
    }

    void apply( const Viewport& rhs )
    {
        // honor position over size to avoid rounding artifacts
        const int32_t xEnd = x + static_cast<int32_t>((rhs.x+rhs.w)*w);
        const int32_t yEnd = y + static_cast<int32_t>((rhs.y+rhs.h)*h);

        x += static_cast<int32_t>( w * rhs.x );
        y += static_cast<int32_t>( h * rhs.y );
        w = xEnd - x;
        h = yEnd - y;
    }

    void apply( const Pixel& pixel )
    {
        if( pixel.w > 1 )
        {
            int32_t newWidth = w / pixel.w;
            // This would be the correct thing to do, but it would
            // require frustum adaptations in CUV::_computeFrustum:
            //if( w - ( newWidth * pixel.w ) > pixel.x )
            if( w - ( newWidth * pixel.w ) != 0 )
                ++newWidth;

            w = newWidth;
        }
        if( pixel.h > 1 )
        {
            int32_t newHeight = h / pixel.h;
            // This would be the correct thing to do, but it would
            // require frustum adaptations in CUV::_computeFrustum:
            // if( w - ( newWidth * pixel.h ) > pixel.y )
            if( h - ( newHeight * pixel.h ) != 0 )
                ++newHeight;

            h = newHeight;
        }
    }

    void apply( const Zoom& zoom )
    {
        if( zoom == Zoom::NONE )
            return;

        x = static_cast< int32_t >( x * zoom.x() + .5f );
        y = static_cast< int32_t >( y * zoom.y() + .5f );
        w = static_cast< int32_t >( w * zoom.x() + .5f );
        h = static_cast< int32_t >( h * zoom.y() + .5f );
    }

    const Zoom getZoom( const PixelViewport& rhs ) const
    {
        if( *this == rhs )
            return Zoom::NONE;

        if( !rhs.hasArea( ))
            return Zoom( std::numeric_limits< float >::max(),
                         std::numeric_limits< float >::max( ));

        return Zoom( w / static_cast<float>( rhs.w ),
                     h / static_cast<float>( rhs.h ));
    }

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

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

    void convertToPlugin( uint64_t dims[4] ) const
    {
        dims[ 0 ] = x;
        dims[ 1 ] = w;
        dims[ 2 ] = y;
        dims[ 3 ] = h;
    }

    void convertFromPlugin( const uint64_t dims[4] )
    {
        x = int32_t( dims[ 0 ]);
        w = int32_t( dims[ 1 ]);
        y = int32_t( dims[ 2 ]);
        h = int32_t( dims[ 3 ]);
    }

    const PixelViewport operator + ( const Vector2i& offset ) const
    {
        return PixelViewport( x+offset.x(), y+offset.y(), w, h );
    }

    Viewport operator / ( const PixelViewport& rhs ) const
    {
        if( *this == rhs )
            return Viewport::FULL;

        if( !rhs.hasArea( ))
            return Viewport( static_cast<float>( x ),
                             static_cast<float>( y ), 0.f, 0.f );

        return Viewport(  ( x - rhs.x )/ static_cast<float>( rhs.w ),
                          ( y - rhs.y )/ static_cast<float>( rhs.h ),
                          ( w )/ static_cast<float>( rhs.w ),
                          ( h )/ static_cast<float>( rhs.h ));
    }

    const PixelViewport& operator -= ( const Vector2i& offset )
    {
        x -= offset.x();
        y -= offset.y();
        return *this;
    }

    void unapply( const Pixel& pixel )
    {
        w *= pixel.w;
        h *= pixel.h;
        x += pixel.x;
        y += pixel.y;
    }

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

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

    void merge( const PixelViewport& rhs )
    {
        if( *this == rhs || !rhs.isValid( ))
            return;

        if( !hasArea( ))
        {
            *this = rhs;
            return;
        }
        if( !rhs.hasArea( ))
            return;

        const int32_t sEx =     x +     w;
        const int32_t sEy =     y +     h;
        const int32_t dEx = rhs.x + rhs.w;
        const int32_t dEy = rhs.y + rhs.h;

        x = LB_MIN( x, rhs.x );
        y = LB_MIN( y, rhs.y );
        w = LB_MAX( sEx, dEx ) - x;
        h = LB_MAX( sEy, dEy ) - y;
    }

    void intersect( const PixelViewport& 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 int32_t sEx =     x +     w;
        const int32_t sEy =     y +     h;
        const int32_t dEx = rhs.x + rhs.w;
        const int32_t dEy = 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;
    }


    int32_t x;
    int32_t y;
    int32_t w;
    int32_t h;
};

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

namespace lunchbox
{
template<> inline void byteswap( eq::fabric::PixelViewport& value )
{
    byteswap( value.x );
    byteswap( value.y );
    byteswap( value.w );
    byteswap( value.h );
}
}
#endif // EQFABRIC_PIXELVIEWPORT_H