fabric/channel.h

/* Copyright (c) 2010-2013, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2010, Cedric Stalder <cedric.stalder@gmail.com>
 *                    2013, Julio Delgado Mangas <julio.delgadomangas@epfl.ch>
 *
 * 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>

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   = LB_BIT_NONE, 
        FBO_COLOR   = LB_BIT1,     
        FBO_DEPTH   = LB_BIT2,     
        FBO_STENCIL = LB_BIT3      
    };

    void init();

    W* getWindow() { return _window; }

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

    bool isDestination() const
        { return _data.nativeContext.view.identifier != 0;}

    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
    };

    enum SAttribute
    {
        SATTR_DUMP_IMAGE,
        SATTR_LAST,
        SATTR_ALL = SATTR_LAST + 5
    };

    EQFABRIC_INL int32_t getIAttribute( const IAttribute attr ) const;

    EQFABRIC_INL std::string getSAttribute( const SAttribute attr ) const;

    EQFABRIC_INL static const std::string& getIAttributeString(
        const IAttribute attr );

    EQFABRIC_INL static const std::string& getSAttributeString(
        const SAttribute 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 ); }

    void setSAttribute( const SAttribute attr, const std::string& value )
        { _sAttributes[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( LB_BIT_ALL_64 ), fixedVP( true ) {}

        RenderContext nativeContext;

        uint64_t capabilities;

        bool fixedVP;
    }
        _data, _backup;

    RenderContext* _context;

    int32_t _iAttributes[IATTR_ALL];

    std::string _sAttributes[SATTR_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