Created a GameObject hierarchy system and a 3D coord axes model.

AlonsoCerpa · AlonsoCerpa · commit a31527aba33d · 2023-03-24T00:41:09.000-05:00
diff --git a/NeonEngine/imgui.ini b/NeonEngine/imgui.ini
@@ -56,7 +56,7 @@ Size=1441,1038
 Collapsed=0
 
 [Docking][Data]
-DockSpace     ID=0x3BC79352 Window=0x4647B76E Pos=467,527 Size=1920,1054 Split=X Selected=0x13926F0B
+DockSpace     ID=0x3BC79352 Window=0x4647B76E Pos=505,565 Size=1920,1054 Split=X Selected=0x13926F0B
   DockNode    ID=0x00000003 Parent=0x3BC79352 SizeRef=1426,527 Split=Y Selected=0x13926F0B
     DockNode  ID=0x00000005 Parent=0x00000003 SizeRef=1387,702 CentralNode=1 Selected=0x13926F0B
     DockNode  ID=0x00000006 Parent=0x00000003 SizeRef=1387,350 Selected=0xBF096F38
diff --git a/NeonEngine/src/cylinder.cpp b/NeonEngine/src/cylinder.cpp
@@ -183,16 +183,26 @@ void Cylinder::printSelf() const
 
 // Test intersection with a ray
 bool Cylinder::intersected_ray(const glm::vec3& orig, const glm::vec3& dir, float& t) {
+    float min_t = std::numeric_limits<float>::max();
+    float t_aux;
     for (int i = 0; i < indices.size(); i += 3) {
         glm::vec3 v0(vertices[indices[i] * 3], vertices[indices[i] * 3 + 1], vertices[indices[i] * 3 + 2]);
         glm::vec3 v1(vertices[indices[i+1] * 3], vertices[indices[i+1] * 3 + 1], vertices[indices[i+1] * 3 + 2]);
         glm::vec3 v2(vertices[indices[i+2] * 3], vertices[indices[i+2] * 3 + 1], vertices[indices[i+2] * 3 + 2]);
-
-        if (ray_triangle_intersection(orig, dir, v0, v1, v2, t)) {
-            return true;
+        if (ray_triangle_intersection(orig, dir, v0, v1, v2, t_aux)) {
+            if (t_aux < min_t) {
+                min_t = t_aux;
+            }
         }
     }
-    return false;
+    if (min_t != std::numeric_limits<float>::max()) {
+        t = min_t;
+        return true;
+    }
+    else {
+        t = -1.0f;
+        return false;
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/NeonEngine/src/game_object.h b/NeonEngine/src/game_object.h
@@ -1,5 +1,9 @@
 #pragma once
 
+#include "shader.h"
+#include "rendering.h"
+#include "model.h"
+
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
@@ -9,34 +13,95 @@ class GameObject {
     int idx_loaded_models = -1;
     glm::vec3 position;
     glm::vec3 scale;
-    glm::vec3 axis_rotation;
-    float angle_rotation_degrees;
+    glm::vec3 rotation;
     glm::mat4 model;
     glm::mat4 model_inv;
+    glm::mat3 model_normals;
     glm::vec3 color;
     bool is_selected;
+    std::vector<GameObject*> children_game_objects;
 
-    GameObject(int idx_loaded_models = 0, const glm::vec3& pos = glm::vec3(0.0f, 0.0f, 0.0f), const glm::vec3& scale = glm::vec3(1.0f, 1.0f, 1.0f),
-               const glm::vec3& axis_rot = glm::vec3(1.0f, 0.0f, 0.0f), float angle = 0.0f,
-               const glm::vec3& color = glm::vec3(0.0f, 0.0f, 0.0f), bool is_selected = false) {
+    GameObject(int idx_loaded_models = 0, const glm::vec3& position = glm::vec3(0.0f, 0.0f, 0.0f), const glm::vec3& scale = glm::vec3(1.0f, 1.0f, 1.0f),
+               const glm::vec3& rotation = glm::vec3(0.0f, 0.0f, 0.0f), const glm::vec3& color = glm::vec3(0.0f, 0.0f, 0.0f), bool is_selected = false) {
         this->idx_loaded_models = idx_loaded_models;
-        this->position = pos;
+        this->position = position;
         this->scale = scale;
-        this->axis_rotation = axis_rot;
-        this->angle_rotation_degrees = angle;
+        this->rotation = rotation;
         this->color = color;
         this->is_selected = is_selected;
 
-        set_model_and_model_inv();
+        set_model_matrices_standard();
+    }
+
+    ~GameObject() {
+        for (int i = 0; i < children_game_objects.size(); i++) {
+            delete children_game_objects[i];
+        }
     }
 
-    void set_model_and_model_inv() {
+    void set_model_matrices_standard() {
         model = glm::mat4(1.0f);
         model = glm::translate(model, position);
-        model = glm::rotate(model, glm::radians(angle_rotation_degrees), axis_rotation);
+        model = glm::rotate(model, glm::radians(rotation.x), glm::vec3(1.0f, 0.0f, 0.0f));
+        model = glm::rotate(model, glm::radians(rotation.y), glm::vec3(0.0f, 1.0f, 0.0f));
+        model = glm::rotate(model, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
         model = glm::scale(model, scale);
 
         model_inv = glm::inverse(model);
+
+        model_normals = glm::mat3(glm::transpose(model_inv));
+    }
+
+    void set_model_matrices_type1(GameObject* parent) {
+        model = glm::mat4(1.0f);
+        model = glm::translate(model, parent->position);
+        model = glm::rotate(model, glm::radians(parent->rotation.x), glm::vec3(1.0f, 0.0f, 0.0f));
+        model = glm::rotate(model, glm::radians(parent->rotation.y), glm::vec3(0.0f, 1.0f, 0.0f));
+        model = glm::rotate(model, glm::radians(parent->rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
+
+        model = glm::translate(model, position * parent->scale);
+        model = glm::rotate(model, glm::radians(rotation.x), glm::vec3(1.0f, 0.0f, 0.0f));
+        model = glm::rotate(model, glm::radians(rotation.y), glm::vec3(0.0f, 1.0f, 0.0f));
+        model = glm::rotate(model, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
+        model = glm::scale(model, scale * parent->scale);
+
+        model_inv = glm::inverse(model);
+
+        model_normals = glm::mat3(glm::transpose(model_inv));
+    }
+
+    void draw(Shader* shader, Rendering* rendering) {
+        shader->setVec3("model_color", color);
+        shader->setMat4("model", model);
+        shader->setMat3("model_normals", model_normals);
+        shader->setMat4("model_view_projection", rendering->projection * rendering->view * model);
+        if (idx_loaded_models != -1) {
+            rendering->loaded_models[idx_loaded_models]->draw(*shader, is_selected, rendering);
+        }
+        for (int i = 0; i < children_game_objects.size(); i++) {
+            children_game_objects[i]->draw(shader, rendering);
+        }
+    }
+
+    bool intersected_ray(Rendering* rendering, const glm::vec3& ray_dir, const glm::vec3& camera_position, float& t) {
+        glm::vec3 ray_dir_model = model_inv * glm::vec4(ray_dir, 0.0f);
+        glm::vec3 ray_origin_model = model_inv * glm::vec4(camera_position, 1.0f);
+        if (idx_loaded_models != -1 && rendering->loaded_models[idx_loaded_models]->intersected_ray(ray_origin_model, ray_dir_model, t)) {
+            return true;
+        }
+        for (int i = 0; i < children_game_objects.size(); i++) {
+            if (children_game_objects[i]->intersected_ray(rendering, ray_dir, camera_position, t)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    void set_select_state(bool is_game_obj_selected) {
+        is_selected = is_game_obj_selected;
+        for (int i = 0; i < children_game_objects.size(); i++) {
+            children_game_objects[i]->set_select_state(is_game_obj_selected);
+        }
     }
 };
 
@@ -48,9 +113,9 @@ class Light : public GameObject {
 
     Light() {}
 
-    Light(int idx_loaded_models, const glm::vec3& pos, const glm::vec3& scale, const glm::vec3& axis_rot, float angle, const glm::vec3& color, bool is_selected,
+    Light(int idx_loaded_models, const glm::vec3& position, const glm::vec3& scale, const glm::vec3& rotation, const glm::vec3& color, bool is_selected,
           const glm::vec3& ambient, const glm::vec3& diffuse, const glm::vec3& specular)
-          : GameObject(idx_loaded_models, pos, scale, axis_rot, angle, color, is_selected) {
+          : GameObject(idx_loaded_models, position, scale, rotation, color, is_selected) {
         this->ambient = ambient;
         this->diffuse = diffuse;
         this->specular = specular;
@@ -63,9 +128,9 @@ class PointLight : public Light {
     float linear;
     float quadratic;
 
-    PointLight(int idx_loaded_models, const glm::vec3& pos, const glm::vec3& scale, const glm::vec3& axis_rot, float angle, const glm::vec3& color, bool is_selected,
+    PointLight(int idx_loaded_models, const glm::vec3& position, const glm::vec3& scale, const glm::vec3& rotation, const glm::vec3& color, bool is_selected,
                const glm::vec3& ambient, const glm::vec3& diffuse, const glm::vec3& specular, float constant, float linear, float quadratic)
-               : Light(idx_loaded_models, pos, scale, axis_rot, angle, color, is_selected, ambient, diffuse, specular) {
+               : Light(idx_loaded_models, position, scale, rotation, color, is_selected, ambient, diffuse, specular) {
         this->constant = constant;
         this->linear = linear;
         this->quadratic = quadratic;
@@ -76,9 +141,9 @@ class DirectionalLight : public Light {
 public:
     glm::vec3 direction;
 
-    DirectionalLight(int idx_loaded_models, const glm::vec3& pos, const glm::vec3& scale, const glm::vec3& axis_rot, float angle, const glm::vec3& color, bool is_selected,
+    DirectionalLight(int idx_loaded_models, const glm::vec3& position, const glm::vec3& scale, const glm::vec3& rotation, const glm::vec3& color, bool is_selected,
                      const glm::vec3& ambient, const glm::vec3& diffuse, const glm::vec3& specular, const glm::vec3& direction)
-                     : Light(idx_loaded_models, pos, scale, axis_rot, angle, color, is_selected, ambient, diffuse, specular) {
+                     : Light(idx_loaded_models, position, scale, rotation, color, is_selected, ambient, diffuse, specular) {
         this->direction = direction;
     }
 };
@@ -94,10 +159,10 @@ class SpotLight : public Light {
     float linear;
     float quadratic;
 
-    SpotLight(int idx_loaded_models, const glm::vec3& pos, const glm::vec3& scale, const glm::vec3& axis_rot, float angle, const glm::vec3& color, bool is_selected,
+    SpotLight(int idx_loaded_models, const glm::vec3& position, const glm::vec3& scale, const glm::vec3& rotation, const glm::vec3& color, bool is_selected,
               const glm::vec3& ambient, const glm::vec3& diffuse, const glm::vec3& specular, const glm::vec3& direction, float inner_cut_off, float outer_cut_off,
               float constant, float linear, float quadratic)
-              : Light(idx_loaded_models, pos, scale, axis_rot, angle, color, is_selected, ambient, diffuse, specular) {
+              : Light(idx_loaded_models, position, scale, rotation, color, is_selected, ambient, diffuse, specular) {
         this->direction = direction;
 
         this->inner_cut_off = inner_cut_off;
diff --git a/NeonEngine/src/input.cpp b/NeonEngine/src/input.cpp
@@ -52,11 +52,11 @@ void Input::process_viewport_input() {
         int game_object_key = rendering->check_mouse_over_models();
         std::cout << "ENDED CHECKING" << std::endl;
         if (rendering->key_selected_object != -1) {
-            rendering->game_objects[rendering->key_selected_object]->is_selected = false;
+            rendering->game_objects[rendering->key_selected_object]->set_select_state(false);
         }
         if (game_object_key != -1) {
             std::cout << "FOUND INTERSECTION" << std::endl;
-            rendering->game_objects[game_object_key]->is_selected = true;
+            rendering->game_objects[game_object_key]->set_select_state(true);
             rendering->key_selected_object = game_object_key;
             std::cout << "INTERSECTION DETECTED: " << game_object_key << std::endl;
         }
diff --git a/NeonEngine/src/mesh.h b/NeonEngine/src/mesh.h
@@ -135,15 +135,26 @@ class Mesh {
     }
 
     bool intersected_ray(const glm::vec3& orig, const glm::vec3& dir, float& t) {
+        float min_t = std::numeric_limits<float>::max();
+        float t_aux;
         for (int i = 0; i < indices.size(); i += 3) {
             glm::vec3 v0 = vertices[i].Position;
             glm::vec3 v1 = vertices[i+1].Position;
             glm::vec3 v2 = vertices[i+2].Position;
-            if (ray_triangle_intersection(orig, dir, v0, v1, v2, t)) {
-                return true;
+            if (ray_triangle_intersection(orig, dir, v0, v1, v2, t_aux)) {
+                if (t_aux < min_t) {
+                    min_t = t_aux;
+                }
             }
         }
-        return false;
+        if (min_t != std::numeric_limits<float>::max()) {
+            t = min_t;
+            return true;
+        }
+        else {
+            t = -1.0f;
+            return false;
+        }
     }
 
 private:
diff --git a/NeonEngine/src/rendering.cpp b/NeonEngine/src/rendering.cpp
@@ -74,15 +74,7 @@ int Rendering::check_mouse_over_models() {
         float min_t = std::numeric_limits<float>::max();
         for (auto it = game_objects.begin(); it != game_objects.end(); it++) {
             GameObject* game_object = it->second;
-            glm::vec3 ray_dir_model = game_object->model_inv * glm::vec4(ray_dir, 0.0f);
-            glm::vec3 ray_origin_model = game_object->model_inv * glm::vec4(camera_viewport->Position, 1.0f);
-
-            /*
-            if (game_object.idx_loaded_models != 0) {
-                continue;
-            }*/
-
-            if (loaded_models[game_object->idx_loaded_models]->intersected_ray(ray_origin_model, ray_dir_model, t)) {
+            if (game_object->intersected_ray(this, ray_dir, camera_viewport->Position, t)) {
                 if (t < min_t) {
                     min_t = t;
                     key_intersected_object = it->first;
@@ -104,39 +96,69 @@ void Rendering::initialize_game_objects() {
     int backpack1_key = key_generator->generate_key();
     game_objects[backpack1_key] = backpack1;
 
-    GameObject* backpack2 = new GameObject(0, glm::vec3(6.0f, 4.0f, -15.0f), glm::vec3(0.5f, 0.5f, 0.5f), glm::vec3(1.0f, 0.0f, 0.0f), 60.0f);
+    GameObject* backpack2 = new GameObject(0, glm::vec3(6.0f, 4.0f, -15.0f), glm::vec3(0.5f, 0.5f, 0.5f), glm::vec3(60.0f, 0.0f, 0.0f));
     int backpack2_key = key_generator->generate_key();
     game_objects[backpack2_key] = backpack2;
 
-    GameObject* cylinder1 = new GameObject(1, glm::vec3(3.0f, 7.0f, -6.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.8f, 1.0f, 0.3f), 60.0f, glm::vec3(1.0f, 1.0f, 0.0f));
+    GameObject* cylinder1 = new GameObject(1, glm::vec3(3.0f, 7.0f, -6.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(45.0f, 60.0f, 20.0f), glm::vec3(1.0f, 1.0f, 0.0f));
     int cylinder1_key = key_generator->generate_key();
     game_objects[cylinder1_key] = cylinder1;
 
-    GameObject* cone1 = new GameObject(2, glm::vec3(-3.0f, 7.0f, -6.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(1.0f, 0.0f, 0.0f), 0.0f, glm::vec3(0.0f, 1.0f, 0.0f));
+    GameObject* cone1 = new GameObject(2, glm::vec3(-3.0f, 7.0f, -6.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
     int cone1_key = key_generator->generate_key();
     game_objects[cone1_key] = cone1;
 
-    GameObject* cylinder2 = new GameObject(1, glm::vec3(-3.0f, -7.0f, -6.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(1.0f, 0.0f, 0.0f), 0.0f, glm::vec3(0.0f, 0.0f, 1.0f));
+    GameObject* cylinder2 = new GameObject(1, glm::vec3(-3.0f, -7.0f, -6.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f));
     int cylinder2_key = key_generator->generate_key();
     game_objects[cylinder2_key] = cylinder2;
 
+
+
+    GameObject* coord_axes_3D = new GameObject(-1, glm::vec3(0.0f, -3.0f, -3.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f));
+    int coord_axes_3D_key = key_generator->generate_key();
+    game_objects[coord_axes_3D_key] = coord_axes_3D;
+
+    GameObject* x_arrow_body = new GameObject(1, glm::vec3(0.0f, 0.0f, 1.5f), glm::vec3(0.1f, 0.1f, 3.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
+    x_arrow_body->set_model_matrices_type1(coord_axes_3D);
+    coord_axes_3D->children_game_objects.push_back(x_arrow_body);
     
+    GameObject* y_arrow_body = new GameObject(1, glm::vec3(0.0f, 1.5f, 0.0f), glm::vec3(0.1f, 0.1f, 3.0f), glm::vec3(90.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
+    y_arrow_body->set_model_matrices_type1(coord_axes_3D);
+    coord_axes_3D->children_game_objects.push_back(y_arrow_body);
+
+    GameObject* z_arrow_body = new GameObject(1, glm::vec3(1.5f, 0.0f, 0.0f), glm::vec3(0.1f, 0.1f, 3.0f), glm::vec3(0.0f, 90.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f));
+    z_arrow_body->set_model_matrices_type1(coord_axes_3D);
+    coord_axes_3D->children_game_objects.push_back(z_arrow_body);
+
+    GameObject* x_arrow_head = new GameObject(2, glm::vec3(0.0f, 0.0f, 3.0f), glm::vec3(0.3f, 0.3f, 0.6f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
+    x_arrow_head->set_model_matrices_type1(coord_axes_3D);
+    coord_axes_3D->children_game_objects.push_back(x_arrow_head);
+
+    GameObject* y_arrow_head = new GameObject(2, glm::vec3(0.0f, 3.0f, 0.0f), glm::vec3(0.3f, 0.3f, 0.6f), glm::vec3(-90.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
+    y_arrow_head->set_model_matrices_type1(coord_axes_3D);
+    coord_axes_3D->children_game_objects.push_back(y_arrow_head);
+
+    GameObject* z_arrow_head = new GameObject(2, glm::vec3(3.0f, 0.0f, 0.0f), glm::vec3(0.3f, 0.3f, 0.6f), glm::vec3(0.0f, 90.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f));
+    z_arrow_head->set_model_matrices_type1(coord_axes_3D);
+    coord_axes_3D->children_game_objects.push_back(z_arrow_head);
+
+
 
-    GameObject* point_light1 = new PointLight(1, glm::vec3(1.0f, 1.0f, -3.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(1.0f, 0.0f, 0.0f), 0.0f, glm::vec3(1.0f, 1.0f, 1.0f), false,
+    GameObject* point_light1 = new PointLight(1, glm::vec3(1.0f, 1.0f, -3.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 1.0f, 1.0f), false,
         glm::vec3(0.05f, 0.05f, 0.05f), glm::vec3(0.8f, 0.8f, 0.8f), glm::vec3(1.0f, 1.0f, 1.0f), 1.0f, 0.045f, 0.0075f);
     int point_light1_key = key_generator->generate_key();
     game_objects[point_light1_key] = point_light1;
     point_lights[point_light1_key] = (PointLight*)point_light1;
 
 
-    GameObject* directional_light1 = new DirectionalLight(1, glm::vec3(-5.0f, 5.0f, -3.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(1.0f, 0.0f, 0.0f), 0.0f, glm::vec3(1.0f, 1.0f, 1.0f), false,
+    GameObject* directional_light1 = new DirectionalLight(1, glm::vec3(-5.0f, 5.0f, -3.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 1.0f, 1.0f), false,
         glm::vec3(0.05f, 0.05f, 0.05f), glm::vec3(0.4f, 0.4f, 0.4f), glm::vec3(0.8f, 0.8f, 0.8f), glm::vec3(3.0f, -4.0f, -3.0f));
     int directional_light1_key = key_generator->generate_key();
     game_objects[directional_light1_key] = directional_light1;
     directional_lights[directional_light1_key] = (DirectionalLight*)directional_light1;
 
 
-    GameObject* spot_light1 = new SpotLight(1, glm::vec3(-5.0f, -5.0f, -3.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(1.0f, 0.0f, 0.0f), 0.0f, glm::vec3(1.0f, 1.0f, 1.0f), false,
+    GameObject* spot_light1 = new SpotLight(1, glm::vec3(-5.0f, -5.0f, -3.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 1.0f, 1.0f), false,
         glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(5.0f, 5.0f, -3.0f),
         glm::cos(glm::radians(12.5f)), glm::cos(glm::radians(15.0f)), 1.0f, 0.09f, 0.032f);
     int spot_light1_key = key_generator->generate_key();
@@ -208,11 +230,7 @@ void Rendering::render_viewport() {
     // render all the game objects
     for (auto it = game_objects.begin(); it != game_objects.end(); it++) {
         GameObject* game_object = it->second;
-        ourShader->setVec3("model_color", game_object->color);
-        ourShader->setMat4("model", game_object->model);
-        ourShader->setMat3("model_normals", glm::mat3(glm::transpose(glm::inverse(game_object->model))));
-        ourShader->setMat4("model_view_projection", projection * view * game_object->model);
-        loaded_models[game_object->idx_loaded_models]->draw(*ourShader, game_object->is_selected, this);
+        game_object->draw(ourShader, this);
     }
 
     glBindFramebuffer(GL_FRAMEBUFFER, 0);

Original file line number	Diff line number	Diff line change
`@@ -52,11 +52,11 @@ void Input::process_viewport_input() {`
`52`	`52`	`int game_object_key = rendering->check_mouse_over_models();`
`53`	`53`	`std::cout << "ENDED CHECKING" << std::endl;`
`54`	`54`	`if (rendering->key_selected_object != -1) {`
`55`		`- rendering->game_objects[rendering->key_selected_object]->is_selected = false;`
	`55`	`+ rendering->game_objects[rendering->key_selected_object]->set_select_state(false);`
`56`	`56`	`}`
`57`	`57`	`if (game_object_key != -1) {`
`58`	`58`	`std::cout << "FOUND INTERSECTION" << std::endl;`
`59`		`- rendering->game_objects[game_object_key]->is_selected = true;`
	`59`	`+ rendering->game_objects[game_object_key]->set_select_state(true);`
`60`	`60`	`rendering->key_selected_object = game_object_key;`
`61`	`61`	`std::cout << "INTERSECTION DETECTED: " << game_object_key << std::endl;`
`62`	`62`	`}`