include/eq/client/channel.h

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

#include <eq/client/event.h>          // member
#include <eq/client/types.h>
#include <eq/client/gl.h>             // GLEWContext

#include <eq/fabric/channel.h>        // base class
#include <eq/fabric/drawableConfig.h> // member

namespace eq
{
    struct ChannelFrameTransmitImagePacket;
    struct ChannelFrameSetReadyPacket;

    class Channel : public fabric::Channel< Window, Channel >
    {
    public:
        EQ_API Channel( Window* parent );

        EQ_API virtual ~Channel();

        EQ_API co::CommandQueue* getPipeThreadQueue(); 
        EQ_API co::CommandQueue* getCommandThreadQueue(); 
        EQ_API uint32_t getCurrentFrame() const; 

        bool isStopped() const { return (_state == STATE_STOPPED); }

        EQ_API Pipe* getPipe();

        EQ_API const Pipe* getPipe() const;

        EQ_API Node* getNode();

        EQ_API const Node* getNode() const;

        EQ_API Config* getConfig();

        EQ_API const Config* getConfig() const;

        EQ_API ServerPtr getServer();

        EQ_API const GLEWContext* glewGetContext() const;

        EQ_API ObjectManager* getObjectManager();

        EQ_API const DrawableConfig& getDrawableConfig() const;

        EQ_API View* getNativeView();

        EQ_API const View* getNativeView() const;

        EQ_API util::FrameBufferObject* getFrameBufferObject();

        EQ_API void addStatistic( Event& event, const uint32_t index );

        EQ_API virtual Vector2f getJitter() const;

        const Frames& getInputFrames() { return _inputFrames; }

        const Frames& getOutputFrames() { return _outputFrames; }

        EQ_API View* getView();

        EQ_API const View* getView() const;

        EQ_API Frustumf getScreenFrustum() const;

        EQ_API virtual void applyBuffer();

        EQ_API virtual void applyColorMask() const;

        EQ_API virtual void applyViewport() const;

        EQ_API virtual void applyFrustum() const;

        EQ_API virtual void applyPerspective() const;

        EQ_API virtual void applyOrtho() const;

        EQ_API void applyScreenFrustum() const;

        EQ_API virtual void applyHeadTransform() const;

        EQ_API virtual void applyPerspectiveTransform() const;

        EQ_API virtual void applyOrthoTransform() const;

        EQ_API virtual void applyFrameBufferObject();

        EQ_API void bindFrameBuffer();        

        EQ_API virtual bool processEvent( const Event& event );

        EQ_API virtual void drawStatistics();

        EQ_API virtual void outlineViewport();

        void changeLatency( const uint32_t latency );

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

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

        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 void setupAssemblyState();

        EQ_API virtual void resetAssemblyState();

        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 frameClear( const uint128_t& frameID );

        EQ_API virtual void frameDraw( const uint128_t& frameID );

        EQ_API virtual void frameAssemble( const uint128_t& frameID );

         EQ_API virtual void frameReadback( const uint128_t& frameID );

        EQ_API virtual void frameViewStart( const uint128_t& frameID );

        EQ_API virtual void frameViewFinish( const uint128_t& frameID );

        virtual void frameTilesStart( const uint128_t& frameID ) {}

        virtual void frameTilesFinish( const uint128_t& frameID ) {}

        EQ_API virtual void notifyViewportChanged();

        virtual void notifyStopFrame( const uint32_t lastFrameNumber ) {}

    private:
        //-------------------- Members --------------------
        friend class fabric::Window< Pipe, Window, Channel >;

        DrawableConfig _drawableConfig;

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

        State _state;

        Frames _outputFrames;

        Frames _inputFrames;

        util::FrameBufferObject* _fbo; 

        Vector3ub _color;

        typedef std::vector< Statistic > Statistics;
        struct FrameStatistics
        {
            Statistics data; 

            co::base::a_int32_t used;
        };

        typedef std::vector< FrameStatistics > StatisticsRB;

        co::base::Lockable< StatisticsRB, co::base::SpinLock > _statistics;
        /* Index of current vector StatisticsRB */ 
        uint32_t _statisticsIndex;
        friend class ChannelStatistics;

        Vector2i _initialSize;

        struct Private;
        Private* _private; // placeholder for binary-compatible changes

        //-------------------- Methods --------------------
        void _setRenderContext( RenderContext& context );

        bool _configInitFBO();

        void _initDrawableConfig();

        void _unrefFrame( const uint32_t frameNumber, const uint32_t index );

        void _transmitImage( Image* image, 
                             const ChannelFrameTransmitImagePacket* packet );
        
        void _sendFrameDataReady( const ChannelFrameTransmitImagePacket* packet );

        void _setOutputFrames( uint32_t nFrames, co::ObjectVersion* frames );
        void _frameReadback( const uint128_t& frameID, uint32_t nFrames,
                             co::ObjectVersion* frames );

        co::QueueSlave* _getQueue( const co::ObjectVersion& queueVersion );

        void _transmitImages( const RenderContext& context, Frame* frame,
                              const size_t startPos );

        void _resetOutputFrames( const RenderContext& context );

        /* The command handler functions. */
        bool _cmdConfigInit( co::Command& command );
        bool _cmdConfigExit( co::Command& command );
        bool _cmdFrameStart( co::Command& command );
        bool _cmdFrameFinish( co::Command& command );
        bool _cmdFrameClear( co::Command& command );
        bool _cmdFrameDraw( co::Command& command );
        bool _cmdFrameDrawFinish( co::Command& command );
        bool _cmdFrameAssemble( co::Command& command );
        bool _cmdFrameReadback( co::Command& command );
        bool _cmdFrameTransmitImage( co::Command& command );
        bool _cmdFrameSetReady( co::Command& command );
        bool _cmdFrameViewStart( co::Command& command );
        bool _cmdFrameViewFinish( co::Command& command );
        bool _cmdStopFrame( co::Command& command );
        bool _cmdFrameTiles( co::Command& command );

        EQ_TS_VAR( _pipeThread );
    };
}

#endif // EQ_CHANNEL_H