buffer.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/rs_gl.h"
#include "renderstack/rs_log.h"
#include "renderstack/buffer.hpp"
#include "renderstack/vec2.hpp"
#include "renderstack/vec3.hpp"
#include "renderstack/vec4.hpp"

namespace renderstack {


buffer::buffer(
    int gl_target, 
    int gl_usage
)
:   m_gl_buffer_object  ((unsigned int)(~0))
,   m_gl_target         (gl_target)
,   m_gl_usage          (gl_usage)
{
    ::rs_gl_gen_buffers(1, &m_gl_buffer_object);
}

buffer::buffer(
    int gl_target, 
    int gl_usage, 
    int gl_index_type, 
    int gl_mode
)
:   m_gl_buffer_object  ((unsigned int)(~0))
,   m_gl_target         (gl_target)
,   m_gl_usage          (gl_usage)
,   m_gl_index_type     (gl_index_type)
,   m_gl_mode           (gl_mode)
{
    ::rs_gl_gen_buffers(1, &m_gl_buffer_object);
}

buffer::~buffer()
{
    ::GLboolean is_buffer = ::rs_gl_is_buffer(m_gl_buffer_object);
    if(is_buffer != GL_FALSE)
    {
        ::rs_gl_delete_buffers(1, &m_gl_buffer_object);
    }
    else
    {
        ::rs_log("glIsBuffer() == GL_FALSE\n");
    }
}

void buffer::begin_edit()
{
    if(m_gl_target == GL_ARRAY_BUFFER)
    {
        m_stride = vertex_format().stride();
    }
    else if(m_gl_target == GL_ELEMENT_ARRAY_BUFFER)
    {
        m_stride = gl_size_of_type(gl_index_type());
    }
    else
    {
        throw invalid_buffer_gl_target_exception(m_gl_target);
    }

    if(m_stride == 0)
    {
        throw invalid_buffer_stride_exception();
    }

    m_current_index = 0;
}

void buffer::end_edit(uint32 end_index)
{
    uint32 current_size = end_index * m_stride;

    if(current_size == 0)
    {
        return;
    }

    m_count = end_index;
    m_size  = current_size;

    ::rs_gl_bind_buffer(
        gl_target(), 
        gl_buffer_object()
    );

    ::rs_gl_buffer_data(
        gl_target(),   /*  gl target       */ 
        current_size,  /*  length          */ 
        &m_data[0],    /*  data pointer    */ 
        gl_usage()     /*  gl usage        */ 
    );

    /*  This will free the memory  */ 
    std::vector<unsigned char> dummy;
    m_data = dummy;
}

void buffer::use() const
{
    ::rs_gl_bind_buffer(
        gl_target(),
        gl_buffer_object()
    );
}


void buffer::set_index(uint32 index)
{
    m_current_index = index;

    size_t offset = m_current_index * m_stride;

    /*  writing for example triangle writes 2 indices past current index  */ 
    if(offset + (4 * m_stride) > m_data.size())
    {
        size_t adjusted_capacity = m_data.size();

        /*  start with initial 32 kB  */ 
        if(adjusted_capacity == 0)
        {
            adjusted_capacity = 32 * 1024;
        }

        while(offset + (4 * m_stride) > adjusted_capacity)
        {
            adjusted_capacity *= 2;
        }
        if(adjusted_capacity != m_data.size())
        {
            m_data.resize(adjusted_capacity);
        }
    }
}

void buffer::put_float(vertex_attribute const &attribute, float x)
{
    size_t  offset   = m_current_index * m_stride + attribute.offset();
    float   *pointer = reinterpret_cast<float*>(&m_data[offset]);

    pointer[0] = x;
}

void buffer::put_vec2(vertex_attribute const &attribute, vec2 const &v)
{
    size_t  offset   = m_current_index * m_stride + attribute.offset();
    float   *pointer = reinterpret_cast<float*>(&m_data[offset]);

    pointer[0] = v.x;
    pointer[1] = v.y;
}

void buffer::put_vec2(vertex_attribute const &attribute, float x, float y)
{
    size_t  offset   = m_current_index * m_stride + attribute.offset();
    float   *pointer = reinterpret_cast<float*>(&m_data[offset]);

    pointer[0] = x;
    pointer[1] = y;
}

void buffer::put_vec3(vertex_attribute const &attribute, vec3 const &v)
{
    size_t  offset   = m_current_index * m_stride + attribute.offset();
    float   *pointer = reinterpret_cast<float*>(&m_data[offset]);

    pointer[0] = v.x;
    pointer[1] = v.y;
    pointer[2] = v.z;
}

void buffer::put_vec3(vertex_attribute const &attribute, float x, float y, float z)
{
    size_t  offset   = m_current_index * m_stride + attribute.offset();
    float   *pointer = reinterpret_cast<float*>(&m_data[offset]);

    pointer[0] = x;
    pointer[1] = y;
    pointer[2] = z;
}

void buffer::put_vec4(vertex_attribute const &attribute, vec4 const &v)
{
    size_t  offset   = m_current_index * m_stride + attribute.offset();
    float   *pointer = reinterpret_cast<float*>(&m_data[offset]);

    pointer[0] = v.x;
    pointer[1] = v.y;
    pointer[2] = v.z;
    pointer[3] = v.w;
}

void buffer::put_vec4(vertex_attribute const &attribute, float x, float y, float z, float w)
{
    size_t  offset   = m_current_index * m_stride + attribute.offset();
    float   *pointer = reinterpret_cast<float*>(&m_data[offset]);

    pointer[0] = x;
    pointer[1] = y;
    pointer[2] = z;
    pointer[3] = w;
}

void buffer::put_uint16(vertex_attribute const &attribute, uint16 x)
{
    size_t  offset   = m_current_index * m_stride + attribute.offset();
    uint16  *pointer = reinterpret_cast<uint16*>(&m_data[offset]);

    pointer[0] = x;
}

void buffer::put_uint32(vertex_attribute const &attribute, uint32 x)
{
    size_t  offset   = m_current_index * m_stride + attribute.offset();
    uint32  *pointer = reinterpret_cast<uint32*>(&m_data[offset]);

    pointer[0] = x;
}

void buffer::put_position(vec3 const &v, int index)
{
    vertex_attribute const &attribute = vertex_format().attribute(
        vertex_attribute_usage_position,
        index
    );

    put_vec3(attribute, v);
}

void buffer::put_position(float x, float y, float z, int index)
{
    vertex_attribute const &attribute = vertex_format().attribute(
        vertex_attribute_usage_position,
        index
    );

    put_vec3(attribute, x, y, z);
}

void buffer::put_normal(vec3 const &v, int index)
{
    vertex_attribute const &attribute = vertex_format().attribute(
        vertex_attribute_usage_normal,
        index
    );

    put_vec3(attribute, v);
}

void buffer::put_normal(float x, float y, float z, int index)
{
    vertex_attribute const &attribute = vertex_format().attribute(
        vertex_attribute_usage_normal,
        index
    );

    put_vec3(attribute, x, y, z);
}

void buffer::put_texcoord(vec2 const &v, int index)
{
    vertex_attribute const &attribute = vertex_format().attribute(
        vertex_attribute_usage_texcoord,
        index
    );

    put_vec2(attribute, v);
}

void buffer::put_texcoord(float s, float t, int index)
{
    vertex_attribute const &attribute = vertex_format().attribute(
        vertex_attribute_usage_texcoord,
        index
    );

    put_vec2(attribute, s, t);
}

void buffer::put_index(uint32 index_location, uint32 index_value)
{
    switch(m_stride)
    {
        case 1:
        {
            size_t    offset   = index_location * m_stride;
            ::GLubyte *pointer = reinterpret_cast<::GLubyte*>(&m_data[offset]);

            if(
                (index_value > 0xff) 
            )
            {
                throw index_out_of_range_exception();
            }

            pointer[0] = static_cast<::GLubyte>(index_value & 0xff);

            break;
        }
        case 2:
        {
            size_t     offset   = index_location * m_stride;
            ::GLushort *pointer = reinterpret_cast<::GLushort*>(&m_data[offset]);

            if(
                (index_value > 0xffff) 
            )
            {
                throw index_out_of_range_exception();
            }

            pointer[0] = static_cast<::GLushort>(index_value & 0xffff);

            break;
        }
        case 4:
        {
            size_t   offset   = index_location * m_stride;
            ::GLuint *pointer = reinterpret_cast<::GLuint*>(&m_data[offset]);

            pointer[0] = index_value;

            break;
        }
        default:
        {
            throw invalid_buffer_stride_exception();
        }
    }
}

void buffer::point(uint32 index0)
{
    put_index(m_current_index, index0);
}

void buffer::line(uint32 index0, uint32 index1)
{
    put_index(m_current_index    , index0);
    put_index(m_current_index + 1, index1);
}

void buffer::triangle(uint32 index0, uint32 index1, uint32 index2)
{
    put_index(m_current_index    , index0);
    put_index(m_current_index + 1, index1);
    put_index(m_current_index + 2, index2);
}

void buffer::quad(uint32 index0, uint32 index1, uint32 index2, uint32 index3)
{
    put_index(m_current_index    , index0);
    put_index(m_current_index + 1, index1);
    put_index(m_current_index + 2, index2);
    put_index(m_current_index + 3, index0);
    put_index(m_current_index + 4, index2);
    put_index(m_current_index + 5, index3);
}

}