engineer-thesis-WUT/Engine/engine/draw.cpp

#ifndef DRAW_CPP
#define DRAW_CPP
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include "draw.hpp"
#include "renderLoop.hpp"
#include "shaders.hpp"
#include "constants.hpp"
#include "misc.hpp"

int drawFigure(const bool whatToDraw)
{
    if (whatToDraw)
    {
        if (drawTriangle() == -1)
        {
            print("Error with drawing triangle! ");
            return -1;
        }
    }
    else
    {
        if (drawSquare() == -1)
        {
            print("Error with drawing square! ");
            return -1;
        }
    }
    return 0;
}

int drawSquare()
{
    const std::pair<unsigned int, unsigned int> shaders = compileShaders();
    if (shaders.first == 0 || shaders.second == 0)
        return -1;

    const unsigned int shaderProgram = linkShaderObjectsShaderProgram(shaders.first, shaders.second);
    if (shaderProgram == 0)
        return -1;

    const unsigned int VAO = generateBindVAO();
    copyVerticesMemory(constants::SQUARE_VERTICES, constants::SQUARE_VERTICES_SIZE, GL_ARRAY_BUFFER);
    copyVerticesMemory(constants::SQUARE_INDICES, constants::SQUARE_INDICES_SIZE, GL_ELEMENT_ARRAY_BUFFER);

    // set vertex attribute pointers
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
    glEnableVertexAttribArray(0);

    doDrawElements(shaderProgram, VAO, GL_TRIANGLES, GL_UNSIGNED_INT, std::size(constants::SQUARE_INDICES));
    return 0;
}

void doDrawElements(const unsigned int shaderProgram, const unsigned int vertexArrayObject, const GLenum drawArrayMode, const GLenum drawType, const int numberOfElementsToDraw)
{
    glUseProgram(shaderProgram);
    glBindVertexArray(vertexArrayObject);
    glDrawElements(drawArrayMode, numberOfElementsToDraw, drawType, 0);
    glBindVertexArray(0);
}

int drawTriangle()
{
    const unsigned int vertexBufferObject = copyVerticesMemory(constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, GL_ARRAY_BUFFER);

    const std::pair<unsigned int, unsigned int> shaders = compileShaders();
    if (shaders.first == 0 || shaders.second == 0)
        return -1;

    const unsigned int shaderProgram = linkShaderObjectsShaderProgram(shaders.first, shaders.second);
    if (shaderProgram == 0)
        return -1;

    configureVertexAttribute();
    const unsigned int vertexArrayObject = generateBindVAO();
    copyVerticesArray(vertexBufferObject, constants::TRIANGLE_VERTICES, constants::TRIANGLE_VERTICES_SIZE, GL_ARRAY_BUFFER);

    // set vertex attribute pointers
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
    glEnableVertexAttribArray(0);
    doDrawArrays(shaderProgram, vertexArrayObject, GL_TRIANGLES, 0, 3);
    return 0;
}

void doDrawArrays(const unsigned int shaderProgram, const unsigned int vertexArrayObject, const GLenum drawArrayMode, const int firstIndex, const unsigned int numberOfIndicesToBeRendered)
{
    // use shader program to render an object
    glUseProgram(shaderProgram);
    glBindVertexArray(vertexArrayObject);
    // From left:
    // primitive type we want to draw
    // starting index of vertex array
    // how many vertices we want to draw
    glDrawArrays(drawArrayMode, firstIndex, numberOfIndicesToBeRendered);
}

#endif