lib/client/window.h

/* Copyright (c) 2005-2009, 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 EQ_WINDOW_H
#define EQ_WINDOW_H

#include <eq/client/objectManager.h> // member
#include <eq/client/pixelViewport.h> // member
#include <eq/client/renderContext.h> // member
#include <eq/client/types.h>
#include <eq/client/visitorResult.h> // enum

#include <eq/util/bitmapFont.h>      // member
#include <eq/net/object.h>           // base class

namespace eq
{
    class OSWindow;
    class WindowVisitor;
    struct Event;

    class Window : public net::Object
    {
    public:
        struct DrawableConfig
        {
            int32_t stencilBits;
            int32_t alphaBits;
            float   glVersion;
            bool    stereo;
            bool    doublebuffered;
        };
        
        class ObjectManager : public eq::ObjectManager< const void* >
        {
        public:
            ObjectManager( Window* window ) 
                    : eq::ObjectManager<const void *>(window->glewGetContext( ))
                    , _smallFont( window )
                    , _mediumFont( window )
                {}
            ObjectManager( Window* window, ObjectManager* shared ) 
                    : eq::ObjectManager<const void *>(window->glewGetContext(),
                                                      shared )
                    , _smallFont( window )
                    , _mediumFont( window )
                {}
            virtual ~ObjectManager(){}
            
            const util::BitmapFont& getDefaultFont() const { return _smallFont;}

            const util::BitmapFont& getMediumFont() const { return _mediumFont;}

        private:
            util::BitmapFont _smallFont;
            util::BitmapFont _mediumFont;

            friend class Window;
        };

        EQ_EXPORT Window( Pipe* parent );

        EQ_EXPORT virtual ~Window();

        EQ_EXPORT net::CommandQueue* getPipeThreadQueue();

        const Pipe* getPipe() const { return _pipe; }
        Pipe*       getPipe()       { return _pipe; }

        EQ_EXPORT const Node* getNode() const; 
        EQ_EXPORT Node*       getNode();

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

        EQ_EXPORT ClientPtr getClient();
        EQ_EXPORT ServerPtr getServer();

        const ChannelVector& getChannels() { return _channels; }

        const std::string& getName() const { return _name; }

        bool isRunning() const { return (_state == STATE_RUNNING); }

        uint32_t getTasks() const { return _tasks; }

        EQ_EXPORT VisitorResult accept( WindowVisitor& visitor );

        void setSharedContextWindow( Window* sharedContextWindow )
            { _sharedContextWindow = sharedContextWindow; }

        const Window* getSharedContextWindow() const 
            { return _sharedContextWindow; }

        Window* getSharedContextWindow() 
            { return _sharedContextWindow; }


        EQ_EXPORT GLEWContext* glewGetContext();

        EQ_EXPORT WGLEWContext* wglewGetContext();

        const DrawableConfig& getDrawableConfig() const 
            { return _drawableConfig; }

        ObjectManager* getObjectManager() { return _objectManager; }
        const ObjectManager* getObjectManager() const { return _objectManager; }

        EQ_EXPORT void setPixelViewport( const PixelViewport& pvp );
        
        EQ_EXPORT const PixelViewport& getPixelViewport() const { return _pvp; }

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

        void addRenderContext( const RenderContext& context );

        EQ_EXPORT bool getRenderContext( const int32_t x, const int32_t y,
                                         RenderContext& context ) const;

        // Note: also update string array initialization in window.cpp
        enum IAttribute
        {
            IATTR_HINT_STEREO,           
            IATTR_HINT_DOUBLEBUFFER,     
            IATTR_HINT_FULLSCREEN,       
            IATTR_HINT_DECORATION,       
            IATTR_HINT_SWAPSYNC,         
            IATTR_HINT_DRAWABLE,         
            IATTR_HINT_STATISTICS,       
            IATTR_HINT_SCREENSAVER,      
            IATTR_PLANES_COLOR,          
            IATTR_PLANES_ALPHA,          
            IATTR_PLANES_DEPTH,          
            IATTR_PLANES_STENCIL,        
            IATTR_PLANES_ACCUM,          
            IATTR_PLANES_ACCUM_ALPHA,    
            IATTR_PLANES_SAMPLES,        
            IATTR_FILL1,
            IATTR_FILL2,
            IATTR_ALL
        };

        EQ_EXPORT void setIAttribute( const IAttribute attr,
                                      const int32_t value );
        EQ_EXPORT int32_t  getIAttribute( const IAttribute attr ) const;
        EQ_EXPORT static const std::string& getIAttributeString(
                                                const IAttribute attr );

        virtual void flush() const { glFlush(); } 
        virtual void finish() const { glFinish(); }

        EQ_EXPORT void setOSWindow( OSWindow* window );

        const OSWindow* getOSWindow() const { return _osWindow; }
        OSWindow*       getOSWindow()       { return _osWindow; }


        EQ_EXPORT void setErrorMessage( const std::string& message );


        EQ_EXPORT virtual bool processEvent( const Event& event );


        double getFPS() const { return _avgFPS; }

        /* Draw FPS count */
        EQ_EXPORT virtual void drawFPS() const;

        int getColorType();
        
        EQ_EXPORT bool isFBOWindow();

    protected:
        friend class Pipe;

        EQ_EXPORT virtual void attachToSession( const uint32_t id, 
                                                const uint32_t instanceID, 
                                                net::Session* session );

        void startFrame( const uint32_t frameNumber ) { /* currently nop */ }

        void releaseFrame( const uint32_t frameNumber ) { /* currently nop */ }

        void releaseFrameLocal( const uint32_t frameNumber ) { /* nop */ }


        EQ_EXPORT virtual bool configInit( const uint32_t initID );

        EQ_EXPORT virtual bool configInitOSWindow( const uint32_t initID );

        EQ_EXPORT virtual bool configInitGL( const uint32_t initID );

        EQ_EXPORT virtual bool configExit();

        EQ_EXPORT virtual bool configExitOSWindow();

        virtual bool configExitGL() { return true; }

        virtual void frameStart( const uint32_t frameID, 
                                 const uint32_t frameNumber ) 
            { startFrame( frameNumber ); }

        EQ_EXPORT virtual void frameFinish( const uint32_t frameID, 
                                            const uint32_t frameNumber );

        virtual void frameDrawFinish( const uint32_t frameID, 
                                      const uint32_t frameNumber )
            { releaseFrameLocal( frameNumber ); }

        EQ_EXPORT virtual void makeCurrent( const bool cache = true ) const;

        EQ_EXPORT virtual void bindFrameBuffer() const;

        EQ_EXPORT virtual void swapBuffers();

    private:
        Pipe* const   _pipe;

        std::string    _name;

        Window* _sharedContextWindow;

        std::string    _error;

        OSWindow* _osWindow;

        int32_t _iAttributes[IATTR_ALL];
        static std::string _iAttributeStrings[IATTR_ALL];

        uint32_t _tasks;

        ChannelVector     _channels;

        eq::PixelViewport _pvp;

        eq::Viewport      _vp;

        Window::DrawableConfig _drawableConfig;

        enum State
        {
            STATE_STOPPED,
            STATE_INITIALIZING,
            STATE_RUNNING
        };
        State _state;

        ObjectManager* _objectManager;

        double _lastTime;

        double _avgFPS;

        std::vector< RenderContext > _renderContexts[2];
        enum 
        {
            FRONT = 0,
            BACK  = 1
        };

        int64_t _lastSwapTime;

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

        friend class Channel;
        void _addChannel( Channel* channel );
        void _removeChannel( Channel* channel );
        Channel* _findChannel( const uint32_t id );

        bool _setPixelViewport( const PixelViewport& pvp );
        void _setViewport( const Viewport& vp );

        void _setupObjectManager();
        void _releaseObjectManager();

        void _queryDrawableConfig();

        void _updateFPS();

        void _enterBarrier( net::ObjectVersion barrier );

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

        /* The command functions. */
        net::CommandResult _cmdCreateChannel( net::Command& command );
        net::CommandResult _cmdDestroyChannel(net::Command& command );
        net::CommandResult _cmdConfigInit( net::Command& command );
        net::CommandResult _cmdConfigExit( net::Command& command );
        net::CommandResult _cmdFrameStart( net::Command& command );
        net::CommandResult _cmdFrameFinish( net::Command& command );
        net::CommandResult _cmdThrottleFramerate( net::Command& command );
        net::CommandResult _cmdFinish( net::Command& command );
        net::CommandResult _cmdBarrier( net::Command& command );
        net::CommandResult _cmdNVBarrier( net::Command& command );
        net::CommandResult _cmdSwap( net::Command& command );
        net::CommandResult _cmdFrameDrawFinish( net::Command& command );

        CHECK_THREAD_DECLARE( _pipeThread );
    };

    std::ostream& operator << ( std::ostream& , const Window::DrawableConfig& );
}

#endif // EQ_WINDOW_H