server/channel.h

/* Copyright (c) 2005-2010, Stefan Eilemann <eile@equalizergraphics.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 EQSERVER_CHANNEL_H
#define EQSERVER_CHANNEL_H

#ifdef EQUALIZERSERVERLIBRARY_EXPORTS
   // We need to instantiate a Monitor< State > when compiling the library,
   // but we don't want to have <pthread.h> for a normal build, hence this hack
#  include <pthread.h>
#endif
#include <eq/base/monitor.h>

#include "base.h"
#include "types.h"
#include "visitorResult.h" // nested enum

#include <eq/client/channel.h>
#include <eq/client/commands.h>
#include <eq/client/pixelViewport.h>
#include <eq/client/viewport.h>
#include <eq/net/object.h>
#include <eq/net/packets.h>

#include <iostream>
#include <vector>

namespace eq
{

namespace server
{
    class ChannelListener;
    class ChannelVisitor;
    struct ChannelPath;

    class Channel : public net::Object
    {
    public:
        enum State
        {
            STATE_STOPPED = 0,  // next: INITIALIZING
            STATE_INITIALIZING, // next: INIT_FAILED or INIT_SUCCESS
            STATE_INIT_SUCCESS, // next: RUNNING
            STATE_INIT_FAILED,  // next: EXITING
            STATE_RUNNING,      // next: EXITING
            STATE_EXITING,      // next: EXIT_FAILED or EXIT_SUCCESS
            STATE_EXIT_SUCCESS, // next: STOPPED
            STATE_EXIT_FAILED,  // next: STOPPED
        };

        EQSERVER_EXPORT Channel();

        Channel( const Channel& from, Window* window );

        virtual ~Channel();

        State getState()    const { return _state.get(); }

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

        EQSERVER_EXPORT Node* getNode();
        EQSERVER_EXPORT const Node* getNode() const;

        Pipe* getPipe();
        const Pipe* getPipe() const;

        Window* getWindow()             { return _window; }
        const Window* getWindow() const { return _window; }

        ChannelPath getPath() const;

        const CompoundVector& getCompounds() const;

        net::CommandQueue* getServerThreadQueue();
        net::CommandQueue* getCommandThreadQueue();

        EQSERVER_EXPORT VisitorResult accept( ChannelVisitor& visitor );
        EQSERVER_EXPORT VisitorResult accept( ChannelVisitor& visitor ) const;

        void activate();

        void deactivate();

        bool isActive() const { return (_active != 0); }

        void addTasks( const uint32_t tasks );

        void setOutput( View* view, Segment* segment );

        void unsetOutput();

        const View* getView() const { return _view; }

        const Layout* getLayout() const;

        const Segment* getSegment() const { return _segment; }

        Segment* getSegment() { return _segment; }

        void setName( const std::string& name ) { _name = name; }
        const std::string& getName() const      { return _name; }

        void setPixelViewport( const eq::PixelViewport& pvp );

        const eq::PixelViewport& getPixelViewport() const { return _pvp; }

        void notifyViewportChanged();

        void setViewport( const eq::Viewport& vp );

        const eq::Viewport& getViewport() const { return _vp; }

        void getNearFar( float* nearPlane, float* farPlane ) const 
            { *nearPlane = _near; *farPlane = _far; }

        void setLastDrawCompound( const Compound* compound )
            { _lastDrawCompound = compound; }
        const Compound* getLastDrawCompound() const { return _lastDrawCompound;}

        void updateRunning( const uint32_t initID );

        bool syncRunning();

        void startConfigExit();

        bool syncConfigExit();

        bool update( const uint32_t frameID, const uint32_t frameNumber );

        void send( net::ObjectPacket& packet );
        void send( net::ObjectPacket& packet, const std::string& string );
        template< typename T >
        void send( net::ObjectPacket &packet, const std::vector<T>& data );

        void addListener( ChannelListener* listener );
        void removeListener( ChannelListener* listener );

        void setIAttribute( const eq::Channel::IAttribute attr,
                            const int32_t value )
            { _iAttributes[attr] = value; }
        int32_t  getIAttribute( const eq::Channel::IAttribute attr ) const
            { return _iAttributes[attr]; }

        const std::string& getErrorMessage() const { return _error; }
        
        /* Set the channel's drawable. */
        void setDrawable( const uint32_t drawable );

        /* Get the channel's drawable. */
        uint32_t getDrawable() const { return _drawable; }

        void setOverdraw( const Vector4i& overdraw )
            { _overdraw = overdraw; }
        const Vector4i& getOverdraw() const { return _overdraw; }
        const Vector2i& getMaxSize()  const { return _maxSize; }

    protected:
        base::RequestHandler _requestHandler;

        virtual void attachToSession( const uint32_t id, 
                                      const uint32_t instanceID, 
                                      net::Session* session );
    private:
        //-------------------- Members --------------------
        uint32_t _active;

        View* _view;

        Segment* _segment;

        std::string _error;

        Window* _window;
        friend class Window;

        std::string _name;

        int32_t _iAttributes[eq::Channel::IATTR_ALL];

        eq::Viewport _vp;

        eq::PixelViewport _pvp;

        uint32_t _drawable;
        
        bool _fixedPVP;

        float        _near;
        float        _far;

        Vector4i    _overdraw;
        Vector2i    _maxSize;

        uint32_t _tasks;

        base::Monitor< State > _state;

        const Compound* _lastDrawCompound;

        typedef std::vector< ChannelListener* > ChannelListeners;
        ChannelListeners _listeners;

        CHECK_THREAD_DECLARE( _serverThread );

        union // placeholder for binary-compatible changes
        {
            char dummy[64];
        };

        //-------------------- Methods --------------------
        void _construct();

        Vector3ub _getUniqueColor() const;

        void _configInit( const uint32_t initID );
        bool _syncConfigInit();
        void _configExit();
        bool _syncConfigExit();

        void _setupRenderContext( const uint32_t frameID,
                                  eq::RenderContext& context );

        void _fireLoadData( const uint32_t frameNumber, 
                            const uint32_t nStatistics,
                            const eq::Statistic* statistics );

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

        /* command handler functions. */
        net::CommandResult _cmdConfigInitReply( net::Command& command );
        net::CommandResult _cmdConfigExitReply( net::Command& command );
        net::CommandResult _cmdSetNearFar( net::Command& command );
        net::CommandResult _cmdFrameFinishReply( net::Command& command );

        // For access to _fixedPVP
        friend std::ostream& operator << ( std::ostream&, const Channel*);
    };

    std::ostream& operator << ( std::ostream& os, const Channel* channel);
}
}
#endif // EQSERVER_CHANNEL_H