include/eq/client/channel.h

/* Copyright (c) 2005-2012, 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_CHANNEL_H
#define EQ_CHANNEL_H

#include <eq/client/event.h>          // member
#include <eq/client/types.h>
#include <eq/client/gl.h>             // GLEWContext

#include <eq/fabric/channel.h>        // base class
#include <eq/fabric/drawableConfig.h> // member

namespace eq
{
namespace detail { class Channel; struct RBStat; }

    struct ChannelFinishReadbackPacket;
    struct ChannelFrameSetReadyNodePacket;
    struct ChannelFrameSetReadyPacket;
    struct ChannelFrameTilesPacket;
    struct ChannelFrameTransmitImagePacket;

    class Channel : public fabric::Channel< Window, Channel >
    {
    public:
        EQ_API Channel( Window* parent );

        EQ_API virtual ~Channel();

        EQ_API co::CommandQueue* getPipeThreadQueue(); 
        EQ_API co::CommandQueue* getCommandThreadQueue(); 
        EQ_API uint32_t getCurrentFrame() const; 
        void waitFrameFinished( const uint32_t frame ) const; 

        EQ_API bool isStopped() const;

        EQ_API Pipe* getPipe();

        EQ_API const Pipe* getPipe() const;

        EQ_API Node* getNode();

        EQ_API const Node* getNode() const;

        EQ_API Config* getConfig();

        EQ_API const Config* getConfig() const;

        EQ_API ServerPtr getServer();

        EQ_API const GLEWContext* glewGetContext() const;

        EQ_API ObjectManager* getObjectManager();

        EQ_API const DrawableConfig& getDrawableConfig() const;

        EQ_API View* getNativeView();

        EQ_API const View* getNativeView() const;

        EQ_API util::FrameBufferObject* getFrameBufferObject();

        EQ_API const Vector3ub& getUniqueColor() const;

        EQ_API void addStatistic( Event& event );

        EQ_API virtual Vector2f getJitter() const;

        EQ_API const Frames& getInputFrames();

        EQ_API const Frames& getOutputFrames();

        EQ_API View* getView();

        EQ_API const View* getView() const;

        EQ_API Frustumf getScreenFrustum() const;

        EQ_API virtual void applyBuffer();

        EQ_API virtual void applyColorMask() const;

        EQ_API virtual void applyViewport() const;

        EQ_API virtual void applyFrustum() const;

        EQ_API virtual void applyPerspective() const;

        EQ_API virtual void applyOrtho() const;

        EQ_API void applyScreenFrustum() const;

        EQ_API virtual void applyHeadTransform() const;

        EQ_API virtual void applyPerspectiveTransform() const;

        EQ_API virtual void applyOrthoTransform() const;

        EQ_API virtual void applyFrameBufferObject();

        EQ_API void bindFrameBuffer();        

        EQ_API virtual void resetRegions();

        EQ_API virtual void declareRegion( const eq::PixelViewport& region );

        EQ_API void declareRegion( const eq::Viewport& vp );

        EQ_API PixelViewport getRegion() const;

        EQ_API const PixelViewports& getRegions() const;


        EQ_API virtual bool processEvent( const Event& event );

        EQ_API virtual void drawStatistics();

        EQ_API virtual void outlineViewport();

        void changeLatency( const uint32_t latency );

    protected:
        EQ_API void attach( const UUID& id, const uint32_t instanceID );

        EQ_API void startFrame( const uint32_t frameNumber );

        EQ_API void releaseFrame( const uint32_t frameNumber );

        EQ_API void releaseFrameLocal( const uint32_t frameNumber );

        EQ_API virtual void setupAssemblyState();

        EQ_API virtual void resetAssemblyState();

        EQ_API virtual bool configInit( const uint128_t& initID );

        EQ_API virtual bool configExit();

        EQ_API virtual void frameStart( const uint128_t& frameID,
                                        const uint32_t frameNumber );

        EQ_API virtual void frameFinish( const uint128_t& frameID, 
                                         const uint32_t frameNumber );

        EQ_API virtual void frameDrawFinish( const uint128_t& frameID, 
                                             const uint32_t frameNumber );

        EQ_API virtual void frameClear( const uint128_t& frameID );

        EQ_API virtual void frameDraw( const uint128_t& frameID );

        EQ_API virtual void frameAssemble( const uint128_t& frameID );

         EQ_API virtual void frameReadback( const uint128_t& frameID );

        EQ_API virtual void frameViewStart( const uint128_t& frameID );

        EQ_API virtual void frameViewFinish( const uint128_t& frameID );

        virtual void frameTilesStart( const uint128_t& frameID ) {}

        virtual void frameTilesFinish( const uint128_t& frameID ) {}

        EQ_API virtual void notifyViewportChanged();

        virtual void notifyStopFrame( const uint32_t lastFrameNumber ) {}

    private:
        detail::Channel* const _impl;
        friend class fabric::Window< Pipe, Window, Channel >;

        //-------------------- Methods --------------------
        void _setRenderContext( RenderContext& context );

        bool _configInitFBO();

        void _initDrawableConfig();

        void _frameTiles( const ChannelFrameTilesPacket* packet );

        void _refFrame( const uint32_t frameNumber );

        void _unrefFrame( const uint32_t frameNumber );

        void _transmitImage( const ChannelFrameTransmitImagePacket* packet );
        
        void _frameReadback( const uint128_t& frameID, uint32_t nFrames,
                             co::ObjectVersion* frames );
        void _finishReadback( const ChannelFinishReadbackPacket* packet );

        bool _asyncFinishReadback( const std::vector< size_t >& imagePos );

        void _asyncTransmit( FrameData* frame, const uint32_t frameNumber,
                             const size_t image,
                             const std::vector<uint128_t>& nodes,
                             const std::vector< uint128_t >& netNodes,
                             const uint32_t taskID );

        void _setReady( const bool async, detail::RBStat* stat );
        void _asyncSetReady( const FrameData* frame, detail::RBStat* stat,
                             const std::vector< uint128_t >& nodes,
                             const std::vector< uint128_t >& netNodes );

        void _setReady( FrameData* frame, detail::RBStat* stat,
                        const std::vector< uint128_t >& nodes,
                        const std::vector< uint128_t >& netNodes );

        co::QueueSlave* _getQueue( const co::ObjectVersion& queueVersion );

        void _setOutputFrames( const uint32_t nFrames,
                               const co::ObjectVersion* frames );
        void _resetOutputFrames();

        void _deleteTransferContext();

        /* The command handler functions. */
        bool _cmdConfigInit( co::Command& command );
        bool _cmdConfigExit( co::Command& command );
        bool _cmdFrameStart( co::Command& command );
        bool _cmdFrameFinish( co::Command& command );
        bool _cmdFrameClear( co::Command& command );
        bool _cmdFrameDraw( co::Command& command );
        bool _cmdFrameDrawFinish( co::Command& command );
        bool _cmdFrameAssemble( co::Command& command );
        bool _cmdFrameReadback( co::Command& command );
        bool _cmdFinishReadback( co::Command& command );
        bool _cmdFrameSetReady( co::Command& command );
        bool _cmdFrameTransmitImage( co::Command& command );
        bool _cmdFrameSetReadyNode( co::Command& command );
        bool _cmdFrameViewStart( co::Command& command );
        bool _cmdFrameViewFinish( co::Command& command );
        bool _cmdStopFrame( co::Command& command );
        bool _cmdFrameTiles( co::Command& command );
        bool _cmdDeleteTransferContext( co::Command& command );

        LB_TS_VAR( _pipeThread );
    };
}

#endif // EQ_CHANNEL_H