vertex_format.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/vertex_format.hpp"
#include "renderstack/rs_gl.h"

namespace renderstack {

int gl_size_of_type(int gl_type_code)
{
    switch(gl_type_code)
    {
        case GL_UNSIGNED_BYTE:  return 1;
        case GL_BYTE:           return 1;
        case GL_UNSIGNED_SHORT: return 2;
        case GL_SHORT:          return 2;
        case GL_UNSIGNED_INT:   return 4;
        case GL_INT:            return 4;
        case GL_FLOAT:          return 4;
        default: throw false;
    }
}

vertex_attribute::vertex_attribute(
    vertex_attribute_usage  usage, 
    int                     gl_type_code, 
    int                     index,
    int                     dimension
)
:   m_usage         (usage)
,   m_gl_type_code  (gl_type_code)
,   m_index         (index)
,   m_dimension     (dimension)
,   m_offset        (-1)
{
}

vertex_attribute_usage vertex_attribute::usage() const
{
    return m_usage;
}

int vertex_attribute::gl_type_code() const
{
    return m_gl_type_code;
}

int vertex_attribute::index() const
{
    return m_index;
}

int vertex_attribute::dimension() const
{
    return m_dimension;
}

int vertex_attribute::offset() const
{
    return m_offset;
}

void vertex_attribute::set_offset(int offset)
{
    m_offset = offset;
}


vertex_format::vertex_format()
:    m_stride(0)
{
}

vertex_format::~vertex_format()
{
}

void vertex_format::append(vertex_attribute &attribute)
{
    int size = gl_size_of_type(attribute.gl_type_code()) * attribute.dimension();

    attribute.set_offset(m_stride);
    m_attributes.push_back(attribute);

    m_stride += size;
}

bool vertex_format::has_attribute(
    vertex_attribute_usage  usage, 
    int                     index
) const
{
    for(
        std::vector<vertex_attribute>::const_iterator i = m_attributes.begin();
        i != m_attributes.end();
        ++i
    )
    {
        vertex_attribute const &attribute = *i;

        if(
            (attribute.usage() == usage) &&
            (attribute.index() == index)
        )
        {
            return true;
        }
    }

    return false;
}

vertex_attribute const &vertex_format::attribute(
    vertex_attribute_usage  usage, 
    int                     index
) const
{
    for(
        std::vector<vertex_attribute>::const_iterator i = m_attributes.begin();
        i != m_attributes.end();
        ++i
    )
    {
        vertex_attribute const &attribute = *i;

        if(
            (attribute.usage() == usage) &&
            (attribute.index() == index)
        )
        {
            return attribute;
        }
    }

    throw vertex_attribute_not_found_exception(usage, index);
}

int vertex_format::stride() const
{
    return m_stride;
}

}