YoggieEngine/SandboxApplication/Sandbox.cpp

#include <MyGraphicsEngine/Shader.h>
#include <MyGraphicsEngine/Window.h>
#include <MyGraphicsEngine/Camera.h>
#include <MyGraphicsEngine/Mesh.h>
#include <MyGraphicsEngine/Transform.h>
#include <MyGraphicsEngine/Buffer.h>

#include <string>

#include "imgui.h"
#include "backends/imgui_impl_glfw.h"
#include "backends/imgui_impl_opengl3.h"

/*
* extern "C"
 {
    #include "lauxlib.h"
    #include "lua.h"
    #include "lualib.h"
}

#include <include/AssetManager/ModelImporter.h>

#include <gorilla/gau.h>
#include <gorilla/ga.h>
*/

int main(int argc, char* argv[]) {

    spdlog::info("Working directory: {}", argv[0]);

    //ModelImporter::Test();


    Transform t;
    t.Scale.x = 1.0f;
    t.Scale.y = 1.0f;
    t.Rotation.y = 90.0f;

    Mesh mesh;

    mesh.vertices = {
         glm::vec3( 0.5f,  0.5f, 0.0f), // top, right
         glm::vec3( 0.5f, -0.5f, 0.0f), // bottom right
         glm::vec3(-0.5f, -0.5f, 0.0f), // bottom left
         glm::vec3(-0.5f,  0.5f, 0.0f) // top left
    };


    mesh.elements = {
        0,1,3,
        1,2,3
    };


    Camera cam(glm::vec3(2.0f, 0.0f, 0.0f), glm::vec3(0.0f,0.0f,0.0f), 90.0f);

  
    BarinkWindow GameWindow(800, 600);
   
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO& io = ImGui::GetIO();
    (void)io;

    ImGui::StyleColorsDark();
    ImGui_ImplGlfw_InitForOpenGL(GameWindow.windowptr(), true);
    ImGui_ImplOpenGL3_Init("#version 440");
        

    std::string vertexShaderSource = "build/SandboxApplication/Debug/test.vs";
    std::string fragmentShaderSource = "build/SandboxApplication/Debug/test.fs";
    Shader shader (vertexShaderSource, fragmentShaderSource);

    /*
    *   lua_State* L = luaL_newstate();
    luaL_openlibs(L);
    luaL_dostring(L, "print('BarinkEngine')");
    luaL_dofile(L,"./script.lua");
    */

    spdlog::info("Vertices: {}, {} bytes", mesh.vertices.size(), sizeof(glm::vec3));
    spdlog::info("Elements: {}, {} bytes", mesh.elements.size(), sizeof(GLushort));


    Buffer VertexBuffer;
    Buffer ElementBuffer;

    unsigned int  VAO;

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

    VertexBuffer.createBuffer();
    VertexBuffer.Bind(false);
    VertexBuffer.setBufferData(&mesh.vertices[0], mesh.vertices.size() * sizeof(glm::vec3),false);

    ElementBuffer.createBuffer();
    ElementBuffer.Bind(true);
    ElementBuffer.setBufferData(&mesh.elements[0], mesh.elements.size() * sizeof(GLushort), true);

 
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);

    VertexBuffer.Unbind(false);
    glBindVertexArray(0);

    /*
    * gau_Manager* mgr;
    ga_Mixer* mixer;
    ga_Sound sound;
    ga_Handle handle;
    gau_SampleSourceLoop* loopSrc = 0;
    gau_SampleSourceLoop** pLoopSrc = &loopSrc;
    gc_int32 loop = 0;
    gc_int32 quit = 0;


    gc_initialize(0);
    mgr = gau_manager_create();
    mixer = gau_manager_mixer(mgr);
    */
    




    while (!GameWindow.WindowShouldClose()) {
        glm::mat4 tran = glm::translate(glm::mat4(), t.Position);
        glm::mat4 scale = glm::scale(glm::mat4(), t.Scale);
        glm::mat4 rot =
            glm::rotate(glm::mat4(), glm::radians(t.Rotation.x), glm::vec3(1.0f, 0.0f, 0.0f)) *
            glm::rotate(glm::mat4(), glm::radians(t.Rotation.y), glm::vec3(0.0f, 1.0f, 0.0f)) *
            glm::rotate(glm::mat4(), glm::radians(t.Rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));


        glm::mat4 model = tran * rot * scale;

        glm::mat4 projection = glm::perspective(cam.Zoom, (800.0f / 600.0f), 0.001f, 100.0f);


        GameWindow.Poll();

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

        shader.Use();
        shader.setUniformMat4("P", projection);
        shader.setUniformMat4("M", model);
        shader.setUniformMat4("V", cam.GetViewMatrix());
        glBindVertexArray(VAO);
        ElementBuffer.Bind(true);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, NULL);
        glBindVertexArray(0);


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

        ImGui::Begin("Transform Test Tool");

        ImGui::SliderFloat("Scale Y:", (float*)&t.Scale.y, 1, 4);
        ImGui::SliderFloat("Scale X:", (float*)&t.Scale.x, 1, 4);
       
        ImGui::SliderFloat("Position X:", (float*)&t.Position.z, -5, 5);


        ImGui::End();



        ImGui::Render();
        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());


        GameWindow.SwapBuffers();
    }

    // Cleanup
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();

    glDeleteVertexArrays(1, &VAO);
    ElementBuffer.Delete();
    

}