config.h

/* Copyright (c) 2005-2008, Stefan Eilemann <eile@equalizergraphics.com> 
   All rights reserved. */

#ifndef EQ_CONFIG_H
#define EQ_CONFIG_H

#include <eq/client/server.h>       // called in inline method
#include <eq/client/commandQueue.h> // member
#include <eq/client/configVisitor.h>// nested enum
#include <eq/client/matrix4.h>      // member
#include <eq/client/types.h>        // typedefs
#include <eq/client/view.h>         // member

#include <eq/net/session.h>         // base class
#include <eq/base/monitor.h>        // member

namespace eq
{
    class Node;
    class SceneObject;
    struct ConfigEvent;

    class EQ_EXPORT Config : public net::Session
    {
    public:
        Config( base::RefPtr< Server > parent );

        //*{
        ClientPtr getClient();
        ServerPtr getServer();
        const NodeVector& getNodes() const { return _nodes; }
        CommandQueue* getNodeThreadQueue()
            { return getClient()->getNodeThreadQueue(); }
        uint32_t getCurrentFrame()  const { return _currentFrame; }
        uint32_t getFinishedFrame() const { return _finishedFrame.get(); }

        ConfigVisitor::Result accept( ConfigVisitor* visitor );

        void getStatistics( std::vector< FrameStatistics >& statistics );

        bool isRunning() const { return _running; }

        void stopRunning() { _running = false; }

        int64_t getTime() const { return _clock.getTime64(); }

        const ViewVector& getViews() { return _views; }
        //*}

        virtual bool init( const uint32_t initID )
            { return _startInit( initID ) && _finishInit(); }

        virtual bool exit();

        //*{
        virtual uint32_t startFrame( const uint32_t frameID );

        virtual uint32_t finishFrame();

        virtual uint32_t finishAllFrames();

        void releaseFrameLocal( const uint32_t frameNumber )
            { _unlockedFrame = frameNumber; }

        void waitFrameFinished( const uint32_t frameNumber ) const
            { _finishedFrame.waitGE( frameNumber ); }
        //*}

        //*{
        void sendEvent( ConfigEvent& event );

        const ConfigEvent* nextEvent();

        const ConfigEvent* tryNextEvent();

        bool checkEvent() const { return !_eventQueue.empty(); }

        virtual void handleEvents();

        virtual bool handleEvent( const ConfigEvent* event );

        virtual void handleViewResize( const uint32_t viewID, 
                                       const vmml::Vector2i& newSize );
        //*}

        void setHeadMatrix( const vmml::Matrix4f& matrix );

        const vmml::Matrix4f& getHeadMatrix() const { return _headMatrix; }


        //*{
        const std::string& getErrorMessage() const { return _error; }
        //*}

#ifdef EQ_TRANSMISSION_API

        //*{
        void broadcastData( const void* data, uint64_t size );
        //*}
#endif

        void freezeLoadBalancing( const bool onOff );

        void setWindowSystem( const WindowSystem windowSystem );

    protected:
        virtual ~Config();

        struct BaseView
        {
            View*          view;
            View           base;
            vmml::Vector2i size;
        };

        net::IDHash< BaseView > _baseViews;

    private:
        net::NodeID _appNodeID;
        friend class Server;

        net::NodePtr _appNode;

#ifdef EQ_TRANSMISSION_API

        std::vector<net::NodeID> _clientNodeIDs;

        net::NodeVector _clientNodes;
#endif

        NodeVector _nodes;

        Matrix4f _headMatrix;

        std::string _error;

        CommandQueue _eventQueue;
        
        net::Command* _lastEvent;

        std::deque< FrameStatistics > _statistics;
        base::SpinLock                _statisticsMutex;

        uint32_t _latency;
        uint32_t _currentFrame;
        uint32_t _unlockedFrame;
        base::Monitor< uint32_t > _finishedFrame;

        base::Clock _clock;

        ViewVector _views;

        class Distributor : public net::Object
        {
        public:
            Distributor( Config* config ) : _config( config ) {}
            virtual ~Distributor() {}

        protected:
            virtual void getInstanceData( net::DataOStream& os ) { EQDONTCALL; }
            virtual void applyInstanceData( net::DataIStream& is );

        private:
            Config* _config;
        };

        friend class Distributor;

        bool _running;

        friend class Node;
        void _addNode( Node* node );
        void _removeNode( Node* node );
        Node* _findNode( const uint32_t id );

        virtual bool _startInit( const uint32_t initID );

        virtual bool _finishInit();

        void _updateStatistics( const uint32_t finishedFrame );

#ifdef EQ_TRANSMISSION_API

        bool _connectClientNodes();
#endif

        void _initAppNode( const uint32_t distributorID );

        void _exitAppNode();

        net::CommandResult _cmdStartClock( net::Command& command );
        net::CommandResult _cmdCreateNode( net::Command& command );
        net::CommandResult _cmdDestroyNode( net::Command& command );
        net::CommandResult _cmdStartInitReply( net::Command& command );
        net::CommandResult _cmdFinishInitReply( net::Command& command );
        net::CommandResult _cmdExitReply( net::Command& command );
        net::CommandResult _cmdStartFrameReply( net::Command& command );
        net::CommandResult _cmdFrameFinish( net::Command& command );
#ifdef EQ_TRANSMISSION_API
        net::CommandResult _cmdData( net::Command& command );
#endif
    };
}

#endif // EQ_CONFIG_H