Application.cpp

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <string>
#include <iostream>
#include <sstream>
#include <fstream>

#include "Renderer.h"
#include "VertexBuffer.h"
#include "IndexBuffer.h"
#include "VertexArray.h"
#include "Shader.h"
#include "VertexBufferLayout.h"
#include "Texture.h"
#include "Res/Vendor/glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"

#include "gui/imgui.h"
#include "gui/imgui_impl_glfw.h"
#include "gui/imgui_impl_opengl3.h"
#include "Tests/TestClearColor.h"

#include <chrono>

class Timer
{
public:
    Timer() : m_StartTimepoint(std::chrono::high_resolution_clock::now()) {}

    ~Timer()
    {
        Stop();
    }

    void Stop()
    {
        auto endTimepoint = std::chrono::high_resolution_clock::now();
        auto start = std::chrono::time_point_cast<std::chrono::microseconds>(m_StartTimepoint).time_since_epoch().count();
        auto end = std::chrono::time_point_cast<std::chrono::microseconds>(endTimepoint).time_since_epoch().count();

        auto duration = end - start;
        double ms = duration * 0.001;

        std::cout << "Duration: " << duration << "us (" << ms << "ms)\n";
    }

private:
    std::chrono::time_point<std::chrono::high_resolution_clock> m_StartTimepoint;
};

//#include "gui/imgui_impl_opengl3_loader.h"

int main(void)
{   

    Timer timer;
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(960, 540, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    
    glfwMakeContextCurrent(window);
    glfwSwapInterval(1);
    glewInit();
    {

        //GLCall(glClearColor(1,1,1, 0));
        /*float positions[] = {
            -50.0f, -50.0f,  0.0f,  0.0f,
            50.0f, -50.0f,  1.0f,  0.0f,
            50.0f, 50.0f,  1.0f,  1.0f,
            -50.0f, 50.0f,  0.0f,  1.0f
        };

        unsigned int indices[] = {
            0, 3, 2,
            2, 1, 0
        };*/

        GLCall(glEnable(GL_BLEND));
        GLCall(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
        //GLCall(glBlendEquation(GL_FUNC_SUBTRACT));

        /*VertexArray va;
        VertexBuffer vb(positions, 4 * 4 * sizeof(float));

        VertexBufferLayout layout;
        layout.Push<float>(2);
        layout.Push<float>(2);
        va.addBuffer(vb, layout);

        glm::mat4 proj = glm::ortho(0.0f, 960.0f, 0.0f, 540.0f, -1.0f, 1.0f);
        glm::mat4 view = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f));
        
        IndexBuffer ib(indices, 6);

        Shader shader("Res/Shader/Basic.shader");
        shader.Bind();

        shader.setUniform4f("u_Color", 1.0f, 1.0f, 0.0f, 1.0f);

        Texture texture("Res/textures/img.png");
        texture.Bind(0);
        shader.setUniform1i("u_Texture", 0);

        va.Unbind();
        vb.Unbind();
        ib.Unbind();
        shader.Unbind();


        float r = 0.0f;
        float g = 0.0f;
        float b = 0.0f;
        float incr = 0.005f;

        glm::vec3 translationA(200.0f, 200.0f, 0.0f);
        glm::vec3 translationB(400.0f, 200.0f, 0.0f);

        bool show_demo_window = true;
        bool show_another_window = false;
        ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);*/

        Renderer renderer;

        ImGui::CreateContext();
        ImGuiIO& io = ImGui::GetIO(); (void)io;
        /*io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;    
        io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;*/

        ImGui_ImplGlfw_InitForOpenGL(window, true);

        ImGui::StyleColorsDark();
        ImGui_ImplOpenGL3_Init();
        /* Loop until the user closes the window */

        test::TestClearColor test;
        while (!glfwWindowShouldClose(window))
        {
            
            renderer.Clear();

            test.OnUpdate(0.0f);
            test.OnRender();

            ImGui_ImplOpenGL3_NewFrame();
            ImGui_ImplGlfw_NewFrame();
            ImGui::NewFrame();

            /* Swap front and back buffers */
            test.OnImGuiRender();
            ImGui::Render();

            int display_w, display_h;
            glfwGetFramebufferSize(window, &display_w, &display_h);
            glViewport(0, 0, display_w, display_h);
            ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

            glfwSwapBuffers(window);

            /* Poll for and process events */
            glfwPollEvents();
        }
        /*GLCall(glDeleteProgram(shader));*/
    }
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();

    glfwDestroyWindow(window);
    glfwTerminate();
    return 0;
}



//Extra

//glClearColor(clear_color.x* clear_color.w, clear_color.y* clear_color.w, clear_color.z* clear_color.w, clear_color.w);
//glClear(GL_COLOR_BUFFER_BIT);
//
//{
//    glm::mat4 model = glm::translate(glm::mat4(1.0f), translationA);
//    glm::mat4 mvp = proj * view * model;
//
//    shader.Bind();
//    /*shader.setUniform4f("u_Color", r, g, b, 1.0f);*/
//    shader.setUniformMat4f("u_MVP", mvp);
//
//    renderer.Draw(va, ib, shader);
//}
//
//{
//    glm::mat4 model = glm::translate(glm::mat4(1.0f), translationB);
//    glm::mat4 mvp = proj * view * model;
//
//    shader.Bind();
//    /*shader.setUniform4f("u_Color", r, g, b, 1.0f);*/
//    shader.setUniformMat4f("u_MVP", mvp);
//
//    renderer.Draw(va, ib, shader);
//}
//
//
//
//r += incr;
//if (r >= 1)
//{
//    incr = -incr;
//    r = 1;
//
//}
//else if (r <= 0)
//{
//    incr = -incr;
//    r = 0;
//}
//
//
//
//// 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
//{
//    static float f = 0.0f;
//    static int counter = 0;
//
//    // Create a window called "Hello, world!" and append into it.
//    ImGui::Begin("Hello, world!");
//
//    //ImGui::Text("This is some useful text.");               // Display some text (you can use a format strings too)
//    //ImGui::Checkbox("Demo Window", &show_demo_window);      // Edit bools storing our window open/close state
//    //ImGui::Checkbox("Another Window", &show_another_window);
//
//    ImGui::SliderFloat3("Translation A", &translationA.x, 0.0f, 960.0f);            // Edit 1 float using a slider from 0.0f to 1.0f
//    ImGui::SliderFloat3("Translation B", &translationB.x, 0.0f, 960.0f);            // Edit 1 float using a slider from 0.0f to 1.0f
//    //ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color
//
//    //if (ImGui::Button("Button"))                            // Buttons return true when clicked (most widgets return true when edited/activated)
//    //    counter++;
//    //ImGui::SameLine();
//    //ImGui::Text("counter = %d", counter);
//
//    ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
//    ImGui::End();
//
//
//}