buffer.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 BUFFER_HPP
#define BUFFER_HPP

#include "renderstack/rs.h"
#include "renderstack/vertex_format.hpp"
#include <exception>
#include <vector>

namespace renderstack {

class vec2;
class vec3;
class vec4;

class index_out_of_range_exception
:   public std::exception
{
};

class invalid_buffer_stride_exception
:   public std::exception
{
};

class invalid_buffer_gl_target_exception
:   public std::exception
{
public:
    invalid_buffer_gl_target_exception(int gl_target)
    :   m_gl_target(gl_target)
    {
    }

    int gl_target() const { return m_gl_target; }

private:
    int m_gl_target;
};

class buffer
{
public:
    buffer(int gl_target, int gl_usage);
    buffer(int gl_target, int gl_usage, int gl_index_type, int gl_mode);
    ~buffer();

public:
    void                        use             () const;
    class vertex_format         &vertex_format  () { return m_vertex_format; }
    class vertex_format const   &vertex_format  () const { return m_vertex_format; }
    int                         count           () const { return m_count; }
    int                         gl_target       () const { return m_gl_target; }
    int                         gl_usage        () const { return m_gl_usage; }
    unsigned int                gl_buffer_object() const { return m_gl_buffer_object; }
    int                         gl_index_type   () const { return m_gl_index_type; }
    int                         gl_mode         () const { return m_gl_mode; }

public:
    void begin_edit     ();
    void end_edit       (uint32 end_index);

    void set_index      (uint32 index);
    void put_float      (vertex_attribute const &attribute, float x);
    void put_vec2       (vertex_attribute const &attribute, vec2 const &v);
    void put_vec2       (vertex_attribute const &attribute, float x, float y);
    void put_vec3       (vertex_attribute const &attribute, vec3 const &v);
    void put_vec3       (vertex_attribute const &attribute, float x, float y, float z);
    void put_vec4       (vertex_attribute const &attribute, vec4 const &v);
    void put_vec4       (vertex_attribute const &attribute, float x, float y, float z, float w);
    void put_uint16     (vertex_attribute const &attribute, uint16 x);
    void put_uint32     (vertex_attribute const &attribute, uint32 x);
    void put_position   (vec3 const &v, int index = 0);
    void put_position   (float x, float y, float z, int index = 0);
    void put_normal     (vec3 const &v, int index = 0);
    void put_normal     (float x, float y, float z, int index = 0);
    void put_texcoord   (vec2 const &v, int index = 0);
    void put_texcoord   (float s, float t, int index = 0);

    void put_index      (uint32 index_location, uint32 index);
    void point          (uint32 index0);
    void line           (uint32 index0, uint32 index1);
    void triangle       (uint32 index0, uint32 index1, uint32 index2);
    void quad           (uint32 index0, uint32 index1, uint32 index2, uint32 index3);

private:
    class vertex_format m_vertex_format;
    int                 m_count;
    unsigned long       m_size;
    int                 m_gl_target;
    int                 m_gl_usage;
    unsigned int        m_gl_buffer_object;
    int                 m_gl_index_type;
    int                 m_gl_mode;

    std::vector<unsigned char>  m_data;
    uint32                      m_current_index;
    int                         m_stride;

};

}

#endif