lib/client/frame.h

/* Copyright (c) 2006-2009, 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 EQ_FRAME_H
#define EQ_FRAME_H

#include <eq/client/eye.h>    // enum Eye
#include <eq/client/window.h> // nested ObjectManager type
#include <eq/client/types.h>  // member
#include <eq/client/zoom.h>   // member

#include <eq/base/monitor.h>
#include <eq/net/object.h>

namespace eq
{

namespace server
{
    class Frame;
}

    class FrameData;
    class Image;
    class Pipe;
    class Pixel;
    class Range;

    class Frame : public net::Object
    {
    public:
        enum Buffer
        {
            BUFFER_NONE      = EQ_BIT_NONE,
            BUFFER_UNDEFINED = EQ_BIT1,  
            BUFFER_COLOR     = EQ_BIT5,  
            BUFFER_DEPTH     = EQ_BIT9,  
            BUFFER_ALL       = EQ_BIT_ALL
        };

        enum Type
        {
            TYPE_MEMORY,    
            TYPE_TEXTURE    
        };

        EQ_EXPORT Frame();
        EQ_EXPORT virtual ~Frame();

        EQ_EXPORT const std::string& getName() const;

        const Vector2i& getOffset() const { return _data.offset; }
        void setOffset( const Vector2i& offset ) { _data.offset = offset;}

        EQ_EXPORT const Range& getRange() const;
        EQ_EXPORT void         setRange( const Range& range );

        EQ_EXPORT const Pixel& getPixel() const;

        const Zoom& getZoom() const { return _data.zoom; }

        void setZoom( const Zoom& zoom ) { _data.zoom = zoom; }

        EQ_EXPORT const ImageVector& getImages() const;

        void setData( FrameData* data ) { _frameData = data; }
        FrameData* getData() { return _frameData; }

        EQ_EXPORT void setPixelViewport( const PixelViewport& pvp );

        const net::ObjectVersion& getDataVersion( const Eye eye ) const
            { return _data.frameData[ eye ]; }


        EQ_EXPORT void clear();

        void flush();

        EQ_EXPORT void startReadback( Window::ObjectManager* glObjects );
        
        EQ_EXPORT void syncReadback();

        void transmit( net::NodePtr toNode, const uint32_t frameNumber );

        void setReady();

        EQ_EXPORT bool isReady() const;

        EQ_EXPORT void waitReady() const;

        void addListener( base::Monitor<uint32_t>& listener );

        void removeListener( base::Monitor<uint32_t>& listener );

        EQ_EXPORT uint32_t getBuffers() const;

        EQ_EXPORT void disableBuffer( const Buffer buffer );

        EQ_EXPORT void setColorType( const GLuint colorType );

        EQ_EXPORT void setAlphaUsage( const bool useAlpha );

        void useSendToken( const bool use );

    protected:
        virtual ChangeType getChangeType() const { return INSTANCE; }
        virtual void getInstanceData( net::DataOStream& os );
        virtual void applyInstanceData( net::DataIStream& is );

    private:
        std::string _name;
        FrameData*  _frameData;

        friend class eq::server::Frame;
        struct Data
        {
            Data() : offset( Vector2i::ZERO ), zoom( 0.f, 0.f ) {}

            Vector2i     offset;
            Zoom               zoom;
            net::ObjectVersion frameData[EYE_ALL];
        }
        _data;

        union // placeholder for binary-compatible changes
        {
            char dummy[64];
        };
    };

    EQ_EXPORT std::ostream& operator << ( std::ostream&, const Frame::Type );
    EQ_EXPORT std::ostream& operator << ( std::ostream&, const Frame::Buffer );
};
#endif // EQ_FRAME_H