[ADD] player spawns at hightlimit, hightlimit is lowered

merge Feature/loading all models into develop

enc_temp_folder/e14e1bac1d366a32333657ac3b22e523/house_generator.cpp

@@ -1,340 +0,0 @@
-#include "house_generator.h"
-
-#include <functional>
-#include <iostream>
-
-#include "../renderEngine/obj_loader.h"
-#include "../renderEngine/Loader.h"
-#include "../toolbox/toolbox.h"
-#include "collision_entity.h"
-
-namespace entities
-{
-	HouseGenerator::HouseGenerator()
-	{
-		models::RawModel raw_model = render_engine::LoadObjModel("res/HouseNew.obj");
-		default_texture = { render_engine::loader::LoadTexture("res/Texture.png") };
-		default_texture.shine_damper = 10;
-		house_model = { raw_model, default_texture };
-
-		GenerateFurnitureModels();
-	}
-
-	const FurniturePiece* HouseGenerator::GetRandomFurniturePiece()
-	{
-		FurnitureType random_type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
-
-		for(std::deque<FurnitureModel>::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it)
-		{
-			if(it->furniture.type == random_type)
-			{
-				return &it->furniture;
-			}
-		}
-		
-		return nullptr;
-	}
-	
-	std::deque<std::shared_ptr<Entity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
-	{
-		std::deque<std::shared_ptr<Entity>> furniture;
-
-		// Add house
-		furniture.push_front(std::make_shared<Entity>(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE));
-		int house_size = house_model.raw_model.model_size.x * HOUSE_SIZE;
-		int offset_x = house_model.raw_model.model_size.z * (HOUSE_SIZE/2);
-		int offset_z = house_model.raw_model.model_size.x *( HOUSE_SIZE/2);
-		double multiplier_x = house_size/2;
-		double multiplier_z = house_size / 3;
-		
-		for (int z = 1; z < 4; z++) {
-			for (int x = 1; x < 3; x++)
-			{
-				//if (toolbox::Random(0, 100) < 50) {
-						const FurniturePiece* furniture_piece = GetRandomFurniturePiece();
-						models::TexturedModel model = GetFurnitureModel(furniture_piece);
-						//if (//check of size van furniture nog past in huidige grid vlakje, of ie geen 2 size op t laatste vakje neerzet) {
-						glm::vec3 model_pos = glm::vec3(position.x + (x * multiplier_x) - (multiplier_x/2) - offset_x, position.y, position.z + (z * multiplier_z) - (multiplier_z / 2) + offset_z);
-
-						collision::Box model_box = { model_pos, model.raw_model.model_size };
-						model_box.SetRotation(-90);
-						furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box));
-					//}
-					//}
-				}
-			}
-
-		return furniture;
-		
-		/*
-		// Add furniture
-		models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH);
-		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 };
-		couch_box.SetRotation(-90);
-		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);
-		glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
-		collision::Box table_box = { table_pos, table.raw_model.model_size };
-		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);
-		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 };
-		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);
-		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 };
-		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);
-		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 };
-		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);
-		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 };
-		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);
-		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 };
-		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);
-		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 };
-		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);
-		collision::Box misc_box = { misc_pos, misc.raw_model.model_size };
-		furniture.push_back(std::make_shared<CollisionEntity>(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box));
-		*/
-		
-	}
-
-	models::TexturedModel HouseGenerator::GetFurnitureModel(const FurniturePiece* furniture)
-	{
-		std::deque<models::TexturedModel> *furniture_list = nullptr;
-		
-		for (std::deque<FurnitureModel>::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it)
-		{
-			if(it->furniture.type == furniture->type)
-			{
-				furniture_list = &it->texture;
-			}
-		}
-		
-		if (furniture_list == nullptr)
-		{
-			std::cerr << "OH NEEEEEEEEEEEEEEE";
-		}
-		
-		const int modelNumber = toolbox::Random(0, furniture_list->size() - 1);
-		
-		return furniture_list->at(modelNumber);
-		
-		//return {};
-	}
-
-	void HouseGenerator::GenerateFurnitureModels()
-	{
-		// Couches
-		std::deque<models::TexturedModel> couches;
-		
-		models::RawModel couch_inside_model = render_engine::LoadObjModel("res/couchThree.obj");
-		models::TexturedModel couch_inside = { couch_inside_model, default_texture };
-		couches.push_back(couch_inside);
-
-		models::RawModel couch_inside_model2 = render_engine::LoadObjModel("res/Coach.obj");
-		models::TexturedModel couch_inside2 = { couch_inside_model2, default_texture };
-		couches.push_back(couch_inside2);
-
-		models::RawModel couch_inside_model3 = render_engine::LoadObjModel("res/lawnBenchOne.obj");
-		models::TexturedModel couch_inside3 = { couch_inside_model3, default_texture };
-		couches.push_back(couch_inside3);
-
-		FurnitureModel couch;
-		couch.furniture = {
-		FurnitureType::COUCH, 2 };
-		couch.texture = couches;
-		
-		furniture_models.push_back(couch);
-
-		// Tables
-		std::deque<models::TexturedModel> tables;
-
-		models::RawModel table_model1 = render_engine::LoadObjModel("res/tableOne.obj");
-		models::TexturedModel table1 = { table_model1, default_texture };
-		tables.push_back(table1);
-
-		models::RawModel table_model2 = render_engine::LoadObjModel("res/tableTwo.obj");
-		models::TexturedModel table2 = { table_model2, default_texture };
-		tables.push_back(table2);
-
-		models::RawModel table_model3 = render_engine::LoadObjModel("res/bureauOne.obj");
-		models::TexturedModel table3 = { table_model3, default_texture };
-		tables.push_back(table3);
-		
-		FurnitureModel table;
-		table.furniture = {
-		FurnitureType::TABLE, 2 };
-		table.texture = tables;
-		
-		furniture_models.push_back(table);
-
-		// Chairs
-		std::deque<models::TexturedModel> chairs;
-
-		models::RawModel chair_model1 = render_engine::LoadObjModel("res/launchchair.obj");
-		models::TexturedModel chair1 = { chair_model1, default_texture };
-		chairs.push_back(chair1);
-
-		models::RawModel chair_model2 = render_engine::LoadObjModel("res/lawnChairOne.obj");
-		models::TexturedModel chair2 = { chair_model2, default_texture };
-		chairs.push_back(chair2);
-
-		models::RawModel chair_model3 = render_engine::LoadObjModel("res/ugly_chair.obj");
-		models::TexturedModel chair3 = { chair_model3, default_texture };
-		chairs.push_back(chair3);
-
-		FurnitureModel chair;
-		chair.furniture = {
-		FurnitureType::CHAIR, 1 };
-		chair.texture = chairs;
-
-		furniture_models.push_back(chair);
-
-		// Plants
-		std::deque<models::TexturedModel> plants;
-
-		models::RawModel plant_model1 = render_engine::LoadObjModel("res/plantOne.obj");
-		models::TexturedModel plant1 = { plant_model1, default_texture };
-		plants.push_back(plant1);
-
-		models::RawModel plant_model2 = render_engine::LoadObjModel("res/plantTwo.obj");
-		models::TexturedModel plant2 = { plant_model2, default_texture };
-		plants.push_back(plant2);
-
-		models::RawModel plant_model3 = render_engine::LoadObjModel("res/plantThree.obj");
-		models::TexturedModel plant3 = { plant_model3, default_texture };
-		plants.push_back(plant3);
-
-		FurnitureModel plant;
-		plant.furniture = {
-		FurnitureType::PLANT, 1 };
-		plant.texture = plants;
-
-		furniture_models.push_back(plant);
-
-		// Guitars
-		std::deque<models::TexturedModel> guitars;
-
-		models::RawModel guitar_model1 = render_engine::LoadObjModel("res/guitarOne.obj");
-		models::TexturedModel guitar1 = { guitar_model1, default_texture };
-		guitars.push_back(guitar1);
-
-		models::RawModel guitar_model2 = render_engine::LoadObjModel("res/guitarTwo.obj");
-		models::TexturedModel guitar2 = { guitar_model2, default_texture };
-		guitars.push_back(guitar2);
-
-		FurnitureModel guitar;
-		guitar.furniture = {
-		FurnitureType::GUITAR, 1 };
-		guitar.texture = guitars;
-
-		furniture_models.push_back(guitar);
-
-		// Bookshelves
-		std::deque<models::TexturedModel> bookshelves;
-
-		models::RawModel bookshelf_model1 = render_engine::LoadObjModel("res/bookShelfOne.obj");
-		models::TexturedModel bookshelf1 = { bookshelf_model1, default_texture };
-		bookshelves.push_back(bookshelf1);
-
-		models::RawModel bookshelf_model2 = render_engine::LoadObjModel("res/bookShelfTwo.obj");
-		models::TexturedModel bookshelf2 = { bookshelf_model2, default_texture };
-		bookshelves.push_back(bookshelf2);
-
-		models::RawModel bookshelf_model3 = render_engine::LoadObjModel("res/bookShelfThree.obj");
-		models::TexturedModel bookshelf3 = { bookshelf_model3, default_texture };
-		bookshelves.push_back(bookshelf3);
-
-		FurnitureModel bookshelf;
-		bookshelf.furniture = {
-		FurnitureType::BOOKSHELF, 1 };
-		bookshelf.texture = bookshelves;
-
-		furniture_models.push_back(bookshelf);
-
-		// Lamps
-		std::deque<models::TexturedModel>lamps;
-
-		models::RawModel lamp_model1 = render_engine::LoadObjModel("res/lampOne.obj");
-		models::TexturedModel lamp1 = { lamp_model1, default_texture };
-		lamps.push_back(lamp1);
-
-		models::RawModel lamp_model2 = render_engine::LoadObjModel("res/lampTwo.obj");
-		models::TexturedModel lamp2 = { lamp_model2, default_texture };
-		lamps.push_back(lamp2);
-
-		FurnitureModel lamp;
-		lamp.furniture = {
-		FurnitureType::LAMP, 1 };
-		lamp.texture = lamps;
-
-		furniture_models.push_back(lamp);
-
-		// Ceiling objects
-		std::deque<models::TexturedModel>ceiling_Objects;
-
-		models::RawModel ceiling_Obj_model1 = render_engine::LoadObjModel("res/ceilingFan.obj");
-		models::TexturedModel ceiling_Obj1 = { ceiling_Obj_model1, default_texture };
-		ceiling_Objects.push_back(ceiling_Obj1);
-
-		models::RawModel ceiling_Obj_model2 = render_engine::LoadObjModel("res/ceilingFanTwo.obj");
-		models::TexturedModel ceiling_Obj2 = { ceiling_Obj_model2, default_texture };
-		ceiling_Objects.push_back(ceiling_Obj2);
-
-		models::RawModel ceiling_Obj_model3 = render_engine::LoadObjModel("res/ceilingLampOne.obj");
-		models::TexturedModel ceiling_Obj3 = { ceiling_Obj_model3, default_texture };
-		ceiling_Objects.push_back(ceiling_Obj3);
-
-		models::RawModel ceiling_Obj_model4 = render_engine::LoadObjModel("res/ceilingLampTwo.obj");
-		models::TexturedModel ceiling_Obj4 = { ceiling_Obj_model4, default_texture };
-		ceiling_Objects.push_back(ceiling_Obj4);
-
-		FurnitureModel ceiling_object;
-		ceiling_object.furniture = {
-		FurnitureType::CEILING_OBJECTS, 1 };
-		ceiling_object.texture = ceiling_Objects;
-
-		furniture_models.push_back(ceiling_object);
-
-		// Miscs
-		std::deque<models::TexturedModel> miscs;
-
-		models::RawModel misc_model1 = render_engine::LoadObjModel("res/tv.obj");
-		models::TexturedModel misc1 = { misc_model1, default_texture };
-		miscs.push_back(misc1);
-
-		models::RawModel misc_model2 = render_engine::LoadObjModel("res/radio.obj");
-		models::TexturedModel misc2 = { misc_model2, default_texture };
-		miscs.push_back(misc2);
-
-		models::RawModel misc_model3 = render_engine::LoadObjModel("res/Flowerpot.obj");
-		models::TexturedModel misc3 = { misc_model3, default_texture };
-		miscs.push_back(misc3);
-
-		FurnitureModel misc;
-		misc.furniture = {
-		FurnitureType::MISC, 1 };
-		misc.texture = miscs;
-
-		furniture_models.push_back(misc);		
-	}
-}

