[FIXED] collisions

* feature/number-from-images:
  [ADD] convert number to digits

src/collision/collision_handler.cpp

@@ -3,7 +3,7 @@
 
 namespace collision
 {
-	void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>> entities)
+	void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>>& entities)
 	{
 		if (entities.size() < 2) { return; }
 			if (entities.size() == 2)
@@ -15,7 +15,7 @@ namespace collision
 					entities[1]->OnCollide(c);
 				}
 			}
-
+		
 			for (int i = 0; i < entities.size() - 2; i++)
 			{
 				std::shared_ptr<entities::CollisionEntity> entity = entities[i];

src/collision/collision_handler.h

@@ -13,5 +13,5 @@ namespace collision
 	 *
 	 * @param entities: A list with all the collision entities.
 	 */
-	void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>> entities);
+	void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>>& entities);
 }

src/computervision/async/StaticCameraInstance.h

@@ -6,7 +6,7 @@ namespace static_camera
 
 	static cv::VideoCapture getCap()
 	{
-		static cv::VideoCapture cap(0);
+		static cv::VideoCapture cap(1);
 		return cap;
 	}
 };

src/entities/collision_entity.cpp

@@ -40,7 +40,10 @@ namespace entities
 		
 		const glm::vec3 size = bounding_box.size;
 
-		min_xyz = bounding_box.center_pos;
+		min_xyz = { bounding_box.center_pos.x - (0.5 * size.x), bounding_box.center_pos.y, bounding_box.center_pos.z - (0.5 * size.z) };
-		max_xyz = glm::vec3(min_xyz.x + size.x, min_xyz.y + size.y, min_xyz.z + size.z);
+		max_xyz = { bounding_box.center_pos.x + (0.5 * size.x), bounding_box.center_pos.y + size.y, bounding_box.center_pos.z + (0.5 * size.z) };
+
+		// min_xyz = bounding_box.center_pos;
+		// max_xyz = { bounding_box.center_pos.x + size.x, bounding_box.center_pos.y + size.y, bounding_box.center_pos.z + size.z };
 	}
 }

src/entities/collision_entity.h

@@ -58,7 +58,7 @@ namespace entities
 		void SetCollisionBehaviour(std::function<void(const collision::Collision&)> function)
 		{ if (function != nullptr) { on_collide = function; } }
 
