1 files changed, 89 insertions, 58 deletions

diff --git a/src/main.cpp b/src/main.cpp
index 33488bb..f2b2c3f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -54,8 +54,13 @@ static std::vector<Triangle3D> generate_sand() {
     return vertices;
 }
 
+struct Model {
+    ShaderFrame frame;
+    Texture2D texture;
+};
+
 static void create_sand(DeviceMemory *triangles, DeviceMemory *texcoords, Texture2D *texture);
-static DeviceMemory* load_model(const char *filepath);
+static Model load_model(const char *filepath, ShaderProgram *shader_program);
 
 int main() {
     initGlfw();
@@ -65,7 +70,7 @@ int main() {
     int window_height = 1;
     glfwGetWindowSize(window, &window_width, &window_height);
 
-    glm::mat4 proj = glm::perspective(glm::radians(75.0f), (float)window_width / (float)window_height, 0.2f, 1000.0f);
+    glm::mat4 proj = glm::perspective(glm::radians(75.0f), (float)window_width / (float)window_height, 0.01f, 1000.0f);
 
     std::unique_ptr<Shader> sand_vertex_shader = load_shader_from_file("shaders/sand_vertex.vert", Shader::Type::VERTEX);
     std::unique_ptr<Shader> sand_pixel_shader = load_shader_from_file("shaders/sand_fragment.frag", Shader::Type::PIXEL);
@@ -91,30 +96,44 @@ int main() {
     std::unique_ptr<Shader> vertex_shader = load_shader_from_file("shaders/vertex.vert", Shader::Type::VERTEX);
     std::unique_ptr<Shader> pixel_shader = load_shader_from_file("shaders/fragment.frag", Shader::Type::PIXEL);
     std::unique_ptr<ShaderProgram> shader_program = build_shader_program_from_shaders({ vertex_shader.get(), pixel_shader.get() });
-    ShaderFrame model_frame = shader_program->create_frame();
-
-    std::vector<Triangle3D> triangles;
-    std::vector<vec2f> texture_coords;
-    Image *image;
-    ObjModelLoader::load_from_file("/home/dec05eba/Downloads/ELI4OS.obj", triangles, texture_coords, &image);
-    DeviceMemory *gpuModel = model_frame.get_input_by_name("position");
-    gpuModel->set({triangles.data(), triangles.size()}, DeviceMemory::StorageType::STATIC);
+    Model buddha_model = load_model("/home/dec05eba/Downloads/ELI4OS.obj", shader_program.get());
+    buddha_model.frame.get_uniform_by_name("proj")->set(proj);
+    Result<Uniform> view_uniform = buddha_model.frame.get_uniform_by_name("view");
+    Result<Uniform> model_uniform = buddha_model.frame.get_uniform_by_name("model");
+
+    std::unique_ptr<Shader> vertex_no_texture_shader = load_shader_from_file("shaders/vertex_no_texture.vert", Shader::Type::VERTEX);
+    std::unique_ptr<Shader> pixel_no_texture_shader = load_shader_from_file("shaders/fragment_no_texture.frag", Shader::Type::PIXEL);
+    std::unique_ptr<ShaderProgram> no_texture_shader_program = build_shader_program_from_shaders({ vertex_no_texture_shader.get(), pixel_no_texture_shader.get() });
+    Model character_model = load_model("/home/dec05eba/Downloads/FinalBaseMesh.obj", no_texture_shader_program.get());
+    character_model.frame.get_uniform_by_name("proj")->set(proj);
+    Result<Uniform> char_view_uniform = character_model.frame.get_uniform_by_name("view");
+    Result<Uniform> char_model_uniform = character_model.frame.get_uniform_by_name("model");
+
+
+
+    glm::mat4 model = glm::rotate(
+        glm::mat4(1.0f),
+        0.0f,
+        glm::vec3(0.0f, 0.0f, 1.0f)
+    );
+    model_uniform->set(model);
+
+    glm::mat4 char_model = glm::rotate(
+        glm::mat4(1.0f),
+        glm::pi<float>() * 0.5f,
+        glm::vec3(1.0f, 0.0f, 0.0f)
+    );
+    char_model = glm::scale(char_model, glm::vec3(0.1f, 0.1f, 0.1f));
+    char_model_uniform->set(char_model);
+
+    glm::mat4 sand_model = glm::rotate(
+        glm::mat4(1.0f),
+        0.0f,
+        glm::vec3(0.0f, 0.0f, 1.0f)
+    );
+    sand_model = glm::scale(sand_model, glm::vec3(50.0f, 50.0f, 50.0f));
+    sand_model_uniform->set(sand_model);
 
-    Texture2D model_texture(image);
-    delete image;
-    DeviceMemory *model_gpu_texcoords = model_frame.get_input_by_name("texcoord_vert");
-    model_gpu_texcoords->set({texture_coords.data(), texture_coords.size()}, DeviceMemory::StorageType::STATIC);
-
-    Result<Uniform> proj_uniform = model_frame.get_uniform_by_name("proj");
-    Result<Uniform> view_uniform = model_frame.get_uniform_by_name("view");
-    Result<Uniform> model_uniform = model_frame.get_uniform_by_name("model");
-    Result<Uniform> tex_uniform = model_frame.get_uniform_by_name("tex");
-
-    proj_uniform->set(proj);
-    tex_uniform->set(model_texture);
-
-    triangles.resize(0);
-    texture_coords.resize(0);
 
     Userdata userdata;
     ThirdPersonCamera third_person_camera;
@@ -128,7 +147,7 @@ int main() {
     
     glfwSetScrollCallback(window, [](GLFWwindow *window, double xoffset, double yoffset){
         Userdata *userdata = (Userdata*)glfwGetWindowUserPointer(window);
-        userdata->third_person_camera->zoom(-yoffset);
+        userdata->third_person_camera->zoom(-yoffset*0.1f);
     });
 
     glfwSetCursorPosCallback(window, [](GLFWwindow *window, double xpos, double ypos) {
@@ -158,13 +177,9 @@ int main() {
         t_start = t_now;
         time += time_delta;
 
-        glm::mat4 camera_matrix = third_person_camera.get_matrix();
         glm::vec3 camera_forward = third_person_camera.get_forward_vector();
         glm::vec3 camera_right = third_person_camera.get_right_vector();
 
-        sand_view_uniform->set(camera_matrix);
-        view_uniform->set(camera_matrix);
-
         float move_speed = time_delta * 3.0f;
         glm::vec3 move_vec = glm::vec3();
         if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
@@ -183,40 +198,32 @@ int main() {
             move_vec.x += camera_right.x;
             move_vec.y += camera_right.y;
         }
+
         if(glm::length(move_vec) > 0.0f)
             character_pos += (glm::normalize(move_vec) * move_speed);
+
         third_person_camera.set_target_position(character_pos);
+        char_model[3][0] = character_pos.x;
+        char_model[3][1] = character_pos.y;
+        char_model[3][2] = character_pos.z - 2.0f;
+        char_model_uniform->set(char_model);
 
-        glm::mat4 model = glm::mat4(1.0f);
-        model = glm::rotate(
-            model,
-            0.0f,
-            glm::vec3(0.0f, 0.0f, 1.0f)
-        );
-        model_uniform->set(model);
-
-        glm::mat4 sand_model = glm::mat4(1.0f);
-        sand_model = glm::rotate(
-            sand_model,
-            0.0f,
-            glm::vec3(0.0f, 0.0f, 1.0f)
-        );
-        sand_model = glm::scale(sand_model, glm::vec3(50.0f, 50.0f, 50.0f));
-        sand_model_uniform->set(sand_model);
-
-        //printf("now: %f\n", time);
-        //sand_time->set(time);
+        glm::mat4 camera_matrix = third_person_camera.get_matrix();
+        sand_view_uniform->set(camera_matrix);
+        view_uniform->set(camera_matrix);
+        char_view_uniform->set(camera_matrix);
 
         // Set color for clearing
         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
         // Do the actual screen clearing, using the color set using glClearColor
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-        //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 
-        model_frame.draw();
+        buddha_model.frame.draw();
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+        character_model.frame.draw();
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
         sand_frame.draw();
 
-        //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
         glfwSwapBuffers(window);
     }
 
@@ -247,8 +254,32 @@ void create_sand(DeviceMemory *triangles, DeviceMemory *texcoords, Texture2D *te
     texcoords->set({height_map_texcoord.data(), height_map_texcoord.size()}, DeviceMemory::StorageType::STATIC);
 }
 
-DeviceMemory* load_model(const char *filepath) {
-    return nullptr;
+Model load_model(const char *filepath, ShaderProgram *shader_program) {
+    ShaderFrame model_frame = shader_program->create_frame();
+
+    std::vector<Triangle3D> triangles;
+    std::vector<vec2f> texture_coords;
+    Image *image;
+    ObjModelLoader::load_from_file(filepath, triangles, texture_coords, &image);
+    // TODO: This needs to be done to prevent crash in glDrawArrays, but this should not be used when shader doesn't handle any texture
+    //if(texture_coords.size() < triangles.size())
+    //    texture_coords.resize(triangles.size());
+
+    DeviceMemory *gpuModel = model_frame.get_input_by_name("position");
+    gpuModel->set({triangles.data(), triangles.size()}, DeviceMemory::StorageType::STATIC);
+
+    if(image) {
+        Texture2D model_texture(image);
+        delete image;
+        DeviceMemory *model_gpu_texcoords = model_frame.get_input_by_name("texcoord_vert");
+        model_gpu_texcoords->set({texture_coords.data(), texture_coords.size()}, DeviceMemory::StorageType::STATIC);
+
+        Result<Uniform> tex_uniform = model_frame.get_uniform_by_name("tex");
+        tex_uniform->set(model_texture);
+        return { std::move(model_frame), std::move(model_texture) };
+    } else {
+        return { std::move(model_frame), Texture2D() };
+    }
 }
 
 void glfwErrorHandler(int errorCode, const char *errorDescription)
@@ -282,10 +313,10 @@ void initGlfw()
     GLint flags;
     glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
     if(flags & GL_CONTEXT_FLAG_DEBUG_BIT) {
-        glEnable(GL_DEBUG_OUTPUT);
-        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
-        glDebugMessageCallback(gl_debug_callback, nullptr);
-        glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
+        //glEnable(GL_DEBUG_OUTPUT);
+        //glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
+        //glDebugMessageCallback(gl_debug_callback, nullptr);
+        //glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
     } else {
         fprintf(stderr, "Warning: failed to enable gl debugging\n");
     }