QuadTextured.cpp

Go to the documentation of this file.

#include "QuadTextured.h"

using namespace vis2;

QuadTextured::QuadTextured(glm::mat4 _modelMatrix, ShaderController* _shader_ctrl, bool _b_fill_window)
    :   DrawableObject(_modelMatrix), shader_ctrl(_shader_ctrl), b_fill_window(_b_fill_window),
        vao_handle(0), vao_setup_done(false),
        position_buffer_handle(0), normal_buffer_handle(0), uv_buffer_handle(0), index_buffer_handle(0)
{
    // ------------------------- 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
    if (b_fill_window)
        glBufferData(GL_ARRAY_BUFFER, QUAD_TEXTURED_VERTEX_COUNT * 3 * sizeof(float), generic_positions_full, GL_STATIC_DRAW); // load data
    else
        glBufferData(GL_ARRAY_BUFFER, QUAD_TEXTURED_VERTEX_COUNT * 3 * sizeof(float), generic_positions, 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, QUAD_TEXTURED_VERTEX_COUNT * 3 * sizeof(float), generic_normlas, 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, QUAD_TEXTURED_VERTEX_COUNT * 2 * sizeof(float), generic_uv, 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, QUAD_TEXTURED_INDEX_COUNT * sizeof(unsigned int), generic_indices, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);

    // ------------------------- BIND VBOs to VAO ----------------------------------- //
    int success = shader_ctrl->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 QuadTextured !" << std::endl;
        system("PAUSE");
        exit(-1);
    }
    vao_handle = shader_ctrl->getVAOHandle();
    vao_setup_done = true;

}

QuadTextured::~QuadTextured()
{
    // 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(1,&vao_handle);
}


void QuadTextured::update(double _deltaT)
{
}

void QuadTextured::draw(glm::mat4 & _projectionMatrix)
{
    draw(_projectionMatrix, glm::vec3(0.0f, 0.0f, 0.0f));
}

void QuadTextured::draw(glm::mat4 & _projectionMatrix, glm::vec3 _edge_color)
{
    if (!vao_setup_done)
        return;

    // activate shader
    this->shader_ctrl->shader_Ptr->useShader();
    // setup of Uniforms
    int success = this->shader_ctrl->updateShaderUniforms(_projectionMatrix, this->modelMatrix, glm::vec3(0.0f, 0.0f, 0.0f), _edge_color);
    if (success != VIS2_SHADER_UNIFORMS_SETUP_SUCCESS)
    {
        std::cout << "Failed to update uniforms for QuadTextured!" << std::endl;
        return;
    }

    // activate vao
    glBindVertexArray(vao_handle);
    // place draw call with the vao above
    glDrawElements(GL_TRIANGLES, QUAD_TEXTURED_INDEX_COUNT, GL_UNSIGNED_INT,0);
    // deactivate vao
    glBindVertexArray(0);

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


// ------------------- the static arrays --------------------------- //

const float QuadTextured::generic_positions[QUAD_TEXTURED_VERTEX_COUNT * 3] =
{
    0.0f, 0.0f, 0.1f,
    0.0f, 0.5f, 0.1f,
    0.5f, 0.0f, 0.1f,
    0.5f, 0.5f, 0.1f
};

const float QuadTextured::generic_positions_full[QUAD_TEXTURED_VERTEX_COUNT * 3] =
{
    0.0f, 0.0f, 0.0f,
    0.0f, 1.0f, 0.0f,
    1.0f, 0.0f, 0.0f,
    1.0f, 1.0f, 0.0f
};

const float QuadTextured::generic_normlas[QUAD_TEXTURED_VERTEX_COUNT * 3] =
{
    0.0f, 0.0f, 1.0f,
    0.0f, 0.0f, 1.0f,
    0.0f, 0.0f, 1.0f,
    0.0f, 0.0f, 1.0f
};

const float QuadTextured::generic_uv[QUAD_TEXTURED_VERTEX_COUNT * 2] =
{
    0.0f, 1.0f,
    0.0f, 0.0f,
    1.0f, 1.0f,
    1.0f, 0.0f
};

const unsigned int QuadTextured::generic_indices[QUAD_TEXTURED_INDEX_COUNT] =
{
    0, 3, 2,
    0, 1, 3
};