program.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 PROGRAM_HPP
#define PROGRAM_HPP

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

namespace renderstack {

class program_attribute_not_found_exception
:   public std::exception
{
};

class uniform_not_found_exception
:   public std::exception
{
};

class uniform
{
public:
    uniform(){}
    uniform(std::string const &name, int gl_slot, int size, int gl_type_code)
    :   m_name        (name)
    ,   m_gl_slot     (gl_slot)
    ,   m_size        (size)
    ,   m_gl_type_code(gl_type_code)
    {
    }

    static void         print_source(std::string const &source);

    std::string const   &name       () const { return m_name; }
    int                 gl_slot     () const { return m_gl_slot; } 
    int                 size        () const { return m_size; }
    int                 gl_type_code() const { return m_gl_type_code; } 

private:
    std::string m_name;
    int         m_gl_slot;
    int         m_size;
    int         m_gl_type_code;
};

class program_attribute
{
public:
    program_attribute(
        std::string const   &name, 
        int                 gl_slot, 
        int                 size, 
        int                 gl_type_code
    )
    :   m_name          (name)
    ,   m_gl_slot       (gl_slot)
    ,   m_size          (size)
    ,   m_gl_type_code  (gl_type_code)
    {
    }


    std::string const   &name       () const { return m_name; }
    int                 gl_slot     () const { return m_gl_slot; }
    int                 gl_type_code() const { return m_gl_type_code; } 

    void                debug() const;

private:
    std::string m_name;
    int         m_gl_slot;
    int         m_size;
    int         m_gl_type_code;
};

class shader
{
public:
    shader(
        int                 shader_type,
        std::string const   &source
    );

    std::string const   &source() const { return m_source; }
    int                 gl_shader_object() const { return m_gl_shader_object; } 

    void                print_source() const;

private:
    std::string m_source;
    int         m_gl_shader_object;
};

class program
{
public:
    program();
    program(std::string const &vertex_shader, std::string const &fragment_shader, enum mesh_mode mode);

    void    create ();
    void    set    (std::string const &vertex_shader, std::string const &fragment_shader, enum mesh_mode mode);
    void    link   ();
    int     gl_program_object() const { return m_gl_program_object; }

    void                            set_mesh_mode   (enum mesh_mode mode){ m_mesh_mode = mode; }
    enum mesh_mode                  mesh_mode       () const { return m_mesh_mode; }
    void                            use             () const;
    bool                            has_uniform     (std::string const &name) const;
    bool                            has_attribute   (std::string const &name) const;
    class uniform                   &uniform        (std::string const &name);
    class uniform const             &uniform        (std::string const &name) const;
    class program_attribute         &attribute      (std::string const &name);
    class program_attribute const   &attribute      (std::string const &name) const;
    void                            make_shader     (int shader_type, std::string const &source);

    class attribute_mappings        &attribute_mappings() { return m_attribute_mappings; }
    class attribute_mappings const  &attribute_mappings() const { return m_attribute_mappings; }

private:
    void map_attributes();
    void map_uniforms();

public:
    std::vector<class program_attribute>    m_attributes;
    std::vector<class uniform>              m_uniforms;
    std::vector<class shader>               m_shaders;

    int                                     m_gl_program_object;
    enum mesh_mode                          m_mesh_mode;

    class attribute_mappings                m_attribute_mappings;

};

}

#endif