include/eq/fabric/channel.h

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

#include <eq/fabric/object.h>        // base class
#include <eq/fabric/paths.h>
#include <eq/fabric/renderContext.h> // member
#include <eq/fabric/types.h>
#include <eq/fabric/visitorResult.h> // enum

namespace eq
{
namespace fabric
{
    template< class W, class C > class Channel : public Object
    {
    public: 
        typedef LeafVisitor< C > Visitor; 
        typedef W Parent; 

        enum Drawable
        {
            FB_WINDOW   = EQ_BIT_NONE, 
            FBO_COLOR   = EQ_BIT1,     
            FBO_DEPTH   = EQ_BIT2,     
            FBO_STENCIL = EQ_BIT3      
        };
        
        void init();

        W* getWindow() { return _window; }

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

        bool isDestination() const
            { return _data.nativeContext.view.identifier!=co::base::UUID::ZERO;}

        void setViewVersion( const co::ObjectVersion& view );

        const co::ObjectVersion& getViewVersion() const
            { return _data.nativeContext.view; }

        void setPixelViewport( const PixelViewport& pvp );

        EQFABRIC_INL void setViewport( const Viewport& vp );

        virtual void notifyViewportChanged();

        const PixelViewport& getNativePixelViewport() const
            { return _data.nativeContext.pvp; }

        bool hasFixedViewport() const { return _data.fixedVP; }

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

        uint32_t getDrawable() const { return _drawable; }

        EQFABRIC_INL VisitorResult accept( Visitor& visitor );

        EQFABRIC_INL VisitorResult accept( Visitor& visitor ) const;

        EQFABRIC_INL void setCapabilities( const uint64_t bitmask );

        EQFABRIC_INL uint64_t getCapabilities() const;

        EQFABRIC_INL void setMaxSize( const Vector2i& size );

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

        EQFABRIC_INL ChannelPath getPath() const;

        EQFABRIC_INL virtual void backup(); 
        EQFABRIC_INL virtual void restore(); 


        uint32_t getDrawBuffer() const { return _context->buffer; }

        uint32_t getReadBuffer() const { return _context->buffer; }

        const ColorMask& getDrawBufferMask() const
            { return _context->bufferMask; }

        const PixelViewport& getPixelViewport() const { return _context->pvp; }

        virtual bool useOrtho() const { return false; }

        const Frustumf& getFrustum() const
            { return useOrtho() ? getOrtho() : getPerspective(); }

        const Frustumf& getPerspective() const { return _context->frustum; }

        const Frustumf& getOrtho() const { return _context->ortho; }

        const Matrix4f& getHeadTransform() const
        { return useOrtho() ? getOrthoTransform() : getPerspectiveTransform(); }

        const Matrix4f& getPerspectiveTransform() const
            { return _context->headTransform; }

        const Matrix4f& getOrthoTransform() const
            { return _context->orthoTransform; }

        const Viewport& getViewport() const { return _context->vp; }

        const Range& getRange() const { return _context->range; }

        const Pixel& getPixel() const { return _context->pixel; }

        const SubPixel& getSubPixel() const { return _context->subpixel; }

        const Zoom& getZoom() const { return _context->zoom; }

        uint32_t getPeriod() const { return _context->period; }

        uint32_t getPhase() const { return _context->phase; }

        const Vector2i& getPixelOffset() const { return _context->offset; }

        Eye getEye() const { return _context->eye; }

        const Vector4i& getOverdraw() const { return _context->overdraw; }

        uint32_t getTaskID() const { return _context->taskID; }

        // Note: also update string array initialization in channel.cpp
        enum IAttribute
        {
            IATTR_HINT_STATISTICS,
            IATTR_HINT_SENDTOKEN,
            IATTR_LAST,
            IATTR_ALL = IATTR_LAST + 5
        };
        
        EQFABRIC_INL int32_t getIAttribute( const IAttribute attr ) const;
        EQFABRIC_INL static const std::string& getIAttributeString(
                                                        const IAttribute attr );

        virtual bool omitOutput() const { return false; } 
        virtual void output( std::ostream& ) const {} 
        
    protected:
        EQFABRIC_INL Channel( W* parent );

        Channel( const Channel& from );

        EQFABRIC_INL virtual ~Channel();

        EQFABRIC_INL virtual void serialize( co::DataOStream& os,
                                                const uint64_t dirtyBits );
        EQFABRIC_INL virtual void deserialize( co::DataIStream& is, 
                                                  const uint64_t dirtyBits );

        EQFABRIC_INL virtual void setDirty( const uint64_t bits );

        void setDrawable( const uint32_t drawable ); 

        void overrideContext( RenderContext& context ) { _context = &context; }

        void resetContext() { _context = &_data.nativeContext; }

        const RenderContext& getContext() const { return *_context; }

        const RenderContext& getNativeContext() const
            { return _data.nativeContext; }

        void setIAttribute( const IAttribute attr, const int32_t value )
            { _iAttributes[attr] = value; setDirty( DIRTY_ATTRIBUTES ); }

        virtual ChangeType getChangeType() const { return UNBUFFERED; }

        enum DirtyBits
        {
            DIRTY_ATTRIBUTES    = Object::DIRTY_CUSTOM << 0, //   64
            DIRTY_VIEWPORT      = Object::DIRTY_CUSTOM << 1, //  128
            DIRTY_MEMBER        = Object::DIRTY_CUSTOM << 2, //  256
            DIRTY_FRUSTUM       = Object::DIRTY_CUSTOM << 3, //  512
            DIRTY_CAPABILITIES  = Object::DIRTY_CUSTOM << 4, // 1024
            DIRTY_CHANNEL_BITS = 
               DIRTY_ATTRIBUTES | DIRTY_VIEWPORT | DIRTY_MEMBER |
               DIRTY_FRUSTUM | DIRTY_OBJECT_BITS
        };

        virtual uint64_t getRedistributableBits() const
            { return DIRTY_CHANNEL_BITS; }

        virtual void updateCapabilities() {}; 

    private:
        W* const _window;

        struct BackupData
        {
            BackupData() : capabilities( EQ_BIT_ALL_64 ), fixedVP( true ) {}

            RenderContext nativeContext;

            uint64_t capabilities;

            bool fixedVP;
        }
            _data, _backup;

        RenderContext* _context;

        int32_t _iAttributes[IATTR_ALL];

        uint32_t _drawable;

        Vector2i    _maxSize;

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

    template< class W, class C > EQFABRIC_INL
    std::ostream& operator << ( std::ostream&, const Channel< W, C >& );
}
}

#endif // EQFABRIC_CHANNEL_H