-	protected:
+	public:
 
 		/*
 		 * @brief: This method moves the collision to the center of the entity

src/entities/house_generator.cpp

@@ -20,71 +20,76 @@ namespace entities
 		GenerateFurnitureModels();
 	}
 
-	std::deque<std::shared_ptr<Entity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
+	std::deque<std::shared_ptr<CollisionEntity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
 	{
-		std::deque<std::shared_ptr<Entity>> furniture;
+		std::deque<std::shared_ptr<CollisionEntity>> furniture;
 
 		// Add house
-		furniture.push_front(std::make_shared<Entity>(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE));
+		collision::Box house_box = { position, glm::vec3(0,0,0) };
+		furniture.push_front(std::make_shared<CollisionEntity>(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE, house_box));
 
-		for(int i = 0; i<toolbox::Random(1,4);i++)
+		// for(int i = 0; i<toolbox::Random(1,4);i++)
-		{
+		// {
-			FurnitureType type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
+		// 	FurnitureType type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
-			models::TexturedModel model = GetFurnitureModel(type);
+		// 	models::TexturedModel model = GetFurnitureModel(type);
-			glm::vec3 model_pos = glm::vec3(position.x, position.y, position.z);
+		// 	glm::vec3 model_pos = glm::vec3(position.x, position.y, position.z);
-			collision::Box model_box = { model_pos, model.raw_model.model_size };
+		// 	collision::Box model_box = { model_pos, model.raw_model.model_size };
-			model_box.SetRotation(-90);
+		// 	model_box.SetRotation(-90);
-			furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box));
+		// 	furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box));
-		}
+		// 	//furniture_collision.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box));
+		// 	
+		// }
+
+		//furniture_collision.pop_front();
+		
 		
-		/*
 		// Add furniture
-		models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH);
+		 // models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH);
-		glm::vec3 couch_pos = glm::vec3(position.x + 200, position.y, position.z + 10);
+		 // glm::vec3 couch_pos = glm::vec3(position.x + 200, position.y, position.z + 10);
-		collision::Box couch_box = { couch_pos, couch.raw_model.model_size };
+		 // collision::Box couch_box = { couch_pos, couch.raw_model.model_size * (HOUSE_SIZE) };
-		couch_box.SetRotation(-90);
+		 // couch_box.SetRotation(-90);
-		furniture.push_back(std::make_shared<CollisionEntity>(couch, couch_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, couch_box));
+		 // furniture.push_back(std::make_shared<CollisionEntity>(couch, couch_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, couch_box));
-
+		 //
-		models::TexturedModel table = GetFurnitureModel(FurnitureType::TABLE);
+		 // models::TexturedModel table = GetFurnitureModel(FurnitureType::TABLE);
-		glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
+		 // glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
-		collision::Box table_box = { table_pos, table.raw_model.model_size };
+		 // collision::Box table_box = { table_pos, table.raw_model.model_size * ((HOUSE_SIZE) * 1.3f) };
-		furniture.push_back(std::make_shared<CollisionEntity>(table, table_pos, glm::vec3(0, 0, 0), HOUSE_SIZE * 1.3, table_box));
+		 // furniture.push_back(std::make_shared<CollisionEntity>(table, table_pos, glm::vec3(0, 0, 0), HOUSE_SIZE * 1.3, table_box));
-
+		 //
-		models::TexturedModel chair = GetFurnitureModel(FurnitureType::CHAIR);
+		 // models::TexturedModel chair = GetFurnitureModel(FurnitureType::CHAIR);
-		glm::vec3 chair_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		 // glm::vec3 chair_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		collision::Box chair_box = { chair_pos, chair.raw_model.model_size };
+		 // collision::Box chair_box = { chair_pos, chair.raw_model.model_size * (HOUSE_SIZE) };
-		furniture.push_back(std::make_shared<CollisionEntity>(chair, chair_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, chair_box));
+		 // furniture.push_back(std::make_shared<CollisionEntity>(chair, chair_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, chair_box));
-
+		 //
-		models::TexturedModel plant = GetFurnitureModel(FurnitureType::PLANT);
+		 // models::TexturedModel plant = GetFurnitureModel(FurnitureType::PLANT);
-		glm::vec3 plant_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		 // glm::vec3 plant_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		collision::Box plant_box = { plant_pos, plant.raw_model.model_size };
+		 // collision::Box plant_box = { plant_pos, plant.raw_model.model_size * (HOUSE_SIZE) };
-		furniture.push_back(std::make_shared<CollisionEntity>(plant, plant_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, plant_box));
+		 // furniture.push_back(std::make_shared<CollisionEntity>(plant, plant_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, plant_box));
-
+		 //
-		models::TexturedModel guitar = GetFurnitureModel(FurnitureType::GUITAR);
+		 // models::TexturedModel guitar = GetFurnitureModel(FurnitureType::GUITAR);
-		glm::vec3 guitar_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		 // glm::vec3 guitar_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		collision::Box guitar_box = { guitar_pos, guitar.raw_model.model_size };
+		 // collision::Box guitar_box = { guitar_pos, guitar.raw_model.model_size * (HOUSE_SIZE) };
-		furniture.push_back(std::make_shared<CollisionEntity>(guitar, guitar_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, guitar_box));
+		 // furniture.push_back(std::make_shared<CollisionEntity>(guitar, guitar_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, guitar_box));
-		
+		 //
-		models::TexturedModel bookshelf = GetFurnitureModel(FurnitureType::BOOKSHELF);
+		 // models::TexturedModel bookshelf = GetFurnitureModel(FurnitureType::BOOKSHELF);
-		glm::vec3 bookshelf_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		 // glm::vec3 bookshelf_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		collision::Box bookshelf_box = { bookshelf_pos, bookshelf.raw_model.model_size };
+		 // collision::Box bookshelf_box = { bookshelf_pos, bookshelf.raw_model.model_size * (HOUSE_SIZE) };
-		furniture.push_back(std::make_shared<CollisionEntity>(bookshelf, bookshelf_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, bookshelf_box));
+		 // furniture.push_back(std::make_shared<CollisionEntity>(bookshelf, bookshelf_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, bookshelf_box));
-
+		 //
-		models::TexturedModel lamp = GetFurnitureModel(FurnitureType::LAMP);
+		 // models::TexturedModel lamp = GetFurnitureModel(FurnitureType::LAMP);
-		glm::vec3 lamp_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		 // glm::vec3 lamp_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		collision::Box lamp_box = { lamp_pos, lamp.raw_model.model_size };
+		 // collision::Box lamp_box = { lamp_pos, lamp.raw_model.model_size * (HOUSE_SIZE) };
-		furniture.push_back(std::make_shared<CollisionEntity>(lamp, lamp_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, lamp_box));
+		 // furniture.push_back(std::make_shared<CollisionEntity>(lamp, lamp_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, lamp_box));
-
+		 //
-		models::TexturedModel ceiling_object = GetFurnitureModel(FurnitureType::CEILING_OBJECTS);
+		 // models::TexturedModel ceiling_object = GetFurnitureModel(FurnitureType::CEILING_OBJECTS);
-		glm::vec3 ceiling_object_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		 // glm::vec3 ceiling_object_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		collision::Box ceiling_object_box = { ceiling_object_pos, ceiling_object.raw_model.model_size };
+		 // collision::Box ceiling_object_box = { ceiling_object_pos, ceiling_object.raw_model.model_size * (HOUSE_SIZE / 2) };
-		furniture.push_back(std::make_shared<CollisionEntity>(ceiling_object, ceiling_object_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, ceiling_object_box));
+		 // furniture.push_back(std::make_shared<CollisionEntity>(ceiling_object, ceiling_object_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, ceiling_object_box));
 
 		models::TexturedModel misc = GetFurnitureModel(FurnitureType::MISC);
-		glm::vec3 misc_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		glm::vec3 misc_pos = glm::vec3(position.x - 50, position.y - 10, position.z + 220);
-		collision::Box misc_box = { misc_pos, misc.raw_model.model_size };
+		collision::Box misc_box = { misc_pos, misc.raw_model.model_size * (HOUSE_SIZE) };
 		furniture.push_back(std::make_shared<CollisionEntity>(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box));
-		*/
+		
 		return furniture;
 	}
 
