Modularization part 1

.gitmodules

@@ -25,3 +25,6 @@
 [submodule "include/glad"]
 	path = include/glad
 	url = https://github.com/Dav1dde/glad.git
+[submodule "include/imGuIZMO.quat"]
+	path = include/imGuIZMO.quat
+	url = https://github.com/BrutPitt/imGuIZMO.quat.git

CMakeLists.txt

@@ -13,6 +13,8 @@ set(GLFW_BUILD_TESTS OFF) # Don't build GLFW Tests
 set(GLFW_INSTALL OFF) # We're not building a standalone
 # set(GLEW_BUILD_DOCS $<CONFIG:Debug>) # Build docs if debug
 set(SOIL2_BUILD_TESTS OFF) # Don't build SOIL2 Tests
+set(ASSIMP_BUILD_ASSIMP_TOOLS OFF)
+set(ASSIMP_BUILD_TESTS OFF)
 
 find_package(OpenGL REQUIRED)
 
@@ -53,6 +55,14 @@ add_library(
   include/imgui/backends/imgui_impl_opengl3.cpp)
 target_link_libraries(imgui glfw)
 
+include_directories(include) # Kill me please
+include_directories(include/imGuIZMO.quat)
+add_library(
+  imGuIZMO STATIC
+  include/imGuIZMO.quat/imGuIZMO.quat/imGuIZMOquat.cpp
+)
+target_link_libraries(imGuIZMO imgui)
+
 add_executable(fred engine.cpp shader.c)
 if(UNIX)
   target_link_libraries(

engine.cpp

@@ -1,3 +1,4 @@
+#include "imGuIZMO.quat/vgMath.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -6,13 +7,18 @@
 #include <glad/gl.h>
 #include <GLFW/glfw3.h>
 #include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
 #include <glm/gtc/matrix_transform.hpp>
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/matrix_decompose.hpp>
 #include <glm/trigonometric.hpp>
 
-#include <backends/imgui_impl_glfw.h>
+#define IMGUI_DEFINE_MATH_OPERATORS // ImGui
-#include <backends/imgui_impl_opengl3.h>
+#include <imgui/backends/imgui_impl_glfw.h>
+#include <imgui/backends/imgui_impl_opengl3.h>
+#include <imgui/imgui.h>
+#include <imGuIZMO.quat/imGuIZMOquat.h>
 #include <clog/clog.h>
-#include <imgui.h>
 
 #include <SOIL2.h>
 #include <assimp/DefaultLogger.hpp>
@@ -23,13 +29,15 @@
 
 #include "shader.h"
 
-constexpr int WIDTH = 1024;
+constexpr int WIDTH = 1366;
 constexpr int HEIGHT = 768;
 
 static void glfwErrorCallback(int e, const char *description) {
   clog_log(CLOG_LEVEL_ERROR, "GLFW Error %d: %s", e, description);
 }
 
+namespace fred {
+
 static bool loadModel(const char *path, std::vector<unsigned short> &indices,
                       std::vector<glm::vec3> &vertices,
                       std::vector<glm::vec2> &uvs,
@@ -67,6 +75,139 @@ static bool loadModel(const char *path, std::vector<unsigned short> &indices,
   return true;
 }
 
+GLuint loadTexture(const char *path) {
+  GLuint texture = SOIL_load_OGL_texture(
+      path, SOIL_LOAD_AUTO,
+      SOIL_CREATE_NEW_ID,
+      SOIL_FLAG_MIPMAPS | SOIL_FLAG_NTSC_SAFE_RGB | SOIL_FLAG_COMPRESS_TO_DXT | SOIL_FLAG_INVERT_Y);
+  if (texture == 0) {
+    clog_log(CLOG_LEVEL_WARN, "Texture failed to load");
+    return 0;
+  }
+  return texture;
+}
+
+class Model {
+public:
+    std::vector<unsigned short> indices;
+    GLuint vertexBuffer;
+    GLuint uvBuffer;
+    GLuint normalBuffer;
+    GLuint elementBuffer;
+
+  Model(std::string modelPath) {
+    std::vector<glm::vec3> indexed_vertices;
+    std::vector<glm::vec2> indexed_uvs;
+    std::vector<glm::vec3> indexed_normals;
+
+    loadModel(modelPath.c_str(), indices, indexed_vertices, indexed_uvs, indexed_normals);
+
+    glGenBuffers(1, &vertexBuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
+    glBufferData(GL_ARRAY_BUFFER, indexed_vertices.size() * sizeof(glm::vec3),
+               &indexed_vertices[0], GL_STATIC_DRAW);
+
+    glGenBuffers(1, &uvBuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, uvBuffer);
+    glBufferData(GL_ARRAY_BUFFER, indexed_uvs.size() * sizeof(glm::vec2),
+               &indexed_uvs[0], GL_STATIC_DRAW);
+
+    glGenBuffers(1, &normalBuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, normalBuffer);
+    glBufferData(GL_ARRAY_BUFFER, indexed_normals.size() * sizeof(glm::vec3),
+               &indexed_normals[0], GL_STATIC_DRAW);
+
+    glGenBuffers(1, &elementBuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, elementBuffer);
+    glBufferData(GL_ARRAY_BUFFER, indices.size() * sizeof(unsigned short),
+               &indices[0], GL_STATIC_DRAW);
+  }
+  ~Model() {
+    // glDeleteBuffers(4, vertexBuffer); // Chances that these are contiguous in memory is zero
+    glDeleteBuffers(1, &vertexBuffer);
+    glDeleteBuffers(1, &uvBuffer);
+    glDeleteBuffers(1, &normalBuffer);
+    glDeleteBuffers(1, &elementBuffer);
+  }
+};
+
+class Texture {
+public:
+  GLuint texture;
+
+  Texture(std::string texturePath) {
+    texture = loadTexture(texturePath.c_str());
+  }
+  ~Texture() {
+    glDeleteTextures(1, &texture);
+  }
+};
+
+class Shader {
+public:
+  GLuint shaderProgram;
+
+  Shader(std::string vertPath, std::string fragPath) {
+    shaderProgram = loadShaders(vertPath.c_str(), fragPath.c_str());
+  }
+  ~Shader() {
+    glDeleteProgram(shaderProgram);
+  }
+};
+
+class Asset {
+public:
+  std::vector<unsigned short> *indices;
+  GLuint *vertexBuffer;
+  GLuint *uvBuffer;
+  GLuint *normalBuffer;
+  GLuint *elementBuffer;
+
+  GLuint matrixID;
+  GLuint textureID;
+
+  glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f);
+  glm::quat rotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f); // https://en.wikipedia.org/wiki/Quaternion
+  glm::vec3 scaling = glm::vec3(1.0f, 1.0f, 1.0f);
+
+  GLuint *modelTexture;
+
+  GLuint *shaderProgram;
+
+  Asset(Model &model, Texture &texture, Shader &shader) {
+    indices = &model.indices;
+    vertexBuffer = &model.vertexBuffer;
+    uvBuffer = &model.uvBuffer;
+    normalBuffer = &model.normalBuffer;
+    elementBuffer = &model.elementBuffer;
+
+    modelTexture = &texture.texture;
+
+    shaderProgram = &shader.shaderProgram;
+
+    matrixID = glGetUniformLocation(*shaderProgram, "MVP");
+    textureID = glGetUniformLocation(*shaderProgram, "textureSampler");
+  }
+};
+
+class Scene {
+public:
+  std::vector<Asset*> assets;
+  void addAsset(Asset *asset) {
+    assets.push_back(asset);
+  }
+};
+
+GLFWwindow *window;
+
+static bool shouldExit() {
+return glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwWindowShouldClose(window) == 0;
+}
+
+glm::mat4 mvp; // TODO: REMOVE THIS PLLAAAHSE
+glm::mat4 viewMatrix;
+glm::mat4 projectionMatrix;
+
 static int initWindow() {
   glfwSetErrorCallback(glfwErrorCallback);
 
@@ -81,7 +222,6 @@ static int initWindow() {
   glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Loser MacOS is broken
   glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // New GL
 
-  GLFWwindow *window;
   window = glfwCreateWindow(WIDTH, HEIGHT, "Fred", NULL, NULL);
   if (window == NULL) {
     clog_log(CLOG_LEVEL_ERROR, "Failed to open window.");
@@ -113,71 +253,21 @@ static int initWindow() {
   ImGui_ImplGlfw_InitForOpenGL(window, true);
   ImGui_ImplOpenGL3_Init("#version 330");
 
-  std::vector<unsigned short> indices;
-  std::vector<glm::vec3> indexed_vertices;
-  std::vector<glm::vec2> indexed_uvs;
-  std::vector<glm::vec3> indexed_normals;
-  if (!loadModel("../models/model.obj", indices, indexed_vertices, indexed_uvs,
-                 indexed_normals)) {
-    return 0;
-  }
-
-  GLuint vertexArrayID;
-  glGenVertexArrays(1, &vertexArrayID);
-  glBindVertexArray(vertexArrayID);
-
-  GLuint vertexBuffer;
-  glGenBuffers(1, &vertexBuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
-  glBufferData(GL_ARRAY_BUFFER, indexed_vertices.size() * sizeof(glm::vec3),
-               &indexed_vertices[0], GL_STATIC_DRAW);
-
-  GLuint uvBuffer;
-  glGenBuffers(1, &uvBuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, uvBuffer);
-  glBufferData(GL_ARRAY_BUFFER, indexed_uvs.size() * sizeof(glm::vec2),
-               &indexed_uvs[0], GL_STATIC_DRAW);
-
-  GLuint normalBuffer;
-  glGenBuffers(1, &normalBuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, normalBuffer);
-  glBufferData(GL_ARRAY_BUFFER, indexed_normals.size() * sizeof(glm::vec3),
-               &indexed_normals[0], GL_STATIC_DRAW);
-
-  GLuint elementBuffer;
-  glGenBuffers(1, &elementBuffer);
-  glBindBuffer(GL_ARRAY_BUFFER, elementBuffer);
-  glBufferData(GL_ARRAY_BUFFER, indices.size() * sizeof(unsigned short),
-               &indices[0], GL_STATIC_DRAW);
-
-  GLuint texture = SOIL_load_OGL_texture(
-      "../textures/results/texture_BMP_DXT5_3.DDS", SOIL_LOAD_AUTO,
-      SOIL_CREATE_NEW_ID,
-      SOIL_FLAG_MIPMAPS | SOIL_FLAG_NTSC_SAFE_RGB | SOIL_FLAG_COMPRESS_TO_DXT);
-  if (texture == 0) {
-    clog_log(CLOG_LEVEL_WARN, "Texture failed to load");
-    return 0;
-  }
-
-  GLuint programID =
-      loadShaders("../shaders/shader.vert", "../shaders/shader.frag");
 
   // I love glm
   // Projection matrix, 45deg FOV, 4:3 Aspect Ratio, Planes: 0.1units ->
   // 100units
-  glm::mat4 projection = glm::perspective(
+  projectionMatrix = glm::perspective(
       glm::radians(45.0f), (float)WIDTH / (float)HEIGHT, 0.1f, 100.0f);
 
   // Camera matrix
-  glm::mat4 view =
+  viewMatrix =
       glm::lookAt(glm::vec3(4, 3, 3), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
 
   glm::mat4 model = glm::mat4(1.0f);
 
   // Model view projection, the combination of the three vectors
-  glm::mat4 mvp = projection * view * model;
+  mvp = projectionMatrix * viewMatrix * model;
-
-  GLuint matrixID = glGetUniformLocation(programID, "MVP");
 
   glEnable(GL_DEPTH_TEST); // Turn on the Z-buffer
   glDepthFunc(GL_LESS);    // Accept only the closest fragments
@@ -186,145 +276,112 @@ static int initWindow() {
 
   glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
 
+  GLuint vertexArrayID;
+  glGenVertexArrays(1, &vertexArrayID);
+  glBindVertexArray(vertexArrayID);
+
   // Define camera stuff
-  glm::vec3 position = {4, 3, 3};
+  //glm::vec3 position = {4, 3, 3};
-  float horizontalAngle = 3.14F; // Toward -Z, in Rads
+  //float horizontalAngle = 3.14f;
-  float verticalAngle = 0.0f;    // On the horizon
+  //float verticalAngle = -0.1f;
-  float initialFOV = 60.0f;
+  //float initialFOV = 60.0f;
 
-  float speed = 3.0f;
+  //float speed = 3.0f;
-  float mouseSpeed = 0.005f;
+  //float mouseSpeed = 0.005f;
 
-  double xpos, ypos;
+  //double xpos, ypos;
 
-  double lastTime = 0;
+  //glDeleteVertexArrays(1, &vertexArrayID);
-  while (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS &&
+  //ImGui_ImplOpenGL3_Shutdown();
-         glfwWindowShouldClose(window) == 0) {
+  //ImGui_ImplGlfw_Shutdown();
+  //ImGui::DestroyContext();
+
+  //glfwDestroyWindow(window);
+  //glfwTerminate();
+
+  return 0;
+}
+
+void imguiMat4Table(glm::mat4 matrix, const char *name) {
+  if (ImGui::BeginTable(name, 4)) {
+    for (int i = 0; i < 4; i++) {
+      for (int j = 0; j < 4; j++) {
+        ImGui::TableNextColumn();
+        ImGui::Text("%f", matrix[i][j]);
+      }
+    }
+    ImGui::EndTable();
+  }
+}
+
+void render(Scene scene) {
   // Clear this mf
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    glUseProgram(programID);
-
-    // ImGui
-    // if (glfwGetWindowAttrib(window, GLFW_ICONIFIED) != 0) {
-    //   ImGui_ImplGlfw_Sleep(10);
-    //   continue; // No rendering while minimized
-    // }
-
-    glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
-    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
 
   ImGui_ImplOpenGL3_NewFrame();
   ImGui_ImplGlfw_NewFrame();
-
   ImGui::NewFrame();
 
-    // ImGui::ShowDemoWindow();
+  for (int i = 0; i < scene.assets.size(); i++) {
-    ImGui::Begin("DEBUG INFO");
+    Asset *currentAsset = scene.assets[i];
-    ImGui::Text("MVP:");
-    if (ImGui::BeginTable("mvp", 4)) {
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[0][0]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[0][1]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[0][2]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[0][3]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[1][0]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[1][1]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[1][2]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[1][3]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[2][0]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[2][1]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[2][2]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[2][3]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[3][0]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[3][1]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[3][2]);
-      ImGui::TableNextColumn();
-      ImGui::Text("%f", mvp[3][3]);
 
-      ImGui::EndTable();
+    glUseProgram(*currentAsset->shaderProgram);
-    }
-    ImGui::End();
-
-    // Compute a Fresh Super Sigma MVP
-    // What would an input system be without delta time
-    double currentTime = glfwGetTime();
-    float deltaTime = (float)(currentTime - lastTime);
-
-    glfwGetCursorPos(window, &xpos, &ypos);
-    glfwSetCursorPos(window, (float)(WIDTH) / 2, (float)(HEIGHT) / 2);
-
-    horizontalAngle +=
-        mouseSpeed * deltaTime * (float)((float)(WIDTH) / 2 - xpos);
-    verticalAngle +=
-        mouseSpeed * deltaTime * (float)((float)(HEIGHT) / 2 - ypos);
-    glm::vec3 direction(cos(verticalAngle) * sin(horizontalAngle),
-                        sin(verticalAngle),
-                        cos(verticalAngle) * cos(horizontalAngle));
-    glm::vec3 right(sin(horizontalAngle - 3.14f / 2.0f), 0,
-                    cos(horizontalAngle - 3.14f / 2.0f));
-    glm::vec3 up = glm::cross(right, direction);
-
-    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
-      position += direction * deltaTime * speed;
-    }
-    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
-      position -= direction * deltaTime * speed;
-    }
-    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
-      position += right * deltaTime * speed;
-    }
-    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
-      position -= right * deltaTime * speed;
-    }
-
-    // float FOV = initialFOV;
-    // Disabled because unchanged
-    // glm_perspective(glm_rad(FOV), 4.0f/ 3.0f, 0.1f, 100.0f, projection);
-    glm::mat4 view = glm::lookAt(position, position + direction, up);
-    // mvp = projection * view * model;
 
     // Send mega sigma MVP to the vertex shader (transformations for the win)
-    glUniformMatrix4fv(matrixID, 1, GL_FALSE, &mvp[0][0]);
+    glm::mat4 rotationMatrix = mat4_cast(currentAsset->rotation);
+    glm::mat4 translationMatrix = glm::translate(glm::mat4(1), currentAsset->position);
+    glm::mat4 scalingMatrix = glm::scale(glm::mat4(1), currentAsset->scaling);
+    glm::mat4 modelMatrix = translationMatrix * rotationMatrix * scalingMatrix;
+
+    mvp = projectionMatrix * viewMatrix * modelMatrix;
+
+    char assetName[] = "Asset: 00";
+    sprintf(assetName, "Asset: %d", i);
+    ImGui::Begin(assetName);
+
+    ImGui::SeparatorText("Position Matrix:");
+    imguiMat4Table(translationMatrix, "posmat");
+    ImGui::SeparatorText("Rotation Matrix:");
+    imguiMat4Table(rotationMatrix, "rotmat");
+    ImGui::SeparatorText("Scaling Matrix:");
+    imguiMat4Table(scalingMatrix, "scalmat");
+    ImGui::SeparatorText("Model Matrix:");
+    imguiMat4Table(modelMatrix, "modmat");
+    ImGui::End();
+
+    glUniformMatrix4fv(currentAsset->matrixID, 1, GL_FALSE, &mvp[0][0]);
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, *currentAsset->modelTexture);
+    // Set sampler texture
+    glUniform1i(currentAsset->textureID, 0);
 
     // DRAWING HAPPENS HERE
     // Vertex Data
     glEnableVertexAttribArray(0);
-    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, *currentAsset->vertexBuffer);
     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void *)0);
 
     // UV Data
     glEnableVertexAttribArray(1);
-    glBindBuffer(GL_ARRAY_BUFFER, uvBuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, *currentAsset->uvBuffer);
     glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void *)0);
 
     // Normal Data
     glEnableVertexAttribArray(2);
-    glBindBuffer(GL_ARRAY_BUFFER, normalBuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, *currentAsset->normalBuffer);
     glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (void *)0);
 
     // Index buffer
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, *currentAsset->elementBuffer);
 
