pipe.h

/* Copyright (c) 2005-2013, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2010, Cedric Stalder <cedric.stalder@gmail.com>
 *               2010-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_PIPE_H
#define EQ_PIPE_H

#include <eq/api.h>
#include <eq/eye.h>            // Eye enum
#include <eq/types.h>
#include <eq/visitorResult.h>  // enum

#include <eq/fabric/pipe.h>           // base class
#include <co/objectVersion.h>

namespace eq
{
namespace detail
{
class Pipe;
class RenderThread;
class ThreadAffinityVisitor;
}

class Pipe : public fabric::Pipe< Node, Pipe, eq::Window, PipeVisitor >
{
public:
    EQ_API explicit Pipe( Node* parent );

    EQ_API virtual ~Pipe();

    EQ_API co::CommandQueue* getPipeThreadQueue(); 
    co::CommandQueue* getMainThreadQueue(); 
    co::CommandQueue* getCommandThreadQueue(); 
    co::CommandQueue* getTransferThreadQueue(); 

    EQ_API Config* getConfig();
    EQ_API const Config* getConfig() const;

    EQ_API ClientPtr getClient();

    EQ_API ServerPtr getServer();

    bool isRunning() const;

    EQ_API bool isStopped() const;

    EQ_API uint32_t getCurrentFrame() const;
    EQ_API uint32_t getFinishedFrame() const; 

    EQ_API WindowSystem getWindowSystem() const;

    Frame* getFrame( const co::ObjectVersion& frameVersion,
                     const Eye eye, const bool output );

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

    void flushFrames( util::ObjectManager& om );

    const View* getView( const co::ObjectVersion& viewVersion ) const;

    View* getView( const co::ObjectVersion& viewVersion );

    void waitExited() const; 
    void notifyMapped(); 

    EQ_API void waitFrameFinished( const uint32_t frameNumber );

    EQ_API EventOCommand sendError( const uint32_t error );

    EQ_API void waitFrameLocal( const uint32_t frameNumber ) const;

    EQ_API virtual bool processEvent( const Event& event );

    void startThread();

    void exitThread();

    void cancelThread(); 

    bool startTransferThread();

    bool hasTransferThread() const;

    EQ_API void setSystemPipe( SystemPipe* pipe );

    EQ_API SystemPipe* getSystemPipe();

    EQ_API const SystemPipe* getSystemPipe() const;

    EQ_API void setComputeContext( ComputeContext* ctx );

    EQ_API const ComputeContext* getComputeContext() const;

    EQ_API ComputeContext* getComputeContext();

    EQ_API virtual MessagePump* createMessagePump();

    MessagePump* getMessagePump();

    EQ_API virtual void setDirty( const uint64_t bits );

protected:
    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 WindowSystem selectWindowSystem() const;

    EQ_API virtual bool configInit( const uint128_t& initID );

    EQ_API virtual bool configInitSystemPipe( 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 attach( const uint128_t& id, const uint32_t instanceID );

private:
    detail::Pipe* const _impl;
    friend class detail::RenderThread;

    //-------------------- Methods --------------------
    void _setupCommandQueue();
    void _setupAffinity();
    void _exitCommandQueue();

    EQ_API int32_t _getAutoAffinity() const;
    friend class detail::ThreadAffinityVisitor;

    //friend class Window;

    void _stopTransferThread();

    void _releaseViews();

    void _flushViews();

    void _flushQueues();

    /* The command functions. */
    bool _cmdCreateWindow( co::ICommand& command );
    bool _cmdDestroyWindow( co::ICommand& command );
    bool _cmdConfigInit( co::ICommand& command );
    bool _cmdConfigExit( co::ICommand& command );
    bool _cmdFrameStartClock( co::ICommand& command );
    bool _cmdFrameStart( co::ICommand& command );
    bool _cmdFrameFinish( co::ICommand& command );
    bool _cmdFrameDrawFinish( co::ICommand& command );
    bool _cmdExitThread( co::ICommand& command );
    bool _cmdDetachView( co::ICommand& command );
    bool _cmdExitTransferThread( co::ICommand& command );

    LB_TS_VAR( _pipeThread );
};
}

#endif // EQ_PIPE_H