~thumper/glint/simple-app

/*
 * Copyright (C) 2012 Canonical Ltd
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Authored by: Michi Henning <michi.henning@canonical.com>
 */

#include <glint/internal/AttributeVariableImpl.h>
#include <glint/GlintExceptions.h>
#include <glint/GLUtil.h>

#include <algorithm>
#include <cassert>
#include <sstream>

using namespace std;

namespace glint
{

namespace internal
{

// AttributeVariable

AttributeVariableImpl::
AttributeVariableImpl(GLuint prog_id, GLint location, const string& name, GLenum type)
    : ShaderVariableImpl(prog_id, location, name, type, 1)
{
    assert(type == GL_FLOAT ||
           type == GL_FLOAT_VEC2 || type == GL_FLOAT_VEC3 || type == GL_FLOAT_VEC4 ||
           type == GL_FLOAT_MAT2 || type == GL_FLOAT_MAT3 || type == GL_FLOAT_MAT4);
}

AttributeVariableImpl::
~AttributeVariableImpl() noexcept
{
}

// No check_gl() calls in any of this code because the only failure condition is that the
// location is wrong, which is impossible.

AttributeVariable::ArrayState
AttributeVariableImpl::
array_state() const
{
    GLint v;
    glGetVertexAttribiv(location(), GL_VERTEX_ATTRIB_ARRAY_ENABLED, &v);
    return v ? AttributeVariable::ArrayState::enabled : AttributeVariable::ArrayState::disabled;
}

void
AttributeVariableImpl::
set_array_state(AttributeVariable::ArrayState state)
{
    if (state == AttributeVariable::ArrayState::enabled)
    {
        glEnableVertexAttribArray(location());
    }
    else
    {
        glDisableVertexAttribArray(location());
    }
}

// Float

FloatAttributeImpl::
FloatAttributeImpl(GLuint prog_id, GLint location, const string& name)
    : AttributeVariableImpl(prog_id, location, name, GL_FLOAT)
{
}

FloatAttributeImpl::
~FloatAttributeImpl() noexcept
{
}

GLfloat
FloatAttributeImpl::
get() const
{
    FloatVec4 v;
    glGetVertexAttribfv(location(), GL_CURRENT_VERTEX_ATTRIB, &v[0]);
    return v[0];
}

void
FloatAttributeImpl::
set(GLfloat v)
{
    glVertexAttrib1f(location(), v);
}

// FloatVec2

FloatVec2AttributeImpl::
FloatVec2AttributeImpl(GLuint prog_id, GLint location, const string& name)
    : AttributeVariableImpl(prog_id, location, name, GL_FLOAT_VEC2)
{
}

FloatVec2AttributeImpl::
~FloatVec2AttributeImpl() noexcept
{
}

FloatVec2
FloatVec2AttributeImpl::
get() const
{
    FloatVec4 v;
    glGetVertexAttribfv(location(), GL_CURRENT_VERTEX_ATTRIB, &v[0]);
    return FloatVec2({ { v[0], v[1] } });
}

void
FloatVec2AttributeImpl::
set(const FloatVec2& v)
{
    glVertexAttrib2fv(location(), &v[0]);
}

// FloatVec3

FloatVec3AttributeImpl::
FloatVec3AttributeImpl(GLuint prog_id, GLint location, const string& name)
    : AttributeVariableImpl(prog_id, location, name, GL_FLOAT_VEC3)
{
}

FloatVec3AttributeImpl::
~FloatVec3AttributeImpl() noexcept
{
}

FloatVec3
FloatVec3AttributeImpl::
get() const
{
    FloatVec4 v;
    glGetVertexAttribfv(location(), GL_CURRENT_VERTEX_ATTRIB, &v[0]);
    return FloatVec3({ { v[0], v[1], v[2] } });
}

void
FloatVec3AttributeImpl::
set(const FloatVec3& v)
{
    glVertexAttrib3fv(location(), &v[0]);
}

// FloatVec4

FloatVec4AttributeImpl::
FloatVec4AttributeImpl(GLuint prog_id, GLint location, const string& name)
    : AttributeVariableImpl(prog_id, location, name, GL_FLOAT_VEC4)
{
}

FloatVec4AttributeImpl::
~FloatVec4AttributeImpl() noexcept
{
}

FloatVec4
FloatVec4AttributeImpl::
get() const
{
    FloatVec4 v;
    glGetVertexAttribfv(location(), GL_CURRENT_VERTEX_ATTRIB, &v[0]);
    return v;
}

void
FloatVec4AttributeImpl::
set(const FloatVec4& v)
{
    glVertexAttrib4fv(location(), &v[0]);
}

// FloatMat2

FloatMat2AttributeImpl::
FloatMat2AttributeImpl(GLuint prog_id, GLint location, const string& name)
    : AttributeVariableImpl(prog_id, location, name, GL_FLOAT_MAT2)
{
}

FloatMat2AttributeImpl::
~FloatMat2AttributeImpl() noexcept
{
}

FloatMat2
FloatMat2AttributeImpl::
get() const
{
    FloatMat4 v;
    glGetVertexAttribfv(location(), GL_CURRENT_VERTEX_ATTRIB, v[0].begin());
    glGetVertexAttribfv(location() + 1, GL_CURRENT_VERTEX_ATTRIB, v[1].begin());
    return FloatMat2({ {
                        { { v[0][0], v[0][1] } },
                        { { v[1][0], v[1][1] } }
                     } });
}

void
FloatMat2AttributeImpl::
set(const FloatMat2& v)
{
    glVertexAttrib2fv(location(), v[0].begin());
    glVertexAttrib2fv(location() + 1, v[1].begin());
}

// FloatMat3

FloatMat3AttributeImpl::
FloatMat3AttributeImpl(GLuint prog_id, GLint location, const string& name)
    : AttributeVariableImpl(prog_id, location, name, GL_FLOAT_MAT3)
{
}

FloatMat3AttributeImpl::
~FloatMat3AttributeImpl() noexcept
{
}

FloatMat3
FloatMat3AttributeImpl::
get() const
{
    FloatMat4 v;
    glGetVertexAttribfv(location(), GL_CURRENT_VERTEX_ATTRIB, v[0].begin());
    glGetVertexAttribfv(location() + 1, GL_CURRENT_VERTEX_ATTRIB, v[1].begin());
    glGetVertexAttribfv(location() + 2, GL_CURRENT_VERTEX_ATTRIB, v[2].begin());
    return FloatMat3({ {
                        { { v[0][0], v[0][1], v[0][2] } },
                        { { v[1][0], v[1][1], v[1][2] } },
                        { { v[2][0], v[2][1], v[2][2] } }
                     } });
}

void
FloatMat3AttributeImpl::
set(const FloatMat3& v)
{
    glVertexAttrib3fv(location(), v[0].begin());
    glVertexAttrib3fv(location() + 1, v[1].begin());
    glVertexAttrib3fv(location() + 2, v[2].begin());
}

// FloatMat4

FloatMat4AttributeImpl::
FloatMat4AttributeImpl(GLuint prog_id, GLint location, const string& name)
    : AttributeVariableImpl(prog_id, location, name, GL_FLOAT_MAT4)
{
}

FloatMat4AttributeImpl::
~FloatMat4AttributeImpl() noexcept
{
}

FloatMat4
FloatMat4AttributeImpl::
get() const
{
    FloatMat4 v;
    glGetVertexAttribfv(location(), GL_CURRENT_VERTEX_ATTRIB, v[0].begin());
    glGetVertexAttribfv(location() + 1, GL_CURRENT_VERTEX_ATTRIB, v[1].begin());
    glGetVertexAttribfv(location() + 2, GL_CURRENT_VERTEX_ATTRIB, v[2].begin());
    glGetVertexAttribfv(location() + 3, GL_CURRENT_VERTEX_ATTRIB, v[3].begin());
    return v;
}

void
FloatMat4AttributeImpl::
set(const FloatMat4& v)
{
    glVertexAttrib4fv(location(), v[0].begin());
    glVertexAttrib4fv(location() + 1, v[1].begin());
    glVertexAttrib4fv(location() + 2, v[2].begin());
    glVertexAttrib4fv(location() + 3, v[3].begin());
}

} // namespace internal

} // namespace glint