src/collision/collision_handler.cpp

@@ -3,7 +3,7 @@
 
 namespace collision
 {
-	void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>> entities)
+	void CheckCollisions(std::deque<std::shared_ptr<entities::CollisionEntity>>& entities)
 	{
 		if (entities.size() < 2) { return; }
 			if (entities.size() == 2)

src/collision/collision_handler.h

@@ -4,6 +4,7 @@
 #include <vector>
 #include "../entities/collision_entity.h"
 #include "collision.h"
+#include <deque>
 
 namespace collision
 {
@@ -13,5 +14,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::deque<std::shared_ptr<entities::CollisionEntity>>& entities);
 }

src/computervision/OpenPoseVideo.cpp

@@ -1,108 +0,0 @@
-#include "OpenPoseVideo.h"
-
-using namespace std;
-using namespace cv;
-using namespace cv::dnn;
-
-namespace computervision
-{
-#define MPI
-
-#ifdef MPI
-	const int POSE_PAIRS[7][2] =
-	{
-		{0,1}, {1,2}, {2,3},
-		{3,4}, {1,5}, {5,6},
-		{6,7}
-	};
-
-	string protoFile = "res/pose/mpi/pose_deploy_linevec_faster_4_stages.prototxt";
-	string weightsFile = "res/pose/mpi/pose_iter_160000.caffemodel";
-
-	int nPoints = 8;
-#endif
-
-#ifdef COCO
-	const int POSE_PAIRS[17][2] =
-	{
-		{1,2}, {1,5}, {2,3},
-		{3,4}, {5,6}, {6,7},
-		{1,8}, {8,9}, {9,10},
-		{1,11}, {11,12}, {12,13},
-		{1,0}, {0,14},
-		{14,16}, {0,15}, {15,17}
-	};
-
-	string protoFile = "pose/coco/pose_deploy_linevec.prototxt";
-	string weightsFile = "pose/coco/pose_iter_440000.caffemodel";
-
-	int nPoints = 18;
-#endif
-	Net net;
-
-	void OpenPoseVideo::setup() {
-		net = readNetFromCaffe(protoFile, weightsFile);
-
-		net.setPreferableBackend(DNN_TARGET_CPU);
-	}
-
-	void OpenPoseVideo::movementSkeleton(Mat& inputImage, std::function<void(std::vector<Point>&, cv::Mat& poinst_on_image)> f) {
-		std::cout << "movement skeleton start" << std::endl;
-
-		int inWidth = 368;
-		int inHeight = 368;
-		float thresh = 0.01;
-
-		Mat frame;
-		int frameWidth = inputImage.size().width;
-		int frameHeight = inputImage.size().height;
-
-		double t = (double)cv::getTickCount();
-		std::cout << "reading input image and blob" << std::endl;
-
-		frame = inputImage;
-		Mat inpBlob = blobFromImage(frame, 1.0 / 255, Size(inWidth, inHeight), Scalar(0, 0, 0), false, false);
-
-		std::cout << "done reading image and blob" << std::endl;
-
-		net.setInput(inpBlob);
-
-		std::cout << "done setting input to net" << std::endl;
-		Mat output = net.forward();
-		std::cout << "time took to set input and forward: " << t << std::endl;
-
-		int H = output.size[2];
-		int W = output.size[3];
-
-		std::cout << "about to find position of boxy parts" << std::endl;
-		// find the position of the body parts
-		vector<Point> points(nPoints);
-		for (int n = 0; n < nPoints; n++)
-		{
-			// Probability map of corresponding body's part.
-			Mat probMap(H, W, CV_32F, output.ptr(0, n));
-
-			Point2f p(-1, -1);
-			Point maxLoc;
-			double prob;
-			minMaxLoc(probMap, 0, &prob, 0, &maxLoc);
-			if (prob > thresh)
-			{
-				p = maxLoc;
-				p.x *= (float)frameWidth / W;
-				p.y *= (float)frameHeight / H;
-
-				circle(frame, cv::Point((int)p.x, (int)p.y), 8, Scalar(0, 255, 255), -1);
-				cv::putText(frame, cv::format("%d", n), cv::Point((int)p.x, (int)p.y), cv::FONT_HERSHEY_COMPLEX, 1.1, cv::Scalar(0, 0, 255), 2);
-			}
-			points[n] = p;
-		}
-
-		cv::putText(frame, cv::format("time taken = %.2f sec", t), cv::Point(50, 50), cv::FONT_HERSHEY_COMPLEX, .8, cv::Scalar(255, 50, 0), 2);
-		std::cout << "time taken: " << t << std::endl;
-		//imshow("Output-Keypoints", frame);
-		//imshow("Output-Skeleton", frame);
-		std::cout << "about to call points receiving method" << std::endl;
-		f(points,frame);
-	}
-}

src/computervision/OpenPoseVideo.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include <opencv2/dnn.hpp>
-#include <opencv2/imgproc.hpp>
-#include <opencv2/highgui.hpp>
-#include <iostream>
-
-using namespace cv;
-
-namespace computervision
-{
-	class OpenPoseVideo{
-	private:
-
-	public:
-		void movementSkeleton(Mat& inputImage, std::function<void(std::vector<Point>&, cv::Mat& poinst_on_image)> f);
-		void setup();
-	};
-}

src/computervision/async/async_arm_detection.cpp

@@ -1,46 +0,0 @@
-#include <iostream>
-#include "async_arm_detection.h"
-#include "../OpenPoseVideo.h"
-#include <thread>
-#include "StaticCameraInstance.h"
-
-
-namespace computervision
-{
-	AsyncArmDetection::AsyncArmDetection()
-	{
-
-	}
-
-	void AsyncArmDetection::run_arm_detection(std::function<void(std::vector<Point>, cv::Mat poinst_on_image)> points_ready_func, OpenPoseVideo op)
-	{
-		VideoCapture cap = static_camera::getCap();
-		
-		std::cout << "STARTING THREAD LAMBDA" << std::endl;
-		/*cv::VideoCapture cap = static_camera::GetCap();*/
-
-		if (!cap.isOpened())
-		{
-			std::cout << "capture was closed, opening..." << std::endl;
-			cap.open(0);
-		}
-
-		while (true)
-		{
-			Mat img;
-			cap.read(img);
-			op.movementSkeleton(img, points_ready_func);
-		}
-	}
-
-	void AsyncArmDetection::start(std::function<void(std::vector<Point>, cv::Mat poinst_on_image)> points_ready_func, OpenPoseVideo op)
-	{
-
-		std::cout << "starting function" << std::endl;
-
-
-		std::thread async_arm_detect_thread(&AsyncArmDetection::run_arm_detection,this, points_ready_func, op);
-
-		async_arm_detect_thread.detach(); // makes sure the thread is detached from the variable.
-	}
-}

src/computervision/async/async_arm_detection.h

@@ -1,23 +0,0 @@
-#pragma once
-#include <vector>
-#include <opencv2/core/types.hpp>
-#include <opencv2/videoio.hpp>
-#include <functional>
-#include "../OpenPoseVideo.h"
-#include "StaticCameraInstance.h"
-
-
-namespace computervision
-{
-	class AsyncArmDetection
-	{
-	public:
-		AsyncArmDetection(void);
-
-		
-		void start(std::function<void(std::vector<cv::Point>, cv::Mat poinst_on_image)>, computervision::OpenPoseVideo op);
-	private:
-		void run_arm_detection(std::function<void(std::vector<Point>, cv::Mat poinst_on_image)> points_ready_func, OpenPoseVideo op);
-	};
-
-}

src/computervision/background_remover.cpp

@@ -1,4 +1,4 @@
-#include "BackgroundRemover.h"
+#include "background_remover.h"
 
 /*
  Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti

src/computervision/finger_count.cpp

@@ -1,4 +1,4 @@
-#include "FingerCount.h"
+#include "finger_count.h"
 
 #include "opencv2/imgproc.hpp"
 #include "opencv2/highgui.hpp"

src/computervision/hand_detect_region.cpp

@@ -1,6 +1,6 @@
 
-#include "HandDetectRegion.h"
+#include "hand_detect_region.h"
-
+#define TIME_DURATION 1.0f
 namespace computervision
 {
 
@@ -20,10 +20,20 @@ namespace computervision
 		Mat input_frame = GenerateHandMaskSquare(camera_frame);
 		frame_out = input_frame.clone();
 
+		if (!background_calibrated || !skin_calibrated)
+			if (time >= TIME_DURATION)
+			{
+				//std::cout << "timer finised,  seconds left: " << seconds_left << std::endl;
+				seconds_left--;
+				time = 0;
+			}
+		
+
 		// detect skin color
 		skin_detector.drawSkinColorSampler(camera_frame,start_x_pos,start_y_pos,region_width,region_height);
 
 		// remove background from image
+
 		foreground = background_remover.getForeground(input_frame);
 
 		// detect the hand contours
@@ -32,10 +42,33 @@ namespace computervision
 		// draw the hand rectangle on the camera input, and draw text showing if the hand is open or closed.
 		DrawHandMask(&camera_frame);
 
+		if (seconds_left <= 0)
+		{
+			if (!background_calibrated)
+			{
+				background_remover.calibrate(input_frame);
+				background_calibrated = true;
+				hand_calibrator.SetBackGroundCalibrated(background_calibrated);
+				seconds_left = 5;
+				time = 0;
+			}
+			else
+			{
+
+				if (!skin_calibrated)
+				{
+					if (is_main_skin_detection_region)
+						skin_timer_callback();
+				}
+			}
+
+		}
+
+		// uncomment these lines to show debug hand information
 		//imshow("output" + region_id, frame_out);
 		//imshow("foreground" + region_id, foreground);
 		//imshow("handMask" + region_id, handMask);
-		/*imshow("handDetection", fingerCountDebug);*/
+		//imshow("handDetection", fingerCountDebug);
 
 		hand_present = hand_calibrator.CheckIfHandPresent(handMask,handcalibration::HandDetectionType::GAME);
 		//std::string text = (hand_present ? "hand" : "no");
@@ -47,7 +80,17 @@ namespace computervision
 
 		hand_calibrator.DrawBackgroundSkinCalibrated(camera_frame);
 
-
+		std::string calibration_text = (!background_calibrated ? "calibrating background in " : (!skin_calibrated ? "calibrating skin in " : ""));
+		calibration_text += std::to_string(seconds_left);
+		if (!background_calibrated || !skin_calibrated)
+		{
+			cv::rectangle(camera_frame, cv::Rect(0, camera_frame.rows - 130, 600, 60), cv::Scalar(0, 0, 0), -1);
+			cv:putText(camera_frame, calibration_text, cv::Point(5, 400), cv::FONT_HERSHEY_COMPLEX, 1.0, cv::Scalar(255, 0, 255), 2);
+		}
+		if (background_calibrated && !skin_calibrated)
+		{
+			cv::putText(camera_frame, "put your hand in the left square", cv::Point(5, camera_frame.rows - 105), cv::FONT_HERSHEY_COMPLEX, 1.0, cv::Scalar(255, 0, 255), 2);
+		}
 
 	}
 
@@ -92,6 +135,8 @@ namespace computervision
 	{
 		std::cout << "calibrating skin " << region_id << std::endl;
 		hand_calibrator.SetSkinCalibration(true);
+		skin_calibrated = true;
+		time = 0;
 		return skin_detector.calibrateAndReturn(frame_out);
 	}
 
@@ -100,6 +145,13 @@ namespace computervision
 		std::cout << "setting skin " << region_id << std::endl;
 		skin_detector.setTresholds(tresholds);
 		hand_calibrator.SetSkinCalibration(true);
+		skin_calibrated = true;
+		time = 0;
+	}
+
+	void HandDetectRegion::UpdateTime(float delta_time)
+	{
+		time += delta_time;
 	}
 
 }

src/computervision/hand_detect_region.h

@@ -2,11 +2,13 @@
 
 #include <opencv2/core.hpp>
 #include <opencv2/imgproc.hpp>