@@ -255,4 +260,9 @@ namespace entities
 
 		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::MISC, miscs));
 	}
+
+	/*std::deque<std::shared_ptr<CollisionEntity>> HouseGenerator::GetFurnitureCollisions() 
+	{
+		return furniture_collision;
+	}*/
 }

src/entities/house_generator.h

@@ -5,6 +5,7 @@
 #include <map>
 #include "../models/Model.h"
 #include "../collision/collision.h"
+#include "collision_entity.h"
 
 namespace entities
 {
@@ -30,6 +31,8 @@ namespace entities
 		models::ModelTexture default_texture;
 		
 		std::map<FurnitureType, std::deque<models::TexturedModel>> furniture_models;
+		//std::deque<std::shared_ptr<CollisionEntity>> furniture_collision;
+
 
 	public:
 		HouseGenerator();
@@ -42,12 +45,17 @@ namespace entities
 		 *
 		 * @return: A list with all the entities of the generated house (the furniture)
 		 */
-		std::deque<std::shared_ptr<Entity>> GenerateHouse(const glm::vec3& position, float y_rotation);
+		std::deque<std::shared_ptr<CollisionEntity>> GenerateHouse(const glm::vec3& position, float y_rotation);
 
 		/*
 		 * @brief: Returns the depth of the house (chunk)
 		 */
-		float GetHouseDepth() const { return house_model.raw_model.model_size.x * HOUSE_SIZE; }
+		float GetHouseDepth() const { return house_model.raw_model.model_size.x * HOUSE_SIZE; 
+		
+		}
+
+		//std::deque<std::shared_ptr<CollisionEntity>> GetFurnitureCollisions();
+
 	
 	private:
 		/*

src/entities/main_character.cpp

@@ -22,7 +22,7 @@ namespace entities
 	void MainCharacter::Move(GLFWwindow* window)
 	{
 		if (is_playing) {
-			movement_speed = -0.5f;	//Forward speed adjustment, bee is moving at a standard speedrate
+			movement_speed = -2.0f;	//Forward speed adjustment, bee is moving at a standard speedrate
 			down_speed = -1.0f;		//Down speed adjustment, downspeed is difference between down_speed and UP_SPEED	
 			side_speed = 0;			//Side speed adjustment
 
@@ -97,4 +97,8 @@ namespace entities
 		is_playing = false;
 		std::cout << "collision" << std::endl;
 	}
+
+	bool MainCharacter::GetOnCollide() {
+		return is_playing;
+	}
 }

src/entities/main_character.h

@@ -34,5 +34,7 @@ namespace entities
 		void Move(GLFWwindow* window);
 
 		void OnCollide(const collision::Collision& collision) override;
+	
+		bool GetOnCollide();
 	};
 }

src/main.cpp

@@ -27,6 +27,8 @@
 #include "scenes/scene.h"
 #include "scenes/in_Game_Scene.h"
 #include "scenes/startup_Scene.h"
+#include "scenes/game_Over_Scene.h"
+#include "entities/collision_entity.h"
 
 #include "computervision/ObjectDetection.h"
 //#include "computervision/OpenPoseImage.h"
@@ -112,6 +114,10 @@ int main(void)
                 current_scene = new scene::In_Game_Scene();
                 break;
                 
+            case scene::Scenes::GAMEOVER:
+                current_scene = new scene::Game_Over_Scene();
+                break;
+
             default:
                 std::cout << "Wrong return value!!! ->" << std::endl;
                 break;
@@ -137,4 +143,4 @@ static double UpdateDelta()
 	double delt_time = current_time - last_frame_time;
 	last_frame_time = current_time;
 	return delt_time;
-}
+}

src/renderEngine/Renderer.cpp

@@ -121,5 +121,87 @@ namespace render_engine
 
 			shader.Stop();
 		}
+
+		void Render(std::vector<std::shared_ptr<gui::GuiTexture>>& guis, shaders::GuiShader& shader)
+		{
+			shader.Start();
+
+			// Enable the VAO and the positions VBO
+			glBindVertexArray(quad.vao_id);
+			glEnableVertexAttribArray(0);
+
+			// Enable alpha blending (for transparency in the texture)
+			glEnable(GL_BLEND);
+			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+			// Disable depth testing to textures with transparency can overlap
+			glDisable(GL_DEPTH_TEST);
+
+			// Render each gui to the screen
+			for (std::shared_ptr<gui::GuiTexture> gui : guis)
+			{
+				// Bind the texture of the gui to the shader
+				glActiveTexture(GL_TEXTURE0);
+				glBindTexture(GL_TEXTURE_2D, gui->texture);
+
+				glm::mat4 matrix = toolbox::CreateModelMatrix(gui->position, gui->scale);
+				shader.LoadModelMatrix(matrix);
+
+				glDrawArrays(GL_TRIANGLE_STRIP, 0, quad.vertex_count);
+
+				std::cout << "in render method, gui x value: " << gui.get()->scale.x << std::endl;
+			}
+
+			// Enable depth test again
+			glEnable(GL_DEPTH_TEST);
+
+			// Disable alpha blending
+			glDisable(GL_BLEND);
+
+			// Disable the VBO and VAO
+			glDisableVertexAttribArray(0);
+			glBindVertexArray(0);
+
+			shader.Stop();
+		}
+
+		void Render(std::shared_ptr<gui::GuiTexture>& gui, shaders::GuiShader& shader)
+		{
+			shader.Start();
+
+			// Enable the VAO and the positions VBO
+			glBindVertexArray(quad.vao_id);
+			glEnableVertexAttribArray(0);
+
+			// Enable alpha blending (for transparency in the texture)
+			glEnable(GL_BLEND);
+			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+			// Disable depth testing to textures with transparency can overlap
+			glDisable(GL_DEPTH_TEST);
+
+			// Render each gui to the screen
+			// Bind the texture of the gui to the shader
+			glActiveTexture(GL_TEXTURE0);
+			glBindTexture(GL_TEXTURE_2D, gui->texture);
+
+			glm::mat4 matrix = toolbox::CreateModelMatrix(gui->position, gui->scale);
+			shader.LoadModelMatrix(matrix);
+
+			glDrawArrays(GL_TRIANGLE_STRIP, 0, quad.vertex_count);
+
+
+			// Enable depth test again
+			glEnable(GL_DEPTH_TEST);
+
+			// Disable alpha blending
+			glDisable(GL_BLEND);
+
+			// Disable the VBO and VAO
+			glDisableVertexAttribArray(0);
+			glBindVertexArray(0);
+
+			shader.Stop();
+		}
 	}
 }

src/renderEngine/Renderer.h

@@ -40,5 +40,22 @@ namespace render_engine
 			@param shade: The shader the GUI textures need to be rendered with
 		 */
 		void Render(std::vector<gui::GuiTexture*>& guis, shaders::GuiShader& shader);
+
+		/*
+		* @brief: renders guis elements from a shared pointer vector
+		* 
+		* @param  guis: List with GUI textures to render
+		* @param sahde: The shader to use
+		*/
+		void Render(std::vector<std::shared_ptr<gui::GuiTexture>>& guis, shaders::GuiShader& shader);
+
+
+		/*
+		 * @brief renders 1 gui element.
+		 *
+		 * @param gui: the texture to render
+		 * @param shader: the shader to use
+		 */
+		void Render(std::shared_ptr<gui::GuiTexture>& gui, shaders::GuiShader& shader);
 	}
 }

