wrapper.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_PROG_VAR_WRAPPER_1405052234_HPP
#define OGLPLUS_PROG_VAR_WRAPPER_1405052234_HPP

#include <oglplus/fwd.hpp>
#include <oglplus/string/ref.hpp>
#include <oglplus/prog_var/location.hpp>
#include <oglplus/prog_var/typecheck.hpp>
#include <cassert>
#include <new>

namespace oglplus {

template <typename VarTag>
class ProgVarCommonOps
 : public ProgVarLoc<VarTag>
{
protected:
    ProgVarCommonOps(ProgVarLoc<VarTag> pvloc)
     : ProgVarLoc<VarTag>(pvloc)
    { }
public:
};

template <typename OpsTag, typename VarTag, typename ChkTag, typename T>
class ProgVar
 : public ProgVarGetSetOps<OpsTag, VarTag, typename AdjustProgVar<T>::BaseType>
 , public ProgVarTypecheck<ChkTag, VarTag>
{
private:
    typedef typename AdjustProgVar<T>::BaseType BaseType;
    typedef ProgVarGetSetOps<OpsTag, VarTag, BaseType> BaseGetSetOps;
    typedef ProgVarTypecheck<ChkTag, VarTag> Typecheck;
public:
    ProgVar(void)
     : BaseGetSetOps(ProgVarLoc<VarTag>())
     , Typecheck((BaseType*)0)
    { }

    ProgVar(ProgVarLoc<VarTag> pvloc)
     : BaseGetSetOps(pvloc)
     , Typecheck((BaseType*)0)
    { }

    ProgVar(ProgramName program, GLuint location)
     : BaseGetSetOps(ProgVarLoc<VarTag>(program, GLint(location)))
     , Typecheck((BaseType*)0)
    { }

    ProgVar(ProgramName program, StrCRef identifier)
     : BaseGetSetOps(ProgVarLoc<VarTag>(program, identifier))
     , Typecheck((BaseType*)0)
    {
        Typecheck::CheckType(program, this->_location, identifier);
    }

    ProgVar(ProgramName program, StrCRef identifier, bool active_only)
     : BaseGetSetOps(ProgVarLoc<VarTag>(program, identifier, active_only))
     , Typecheck((BaseType*)0)
    {
        Typecheck::CheckType(program, this->_location, identifier);
    }

    ProgVar(ProgramName program, StrCRef identifier, std::nothrow_t)
     : BaseGetSetOps(ProgVarLoc<VarTag>(program, identifier, false))
     , Typecheck((BaseType*)0)
    {
        Typecheck::CheckType(program, this->_location, identifier);
    }

    ProgVar& BindTo(StrCRef identifier)
    {
        BaseGetSetOps::BindTo(identifier);
        Typecheck::CheckType(
            ProgramName(this->_program),
            this->_location,
            identifier
        );
        return *this;
    }

    ProgVar operator[](std::size_t offset) const
    {
        return ProgVar(
            ProgramName(this->_program),
            this->_location+offset
        );
    }

    ProgVar& operator = (ProgVarLoc<VarTag> pvloc)
    {
        BaseGetSetOps::Assign(pvloc);
        return *this;
    }

    typedef typename AdjustProgVar<T>::ValueType ParamType;

    void Set(ParamType value)
    {
        BaseGetSetOps::RequireActive();
        BaseGetSetOps::SetValue(AdjustProgVar<T>::Adjust(value));
    }

    void Set(std::size_t count, const T* values)
    {
        BaseGetSetOps::RequireActive();
        BaseGetSetOps::SetValues(count, values);
    }

    void Set(const std::vector<T>& values)
    {
        Set(values.size(), values.data());
    }

    template <typename T0, typename T1>
    void Set(T0 v0, T1 v1)
    {
        Set(ParamType(v0, v1));
    }

    template <typename T0, typename T1, typename T2>
    void Set(T0 v0, T1 v1, T2 v2)
    {
        Set(ParamType(v0, v1, v2));
    }

    template <typename T0, typename T1, typename T2, typename T3>
    void Set(T0 v0, T1 v1, T2 v2, T3 v3)
    {
        Set(ParamType(v0, v1, v2, v3));
    }

    void TrySet(ParamType value)
    {
        if(this->IsActive())
        {
            BaseGetSetOps::SetValue(AdjustProgVar<T>::Adjust(value));
        }
    }

    ProgVar& operator = (ParamType value)
    {
        this->Set(value);
        return *this;
    }
};

template <typename OpsTag, typename VarTag>
class ProgVar<OpsTag, VarTag, tag::NoTypecheck, void>
 : public ProgVarCommonOps<VarTag>
{
private:
    typedef ProgVarCommonOps<VarTag> BaseOps;
public:
    ProgVar(void)
     : BaseOps(ProgVarLoc<VarTag>())
    { }

    ProgVar(ProgVarLoc<VarTag> pvloc)
     : BaseOps(pvloc)
    { }

    ProgVar(ProgramName program, GLuint location)
     : BaseOps(ProgVarLoc<VarTag>(program, GLint(location)))
    { }

    ProgVar(ProgramName program, StrCRef identifier)
     : BaseOps(ProgVarLoc<VarTag>(program, identifier))
    { }

    ProgVar(ProgramName program, StrCRef identifier, bool active_only)
     : BaseOps(ProgVarLoc<VarTag>(program, identifier, active_only))
    { }

    ProgVar(ProgramName program, StrCRef identifier, std::nothrow_t)
     : BaseOps(ProgVarLoc<VarTag>(program, identifier, false))
    { }
};

#if !OGLPLUS_NO_INHERITED_CONSTRUCTORS
#define OGLPLUS_IMPLEMENT_PROG_VAR_CTRS(VAR_TAG, PROG_VAR, BASE) \
    using BASE::BASE;

#else
#define OGLPLUS_IMPLEMENT_PROG_VAR_CTRS(VAR_TAG, PROG_VAR, BASE) \
    PROG_VAR(void) : BASE() { } \
    PROG_VAR(ProgVarLoc<VAR_TAG> pvloc) : BASE(pvloc) { } \
    PROG_VAR(ProgramName program, GLuint location) \
     : BASE(program, location) { } \
    PROG_VAR(ProgramName program, StrCRef identifier) \
     : BASE(program, identifier) { } \
    PROG_VAR(ProgramName program, StrCRef identifier, bool active_only) \
     : BASE(program, identifier, active_only) { } \
    PROG_VAR(ProgramName program, StrCRef identifier, std::nothrow_t nt) \
     : BASE(program, identifier, nt) { }
#endif

#if !OGLPLUS_NO_TEMPLATE_ALIASES

// OGLPLUS_DECLARE_PROG_VAR
#define OGLPLUS_DECLARE_PROG_VAR(PROG_VAR, OPS_TAG, VAR_TAG, CHK_TAG) \
template <typename T> \
using PROG_VAR = ProgVar<OPS_TAG, VAR_TAG, CHK_TAG, T>;

#else

// OGLPLUS_DECLARE_PROG_VAR
#define OGLPLUS_DECLARE_PROG_VAR(PROG_VAR, OPS_TAG, VAR_TAG, CHK_TAG) \
template <typename T> \
class PROG_VAR \
 : public ProgVar<OPS_TAG, VAR_TAG, CHK_TAG, T> \
{ \
private:\
    typedef ProgVar<OPS_TAG, VAR_TAG, CHK_TAG, T> Base;\
public:\
    OGLPLUS_IMPLEMENT_PROG_VAR_CTRS(VAR_TAG, PROG_VAR, Base) \
    PROG_VAR& operator = (ProgVarLoc<VAR_TAG> pvloc) \
    { \
        Base::Assign(pvloc); \
        return *this; \
    } \
    PROG_VAR& operator = (typename Base::ParamType value) \
    { \
        this->Set(value); \
        return *this; \
    } \
}; \
template <typename T> \
struct Classify<PROG_VAR<T>> \
 : Classify<ProgVar<OPS_TAG, VAR_TAG, CHK_TAG, T>> \
{ };
#endif

} // namespace oglplus

#endif // include guard