+#include <GLFW/glfw3.h>
+
 #include "async/StaticCameraInstance.h"
 #include "calibration/HandCalibrator.h"
-#include "BackgroundRemover.h"
+#include "background_remover.h"
-#include "SkinDetector.h"
+#include "skin_detector.h"
-#include "FingerCount.h"
+#include "finger_count.h"
 namespace computervision
 {
 	class HandDetectRegion
@@ -36,8 +38,12 @@ namespace computervision
 		std::vector<int> CalculateSkinTresholds();
 
 		void setSkinTresholds(std::vector<int>& tresholds);
+		void UpdateTime(float delta_time);
+		void SetMainSkinDetecRegion(bool val) { is_main_skin_detection_region = val; };
+		void SetSkinTimerCallback(std::function<void()> fun) { skin_timer_callback = fun; };
 
 	private:
+
 		int start_x_pos;
 		int start_y_pos;
 		int region_height;
@@ -51,6 +57,17 @@ namespace computervision
 		std::string region_id;
 
 		bool DrawHandMask(cv::Mat* input);
+
+		float time = 0;
+		int seconds_left = 5; // calibration countdown
+
+		bool background_calibrated = false;
+		bool skin_calibrated = false;
+		bool is_main_skin_detection_region = false;
+		std::function<void()> skin_timer_callback;
+
+
+		
 	};
 
 }

src/computervision/object_detection.cpp

@@ -1,14 +1,7 @@
 
-#include <opencv2/videoio.hpp>
+#include "object_detection.h"
-#include <opencv2/highgui.hpp>
-#include <opencv2/video.hpp>
 
-#include "ObjectDetection.h"
+#define TIME_DURATION 1.0f
-#include "BackgroundRemover.h"
-#include "SkinDetector.h"
-#include "FingerCount.h"
-#include "async/StaticCameraInstance.h"
-#include "calibration/HandCalibrator.h"
 
 namespace computervision
 {
@@ -25,6 +18,11 @@ namespace computervision
 	handcalibration::HandCalibrator hand_calibrator;
 
 	cv::VideoCapture cap = static_camera::getCap();
+	float time = 0;
+	int seconds_left = 5; // calibration countdown
+
+	bool background_calibrated = false;
+	bool skin_calibrated = false;
 
 	ObjectDetection::ObjectDetection()
 	{
@@ -42,6 +40,20 @@ namespace computervision
 
 	bool ObjectDetection::DetectHand(Mat camera_frame, bool& hand_present)
 	{
+		//calculate deltatime
+		if (!background_calibrated || !skin_calibrated)
+		{
+			UpdateTime();
+
+			if (time >= TIME_DURATION)
+			{
+				std::cout << "timer finised,  seconds left: " << seconds_left << std::endl;
+				seconds_left--;
+				time = 0;
+			}
+		}
+
+
 		Mat input_frame = GenerateHandMaskSquare(camera_frame);
 		frame_out = input_frame.clone();
 
@@ -63,37 +75,58 @@ namespace computervision
 		// draw the hand rectangle on the camera input, and draw text showing if the hand is open or closed.
 		DrawHandMask(&camera_frame);
 
+		if (seconds_left <= 0)
+		{
+			if (!background_calibrated)
+			{
+				background_remover.calibrate(input_frame);
+				background_calibrated = true;
+				hand_calibrator.SetBackGroundCalibrated(background_calibrated);
+				seconds_left = 5;
+				time = 0;
+			}
+			else
+			{
+
+				if (!skin_calibrated)
+				{
+					skin_detector.calibrate(input_frame);
+					skin_calibrated = true;
+					hand_calibrator.SetSkinCalibration(skin_calibrated);
+					time = 0;
+				}
+			}
+
+		}
 
 		hand_calibrator.SetAmountOfFingers(fingers_amount);
 		finger_count.DrawHandContours(camera_frame);
 		hand_calibrator.DrawHandCalibrationText(camera_frame);
+
+		std::string calibration_text = (!background_calibrated ? "calibrating background in " : (!skin_calibrated ? "calibrating skin in " : ""));
+		calibration_text += std::to_string(seconds_left);
+		if (!background_calibrated || !skin_calibrated)
+		{
+			cv::rectangle(camera_frame, cv::Rect(0, camera_frame.rows - 120, 500, 50), cv::Scalar(0, 0, 0), -1);
+			cv::putText(camera_frame, calibration_text, cv::Point(5, camera_frame.rows-80), cv::FONT_HERSHEY_COMPLEX, 1.0, cv::Scalar(255, 0, 255), 2);
+		}
+
+		if (background_calibrated && !skin_calibrated)
+		{
+			cv::putText(camera_frame, "put your hand in the square", cv::Point(5, camera_frame.rows - 100), cv::FONT_HERSHEY_COMPLEX, 1.0, cv::Scalar(255, 0, 255), 2);
+		}
 		imshow("camera", camera_frame);
 
+		// uncomment these lines to show debug hand information
 		/*imshow("output", frame_out);
 		imshow("foreground", foreground);
 		imshow("handMask", handMask);
 		imshow("handDetection", fingerCountDebug);*/
 
-		hand_present = hand_calibrator.CheckIfHandPresent(handMask,handcalibration::HandDetectionType::MENU);
+		hand_present = hand_calibrator.CheckIfHandPresent(handMask, handcalibration::HandDetectionType::MENU);
 		hand_calibrator.SetHandPresent(hand_present);
 
 
-
-		int key = waitKey(1);
-
-		if (key == 98) // b, calibrate the background
-		{
-			background_remover.calibrate(input_frame);
-			hand_calibrator.SetBackGroundCalibrated(true);
-		}
-		else if (key == 115) // s, calibrate the skin color
-		{
-			skin_detector.calibrate(input_frame);
-			hand_calibrator.SetSkinCalibration(true);
-
-		}
-
-
 		return fingers_amount > 0;
 	}
 
@@ -144,5 +177,15 @@ namespace computervision
 		imshow("Webcam image", img);
 	}
 
+	void ObjectDetection::UpdateTime()
+	{
+		double current_time = glfwGetTime();
+		static double last_frame_time = current_time;
+		double delt_time = current_time - last_frame_time;
+		last_frame_time = current_time;
+
+		time += delt_time;
+	}
+
 
 }

src/computervision/object_detection.h

@@ -8,6 +8,14 @@
 #include <opencv2/core.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/highgui/highgui.hpp>
+#include <opencv2/video.hpp>
+#include <GLFW/glfw3.h>
+
+#include "background_remover.h"
+#include "skin_detector.h"
+#include "finger_count.h"
+#include "async/StaticCameraInstance.h"
+#include "calibration/HandCalibrator.h"
 
 
 namespace computervision
@@ -86,6 +94,7 @@ namespace computervision
 	private:
 		bool is_hand_open;
 		bool is_hand_present;
+		void UpdateTime();
 
 	};
 

src/computervision/skin_detector.cpp

@@ -1,4 +1,4 @@
-#include "SkinDetector.h"
+#include "skin_detector.h"
 #include <iostream>
 
 /*

src/entities/Entity.cpp

@@ -23,5 +23,7 @@ namespace entities
 		this->rotation.y += rotation.y;
 		this->rotation.z += rotation.z;
 	}
+
+
 }
 

src/entities/Entity.h

@@ -40,7 +40,7 @@ namespace entities
 		inline glm::vec3 GetPosition() const { return position; }
 		inline void SetPosition(const ::glm::vec3& position) {	this->position = position; }
 		inline glm::vec3 GetRotation() const { return rotation; }
-		inline void SetRotation(const ::glm::vec3& rotation) { this->rotation = rotation; }
+		void SetRotation(const ::glm::vec3& rotation) { this->rotation = rotation; }
 		inline float GetScale() const {	return scale; }
 		inline void SetScale(const float scale) { this->scale = scale; }
 	};

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

@@ -12,56 +12,57 @@ namespace entities
 {
 	HouseGenerator::HouseGenerator()
 	{
-		models::RawModel raw_model = render_engine::LoadObjModel("res/HouseNew.obj");
-		default_texture = { render_engine::loader::LoadTexture("res/Texture.png") };
-		default_texture.shine_damper = 10;
-		house_model = { raw_model, default_texture };
-
-		GenerateFurnitureModels();
 	}
 
-	const FurniturePiece* HouseGenerator::GetRandomFurniturePiece()
+	void HouseGenerator::GetRandomFurniturePiece(singleton::FurniturePiece* furniture_piece)
 	{
-		FurnitureType random_type = FurnitureType::CEILING_OBJECTS;
+		singleton::FurnitureType random_type = singleton::FurnitureType::CEILING_OBJECTS;
-		while (random_type == FurnitureType::CEILING_OBJECTS ) {
+		std::deque<singleton::FurnitureModel> furniture_models = singleton::Model_Storage::get_instance()->get_all_furniture_models();
-			random_type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
+		
+		while (random_type == singleton::FurnitureType::CEILING_OBJECTS ) {
+			random_type = singleton::FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
 		}
 
-		for (std::deque<FurnitureModel>::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it)
+		for (auto it = furniture_models.begin(); it != furniture_models.end(); ++it)
 		{
 			if (it->furniture.type == random_type)
 			{
-				return &it->furniture;
+				furniture_piece->type = it->furniture.type;
+				furniture_piece->size = it->furniture.size;
+				break;
 			}
 		}
 		
-		return nullptr;
+
 	}
 
-	const FurniturePiece* HouseGenerator::GetFurniturePiece(FurnitureType type)
+	void HouseGenerator::GetFurniturePiece(singleton::FurnitureType type, singleton::FurniturePiece* furniture_piece)
 	{
-		for (std::deque<FurnitureModel>::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it)
+		std::deque<singleton::FurnitureModel> furniture_models = singleton::Model_Storage::get_instance()->get_all_furniture_models();
+		for (auto it = furniture_models.begin(); it != furniture_models.end(); ++it)
 		{
 			if (it->furniture.type == type)
 			{
-				return &it->furniture;
+				furniture_piece->type = it->furniture.type;
+				furniture_piece->size = it->furniture.size;
+				break;
 			}
 		}
-		return nullptr;
 	}
 
-	std::deque<std::shared_ptr<Entity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
+	void HouseGenerator::GenerateHouse(std::deque<std::shared_ptr<CollisionEntity>>* furniture_list , const glm::vec3& position, float y_rotation)
 	{
 		std::deque<std::shared_ptr<Entity>> furniture;
 
 		// Add house
-		furniture.push_front(std::make_shared<Entity>(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE));
+		collision::Box bounding_box = { glm::vec3(0, 0, 0), glm::vec3(0, 0, 0) };
-		int house_size_x = house_model.raw_model.model_size.x * HOUSE_SIZE;
+		furniture_list->push_front(std::make_shared<CollisionEntity>(singleton::Model_Storage::get_instance()->get_house_model(), position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE, bounding_box));
-		int house_size_y = house_model.raw_model.model_size.x * HOUSE_SIZE;
+		int house_size_x = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE;
-		int house_size_z = house_model.raw_model.model_size.x * HOUSE_SIZE;
+		int house_size_y = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE;
+		int house_size_z = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE;
 
-		int offset_x = house_model.raw_model.model_size.z * (HOUSE_SIZE / 2);
+		int offset_x = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.z * (HOUSE_SIZE / 2);
-		int offset_z = house_model.raw_model.model_size.x * (HOUSE_SIZE / 2);
+		int offset_z = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * (HOUSE_SIZE / 2);
 		double multiplier_x = house_size_x / 4;
 		double multiplier_z = house_size_z / 3;
 
@@ -69,298 +70,62 @@ namespace entities
 			for (int x = 1; x < 4; x++)
 			{
 				//if (toolbox::Random(0, 100) < 90) {
-					const FurniturePiece* furniture_piece = GetRandomFurniturePiece();
+				singleton::FurniturePiece furniture_piece;
-					if (furniture_piece->type != FurnitureType::CEILING_OBJECTS) {
+				GetRandomFurniturePiece(&furniture_piece);
-						models::TexturedModel model = GetFurnitureModel(furniture_piece);
+				if (furniture_piece.type != singleton::FurnitureType::CEILING_OBJECTS) {
+					std::cout << "Furniture Piece: " << int(furniture_piece.type) << std::endl;
+					models::TexturedModel model = GetFurnitureModel(&furniture_piece);
 					//if (!(furniture_piece->size > 1 && x > 1)) {
 					glm::vec3 model_pos = glm::vec3(position.x + (x * multiplier_x) - (multiplier_x / 2) - offset_x, position.y, position.z + (z * multiplier_z) - (multiplier_z / 2) + offset_z);
 
-							collision::Box model_box = { model_pos, model.raw_model.model_size };
+					collision::Box model_box = { model_pos, model.raw_model.model_size * HOUSE_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, model_box));
+					furniture_list->push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box));
 				}
 				//}
 			//}
 			}
 		}
 
-		models::TexturedModel model = GetFurnitureModel(GetFurniturePiece(FurnitureType::CEILING_OBJECTS));
+		singleton::FurniturePiece furniture_piece;
-		glm::vec3 model_pos = glm::vec3(position.x, position.y + (house_size_y/5 *3), position.z);
+		GetFurniturePiece(singleton::FurnitureType::CEILING_OBJECTS, &furniture_piece);
+		models::TexturedModel model = GetFurnitureModel(&furniture_piece);
+		glm::vec3 model_pos = glm::vec3(position.x, position.y + (house_size_y / 5 * 3), position.z);
 		collision::Box model_box = { model_pos, model.raw_model.model_size };
 		model_box.SetRotation(-90);
-		furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box));
+		furniture_list->push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box));
-
-		return furniture;
-
-		/*
-		// Add furniture
-		models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH);
-		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 };
-		couch_box.SetRotation(-90);
-		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);
-		glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
-		collision::Box table_box = { table_pos, table.raw_model.model_size };
-		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);
-		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 };
-		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);
-		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 };
-		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);
-		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 };
-		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);
-		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 };
-		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);
-		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 };
-		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);
-		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 };
-		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);
-		collision::Box misc_box = { misc_pos, misc.raw_model.model_size };
-		furniture.push_back(std::make_shared<CollisionEntity>(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box));
-		*/
 
 	}
 