src/scenes/game_Over_Scene.cpp

@@ -0,0 +1,184 @@
+#include <iostream>
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <map>
+#include "game_Over_Scene.h"
+#include <iostream>
+#include <opencv2/core/mat.hpp>
+
+#include "../models/model.h"
+#include "../renderEngine/loader.h"
+#include "../renderEngine/obj_loader.h"
+#include "../renderEngine/renderer.h"
+#include "../shaders/entity_shader.h"
+#include "../gui/gui_interactable.h"
+#include "../toolbox/toolbox.h"
+#include "../computervision/MenuTest.h"
+#include "../computervision/ObjectDetection.h"
+#include "../computervision/HandDetectRegion.h"
+
+namespace scene
+{
+	shaders::GuiShader* gui_shader_gameOver;
+	std::vector<gui::GuiTexture*> guis_gameOver;
+	computervision::ObjectDetection objDetect_gameOver;
+
+	float item_number_gameOver = 0;
+
+	bool hand_mode_gameOver = false;
+
+	Game_Over_Scene::Game_Over_Scene() 
+	{
+		shaders::EntityShader shader;
+		shader.Init();
+		render_engine::renderer::Init(shader);
+		shader.CleanUp();
+
+		gui_shader_gameOver = new shaders::GuiShader();
+		gui_shader_gameOver->Init();
+	}
+
+	gui::Button* ConvertGuiTextureToButtonGameOver(gui::GuiTexture* texture) {
+		gui::Button* button;
+		if (texture != NULL)
+		{
+
+			if (texture->GetType() == gui::GuiType::BUTTON) {
+
+				button = (gui::Button*)texture;
+				return button;
+			}
+			else {
+				button = nullptr;
+				return button;
+			}
+		}
+		else {
+			button = nullptr;
+			return button;
+		}
+	}
+
+	gui::GuiTexture* GetMenuItemGameOver(bool hand_state) {
+		if (hand_state)
+			item_number_gameOver += 0.20f;
+
+		int temp_item_number = item_number_gameOver;
+
+		//If temp_item_number is equal to the size of the array, set item_number bac to zero to loop through the array again
+		if (temp_item_number == guis_gameOver.size()) {
+			item_number_gameOver = 0;
+			temp_item_number = 0;
+		}
+		std::cout << guis_gameOver[temp_item_number]->texture << std::endl;
+		return guis_gameOver[temp_item_number];
+	}
+
+	scene::Scenes scene::Game_Over_Scene::start(GLFWwindow* window) {
+		gui::Button button_start_scene(render_engine::loader::LoadTexture("res/Birb1.jpg"), glm::vec2(0.0f, 0.6f), glm::vec2(0.25f, 0.25f));
+		button_start_scene.SetHoverTexture(render_engine::loader::LoadTexture("res/Birb2.jpg"));
+		button_start_scene.SetClickedTexture(render_engine::loader::LoadTexture("res/Birb3.jpg"));
+		button_start_scene.SetOnClickAction([]()
+			{
+				std::cout << "Back to start screen!!" << std::endl;
+			});
+		guis_gameOver.push_back(&button_start_scene);
+	
+		computervision::ObjectDetection objDetect;
+		cv::Mat cameraFrame;
+		gui::GuiTexture* chosen_item_gameOver = NULL; //This is the selected menu_item
+		bool hand_closed = false; //Flag to prevent multiple button presses
+
+		while (return_value == scene::Scenes:: GAMEOVER)
+		{
+			render();
+			update(window);
+
+			if (hand_mode_gameOver) 
+			{
+				cameraFrame = objDetect_gameOver.ReadCamera();
+
+				bool detect = false;
+				bool hand_detection = objDetect_gameOver.DetectHand(cameraFrame, detect);
+
+				if (hand_detection) 
+				{
+					hand_closed = false;
+					std::cout << "hand is opened" << std::endl;
+
+					//Loop through menu items
+					chosen_item_gameOver = GetMenuItemGameOver(true);
+
+					gui::Button* new_button = ConvertGuiTextureToButtonGameOver(chosen_item_gameOver);
+					if (new_button != NULL) {
+						const float x_pos = (chosen_item_gameOver->position.x + 1.0) * WINDOW_WIDTH / 2;
+						const float y_pos = (1.0 - chosen_item_gameOver->position.y) * WINDOW_HEIGHT / 2;
+
+						//Set cursor to location of selected menu_item
+						glfwSetCursorPos(window, x_pos, y_pos);
+					}
+				}
+				else if (!hand_detection)
+				{
+					std::cout << "hand is closed" << std::endl;
+
+					//Gets selected menu_item
+					chosen_item_gameOver = GetMenuItemGameOver(false);
+					gui::Button* new_button = ConvertGuiTextureToButtonGameOver(chosen_item_gameOver);
+
+					if (new_button != NULL && !hand_closed) {
+						//Run function click
+						new_button->ForceClick(GLFW_MOUSE_BUTTON_LEFT);
+						hand_closed = true;
+					}
+				}
+			}
+			glfwSwapBuffers(window);
+			glfwPollEvents();
+		}
+
+		gui_shader_gameOver->CleanUp();
+		render_engine::loader::CleanUp();
+		return return_value;
+	}
+
+	/**
+	 * renders the models in the start-up scene
+	 */
+	void scene::Game_Over_Scene::render()
+	{
+		render_engine::renderer::Prepare();
+
+		// Render GUI items
+		render_engine::renderer::Render(guis_gameOver, *gui_shader_gameOver);
+	}
+
+	/**
+	 * updates the variables for the start-up scene
+	 */
+	void scene::Game_Over_Scene::update(GLFWwindow* window)
+	{
+		for (gui::GuiTexture* button : guis_gameOver) {
+			gui::Button* new_button = ConvertGuiTextureToButtonGameOver(button);
+			if (new_button != NULL)
+				new_button->Update(window);
+		}
+		bool hand_present;
+		objDetect_gameOver.DetectHand(objDetect_gameOver.ReadCamera(), hand_present);
+	}
+
+	/**
+	 * manages the key input in the start-up scene
+	 */
+	void scene::Game_Over_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
+	{
+		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+		{
+			return_value = scene::Scenes::INGAME;
+			cv::destroyWindow("camera");
+		}
+		else if (glfwGetKey(window, GLFW_KEY_BACKSPACE) == GLFW_PRESS) {
+			hand_mode_gameOver = !hand_mode_gameOver;
+		}
+	}
+}

