stuff-from-scratch/src/graphics/opengl/OpenGlPainter.cpp

#include "OpenGlPainter.h"

#include "DrawingContext.h"
#include "DrawingSurface.h"
#include "Scene.h"
#include "TriMesh.h"

#ifdef _WIN32
#include <windows.h>
#endif

#define GL_GLEXT_PROTOTYPES
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glx.h>

#include <iostream>

const char* vertexShaderSource = "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
    "}\0";


const char* fragmentShaderSource = "#version 330 core\n"
        "out vec4 FragColor;\n"
        "void main()\n"
        "{\n"
        "FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
        "}\n";


OpenGlPainter::OpenGlPainter()
{

}

void OpenGlPainter::initialize()
{
    if (auto context = glXGetCurrentContext())
    {
        std::cout << "has valid context" << std::endl;
    }
    else
    {
        std::cout << "no valid context" << std::endl;
    }

    int major_version{0};
    int minor_version{0};
    glGetIntegerv(GL_MAJOR_VERSION, &major_version);
    glGetIntegerv(GL_MINOR_VERSION, &minor_version);
    std::cout << "Using opengl version " << major_version << "|" << minor_version << std::endl;

    std::cout << "Creating opengl painter" << std::endl;
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, nullptr);
    glCompileShader(vertexShader);

    int  success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if(!success)
    {
        glGetShaderInfoLog(vertexShader, 512, nullptr, infoLog);
        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED: " << std::string(infoLog) << std::endl;

        if (auto errCode = glGetError(); errCode != GL_NO_ERROR)
        {
            auto errString = gluErrorString(errCode);
            std::cout << "Got gl error" << errString << std::endl;
        }
    }
    else
    {
        std::cout << "Shader compiled ok" << std::endl;
        if (auto errCode = glGetError(); errCode != GL_NO_ERROR)
        {
            auto errString = gluErrorString(errCode);
            std::cout << "Got gl error after ok" << errString << std::endl;
        }
    }

    unsigned int fragmentShader;
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, nullptr);
    glCompileShader(fragmentShader);

    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);

    if(!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED: " << infoLog << std::endl;
    }

    mShaderProgram = glCreateProgram();

    glAttachShader(mShaderProgram, vertexShader);
    glAttachShader(mShaderProgram, fragmentShader);
    glLinkProgram(mShaderProgram);

    glGetProgramiv(mShaderProgram, GL_LINK_STATUS, &success);
    if(!success)
    {
        glGetProgramInfoLog(mShaderProgram, 512, NULL, infoLog);
        std::cout << "Shader linking FAILED\n" << infoLog << std::endl;
    }

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    mInitialized = true;
}

void OpenGlPainter::paint(DrawingContext* context)
{
    if (!mInitialized)
    {
        initialize();
    }

    auto surface = context->getSurface();
    const auto width = double(surface->getWidth());
    const auto height = double(surface->getHeight());
    const auto num_mesh = context->getScene()->getNumMeshes();

    glViewport(0, 0, width, height);
    //glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
    //glScissor(0, 0, width, height);
    //glMatrixMode(GL_PROJECTION);
    //glLoadIdentity();

    glClearColor(0.5, 0.5, 1.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);

    //glMatrixMode(GL_MODELVIEW);
   //glLoadIdentity();

    float vertices[] = {
        -0.5f, -0.5f, 0.0f,
         0.5f, -0.5f, 0.0f,
         0.0f,  0.5f, 0.0f
    };
    unsigned int vbo{0};
    glGenBuffers(1, &vbo);

    unsigned int VAO;
    glGenVertexArrays(1, &VAO);
    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    glUseProgram(mShaderProgram);
    glBindVertexArray(VAO);

    glDrawArrays(GL_TRIANGLES, 0, 3);

    /*
    std::cout << "Bounds are : " << width << " | " << height << std::endl;

    for (std::size_t idx=0; idx<num_mesh; idx++)
    {
        auto mesh = context->getScene()->getMesh(idx);
        const auto faces =  mesh->getFaceVertices();
        const auto colors = mesh->getFaceVectorAttributes("Color");

        std::size_t counter{0};
        for (const auto& face : faces)
        {
            const auto r = colors[counter][0];
            const auto g = colors[counter][1];
            const auto b = colors[counter][2];

            glColor3f(r, g, b);

            glBegin(GL_TRIANGLES);
            double x0 = 2.0*face[0].getX()/width - 1.0;
            double y0 = 1.0 - 2.0*face[0].getY()/height;

            double x1 = 2.0*face[1].getX()/width - 1.0;
            double y1 = 1.0 - 2.0*face[1].getY()/height;

            double x2 = 2.0*face[2].getX()/width - 1.0;
            double y2 = 1.0 - 2.0*face[2].getY()/height;

            glVertex3f(x0, y0, 0);
            glVertex3f(x1, y1, 0);
            glVertex3f(x2, y2, 0);

            std::cout << "Verts0| " << x0 << " | " << y0 << " | "<< std::endl;
            std::cout << "Verts1| " << x1 << " | " << y1 << " | "<< std::endl;
            std::cout << "Verts2| " << x2 << " | " << y2 << " | "<< std::endl;
            std::cout << "****************" << std::endl;

            glEnd();

            counter++;
            break;
        }
        break;
    }
    */

    glFlush();
}