attribute_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 ATTRIBUTE_BINDINGS_HPP
#define ATTRIBUTE_BINDINGS_HPP

#include "renderstack/rs.h"
#include "renderstack/rs_gl.h"
#include <memory>
#include <vector>
#include <string>
#include <map>

namespace renderstack {

struct attribute_mapping;
struct attribute_binding;
class attribute_mappings;
class attribute_bindings;

struct attribute_mapping
{
    attribute_mapping(
        std::string const           &name_,
        enum vertex_attribute_usage usage_,
        int                         index_,         /*  0, 1, ...  */ 
        int                         dimension_      /*  1  -> float, 2 -> vec2, 3 -> vec3, 4 -> vec4  */ 
    )
    :   name        (name_)
    ,   usage       (usage_)
    ,   index       (index_)
    ,   dimension   (dimension_)
    {
    }

    std::string                 name;
    enum vertex_attribute_usage usage;
    int                         index;
    int                         dimension;
};

class attribute_mappings
{
public:
    void insert(
        std::string const           &name,          /*  name in source code  */ 
        enum vertex_attribute_usage usage,          /*  TODO replace with a string  */ 
        int                         index,
        int                         dimension
    )
    {
        std::tr1::shared_ptr<attribute_mapping> m(
            new attribute_mapping(name, usage, index, dimension)
        );
        m_mappings.push_back(m);
    }

    void bind_attributes(
        class attribute_bindings    &bindings,
        class program const         &program, 
        class mesh const            &mesh
    ) const;

private:
    std::vector<std::tr1::shared_ptr<attribute_mapping> > m_mappings;
};

struct attribute_binding
{
    attribute_binding(
        unsigned int    index_,
        int             size_,
        int             type_,
        unsigned char   normalized_,
        int             stride_,
        void const      *pointer_
    )
    :   index       (index_)
    ,   size        (size_)
    ,   type        (type_)
    ,   normalized  (normalized_)
    ,   stride      (stride_)
    ,   pointer     (pointer_)
    {
    }

    unsigned int    index;
    int             size;
    int             type;
    unsigned char   normalized;
    int             stride;
    void const      *pointer;
};

class attribute_bindings
{
public:
    void add(
        unsigned int    index,          /*  slot   */ 
        int             size,           /*  count  */ 
        int             type,
        unsigned char   normalized,
        int             stride,
        void const      *pointer
    )
    {
        attribute_binding binding(index, size, type, normalized, stride, pointer);
        m_bindings.push_back(binding);
    }

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

            if(enable == true)
            {
                if(
                    (binding.type == GL_UNSIGNED_SHORT) ||
                    (binding.type == GL_UNSIGNED_INT)   
                )
                {
                    ::rs_gl_vertex_attrib_i_pointer(
                        binding.index,
                        binding.size,
                        binding.type,
                        binding.stride,
                        binding.pointer
                    );
                }
                else
                {
                    ::rs_gl_vertex_attrib_pointer(
                        binding.index,
                        binding.size,
                        binding.type,
                        binding.normalized,
                        binding.stride,
                        binding.pointer
                    );
                }
                ::rs_gl_enable_vertex_attrib_array(binding.index);
            }
            else
            {
                ::rs_gl_disable_vertex_attrib_array(binding.index);
            }
        }
    }

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

}

#endif