frame.h

/* Copyright (c) 2006-2011, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2010, Cedric Stalder <cedric.stalder@gmail.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/api.h>
#include <eq/client/eye.h>    // enum Eye
#include <eq/client/types.h>
#include <eq/client/zoomFilter.h>   // member

#include <eq/fabric/zoom.h>   // member
#include <co/object.h>
#include <co/objectVersion.h>
#include <co/types.h>
#include <co/base/bitOperation.h> // function getIndexOfLastBit
#include <co/base/monitor.h>

namespace eq
{
namespace server
{
    class Frame;
}
    class Frame : public co::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_32
        };

        enum Type
        {
            TYPE_MEMORY,    
            TYPE_TEXTURE    
        };

        EQ_API Frame();

        EQ_API virtual ~Frame();

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

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

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

        EQ_API const Range& getRange() const;

        EQ_API const Pixel& getPixel() const;

        EQ_API const SubPixel& getSubPixel() const;

        EQ_API uint32_t getPeriod() const;

        EQ_API uint32_t getPhase() const;

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

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

        void setZoomFilter( const ZoomFilter zoomFilter )
            { _zoomFilter = zoomFilter; }

        ZoomFilter getZoomFilter() const { return _zoomFilter; }

        EQ_API const Images& getImages() const;

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

        FrameData* getData() { return _frameData; }

        const FrameData* getData() const { return _frameData; }

        EQ_API uint32_t getBuffers() const;

        EQ_API void disableBuffer( const Buffer buffer );

        EQ_API void setAlphaUsage( const bool useAlpha );

        EQ_API void setQuality( const Frame::Buffer buffer,
                                   const float quality );

        EQ_API void useCompressor( const Frame::Buffer buffer,
                                   const uint32_t name );

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

        EQ_API void clear();

        void flush();

        EQ_API void readback( util::ObjectManager< const void* >* glObjects,
                                 const DrawableConfig& config );

        void setReady();

        EQ_API bool isReady() const;

        EQ_API void waitReady( const uint32_t timeout =
                               EQ_TIMEOUT_INDEFINITE ) const;

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

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

        const std::vector< uint128_t >& getInputNodes( const Eye eye ) const
        { return _data.toNodes[co::base::getIndexOfLastBit(eye)].inputNodes; }

        const std::vector< uint128_t >& getInputNetNodes(const Eye eye) const
        { return _data.toNodes[co::base::getIndexOfLastBit(eye)].inputNetNodes; }

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

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

        ZoomFilter _zoomFilter; // texture filter

        friend class eq::server::Frame;

        struct Data
        {
            struct ToNode
            {
                std::vector< uint128_t > inputNodes;
                std::vector< uint128_t > inputNetNodes;
            };

            Data() : offset( Vector2i::ZERO ) {}

            Vector2i offset;
            Zoom zoom;
            co::ObjectVersion frameData[ NUM_EYES ];
            ToNode toNodes[ NUM_EYES ];

            EQ_API void serialize( co::DataOStream& os ) const;
            EQ_API void deserialize( co::DataIStream& is );
        }
        _data;

        struct Private;
        Private* _private; // placeholder for binary-compatible changes
    };

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