channel.h

/* Copyright (c) 2005-2015, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Cedric Stalder <cedric.stalder@gmail.com>
 *                          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/api.h>
#include <eq/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 explicit Channel( Window* parent );

    EQ_API virtual ~Channel();

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

    bool waitFrameFinished( uint32_t frame, uint32_t timeout ) 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 util::ObjectManager& getObjectManager();

    EQ_API const DrawableConfig& getDrawableConfig() const;

    EQ_API View* getNativeView();

    EQ_API const View* getNativeView() const;

    EQ_API const Vector3ub& getUniqueColor() const;

    EQ_API void addStatistic( Event& event );

    EQ_API virtual Vector2f getJitter() const;

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

    EQ_API void resetOverlayState();

    EQ_API void bindFrameBuffer();

    EQ_API void bindDrawFrameBuffer();

    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 EventOCommand sendError( const uint32_t error );

    EQ_API virtual bool processEvent( const Event& event );

    EQ_API virtual void drawStatistics();

    EQ_API virtual void outlineViewport();

    void changeLatency( const uint32_t latency );

    EQ_API void addResultImageListener( ResultImageListener* listener );

    EQ_API void removeResultImageListener( ResultImageListener* listener );

    EQ_API virtual std::string getDumpImageFileName() const;

protected:
    EQ_API void attach( const uint128_t& 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,
                                       const Frames& frames );

    EQ_API virtual void frameReadback( const uint128_t& frameID,
                                       const Frames& frames );

    EQ_API virtual void frameViewStart( const uint128_t& frameID );

    EQ_API virtual void frameViewFinish( const uint128_t& frameID );

    EQ_API virtual void frameDrawOverlay( 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, WindowSettings >;

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

    void _initDrawableConfig();

    void _frameTiles( RenderContext& context, const bool isLocal,
                      const uint128_t& 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 co::NodeID& 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 co::NodeIDs& netNodes );

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

    void _asyncTransmit( FrameDataPtr frame, const uint32_t frameNumber,
                         const uint64_t image,
                         const std::vector< uint128_t >& nodes,
                         const co::NodeIDs& netNodes,
                         const uint32_t taskID );

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

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

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

    Frames _getFrames( const co::ObjectVersions& frameIDs,
                       const bool isOutput );

    void _createTransferWindow();
    void _deleteTransferWindow();

    /* 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 _cmdDeleteTransferWindow( co::ICommand& command );

    LB_TS_VAR( _pipeThread );
};
}

#endif // EQ_CHANNEL_H