-	models::TexturedModel HouseGenerator::GetFurnitureModel(const FurniturePiece* furniture)
+	models::TexturedModel HouseGenerator::GetFurnitureModel(const singleton::FurniturePiece* furniture)
 	{
-		std::deque<models::TexturedModel>* furniture_list = nullptr;
+		std::deque<models::TexturedModel> furniture_list;
+		std::deque<singleton::FurnitureModel> furniture_models = singleton::Model_Storage::get_instance()->get_all_furniture_models();
 
-		for (std::deque<FurnitureModel>::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it)
+		std::cout << "type of furniture_piece: " << int(furniture->type) << std::endl;
+
+		for (auto it = furniture_models.begin(); it != furniture_models.end(); ++it)
 		{
 			if (it->furniture.type == furniture->type)
 			{
-				furniture_list = &it->texture;
+				std::deque<models::TexturedModel> textures = it->texture;
+				for (int i = 0; i< textures.size(); i++)
+				{
+					furniture_list.push_back(textures.at(i));
+				}
+				std::cout << "Size of textures: " << textures.size() << std::endl;
+				std::cout << "Size of furniture_list: " << furniture_list.size() << std::endl;
+				break;
 			}
 		}
-
+		std::cout << "Size of furniture_list after for loop: " << furniture_list.size() << std::endl;
-		if (furniture_list == nullptr)
+		if (furniture_list.empty())
 		{
 			std::cerr << "OH NEEEEEEEEEEEEEEE";
 		}
 
-		const int modelNumber = toolbox::Random(0, furniture_list->size() - 1);
+		const int modelNumber = toolbox::Random(0, furniture_list.size() - 1);
 
-		return furniture_list->at(modelNumber);
+		return furniture_list.at(modelNumber);
-
-		//return {};
-	}
-
-	void HouseGenerator::GenerateFurnitureModels()
-	{
-		// Couches
-		std::deque<models::TexturedModel> couches;
-
-		models::RawModel couch_inside_model = render_engine::LoadObjModel("res/couchThree.obj");
-		models::TexturedModel couch_inside = { couch_inside_model, default_texture };
-		couches.push_back(couch_inside);
-
-		models::RawModel couch_inside_model2 = render_engine::LoadObjModel("res/Coach.obj");
-		models::TexturedModel couch_inside2 = { couch_inside_model2, default_texture };
-		couches.push_back(couch_inside2);
-
-		models::RawModel couch_inside_model3 = render_engine::LoadObjModel("res/lawnBenchOne.obj");
-		models::TexturedModel couch_inside3 = { couch_inside_model3, default_texture };
-		couches.push_back(couch_inside3);
-
-		FurnitureModel couch;
-		couch.furniture = {
-		FurnitureType::COUCH, 2 };
-		couch.texture = couches;
-
-		furniture_models.push_back(couch);
-
-		// Tables
-		std::deque<models::TexturedModel> tables;
-
-		models::RawModel table_model1 = render_engine::LoadObjModel("res/tableOne.obj");
-		models::TexturedModel table1 = { table_model1, default_texture };
-		tables.push_back(table1);
-
-		models::RawModel table_model2 = render_engine::LoadObjModel("res/tableTwo.obj");
-		models::TexturedModel table2 = { table_model2, default_texture };
-		tables.push_back(table2);
-
-		models::RawModel table_model3 = render_engine::LoadObjModel("res/bureauOne.obj");
-		models::TexturedModel table3 = { table_model3, default_texture };
-		tables.push_back(table3);
-
-		FurnitureModel table;
-		table.furniture = {
-		FurnitureType::TABLE, 2 };
-		table.texture = tables;
-
-		furniture_models.push_back(table);
-
-		// Chairs
-		std::deque<models::TexturedModel> chairs;
-
-		models::RawModel chair_model1 = render_engine::LoadObjModel("res/launchchair.obj");
-		models::TexturedModel chair1 = { chair_model1, default_texture };
-		chairs.push_back(chair1);
-
-		models::RawModel chair_model2 = render_engine::LoadObjModel("res/lawnChairOne.obj");
-		models::TexturedModel chair2 = { chair_model2, default_texture };
-		chairs.push_back(chair2);
-
-		models::RawModel chair_model3 = render_engine::LoadObjModel("res/ugly_chair.obj");
-		models::TexturedModel chair3 = { chair_model3, default_texture };
-		chairs.push_back(chair3);
-
-		FurnitureModel chair;
-		chair.furniture = {
-		FurnitureType::CHAIR, 1 };
-		chair.texture = chairs;
-
-		furniture_models.push_back(chair);
-
-		// Plants
-		std::deque<models::TexturedModel> plants;
-
-		models::RawModel plant_model1 = render_engine::LoadObjModel("res/plantOne.obj");
-		models::TexturedModel plant1 = { plant_model1, default_texture };
-		plants.push_back(plant1);
-
-		models::RawModel plant_model2 = render_engine::LoadObjModel("res/plantTwo.obj");
-		models::TexturedModel plant2 = { plant_model2, default_texture };
-		plants.push_back(plant2);
-
-		models::RawModel plant_model3 = render_engine::LoadObjModel("res/plantThree.obj");
-		models::TexturedModel plant3 = { plant_model3, default_texture };
-		plants.push_back(plant3);
-
-		FurnitureModel plant;
-		plant.furniture = {
-		FurnitureType::PLANT, 1 };
-		plant.texture = plants;
-
-		furniture_models.push_back(plant);
-
-		// Guitars
-		std::deque<models::TexturedModel> guitars;
-
-		models::RawModel guitar_model1 = render_engine::LoadObjModel("res/guitarOne.obj");
-		models::TexturedModel guitar1 = { guitar_model1, default_texture };
-		guitars.push_back(guitar1);
-
-		models::RawModel guitar_model2 = render_engine::LoadObjModel("res/guitarTwo.obj");
-		models::TexturedModel guitar2 = { guitar_model2, default_texture };
-		guitars.push_back(guitar2);
-
-		FurnitureModel guitar;
-		guitar.furniture = {
-		FurnitureType::GUITAR, 1 };
-		guitar.texture = guitars;
-
-		furniture_models.push_back(guitar);
-
-		// Bookshelves
-		std::deque<models::TexturedModel> bookshelves;
-
-		models::RawModel bookshelf_model1 = render_engine::LoadObjModel("res/bookShelfOne.obj");
-		models::TexturedModel bookshelf1 = { bookshelf_model1, default_texture };
-		bookshelves.push_back(bookshelf1);
-
-		models::RawModel bookshelf_model2 = render_engine::LoadObjModel("res/bookShelfTwo.obj");
-		models::TexturedModel bookshelf2 = { bookshelf_model2, default_texture };
-		bookshelves.push_back(bookshelf2);
-
-		models::RawModel bookshelf_model3 = render_engine::LoadObjModel("res/bookShelfThree.obj");
-		models::TexturedModel bookshelf3 = { bookshelf_model3, default_texture };
-		bookshelves.push_back(bookshelf3);
-
-		FurnitureModel bookshelf;
-		bookshelf.furniture = {
-		FurnitureType::BOOKSHELF, 1 };
-		bookshelf.texture = bookshelves;
-
-		furniture_models.push_back(bookshelf);
-
-		// Lamps
-		std::deque<models::TexturedModel>lamps;
-
-		models::RawModel lamp_model1 = render_engine::LoadObjModel("res/lampOne.obj");
-		models::TexturedModel lamp1 = { lamp_model1, default_texture };
-		lamps.push_back(lamp1);
-
-		models::RawModel lamp_model2 = render_engine::LoadObjModel("res/lampTwo.obj");
-		models::TexturedModel lamp2 = { lamp_model2, default_texture };
-		lamps.push_back(lamp2);
-
-		FurnitureModel lamp;
-		lamp.furniture = {
-		FurnitureType::LAMP, 1 };
-		lamp.texture = lamps;
-
-		furniture_models.push_back(lamp);
-
-		// Ceiling objects
-		std::deque<models::TexturedModel>ceiling_Objects;
-
-		models::RawModel ceiling_Obj_model1 = render_engine::LoadObjModel("res/ceilingFan.obj");
-		models::TexturedModel ceiling_Obj1 = { ceiling_Obj_model1, default_texture };
-		ceiling_Objects.push_back(ceiling_Obj1);
-
-		models::RawModel ceiling_Obj_model2 = render_engine::LoadObjModel("res/ceilingFanTwo.obj");
-		models::TexturedModel ceiling_Obj2 = { ceiling_Obj_model2, default_texture };
-		ceiling_Objects.push_back(ceiling_Obj2);
-
-		models::RawModel ceiling_Obj_model3 = render_engine::LoadObjModel("res/ceilingLampOne.obj");
-		models::TexturedModel ceiling_Obj3 = { ceiling_Obj_model3, default_texture };
-		ceiling_Objects.push_back(ceiling_Obj3);
-
-		models::RawModel ceiling_Obj_model4 = render_engine::LoadObjModel("res/ceilingLampTwo.obj");
-		models::TexturedModel ceiling_Obj4 = { ceiling_Obj_model4, default_texture };
-		ceiling_Objects.push_back(ceiling_Obj4);
-
-		FurnitureModel ceiling_object;
-		ceiling_object.furniture = {
-		FurnitureType::CEILING_OBJECTS, 1 };
-		ceiling_object.texture = ceiling_Objects;
-
-		furniture_models.push_back(ceiling_object);
-
-		// Miscs
-		std::deque<models::TexturedModel> miscs;
-
-		models::RawModel misc_model1 = render_engine::LoadObjModel("res/tv.obj");
-		models::TexturedModel misc1 = { misc_model1, default_texture };
-		miscs.push_back(misc1);
-
-		models::RawModel misc_model2 = render_engine::LoadObjModel("res/radio.obj");
-		models::TexturedModel misc2 = { misc_model2, default_texture };
-		miscs.push_back(misc2);
-
-		models::RawModel misc_model3 = render_engine::LoadObjModel("res/Flowerpot.obj");
-		models::TexturedModel misc3 = { misc_model3, default_texture };
-		miscs.push_back(misc3);
-
-		FurnitureModel misc;
-		misc.furniture = {
-		FurnitureType::MISC, 1 };
-		misc.texture = miscs;
-
-		furniture_models.push_back(misc);
 	}
 }

