fabric/frame.h

/* Copyright (c) 2012-2017, Stefan Eilemann <eile@eyescale.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_FRAME_H
#define EQFABRIC_FRAME_H

#include <co/object.h> // base class
#include <eq/fabric/api.h>
#include <eq/fabric/eye.h> // enum
#include <eq/fabric/types.h>

namespace eq
{
namespace fabric
{
namespace detail
{
class Frame;
}

class Frame : public co::Object
{
public:
    enum class Buffer : uint32_t
    {
        none = LB_BIT_NONE,
        undefined = LB_BIT1, 
        color = LB_BIT5,     
        depth = LB_BIT9,     
        all = LB_BIT_ALL_32
    };

    enum Type
    {
        TYPE_MEMORY, 
        TYPE_TEXTURE 
    };

    EQFABRIC_API Frame();

    EQFABRIC_API virtual ~Frame();

    EQFABRIC_API void setName(const std::string& name);

    EQFABRIC_API const std::string& getName() const;

    EQFABRIC_API const Vector2i& getOffset() const;

    EQFABRIC_API void setOffset(const Vector2i& offset);

    EQFABRIC_API void setZoom(const Zoom& zoom);

    EQFABRIC_API const Zoom& getZoom() const;

    EQFABRIC_API const co::ObjectVersion& getDataVersion(const Eye) const;

    EQFABRIC_API
    const std::vector<uint128_t>& getInputNodes(const Eye eye) const;

    EQFABRIC_API const co::NodeIDs& getInputNetNodes(const Eye eye) const;

protected:
    virtual ChangeType getChangeType() const { return INSTANCE; }
    EQFABRIC_API virtual void getInstanceData(co::DataOStream& os);
    EQFABRIC_API virtual void applyInstanceData(co::DataIStream& is);

    EQFABRIC_API void _setDataVersion(const unsigned i,
                                      const co::ObjectVersion& ov);

    EQFABRIC_API std::vector<uint128_t>& _getInputNodes(const unsigned i);

    EQFABRIC_API co::NodeIDs& _getInputNetNodes(const unsigned i);

private:
    detail::Frame* const _impl;
};

inline bool operator&(const Frame::Buffer l, const Frame::Buffer r)
{
    return (static_cast<uint32_t>(l) & static_cast<uint32_t>(r));
}

inline Frame::Buffer operator|(const Frame::Buffer l, const Frame::Buffer r)
{
    return static_cast<Frame::Buffer>(static_cast<uint32_t>(l) |
                                      static_cast<uint32_t>(r));
}

inline Frame::Buffer& operator&=(Frame::Buffer& l, const Frame::Buffer r)
{
    l = static_cast<Frame::Buffer>(static_cast<uint32_t>(l) &
                                   static_cast<uint32_t>(r));
    return l;
}

inline Frame::Buffer& operator|=(Frame::Buffer& l, const Frame::Buffer r)
{
    l = static_cast<Frame::Buffer>(static_cast<uint32_t>(l) |
                                   static_cast<uint32_t>(r));
    return l;
}

inline Frame::Buffer operator~(const Frame::Buffer l)
{
    return static_cast<Frame::Buffer>(~static_cast<uint32_t>(l));
}

EQFABRIC_API std::ostream& operator<<(std::ostream&, const Frame&);
EQFABRIC_API std::ostream& operator<<(std::ostream&, const Frame::Type);
EQFABRIC_API std::ostream& operator<<(std::ostream&, const Frame::Buffer);
}
}

#endif // EQFABRIC_FRAME_H