vert_attr_info.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_SHAPES_VERT_ATTR_INFO_1107121519_HPP
#define OGLPLUS_SHAPES_VERT_ATTR_INFO_1107121519_HPP

#include <oglplus/string/ref.hpp>

#include <tuple>

namespace oglplus {
namespace shapes {

template <class ShapeBuilder, class VertexAttributeTag>
struct VertexAttribInfo;

#define OGLPLUS_SHAPES_HLPR_MAKE_VERT_ATTR_INFO(ATTR_NAME, GETTER_NAME) \
struct Vertex ## GETTER_NAME ## Tag { }; \
 \
template <class ShapeBuilder> \
struct VertexAttribInfo<ShapeBuilder, Vertex ## GETTER_NAME ## Tag> \
{ \
public: \
    static const GLchar* _name(void) \
    { \
        return #ATTR_NAME; \
    } \
 \
    template <typename T> \
    struct _getter_proc \
    { \
        typedef GLuint (*type)(const ShapeBuilder&, std::vector<T>&); \
    };\
 \
    template <typename T> \
    static GLuint _getter_wrapper( \
        const ShapeBuilder& make, \
        std::vector<T>& dest \
    ) \
    { \
        return make.GETTER_NAME(dest); \
    } \
 \
    template <typename T> \
    static typename _getter_proc<T>::type _getter(T*) \
    { \
        return &VertexAttribInfo::_getter_wrapper<T>; \
    } \
};

OGLPLUS_SHAPES_HLPR_MAKE_VERT_ATTR_INFO(Position, Positions)
OGLPLUS_SHAPES_HLPR_MAKE_VERT_ATTR_INFO(Normal, Normals)
OGLPLUS_SHAPES_HLPR_MAKE_VERT_ATTR_INFO(Tangent, Tangents)
OGLPLUS_SHAPES_HLPR_MAKE_VERT_ATTR_INFO(Bitangent, Bitangents)
OGLPLUS_SHAPES_HLPR_MAKE_VERT_ATTR_INFO(TexCoord, TexCoordinates)
OGLPLUS_SHAPES_HLPR_MAKE_VERT_ATTR_INFO(Material, MaterialNumbers)

#undef OGLPLUS_SHAPES_HLPR_MAKE_VERT_ATTR_INFO

#if OGLPLUS_DOCUMENTATION_ONLY

class VertexAttribsInfo<ShapeBuiler>
{
public:
    bool MakesVertexAttrib(StrCRef name) const;


    template <typename T>
    static GetterFunction VertexAttribGetter(StrCRef name);
};
#else
template <class ShapeBuilder, class VertexAttribTags, std::size_t N>
class VertexAttribsInfoBase
{
private:
    static bool _has_vertex_attrib(
        StrCRef,
        std::integral_constant<std::size_t, N>,
        std::integral_constant<std::size_t, N>
    )
    {
        return false;
    }

    template <std::size_t I>
    static bool _has_vertex_attrib(
        StrCRef name,
        std::integral_constant<std::size_t, I>,
        std::integral_constant<std::size_t, N>
    )
    {
        auto info = VertexAttribInfo<
            ShapeBuilder,
            typename std::tuple_element<I, VertexAttribTags>::type
        >();
        if(name == info._name()) return true;
        else return _has_vertex_attrib(
            name,
            std::integral_constant<std::size_t, I+1>(),
            std::integral_constant<std::size_t, N>()
        );
    }
protected:
    static bool _has_vertex_attrib(StrCRef name)
    {
        return _has_vertex_attrib(
            name,
            std::integral_constant<std::size_t, 0>(),
            std::integral_constant<std::size_t, N>()
        );
    }

    template <typename T>
    struct _getter_proc
    {
        typedef GLuint (*type)(const ShapeBuilder&, std::vector<T>&);
    };
private:
    template <typename T>
    static typename _getter_proc<T>::type
    _find_getter(
        T*,
        StrCRef,
        std::integral_constant<std::size_t, N>,
        std::integral_constant<std::size_t, N>
    )
    {
        return nullptr;
    }

    template <typename T, std::size_t I>
    static typename _getter_proc<T>::type
    _find_getter(
        T* selector,
        StrCRef name,
        std::integral_constant<std::size_t, I>,
        std::integral_constant<std::size_t, N>
    )
    {
        auto info = VertexAttribInfo<
            ShapeBuilder,
            typename std::tuple_element<I, VertexAttribTags>::type
        >();
        if(std::strcmp(name.c_str(), info._name()) == 0)
        {
            return info._getter(selector);
        }
        return _find_getter(
            selector,
            name,
            std::integral_constant<std::size_t, I+1>(),
            std::integral_constant<std::size_t, N>()
        );
    }

protected:
    template <typename T>
    static typename _getter_proc<T>::type
    _find_getter(T* selector, StrCRef name)
    {
        return _find_getter(
            selector,
            name,
            std::integral_constant<std::size_t, 0>(),
            std::integral_constant<std::size_t, N>()
        );
    }
};

template <class ShapeBuilder, class VertexAttribTags>
class VertexAttribsInfo
 : public VertexAttribsInfoBase<
    ShapeBuilder,
    VertexAttribTags,
    std::tuple_size<VertexAttribTags>::value
>
{
private:
    typedef VertexAttribsInfoBase<
        ShapeBuilder,
        VertexAttribTags,
        std::tuple_size<VertexAttribTags>::value
    > _base;
public:
    bool MakesVertexAttrib(StrCRef name) const
    {
        return _base::_has_vertex_attrib(name);
    }

    template <typename T>
    static typename _base::template _getter_proc<T>::type
    VertexAttribGetter(
        const std::vector<T>& /*selector*/,
        StrCRef name
    )
    {
        return _base::_find_getter((T*)nullptr, name);
    }
};
#endif

} // shapes
} // oglplus

#endif // include guard