SparrowRenderer/sparrowrenderer.cpp

#include <glew/glew.h>
#include <iostream>
#include "sparrowrenderer.h"
#include "glassert.h"
#include "camera.h"
#include "basicmodule.h"

// main methods

void SparrowRenderer::initGL(int width, int height)
{
    glewExperimental = GL_TRUE;
    GLenum err = glewInit();
    if (GLEW_OK != err)
    {
        std::cerr << "Warning: glewInit failed!" << std::endl;
    }
    if (!GLEW_ARB_vertex_program   ||
        !GLEW_ARB_fragment_program ||
        !GLEW_ARB_texture_float    ||
        !GLEW_ARB_draw_buffers     ||
        !GLEW_ARB_framebuffer_object)
    {
        std::cerr << "Warning: Shaders not supported!" << std::endl;
    }

    std::cout << "OpenGL version " << glGetString(GL_VERSION) << std::endl;
    std::cout << "GLSL version " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;

    glAssert(glEnable(GL_DEPTH_TEST));
    glAssert(glEnable(GL_CULL_FACE));
    glAssert(glEnable(GL_TEXTURE_2D));
    resize(width, height);
}

void SparrowRenderer::destroyGL()
{

}

void SparrowRenderer::resize(int width, int height)
{
    glAssert(glViewport(0, 0, width, height));
    camera.resize(width, height);
}

void SparrowRenderer::render()
{
    glAssert(glClearColor(0.60, 0.65, 0.75, 1.0));
    glAssert(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
    for(ModuleNode &m : modules)
    {
        if(m.isEnabled)
            m.module->render(getCamera());
    }
}

// module methods

void SparrowRenderer::addModule(Module* myModule, std::string name)
{
    modules.push_back(ModuleNode(myModule, name));
}

void SparrowRenderer::addModule(Module* myModule, std::string name, int index)
{
    if(index < 0)
        index = 0;
    if(index > modules.size())
        modules.push_back(ModuleNode(myModule, name));
    else
    {
        auto it = modules.begin();
        std::advance(it, index);
        modules.insert(it, ModuleNode(myModule, name));
    }
}

void SparrowRenderer::removeModule(int index)
{
    auto it = modules.begin();
    std::advance(it, index);
    modules.erase(it);
}

void SparrowRenderer::removeModule(std::string name)
{
    modules.erase(getModuleNode(name));
}

Module* SparrowRenderer::getModule(int index)
{
    auto it = modules.begin();
    std::advance(it, index);
    return (*it).module;
}

Module* SparrowRenderer::getModule(std::string name)
{
    return (*getModuleNode(name)).module;
}

std::list<SparrowRenderer::ModuleNode>::iterator SparrowRenderer::getModuleNode(std::string name)
{
    for(auto iterator = modules.begin(); iterator != modules.end(); ++iterator)
    {
        if(iterator->name == name)
            return iterator;
    }
}

int SparrowRenderer::getNbModules()
{
    return modules.size();
}

std::string SparrowRenderer::getModuleName(int index)
{
    auto it = modules.begin();
    std::advance(it, index);
    return (*it).name;
}

void SparrowRenderer::enableModule(std::string name)
{
    (*getModuleNode(name)).isEnabled = true;
}

void SparrowRenderer::enableModule(int index)
{
    auto it = modules.begin();
    std::advance(it, index);
    (*it).isEnabled = true;
}

void SparrowRenderer::disableModule(std::string name)
{
    (*getModuleNode(name)).isEnabled = false;
}

void SparrowRenderer::disableModule(int index)
{
    auto it = modules.begin();
    std::advance(it, index);
    (*it).isEnabled = false;
}

bool SparrowRenderer::isModuleEnabled(std::string name)
{
    return (*getModuleNode(name)).isEnabled;
}

bool SparrowRenderer::isModuleEnabled(int index)
{
    auto it = modules.begin();
    std::advance(it, index);
    return (*it).isEnabled;
}

// camera methods

Camera* SparrowRenderer::getCamera()
{
    return &camera;
}