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

namespace renderstack {

void program_attribute::debug() const
{
    ::rs_log(
        "attribute %s type %s size %d slot %d\n",
        &m_name[0],
        ::rs_gl_enum_string(m_gl_type_code),
        m_size,
        m_gl_slot
    );
}

void shader::print_source() const
{
    int         line = 1;
    const char  *head = m_source.c_str();
    char        c;

    ::rs_log("%3d: ", line);
    for(;;)
    {
        c = *head;
        ++head;
        if(c == 0)
        {
            break;
        }
        if(c == '\n')
        {
            ++line;
            ::rs_log("\n%3d: ", line);
            continue;
        }
        ::rs_log("%c", c);
    }
}

shader::shader(
    int                 shader_type,
    std::string const   &source
)
:   m_source(source)
,   m_gl_shader_object((int)(~0))
{
    int         status;
    const char  *source0     = m_source.c_str();
    const char  **source_ptr = &source0;

    m_gl_shader_object = ::rs_gl_create_shader(shader_type);

    ::rs_gl_shader_source (m_gl_shader_object, 1, source_ptr, NULL);
    ::rs_gl_compile_shader(m_gl_shader_object);
    ::rs_gl_get_shader_iv (m_gl_shader_object, GL_COMPILE_STATUS, &status);

    if(status == GL_FALSE)
    {
        char      info_log[4096];
        ::GLsizei length = 0;

        ::memset(&info_log[0], 0, 4096);

        ::rs_gl_get_shader_info_log(m_gl_shader_object, 4096, &length, &info_log[0]);
        ::rs_gl_delete_shader      (m_gl_shader_object);

        ::rs_log("shader compilation failed:\n%s", info_log);

        print_source();
        ::rs_log("\nerrors\n");
    }
}

void program::make_shader(
    int                shader_type,
    std::string const &source
)
{
    class shader shader(shader_type, source);
    ::rs_gl_attach_shader(m_gl_program_object, shader.gl_shader_object());

    /*  calls copy constructor  */ 
    m_shaders.push_back(shader);
}

program::program()
:   m_mesh_mode(mesh_mode_polygon_fill)
,   m_gl_program_object((int)(~0))
{
    m_gl_program_object = (int)(~0);
}

program::program(
    std::string const   &vertex_shader_source,
    std::string const   &fragment_shader_source,
    enum mesh_mode      mode
)
:   m_mesh_mode(mode)
,   m_gl_program_object((int)(~0))
{
    create();
    make_shader(GL_VERTEX_SHADER,    vertex_shader_source);
    make_shader(GL_FRAGMENT_SHADER,  fragment_shader_source);
    link();
}

void program::set(
    std::string const &vertex_shader, 
    std::string const &fragment_shader, 
    enum mesh_mode mode
)
{
    m_mesh_mode = mode;
    create();
    make_shader(GL_VERTEX_SHADER,    vertex_shader);
    make_shader(GL_FRAGMENT_SHADER,  fragment_shader);
    link();
}

void program::create()
{
    ::GLboolean is_program = ::rs_gl_is_program(m_gl_program_object);
    if(is_program != GL_FALSE)
    {
        ::rs_gl_delete_program(m_gl_program_object);
    }
    m_gl_program_object = ::rs_gl_create_program();
}

void program::link()
{
    int link_status;
    ::rs_gl_link_program  (m_gl_program_object);
    ::rs_gl_get_program_iv(m_gl_program_object, GL_LINK_STATUS, &link_status);

    if(link_status == GL_FALSE)
    {
        char      info_log[4096];
        ::GLsizei length = 0;

        ::memset(&info_log[0], 0, 4096);

        ::rs_gl_get_program_info_log(m_gl_program_object, 4096, &length, &info_log[0]);
        ::rs_gl_delete_program(m_gl_program_object);

        ::rs_log("program linking failed:\n%s", info_log);
    }
    ::rs_gl_use_program(m_gl_program_object);
    map_attributes();
    map_uniforms();
}

void program::map_attributes()
{
    int i;

    int attribute_count = 0;

    ::rs_gl_get_program_iv(m_gl_program_object, GL_ACTIVE_ATTRIBUTES, &attribute_count);

    for(i = 0; i < attribute_count; ++i)
    {
        ::GLint   size;
        ::GLenum  gl_type_code;
        ::GLchar  name[RS_NAME_LENGTH];

        ::rs_gl_get_active_attrib(
            m_gl_program_object,    /*  GLuint  program  */ 
            i,                      /*  GLuint  index    */ 
            RS_NAME_LENGTH,         /*  GLsizei bufSize  */ 
            NULL,                   /*  GLsizei *length  */ 
            &size,                  /*  GLint   *size    */ 
            &gl_type_code,          /*  GLenum  *type    */ 
            &name[0]                /*  GLchar  *name    */ 
        );

        ::GLint gl_slot = ::rs_gl_get_attrib_location(m_gl_program_object, &name[0]);

        program_attribute attribute(name, gl_slot, size, gl_type_code);

        /*  calls copy constructor  */ 
        m_attributes.push_back(attribute);
    }
}

void program::map_uniforms()
{
    int uniform_count = 0;

    ::rs_gl_get_program_iv(m_gl_program_object, GL_ACTIVE_UNIFORMS, &uniform_count);

    for(int i = 0; i < uniform_count; ++i)
    {
        ::GLint   size;
        ::GLenum  gl_type_code;
        ::GLchar  name[RS_NAME_LENGTH];

        ::rs_gl_get_active_uniform(
            m_gl_program_object, 
            i, 
            RS_NAME_LENGTH, 
            NULL, 
            &size, 
            &gl_type_code, 
            &name[0]
        );

        ::GLint gl_slot = ::rs_gl_get_uniform_location(m_gl_program_object, &name[0]);

        class uniform uniform(name, gl_slot, size, gl_type_code);

        m_uniforms.push_back(uniform);
    }
}

void program::use() const
{
    ::rs_gl_use_program(m_gl_program_object);
}

bool program::has_attribute(std::string const &name) const
{
    for(
        std::vector<program_attribute>::const_iterator i = m_attributes.begin(); 
        i != m_attributes.end();
        ++i
    )
    {
        program_attribute const &attribute = *i;
        int diff = attribute.name().compare(name);

        if(diff == 0)
        {
            return true;
        }
    }

    return false;
}

program_attribute const &program::attribute(std::string const &name) const
{
    for(
        std::vector<program_attribute>::const_iterator i = m_attributes.begin(); 
        i != m_attributes.end();
        ++i
    )
    {
        program_attribute const &attribute = *i;
        int diff = attribute.name().compare(name);

        if(diff == 0)
        {
            return attribute;
        }
    }

    throw program_attribute_not_found_exception();
}

program_attribute &program::attribute(std::string const &name)
{
    for(
        std::vector<program_attribute>::iterator i = m_attributes.begin(); 
        i != m_attributes.end();
        ++i
    )
    {
        program_attribute &attribute = *i;
        int diff = attribute.name().compare(name);

        if(diff == 0)
        {
            return attribute;
        }
    }

    throw program_attribute_not_found_exception();
}

bool program::has_uniform(std::string const &name) const
{
    for(
        std::vector<class uniform>::const_iterator i = m_uniforms.begin(); 
        i != m_uniforms.end();
        ++i
    )
    {
        class uniform const& uniform = *i;
        int diff = uniform.name().compare(name);

        if(diff == 0)
        {
            return true;
        }
    }

    return false;
}

uniform const &program::uniform(std::string const &name) const
{
    for(
        std::vector<class uniform>::const_iterator i = m_uniforms.begin(); 
        i != m_uniforms.end();
        ++i
    )
    {
        class uniform const &uniform = *i;
        int diff = uniform.name().compare(name);

        if(diff == 0)
        {
            return uniform;
        }
    }

    throw uniform_not_found_exception();
}

uniform &program::uniform(std::string const &name)
{
    for(
        std::vector<class uniform>::iterator i = m_uniforms.begin(); 
        i != m_uniforms.end();
        ++i
    )
    {
        class uniform &uniform = *i;
        int diff = uniform.name().compare(name);

        if(diff == 0)
        {
            return uniform;
        }
    }

    throw uniform_not_found_exception();
}

}