ModelMultiTextured.cpp

Go to the documentation of this file.

#include <stdexcept>
#include <iostream>
#include "ModelMultiTextured.h"

using namespace vis2;

// %%%%%%%%%%%%%%%%%%%%%%%%%%% CONSTRUCTOR & DESTRUCTOR %%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

ModelMultiTextured::ModelMultiTextured( const char* _id_name,
                                        const glm::vec3 _id_color,
                                        const glm::vec3 _contour_color,
                                        glm::mat4 & _modelMatrix,
                                        LoaderOBJ* _loader,
                                        ShaderController* _shader_controller)
    :   DrawableObject(_modelMatrix),
        id_name(_id_name),
        id_color(_id_color),
        contour_color(_contour_color),
        loader_Ptr(_loader),
        index_count(0),
        position_buffer_handle(0), normal_buffer_handle(0), uv_buffer_handle(0), index_buffer_handle(0) 
{
    shader_ctrl[0] = _shader_controller;
    vao_handle[0] = 0; vao_handle[1] = 0; vao_handle[2] = 0;
    vao_setup_done[0] = false; vao_setup_done[1] = false; vao_setup_done[2] = false;

    // ------------------------- LOAD GEOMETRY ------------------------------- //

    if (!loader_Ptr)
    {
        std::cout << "Geometry loader for object \"" << this->id_name << "\" invalid!" << std::endl;
        system("PAUSE");
        exit(-1);
    }
    
    loader_Ptr->obj2Container(); // parse the OBJ file
    const GLfloat* _positions_Ptr = loader_Ptr->vert_positions;
    const GLfloat* _normals_Ptr = loader_Ptr->vert_normals;
    const GLfloat* _uv_Ptr = loader_Ptr->vert_uvs;
    const GLuint* _index_Ptr = loader_Ptr->face_ind;
    const unsigned int _vertex_count = loader_Ptr->getNrVertices();
    const unsigned int _face_ind_count = loader_Ptr->getNrFaceInd();
    index_count = _face_ind_count;

    // ------------------------- LOAD VBOs ----------------------------------- //

    // load positions to buffer
    glGenBuffers(1,&position_buffer_handle); // takes n, array of handles as well
    glBindBuffer(GL_ARRAY_BUFFER, position_buffer_handle); //activate buffer
    glBufferData(GL_ARRAY_BUFFER, _vertex_count * 3 * sizeof(float), _positions_Ptr, GL_STATIC_DRAW); // load data
    glBindBuffer(GL_ARRAY_BUFFER,0); // deactivate buffer

    // load normals to buffer
    glGenBuffers(1,&normal_buffer_handle);
    glBindBuffer(GL_ARRAY_BUFFER, normal_buffer_handle);
    glBufferData(GL_ARRAY_BUFFER, _vertex_count * 3 * sizeof(float), _normals_Ptr, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER,0);

    // load texture coordinates to buffer
    glGenBuffers(1,&uv_buffer_handle);
    glBindBuffer(GL_ARRAY_BUFFER, uv_buffer_handle);
    glBufferData(GL_ARRAY_BUFFER, _vertex_count * 2 * sizeof(float), _uv_Ptr, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER,0);

    // load face indices to buffer
    glGenBuffers(1,&index_buffer_handle);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_handle);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, _face_ind_count * sizeof(unsigned int), _index_Ptr, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);

    // ------------------------- BIND VBOs to VAO ----------------------------------- //
    // ------------- this section needs to be repeated for each shader --------------- //
    int success = shader_ctrl[0]->setupShaderInVars(    position_buffer_handle,
                                                    normal_buffer_handle,
                                                    uv_buffer_handle,
                                                    index_buffer_handle);   
    if (success != VIS2_SHADER_INVARS_SETUP_SUCCESS)
    {
        std::cout << "Failed to set up the shader program for object \"" << this->id_name << "\" !" << std::endl;
        system("PAUSE");
        exit(-1);
    }
    vao_handle[0] = shader_ctrl[0]->getVAOHandle();
    vao_setup_done[0] = true;

}

ModelMultiTextured::~ModelMultiTextured()
{
    // first VBOs, then VAOs !!!
    glDeleteBuffers(1,&position_buffer_handle);
    glDeleteBuffers(1,&normal_buffer_handle);
    glDeleteBuffers(1,&uv_buffer_handle);
    glDeleteBuffers(1,&index_buffer_handle);

    glDeleteVertexArrays(3, vao_handle);
}

// %%%%%%%%%%%%%%%%%%%%%% ASSIGN CLASS ELEMENTS, UPDATE AND DRAW %%%%%%%%%%%%%%%%%%%% //

void ModelMultiTextured::update(double _deltaT)
{
}

void ModelMultiTextured::draw(glm::mat4 & _projectionMatrix)
{

    if (!vao_setup_done[0])
        return;

    // activate STANDARD shader
    this->shader_ctrl[0]->shader_Ptr->useShader();
    // setup of Uniforms
    int success = this->shader_ctrl[0]->updateShaderUniforms(_projectionMatrix, this->modelMatrix, this->id_color, this->contour_color);
    if (success != VIS2_SHADER_UNIFORMS_SETUP_SUCCESS)
        return;

    // activate vao
    glBindVertexArray(vao_handle[0]);
    // place draw call with the vao above
    glDrawElements(GL_TRIANGLES, this->index_count, GL_UNSIGNED_INT,0);
    // deactivate vao
    glBindVertexArray(0);

    // deactivate shader
    this->shader_ctrl[0]->shader_Ptr->releaseShader();

}

void ModelMultiTextured::assignShaderController(ShaderController* _shader_ctrl, const unsigned int _slot)
{
    if (!_shader_ctrl || (_slot != 1 && _slot != 2))
        return;

    int success = 0;
    this->shader_ctrl[_slot] = _shader_ctrl;
    success = this->shader_ctrl[_slot]->setupShaderInVars(  position_buffer_handle,
                                                            normal_buffer_handle,
                                                            uv_buffer_handle,
                                                            index_buffer_handle);
    if (success != VIS2_SHADER_INVARS_SETUP_SUCCESS)
    {
        std::cout << "Failed to set up the color ID shader program for object \"" << this->id_name << "\" !" << std::endl;
    }
    else
    {
        vao_handle[_slot] = shader_ctrl[_slot]->getVAOHandle();
        vao_setup_done[_slot] = true;
    }
}

void ModelMultiTextured::updateModelMatrix(glm::mat4 & _modelMatrix)
{
    this->modelMatrix = _modelMatrix;
}

void ModelMultiTextured::draw(glm::mat4 & _projectionMatrix, const unsigned int _slot)
{

    if ((_slot != 0 && _slot != 1 && _slot != 2) || !vao_setup_done[_slot])
        return;

    // activate shader
    this->shader_ctrl[_slot]->shader_Ptr->useShader();
    // setup of Uniforms
    int success = this->shader_ctrl[_slot]->updateShaderUniforms(_projectionMatrix, this->modelMatrix, this->id_color, this->contour_color);
    if (success != VIS2_SHADER_UNIFORMS_SETUP_SUCCESS)
        return;

    // activate vao
    glBindVertexArray(vao_handle[_slot]);
    // place draw call with the vao above
    glDrawElements(GL_TRIANGLES, this->index_count, GL_UNSIGNED_INT,0);
    // deactivate vao
    glBindVertexArray(0);

    // deactivate shader
    this->shader_ctrl[_slot]->shader_Ptr->releaseShader();
        
}