compound.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_COMPOUND_H
#define EQSERVER_COMPOUND_H

#include "channel.h"               // used in inline method
#include "frustum.h"               // member
#include "frustumData.h"           // member

#include <eq/client/colorMask.h>
#include <eq/client/frame.h>
#include <eq/client/frameData.h>
#include <eq/client/global.h>
#include <eq/client/projection.h>
#include <eq/client/range.h>
#include <eq/client/renderContext.h>
#include <eq/client/subPixel.h>
#include <eq/client/task.h>
#include <eq/client/viewport.h>
#include <eq/client/wall.h>
#include <eq/client/zoom.h>
#include <eq/net/barrier.h>
#include <eq/base/thread.h>
#include <iostream>
#include <vector>

namespace eq
{
namespace server
{
    class CompoundListener;
    class CompoundVisitor;
    class Frame;
    class SwapBarrier;
    
    class Compound
    {
    public:
        EQSERVER_EXPORT Compound();

        Compound( const Compound& from, Config* config, Compound* parent );

        virtual ~Compound();

        enum EyeMask
        {
            EYE_UNDEFINED  = 0,                 
            EYE_CYCLOP_BIT = 1<<eq::EYE_CYCLOP, 
            EYE_LEFT_BIT   = 1<<eq::EYE_LEFT,   
            EYE_RIGHT_BIT  = 1<<eq::EYE_RIGHT   
        };

        enum ColorMask
        {
            COLOR_MASK_NONE      = 0,
            COLOR_MASK_RED       = 0x02,
            COLOR_MASK_GREEN     = 0x04,
            COLOR_MASK_BLUE      = 0x08,
            COLOR_MASK_ALL       = 0xff
        };

        // Note: also update string array initialization in compound.cpp
        enum IAttribute
        {
            IATTR_STEREO_MODE,
            IATTR_STEREO_ANAGLYPH_LEFT_MASK,
            IATTR_STEREO_ANAGLYPH_RIGHT_MASK,
            IATTR_HINT_OFFSET,
            IATTR_FILL1,
            IATTR_FILL2,
            IATTR_ALL
        };

        EQSERVER_EXPORT void addChild( Compound* child );

        EQSERVER_EXPORT bool removeChild( Compound* child );

        bool isLeaf() const { return _children.empty(); }

        bool isDestination() const;
        
        const CompoundVector& getChildren() const { return _children; }

        Compound* getParent() const
            { return _parent; }

        Compound* getRoot()
            { return _parent ? _parent->getRoot() : this; }
        const Compound* getRoot() const
            { return _parent ? _parent->getRoot() : this; }

        Compound* getNext() const;

        Config*       getConfig()       { return getRoot()->_config; }
        const Config* getConfig() const { return getRoot()->_config; }

        Node* getNode();

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

        EQSERVER_EXPORT void setChannel( Channel* channel );

        EQSERVER_EXPORT Channel* getChannel();
        EQSERVER_EXPORT const Channel* getChannel() const;

        Window* getWindow();
        const Window* getWindow() const;

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

        Frustum& getFrustum() { return _frustum; }

        EQSERVER_EXPORT void addEqualizer( Equalizer* equalizer );

        const EqualizerVector& getEqualizers() const
            { return _equalizers; }

        void setTasks( const uint32_t tasks ) { _data.tasks = tasks; }

        void enableTask( const eq::Task task ) { _data.tasks |= task; }

        uint32_t getTasks() const { return _data.tasks; }

        void setBuffers( const uint32_t buffers ) { _data.buffers = buffers; }

        void enableBuffer( const eq::Frame::Buffer buffer )
            { _data.buffers |= buffer; }

        uint32_t getBuffers() const { return _data.buffers; }

        void setViewport( const eq::Viewport& vp ) { _data.vp = vp; }
        const eq::Viewport& getViewport() const    { return _data.vp; }

        void setRange( const eq::Range& range )    { _data.range = range; }
        const eq::Range& getRange() const          { return _data.range; }

        void setPeriod( const uint32_t period )    { _data.period = period; }
        uint32_t getPeriod() const                 { return _data.period; }

        void setPhase( const uint32_t phase )      { _data.phase = phase; }
        uint32_t getPhase() const                  { return _data.phase; }

        void setPixel( const eq::Pixel& pixel )    { _data.pixel = pixel; }
        const eq::Pixel& getPixel() const          { return _data.pixel; }

        void setSubPixel( const eq::SubPixel& subpixel ) { _data.subpixel = subpixel; }
        const eq::SubPixel& getSubPixel() const      { return _data.subpixel; }

        void setZoom( const eq::Zoom& zoom )       { _data.zoom = zoom; }
        const eq::Zoom& getZoom() const            { return _data.zoom; }

        void setMaxFPS( const float fps )          { _data.maxFPS = fps; }
        float getMaxFPS() const                    { return _data.maxFPS; }

        void setUsage( const float usage )         { _usage = usage; }
        float getUsage() const                     { return _usage; }

        void setTaskID( const uint32_t id )        { _taskID = id; }
        uint32_t getTaskID() const                 { return _taskID; }

        void setSwapBarrier( SwapBarrier* barrier );
        
        const SwapBarrier* getSwapBarrier() const { return _swapBarrier; }

