uniform_bindings.hpp

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
*/

#ifndef UNIFORM_BINDINGS_HPP
#define UNIFORM_BINDINGS_HPP

#include "renderstack/rs.h"
#include "renderstack/vec2.hpp"
#include "renderstack/vec3.hpp"
#include "renderstack/vec4.hpp"
#include "renderstack/matrix.hpp"
#include "renderstack/scoped_array.hpp"
#include <memory>
#include <vector>
#include <string>
#include <map>

namespace renderstack {

enum uniform_type
{
    uniform_type_matrix_4,
    uniform_type_float,
    uniform_type_vec2,
    uniform_type_vec3,
    uniform_type_vec4,
    uniform_type_int,
    uniform_type_uint,
    uniform_type_texture_2d,
    uniform_type_texture_cube
};

enum logical_uniform
{
    logical_uniform_local_to_world,
    logical_uniform_world_to_local,
    logical_uniform_local_to_clip,
    logical_uniform_clip_to_local,
    logical_uniform_world_to_clip,
    logical_uniform_clip_to_world,
    logical_uniform_view_position_in_world,
    logical_uniform_generic_uniform
};


struct uniform_binding;
struct uniform_mapping;
class uniform_collection;
class uniform_mappings;
class uniform_source;
struct float_parameter;
struct vec2_parameter;
struct vec3_parameter;
struct vec4_parameter;
struct matrix_parameter;
class texture;
class uniform_parameter_source;

struct texture_binding
{
    int             index;
    class texture   *texture;
};

struct uniform_binding
{
    uniform_binding(
        enum uniform_type   type_,
        int                 gl_slot_,
        int                 count_,
        void *              value_
    )
    :   type(type_)
    ,   gl_slot(gl_slot_)
    ,   count(count_)
    ,   value(value_)
    {
    }
    enum uniform_type   type;
    int                 gl_slot;    /*  location  */ 
    int                 count;
    void *              value;
};

class uniform_bindings
{
public:
    void clear()
    {
        m_bindings.clear();
    }

    bool add(
        enum uniform_type   type,
        int                 gl_slot,
        int                 count,
        void                *value
    );

    void apply();

private:
    std::vector<uniform_binding> m_bindings;
};

struct uniform_mapping
{
    uniform_mapping(
        std::string         shader_name_,
        std::string         parameter_name_,
        enum uniform_type   type_,
        int                 count_
    )
    :   shader_name     (shader_name_)
    ,   parameter_name  (parameter_name_)
    ,   type            (type_)
    ,   count           (count_)
    {
    }

    std::string         shader_name;
    std::string         parameter_name;
    enum uniform_type   type;
    int                 count;
};

class uniform_mappings
{
public:
    void insert(std::string const &name_in_shader, enum logical_uniform u)
    {
        m_string_to_uniform.insert(std::make_pair(name_in_shader, u));
        m_uniform_to_string.insert(std::make_pair(u, name_in_shader));
    }
    void insert(
        std::string         shader_name,
        std::string         parameter_name,
        enum uniform_type   type,
        int                 count
    )
    {
        std::tr1::shared_ptr<uniform_mapping> m(
            new uniform_mapping(shader_name, parameter_name, type, count)
        );
        m_parameter_mappings.push_back(m);
    }
    std::string const       &name           (enum logical_uniform u) const;
    enum logical_uniform    logical_uniform (std::string const &name_in_shader) const;

