MyView.cpp

#include "MyView.hpp"
#include <SceneModel/SceneModel.hpp>
#include <tygra/FileHelper.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <iostream>
#include <cassert>

MyView::MyView() : shaderProgram_(0)
{

}

MyView::~MyView()
{
}

void MyView::setScene(std::shared_ptr<const SceneModel::Context> par1Scene)
{
    scene_ = par1Scene;
}

void MyView::windowViewWillStart(std::shared_ptr<tygra::Window> par1Window)
{
    assert(scene_ != nullptr);

    start_time_ = std::chrono::system_clock::now();

    GLuint vertex_shader = createAndCompileShader("sponza_vs.glsl", "VERTEX_SHADER");
    GLuint fragment_shader = createAndCompileShader("sponza_fs.glsl", "FRAGMENT_SHADER");

    setupProgram(vertex_shader, fragment_shader);

    checkProgramLinkStatus();

    SceneModel::GeometryBuilder builder;
    const auto& source_mesh = builder.getMeshById(309);
    const auto& positions = source_mesh.getPositionArray();
    const auto& elements = source_mesh.getElementArray();
    const auto& normals = source_mesh.getNormalArray();

    glGenBuffers(1, &sponzaMesh_.position_vbo);
    glBindBuffer(GL_ARRAY_BUFFER, sponzaMesh_.position_vbo);
    glBufferData(GL_ARRAY_BUFFER,
                 positions.size() * sizeof(glm::vec3), // size of data in bytes
                 positions.data(), // pointer to the data
                 GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenBuffers(1, &sponzaMesh_.colourvbo_);
    glBindBuffer(GL_ARRAY_BUFFER, sponzaMesh_.colourvbo_);
    glBufferData(GL_ARRAY_BUFFER, positions.size() * sizeof(glm::vec3), positions.data(), GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenBuffers(1, &sponzaMesh_.normalvbo_);
    glBindBuffer(GL_ARRAY_BUFFER, sponzaMesh_.normalvbo_);
    glBufferData(GL_ARRAY_BUFFER, positions.size() * sizeof(glm::vec3), positions.data(), GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenBuffers(1, &sponzaMesh_.element_vbo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sponzaMesh_.element_vbo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,
        elements.size() * sizeof(unsigned int),
        elements.data(),
        GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    sponzaMesh_.element_count = elements.size();

    glGenVertexArrays(1, &sponzaMesh_.vao);
    glBindVertexArray(sponzaMesh_.vao);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sponzaMesh_.element_vbo);
    glBindBuffer(GL_ARRAY_BUFFER, sponzaMesh_.position_vbo);
    glBindBuffer(GL_ARRAY_BUFFER, sponzaMesh_.colourvbo_);
    glBindBuffer(GL_ARRAY_BUFFER, sponzaMesh_.normalvbo_);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
        sizeof(glm::vec3), TGL_BUFFER_OFFSET(0));
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,
        sizeof(glm::vec3), TGL_BUFFER_OFFSET(0));
    glEnableVertexAttribArray(2);
    glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE,
        sizeof(glm::vec3), TGL_BUFFER_OFFSET(0));
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
}

void MyView::windowViewDidReset(std::shared_ptr<tygra::Window> par1Window, int par2Width, int par3Height)
{
    glViewport(0, 0, par2Width, par3Height);
}

void MyView::windowViewDidStop(std::shared_ptr<tygra::Window> par1Window)
{
    cleanupBeforeClosing();
}

