draw.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_SHAPES_DRAW_1107121519_HPP
#define OGLPLUS_SHAPES_DRAW_1107121519_HPP

#include <oglplus/config/basic.hpp>
#include <oglplus/primitive_type.hpp>
#include <oglplus/data_type.hpp>

#include <vector>
#include <cassert>

namespace oglplus {
namespace shapes {


class ElementIndexInfo
{
private:
    const size_t _sizeof_index;
    const oglplus::DataType _index_data_type;

    template <typename IT>
    static size_t _do_get_sizeof_index(const std::vector<IT>*)
    {
        return sizeof(IT);
    }

    template <class ShapeBuilder>
    static size_t _get_sizeof_index(const ShapeBuilder&)
    {
        return _do_get_sizeof_index(
            (typename ShapeBuilder::IndexArray*)nullptr
        );
    }

    template <typename IT>
    static oglplus::DataType _do_get_index_data_type(const std::vector<IT>*)
    {
        return oglplus::GetDataType<IT>();
    }

    template <class ShapeBuilder>
    static oglplus::DataType _get_index_data_type(const ShapeBuilder&)
    {
        return _do_get_index_data_type(
            (typename ShapeBuilder::IndexArray*)nullptr
        );
    }
public:
    template <class ShapeBuilder>
    ElementIndexInfo(const ShapeBuilder& builder)
     : _sizeof_index(_get_sizeof_index(builder))
     , _index_data_type(_get_index_data_type(builder))
    { }

    size_t Size(void) const
    {
        return _sizeof_index;
    }

    oglplus::DataType DataType(void) const
    {
        return _index_data_type;
    }
};

} // namespace shapes

OGLPLUS_ENUM_CLASS_BEGIN(ShapeDrawOperationMethod, GLuint)
    OGLPLUS_ENUM_CLASS_VALUE(DrawArrays, 0)
    OGLPLUS_ENUM_CLASS_COMMA
    OGLPLUS_ENUM_CLASS_VALUE(DrawElements, 1)
    // TODO
OGLPLUS_ENUM_CLASS_END(ShapeDrawOperationMethod)

namespace shapes {


struct DrawOperation
{
    typedef oglplus::ShapeDrawOperationMethod Method;

    Method method;
    PrimitiveType mode;

    GLuint first;

    GLuint count;

    static GLuint NoRestartIndex(void)
    {
        return ~GLuint(0);
    }


    GLuint restart_index;


    GLuint phase;

    void Draw(
        const ElementIndexInfo& index_info,
        GLuint inst_count = 1,
        GLuint base_inst = 0
    ) const
    {
        this->Draw_(
            IndexPtr_(index_info),
            index_info.DataType(),
            inst_count,
            base_inst
        );
    }

    template <typename IT>
    void Draw(
        const std::vector<IT>& indices,
        GLuint inst_count = 1,
        GLuint base_inst = 0
    ) const
    {
        this->Draw_(
            IndexPtr_(indices),
            IndexDataType_(indices),
            inst_count,
            base_inst
        );
    }
private:

    template <typename IT>
    static DataType IndexDataType_(const std::vector<IT>&)
    {
        return GetDataType<IT>();
    }

    template <typename IT>
    void* IndexPtr_(const std::vector<IT>& indices) const
    {
        const IT* base = indices.empty() ? nullptr : indices.data();
        return (void*)(base + first);
    }

    void* IndexPtr_(const ElementIndexInfo& index_info) const
    {
        return (void*)(first * index_info.Size());
    }

    void SetupPrimitiveRestart_(void) const;
    void CleanupPrimitiveRestart_(void) const;

    void Draw_(
        void* indices,
        DataType index_data_type,
        GLuint inst_count,
        GLuint base_inst
    ) const;

    void DrawArrays_(GLuint inst_count, GLuint base_inst) const;

    void DrawElements_(
        void* indices,
        DataType index_data_type,
        GLuint inst_count,
        GLuint base_inst
    ) const;
};

class DrawingInstructionWriter;


class DrawingInstructions
{
private:

    typedef std::vector<DrawOperation> DrawOperationSeq;
    DrawOperationSeq _ops;

    DrawingInstructions(void)
    { }

    DrawingInstructions(DrawOperationSeq&& ops)
     : _ops(std::move(ops))
    { }

    friend class DrawingInstructionWriter;

    // helper functor used as DrawFun in Draw_
    template <class IndexArray>
    struct DrawFromIndices_
    {
        const IndexArray& _indices;