    void bind_uniforms(
        class uniform_bindings  &bindings,
        class program           &program, 
        class uniform_source    &source
    );
    void bind_uniforms(
        class uniform_bindings          &bindings,
        class program                   &program, 
        class uniform_parameter_source  &source
    );

private:
    std::map<std::string, enum logical_uniform>         m_string_to_uniform;
    std::map<enum logical_uniform, std::string>         m_uniform_to_string;
    std::vector<std::tr1::shared_ptr<uniform_mapping> > m_parameter_mappings;
};

class uniform_source
{
public:
    virtual bool connect(uniform_bindings &bindings, enum logical_uniform type, int slot) = 0;
};

struct uint_parameter
{
    uint_parameter(std::string const &name, int size = 1)
    :   value(new unsigned int[size])
    {
        this->name = name;
    }
    std::string                 name;
    scoped_array<unsigned int>  value;
};
struct float_parameter
{
    float_parameter(std::string const &name, int size = 1)
    :   value(new float[size])
    {
        this->name = name;
    }
    std::string         name;
    scoped_array<float> value;
};
struct vec2_parameter
{
    vec2_parameter(std::string const &name, int size = 1)
    :   value(new vec2[size])
    {
        this->name  = name;
    }
    std::string         name;
    scoped_array<vec2>  value;
};

struct vec3_parameter
{
    vec3_parameter(std::string const &name, int size = 1)
    :   value(new vec3[size])
    {
        this->name  = name;
    }
    std::string         name;
    scoped_array<vec3>  value;
};

struct vec4_parameter
{
    vec4_parameter(std::string const &name, int size = 1)
    :   value(new vec4[size])
    {
        this->name  = name;
    }
    std::string         name;
    scoped_array<vec4>  value;
};


struct matrix_parameter
{
    matrix_parameter(std::string const &name, int size = 1)
    :   value(new matrix[size])
    {
        this->name  = name;
    }
    std::string             name;
    scoped_array<matrix>    value;
};

struct texture_parameter
{
    texture_parameter(std::string const &name, int size = 1)
    :   value(new texture_binding[size])
    {
        this->name = name;
    }
    std::string             name;
    scoped_array<texture_binding> value;
};

class uniform_parameter_source
{
public:
    void *parameter(std::string const &name);
    uint_parameter    *add_uint(std::string const &name, int size = 1)
    {
        std::tr1::shared_ptr<uint_parameter> p(new uint_parameter(name, size));
        m_uint_parameters.push_back(p);
        m_parameters.insert(std::make_pair(name, &p->value[0]));
        return p.get();
    }
    float_parameter   *add_float(std::string const &name, int size = 1)
    {
        std::tr1::shared_ptr<float_parameter> p(new float_parameter(name, size));
        m_float_parameters.push_back(p);
        m_parameters.insert(std::make_pair(name, &p->value[0]));
        return p.get();
    }
    vec2_parameter    *add_vec2(std::string const &name, int size = 1)
    {
        std::tr1::shared_ptr<vec2_parameter> p(new vec2_parameter(name, size));
        m_vec2_parameters.push_back(p);
        m_parameters.insert(std::make_pair(name, &p->value[0].x));
        return p.get();
    }
    vec3_parameter    *add_vec3(std::string const &name, int size = 1)
    {
        std::tr1::shared_ptr<vec3_parameter> p(new vec3_parameter(name, size));
        m_vec3_parameters.push_back(p);
        m_parameters.insert(std::make_pair(name, &p->value[0].x));
        return p.get();
    }
    vec4_parameter    *add_vec4(std::string const &name, int size = 1)
    {
        std::tr1::shared_ptr<vec4_parameter> p(new vec4_parameter(name, size));
        m_vec4_parameters.push_back(p);
        m_parameters.insert(std::make_pair(name, &p->value[0].x));
        return p.get();
    }
    matrix_parameter  *add_matrix(std::string const &name, int size = 1)
    {
        std::tr1::shared_ptr<matrix_parameter> p(new matrix_parameter(name, size));
        m_matrix_parameters.push_back(p);
        m_parameters.insert(std::make_pair(name, &p->value[0].m[0][0]));
        return p.get();
    }

    texture_parameter *add_texture(std::string const &name, int size = 1)
    {
        std::tr1::shared_ptr<texture_parameter> p(new texture_parameter(name, size));
        m_texture_parameters.push_back(p);
        texture_binding *binding = &p->value[0];
        void *v = reinterpret_cast<void *>(binding);
        m_parameters.insert(std::make_pair(name, v));
        //m_parameters.insert(std::make_pair(name, &p->value[0]));
        return p.get();
    }

private:
    std::map<std::string, void *>                           m_parameters;
    std::vector<std::tr1::shared_ptr<uint_parameter> >      m_uint_parameters;
    std::vector<std::tr1::shared_ptr<float_parameter> >     m_float_parameters;
    std::vector<std::tr1::shared_ptr<vec2_parameter> >      m_vec2_parameters;
    std::vector<std::tr1::shared_ptr<vec3_parameter> >      m_vec3_parameters;
    std::vector<std::tr1::shared_ptr<vec4_parameter> >      m_vec4_parameters; 
    std::vector<std::tr1::shared_ptr<matrix_parameter> >    m_matrix_parameters; 
    std::vector<std::tr1::shared_ptr<texture_parameter> >   m_texture_parameters; 
};

}

#endif