include/eq/client/node.h

/* Copyright (c) 2005-2013, 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_NODE_H
#define EQ_NODE_H

#include <eq/client/api.h>
#include <eq/client/types.h>
#include <eq/client/visitorResult.h>  // enum
#include <eq/fabric/node.h>           // base class

#include <co/types.h>

namespace eq
{
namespace detail { class Node; }

class Node : public fabric::Node< Config, Node, Pipe, NodeVisitor >
{
public:
    EQ_API Node( Config* parent );

    EQ_API virtual ~Node();

    EQ_API ClientPtr getClient();

    EQ_API ServerPtr getServer();

    EQ_API co::CommandQueue* getMainThreadQueue(); 
    EQ_API co::CommandQueue* getCommandThreadQueue(); 
    co::CommandQueue* getTransmitterQueue(); 

    uint32_t getCurrentFrame() const;

    co::Barrier* getBarrier( const co::ObjectVersion& barrier );

    FrameDataPtr getFrameData( const co::ObjectVersion& frameDataVersion );

    void releaseFrameData( FrameDataPtr data );

    EQ_API void waitInitialized() const;

    EQ_API bool isRunning() const;

    EQ_API bool isStopped() const;

    EQ_API void waitFrameStarted( const uint32_t frameNumber ) const;

    uint32_t getFinishedFrame() const;

    EQ_API EventOCommand sendError( const uint32_t error );

    EQ_API virtual bool processEvent( const Event& event );

    EQ_API virtual void setDirty( const uint64_t bits );

    EQ_API void dirtyClientExit();

protected:
    EQ_API virtual 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 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 frameTasksFinish( const uint128_t& frameID,
                                          const uint32_t frameNumber );

private:
    detail::Node* const _impl;

    void _setAffinity();

    void _finishFrame( const uint32_t frameNumber ) const;
    void _frameFinish( const uint128_t& frameID,
                       const uint32_t frameNumber );

    void _flushObjects();

    bool _cmdCreatePipe( co::ICommand& command );
    bool _cmdDestroyPipe( co::ICommand& command );
    bool _cmdConfigInit( co::ICommand& command );
    bool _cmdConfigExit( co::ICommand& command );
    bool _cmdFrameStart( co::ICommand& command );
    bool _cmdFrameFinish( co::ICommand& command );
    bool _cmdFrameDrawFinish( co::ICommand& command );
    bool _cmdFrameTasksFinish( co::ICommand& command );
    bool _cmdFrameDataTransmit( co::ICommand& command );
    bool _cmdFrameDataReady( co::ICommand& command );
    bool _cmdSetAffinity( co::ICommand& command );

    LB_TS_VAR( _nodeThread );
};
}

#endif // EQ_NODE_H