location.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_PROG_VAR_LOCATION_1405052234_HPP
#define OGLPLUS_PROG_VAR_LOCATION_1405052234_HPP

#include <oglplus/fwd.hpp>
#include <oglplus/string/ref.hpp>
#include <oglplus/object/tags.hpp>
#include <oglplus/object/name.hpp>
#include <oglplus/error/prog_var.hpp>

namespace oglplus {

template <typename VarTag>
GLint GetGLLocation(ProgVarLoc<VarTag>);

template <typename VarTag>
class ProgVarLoc
 : public ProgVarLocOps<VarTag>
{
protected:
    friend GLint GetGLLocation<VarTag>(ProgVarLoc);
    GLuint _program;
    GLint _location;

    void RequireActive(StrCRef identifier) const
    {
        OGLPLUS_HANDLE_ERROR_IF(
            !IsActive(),
            GL_INVALID_OPERATION,
            ProgVarLocOps<VarTag>::MsgUsingInactive(),
            ProgVarError,
            Program(ProgramName(_program)).
            Identifier(identifier)
        );
    }

    void RequireActive(void) const
    {
        RequireActive(StrCRef());
    }
public:
    ProgVarLoc(void)
    OGLPLUS_NOEXCEPT(true)
     : _program(0u)
     , _location(-1)
    { }

    ProgVarLoc(ProgramName program)
    OGLPLUS_NOEXCEPT(true)
     : _program(GetGLName(program))
     , _location(-1)
    { }

    OGLPLUS_EXPLICIT
    ProgVarLoc(GLint location)
    OGLPLUS_NOEXCEPT(true)
     : _program(0)
     , _location(location)
    { }

    ProgVarLoc(ProgramName program, GLint location)
    OGLPLUS_NOEXCEPT(true)
     : _program(GetGLName(program))
     , _location(location)
    { }

    ProgVarLoc(ProgramName program, StrCRef identifier)
     : _program(GetGLName(program))
     , _location(ProgVarLocOps<VarTag>::GetLocation(
        program,
        identifier,
        true
    )){ }

    template <typename LocOpsParam>
    ProgVarLoc(LocOpsParam param, ProgramName program, StrCRef identifier)
     : ProgVarLocOps<VarTag>(param)
     , _program(GetGLName(program))
     , _location(ProgVarLocOps<VarTag>::GetLocation(
        program,
        identifier,
        true
    )){ }

    ProgVarLoc(ProgramName program, StrCRef identifier, bool active_only)
     : _program(GetGLName(program))
     , _location(ProgVarLocOps<VarTag>::GetLocation(
        program,
        identifier,
        active_only
    )){ }

    template <typename LocOpsParam>
    ProgVarLoc(
        LocOpsParam param,
        ProgramName program,
        StrCRef identifier,
        bool active_only
    ): ProgVarLocOps<VarTag>(param)
     , _program(GetGLName(program))
     , _location(ProgVarLocOps<VarTag>::GetLocation(
        program,
        identifier,
        active_only
    )){ }

    ProgVarLoc& Assign(ProgVarLoc that)
    {
        this->_program = that._program;
        this->_location= that._location;
        return *this;
    }

    ProgVarLoc& BindTo(StrCRef identifier, bool is_active = true)
    {
        _location = ProgVarLocOps<VarTag>::GetLocation(
            ProgramName(_program),
            identifier,
            is_active
        );
        return *this;
    }

    ProgramName Program(void) const
    OGLPLUS_NOEXCEPT(true)
    {
        return ProgramName(_program);
    }

    GLint Location(void) const
    OGLPLUS_NOEXCEPT(true)
    {
        return _location;
    }

    bool IsActive(void) const
    OGLPLUS_NOEXCEPT(true)
    {
        return _location >= 0;
    }

    OGLPLUS_EXPLICIT operator bool (void) const
    OGLPLUS_NOEXCEPT(true)
    {
        return IsActive();
    }

    friend bool operator == (ProgVarLoc a, ProgVarLoc b)
    OGLPLUS_NOEXCEPT(true)
    {
        return (a._program == b._program)&&(a._location == b._location);
    }

    friend bool operator != (ProgVarLoc a, ProgVarLoc b)
    OGLPLUS_NOEXCEPT(true)
    {
        return (a._program != b._program)||(a._location != b._location);
    }

    friend bool operator < (ProgVarLoc a, ProgVarLoc b)
    OGLPLUS_NOEXCEPT(true)
    {
        if(a._program <  b._program) return true;
        if(a._program == b._program) return (a._location < b._location);
        return false;
    }
};

template <typename VarTag>
inline GLint GetGLLocation(ProgVarLoc<VarTag> variable)
{
    return variable._location;
}

} // namespace oglplus

#endif // include guard