-    glDrawElements(GL_TRIANGLES, (GLsizei)indices.size(), GL_UNSIGNED_SHORT,
+    glDrawElements(GL_TRIANGLES, currentAsset->indices->size(), GL_UNSIGNED_SHORT,
                    (void *)0);
 
     glDisableVertexAttribArray(0);
     glDisableVertexAttribArray(1);
     glDisableVertexAttribArray(2);
+  }
 
   ImGui::Render();
   ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
@@ -332,26 +389,31 @@ static int initWindow() {
   // Swap buffers
   glfwSwapBuffers(window);
   glfwPollEvents();
+}
 
-    lastTime = currentTime; // Count total frame time
+} // namespace fred
+
+int main() {
+  fred::initWindow();
+  fred::Model coneModel("../models/model.obj");
+  fred::Texture buffBlackGuy("../textures/results/texture_BMP_DXT5_3.DDS");
+  fred::Shader basicShader("../shaders/shader.vert", "../shaders/shader.frag");
+  fred::Asset cone(coneModel, buffBlackGuy, basicShader);
+  fred::Asset coneTwo(coneModel, buffBlackGuy, basicShader);
+
+  fred::Scene scene = fred::Scene();
+
+  scene.addAsset(&cone);
+  scene.addAsset(&coneTwo);
+
+  while (fred::shouldExit()) {
+  //while (1) {
+    fred::render(scene);
+    cone.position.x += 0.01;
+    glm::vec3 eulerAngles = glm::eulerAngles(coneTwo.rotation);
+    eulerAngles.x += glm::radians(1.0f);
+    coneTwo.rotation = glm::quat(eulerAngles);
   }
 
-  ImGui_ImplOpenGL3_Shutdown();
-  ImGui_ImplGlfw_Shutdown();
-  ImGui::DestroyContext();
-
-  glDeleteBuffers(1, &vertexBuffer);
-  glDeleteBuffers(1, &uvBuffer);
-  glDeleteBuffers(1, &normalBuffer);
-  glDeleteBuffers(1, &elementBuffer);
-  glDeleteProgram(programID);
-  glDeleteTextures(1, &texture);
-  glDeleteVertexArrays(1, &vertexArrayID);
-
-  glfwDestroyWindow(window);
-  glfwTerminate();
-
   return 0;
 }
-
-int main() { return initWindow(); }

include/CLog

@@ -1 +1 @@
-Subproject commit 5a8dc48b060619da1b6fbbacd18630c4d2c92182
+Subproject commit 906059bd02731184f80d8b3e789e61c5499213d0

include/imGuIZMO.quat

@@ -0,0 +1 @@
+Subproject commit 6c038a90fdadae580b357fbaf26f83cafeb83a6a

shaders/shader.vert

@@ -11,6 +11,7 @@ uniform mat4 MVP;
 
 void main() {
     gl_Position = MVP * vec4(vertexPosition_modelspace, 1);
+    //gl_Position = vec4(vertexPosition_modelspace, 1);
 
     vec2 UV_FLIPPED;
     UV_FLIPPED.x = vertexUV.x;