node.h

/* Copyright (c) 2005-2017, Stefan Eilemann <eile@equalizergraphics.com>
 *                          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/api.h>
#include <eq/fabric/eventType.h> // EventType enum
#include <eq/fabric/node.h>      // base class
#include <eq/types.h>
#include <eq/visitorResult.h> // enum

#include <co/types.h>

namespace eq
{
namespace detail
{
class Node;
}

class Node : public fabric::Node<Config, Node, Pipe, NodeVisitor>
{
public:
    EQ_API explicit 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(AxisEvent& event);
    EQ_API virtual bool processEvent(ButtonEvent& event);
    EQ_API virtual bool processEvent(Statistic& event);

    EQ_API void setDirty(const uint64_t bits) override;

    EQ_API void dirtyClientExit();

protected:
    EQ_API
    void attach(const uint128_t& id, const uint32_t instanceID) override;

    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