src/scenes/game_Over_Scene.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "scene.h"
+#include "../gui/gui_element.h"
+
+namespace scene
+{
+	extern GLFWwindow* window;
+
+	class Game_Over_Scene : public scene::Scene
+	{
+	private:
+		scene::Scenes return_value = scene::Scenes::GAMEOVER;
+
+	public:
+		Game_Over_Scene();
+
+		Scenes start(GLFWwindow* window) override;
+
+		void render() override;
+
+		void update(GLFWwindow* window) override;
+
+		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
+
+	};
+}

src/scenes/in_Game_Scene.cpp

@@ -21,16 +21,17 @@
 #include <opencv2/core/base.hpp>
 #include "../computervision/HandDetectRegion.h"
 #include "../computervision/ObjectDetection.h"
+#include <string>
 
 #define MAX_MODEL_DEQUE_SIZE 6 // max amount of models to load at the same time
 #define UPCOMING_MODEL_AMOUNT 4 // how much models should be loaded in front of us
 
 
-
 namespace scene
 {
 	std::shared_ptr<entities::MainCharacter>main_character;
 	std::vector<std::shared_ptr<entities::CollisionEntity>> collision_entities;
+
 	entities::HouseGenerator* house_generator;
 	std::deque<std::shared_ptr<entities::Entity>> house_models;
 
@@ -39,6 +40,7 @@ namespace scene
 	shaders::EntityShader* shader;
 	shaders::GuiShader* gui_shader;
 	std::vector<gui::GuiTexture*> guis;
+	std::vector<std::shared_ptr<gui::GuiTexture>> score_textures;
 
 	int furniture_count_old;
 	int score;
@@ -60,7 +62,26 @@ namespace scene
 		gui_shader = new shaders::GuiShader();
 		gui_shader->Init();
 		score = 0;
+
+		for (int i = 0; i <= 9; i++) 
+		{
+			std::shared_ptr<gui::GuiTexture> score_pointer;
+
+			std::string texture_path = "res/";
+			texture_path += std::to_string(i);
+			texture_path += ".png";
+			
+			score_pointer = std::make_unique<gui::GuiTexture>(render_engine::loader::LoadTexture(texture_path), glm::vec2(-0.9f, 0.8f), glm::vec2(0.07, 0.15));
+			
+			score_textures.push_back(score_pointer);
+
+			std::cout << "Add to score_pointer: " << texture_path << std::endl;
+		}
+
+		std::cout << "Size textures: " << score_textures.size() << std::endl;
+		
 	}
