mesh.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/mesh.hpp"
#include "renderstack/program.hpp"

namespace renderstack {

buffer *mesh::index_buffer(enum mesh_mode mode)
{
    std::map<
        enum mesh_mode, 
        std::tr1::shared_ptr<buffer>
    >::const_iterator i = m_index_buffers.find(mode);

    if(i != m_index_buffers.end())
    {
        std::tr1::shared_ptr<buffer> buffer = (*i).second;
        return buffer.get();
    }

    throw index_buffer_not_found_exception(mode);
}

buffer *mesh::find_or_create_index_buffer(
    enum mesh_mode  mode,
    int             gl_target, 
    int             gl_usage, 
    int             gl_index_type, 
    int             gl_mode
)
{
    std::map<
        enum mesh_mode, 
        std::tr1::shared_ptr<buffer>
    >::const_iterator i = m_index_buffers.find(mode);

    if(i != m_index_buffers.end())
    {
        std::tr1::shared_ptr<buffer> buffer = (*i).second;
        return buffer.get();
    }

    std::tr1::shared_ptr<buffer> b(
        new buffer(gl_target, gl_usage, gl_index_type, gl_mode)
    );
    m_index_buffers.insert(
        std::make_pair(
            mode, 
            b
        )
    );
    return b.get();
}

void mesh::apply_attributes(class program const &program, bool enable)
{
    int gl_program_object = program.gl_program_object();

    std::map<int, std::tr1::shared_ptr<attribute_bindings> >::const_iterator i = m_attribute_bindings.find(gl_program_object);
    if(i != m_attribute_bindings.end())
    {
        std::tr1::shared_ptr<attribute_bindings> bindings = (*i).second;
        bindings->apply(enable);
        m_enabled_attribute_bindings = bindings.get();
    }
    else
    {
        std::tr1::shared_ptr<attribute_bindings> bindings(
            new attribute_bindings()
        );
        m_attribute_bindings.insert(
            std::make_pair(
                gl_program_object,
                bindings
            )
        );
        program.attribute_mappings().bind_attributes(
            *bindings,
            program,
            *this
        );
        bindings->apply(enable);
        m_enabled_attribute_bindings = bindings.get();
    }
}

void mesh::begin(
    class program const &program,
    enum mesh_mode      mode
)
{
    vertex_buffer()->use();
    if(mode == mesh_mode_not_set)
    {
        mode = program.mesh_mode();
    }
    index_buffer(mode)->use();
    apply_attributes(program, true);
}

void mesh::end()
{
    if(m_enabled_attribute_bindings != NULL)
    {
        m_enabled_attribute_bindings->apply(false);
        m_enabled_attribute_bindings = NULL;
    }
}

}