transform_feedback.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_TRANSFORM_FEEDBACK_1107121519_HPP
#define OGLPLUS_TRANSFORM_FEEDBACK_1107121519_HPP

#include <oglplus/config/compiler.hpp>
#include <oglplus/glfunc.hpp>
#include <oglplus/object/wrapper.hpp>
#include <oglplus/error/object.hpp>
#include <oglplus/transform_feedback_target.hpp>
#include <oglplus/transform_feedback_mode.hpp>
#include <oglplus/transform_feedback_type.hpp>
#include <cassert>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0 || GL_ARB_transform_feedback2


template <>
class ObjGenDelOps<tag::TransformFeedback>
{
protected:
    static void Gen(tag::Generate, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(GenTransformFeedbacks)(count, names);
        OGLPLUS_CHECK_SIMPLE(GenTransformFeedbacks);
    }
#if GL_VERSION_4_5 || GL_ARB_direct_state_access
    static void Gen(tag::Create, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(CreateTransformFeedbacks)(count, names);
        OGLPLUS_CHECK_SIMPLE(CreateTransformFeedbacks);
    }
#endif

    static void Delete(GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(DeleteTransformFeedbacks)(count, names);
        OGLPLUS_VERIFY_SIMPLE(DeleteTransformFeedbacks);
    }

    static GLboolean IsA(GLuint name)
    {
        assert(name != 0);
        GLboolean result = OGLPLUS_GLFUNC(IsTransformFeedback)(name);
        OGLPLUS_VERIFY_SIMPLE(IsTransformFeedback);
        return result;
    }
};

template <>
class ObjBindingOps<tag::TransformFeedback>
{
private:
    static GLenum _binding_query(TransformFeedbackTarget target);
protected:
    static GLuint _binding(TransformFeedbackTarget target);
public:
    typedef TransformFeedbackTarget Target;


    static TransformFeedbackName Binding(Target target)
    {
        return TransformFeedbackName(_binding(target));
    }


    static void Bind(
        Target target,
        TransformFeedbackName tfb
    )
    {
        OGLPLUS_GLFUNC(BindTransformFeedback)(
            GLenum(target),
            GetGLName(tfb)
        );
        OGLPLUS_VERIFY(
            BindTransformFeedback,
            ObjectError,
            Object(tfb).
            BindTarget(target)
        );
    }
};

#endif // GL_VERSION_4_0

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0


template <>
class ObjCommonOps<tag::TransformFeedback>
 : public TransformFeedbackName
#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0 || GL_ARB_transform_feedback2
 , public ObjBindingOps<tag::TransformFeedback>
#endif
{
protected:
    ObjCommonOps(void){ }
public:
#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0 || GL_ARB_transform_feedback2
    using ObjBindingOps<tag::TransformFeedback>::Bind;


    void Bind(Target target = Target::TransformFeedback) const
    {
        Bind(target, *this);
    }
#endif


    static void Begin(TransformFeedbackPrimitiveType mode)
    {
        OGLPLUS_GLFUNC(BeginTransformFeedback)(GLenum(mode));
        OGLPLUS_VERIFY(
            BeginTransformFeedback,
            Error,
            EnumParam(mode)
        );
    }

    static void BeginPoints(void)
    {
        Begin(TransformFeedbackPrimitiveType::Points);
    }

    static void BeginLines(void)
    {
        Begin(TransformFeedbackPrimitiveType::Lines);
    }

    static void BeginTriangles(void)
    {
        Begin(TransformFeedbackPrimitiveType::Triangles);
    }


    static void End(void)
    {
        OGLPLUS_GLFUNC(EndTransformFeedback)();
        OGLPLUS_VERIFY_SIMPLE(EndTransformFeedback);
    }


    static void Pause(void)
    {
        OGLPLUS_GLFUNC(PauseTransformFeedback)();
        OGLPLUS_VERIFY_SIMPLE(PauseTransformFeedback);
    }


    static void Resume(void)
    {
        OGLPLUS_GLFUNC(ResumeTransformFeedback)();
        OGLPLUS_VERIFY_SIMPLE(ResumeTransformFeedback);
    }


    class Activator
    {
    private:
        bool _active;
    public:

        Activator(TransformFeedbackPrimitiveType mode)
         : _active(true)
        {
            OGLPLUS_GLFUNC(BeginTransformFeedback)(GLenum(mode));
            OGLPLUS_VERIFY(
                BeginTransformFeedback,
                Error,
                EnumParam(mode)
            );
        }

#if !OGLPLUS_NO_DELETED_FUNCTIONS
        Activator(const Activator&) = delete;
#else
    private:
        Activator(const Activator&);
    public:
#endif

        Activator(Activator&& tmp)
         : _active(tmp._active)
        {
            tmp._active = false;
        }

        void Finish(void)
        {
            if(_active)
            {
                OGLPLUS_GLFUNC(EndTransformFeedback)();
                OGLPLUS_VERIFY_SIMPLE(EndTransformFeedback);
                _active = false;
            }
        }


        ~Activator(void)
        {
            try { Finish(); }
            catch(...){ }
        }
    };


    class Pauser
    {
    private:
        bool _paused;
    public:

        Pauser(void)
         : _paused(true)
        {
            OGLPLUS_GLFUNC(PauseTransformFeedback)();
            OGLPLUS_VERIFY_SIMPLE(PauseTransformFeedback);
        }

#if !OGLPLUS_NO_DELETED_FUNCTIONS
        Pauser(const Pauser&) = delete;
#else
    private:
        Pauser(const Pauser&);
    public:
#endif

        Pauser(Pauser&& tmp)
         : _paused(tmp._paused)
        {
            tmp._paused = false;
        }


        void Resume(void)
        {
            if(_paused)
            {
                OGLPLUS_GLFUNC(ResumeTransformFeedback)();
                OGLPLUS_VERIFY_SIMPLE(ResumeTransformFeedback);
                _paused = false;
            }
        }


        ~Pauser(void)
        {
            try{ Resume(); }
            catch(...){ }
        }
    };
};


typedef ObjectZero<ObjZeroOps<tag::ImplicitSel, tag::TransformFeedback>>
    DefaultTransformFeedback;

#endif // GL_VERSION_3_0

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0 || GL_ARB_transform_feedback2


template <typename OpsTag>
class ObjectOps<OpsTag, tag::TransformFeedback>
 : public ObjZeroOps<OpsTag, tag::TransformFeedback>
{
protected:
    ObjectOps(void){ }
};

typedef ObjectOps<tag::ImplicitSel, tag::TransformFeedback>
    TransformFeedbackOps;


typedef Object<TransformFeedbackOps> TransformFeedback;

#endif // GL_VERSION_4_0 || transform feedback 2

} // namespace oglplus

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

#endif // include guard