src/entities/house_generator.h

@@ -3,52 +3,19 @@
 #include <deque>
 #include <memory>
 #include <map>
+
+#include "collision_entity.h"
 #include "../models/Model.h"
 #include "../collision/collision.h"
+#include "../model_Storage.h"
+#include "collision_entity.h"
 
 namespace entities
 {
-	enum class FurnitureType
-	{
-		COUCH,
-		TABLE,
-		CHAIR,
-		PLANT,
-		GUITAR,
-		BOOKSHELF,
-		LAMP,
-		CEILING_OBJECTS,
-		MISC
-	};
-	struct FurniturePiece
-	{
-		FurnitureType type;
-		int size;
-	};
-
-	struct FurnitureModel
-	{
-		FurniturePiece furniture;
-		std::deque<models::TexturedModel> texture;
-
-		bool operator<(FurnitureModel a)
-		{
-			return true;
-		}
-	};
-
-	
-	
 	class HouseGenerator
 	{
 	private:
 		const float HOUSE_SIZE = 30;
-		
-		models::TexturedModel house_model;
-		models::ModelTexture default_texture;
-		
-		//std::map<FurniturePiece, std::deque<models::TexturedModel>> furniture_models;
-		std::deque<FurnitureModel> furniture_models;
 	public:
 		HouseGenerator();
 		
@@ -60,21 +27,16 @@ 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);
+		void GenerateHouse(std::deque<std::shared_ptr<CollisionEntity>>* furniture_list, 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 singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE; }
 	
 	private:
-		const FurniturePiece* GetRandomFurniturePiece();
+		void GetRandomFurniturePiece(singleton::FurniturePiece* furniture_piece);
-		const FurniturePiece* GetFurniturePiece(FurnitureType type);
+		void GetFurniturePiece(singleton::FurnitureType type, singleton::FurniturePiece* furniture_piece);
-
-		/*
-		 * @brief: This function loads all the 3D furniture models
-		 */
-		void GenerateFurnitureModels();
 
 		/*
 		 * @brief: This funtion chooses and returns a random furniture of the given furniture type
@@ -83,6 +45,6 @@ namespace entities
 		 *
 		 * @return: The model of the random furniture of the chosen furniture type
 		 */
-		models::TexturedModel GetFurnitureModel(const FurniturePiece* furniture);
+		models::TexturedModel GetFurnitureModel(const singleton::FurniturePiece* furniture);
 	};
 }

src/entities/main_character.cpp

@@ -7,11 +7,10 @@
 #include"../renderEngine/loader.h"
 namespace entities
 {
-	float movement_speed;	
+	int movement_speed, down_speed, side_speed;	
-	float down_speed;		
-	float side_speed;
 	bool is_playing;
 
+
 	MainCharacter::MainCharacter(const models::TexturedModel& model, const glm::vec3& position,
 		const glm::vec3& rotation, float scale, const collision::Box& bounding_box)
 		: CollisionEntity(model, position, rotation, scale, bounding_box) 
@@ -19,73 +18,68 @@ namespace entities
 		is_playing = true;
 	}
 
-	void MainCharacter::Move(GLFWwindow* window)
+	void MainCharacter::Move(std::vector<computervision::HandDetectRegion*> regions)
 	{
-		if (is_playing) {
+		computervision::HandDetectRegion* reg_left = regions.at(0);
-			movement_speed = -0.5f;	//Forward speed adjustment, bee is moving at a standard speedrate
+		computervision::HandDetectRegion* reg_up = regions.at(1);
-			down_speed = -1.0f;		//Down speed adjustment, downspeed is difference between down_speed and UP_SPEED	
+		computervision::HandDetectRegion* reg_right = regions.at(2);
-			side_speed = 0;			//Side speed adjustment
 
+		double delta_time = UpdateDelta();
+
+		if (is_playing) {
+			movement_speed = -50;	//Forward speed adjustment, bee is moving at a standard speedrate
+			down_speed = -40;		//Down speed adjustment, downspeed is difference between down_speed and UP_SPEED	
+			side_speed = 0;			//Side speed adjustment
 			//For gameplay with use of keyboard keys: W, A, S, D
 			//W: Go forward
 			//A: Go left
 			//S: Go backwards
 			//D: Go right
 			//TODO Implement CV actions 
-			SetRotation(glm::vec3(0, 90, 0));
-			if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
-			{
-				movement_speed -= SIDE_SPEED;
-			}
-
-			if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
-			{
-				movement_speed += SIDE_SPEED;
-			}
 			//top right
-			if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS)
+			SetRotation(glm::vec3(0, 90, 0));
+			if (reg_up->IsHandPresent() && reg_left->IsHandPresent())
 			{
 				side_speed += SIDE_SPEED;
-				down_speed += UP_SPEED;
+				down_speed += UP_SPEED/2;
+				SetRotation(glm::vec3(10, 90, 0));
 			}
 			//right
-			if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
+			if (reg_left->IsHandPresent())
 			{
 				side_speed += SIDE_SPEED;
 			}
 			//top left
-			if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS)
+			if (reg_up->IsHandPresent() && reg_right->IsHandPresent())
 			{
-				down_speed += UP_SPEED;
+				down_speed += UP_SPEED/2;
 				side_speed -= SIDE_SPEED;
+				SetRotation(glm::vec3(10, 90, 0));
 			}
 			//left
-			if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
+			if (reg_right->IsHandPresent())
 			{
 				side_speed -= SIDE_SPEED;
 			}
 
-			if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+			if (reg_up->IsHandPresent())
 			{
 				down_speed += UP_SPEED;
 				SetRotation(glm::vec3(10, 90, 0));
 			}
-			if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
-			{
-				down_speed -= UP_SPEED;
 		}
-		}
+			IncreasePosition(glm::vec3(side_speed*delta_time, down_speed*delta_time, movement_speed*delta_time));
-			IncreasePosition(glm::vec3(side_speed, down_speed, movement_speed));
+			//std::cout << "delta time char: "<< delta_time << std::endl;
 
 			//Use only for binding bee to house, such that it doesn't go outside of the room.
 			//TODO delete when boundingbox is implemented!
 			if (position.x > 190) position.x = 190;
 			else if (position.x < -190) position.x = -190;
-			if (position.y > 350) position.y = 350;
+			if (position.y > 150) position.y = 150;
-			else if (position.y < -40) position.y = -40;
+			else if (position.y < -60) position.y = -60;
 			//Move player bounding box according to the position on screen
 			MoveCollisionBox();
-			if (glfwGetKey(window, GLFW_KEY_Z) == GLFW_PRESS)
+			if (reg_right->IsHandPresent() && reg_left->IsHandPresent())
 			{
 				is_playing = true;
 			}
@@ -97,4 +91,18 @@ namespace entities
 		is_playing = false;
 		std::cout << "collision" << std::endl;
 	}
+
+	double MainCharacter::UpdateDelta()
+	{
+		double current_time = glfwGetTime();
+		static double last_frame_time = current_time;
+		double delt_time = current_time - last_frame_time;
+		last_frame_time = current_time;
+		return delt_time;
+	}
+
+	bool MainCharacter::GetOnCollide()
+	{
+		return is_playing;
+	}
 }

src/entities/main_character.h

@@ -2,6 +2,7 @@
 
 #include "collision_entity.h"
 #include "../shaders/entity_shader.h"
+#include "../computervision/hand_detect_region.h"
 
 namespace entities
 {
@@ -9,8 +10,8 @@ namespace entities
 	* This class contains the information about the player model
 	*/
 	class MainCharacter : public CollisionEntity {
-		const float SIDE_SPEED = 0.8f;		//Standard movement speed for left/right movement
+		const int SIDE_SPEED = 40;		//Standard movement speed for left/right movement
-		const float UP_SPEED = 2.0f;		//Standard movement speed for up movement
+		const int UP_SPEED = 100;		//Standard movement speed for up movement
 	public:
 		/*
 		* @brief: Constructor for the main character model
@@ -31,8 +32,12 @@ namespace entities
 		* 
 		* @return: Vector with the adjusted side_speed, down_speed, and movement_speed
 		*/
-		void Move(GLFWwindow* window);
+		void Move(std::vector<computervision::HandDetectRegion*> regions);
 
 		void OnCollide(const collision::Collision& collision) override;
+
+		bool GetOnCollide();
+
+		double UpdateDelta();
 	};
 }

src/gui/gui_element.h

@@ -26,7 +26,7 @@ namespace gui
 		virtual GuiType GetType() {
 			return GuiType::LABEL;
 		}
-		GuiTexture(int texture, glm::vec2 position, glm::vec2 scale): texture(texture), position(position), scale(scale)
+		GuiTexture(GLuint texture, glm::vec2 position, glm::vec2 scale): texture(texture), position(position), scale(scale)
 		{
 			scale.x /= (WINDOW_WIDTH / WINDOW_HEIGHT);
 		}

src/main.cpp

@@ -27,17 +27,19 @@
 #include "scenes/scene.h"
 #include "scenes/in_Game_Scene.h"
 #include "scenes/startup_Scene.h"
+#include "scenes/loading_Scene.h"
+#include "model_Storage.h"
 
-#include "computervision/ObjectDetection.h"
+#include "computervision/object_detection.h"
-//#include "computervision/OpenPoseImage.h"
+#include "scenes/game_Over_Scene.h"
-#include "computervision/OpenPoseVideo.h"
+#include "entities/collision_entity.h"
-
+#include "computervision/object_detection.h"
-#include "computervision/async/async_arm_detection.h"
 
 #pragma comment(lib, "glfw3.lib")
 #pragma comment(lib, "glew32s.lib")
 #pragma comment(lib, "opengl32.lib")
 
+int score;
 static double UpdateDelta();
 
 static GLFWwindow* window;
@@ -47,15 +49,6 @@ scene::Scene* current_scene;
 bool points_img_available = false;
 cv::Mat points_img;
 