void MyView::windowViewRender(std::shared_ptr<tygra::Window> par1Window)
{
    assert(scene_ != nullptr);

    //glEnable(GL_DEPTH_TEST);
    //glEnable(GL_CULL_FACE);

    glClearColor(0.f, 0.f, 0.25f, 0.f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    GLint viewport_size[4];
    glGetIntegerv(GL_VIEWPORT, viewport_size);
    const float aspect_ratio = viewport_size[2] / (float)viewport_size[3];

    glm::mat4 projection_xform = glm::perspective(75.f, aspect_ratio, 1.0f, 1000.f);
    glm::mat4 view_xform = glm::lookAt(scene_->getCamera().getPosition(), scene_->getCamera().getDirection(), glm::vec3(0, 1, 0));
    glm::mat4 model_xform = glm::translate(glm::mat4(1.0),glm::vec3(0, 0, 0));

    glm::mat4 combined_xform = projection_xform * view_xform * model_xform;
    //glm::mat4 combined_xform = model_xform * view_xform * projection_xform;

    //Uniforms

    GLuint model_xform_id = glGetUniformLocation(shaderProgram_,"model_xform");
    glUniformMatrix4fv(model_xform_id, 1, GL_FALSE, glm::value_ptr(combined_xform));

    glUseProgram(shaderProgram_);

    glBindVertexArray(sponzaMesh_.vao);

    glDrawElements(GL_TRIANGLES, sponzaMesh_.element_count, GL_UNSIGNED_INT, 0);
}

GLuint MyView::createAndCompileShader(std::string par1ShaderFileName, std::string par2Type)
{
    GLint compile_status = 0;
    GLuint result;

    if (par2Type == "VERTEX_SHADER")
    {
        GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
        std::string vertex_shader_string = tygra::stringFromFile(par1ShaderFileName); //"first_vs.glsl"
        const char* vertex_shader_code = vertex_shader_string.c_str();
        glShaderSource(vertex_shader, 1, (const GLchar **)&vertex_shader_code, NULL);
        glCompileShader(vertex_shader);
        glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &compile_status);
        if (compile_status != GL_TRUE)
        {
            const int string_length = 1024;
            GLchar log[string_length] = "";
            glGetShaderInfoLog(vertex_shader, string_length, NULL, log);
            std::cerr << log << std::endl;
        }

        result = vertex_shader;
    }

    if (par2Type == "FRAGMENT_SHADER")
    {
        GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
        std::string fragment_shader_string = tygra::stringFromFile(par1ShaderFileName); //"first_fs.glsl"
        const char* fragment_shader_code = fragment_shader_string.c_str();
        glShaderSource(fragment_shader, 1, (const GLchar **)&fragment_shader_code, NULL);
        glCompileShader(fragment_shader);
        glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &compile_status);

        if (compile_status != GL_TRUE)
        {
            const int string_length = 1024;
            GLchar log[string_length] = "";
            glGetShaderInfoLog(fragment_shader, string_length, NULL, log);
            std::cerr << log << std::endl;
        }

        result = fragment_shader;
    }

    return result;
}

void MyView::setupProgram(GLuint par1VertexShader, GLuint par2FragmentShader)
{
    shaderProgram_ = glCreateProgram();

    glAttachShader(shaderProgram_, par1VertexShader);

    glBindAttribLocation(shaderProgram_, 0, "vertex_position");
    glBindAttribLocation(shaderProgram_, 1, "vertex_colour");
    glBindAttribLocation(shaderProgram_, 2, "vertex_normal");

    glDeleteShader(par1VertexShader);

    glAttachShader(shaderProgram_, par2FragmentShader);
    glBindFragDataLocation(shaderProgram_, 0, "fragment_colour");
    glDeleteShader(par2FragmentShader);

    glLinkProgram(shaderProgram_);
}

void MyView::checkProgramLinkStatus()
{
    GLint link_status = 0;
    glGetProgramiv(shaderProgram_, GL_LINK_STATUS, &link_status);
    if (link_status != GL_TRUE)
    {
        const int string_length = 1024;
        GLchar log[string_length] = "";
        glGetProgramInfoLog(shaderProgram_, string_length, NULL, log);
        std::cerr << log << std::endl;
    }
}

void MyView::cleanupBeforeClosing()
{
    glDeleteProgram(shaderProgram_);
    glDeleteBuffers(1, &sponzaMesh_.position_vbo);
    glDeleteBuffers(1, &sponzaMesh_.element_vbo);
    glDeleteBuffers(1, &sponzaMesh_.colourvbo_);
    glDeleteVertexArrays(1, &sponzaMesh_.vao);
}