Merge branch 'develop' into temp-end

src/computervision/object_detection.cpp

@@ -23,6 +23,7 @@ namespace computervision
 
 	bool background_calibrated = false;
 	bool skin_calibrated = false;
+	bool hand_open = false;
 
 	ObjectDetection::ObjectDetection()
 	{
@@ -94,6 +95,7 @@ namespace computervision
 					skin_calibrated = true;
 					hand_calibrator.SetSkinCalibration(skin_calibrated);
 					time = 0;
+					calibration_callback();
 				}
 			}
 
@@ -126,8 +128,8 @@ namespace computervision
 		hand_present = hand_calibrator.CheckIfHandPresent(handMask, handcalibration::HandDetectionType::MENU);
 		hand_calibrator.SetHandPresent(hand_present);
 
-
+		hand_open = fingers_amount > 0;
-		return fingers_amount > 0;
+		return hand_open;
 	}
 
 	void ObjectDetection::CalculateDifference()
@@ -187,5 +189,15 @@ namespace computervision
 		time += delt_time;
 	}
 
+	bool ObjectDetection::IsHandOpen()
+	{
+		return hand_open;
+	}
+
+	bool ObjectDetection::IsCalibrated()
+	{
+		return background_calibrated && skin_calibrated;
+	}
+
 
 }

src/computervision/object_detection.h

@@ -11,6 +11,7 @@
 #include <opencv2/video.hpp>
 #include <GLFW/glfw3.h>
 
+#include <functional>
 #include "background_remover.h"
 #include "skin_detector.h"
 #include "finger_count.h"
@@ -81,6 +82,8 @@ namespace computervision
 		 */
 		bool IsHandOpen();
 
