include/eq/client/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/client/api.h>
#include <eq/client/eye.h>            // Eye enum
#include <eq/client/types.h>
#include <eq/client/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 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 UUID& queueID );

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

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

#ifndef EQ_2_0_API

        EQ_API virtual bool supportsWindowSystem( const WindowSystem ws ) const;
#endif

        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 UUID& 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