uniform_bindings.cpp

Go to the documentation of this file.

/*
    RenderStack  Support library for OpenGL 3+
    Copyright (C) 2010  Timo Suoranta

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "renderstack/rs_gl.h"
#include "renderstack/rs_log.h"
#include "renderstack/uniform_bindings.hpp"
#include "renderstack/program.hpp"
#include "renderstack/texture.hpp"

namespace renderstack {

bool uniform_bindings::add(
    enum uniform_type   type,
    int                 gl_slot,
    int                 count,
    void                *value
)
{
    uniform_binding u(type, gl_slot, count, value);

    m_bindings.push_back(u);

    return true;
}

void uniform_bindings::apply()
{
    for(
        std::vector<uniform_binding>::const_iterator i = m_bindings.begin();
        i != m_bindings.end();
        ++i
    )
    {
        uniform_binding const& binding = *i;

        switch(binding.type)
        {
            case uniform_type_matrix_4:
            {
                ::rs_gl_uniform_matrix_4fv(
                    binding.gl_slot,
                    binding.count,
                    GL_FALSE, 
                    reinterpret_cast<::GLfloat const *>(binding.value)
                );
                break;
            }
            case uniform_type_float:
            {
                ::rs_gl_uniform_1fv(
                    binding.gl_slot,
                    binding.count,
                    reinterpret_cast<::GLfloat const *>(binding.value)
                );
                break;
            }
            case uniform_type_vec2:
            {
                ::rs_gl_uniform_2fv(
                    binding.gl_slot,
                    binding.count,
                    reinterpret_cast<::GLfloat const *>(binding.value)
                );
                break;
            }
            case uniform_type_vec3:
            {
                ::rs_gl_uniform_3fv(
                    binding.gl_slot,
                    binding.count,
                    reinterpret_cast<::GLfloat const *>(binding.value)
                );
                break;
            }
            case uniform_type_vec4:
            {
                ::rs_gl_uniform_4fv(
                    binding.gl_slot,
                    binding.count,
                    reinterpret_cast<::GLfloat const *>(binding.value)
                );
                break;
            }
            case uniform_type_int:
            {
                ::rs_gl_uniform_1iv(
                    binding.gl_slot,
                    binding.count,
                    reinterpret_cast<::GLint const *>(binding.value)
                );
                break;
            }
            case uniform_type_uint:
            {
                ::rs_gl_uniform_1uiv(
                    binding.gl_slot,
                    binding.count,
                    reinterpret_cast<::GLuint const *>(binding.value)
                );
                break;
            }
            case uniform_type_texture_2d:
            {
                texture_binding *t = reinterpret_cast<texture_binding*>(binding.value);
                int             texture_index   = t->index;
                class texture   *texture        = t->texture;

                ::rs_gl_uniform_1i     (binding.gl_slot, texture_index);
                ::rs_gl_active_texture (GL_TEXTURE0 + texture_index);
                ::rs_gl_bind_texture   (texture->gl_bind_target(), texture->gl_texture_object()); 
                ::rs_gl_tex_parameter_i(texture->gl_bind_target(), GL_TEXTURE_WRAP_S,     texture->gl_wrap());
                ::rs_gl_tex_parameter_i(texture->gl_bind_target(), GL_TEXTURE_WRAP_T,     texture->gl_wrap());
                ::rs_gl_tex_parameter_i(texture->gl_bind_target(), GL_TEXTURE_MAG_FILTER, texture->gl_magnification_filter());
                ::rs_gl_tex_parameter_i(texture->gl_bind_target(), GL_TEXTURE_MIN_FILTER, texture->gl_minification_filter());
                break;
            }
            case uniform_type_texture_cube:
            {
                break;
            }

            default:
            {
                throw false;
            }

        }
    }
}



std::string const &uniform_mappings::name(
    enum logical_uniform u
) const
{
    std::map<enum logical_uniform, std::string>::const_iterator i = m_uniform_to_string.find(u);
    if(i != m_uniform_to_string.end())
    {
        return (*i).second;
    }
    else
    {
        throw std::exception();
    }
}

enum logical_uniform uniform_mappings::logical_uniform(std::string const &name) const
{
    std::map<std::string, enum logical_uniform>::const_iterator i = m_string_to_uniform.find(name);
    if(i != m_string_to_uniform.end())
    {
        return (*i).second;
    }
    else
    {
        return logical_uniform_generic_uniform;
    }
}

void uniform_mappings::bind_uniforms(
    class uniform_bindings  &bindings,
    class program           &program, 
    class uniform_source    &source
)
{
    for(
        std::map<
            std::string, 
            enum logical_uniform
        >::const_iterator i = m_string_to_uniform.begin();
        i != m_string_to_uniform.end();
        ++i
    )
    {
        std::string const    &name = (*i).first;
        enum logical_uniform lu    = (*i).second;

        if(program.has_uniform(name) == true)
        {
            int gl_slot = program.uniform(name).gl_slot();
            if(gl_slot < 0)
            {
                continue;
            }
            if(source.connect(bindings, lu, gl_slot) == true)
            {
#if 0
                ::rs_log("bound %s slot %d\n", name.c_str(), gl_slot);
#endif
            }
        }

    }
}


void uniform_mappings::bind_uniforms(
    class uniform_bindings          &bindings,
    class program                   &program, 
    class uniform_parameter_source  &source
)
{
    for(
        std::vector<std::tr1::shared_ptr<uniform_mapping> >::const_iterator i = m_parameter_mappings.begin();
        i != m_parameter_mappings.end();
        ++i
    )
    {
        std::tr1::shared_ptr<uniform_mapping> mapping = *i;
        void *value_source = source.parameter(mapping->parameter_name);

        if(
            (program.has_uniform(mapping->shader_name) == true) &&
            (value_source != NULL)
        )
        {
            int gl_slot = program.uniform(mapping->shader_name).gl_slot();
            if(gl_slot < 0)
            {
                continue;
            }
            bindings.add(
                mapping->type,
                gl_slot,
                mapping->count,
                value_source
            );
#if 0
            ::rs_log("source bound %s slot %d count %d\n", mapping->shader_name.c_str(), gl_slot, mapping->count);
#endif
        }

    }
}


void *uniform_parameter_source::parameter(std::string const &name)
{
    std::map<std::string, void*>::const_iterator i = m_parameters.find(name);
    if(i != m_parameters.end())
    {
        return (*i).second;
    }
    return NULL;
}

}