-void retrieve_points(std::vector<Point> arm_points, cv::Mat points_on_image)
-{
-
-	std::cout << "got points!!" << std::endl;
-	std::cout << "points: " << arm_points << std::endl;
-	points_img = points_on_image;
-	points_img_available = true;
-}
-
 int main(void)
 {
 #pragma region OPENGL_SETTINGS
@@ -71,10 +64,11 @@ int main(void)
 	glewInit();
 	glGetError();
 #pragma endregion
+    //current_scene = new scene::Startup_Scene();
+    current_scene = new scene::Loading_Scene();
+    score = 0;
 
 
-    current_scene = new scene::Startup_Scene();
-
     glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
         {
             if (key == GLFW_KEY_ESCAPE)
@@ -87,8 +81,6 @@ int main(void)
     
     bool window_open = true;
 
-	
-
 	// Main game loop
 	while (!glfwWindowShouldClose(window) && window_open)
 	{
@@ -103,13 +95,21 @@ int main(void)
                 window_open = false;
                 break;
 
+            case scene::Scenes::LOADING:
+                current_scene = new scene::Loading_Scene();
+                break;
+
             case scene::Scenes::STARTUP:
                 current_scene = new scene::Startup_Scene();
                 break;
 
 		
             case scene::Scenes::INGAME:
-                current_scene = new scene::In_Game_Scene();
+                current_scene = new scene::In_Game_Scene(&score);
+                break;
+                
+            case scene::Scenes::GAMEOVER:
+                current_scene = new scene::Game_Over_Scene(score);
                 break;
 
             default:
@@ -126,6 +126,7 @@ int main(void)
 
 	// Clean up -> preventing memory leaks!!!
     std::cout << "ending..." << std::endl;
+    render_engine::loader::CleanUp();
 	glfwTerminate();
 	return 0;
 }

src/model_Storage.cpp

@@ -0,0 +1,205 @@
+#include "model_Storage.h"
+
+
+singleton::Model_Storage* singleton::Model_Storage::instance{nullptr};
+std::mutex singleton::Model_Storage::mutex;
+
+singleton::Model_Storage::~Model_Storage()
+{
+	std::cout << "DELETING...." << std::endl;
+	delete instance;
+}
+
+singleton::Model_Storage* singleton::Model_Storage::get_instance()
+{
+	std::lock_guard<std::mutex> lock(mutex);
+	if (instance == nullptr)
+		instance = new Model_Storage();
+
+	return instance;
+}
+
+/**
+ * add methods
+ */
+
+void singleton::Model_Storage::add_couch(models::TexturedModel couch)
+{
+	couches.push_back(couch);
+}
+
+void singleton::Model_Storage::add_table(models::TexturedModel table)
+{
+	tables.push_back(table);
+}
+
+void singleton::Model_Storage::add_chair(models::TexturedModel chair)
+{
+	chairs.push_back(chair);
+}
+
+void singleton::Model_Storage::add_plant(models::TexturedModel plant)
+{
+	plants.push_back(plant);
+}
+
+void singleton::Model_Storage::add_guitar(models::TexturedModel guitar)
+{
+	guitars.push_back(guitar);
+}
+
+void singleton::Model_Storage::add_bookshelf(models::TexturedModel bookshelf)
+{
+	bookshelves.push_back(bookshelf);
+}
+
+void singleton::Model_Storage::add_lamp(models::TexturedModel lamp)
+{
+	lamps.push_back(lamp);
+}
+
+void singleton::Model_Storage::add_ceiling_object(models::TexturedModel co)
+{
+	ceiling_objects.push_back(co);
+}
+
+void singleton::Model_Storage::add_misc(models::TexturedModel misc)
+{
+	miscs.push_back(misc);
+}
+
+void singleton::Model_Storage::add_furniture_model(FurnitureModel model)
+{
+	furniture_models.push_back(model);
+}
+
+/**
+ * getters 
+ */
+
+std::deque<models::TexturedModel> singleton::Model_Storage::get_all_couches()
+{
+	return couches;
+}
+
+std::deque<models::TexturedModel> singleton::Model_Storage::get_all_tables()
+{
+	return tables;
+}
+
+std::deque<models::TexturedModel> singleton::Model_Storage::get_all_chairs()
+{
+	return chairs;
+}
+
+std::deque<models::TexturedModel> singleton::Model_Storage::get_all_plants()
+{
+	return plants;
+}
+
+std::deque<models::TexturedModel> singleton::Model_Storage::get_all_guitars()
+{
+	return guitars;
+}
+
+std::deque<models::TexturedModel> singleton::Model_Storage::get_all_bookshelves()
+{
+	return bookshelves;
+}
+
+std::deque<models::TexturedModel> singleton::Model_Storage::get_all_lamps()
+{
+	return lamps;
+}
+
+std::deque<models::TexturedModel> singleton::Model_Storage::get_all_ceiling_objects()
+{
+	return ceiling_objects;
+}
+
+std::deque<models::TexturedModel> singleton::Model_Storage::get_all_miscs()
+{
+	return miscs;
+}
+
+std::deque<singleton::FurnitureModel> singleton::Model_Storage::get_all_furniture_models()
+{
+	return furniture_models;
+}
+
+models::TexturedModel singleton::Model_Storage::get_couch(int index)
+{
+	return couches[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_table(int index)
+{
+	return tables[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_chair(int index)
+{
+	return chairs[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_plant(int index)
+{
+	return plants[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_guitar(int index)
+{
+	return guitars[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_bookshelf(int index)
+{
+	return bookshelves[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_lamp(int index)
+{
+	return lamps[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_ceiling_object(int index)
+{
+	return ceiling_objects[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_misc(int index)
+{
+	return miscs[index];
+}
+
+singleton::FurnitureModel singleton::Model_Storage::get_furniture_model(int index)
+{
+	return furniture_models[index];
+}
+
+
+//getters for default variables
+models::TexturedModel singleton::Model_Storage::get_house_model()
+{
+	return house_model;
+}
+
+models::ModelTexture singleton::Model_Storage::get_default_texture()
+{
+	return default_texture;
+}
+
+ //setters for deafult variables
+void singleton::Model_Storage::set_house_model(models::TexturedModel house)
+{
+	house_model = house;
+}
+
+void singleton::Model_Storage::set_default_texture(models::ModelTexture texture)
+{
+	default_texture = texture;
+}
+
+
+
+

src/model_Storage.h

@@ -0,0 +1,137 @@
+#pragma once
+#include <iostream>
+#include <deque>
+#include <mutex>
+#include "models/Model.h"
+#include "entities/Entity.h"
+
+namespace singleton {
+	enum class FurnitureType
+	{
+		COUCH,
+		TABLE,
+		CHAIR,
+		PLANT,
+		GUITAR,
+		BOOKSHELF,
+		LAMP,
+		CEILING_OBJECTS,
+		MISC
+	};
+	struct FurniturePiece
+	{
+		FurnitureType type;
+		int size;
+	};
+
+	struct FurnitureModel
+	{
+		FurniturePiece furniture;
+		std::deque<models::TexturedModel> texture;
+
+		bool operator<(FurnitureModel a)
+		{
+			return true;
+		}
+	};
+	
+	class Model_Storage
+	{
+	private:
+		static Model_Storage* instance;
+		static std::mutex mutex;
+
+		//model of the house
+		models::TexturedModel house_model;
+		//default texture
+		models::ModelTexture default_texture;
+
+		//list that sorts furniture_models on type
+		std::deque<FurnitureModel> furniture_models;
+		
+		//list of furniture:
+		//couches
+		std::deque<models::TexturedModel> couches;
+
+		//tables
+		std::deque<models::TexturedModel> tables;
+
+		//chairs
+		std::deque<models::TexturedModel> chairs;
+
+		//plants
+		std::deque<models::TexturedModel> plants;
+
+		//guitars
+		std::deque<models::TexturedModel> guitars;
+
+		//bookshelves
+		std::deque<models::TexturedModel> bookshelves;
+
+		//lamps
+		std::deque<models::TexturedModel>lamps;
+
+		//ceiling objects 
+		std::deque<models::TexturedModel>ceiling_objects;
+
+		//misc
+		std::deque<models::TexturedModel> miscs;
+
+	protected:
+		Model_Storage() { std::cout << "MAKING A NEW SINGLETON!!!" << std::endl; }
+		~Model_Storage();
+
+	public:
+		Model_Storage(Model_Storage& other) = delete;
+		void operator=(const Model_Storage&) = delete;
+
+		static Model_Storage* get_instance();
+
+		//some methods to execute on its instance:
+		void add_couch(models::TexturedModel couch);
+		void add_table(models::TexturedModel table);
+		void add_chair(models::TexturedModel chair);
+		void add_plant(models::TexturedModel plant);
+		void add_guitar(models::TexturedModel guitar);
+		void add_bookshelf(models::TexturedModel bookshelf);
+		void add_lamp(models::TexturedModel lamp);
+		void add_ceiling_object(models::TexturedModel co);
+		void add_misc(models::TexturedModel misc);
+		void add_furniture_model(FurnitureModel model);
+
+		//getters for the whole list
+		std::deque<models::TexturedModel> get_all_couches();
+		std::deque<models::TexturedModel> get_all_tables();
+		std::deque<models::TexturedModel> get_all_chairs();
+		std::deque<models::TexturedModel> get_all_plants();
+		std::deque<models::TexturedModel> get_all_guitars();
+		std::deque<models::TexturedModel> get_all_bookshelves();
+		std::deque<models::TexturedModel> get_all_lamps();
+		std::deque<models::TexturedModel> get_all_ceiling_objects();
+		std::deque<models::TexturedModel> get_all_miscs();
+		std::deque<FurnitureModel> get_all_furniture_models();
+
+		//getters for one model
+		models::TexturedModel get_couch(int index);
+		models::TexturedModel get_table(int index);
+		models::TexturedModel get_chair(int index);
+		models::TexturedModel get_plant(int index);
+		models::TexturedModel get_guitar(int index);
+		models::TexturedModel get_bookshelf(int index);
+		models::TexturedModel get_lamp(int index);
+		models::TexturedModel get_ceiling_object(int index);
+		models::TexturedModel get_misc(int index);
+		FurnitureModel get_furniture_model(int index);
+
+		//getters for the standard variables
+		models::TexturedModel get_house_model();
+		models::ModelTexture get_default_texture();
+
+		//setters for the standard variables
+		void set_house_model(models::TexturedModel house);
+		void set_default_texture(models::ModelTexture texture);
+
+	};
+}
+
+

src/renderEngine/Renderer.cpp

@@ -109,6 +109,88 @@ namespace render_engine
 				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();
+		}
+
+		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);
 

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,219 @@
+#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/object_detection.h"
+#include "../computervision/hand_detect_region.h"
+#include <opencv2/highgui.hpp>
+#include "../computervision/object_detection.h"
+
+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;
+
+	float item_number_gameOver = 0;
+	bool hand_mode_gameOver = false;
+
+	Game_Over_Scene::Game_Over_Scene(int score) 
+	{
+		shaders::EntityShader shader;
+		shader.Init();
+		render_engine::renderer::Init(shader);
+		shader.CleanUp();
+
+		gui_shader_gameOver = new shaders::GuiShader();
+		gui_shader_gameOver->Init();
+
+		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.0f, 0.2f), glm::vec2(0.07, 0.15));
+
+			score_textures_gameOver.push_back(score_pointer);
+		}
+
+		game_over_texture = std::make_unique<gui::GuiTexture>(render_engine::loader::LoadTexture("res/game_over.png"), glm::vec2(0.0f, 0.6f), glm::vec2(0.50f, 0.50f));
+		end_score = score;
+	}
+
+	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.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([]()
+			{
+				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);
+		
+		render_engine::renderer::Render(game_over_texture, *gui_shader_gameOver);
+		DrawScore(end_score);
+		}
+
+	/**
+	 * 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::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)
+	{
+		std::vector<int> digits;
+		score_guis_gameOver.clear();
+
+		toolbox::GetDigitsFromNumber(score, digits);
+
+		for (int i = digits.size() - 1; i >= 0; i--)
+		{
+			score_textures_gameOver[digits[i]].get()->position.x = (0.15 * i - 0.05);
+			render_engine::renderer::Render(score_textures_gameOver[digits[i]], *gui_shader_gameOver);
+		}
+	}
+}

src/scenes/game_Over_Scene.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "scene.h"
+#include "../gui/gui_element.h"
+
+namespace scene
+{
+	extern GLFWwindow* window;
+
+	class Game_Over_Scene : public scene::Scene
+	{
+	private:
+		
+		int end_score;
+		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;
+
+
+	public:
+		Game_Over_Scene(int score);
+
+		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;
+		/**
+		* @brief: This method renders the score points onto the game window
+		* @param score: Score to show
+		*/
+		void DrawScore(int score);
+	};
+}

src/scenes/in_Game_Scene.cpp

@@ -1,36 +1,16 @@
-#include <iostream>
-#include <memory>
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
 #include "in_Game_Scene.h"
-#include "startup_Scene.h"
-#include "../entities/main_character.h"
-#include "../collision/collision_handler.h"
-#include "../gui/gui_interactable.h"
-#include "../models/model.h"
-#include "../renderEngine/loader.h"
-#include "../renderEngine/obj_loader.h"
-#include "../renderEngine/renderer.h"
-#include "../shaders/entity_shader.h"
-#include "../toolbox/toolbox.h"
-#include "../entities/house_generator.h"
-#include <deque>
-#include <functional>
-#include <memory>
-#include <queue>
-#include <opencv2/core/base.hpp>
-#include "../computervision/HandDetectRegion.h"
-#include "../computervision/ObjectDetection.h"
 
 #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;
+	std::deque<std::shared_ptr<entities::CollisionEntity>> collision_entities;
+
+	//std::deque<std::shared_ptr<entities::CollisionEntity>> furniture_collision;
+
 	entities::HouseGenerator* house_generator;
 	std::deque<std::shared_ptr<entities::Entity>> house_models;
 
@@ -39,18 +19,24 @@ 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;
+	int* ptr;
+	bool calibrated = false;
 
-	std::vector<computervision::HandDetectRegion> regions;
+	float delta_time = 0;
+
+	std::vector<computervision::HandDetectRegion*> regions;
 	computervision::HandDetectRegion reg_left("left", 0, 0, 150, 150), reg_right("right", 0, 0, 150, 150), reg_up("up", 0, 0, 150, 150);
 
 	/**
 	 * sets up the first things when the objects has been made
 	 */
-	In_Game_Scene::In_Game_Scene()
+	In_Game_Scene::In_Game_Scene(int *score_ptr)
 	{
+		ptr = score_ptr;
 		camera = std::make_unique<entities::Camera>(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
 
 		shader = new shaders::EntityShader;
@@ -60,9 +46,22 @@ 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);
 		}
+	}
+
 	/**
-	 * temporary!!!!
+	 * temporary?
 	 * just to make some bounding boxes
 	 */
 	collision::Box create_bounding_box(glm::vec3 size, glm::vec3 pos, int scale) {
@@ -84,41 +83,50 @@ namespace scene
 	}
 
 	
-	/**
+	void In_Game_Scene::SetupHandDetection()
-	 * @brief loads a new chunk in front of the camera, and deletes the chunk behind the camera.
-	 *
-	 * @param model_pos the amount of models the camera has passed already. This is the rounded result of (z position of camera) / (size of model)
-	 *
-	 */
-	void load_chunk(int model_pos)
 	{
-		static unsigned int furniture_count = 0;
-
 		// set up squares according to size of camera input
 		cv::Mat camera_frame;
 		static_camera::getCap().read(camera_frame); // get camera frame to know the width and heigth
+
+		reg_left.SetMainSkinDetecRegion(true);
+		reg_right.SetMainSkinDetecRegion(false);
+		reg_right.SetMainSkinDetecRegion(false);
+		std::function<void()> callback = [this]() {OnSkinCalibrationCallback(); };
+		reg_left.SetSkinTimerCallback(callback);
+
 		reg_left.SetXPos(10);
 		reg_left.SetYPos(camera_frame.rows / 2 - reg_left.GetHeight() / 2);
 		reg_right.SetXPos(camera_frame.cols - 10 - reg_right.GetWidth());
 		reg_right.SetYPos(camera_frame.rows / 2 - reg_right.GetHeight() / 2);
 		reg_up.SetXPos(camera_frame.cols / 2 - reg_up.GetWidth() / 2);
 		reg_up.SetYPos(10);
+	}
+
+	
+	void In_Game_Scene::LoadChunk(int model_pos)
+	{
+		static unsigned int furniture_count = 0;
 		std::cout << "loading model chunk" << std::endl;
+		
 		if (house_models.size() >= MAX_MODEL_DEQUE_SIZE * furniture_count)
 		{
 			for (int i = 0; i < furniture_count; i++)
 			{
 				house_models.pop_front();
+				collision_entities.pop_front();
 			}
 		}
 		int z_offset = model_pos * (house_generator->GetHouseDepth()); // how much "in the distance" we should load the model
-
+			std::deque<std::shared_ptr<entities::CollisionEntity>> furniture;
-		std::deque<std::shared_ptr<entities::Entity>> furniture = house_generator->GenerateHouse(glm::vec3(0, -75, -50 - z_offset), 90);
+			house_generator->GenerateHouse(&furniture, 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;
+
 	}
 
 	/**
@@ -134,13 +142,17 @@ namespace scene
 		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);
-		main_character = std::make_shared<entities::MainCharacter>(model_char, glm::vec3(0, -50, -100), glm::vec3(0, 90, 0), 5, char_box);
+		main_character = std::make_shared<entities::MainCharacter>(model_char, glm::vec3(0, 150, -100), glm::vec3(0, 90, 0), 5, char_box);
-		collision_entities.push_back(main_character);
+		
+		//collision_entities.push_back(main_character);
 		house_generator = new entities::HouseGenerator();
+
+		SetupHandDetection();
+
 		// load the first few house models
 		for (int i = 0; i <= UPCOMING_MODEL_AMOUNT; i++)
 		{
-			load_chunk(i);
+			LoadChunk(i);
 		}
 
 		lights.push_back(entities::Light(glm::vec3(0, 1000, 7000), glm::vec3(5, 5, 5))); // sun
@@ -180,6 +192,9 @@ namespace scene
 			});
 		pause_guis.push_back(&pause_button_quit);
 
+		regions.push_back(&reg_left);
+		regions.push_back(&reg_up);
+		regions.push_back(&reg_right);
 
 		//the scene loop, this while loop represent the scene
 		while (return_value == scene::Scenes::INGAME)
@@ -212,7 +227,7 @@ namespace scene
 		}
 		shader->CleanUp();
 		gui_shader->CleanUp();
-		render_engine::loader::CleanUp();
+		//render_engine::loader::CleanUp();
 		return return_value;
 	}
 
@@ -241,16 +256,25 @@ namespace scene
 
 		// Stop rendering the entities
 		shader->Stop();
+
+		DrawScore(score);
 	}
 
 	//updates certain variables 
 	void scene::In_Game_Scene::update(GLFWwindow* window)
 	{
+		UpdateDeltaTime();
 		//camera.Move(window);
+		update_hand_detection();
+		if (!calibrated) return;
+		main_character->Move(regions);
+		if (!main_character.get()->GetOnCollide())
+		{	
+			*ptr = score;
+			std::cout << "Score: " << score << std::endl;
+			return_value = scene::Scenes::GAMEOVER;
+		}
 
-		main_character->Move(window);
-
-		//std::cout << "x get: " << movement.x << "\ny get: " << movement.y << "\nz get: " << movement.z << "\n";
 		camera->Follow(main_character->GetPosition());
 
 		// calculate where the next house model should be loaded
@@ -260,16 +284,19 @@ namespace scene
 		// if we have passed a model, load a new one and delete the one behind us
 		if (last_model_pos != model_pos)
 		{
-			load_chunk(model_pos + UPCOMING_MODEL_AMOUNT);
+			std::cout << "updating score" << std::endl;
+			LoadChunk(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;
+		collision_entities.push_front(main_character);
 
 		collision::CheckCollisions(collision_entities);
-		update_hand_detection();
+		collision_entities.pop_front();
 	}
 
 	//manages the key input in the game scene
@@ -288,24 +315,14 @@ namespace scene
 		{
 			game_state = scene::Game_State::RUNNING;
 		}
-
-		if (glfwGetKey(window, GLFW_KEY_B) == GLFW_PRESS)
-		{
-			reg_left.CalibrateBackground();
-			reg_right.CalibrateBackground();
-			reg_up.CalibrateBackground();
-		}
-
-		if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
-		{
-			std::vector<int> tresholds = reg_left.CalculateSkinTresholds();
-			reg_right.setSkinTresholds(tresholds);
-			reg_up.setSkinTresholds(tresholds);
-		}
 	}
 
 	void scene::In_Game_Scene::update_hand_detection()
 	{
+		reg_left.UpdateTime(delta_time);
+		reg_right.UpdateTime(delta_time);
+		reg_up.UpdateTime(delta_time);
+
 		cv::Mat camera_frame;
 		static_camera::getCap().read(camera_frame);
 		reg_left.DetectHand(camera_frame);
@@ -315,9 +332,42 @@ namespace scene
 		cv::imshow("camera", camera_frame);
 	}
 
+	void scene::In_Game_Scene::OnSkinCalibrationCallback()
+	{
+		calibrated = true;
+		std::cout << "on skin calibration callback" << std::endl;
+		std::vector<int> tresholds = reg_left.CalculateSkinTresholds();
+		reg_right.setSkinTresholds(tresholds);
+		reg_up.setSkinTresholds(tresholds);
+	}
+
 	//renders the models for the pause menu
 	void In_Game_Scene::render_pause_menu()
 	{
 		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; // place the number at the top left. the numbers are just fine tuned to get the position just right
+			render_engine::renderer::Render(score_textures[digits[i]], *gui_shader);
+		}
+	}
+
+	void In_Game_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;
+
+	}
 }

src/scenes/in_Game_Scene.h

@@ -3,6 +3,18 @@
 #include <ostream>
 #include <vector>
 #include <memory>
+#include <string>
+#include <opencv2/core/base.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <deque>
+#include <functional>
+#include <queue>
+#include <opencv2/core/base.hpp>
+
+#include "startup_Scene.h"
 #include "scene.h"
 #include "../gui/gui_interactable.h"
 #include "../models/model.h"
@@ -11,6 +23,12 @@
 #include "../renderEngine/renderer.h"
 #include "../shaders/entity_shader.h"
 #include "../toolbox/toolbox.h"
+#include "../entities/main_character.h"
+#include "../collision/collision_handler.h"
+#include "../entities/house_generator.h"
+#include "../computervision/hand_detect_region.h"
+#include "../computervision/object_detection.h"
+
 
 
 namespace scene
@@ -27,7 +45,6 @@ namespace scene
 		PAUSED
 	};
 
-
 	class In_Game_Scene : public scene::Scene
 	{
 	private:
@@ -53,6 +70,10 @@ namespace scene
 		std::vector<gui::GuiTexture*> guis;
 		//pause_guis is a list of components that will be rendered when the game is paused.
 		std::vector<gui::GuiTexture*> pause_guis;
+		// list of gui texture that holds the textures for the score
+		std::vector<std::shared_ptr<gui::GuiTexture>> score_guis;
+
+		void UpdateDeltaTime();
 
 		/**
 		 * @brief renders the objects/gui models
@@ -60,10 +81,42 @@ namespace scene
 		 * @return void
 		 */
 		void render_pause_menu();
+
+		/**
+		 * @brief updates the hand detection with the deltatime and checks the hand detection for each region. als updates the camera display
+		 *
+		 */
 		void update_hand_detection();
 
+		/**
+		 * @brief sets up the hand detection regions and sets the callbacks for the skin calibration.
+		 *
+		 */
+		void SetupHandDetection();
+
+		/**
+		 * @brief callback that gets called when the left skin detect region timout has been reached. sets the other regions with the skin data from the first region
+		 *
+		 */
+		void OnSkinCalibrationCallback();
+
+		/**
+		 * @brief draws the score on the screen with the digit resources.
+		 * 
+		 * @param score the score to display.
+		 */
+		void DrawScore(int score);
+
+		/**
+		 * @brief loads a new chunk in front of the camera, and deletes the chunk behind the camera.
+		 *
+		 * @param model_pos the amount of models the camera has passed already. This is the rounded result of (z position of camera) / (size of model)
+		 *
+		 */
+		void LoadChunk(int model_pos);
+	
 	public:
-		In_Game_Scene();
+		In_Game_Scene(int *score_ptr);
 		~In_Game_Scene();
 
 		/**

src/scenes/loading_Scene.cpp

@@ -1,15 +1,31 @@
 #include "loading_Scene.h"
+
+#include <iostream>
+
 #include "../renderEngine/Renderer.h"
 #include "../renderEngine/Loader.h"
+#include "../renderEngine/obj_loader.h"
 #include "../gui/gui_element.h"
+#include "../entities/collision_entity.h"
 
 namespace scene
 {
+	std::unique_ptr<entities::Camera> camera_test;
+	shaders::EntityShader* shader_test;
+	std::deque<std::shared_ptr<entities::Entity>> test;
 
 	Loading_Scene::Loading_Scene()
 	{
+		shader_test = new shaders::EntityShader;
+		shader_test->Init();
+		render_engine::renderer::Init(*shader_test);
+		delete shader_test;
+		
 		gui_shader = new shaders::GuiShader();
 		gui_shader->Init();
+
+		camera_test = std::make_unique<entities::Camera>(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
+
 	}
 
 	Loading_Scene::~Loading_Scene()
@@ -20,20 +36,34 @@ namespace scene
 	Scenes Loading_Scene::start(GLFWwindow* window)
 	{
 		render();
-		return Scenes::STARTUP;
+
+		glfwSwapBuffers(window);
+		glfwPollEvents();
+		
+		load_default_variables();
+		load_all_models();
+		
+		return scene::Scenes::STARTUP;
 	}
 
 	void Loading_Scene::render()
 	{
-		/*render_engine::renderer::Prepare();
+		render_engine::renderer::Prepare();
+		//starts the shader and begins to render
+		//shader_test->Start();
+		//shader_test->LoadSkyColor(render_engine::renderer::SKY_COLOR); 
+		//shader_test->LoadViewMatrix(*camera_test);
 				
-		gui::GuiTexture loading_image = { render_engine::loader::LoadTexture("res/menu_item_start1.png"),
+		gui::GuiTexture loading_image = { render_engine::loader::LoadTexture("res/loading_screen.png"),
 			glm::vec2(0,0),glm::vec2(1,1) };
 		
 		std::vector<gui::GuiTexture*> image_list;
 		image_list.push_back(&loading_image);
 		
-		render_engine::renderer::Render(image_list, *gui_shader);*/
+		render_engine::renderer::Render(image_list, *gui_shader);
+		//shader_test->Stop();
+
+		gui_shader->CleanUp();
 	}
 
 	void Loading_Scene::update(GLFWwindow* window)
@@ -44,4 +74,73 @@ namespace scene
 	void Loading_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
 	{
 	}
+
+
+	void Loading_Scene::load_default_variables()
+	{
+		models::RawModel raw_model = render_engine::LoadObjModel("res/HouseNew.obj");
+		models::ModelTexture default_texture = { render_engine::loader::LoadTexture("res/Texture.png") };
+		default_texture.shine_damper = 10;
+		models::TexturedModel house = { raw_model, default_texture };
+		
+		singleton::Model_Storage::get_instance()->set_house_model(house);
+		singleton::Model_Storage::get_instance()->set_default_texture(default_texture);
+	}
+
+	void Loading_Scene::load_all_models() 
+	{
+		// Couches
+		singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/couchThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/Coach.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/lawnBenchOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::COUCH, 2}, singleton::Model_Storage::get_instance()->get_all_couches() });
+		
+		// Tables
+		singleton::Model_Storage::get_instance()->add_table({ render_engine::LoadObjModel("res/tableOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_table({ render_engine::LoadObjModel("res/tableTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_table({ render_engine::LoadObjModel("res/bureauOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::TABLE, 2}, singleton::Model_Storage::get_instance()->get_all_tables() });
+
+		// Chairs
+		singleton::Model_Storage::get_instance()->add_chair({ render_engine::LoadObjModel("res/launchchair.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_chair({ render_engine::LoadObjModel("res/lawnChairOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_chair({ render_engine::LoadObjModel("res/ugly_chair.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::CHAIR, 1}, singleton::Model_Storage::get_instance()->get_all_chairs() });
+
+		// Plants
+		singleton::Model_Storage::get_instance()->add_plant({ render_engine::LoadObjModel("res/plantOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_plant({ render_engine::LoadObjModel("res/plantTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_plant({ render_engine::LoadObjModel("res/plantThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::PLANT, 1}, singleton::Model_Storage::get_instance()->get_all_plants() });
+
+		// Guitars
+		singleton::Model_Storage::get_instance()->add_guitar({ render_engine::LoadObjModel("res/guitarOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_guitar({ render_engine::LoadObjModel("res/guitarTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::GUITAR, 1}, singleton::Model_Storage::get_instance()->get_all_guitars() });
+
+		// Bookshelves
+		singleton::Model_Storage::get_instance()->add_bookshelf({ render_engine::LoadObjModel("res/bookShelfOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_bookshelf({ render_engine::LoadObjModel("res/bookShelfTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_bookshelf({ render_engine::LoadObjModel("res/bookShelfThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::BOOKSHELF, 1}, singleton::Model_Storage::get_instance()->get_all_bookshelves() });
+
+		// Lamps
+		singleton::Model_Storage::get_instance()->add_lamp({ render_engine::LoadObjModel("res/lampOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_lamp({ render_engine::LoadObjModel("res/lampTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::LAMP, 1}, singleton::Model_Storage::get_instance()->get_all_lamps() });
+
+		// Ceiling objects
+		singleton::Model_Storage::get_instance()->add_ceiling_object({ render_engine::LoadObjModel("res/ceilingFan.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_ceiling_object({ render_engine::LoadObjModel("res/ceilingFanTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_ceiling_object({ render_engine::LoadObjModel("res/ceilingLampOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_ceiling_object({ render_engine::LoadObjModel("res/ceilingLampTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::CEILING_OBJECTS, 1}, singleton::Model_Storage::get_instance()->get_all_ceiling_objects() });
+
+		// Miscs
+		singleton::Model_Storage::get_instance()->add_misc({ render_engine::LoadObjModel("res/tv.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_misc({ render_engine::LoadObjModel("res/radio.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_misc({ render_engine::LoadObjModel("res/Flowerpot.obj"), singleton::Model_Storage::get_instance()->get_default_texture() });
+		singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::MISC, 1}, singleton::Model_Storage::get_instance()->get_all_miscs() });
+
+	}
 }

src/scenes/loading_Scene.h

@@ -1,8 +1,8 @@
 #pragma once
-#pragma once
 #include "scene.h"
 #include "../gui/gui_element.h"
 #include "../shaders/gui_shader.h"
+#include "../model_Storage.h"
 
 namespace scene
 {
@@ -17,9 +17,13 @@ namespace scene
 		shaders::GuiShader* gui_shader;
 
 
+	private:
+		void load_default_variables();
+		void load_all_models();
+
 	public:
 		/**
-		 * @brief Constructor of the class Startup_Scene
+		 * @brief Constructor of the class Loading_Scene
 		 *
 		 */
 		Loading_Scene();

src/scenes/scene.h

@@ -55,7 +55,6 @@ namespace scene {
 		 * @return void
 		 */
 		virtual void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) {};
+
 	};
 }
-
-

src/scenes/startup_Scene.cpp

@@ -14,8 +14,8 @@
 #include "../gui/gui_interactable.h"
 #include "../toolbox/toolbox.h"
 #include "../computervision/MenuTest.h"
-#include "../computervision/ObjectDetection.h"
+#include "../computervision/object_detection.h"
-#include "../computervision/HandDetectRegion.h"
+#include "../computervision/hand_detect_region.h"
 
 
 
@@ -175,7 +175,7 @@ namespace scene
 			glfwPollEvents();
 		}
 		gui_shader1->CleanUp();
-		render_engine::loader::CleanUp();
+		//render_engine::loader::CleanUp();
 		return return_value;
 	}
 

src/toolbox/Timer.h

@@ -42,5 +42,7 @@ namespace toolbox
 		 * @return: True if the timer has finished 
 		 */
 		bool HasFinished() const { return has_finished; }
+
+		void Reset() { current_time = 0; }
 	};
 }

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

@@ -19,19 +19,19 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="src\model_Storage.cpp" />
     <ClCompile Include="src\collision\collision_handler.cpp" />
     <ClCompile Include="src\entities\main_character.cpp" />
     <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\computervision\hand_detect_region.cpp" />
     <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
     <ClCompile Include="src\computervision\MenuTest.cpp" />
-    <ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
+    <ClCompile Include="src\computervision\object_detection.cpp" />
-    <ClCompile Include="src\computervision\ObjectDetection.cpp" />
+    <ClCompile Include="src\computervision\skin_detector.cpp" />
-    <ClCompile Include="src\computervision\OpenPoseVideo.cpp" />
+    <ClCompile Include="src\computervision\finger_count.cpp" />
-    <ClCompile Include="src\computervision\SkinDetector.cpp" />
+    <ClCompile Include="src\computervision\background_remover.cpp" />
-    <ClCompile Include="src\computervision\FingerCount.cpp" />
-    <ClCompile Include="src\computervision\BackgroundRemover.cpp" />
     <ClCompile Include="src\entities\camera.cpp" />
     <ClCompile Include="src\entities\collision_entity.cpp" />
     <ClCompile Include="src\entities\entity.cpp" />
@@ -49,24 +49,24 @@
     <ClCompile Include="src\scenes\startup_Scene.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="src\model_Storage.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\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\computervision\hand_detect_region.h" />
     <ClInclude Include="src\scenes\in_Game_Scene.h" />
     <ClInclude Include="src\scenes\loading_Scene.h" />
     <ClInclude Include="src\scenes\scene.h" />
-    <ClInclude Include="src\computervision\async\async_arm_detection.h" />
     <ClInclude Include="src\computervision\async\StaticCameraInstance.h" />
-    <ClInclude Include="src\computervision\FingerCount.h" />
+    <ClInclude Include="src\computervision\finger_count.h" />
-    <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\computervision\background_remover.h" />
     <ClInclude Include="src\computervision\MenuTest.h" />
-    <ClInclude Include="src\computervision\OpenPoseVideo.h" />
+    <ClInclude Include="src\computervision\skin_detector.h" />
-    <ClInclude Include="src\computervision\SkinDetector.h" />
+    <ClInclude Include="src\computervision\object_detection.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" />

wk2_fps.vcxproj.filters

@@ -4,11 +4,11 @@
     <ClCompile Include="src\collision\collision_handler.cpp" />
     <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
     <ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
-    <ClCompile Include="src\computervision\ObjectDetection.cpp" />
+    <ClCompile Include="src\computervision\object_detection.cpp" />
     <ClCompile Include="src\computervision\OpenPoseVideo.cpp" />
-    <ClCompile Include="src\computervision\SkinDetector.cpp" />
+    <ClCompile Include="src\computervision\skin_detector.cpp" />
-    <ClCompile Include="src\computervision\FingerCount.cpp" />
+    <ClCompile Include="src\computervision\finger_count.cpp" />
-    <ClCompile Include="src\computervision\BackgroundRemover.cpp" />
+    <ClCompile Include="src\computervision\background_remover.cpp" />
     <ClCompile Include="src\entities\camera.cpp" />
     <ClCompile Include="src\entities\collision_entity.cpp" />
     <ClCompile Include="src\entities\entity.cpp" />
@@ -23,12 +23,14 @@
     <ClCompile Include="src\toolbox\toolbox.cpp" />
     <ClCompile Include="src\scenes\startup_Scene.cpp" />
     <ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
-    <ClCompile Include="src\computervision\HandDetectRegion.cpp" />
+    <ClCompile Include="src\computervision\hand_detect_region.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\loading_Scene.cpp" />
+    <ClCompile Include="src\model_Storage.cpp" />
+    <ClCompile Include="src\scenes\game_Over_Scene.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\entities\Camera.cpp">
@@ -94,11 +96,9 @@
     <ClInclude Include="src\collision\collision_handler.h" />
     <ClInclude Include="src\scenes\in_Game_Scene.h" />
     <ClInclude Include="src\scenes\scene.h" />
-    <ClInclude Include="src\computervision\async\async_arm_detection.h" />
     <ClInclude Include="src\computervision\async\StaticCameraInstance.h" />
     <ClInclude Include="src\computervision\FingerCount.h" />
     <ClInclude Include="src\computervision\BackgroundRemover.h" />
-    <ClInclude Include="src\computervision\OpenPoseVideo.h" />
     <ClInclude Include="src\computervision\SkinDetector.h" />
     <ClInclude Include="src\computervision\ObjectDetection.h" />
     <ClInclude Include="src\entities\camera.h" />
@@ -119,7 +119,7 @@
     <ClInclude Include="src\toolbox\toolbox.h" />
     <ClInclude Include="src\scenes\startup_Scene.h" />
     <ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
-    <ClInclude Include="src\computervision\HandDetectRegion.h" />
+    <ClInclude Include="src\computervision\hand_detect_region.h" />
     <ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
     <ClInclude Include="src\collision\collision.h" />
     <ClInclude Include="src\collision\collision_handler.h" />
@@ -127,11 +127,11 @@
     <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\finger_count.h" />
-    <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\computervision\background_remover.h" />
     <ClInclude Include="src\computervision\MenuTest.h" />
-    <ClInclude Include="src\computervision\SkinDetector.h" />
+    <ClInclude Include="src\computervision\skin_detector.h" />
-    <ClInclude Include="src\computervision\ObjectDetection.h" />
+    <ClInclude Include="src\computervision\object_detection.h" />
     <ClInclude Include="src\entities\camera.h" />
     <ClInclude Include="src\entities\collision_entity.h" />
     <ClInclude Include="src\entities\entity.h" />
@@ -150,6 +150,8 @@
     <ClInclude Include="src\toolbox\toolbox.h" />
     <ClInclude Include="src\scenes\startup_Scene.h" />
     <ClInclude Include="src\scenes\loading_Scene.h" />
+    <ClInclude Include="src\model_Storage.h" />
+    <ClInclude Include="src\scenes\game_Over_Scene.h" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />