mesh.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 MESH_HPP
#define MESH_HPP

#include "renderstack/rs.h"
#include "renderstack/buffer.hpp"
#include "renderstack/attribute_bindings.hpp"
#include <memory>
#include <map>
#include <exception>

namespace renderstack {

enum mesh_mode
{
    mesh_mode_not_set = 0,
    mesh_mode_polygon_fill,
    mesh_mode_edge_lines,
    mesh_mode_corner_points,
    mesh_mode_corner_normals,
    mesh_mode_polygon_centroids,
    mesh_mode_count
};

class program;

class index_buffer_not_found_exception
:   public std::exception
{
public:
    index_buffer_not_found_exception(enum mesh_mode mode)
    :   m_mesh_mode(mode)
    {
    }
    enum mesh_mode mesh_mode() const { return m_mesh_mode; }

private:
    enum mesh_mode m_mesh_mode;
};

class mesh
{
public:
    mesh(int draw_mode = GL_STATIC_DRAW)
    :   m_enabled_attribute_bindings(NULL)
    {
        m_vertex_buffer.reset(
            new buffer(GL_ARRAY_BUFFER, draw_mode)
        );
    }
    virtual ~mesh()
    {
    }

    void begin(
        class program const &program, 
        enum mesh_mode      mode = mesh_mode_not_set
    );
    void end();

    buffer  * const vertex_buffer  () const { return m_vertex_buffer.get(); } 
    buffer  *vertex_buffer  (){ return m_vertex_buffer.get(); } 
    buffer  *index_buffer   (enum mesh_mode mode);
    buffer  *find_or_create_index_buffer(
        enum mesh_mode  mode,
        int             gl_target, 
        int             gl_usage, 
        int             gl_index_type, 
        int             gl_mode
    );

protected:
    void use(enum mesh_mode mode);
    void apply_attributes(class program const &program, bool enable);

private:
    std::tr1::shared_ptr<buffer>                                m_vertex_buffer;
    std::map<enum mesh_mode, std::tr1::shared_ptr<buffer> >     m_index_buffers;
    std::map<int, std::tr1::shared_ptr<attribute_bindings> >    m_attribute_bindings;
    attribute_bindings                                          *m_enabled_attribute_bindings;
};

}

#endif