server/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 EQSERVER_FRAME_H
#define EQSERVER_FRAME_H

#include "compound.h"

#include <eq/client/frame.h>
#include <eq/client/packets.h>

namespace eq
{
namespace server
{
    class Compound;
    class FrameData;
    class Node;

    class Frame : public net::Object
    {
    public:
        EQSERVER_EXPORT Frame();
        Frame( const Frame& from );

        Compound* getCompound() const { return _compound; }
        Channel* getChannel() const 
            { return _compound ? _compound->getChannel() :0; }
        Node* getNode() const { return _compound ? _compound->getNode() :0; }

        void setName( const std::string& name ) { _name = name; }
        const std::string& getName() const      { return _name; }

        FrameData* getMasterData() const { return _masterFrameData; }
        bool       hasData( const eq::Eye eye ) const
            { return ( _frameData[eye] != 0 ); }

        void setViewport( const eq::Viewport& vp ) { _vp = vp; }
        
        const eq::Viewport& getViewport() const { return _vp; }

        void setZoom( const eq::Zoom& zoom ) { _data.zoom = zoom; }
        
        const eq::Zoom& getZoom() const { return _data.zoom; }

        void setBuffers( const uint32_t buffers ) { _buffers = buffers; }

        eq::Frame::Type getType() const { return _type; }

        void setType( const eq::Frame::Type type ) { _type = type; }

        uint32_t getBuffers() const { return _buffers; }

        void commitData();

        EQSERVER_EXPORT virtual uint32_t commit();

        void cycleData( const uint32_t frameNumber, const uint32_t eyes );

        void addInputFrame( Frame* frame, const uint32_t eyes );
        const FrameVector& getInputFrames( const eq::Eye eye ) const
            { return _inputFrames[eye]; }

        void unsetData();

        void flush();

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

        void setOffset( const Vector2i& offset )
           { _data.offset = offset; }
        
        void setInheritZoom( const eq::Zoom& zoom )
            { _inherit.zoom = zoom; }

        const eq::Zoom& getInheritZoom() const { return _inherit.zoom; }
        
    protected:
        EQSERVER_EXPORT virtual ~Frame();
        EQSERVER_EXPORT virtual ChangeType getChangeType() const { return INSTANCE; }
        EQSERVER_EXPORT virtual void getInstanceData( net::DataOStream& os );
        EQSERVER_EXPORT virtual void applyInstanceData( net::DataIStream& is );

    private:
        Compound* _compound;
        friend class Compound;

        std::string _name;

        eq::Frame::Data _data;
        eq::Viewport    _vp;
        uint32_t        _buffers;
        eq::Frame::Type _type;

        eq::Frame::Data _inherit;

        std::deque<FrameData*> _datas;
        
        FrameData* _masterFrameData;
        FrameData* _frameData[eq::EYE_ALL];

        FrameVector _inputFrames[eq::EYE_ALL];
    };

    std::ostream& operator << ( std::ostream& os, const Frame* frame );
}
}
#endif // EQSERVER_FRAME_H