+
 	/**
 	 * temporary!!!!
 	 * just to make some bounding boxes
@@ -109,16 +130,19 @@ namespace scene
 			for (int i = 0; i < furniture_count; i++)
 			{
 				house_models.pop_front();
+				collision_entities.pop_back();
 			}
 		}
 		int z_offset = model_pos * (house_generator->GetHouseDepth()); // how much "in the distance" we should load the model
 
-		std::deque<std::shared_ptr<entities::Entity>> furniture = house_generator->GenerateHouse(glm::vec3(0, -75, -50 - z_offset), 90);
+		std::deque<std::shared_ptr<entities::CollisionEntity>> furniture = house_generator->GenerateHouse(glm::vec3(0, -75, -50 - z_offset), 90);
 		furniture_count = furniture.size();
-
+		
 		house_models.insert(house_models.end(), furniture.begin(), furniture.end());
+		collision_entities.insert(collision_entities.end(), furniture.begin(), furniture.end());
 		std::cout << "funriture_count in load chunk (house included): " << furniture_count << std::endl;
 		furniture_count_old = furniture_count - 1;
+
 	}
 
 	/**
@@ -130,7 +154,6 @@ namespace scene
 		texture.shine_damper = 10;
 		texture.reflectivity = 0;
 
-
 		raw_model_char = render_engine::LoadObjModel("res/beeTwo.obj");
 		models::TexturedModel model_char = { raw_model_char, texture };
 		collision::Box char_box = create_bounding_box(raw_model_char.model_size, glm::vec3(0, 0, 0), 1);
@@ -206,7 +229,6 @@ namespace scene
 				break;
 			}
 
-
 			glfwSwapBuffers(window);
 			glfwPollEvents();
 		}
@@ -241,14 +263,19 @@ namespace scene
 
 		// Stop rendering the entities
 		shader->Stop();
+
+		DrawScore(score);
 	}
 
 	//updates certain variables 
 	void scene::In_Game_Scene::update(GLFWwindow* window)
 	{
 		//camera.Move(window);
-
 		main_character->Move(window);
+		if (!main_character.get()->GetOnCollide())
+		{
+			//return_value = scene::Scenes::GAMEOVER;
+		}
 
 		//std::cout << "x get: " << movement.x << "\ny get: " << movement.y << "\nz get: " << movement.z << "\n";
 		camera->Follow(main_character->GetPosition());
@@ -263,12 +290,14 @@ namespace scene
 			load_chunk(model_pos + UPCOMING_MODEL_AMOUNT);
 			score += furniture_count_old;
 			std::cout << "Score: " << score << std::endl;
-			std::cout << "Funriture_count_old in model (house excluded): " << furniture_count_old << std::endl;
+			std::cout << "Furniture_count_old in model (house excluded): " << furniture_count_old << std::endl;
 		}
 		// remember the position at which the new model was added
 		last_model_pos = model_pos;
 
+		std::cout << "amount of collision entities: " << collision_entities.size() << std::endl;
 		collision::CheckCollisions(collision_entities);
+		
 		update_hand_detection();
 	}
 
@@ -320,4 +349,19 @@ namespace scene
 	{
 		render_engine::renderer::Render(pause_guis, *gui_shader);
 	}
+
+	void In_Game_Scene::DrawScore(int score) 
+	{	
+		std::vector<int> digits;
+		score_guis.clear();
+
+		toolbox::GetDigitsFromNumber(score, digits);
+
+		for (int i = digits.size()-1; i >= 0; i--)
+		{
+			score_textures[digits[i]].get()->position.x = 0.15 * i -0.9;
+			render_engine::renderer::Render(score_textures[digits[i]], *gui_shader);
+
+		}
+	}
 }

src/scenes/in_Game_Scene.h

@@ -11,6 +11,9 @@
 #include "../renderEngine/renderer.h"
 #include "../shaders/entity_shader.h"
 #include "../toolbox/toolbox.h"
+#include <opencv2/core/base.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
 
 
 namespace scene
@@ -54,6 +57,8 @@ namespace scene
 		//pause_guis is a list of components that will be rendered when the game is paused.
 		std::vector<gui::GuiTexture*> pause_guis;
 
+		std::vector<std::shared_ptr<gui::GuiTexture>> score_guis;
+
 		/**
 		 * @brief renders the objects/gui models
 		 * @param 
@@ -97,6 +102,13 @@ namespace scene
 		 * @return void
 		 */
 		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
