fabric/channel.h

/* Copyright (c) 2010-2016, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Cedric Stalder <cedric.stalder@gmail.com>
 *                          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;               

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

    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;

    void setOverdraw(const Vector4i& overdraw); 

    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; }
    const RenderContext& getContext() const { return *_context; }

    // 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
    const 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 explicit 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 overrideContext(const RenderContext& context)
    {
        _overrideContext = context;
        _context = &_overrideContext;
    }

    void resetContext() { _context = &_data.nativeContext; }
    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,
        DIRTY_VIEWPORT = Object::DIRTY_CUSTOM << 1,
        DIRTY_PIXELVIEWPORT = Object::DIRTY_CUSTOM << 2,
        DIRTY_MEMBER = Object::DIRTY_CUSTOM << 3,
        DIRTY_FRUSTUM = Object::DIRTY_CUSTOM << 4,
        DIRTY_CAPABILITIES = Object::DIRTY_CUSTOM << 5,
        DIRTY_CHANNEL_BITS = DIRTY_ATTRIBUTES | DIRTY_VIEWPORT |
                             DIRTY_PIXELVIEWPORT | 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 _overrideContext;

    RenderContext* _context;

    int32_t _iAttributes[IATTR_ALL];

    std::string _sAttributes[SATTR_ALL];
};

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

#endif // EQFABRIC_CHANNEL_H