include/eq/client/channel.h

/* Copyright (c) 2005-2013, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2010, Cedric Stalder <cedric.stalder@gmail.com>
 *                    2011, Daniel Nachbaur <danielnachbaur@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/api.h>
#include <eq/client/types.h>

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

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

    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();

        EQ_API 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( RenderContext& context, const bool isLocal,
                          const UUID& queueID, const uint32_t tasks,
                          const co::ObjectVersions& frames );

        void _refFrame( const uint32_t frameNumber );

        void _unrefFrame( const uint32_t frameNumber );

        void _transmitImage( const co::ObjectVersion& frameDataVersion,
                             const uint128_t& nodeID,
                             const uint128_t& netNodeID,
                             const uint64_t imageIndex,
                             const uint32_t frameNumber,
                             const uint32_t taskID );

        void _frameReadback( const uint128_t& frameID,
                             const co::ObjectVersions& frames );
        void _finishReadback( const co::ObjectVersion& frameDataVersion,
                              const uint64_t imageIndex,
                              const uint32_t frameNumber,
                              const uint32_t taskID,
                              const std::vector< uint128_t >& nodes,
                              const std::vector< uint128_t >& netNodes );

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

        void _asyncTransmit( FrameDataPtr frame, const uint32_t frameNumber,
                             const uint64_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 FrameDataPtr frame, detail::RBStat* stat,
                             const std::vector< uint128_t >& nodes,
                             const std::vector< uint128_t >& netNodes );

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

        co::QueueSlave* _getQueue( const UUID& queueID );

        void _setOutputFrames( const co::ObjectVersions& frames );
        void _resetOutputFrames();

        void _deleteTransferContext();

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

        LB_TS_VAR( _pipeThread );
    };
}

#endif // EQ_CHANNEL_H