+	
+		/**
+		* @brief: This method renders the score points onto the game window
+		* @param score: Score to show
+		*/
+		void DrawScore(int score);
+
 	};
 }
 

src/toolbox/toolbox.cpp

@@ -1,6 +1,6 @@
 #include <ctime>
 #include "toolbox.h"
-
+#include <iostream>
 namespace toolbox
 {
 	glm::mat4 CreateModelMatrix(glm::vec2 translation, glm::vec2 scale)
@@ -56,4 +56,12 @@ namespace toolbox
 		}
 		return min + rand() % ((max + 1) - min);
 	}
+
+	void GetDigitsFromNumber(int number, std::vector<int>& result_vector)
+	{
+		if (number >= 10)
+			GetDigitsFromNumber(number / 10, result_vector);
+
+		result_vector.push_back(number % 10);
+	}
 }

src/toolbox/toolbox.h

@@ -2,6 +2,7 @@
 
 #include "../entities/camera.h"
 #include <glm/gtc/matrix_transform.hpp>
+#include <vector>
 
 namespace toolbox
 {
@@ -78,4 +79,13 @@ namespace toolbox
 	 * @return: The random number
 	 */
 	int Random(const int min, const int max);
+
+
+	/**
+	 * @brief gets the separate digits from the number.
+	 * 
+	 * @param number the number to get the digits from
+	 * @param result_vector the vector to hold the individual digits.
+	 */
+	void GetDigitsFromNumber(int number, std::vector<int>& result_vector);
 }