        EQSERVER_EXPORT void addInputFrame( Frame* frame );

        const FrameVector& getInputFrames() const {return _inputFrames; }

        EQSERVER_EXPORT void addOutputFrame( Frame* frame );

        const FrameVector& getOutputFrames() const { return _outputFrames; }

        uint32_t getInheritBuffers() const { return _inherit.buffers; }
        const eq::PixelViewport& getInheritPixelViewport() const 
            { return _inherit.pvp; }
        const Vector4i& getInheritOverdraw() const
            { return _inherit.overdraw; }
        const eq::Viewport& getInheritViewport() const { return _inherit.vp; }
        const eq::Range& getInheritRange()   const { return _inherit.range; }
        const eq::Pixel& getInheritPixel()   const { return _inherit.pixel; }
        const eq::SubPixel& getInheritSubPixel() const 
            { return _inherit.subpixel; }
        const eq::Zoom& getInheritZoom()     const { return _inherit.zoom; }
        uint32_t getInheritPeriod()          const { return _inherit.period; }
        uint32_t getInheritPhase()           const { return _inherit.phase; }
        float getInheritMaxFPS()             const { return _inherit.maxFPS; }
        int32_t  getInheritIAttribute( const IAttribute attr ) const
            { return _inherit.iAttributes[attr]; }
        const FrustumData& getInheritFrustumData() const 
            { return _inherit.frustumData; }
        uint32_t getInheritTasks()           const { return _inherit.tasks; }
        uint32_t getInheritEyes()            const { return _inherit.eyes; }
        const Channel* getInheritChannel()   const { return _inherit.channel; }
        
        bool testInheritTask( const eq::Task task ) const
            { return (_inherit.tasks & task); }

        void unsetInheritTask( const eq::Task task )
            { _inherit.tasks &= ~task; }

        bool testInheritEye( const eq::Eye eye ) const
            { return ( _inherit.eyes & (1<<eye) ); }

        EQSERVER_EXPORT void setWall( const eq::Wall& wall );
        
        const eq::Wall& getWall() const { return _frustum.getWall(); }

        EQSERVER_EXPORT void setProjection( const eq::Projection& projection );

        const eq::Projection& getProjection() const 
            { return _frustum.getProjection(); }

        eq::Frustum::Type getFrustumType() const
            { return _frustum.getCurrentType(); }

        const eq::Frustum& getFrustum() const { return _frustum; }

        void updateFrustum();

        uint32_t getEyes() const { return _data.eyes; }

        void setEyes( const uint32_t eyes ) { _data.eyes = eyes; }

        void enableEye( const uint32_t eyes ) { _data.eyes |= eyes; }

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


        void activate();

        void deactivate();

        void setActive( const bool active ) 
            { EQASSERT( _active != active ); _active = active; }

        bool isActive() const;

        void init();

        void exit();

        void update( const uint32_t frameNumber );

        void updateInheritData( const uint32_t frameNumber );

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

        void fireUpdatePre( const uint32_t frameNumber );
        
        void setIAttribute( const IAttribute attr, const int32_t value )
            { _data.iAttributes[attr] = value; }
        int32_t  getIAttribute( const IAttribute attr ) const
            { return _data.iAttributes[attr]; }
        static const std::string&  getIAttributeString( const IAttribute attr )
            { return _iAttributeStrings[attr]; }

        typedef stde::hash_map<std::string, net::Barrier*> BarrierMap;
        typedef stde::hash_map<std::string, Frame*>        FrameMap;

    private:
        //-------------------- Members --------------------
        std::string _name;
        
        friend class Config;
        Config* _config;

        Compound*       _parent;
        CompoundVector  _children;

        bool _active;

        static std::string _iAttributeStrings[IATTR_ALL];

        float _usage;

        uint32_t _taskID;

        struct InheritData
        {
            InheritData();

            Channel*          channel;
            eq::Viewport      vp;
            eq::PixelViewport pvp;
            Vector4i          overdraw;
            eq::Range         range;
            eq::Pixel         pixel;
            eq::SubPixel      subpixel;
            FrustumData       frustumData;
            eq::Zoom          zoom;
            uint32_t          buffers;
            uint32_t          eyes;
            uint32_t          tasks;
            uint32_t          period;
            uint32_t          phase;
            int32_t           iAttributes[IATTR_ALL];
            float             maxFPS;
            bool              active;

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

        InheritData _data;
        InheritData _inherit;

        Frustum _frustum;

        typedef std::vector< CompoundListener* > CompoundListeners;
        CompoundListeners _listeners;

        EqualizerVector _equalizers;

        SwapBarrier* _swapBarrier;

        FrameVector _inputFrames;
        FrameVector _outputFrames;

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

        CHECK_THREAD_DECLARE( _serverThread );

        //-------------------- Methods --------------------
        void _updateOverdraw( Wall& wall );
        void _updateInheritPVP();
        void _updateInheritOverdraw();

        void _setDefaultFrameName( Frame* frame );

        void _fireChildAdded( Compound* child );
        void _fireChildRemove( Compound* child );
    };

    std::ostream& operator << ( std::ostream& os, const Compound* compound );
}
}
#endif // EQSERVER_COMPOUND_H