+		bool IsCalibrated();
+
 
 		/**
 		 * @brief checks whether the hand is held within the detection square.
@@ -91,10 +94,13 @@ namespace computervision
 
 		cv::VideoCapture GetCap();
 
+		void SetCalibrationCallback(std::function<void()> fun) { calibration_callback = fun; };
+
 	private:
 		bool is_hand_open;
 		bool is_hand_present;
 		void UpdateTime();
+		std::function<void()> calibration_callback;
 
 	};
 

src/gui/gui_interactable.h

@@ -4,6 +4,7 @@
 #include <glm/gtc/matrix_transform.hpp>
 #include "../toolbox/toolbox.h"
 #include "gui_element.h"
+#include <functional>
 
 namespace gui
 {
@@ -83,14 +84,15 @@ namespace gui
 
 	
 	/*
-	 * This class represents a button
+ * This class represents a button
-	 */
+ */
 	class Button : public InteractableGui
 	{
 	private:
-		void (*on_click_action)();
+
-		void (*on_enter_action)();
+		std::function<void()> on_click_action;
-		void (*on_exit_action)();
+		std::function<void()> on_enter_action;
+		std::function<void()> on_exit_action;
 
 	public:
 		Button(int default_texture, glm::vec2 position, glm::vec2 scale) : InteractableGui(default_texture, position, scale) {}
@@ -100,21 +102,21 @@ namespace gui
 		 *
 		 * @param fun: A function pointer to a function (or lambda)
 		 */
-		void SetOnClickAction(void (*fun)()) { on_click_action = fun; }
+		void SetOnClickAction(std::function<void()> fun) { on_click_action = fun; }
 
 		/*
 		 * @brief: This function sets an action (function pointer) to the OnEnter function
 		 *
 		 * @param fun: A function pointer to a function (or lambda)
 		 */
-		void SetOnEnterAction(void (*fun)()) { on_enter_action = fun; }
+		void SetOnEnterAction(std::function<void()> fun) { on_enter_action = fun; }
 
 		/*
 		 * @brief: This function sets an action (function pointer) to the OnExit function
 		 *
 		 * @param fun: A function pointer to a function (or lambda)
 		 */
-		void SetOnExitAction(void (*fun)()) { on_exit_action = fun; }
+		void SetOnExitAction(std::function<void()> fun) { on_exit_action = fun; }
 
 		GuiType GetType() override {
 			return GuiType::BUTTON;

src/scenes/game_Over_Scene.cpp

@@ -23,11 +23,10 @@ namespace scene
 {
 	shaders::GuiShader* gui_shader_gameOver;
 	std::vector<gui::GuiTexture*> guis_gameOver;
-	computervision::ObjectDetection objDetect_gameOver;
 	std::vector<std::shared_ptr<gui::GuiTexture>> score_textures_gameOver;
-
+	double delta_time = 0;
-	float item_number_gameOver = 0;
+	double time = 0;
-	bool hand_mode_gameOver = false;
+	bool game_over = false;
 
 	Game_Over_Scene::Game_Over_Scene(int score) 
 	{
@@ -76,28 +75,14 @@ namespace scene
 		}
 	}
 
-	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.5f), 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([]()
+		button_start_scene.SetOnClickAction([this]()
 			{
-				std::cout << "Back to start screen!!" << std::endl;
+				std::cout << "Back to stop screen!!" << std::endl;
+				return_value = Scenes::STOP;
 				
 			});
 		guis_gameOver.push_back(&button_start_scene);
@@ -111,52 +96,13 @@ namespace scene
 		{
 			render();
 			update(window);
-
+			
-			if (hand_mode_gameOver) 
+			if (game_over) button_start_scene.ForceClick(GLFW_MOUSE_BUTTON_LEFT);
-			{
-				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;
 	}
 
@@ -168,7 +114,10 @@ namespace scene
 		render_engine::renderer::Prepare();
 
 		// Render GUI items
-		render_engine::renderer::Render(guis_gameOver, *gui_shader_gameOver);
+		//render_engine::renderer::Render(guis_gameOver, *gui_shader_gameOver);
+
+		render_engine::renderer::Render(game_over_texture, *gui_shader_gameOver);
+		DrawScore(end_score);
 	}
 
 	/**
@@ -181,11 +130,16 @@ namespace scene
 			if (new_button != NULL)
 				new_button->Update(window);
 		}
-		bool hand_present;
+
-		objDetect_gameOver.DetectHand(objDetect_gameOver.ReadCamera(), hand_present);
+		UpdateDeltaTime();
+		time += delta_time;
+
+		if (time >= 5.0)
+		{
+			game_over = true;
+		}
 		
-		render_engine::renderer::Render(game_over_texture, *gui_shader_gameOver);
+
-		DrawScore(end_score);
 		}
 
 	/**
@@ -198,9 +152,6 @@ namespace scene
 			//return_value = scene::Scenes::STARTUP;
 			cv::destroyWindow("camera");
 		}
-		else if (glfwGetKey(window, GLFW_KEY_BACKSPACE) == GLFW_PRESS) {
-			hand_mode_gameOver = !hand_mode_gameOver;
-		}
 	}
 
 	void Game_Over_Scene::DrawScore(int score)
@@ -216,4 +167,19 @@ namespace scene
 			render_engine::renderer::Render(score_textures_gameOver[digits[i]], *gui_shader_gameOver);
 		}
 	}
+
+	void Game_Over_Scene::UpdateDeltaTime()
+	{
+		double current_time = glfwGetTime();
+		static double last_frame_time = current_time;
+		delta_time = current_time - last_frame_time;
+		last_frame_time = current_time;
+
+	}
+
+	Game_Over_Scene::~Game_Over_Scene()
+	{
+		std::cout << "game over destructor" << std::endl;
+		delete gui_shader_gameOver;
+	}
 }

src/scenes/game_Over_Scene.h

@@ -14,10 +14,12 @@ namespace scene
 		scene::Scenes return_value = scene::Scenes::GAMEOVER;
 		std::vector<std::shared_ptr<gui::GuiTexture>> score_guis_gameOver;
 		std::shared_ptr<gui::GuiTexture> game_over_texture;
+		void UpdateDeltaTime();
 
 
 	public:
 		Game_Over_Scene(int score);
+		~Game_Over_Scene();
 
 		Scenes start(GLFWwindow* window) override;
 

src/scenes/in_Game_Scene.cpp

@@ -174,21 +174,23 @@ namespace scene
 		gui::GuiTexture background(render_engine::loader::LoadTexture("res/background_grey.png"), glm::vec2(0, 0), glm::vec2(1, 1));
 		pause_guis.push_back(&background);
 
-		gui::Button pause_button_resume(render_engine::loader::LoadTexture("res/Mayo.png"), glm::vec2(0, 0), glm::vec2(0.25f, 0.25f));
+		gui::Button pause_button_resume(render_engine::loader::LoadTexture("res/menu_item_start1.png"), glm::vec2(0.0f, 0.3f), glm::vec2(0.25f, 0.25f));
-		pause_button_resume.SetHoverTexture(render_engine::loader::LoadTexture("res/Texture.png"));
+		pause_button_resume.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_start1_hover.png"));
-		pause_button_resume.SetClickedTexture(render_engine::loader::LoadTexture("res/Mayo.png"));
+		pause_button_resume.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_start1_click.png"));
 		pause_button_resume.SetOnClickAction([]()
 			{
 				std::cout << "I got clicked on the resume button!" << std::endl;
+				//game_state = scene::Game_State::RUNNING;
 			});
 		pause_guis.push_back(&pause_button_resume);
 
-		gui::Button pause_button_quit(render_engine::loader::LoadTexture("res/Mayo.png"), glm::vec2(0.3f, 0.0f), glm::vec2(0.25f, 0.25f));
+		gui::Button pause_button_quit(render_engine::loader::LoadTexture("res/menu_item_quit1.png"), glm::vec2(0.0f, -0.3f), glm::vec2(0.25f, 0.25f));
-		pause_button_quit.SetHoverTexture(render_engine::loader::LoadTexture("res/Texture.png"));
+		pause_button_quit.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_hover.png"));
-		pause_button_quit.SetClickedTexture(render_engine::loader::LoadTexture("res/Mayo.png"));
+		pause_button_quit.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_click.png"));
 		pause_button_quit.SetOnClickAction([]()
 			{
 				std::cout << "I got clicked on the quit button!" << std::endl;
+				//return_value = scene::Scenes::STOP;
 			});
 		pause_guis.push_back(&pause_button_quit);
 
@@ -273,6 +275,7 @@ namespace scene
 			*ptr = score;
 			std::cout << "Score: " << score << std::endl;
 			return_value = scene::Scenes::GAMEOVER;
+			cv::destroyWindow("camera");
 		}
 
 		camera->Follow(main_character->GetPosition());

src/scenes/startup_Scene.cpp

@@ -40,6 +40,11 @@ namespace scene
 		gui_shader1->Init();
 	}
 
+	void Startup_Scene::EnableHandMode()
+	{
+		hand_mode = true;
+	}
+
 	gui::Button* ConvertGuiTextureToButton(gui::GuiTexture* texture) {
 		gui::Button* button;
 		if (texture != NULL)
@@ -76,7 +81,7 @@ namespace scene
 
 	gui::GuiTexture* GetMenuItem(bool hand_state) {
 		if(hand_state)
-		item_number += 0.20f;
+		item_number += 0.10f;
 
 		int temp_item_number = item_number;
 		
@@ -92,40 +97,37 @@ namespace scene
 	scene::Scenes scene::Startup_Scene::start(GLFWwindow *window)
 	{
 		// GUI stuff
-		gui::Button button_start(render_engine::loader::LoadTexture("res/menu_item_start1.png"), glm::vec2(0.0f, 0.6f), glm::vec2(0.25f, 0.25f));
+		gui::Button button_start(render_engine::loader::LoadTexture("res/menu_item_start1.png"), glm::vec2(0.0f, 0.3f), glm::vec2(0.25f, 0.25f));
 		button_start.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_start1_hover.png"));
 		button_start.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_start1_click.png"));
-		button_start.SetOnClickAction([]()
+		std::function<void()> start_fun = [this]()
-			{
+		{
-				std::cout << "Clicked on button: Start!" << std::endl;
+			std::cout << "Clicked on button: Start!" << std::endl;
-				
+			return_value = scene::Scenes::INGAME;
-			});
+			cv::destroyWindow("camera");
+
+		};
+		button_start.SetOnClickAction(start_fun);
+
 		guis1.push_back(&button_start);
 
-		gui::Button button_calibrate(render_engine::loader::LoadTexture("res/menu_item_calibrate1.png"), glm::vec2(0.0f, 0.0f), glm::vec2(0.25f, 0.25f));
+		gui::Button button_quit(render_engine::loader::LoadTexture("res/menu_item_quit1.png"), glm::vec2(0.0f, -0.3f), glm::vec2(0.25f, 0.25f));
-		button_calibrate.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_calibrate1_hover.png"));
-		button_calibrate.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_calibrate1_click.png"));
-		button_calibrate.SetOnClickAction([]()
-			{
-				std::cout << "Clicked on button: Calibrate!" << std::endl;
-
-			});
-		guis1.push_back(&button_calibrate);
-
-		gui::Button button_quit(render_engine::loader::LoadTexture("res/menu_item_quit1.png"), glm::vec2(0.0f, -0.6f), glm::vec2(0.25f, 0.25f));
 		button_quit.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_hover.png"));
 		button_quit.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_click.png"));
-		button_quit.SetOnClickAction([]()
+		std::function<void()> quit_fun = [this]()
-			{
+		{
-				std::cout << "Clicked on button: Quit!" << std::endl;
+			std::cout << "Clicked on button: Quit!" << std::endl;
-			});
+			return_value = scene::Scenes::STOP;
+			cv::destroyWindow("camera");
+		};
+		button_quit.SetOnClickAction(quit_fun);
 		guis1.push_back(&button_quit);
 
-		computervision::ObjectDetection objDetect;
 		cv::Mat cameraFrame;
 		gui::GuiTexture* chosen_item = NULL; //This is the selected menu_item
 		bool hand_closed = false; //Flag to prevent multiple button presses
-		
+		std::function<void()> calibration_func = [this]() {EnableHandMode(); };
+		objDetect.SetCalibrationCallback(calibration_func);
 		while (return_value == scene::Scenes::STARTUP)
 		{
 			render();
@@ -219,4 +221,10 @@ namespace scene
 			hand_mode = !hand_mode;
 		}
 	}
+
+	Startup_Scene::~Startup_Scene()
+	{
+		std::cout << "startup scene destructor" << std::endl;
+		delete gui_shader1;
+	}
 }

src/scenes/startup_Scene.h

@@ -11,6 +11,7 @@ namespace scene
 	private:
 		//return_value is an enum that is necessary for the scene switching. Whenever this changes, the scene will change to a different scene.
 		scene::Scenes return_value = scene::Scenes::STARTUP;
+		void EnableHandMode();
 
 	public:
 		/**
@@ -19,6 +20,8 @@ namespace scene
 		 */
 		Startup_Scene();
 
+		~Startup_Scene();
+
 		/**
 		 * @brief 
 		 *