lib/client/channel.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_CHANNEL_H
#define EQ_CHANNEL_H

#include <eq/client/event.h>         // member
#include <eq/client/renderContext.h> // member
#include <eq/client/types.h>
#include <eq/client/visitorResult.h> // enum
#include <eq/client/windowSystem.h>  // GLEWContext
#include <eq/client/window.h>

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

namespace eq
{
    class ChannelVisitor;
    class Pixel;
    class Range;
    class SceneObject;
    class FrameBufferObject;
    struct RenderContext;

    class Channel : public net::Object
    {
    public:
    
        enum Drawable
        {
            FBO_NONE      = EQ_BIT_NONE,
            FBO_COLOR     = EQ_BIT1,  
            FBO_DEPTH     = EQ_BIT2,  
            FBO_STENCIL   = EQ_BIT3   
        };
        
        EQ_EXPORT Channel( Window* parent );

        EQ_EXPORT virtual ~Channel();

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

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

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

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

        EQ_EXPORT ServerPtr getServer();

        EQ_EXPORT Window::ObjectManager* getObjectManager();

        EQ_EXPORT GLEWContext*       glewGetContext();
        EQ_EXPORT const GLEWContext* glewGetContext() const;
        
        const std::string& getName() const { return _name; }

        uint32_t getTasks() const { return _tasks; }

        EQ_EXPORT VisitorResult accept( ChannelVisitor& visitor );

        EQ_EXPORT void setNearFar( const float nearPlane, const float farPlane);

        const Vector3ub& getUniqueColor() const { return _color; }

        EQ_EXPORT const View* getView();

        EQ_EXPORT const View* getNativeView();

        EQ_EXPORT void addStatistic( Event& event );

        EQ_EXPORT uint32_t getDrawBuffer() const;

        EQ_EXPORT uint32_t getReadBuffer() const;

        EQ_EXPORT const ColorMask& getDrawBufferMask() const;

        EQ_EXPORT const PixelViewport& getPixelViewport() const;

        EQ_EXPORT const Vector2i& getPixelOffset() const;

        EQ_EXPORT const Frustumf& getFrustum() const;

        EQ_EXPORT const Frustumf& getOrtho() const;

        EQ_EXPORT const Viewport& getViewport() const;

        EQ_EXPORT const Range& getRange() const;

        EQ_EXPORT const Pixel& getPixel() const;

        EQ_EXPORT const Zoom& getZoom() const;

        EQ_EXPORT Eye getEye() const;

        EQ_EXPORT const Matrix4f& getHeadTransform() const;

        const FrameVector& getInputFrames() { return _inputFrames; }

        const FrameVector& getOutputFrames() { return _outputFrames; }

        EQ_EXPORT Frustumf getScreenFrustum() const;

        const PixelViewport& getNativePixelViewPort() const
            { return _nativeContext.pvp; }

        EQ_EXPORT const Vector4i& getOverdraw() const;

        EQ_EXPORT void setMaxSize( const Vector2i& size );

        EQ_EXPORT uint32_t getTaskID() const;

        EQ_EXPORT FrameBufferObject* getFrameBufferObject();

        EQ_EXPORT virtual void applyBuffer();

        EQ_EXPORT virtual void applyColorMask() const;

        EQ_EXPORT virtual void applyViewport() const;

        EQ_EXPORT virtual void applyFrustum() const;

        EQ_EXPORT virtual void applyOrtho() const;

        EQ_EXPORT void applyScreenFrustum() const;

        EQ_EXPORT virtual void applyHeadTransform() const;

        EQ_EXPORT virtual void applyFrameBufferObject();
        
        EQ_EXPORT virtual bool processEvent( const Event& event );

        EQ_EXPORT virtual void drawStatistics();

        EQ_EXPORT virtual void outlineViewport();

        // Note: also update string array initialization in channel.cpp
        enum IAttribute
        {
            IATTR_HINT_STATISTICS,
            IATTR_HINT_SENDTOKEN,
            IATTR_FILL1,
            IATTR_FILL2,
            IATTR_ALL
        };
        
        EQ_EXPORT int32_t getIAttribute( const IAttribute attr ) const;
        EQ_EXPORT static const std::string& getIAttributeString(
                                                        const IAttribute attr );
#if 0

        SceneObject* getNextSceneObject();
        SceneObject* checkNextSceneObject();
        //void putSceneObject( SceneObject* object );
        void passSceneObject( SceneObject* object );
        void flushSceneObjects();
#endif

    protected:
        friend class Window;

        EQ_EXPORT 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 configExit();

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

        virtual void frameFinish( const uint32_t frameID, 
                                  const uint32_t frameNumber ) 
            { releaseFrame( frameNumber ); }

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

        EQ_EXPORT virtual void frameClear( const uint32_t frameID );

        EQ_EXPORT virtual void frameDraw( const uint32_t frameID );

        EQ_EXPORT virtual void frameAssemble( const uint32_t frameID );

        EQ_EXPORT virtual void frameReadback( const uint32_t frameID );

        virtual void frameViewStart( const uint32_t frameID ) { /* nop */ }

        virtual void frameViewFinish( const uint32_t frameID ) { /* nop */ }

        EQ_EXPORT virtual void setupAssemblyState();

        EQ_EXPORT virtual void resetAssemblyState();

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

    private:
        //-------------------- Members --------------------
        Window* const _window;

        RenderContext _nativeContext;

        RenderContext* _context;
            
        std::string    _name;
        
        Vector3ub _color;

        std::string     _error;

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

        uint32_t _tasks;

        enum State
        {
            STATE_STOPPED,
            STATE_INITIALIZING,
            STATE_RUNNING
        };

        State _state;

        FrameVector _outputFrames;

        FrameVector _inputFrames;

        bool _fixedPVP;

        FrameBufferObject* _fbo; 
        
        uint32_t _drawable;
        
        std::vector< Statistic > _statistics;

        Vector2i _initialSize;

        Vector2i _maxSize;

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

        bool _configInitFBO();
        
        //-------------------- Methods --------------------
        void _setViewport( const Viewport& vp );

        void _setPixelViewport( const PixelViewport& pvp );

        void _notifyViewportChanged();

        void _setRenderContext( RenderContext& context );

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

        /* The command handler functions. */
        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 _cmdFrameClear( net::Command& command );
        net::CommandResult _cmdFrameDraw( net::Command& command );
        net::CommandResult _cmdFrameDrawFinish( net::Command& command );
        net::CommandResult _cmdFrameAssemble( net::Command& command );
        net::CommandResult _cmdFrameReadback( net::Command& command );
        net::CommandResult _cmdFrameTransmit( net::Command& command );
        net::CommandResult _cmdFrameViewStart( net::Command& command );
        net::CommandResult _cmdFrameViewFinish( net::Command& command );
    };
}

#endif // EQ_CHANNEL_H