path_array.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_EXT_NV_PATH_RENDERING_PATH_ARRAY_1203031902_HPP
#define OGLPLUS_EXT_NV_PATH_RENDERING_PATH_ARRAY_1203031902_HPP

#if OGLPLUS_DOCUMENTATION_ONLY || GL_NV_path_rendering

#include <oglplus/ext/NV_path_rendering/path.hpp>

#include <oglplus/ext/NV_path_rendering/font_target.hpp>
#include <oglplus/ext/NV_path_rendering/font_style.hpp>
#include <oglplus/ext/NV_path_rendering/list_mode.hpp>
#include <oglplus/ext/NV_path_rendering/missing_glyph.hpp>
#include <oglplus/ext/NV_path_rendering/metric_query.hpp>

namespace oglplus {


class PathArrayNV
 : public Array<PathNV>
{
public:
    PathArrayNV(GLsizei count)
     : Array<PathNV>(count)
    { }


    template <typename CharType>
    PathArrayNV& Glyphs(
        PathNVFontTarget font_target,
        const GLchar* font_name,
        Bitfield<PathNVFontStyle> font_style,
        GLsizei num_glyphs,
        const CharType* char_codes,
        PathNVMissingGlyph handle_missing_glyphs,
        GLuint parameter_template,
        GLfloat em_scale
    )
    {
        OGLPLUS_GLFUNC(PathGlyphsNV)(
            this->_names[0],
            GLenum(font_target),
            (const void*)font_name,
            GLbitfield(font_style),
            num_glyphs,
            GetDataType<CharType>(),
            (const void*)char_codes,
            GLenum(handle_missing_glyphs),
            parameter_template,
            em_scale
        );
        OGLPLUS_CHECK(
            PathGlyphsNV,
            Error,
            EnumParam(font_target)
        );
        return *this;
    }


    template <typename CharType>
    PathArrayNV& Glyphs(
        PathNVFontTarget font_target,
        const GLchar* font_name,
        Bitfield<PathNVFontStyle> font_style,
        const std::vector<CharType>& char_codes,
        PathNVMissingGlyph handle_missing_glyphs,
        GLuint parameter_template,
        GLfloat em_scale
    )
    {
        OGLPLUS_GLFUNC(PathGlyphsNV)(
            this->_names[0],
            GLenum(font_target),
            (const void*)font_name,
            GLbitfield(font_style),
            GLsizei(char_codes.size()),
            GetDataType<CharType>(),
            (const void*)char_codes.data(),
            GLenum(handle_missing_glyphs),
            parameter_template,
            em_scale
        );
        OGLPLUS_CHECK(
            PathGlyphsNV,
            Error,
            EnumParam(font_target)
        );
        return *this;
    }


    PathArrayNV& Glyphs(
        PathNVFontTarget font_target,
        const GLchar* font_name,
        Bitfield<PathNVFontStyle> font_style,
        StrCRef char_codes,
        PathNVMissingGlyph handle_missing_glyphs,
        GLuint parameter_template,
        GLfloat em_scale
    )
    {
        OGLPLUS_GLFUNC(PathGlyphsNV)(
            this->_names[0],
            GLenum(font_target),
            (const void*)font_name,
            GLbitfield(font_style),
            char_codes.size(),
            GL_UTF8_NV,
            (const void*)char_codes.c_str(),
            GLenum(handle_missing_glyphs),
            parameter_template,
            em_scale
        );
        OGLPLUS_CHECK(
            PathGlyphsNV,
            Error,
            EnumParam(font_target)
        );
        return *this;
    }


    PathArrayNV& GlyphRange(
        PathNVFontTarget font_target,
        const GLchar* font_name,
        Bitfield<PathNVFontStyle> font_style,
        GLuint first_glyph,
        GLsizei num_glyphs,
        PathNVMissingGlyph handle_missing_glyphs,
        GLuint parameter_template,
        GLfloat em_scale
    )
    {
        OGLPLUS_GLFUNC(PathGlyphRangeNV)(
            this->_names[0],
            GLenum(font_target),
            (const void*)font_name,
            GLbitfield(font_style),
            first_glyph,
            num_glyphs,
            GLenum(handle_missing_glyphs),
            parameter_template,
            em_scale
        );
        OGLPLUS_CHECK(
            PathGlyphRangeNV,
            Error,
            EnumParam(font_target)
        );
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& GetSpacing(
        PathNVListMode list_mode,
        GLsizei num_indices,
        const IndexType* indices,
        GLfloat advance_scale,
        GLfloat kerning_scale,
        PathNVTransformType transform_type,
        GLfloat* returned_values
    )
    {
        OGLPLUS_GLFUNC(GetPathSpacingNV)(
            GLenum(list_mode),
            num_indices,
            GLenum(GetDataType<IndexType>()),
            (const void*)indices,
            this->_names[0],
            advance_scale,
            kerning_scale,
            GLenum(transform_type),
            returned_values
        );
        OGLPLUS_CHECK(
            GetPathSpacingNV,
            Error,
            EnumParam(list_mode)
        );
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& GetSpacing(
        PathNVListMode list_mode,
        const std::vector<IndexType>& indices,
        GLfloat advance_scale,
        GLfloat kerning_scale,
        PathNVTransformType transform_type,
        std::vector<GLfloat>& returned_values
    )
    {
        OGLPLUS_GLFUNC(GetPathSpacingNV)(
            GLenum(list_mode),
            GLsizei(indices.size()),
            GLenum(GetDataType<IndexType>()),
            (const void*)indices.data(),
            this->_names[0],
            advance_scale,
            kerning_scale,
            GLenum(transform_type),
            returned_values.data()
        );
        OGLPLUS_CHECK(
            GetPathSpacingNV,
            Error,
            EnumParam(list_mode)
        );
        return *this;
    }


    PathArrayNV& GetSpacing(
        PathNVListMode list_mode,
        StrCRef indices,
        GLfloat advance_scale,
        GLfloat kerning_scale,
        PathNVTransformType transform_type,
        std::vector<GLfloat>& returned_values
    )
    {
        OGLPLUS_GLFUNC(GetPathSpacingNV)(
            GLenum(list_mode),
            GLsizei(indices.size()+1), //include null terminator
            GL_UTF8_NV,
            (const void*)indices.c_str(),
            this->_names[0],
            advance_scale,
            kerning_scale,
            GLenum(transform_type),
            returned_values.data()
        );
        OGLPLUS_CHECK(
            GetPathSpacingNV,
            Error,
            EnumParam(list_mode)
        );
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& GetMetrics(
        Bitfield<PathNVMetricQuery> query_mask,
        GLsizei num_indices,
        const IndexType* indices,
        GLsizei stride,
        GLfloat* returned_values
    )
    {
        OGLPLUS_GLFUNC(GetPathMetricsNV)(
            GLbitfield(query_mask),
            num_indices,
            GLenum(GetDataType<IndexType>()),
            (const void*)indices,
            this->_names[0],
            stride,
            returned_values
        );
        OGLPLUS_CHECK_SIMPLE(GetPathMetricsNV);
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& GetMetrics(
        Bitfield<PathNVMetricQuery> query_mask,
        const std::vector<IndexType>& indices,
        GLsizei stride,
        GLfloat* returned_values
    )
    {
        OGLPLUS_GLFUNC(GetPathMetricsNV)(
            GLbitfield(query_mask),
            GLsizei(indices.size()),
            GLenum(GetDataType<IndexType>()),
            (const void*)indices.data(),
            this->_names[0],
            stride,
            returned_values
        );
        OGLPLUS_CHECK_SIMPLE(GetPathMetricsNV);
        return *this;
    }


    PathArrayNV& GetMetrics(
        Bitfield<PathNVMetricQuery> query_mask,
        StrCRef indices,
        GLsizei stride,
        GLfloat* returned_values
    )
    {
        OGLPLUS_GLFUNC(GetPathMetricsNV)(
            GLbitfield(query_mask),
            GLsizei(indices.size()+1),
            GL_UTF8_NV,
            (const void*)indices.c_str(),
            this->_names[0],
            stride,
            returned_values
        );
        OGLPLUS_CHECK_SIMPLE(GetPathMetricsNV);
        return *this;
    }


    PathArrayNV& GetMetricRange(
        Bitfield<PathNVMetricQuery> query_mask,
        GLsizei num_paths,
        GLsizei stride,
        GLfloat* returned_values
    )
    {
        OGLPLUS_GLFUNC(GetPathMetricRangeNV)(
            GLbitfield(query_mask),
            this->_names[0],
            num_paths,
            stride,
            returned_values
        );
        OGLPLUS_CHECK_SIMPLE(GetPathMetricRangeNV);
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& StencilFillInstanced(
        GLsizei num_paths,
        const IndexType* paths,
        PathNVFillMode mode,
        GLuint mask,
        PathNVTransformType transform_type,
        const GLfloat* transform_values
    )
    {
        OGLPLUS_GLFUNC(StencilFillPathInstancedNV)(
            num_paths,
            GLenum(GetDataType<IndexType>()),
            (const void*)paths,
            this->_names[0],
            GLenum(mode),
            mask,
            GLenum(transform_type),
            transform_values
        );
        OGLPLUS_CHECK(
            StencilFillPathInstancedNV,
            Error,
            EnumParam(mode)
        );
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& StencilFillInstanced(
        const std::vector<IndexType>& paths,
        PathNVFillMode mode,
        GLuint mask,
        PathNVTransformType transform_type,
        const std::vector<GLfloat>& transform_values
    )
    {
        // TODO: check if enough transform values
        // are provided for transform type
        OGLPLUS_GLFUNC(StencilFillPathInstancedNV)(
            GLsizei(paths.size()),
            GLenum(GetDataType<IndexType>()),
            (const void*)paths.data(),
            this->_names[0],
            GLenum(mode),
            mask,
            GLenum(transform_type),
            transform_values.data()
        );
        OGLPLUS_CHECK(
            StencilFillPathInstancedNV,
            Error,
            EnumParam(mode)
        );
        return *this;
    }


    PathArrayNV& StencilFillInstanced(
        StrCRef paths,
        PathNVFillMode mode,
        GLuint mask,
        PathNVTransformType transform_type,
        const std::vector<GLfloat>& transform_values
    )
    {
        // TODO: check if enough transform values
        // are provided for transform type
        OGLPLUS_GLFUNC(StencilFillPathInstancedNV)(
            GLsizei(paths.size()),
            GL_UTF8_NV,
            (const void*)paths.c_str(),
            this->_names[0],
            GLenum(mode),
            mask,
            GLenum(transform_type),
            transform_values.data()
        );
        OGLPLUS_CHECK(
            StencilFillPathInstancedNV,
            Error,
            EnumParam(mode)
        );
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& CoverFillInstanced(
        GLsizei num_paths,
        const IndexType* paths,
        PathNVFillCoverMode mode,
        PathNVTransformType transform_type,
        const GLfloat* transform_values
    )
    {
        OGLPLUS_GLFUNC(CoverFillPathInstancedNV)(
            num_paths,
            GLenum(GetDataType<IndexType>()),
            (const void*)paths,
            this->_names[0],
            GLenum(mode),
            GLenum(transform_type),
            transform_values
        );
        OGLPLUS_CHECK(
            CoverFillPathInstancedNV,
            Error,
            EnumParam(mode)
        );
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& CoverFillInstanced(
        const std::vector<IndexType>& paths,
        PathNVFillCoverMode mode,
        PathNVTransformType transform_type,
        const std::vector<GLfloat>& transform_values
    )
    {
        OGLPLUS_GLFUNC(CoverFillPathInstancedNV)(
            GLsizei(paths.size()),
            GLenum(GetDataType<IndexType>()),
            (const void*)paths.data(),
            this->_names[0],
            GLenum(mode),
            GLenum(transform_type),
            transform_values.data()
        );
        OGLPLUS_CHECK(
            CoverFillPathInstancedNV,
            Error,
            EnumParam(mode)
        );
        return *this;
    }


    PathArrayNV& CoverFillInstanced(
        StrCRef paths,
        PathNVFillCoverMode mode,
        PathNVTransformType transform_type,
        const std::vector<GLfloat>& transform_values
    )
    {
        OGLPLUS_GLFUNC(CoverFillPathInstancedNV)(
            GLsizei(paths.size()),
            GL_UTF8_NV,
            (const void*)paths.c_str(),
            this->_names[0],
            GLenum(mode),
            GLenum(transform_type),
            transform_values.data()
        );
        OGLPLUS_CHECK(
            CoverFillPathInstancedNV,
            Error,
            EnumParam(mode)
        );
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& StencilStrokeInstanced(
        GLsizei num_paths,
        const IndexType* paths,
        GLint reference,
        GLuint mask,
        PathNVTransformType transform_type,
        const GLfloat* transform_values
    )
    {
        OGLPLUS_GLFUNC(StencilStrokePathInstancedNV)(
            num_paths,
            GLenum(GetDataType<IndexType>()),
            (const void*)paths,
            this->_names[0],
            reference,
            mask,
            GLenum(transform_type),
            transform_values
        );
        OGLPLUS_CHECK_SIMPLE(StencilStrokePathInstancedNV);
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& StencilStrokeInstanced(
        const std::vector<IndexType>& paths,
        GLint reference,
        GLuint mask,
        PathNVTransformType transform_type,
        const std::vector<GLfloat>& transform_values
    )
    {
        OGLPLUS_GLFUNC(StencilStrokePathInstancedNV)(
            GLsizei(paths.size()),
            GLenum(GetDataType<IndexType>()),
            (const void*)paths.data(),
            this->_names[0],
            reference,
            mask,
            GLenum(transform_type),
            transform_values.data()
        );
        OGLPLUS_CHECK_SIMPLE(StencilStrokePathInstancedNV);
        return *this;
    }


    PathArrayNV& StencilStrokeInstanced(
        StrCRef paths,
        GLint reference,
        GLuint mask,
        PathNVTransformType transform_type,
        const std::vector<GLfloat>& transform_values
    )
    {
        OGLPLUS_GLFUNC(StencilStrokePathInstancedNV)(
            GLsizei(paths.size()),
            GL_UTF8_NV,
            (const void*)paths.c_str(),
            this->_names[0],
            reference,
            mask,
            GLenum(transform_type),
            transform_values.data()
        );
        OGLPLUS_CHECK_SIMPLE(StencilStrokePathInstancedNV);
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& CoverStrokeInstanced(
        GLsizei num_paths,
        const IndexType* paths,
        PathNVStrokeCoverMode mode,
        PathNVTransformType transform_type,
        const GLfloat* transform_values
    )
    {
        OGLPLUS_GLFUNC(CoverStrokePathInstancedNV)(
            num_paths,
            GLenum(GetDataType<IndexType>()),
            (const void*)paths,
            this->_names[0],
            GLenum(mode),
            GLenum(transform_type),
            transform_values
        );
        OGLPLUS_CHECK(
            CoverStrokePathInstancedNV,
            Error,
            EnumParam(mode)
        );
        return *this;
    }


    template <typename IndexType>
    PathArrayNV& CoverStrokeInstanced(
        const std::vector<IndexType>& paths,
        PathNVStrokeCoverMode mode,
        PathNVTransformType transform_type,
        const std::vector<GLfloat>& transform_values
    )
    {
        OGLPLUS_GLFUNC(CoverStrokePathInstancedNV)(
            GLsizei(paths.size()),
            GLenum(GetDataType<IndexType>()),
            (const void*)paths.data(),
            this->_names[0],
            GLenum(mode),
            GLenum(transform_type),
            transform_values.data()
        );
        OGLPLUS_CHECK(
            CoverStrokePathInstancedNV,
            Error,
            EnumParam(mode)
        );
        return *this;
    }


    PathArrayNV& CoverStrokeInstanced(
        StrCRef paths,
        PathNVStrokeCoverMode mode,
        PathNVTransformType transform_type,
        const std::vector<GLfloat>& transform_values
    )
    {
        OGLPLUS_GLFUNC(CoverStrokePathInstancedNV)(
            GLsizei(paths.size()),
            GL_UTF8_NV,
            (const void*)paths.c_str(),
            this->_names[0],
            GLenum(mode),
            GLenum(transform_type),
            transform_values.data()
        );
        OGLPLUS_CHECK(
            CoverStrokePathInstancedNV,
            Error,
            EnumParam(mode)
        );
        return *this;
    }
};

} // namespace oglplus

#endif // NV_path_rendering

#endif // include guard