        DrawFromIndices_(const IndexArray& indices)
         : _indices(indices)
        { }

        void operator()(
            const DrawOperation& op,
            GLuint inst_count,
            GLuint base_inst
        ) const
        {
            op.Draw(_indices, inst_count, base_inst);
        }
    };

    // helper functor used as DrawFun in Draw_
    struct DrawFromIndexInfo_
    {
        ElementIndexInfo _index_info;

        DrawFromIndexInfo_(const ElementIndexInfo& index_info)
         : _index_info(index_info)
        { }

        void operator()(
            const DrawOperation& op,
            GLuint inst_count,
            GLuint base_inst
        ) const
        {
            op.Draw(_index_info, inst_count, base_inst);
        }
    };

    template <typename DrawFun, typename Driver>
    void Draw_(
        const DrawFun& draw_fun,
        const GLuint inst_count,
        const GLuint base_inst,
        const Driver& driver
    ) const
    {
        auto i=_ops.begin(),e=_ops.end();
        if(i != e)
        {
            bool do_draw;
            if(driver(i->phase))
            {
                do_draw = true;
                draw_fun(*i, inst_count, base_inst);
            }
            else do_draw = false;
            GLuint prev_phase = i->phase;
            ++i;

            while(i!=e)
            {
                if(prev_phase != i->phase)
                {
                    do_draw = driver(i->phase);
                    prev_phase = i->phase;
                }
                if(do_draw) draw_fun(*i, inst_count, base_inst);
                ++i;
            }
        }
    }
public:
    DrawingInstructions(DrawingInstructions&& temp)
     : _ops(std::move(temp._ops))
    { }

    DrawingInstructions(const DrawingInstructions& other)
     : _ops(other._ops)
    { }

    const std::vector<DrawOperation>& Operations(void) const
    {
        return _ops;
    }

    struct DefaultDriver
    {
        inline bool operator()(GLuint /*phase*/) const
        {
            return true;
        }
    };

    template <typename IT, typename Driver>
    void Draw(
        const std::vector<IT>& indices,
        GLuint inst_count,
        GLuint base_inst,
        Driver driver
    ) const
    {
        this->Draw_(
            DrawFromIndices_<std::vector<IT>>(indices),
            inst_count,
            base_inst,
            driver
        );
    }

    template <typename IT>
    void Draw(
        const std::vector<IT>& indices,
        GLuint inst_count = 1,
        GLuint base_inst = 0
    ) const
    {
        this->Draw_(
            DrawFromIndices_<std::vector<IT>>(indices),
            inst_count,
            base_inst,
            DefaultDriver()
        );
    }

    template <typename Driver>
    void Draw(
        const ElementIndexInfo& index_info,
        GLuint inst_count,
        GLuint base_inst,
        Driver driver
    ) const
    {
        this->Draw_(
            DrawFromIndexInfo_(index_info),
            inst_count,
            base_inst,
            driver
        );
    }

    void Draw(
        const ElementIndexInfo& index_info,
        GLuint inst_count = 1,
        GLuint base_inst = 0
    ) const
    {
        this->Draw_(
            DrawFromIndexInfo_(index_info),
            inst_count,
            base_inst,
            DefaultDriver()
        );
    }


};

// Helper base class for shape builder classes making the drawing instructions
class DrawingInstructionWriter
{
private:
    typedef DrawingInstructions::DrawOperationSeq Operations;
protected:
    static DrawingInstructions MakeInstructions(void)
    {
        return DrawingInstructions();
    }

    static void AddInstruction(
        DrawingInstructions& instr,
        const DrawOperation& operation
    )
    {
        instr._ops.push_back(operation);
    }

    static DrawingInstructions MakeInstructions(const DrawOperation& operation)
    {
        DrawingInstructions instr;
        instr._ops.push_back(operation);
        return instr;
    }

    static DrawingInstructions MakeInstructions(Operations&& ops)
    {
        return DrawingInstructions(std::forward<Operations>(ops));
    }
};

struct DrawMode
{
    struct Default { };
    struct WithAdjacency { };
    struct Quads { };
    struct Patches { };
    struct Edges { };
};


} // shapes
} // oglplus

#if !OGLPLUS_LINK_LIBRARY || defined(OGLPLUS_IMPLEMENTING_LIBRARY)
#include <oglplus/shapes/draw.ipp>
#endif // OGLPLUS_LINK_LIBRARY

#endif // include guard