wk2_fps.vcxproj

@@ -24,6 +24,7 @@
     <ClCompile Include="src\entities\house_generator.cpp" />
     <ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
     <ClCompile Include="src\computervision\HandDetectRegion.cpp" />
+    <ClCompile Include="src\scenes\game_Over_Scene.cpp" />
     <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
     <ClCompile Include="src\computervision\MenuTest.cpp" />
     <ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
@@ -55,6 +56,7 @@
     <ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
     <ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
     <ClInclude Include="src\computervision\HandDetectRegion.h" />
+    <ClInclude Include="src\scenes\game_Over_Scene.h" />
     <ClInclude Include="src\scenes\in_Game_Scene.h" />
     <ClInclude Include="src\scenes\scene.h" />
     <ClInclude Include="src\computervision\async\async_arm_detection.h" />

wk2_fps.vcxproj.filters

@@ -24,6 +24,11 @@
     <ClCompile Include="src\scenes\startup_Scene.cpp" />
     <ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
     <ClCompile Include="src\computervision\HandDetectRegion.cpp" />
+    <ClCompile Include="src\entities\main_character.cpp" />
+    <ClCompile Include="src\entities\house_generator.cpp" />
+    <ClCompile Include="src\computervision\MenuTest.cpp" />
+    <ClCompile Include="src\scenes\scene.cpp" />
+    <ClCompile Include="src\scenes\game_Over_Scene.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\entities\Camera.cpp">
@@ -83,98 +88,8 @@
     <ClCompile Include="src\computervision\BackgroundRemover.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\computervision\MenuTest.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\scenes\scene.cpp">
-	 <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\entities\house_generator.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\entities\Camera.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\entities\Entity.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\models\Model.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\renderEngine\Loader.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\renderEngine\Renderer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\stb_image.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\shaders\shader_program.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\renderEngine\obj_loader.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\toolbox\toolbox.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\entities\light.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\shaders\entity_shader.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\shaders\gui_shader.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\gui\gui_element.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\gui\gui_interactable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\scenes\scene.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\scenes\in_Game_Scene.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\scenes\startup_Scene.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\entities\collision_entity.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\collision\collision.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\collision\collision_handler.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\computervision\ObjectDetection.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\computervision\SkinDetector.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\computervision\FingerCount.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\computervision\BackgroundRemover.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\toolbox\Timer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\computervision\MenuTest.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\entities\house_generator.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="src\collision\collision.h" />
     <ClInclude Include="src\collision\collision_handler.h" />
     <ClInclude Include="src\scenes\in_Game_Scene.h" />
@@ -206,6 +121,35 @@
     <ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
     <ClInclude Include="src\computervision\HandDetectRegion.h" />
     <ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
+    <ClInclude Include="src\collision\collision.h" />
+    <ClInclude Include="src\collision\collision_handler.h" />
+    <ClInclude Include="src\entities\main_character.h" />
+    <ClInclude Include="src\entities\house_generator.h" />
+    <ClInclude Include="src\scenes\in_Game_Scene.h" />
+    <ClInclude Include="src\scenes\scene.h" />
+    <ClInclude Include="src\computervision\FingerCount.h" />
+    <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\computervision\MenuTest.h" />
+    <ClInclude Include="src\computervision\SkinDetector.h" />
+    <ClInclude Include="src\computervision\ObjectDetection.h" />
+    <ClInclude Include="src\entities\camera.h" />
+    <ClInclude Include="src\entities\collision_entity.h" />
+    <ClInclude Include="src\entities\entity.h" />
+    <ClInclude Include="src\entities\light.h" />
+    <ClInclude Include="src\gui\gui_element.h" />
+    <ClInclude Include="src\gui\gui_interactable.h" />
+    <ClInclude Include="src\models\model.h" />
+    <ClInclude Include="src\renderEngine\loader.h" />
+    <ClInclude Include="src\renderEngine\obj_loader.h" />
+    <ClInclude Include="src\renderEngine\renderer.h" />
+    <ClInclude Include="src\shaders\gui_shader.h" />
+    <ClInclude Include="src\shaders\shader_program.h" />
+    <ClInclude Include="src\shaders\entity_shader.h" />
+    <ClInclude Include="src\stb_image.h" />
+    <ClInclude Include="src\toolbox\Timer.h" />
+    <ClInclude Include="src\toolbox\toolbox.h" />
+    <ClInclude Include="src\scenes\startup_Scene.h" />
+    <ClInclude Include="src\scenes\game_Over_Scene.h" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />