Merge pull request #9 from SemvdH/develop

Develop into master

.gitignore

@@ -2,6 +2,8 @@
 # Created by https://www.toptal.com/developers/gitignore/api/c++,visualstudio,visualstudiocode,opencv
 # Edit at https://www.toptal.com/developers/gitignore?templates=c++,visualstudio,visualstudiocode,opencv
 
+res/**
+
 ### C++ ###
 # Prerequisites
 *.d
@@ -428,4 +430,6 @@ FodyWeavers.xsd
 **/docs/*
 **/doc/*
 
+**/pose_iter_160000.caffemodel
+
 # End of https://www.toptal.com/developers/gitignore/api/c++,visualstudio,visualstudiocode,opencv

src/collision/collision.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <iostream>
+#include <glm/gtc/matrix_transform.hpp>
+#include "../entities/entity.h"
+
+namespace collision
+{
+	/*
+	 * This structure represents a collision box inside the world.
+	 *
+	 * center_pos:	The center position of the collision box
+	 * size:		The size in each axis of the collision box
+	 */
+	struct Box
+	{
+		glm::vec3 center_pos;
+		glm::vec3 size;
+
+		void SetRotation(float angle)
+		{
+			double sinTheta = glm::sin(glm::radians(angle));
+			double cosTheta = glm::cos(glm::radians(angle));
+
+			float x = size.x * cosTheta + size.z * sinTheta;
+			float z = size.z * cosTheta - size.x * sinTheta;
+			
+			size.x = x < 0 ? -x : x;
+			size.z = z < 0 ? -z : z;
+		}
+	};
+
+	/*
+	 * This structure represents a collision between 2 entities
+	 *
+	 * entity1:		The first entity
+	 * entity2:		The second entity
+	 */
+	struct Collision
+	{
+		entities::Entity& entity1;
+		entities::Entity& entity2;
+	};
+}

src/collision/collision_handler.cpp

@@ -0,0 +1,44 @@
+#include "collision_handler.h"
+#include <iostream>
+
+namespace collision
+{
+	void CheckCollisions(std::deque<std::shared_ptr<entities::CollisionEntity>>& entities)
+	{
+		if (entities.size() < 2) { return; }
+			if (entities.size() == 2)
+			{
+				if (entities[0]->IsColliding(*entities[1]))
+				{
+					collision::Collision c = { *entities[0], *entities[1] };
+					entities[0]->OnCollide(c);
+					entities[1]->OnCollide(c);
+				}
+			}
+		
+			for (int i = 0; i < entities.size() - 2; i++)
+			{
+				std::shared_ptr<entities::CollisionEntity> entity = entities[i];
+
+				for (int j = i + 1; j < entities.size() - 1; j++)
+				{
+					
+					std::shared_ptr<entities::CollisionEntity> entity2 = entities[j];
+
+					if (entity == entity2)
+					{
+						continue;
+					}
+
+					if (entity->IsColliding(*entity2))
+					{
+						collision::Collision c = { *entity, *entity2 };
+						entity->OnCollide(c);
+						entity2->OnCollide(c);
+						break;
+					}
+				}
+			}
+			
+	}
+}

src/collision/collision_handler.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include "../entities/collision_entity.h"
+#include "collision.h"
+#include <deque>
+
+namespace collision
+{
+	/*
+	 * @brief: This function will check all the collision entities for
+	 *         collisions and call the OnCollide function when a entity collides.
+	 *
+	 * @param entities: A list with all the collision entities.
+	 */
+	void CheckCollisions(std::deque<std::shared_ptr<entities::CollisionEntity>>& entities);
+}

src/computervision/BackgroundRemover.h

@@ -1,25 +0,0 @@
-#pragma once
-#include"opencv2\opencv.hpp"
-#include <opencv2/imgproc\types_c.h>
-/*
- Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
-*/
-namespace computervision
-{
-using namespace cv;
-using namespace std;
-
-	class BackgroundRemover {
-	public:
-		BackgroundRemover(void);
-		void calibrate(Mat input);
-		Mat getForeground(Mat input);
-
-	private:
-		Mat background;
-		bool calibrated = false;
-
-		Mat getForegroundMask(Mat input);
-		void removeBackground(Mat input, Mat background);
-	};
-}

src/computervision/FaceDetector.cpp

@@ -1,53 +0,0 @@
-#include "FaceDetector.h"
-
-
-/*
- Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
-*/
-namespace computervision
-{
-	Rect getFaceRect(Mat input);
-
-	String faceClassifierFileName = "res/haarcascade_frontalface_alt.xml";
-	CascadeClassifier faceCascadeClassifier;
-
-	FaceDetector::FaceDetector(void) {
-		if (!faceCascadeClassifier.load(faceClassifierFileName))
-			throw runtime_error("can't load file " + faceClassifierFileName);
-	}
-
-	void FaceDetector::removeFaces(Mat input, Mat output) {
-		vector<Rect> faces;
-		Mat frameGray;
-
-		cvtColor(input, frameGray, CV_BGR2GRAY);
-		equalizeHist(frameGray, frameGray);
-
-		faceCascadeClassifier.detectMultiScale(frameGray, faces, 1.1, 2, 0 | 2, Size(120, 120)); // HAAR_SCALE_IMAGE is 2
-
-		for (size_t i = 0; i < faces.size(); i++) {
-			rectangle(
-				output,
-				Point(faces[i].x, faces[i].y),
-				Point(faces[i].x + faces[i].width, faces[i].y + faces[i].height),
-				Scalar(0, 0, 0),
-				-1
-			);
-		}
-	}
-
-	Rect getFaceRect(Mat input) {
-		vector<Rect> faceRectangles;
-		Mat inputGray;
-
-		cvtColor(input, inputGray, CV_BGR2GRAY);
-		equalizeHist(inputGray, inputGray);
-
-		faceCascadeClassifier.detectMultiScale(inputGray, faceRectangles, 1.1, 2, 0 | 2, Size(120, 120)); // HAAR_SCALE_IMAGE is 2
-
-		if (faceRectangles.size() > 0)
-			return faceRectangles[0];
-		else
-			return Rect(0, 0, 1, 1);
-	}
-}

src/computervision/FaceDetector.h

@@ -1,31 +0,0 @@
-#pragma once
-#include <opencv2/opencv.hpp>
-#include <opencv2/imgproc/types_c.h>
-#include <opencv2/objdetect.hpp>
-#include <opencv2/core.hpp>
-#include <opencv2/objdetect/objdetect.hpp>
-/*
- Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
-*/
-
-using namespace cv;
-using namespace std;
-
-namespace computervision
-{
-	class FaceDetector {
-	public:
-		/**
-		 * @brief Constructor for the class FaceDetector, loads training data from a file
-		 * 
-		 */
-		FaceDetector(void);
-		/**
-		 * @brief Detects faces on an image and blocks them with a black rectangle
-		 * 
-		 * @param input Input image
-		 * @param output Output image
-		 */
-		void removeFaces(Mat input, Mat output);
-	};
-}

src/computervision/FingerCount.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include "opencv2/core.hpp"
-#include <opencv2/imgproc/types_c.h>
-
-/*
- Author: Nicol<6F> Castellazzi https://github.com/nicast
-*/
-
-namespace computervision
-{
-	using namespace cv;
-	using namespace std;
-
-	class FingerCount {
-	public:
-		FingerCount(void);
-		Mat findFingersCount(Mat input_image, Mat frame);
-
-	private:
-		Scalar color_blue;
-		Scalar color_green;
-		Scalar color_red;
-		Scalar color_black;
-		Scalar color_white;
-		Scalar color_yellow;
-		Scalar color_purple;
-		double findPointsDistance(Point a, Point b);
-		vector<Point> compactOnNeighborhoodMedian(vector<Point> points, double max_neighbor_distance);
-		double findAngle(Point a, Point b, Point c);
-		bool isFinger(Point a, Point b, Point c, double limit_angle_inf, double limit_angle_sup, cv::Point palm_center, double distance_from_palm_tollerance);
-		vector<Point> findClosestOnX(vector<Point> points, Point pivot);
-		double findPointsDistanceOnX(Point a, Point b);
-		void drawVectorPoints(Mat image, vector<Point> points, Scalar color, bool with_numbers);
-	};
-}

src/computervision/MenuTest.cpp

@@ -0,0 +1,25 @@
+#include "MenuTest.h"
+#include <iostream>
+
+namespace computervision 
+{
+	int menu_item_array[4] = { 1, 2, 3, 4 };
+	float item_number = 0;
+
+	MenuTest::MenuTest(void) {
+		
+	}
+
+	int MenuTest::GetMenuItem(bool hand_state) {
+		item_number += 0.20f;
+
+		
+		int temp_item_number = item_number;
+		//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 == sizeof(menu_item_array) / sizeof(menu_item_array[0])) {
+			item_number = 0;
+		}
+
+		return menu_item_array[temp_item_number];
+	}
+}

src/computervision/MenuTest.h

@@ -0,0 +1,18 @@
+
+namespace computervision
+{
+	class MenuTest {
+	public:
+		/**
+		 * @brief Constructor for the class MenuTest, loads in array with menu items
+		 *
+		 */
+		MenuTest(void);
+		/**
+		 * @brief Returns the itemnumber in an array 
+		 * 
+		 * @param input_bool is either true or false, depending on the recognized hand gesture
+		 */
+		int GetMenuItem(bool input_bool);
+	};
+}

src/computervision/ObjectDetection.cpp

@@ -1,91 +0,0 @@
-
-#include "ObjectDetection.h"
-#include "BackgroundRemover.h"
-#include "SkinDetector.h"
-#include "FaceDetector.h"
-#include "FingerCount.h"
-
-namespace computervision
-{
-	cv::VideoCapture cap(0);
-
-	cv::Mat img, imgGray, img2, img2Gray, img3, img4;
-
-	Mat frame, frameOut, handMask, foreground, fingerCountDebug;
-	BackgroundRemover backgroundRemover;
-	SkinDetector skinDetector;
-	FaceDetector faceDetector;
-	FingerCount fingerCount;
-
-
-	ObjectDetection::ObjectDetection()
-	{
-	}
-
-	bool ObjectDetection::setup() 
-	{
-		if (!cap.isOpened()) {
-			cout << "Can't find camera!" << endl;
-			return false;
-		}
-
-		cap.read(frame);
-		frameOut = frame.clone();
-
-		skinDetector.drawSkinColorSampler(frameOut);
-
-		foreground = backgroundRemover.getForeground(frame);
-
-		faceDetector.removeFaces(frame, foreground);
-		handMask = skinDetector.getSkinMask(foreground);
-		fingerCountDebug = fingerCount.findFingersCount(handMask, frameOut);
-
-		//backgroundRemover.calibrate(frame);
-
-
-		imshow("output", frameOut);
-		imshow("foreground", foreground);
-		imshow("handMask", handMask);
-		imshow("handDetection", fingerCountDebug);
-
-		int key = waitKey(1);
-
-		if (key == 98) // b
-			backgroundRemover.calibrate(frame);
-		else if (key == 115) // s
-			skinDetector.calibrate(frame);
-
-		return true;
-	}
-
-	void ObjectDetection::calculateDifference()
-	{
-		cap.read(img);
-		cap.read(img2);
-
-		cv::cvtColor(img, imgGray, cv::COLOR_RGBA2GRAY);
-		cv::cvtColor(img2, img2Gray, cv::COLOR_RGBA2GRAY);
-
-		cv::absdiff(imgGray, img2Gray, img3);
-		cv::threshold(img3, img4, 50, 170, cv::THRESH_BINARY);
-
-		imshow("threshold", img4);
-	}
-
-	void ObjectDetection::detect()
-	{
-		int key = waitKey(1);
-			
-		if (key == 98) // b
-			backgroundRemover.calibrate(frame);
-		else if (key == 115) // s
-			skinDetector.calibrate(frame);
-	}
-
-	void ObjectDetection::showWebcam()
-	{
-		imshow("Webcam image", img);
-	}
-
-
-}

src/computervision/ObjectDetection.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include <opencv2/imgcodecs.hpp>
-#include <opencv2/highgui.hpp>
-#include <opencv2/imgproc.hpp>
-#include <opencv2/objdetect.hpp>
-#include <opencv2/videoio.hpp>
-#include <opencv2/core.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/highgui/highgui.hpp>
-
-
-namespace computervision
-{
-	class ObjectDetection
-	{
-	private:
-
-	public:
-		/**
-		 * @brief default constructor of ObjectDetection
-		 * 
-		 */
-		ObjectDetection();
-		/**
-		 * @brief Initializes the object detection, captures a frame and modifies it
-		 *  so it is ready to use for object detection
-		 * 
-		 * @return return true if webcam is connected, returns false if it isn't
-		 */
-		bool setup();
-		/**
-		 * @brief Displays an image of the current webcam-footage
-		 * 
-		 */
-		void showWebcam();
-		/**
-		 * @brief Calculates the difference between two images
-		 *  and outputs an image that only shows the difference
-		 * 
-		 */
-		void calculateDifference();
-		/**
-		 * @brief Listens for keypresses and handles them
-		 * 
-		 */
-		void detect();
-
-	};
-
-
-}
-

src/computervision/SkinDetector.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#include<opencv2\core.hpp>
-#include <opencv2/imgcodecs.hpp>
-#include <opencv2/imgproc.hpp>
-#include <opencv2/imgproc/types_c.h>
-/*
- Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
-*/
-
-namespace computervision
-{
-	using namespace cv;
-	using namespace std;
-
-	class SkinDetector {
-	public:
-		SkinDetector(void);
-
-		void drawSkinColorSampler(Mat input);
-		void calibrate(Mat input);
-		Mat getSkinMask(Mat input);
-
-	private:
-		int hLowThreshold = 0;
-		int hHighThreshold = 0;
-		int sLowThreshold = 0;
-		int sHighThreshold = 0;
-		int vLowThreshold = 0;
-		int vHighThreshold = 0;
-
-		bool calibrated = false;
-
-		Rect skinColorSamplerRectangle1, skinColorSamplerRectangle2;
-
-		void calculateThresholds(Mat sample1, Mat sample2);
-		void performOpening(Mat binaryImage, int structuralElementShapde, Point structuralElementSize);
-	};
-}

src/computervision/async/StaticCameraInstance.h

@@ -0,0 +1,12 @@
+#pragma once
+#include <opencv2/videoio.hpp>
+
+namespace static_camera
+{
+
+	static cv::VideoCapture getCap()
+	{
+		static cv::VideoCapture cap(0);
+		return cap;
+	}
+};

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/background_remover.h

@@ -0,0 +1,58 @@
+#pragma once
+#include"opencv2\opencv.hpp"
+#include <opencv2/imgproc\types_c.h>
+/*
+ Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
+*/
+namespace computervision
+{
+using namespace cv;
+using namespace std;
+
+	class BackgroundRemover {
+	public:
+
+		/**
+		 * @brief constructor, 
+		 * create background variable and set calibrated to faslse
+		 * 
+		 */
+		BackgroundRemover(void);
+
+		/**
+		 * @brief sets the input image to a grayscale image
+		 * sets calibrated to true
+		 * 
+		 * @param input input the image that has to be calibrated
+		 */
+		void calibrate(Mat input);
+
+		/**
+		 * @brief Gets the mask of the foregorund of the input image
+		 * and copies it to another image
+		 * 
+		 * @param input The image from which the forground needs to be picked
+		 * @return The image on which te foregroundmask is copied
+		 */
+		Mat getForeground(Mat input);
+
+	private:
+		Mat background;
+		bool calibrated = false;
+
+		/**
+		 * @brief Sets the image to grayscale and removes the background
+		 * 
+		 * @param input The image from which the forground needs to be picked
+		 * @return The mask of the foreground of the image 
+		 */
+		Mat getForegroundMask(Mat input);
+		/**
+		 * @brief makes everything on the background black
+		 * 
+		 * @param input the image from which the background needs to be removed
+		 * @param background the background of the image
+		 */
+		void removeBackground(Mat input, Mat background);
+	};
+}

src/computervision/calibration/HandCalibrator.cpp

@@ -0,0 +1,91 @@
+
+#include "HandCalibrator.h"
+#include <iostream>
+
+#define MIN_MENU_HAND_SIZE 10000
+#define MIN_GAME_HAND_SIZE 3000 // todo change
+namespace computervision
+{
+	namespace handcalibration
+	{
+
+		HandCalibrator::HandCalibrator()
+		{
+
+		}
+
+		void HandCalibrator::DrawHandCalibrationText(cv::Mat& output_frame)
+		{
+			cv::rectangle(output_frame, cv::Rect(0, 0, output_frame.cols, 40), cv::Scalar(0, 0, 0), -1);
+			cv::putText(output_frame, "Hand calibration", cv::Point(output_frame.cols / 2 - 100, 25), cv::FONT_HERSHEY_PLAIN, 2.0, cv::Scalar(18, 219, 65), 2);
+
+			cv::rectangle(output_frame, cv::Rect(0, output_frame.rows - 80, 450, output_frame.cols), cv::Scalar(0, 0, 0), -1);
+
+			cv::putText(output_frame, "hand in frame:", cv::Point(5, output_frame.rows - 50), cv::FONT_HERSHEY_PLAIN, 2.0, cv::Scalar(255, 255, 0), 1);
+			cv::rectangle(output_frame, cv::Rect(420, output_frame.rows - 67, 15, 15), hand_present ? cv::Scalar(0, 255, 0) : cv::Scalar(0, 0, 255), -1);
+
+			DrawBackgroundSkinCalibrated(output_frame);
+
+			if (hand_present)
+			{
+				std::string hand_text = fingers_amount > 0 ? "open" : "closed";
+				cv::putText(output_frame, hand_text, cv::Point(10, 75), cv::FONT_HERSHEY_PLAIN, 2.0, cv::Scalar(255, 0, 255), 3);
+			}
+		}
+
+		void HandCalibrator::DrawBackgroundSkinCalibrated(cv::Mat& output_frame)
+		{
+
+			cv::putText(output_frame, "background calibrated:", cv::Point(5, output_frame.rows - 30), cv::FONT_HERSHEY_PLAIN, 2.0, cv::Scalar(255, 255, 0), 1);
+			cv::rectangle(output_frame, cv::Rect(420, output_frame.rows - 47, 15, 15), background_calibrated ? cv::Scalar(0, 255, 0) : cv::Scalar(0, 0, 255), -1);
+
+			cv::putText(output_frame, "skin color calibrated:", cv::Point(5, output_frame.rows - 10), cv::FONT_HERSHEY_PLAIN, 2.0, cv::Scalar(255, 255, 0), 1);
+			cv::rectangle(output_frame, cv::Rect(420, output_frame.rows - 27, 15, 15), skintone_calibrated ? cv::Scalar(0, 255, 0) : cv::Scalar(0, 0, 255), -1);
+		}
+
+		void HandCalibrator::SetSkinCalibration(bool val)
+		{
+			skintone_calibrated = val;
+		}
+
+		void HandCalibrator::SetBackGroundCalibrated(bool val)
+		{
+			background_calibrated = val;
+		}
+
+		void HandCalibrator::SetHandPresent(bool val)
+		{
+			hand_present = val;
+		}
+
+		void HandCalibrator::SetAmountOfFingers(int amount)
+		{
+			fingers_amount = amount;
+		}
+
+		bool HandCalibrator::CheckIfHandPresent(cv::Mat input_image, HandDetectionType type)
+		{
+			std::vector<std::vector<cv::Point>> points;
+			cv::findContours(input_image, points, cv::RetrievalModes::RETR_LIST, cv::ContourApproximationModes::CHAIN_APPROX_SIMPLE);
+
+			if (points.size() == 0) return false;
+
+			for (int p = 0; p < points.size(); p++)
+			{
+				int area = cv::contourArea(points[p]);
+
+				if (type == handcalibration::HandDetectionType::MENU)
+					if (area > MIN_MENU_HAND_SIZE) return true;
+
+				if (type == handcalibration::HandDetectionType::GAME)
+					if (area > MIN_GAME_HAND_SIZE) return true;
+			}
+
+			return false;
+		}
+
+
+
+
+	}
+}

src/computervision/calibration/HandCalibrator.h

@@ -0,0 +1,76 @@
+#pragma once
+#include <opencv2/core/base.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+
+namespace computervision
+{
+	namespace handcalibration
+	{
+		enum class HandDetectionType
+		{
+			MENU,
+			GAME
+		};
+
+		class HandCalibrator
+		{
+		public:
+			HandCalibrator();
+
+			
+
+			/**
+			 * @brief draws the text to show the status of the calibration on the image
+			 *
+			 * @param output_frame the frame to draw on.
+			 */
+			void DrawHandCalibrationText(cv::Mat& output_frame);
+
+			/**
+			 * @brief sets the skin calibration variable.
+			 *
+			 * @param val the value to set
+			 */
+			void SetSkinCalibration(bool val);
+
+			/**
+			 * @brief sets the background calibration variable.
+			 *
+			 * @param val the value to set
+			 */
+			void SetBackGroundCalibrated(bool val);
+
+			/**
+			 * @brief sets the value for if the hand is present.
+			 * 
+			 * @param val the value to set.
+			 */
+			void SetHandPresent(bool val);
+
+			/**
+			 * @brief checks if the hand is present in the given image
+			 * 
+			 * @param input_image the input image to check.
+			 */
+			bool CheckIfHandPresent(cv::Mat input_image, HandDetectionType type);
+
+			/**
+			 * @brief sets the amount of fingers that are currently detected.
+			 * 
+			 * @param amount the amount of fingers.
+			 */
+			void SetAmountOfFingers(int amount);
+
+			void DrawBackgroundSkinCalibrated(cv::Mat& output_frame);
+
+		private:
+
+			bool background_calibrated;
+			bool skintone_calibrated;
+			bool hand_present;
+			int fingers_amount;
+		};
+
+	}
+}

src/computervision/finger_count.cpp

@@ -1,4 +1,4 @@
-#include "FingerCount.h"
+#include "finger_count.h"
 
 #include "opencv2/imgproc.hpp"
 #include "opencv2/highgui.hpp"
@@ -14,6 +14,7 @@
 
 namespace computervision
 {
+
 	FingerCount::FingerCount(void) {
 		color_blue = Scalar(255, 0, 0);
 		color_green = Scalar(0, 255, 0);
@@ -35,9 +36,6 @@ namespace computervision
 		if (input_image.channels() != 1)
 			return contours_image;
 
-		vector<vector<Point>> contours;
-		vector<Vec4i> hierarchy;
-
 		findContours(input_image, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
 
 		// we need at least one contour to work
@@ -45,7 +43,7 @@ namespace computervision
 			return contours_image;
 
 		// find the biggest contour (let's suppose it's our hand)
-		int biggest_contour_index = -1;
+		biggest_contour_index = -1;
 		double biggest_area = 0.0;
 
 		for (int i = 0; i < contours.size(); i++) {
@@ -151,9 +149,21 @@ namespace computervision
 		drawVectorPoints(frame, filtered_finger_points, color_yellow, false);
 		putText(frame, to_string(filtered_finger_points.size()), center_bounding_rect, FONT_HERSHEY_PLAIN, 3, color_purple);
 
+		amount_of_fingers = filtered_finger_points.size();
+
 		return contours_image;
 	}
 
+	void FingerCount::DrawHandContours(Mat& image)
+	{
+		drawContours(image, contours, biggest_contour_index, color_green, 2, 8, hierarchy);
+	}
+
+	int FingerCount::getAmountOfFingers()
+	{
+		return amount_of_fingers;
+	}
+
 	double FingerCount::findPointsDistance(Point a, Point b) {
 		Point difference = a - b;
 		return sqrt(difference.ddot(difference));

src/computervision/finger_count.h

@@ -0,0 +1,129 @@
+#pragma once
+
+#include "opencv2/core.hpp"
+#include <opencv2/imgproc/types_c.h>
+
+/*
+ Author: Nicol<6F> Castellazzi https://github.com/nicast
+*/
+
+namespace computervision
+{
+	using namespace cv;
+	using namespace std;
+
+	class FingerCount {
+	public:
+		FingerCount(void);
+		/**
+		 * @brief gets the amount of fingers that are held up.
+		 * 
+		 * @param input_image the source image to find the fingers on. It should be a mask of a hand
+		 * @param frame the frame to draw the resulting values on (how many fingers are held up etc)
+		 * @return a new image with all the data drawn on it.
+		 */
+		Mat findFingersCount(Mat input_image, Mat frame);
+
+		/**
+		 * @brief gets the currently held-up finger count.
+		 * 
+		 * @return the currently held-up finger count
+		 */
+		int getAmountOfFingers();
+
+		void DrawHandContours(Mat& image);
+
+	private:
+
+		int biggest_contour_index;
+		vector<vector<Point>> contours;
+		vector<Vec4i> hierarchy;
+
+
+		// colors to use
+		Scalar color_blue;
+		Scalar color_green;
+		Scalar color_red;
+		Scalar color_black;
+		Scalar color_white;
+		Scalar color_yellow;
+		Scalar color_purple;
+
+		int amount_of_fingers;
+
+		/**
+		 * @brief finds the distance between 2 points.
+		 * 
+		 * @param a the first point
+		 * @param b the second point
+		 * @return a double representing the distance
+		 */
+		double findPointsDistance(Point a, Point b);
+
+		/**
+		 * @brief compacts the given points on their medians. 
+		 * what it does is for each point, it checks if the distance to it's neighbour is greater than the 
+		 * max distance. If so, it just adds it to the list that is returned. If not, it calculates the 
+		 * median and adds it to the returned list
+		 * 
+		 * @param points the points to compact
+		 * @param max_neighbor_distance the maximum distance between points
+		 * @return a vector with the points now compacted.
+		 */
+		vector<Point> compactOnNeighborhoodMedian(vector<Point> points, double max_neighbor_distance);
+		
+		/**
+		 * @brief finds the angle between 3 different points.
+		 * 
+		 * @param a the first point
+		 * @param b the second point
+		 * @param c the third point
+		 * @return the angle between the 3 points
+		 */
+		double findAngle(Point a, Point b, Point c);
+
+		/**
+		 * @brief checks if the given points make up a finger.
+		 * 
+		 * @param a the first point to check for
+		 * @param b the second point to check for
+		 * @param c the third point to check for
+		 * @param limit_angle_inf the limit of the angle between 2 fingers
+		 * @param limit_angle_sup the limit of the angle between a finger and a convex point
+		 * @param palm_center the center of the palm
+		 * @param distance_from_palm_tollerance the distance from the palm tolerance
+		 * @return true if the points are a finger, false if not.
+		 */
+		bool isFinger(Point a, Point b, Point c, double limit_angle_inf, double limit_angle_sup, cv::Point palm_center, double distance_from_palm_tollerance);
+		
+		/**
+		 * @brief finds the closest point to the given point that is in the given list.
+		 * 
+		 * @param points the points to check for
+		 * @param pivot the pivot to check against
+		 * @return a vector containing the point that is closest
+		 */
+		vector<Point> findClosestOnX(vector<Point> points, Point pivot);
+
+		/**
+		 * @brief finds the distance between the x coords of the points.
+		 * 
+		 * @param a the first point
+		 * @param b the second point
+		 * @return the distance between the x values
+		 */
+		double findPointsDistanceOnX(Point a, Point b);
+
+		/**
+		 * @brief draws the points on the image.
+		 * 
+		 * @param image the image to draw on
+		 * @param points the points to draw
+		 * @param color the color to draw them with
+		 * @param with_numbers if the numbers should be drawn with the points
+		 */
+		void drawVectorPoints(Mat image, vector<Point> points, Scalar color, bool with_numbers);
+
+
+	};
+}

src/computervision/hand_detect_region.cpp

@@ -0,0 +1,157 @@
+
+#include "hand_detect_region.h"
+#define TIME_DURATION 1.0f
+namespace computervision
+{
+
+	HandDetectRegion::HandDetectRegion(std::string id,int x_pos, int y_pos, int width, int height)
+	{
+		region_id = id;
+		start_x_pos = x_pos;
+		start_y_pos = y_pos;
+		region_width = width;
+		region_height = height;
+		hand_mask_generated = false;
+		hand_present = false;
+	}
+
+	void HandDetectRegion::DetectHand(cv::Mat& camera_frame)
+	{
+		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
+		handMask = skin_detector.getSkinMask(foreground);
+
+		// 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);
+
+		hand_present = hand_calibrator.CheckIfHandPresent(handMask,handcalibration::HandDetectionType::GAME);
+		//std::string text = (hand_present ? "hand" : "no");
+		//cv::putText(camera_frame, text, cv::Point(start_x_pos, start_y_pos), cv::FONT_HERSHEY_COMPLEX, 2.0, cv::Scalar(0, 255, 255), 2);
+		hand_calibrator.SetHandPresent(hand_present);
+
+		//draw black rectangle behind calibration information text
+		cv::rectangle(camera_frame, cv::Rect(0, camera_frame.rows - 55, 450, camera_frame.cols), cv::Scalar(0, 0, 0), -1);
+
+		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);
+		}
+
+	}
+
+	cv::Mat HandDetectRegion::GenerateHandMaskSquare(cv::Mat img)
+	{
+		cv::Mat mask = cv::Mat::zeros(img.size(), img.type());
+		cv::Mat distance_img = cv::Mat::zeros(img.size(), img.type());
+
+		cv::rectangle(mask, cv::Rect(start_x_pos, start_y_pos, region_width, region_height), cv::Scalar(255, 255, 255), -1);
+
+		img.copyTo(distance_img, mask);
+
+		hand_mask_generated = true;
+		return distance_img;
+	}
+
+	bool HandDetectRegion::DrawHandMask(cv::Mat* input)
+	{
+		if (!hand_mask_generated) return false;
+		rectangle(*input, Rect(start_x_pos, start_y_pos, region_width, region_height), (hand_present ? Scalar(0, 255, 0) : Scalar(0,0,255)),2);
+		return true;
+	}
+
+	bool HandDetectRegion::IsHandPresent()
+	{
+		return hand_present;
+	}
+
+	void HandDetectRegion::CalibrateBackground()
+	{
+		std::cout << "calibrating background " << region_id << std::endl;
+		background_remover.calibrate(frame_out);
+		hand_calibrator.SetBackGroundCalibrated(true);
+	}
+	void HandDetectRegion::CalibrateSkin()
+	{
+		skin_detector.calibrate(frame_out);
+		hand_calibrator.SetSkinCalibration(true);
+	}
+
+	std::vector<int> HandDetectRegion::CalculateSkinTresholds()
+	{
+		std::cout << "calibrating skin " << region_id << std::endl;
+		hand_calibrator.SetSkinCalibration(true);
+		skin_calibrated = true;
+		time = 0;
+		return skin_detector.calibrateAndReturn(frame_out);
+	}
+
+	void HandDetectRegion::setSkinTresholds(std::vector<int>& tresholds)
+	{
+		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

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <GLFW/glfw3.h>
+
+#include "async/StaticCameraInstance.h"
+#include "calibration/HandCalibrator.h"
+#include "background_remover.h"
+#include "skin_detector.h"
+#include "finger_count.h"
+namespace computervision
+{
+	class HandDetectRegion
+	{
+	public:
+		HandDetectRegion(std::string id,int x_pos, int y_pos, int width, int height);
+
+		void SetXPos(int x) { start_x_pos = x; }
+		void SetYPos(int y) { start_y_pos = y; }
+		int GetXPos() { return start_x_pos; }
+		int GetYPos() { return start_y_pos; }
+
+		void SetWidth(int width) { region_width = width; }
+		void SetHeigth(int height) { region_height = height; }
+		int GetWidth() { return region_width; }
+		int GetHeight() { return region_height; }
+
+		cv::Mat GenerateHandMaskSquare(cv::Mat img);
+
+		void DetectHand(cv::Mat& camera_frame);
+
+		bool IsHandPresent();
+
+		void CalibrateBackground();
+		void CalibrateSkin();
+
+		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;
+		int region_width;
+		bool hand_mask_generated;
+		bool hand_present;
+		cv::Mat frame, frame_out, handMask, foreground, fingerCountDebug;
+		BackgroundRemover background_remover;
+		SkinDetector skin_detector;
+		handcalibration::HandCalibrator hand_calibrator;
+		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

@@ -0,0 +1,203 @@
+
+#include "object_detection.h"
+
+#define TIME_DURATION 1.0f
+
+namespace computervision
+{
+
+	cv::Mat img, img_gray, img2, img2_gray, img3, img4;
+
+	int hand_mask_start_x_pos, hand_mask_start_y_pos, hand_mask_width, hand_mask_height;
+	bool hand_mask_generated = false;
+
+	Mat frame, frame_out, handMask, foreground, fingerCountDebug;
+	BackgroundRemover background_remover;
+	SkinDetector skin_detector;
+	FingerCount finger_count;
+	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;
+	bool hand_open = false;
+
+	ObjectDetection::ObjectDetection()
+	{
+	}
+
+	cv::Mat ObjectDetection::ReadCamera() {
+		cap.read(img);
+		return img;
+	}
+
+	cv::VideoCapture ObjectDetection::GetCap()
+	{
+		return cap;
+	}
+
+	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();
+
+		// detect skin color
+		skin_detector.drawSkinColorSampler(camera_frame);
+
+		// remove background from image
+		foreground = background_remover.getForeground(input_frame);
+
+		// detect the hand contours
+		handMask = skin_detector.getSkinMask(foreground);
+
+		// count the amount of fingers and put the info on the matrix
+		fingerCountDebug = finger_count.findFingersCount(handMask, frame_out);
+
+		// get the amount of fingers
+		int fingers_amount = finger_count.getAmountOfFingers();
+
+		// 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;
+					calibration_callback();
+				}
+			}
+
+		}
+
+		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_calibrator.SetHandPresent(hand_present);
+
+		hand_open = fingers_amount > 0;
+		return hand_open;
+	}
+
+	void ObjectDetection::CalculateDifference()
+	{
+		cap.read(img);
+		cap.read(img2);
+
+		cv::cvtColor(img, img_gray, cv::COLOR_RGBA2GRAY);
+		cv::cvtColor(img2, img2_gray, cv::COLOR_RGBA2GRAY);
+
+		cv::absdiff(img_gray, img2_gray, img3);
+		cv::threshold(img3, img4, 50, 170, cv::THRESH_BINARY);
+
+		imshow("threshold", img4);
+	}
+
+
+	cv::Mat ObjectDetection::GenerateHandMaskSquare(cv::Mat img)
+	{
+		hand_mask_start_x_pos = 20;
+		hand_mask_start_y_pos = img.rows / 5;
+		hand_mask_width = img.cols / 3;
+		hand_mask_height = img.cols / 3;
+
+
+		cv::Mat mask = cv::Mat::zeros(img.size(), img.type());
+		cv::Mat distance_img = cv::Mat::zeros(img.size(), img.type());
+
+		cv::rectangle(mask, Rect(hand_mask_start_x_pos, hand_mask_start_y_pos, hand_mask_width, hand_mask_height), Scalar(255, 255, 255), -1);
+
+		img.copyTo(distance_img, mask);
+
+		hand_mask_generated = true;
+		return distance_img;
+
+	}
+
+	bool ObjectDetection::DrawHandMask(cv::Mat* input)
+	{
+		if (!hand_mask_generated) return false;
+		rectangle(*input, Rect(hand_mask_start_x_pos, hand_mask_start_y_pos, hand_mask_width, hand_mask_height), Scalar(255, 255, 255));
+		return true;
+	}
+
+	void ObjectDetection::ShowWebcam()
+	{
+		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;
+	}
+
+	bool ObjectDetection::IsHandOpen()
+	{
+		return hand_open;
+	}
+
+	bool ObjectDetection::IsCalibrated()
+	{
+		return background_calibrated && skin_calibrated;
+	}
+
+
+}

src/computervision/object_detection.h

@@ -0,0 +1,109 @@
+#pragma once
+
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/objdetect.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/video.hpp>
+#include <GLFW/glfw3.h>
+
+#include <functional>
+#include "background_remover.h"
+#include "skin_detector.h"
+#include "finger_count.h"
+#include "async/StaticCameraInstance.h"
+#include "calibration/HandCalibrator.h"
+
+
+namespace computervision
+{
+	class ObjectDetection
+	{
+	private:
+
+	public:
+		/**
+		 * @brief default constructor of ObjectDetection
+		 * 
+		 */
+		ObjectDetection();
+
+		/**
+		 * @brief Displays an image of the current webcam-footage
+		 * 
+		 */
+		void ShowWebcam();
+		/**
+		 * @brief Calculates the difference between two images
+		 *  and outputs an image that only shows the difference
+		 * 
+		 */
+		void CalculateDifference();
+
+		/**
+		 * @brief generates the square that will hold the mask in which the hand will be detected.
+		 * 
+		 * @param img the current camear frame
+		 * @return a matrix containing the mask
+		 */
+		cv::Mat GenerateHandMaskSquare(cv::Mat img);
+
+		/**
+		 * @brief reads the camera and returns it in a matrix.
+		 * 
+		 * @return the camera frame in a matrix
+		 */
+		cv::Mat ReadCamera();
+
+		/**
+		 * @brief detects a hand based on the given hand mask input frame.
+		 * 
+		 * @param inputFrame the input frame from the camera
+		 * @param hand_present boolean that will hold true if the hand is detected, false if not.
+		 * @return true if hand is open, false if hand is closed
+		 */
+		bool DetectHand(cv::Mat camera_frame, bool& hand_present);
+
+		/**
+		 * @brief draws the hand mask rectangle on the given input matrix.
+		 * 
+		 * @param input the input matrix to draw the rectangle on
+		 */
+		bool DrawHandMask(cv::Mat *input);
+
+		/**
+		 * @brief checks if the hand of the user is open.
+		 * 
+		 * @return true if the hand is open, false if not.
+		 */
+		bool IsHandOpen();
+
+		bool IsCalibrated();
+
+
+		/**
+		 * @brief checks whether the hand is held within the detection square.
+		 * 
+		 * @return true if the hand is in the detection square, false if not.
+		 */
+		bool IsHandPresent();
+
+		cv::VideoCapture GetCap();
+
+		void SetCalibrationCallback(std::function<void()> fun) { calibration_callback = fun; };
+
+	private:
+		bool is_hand_open;
+		bool is_hand_present;
+		void UpdateTime();
+		std::function<void()> calibration_callback;
+
+	};
+
+
+}
+

src/computervision/skin_detector.cpp

@@ -1,4 +1,5 @@
-#include "SkinDetector.h"
+#include "skin_detector.h"
+#include <iostream>
 
 /*
  Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
@@ -22,8 +23,8 @@ namespace computervision
 	void SkinDetector::drawSkinColorSampler(Mat input) {
 		int frameWidth = input.size().width, frameHeight = input.size().height;
 
-		int rectangleSize = 20;
+		int rectangleSize = 25;
-		Scalar rectangleColor = Scalar(255, 0, 255);
+		Scalar rectangleColor = Scalar(0, 255, 255);
 
 		skinColorSamplerRectangle1 = Rect(frameWidth / 5, frameHeight / 2, rectangleSize, rectangleSize);
 		skinColorSamplerRectangle2 = Rect(frameWidth / 5, frameHeight / 3, rectangleSize, rectangleSize);
@@ -41,6 +42,29 @@ namespace computervision
 		);
 	}
 
+	void SkinDetector::drawSkinColorSampler(Mat input,int x, int y,int width, int height) {
+		int frameWidth = width, frameHeight = height;
+
+		int rectangleSize = 25;
+		Scalar rectangleColor = Scalar(0, 255, 255);
+
+		skinColorSamplerRectangle1 = Rect(frameWidth / 5 + x, frameHeight / 2 + y, rectangleSize, rectangleSize);
+		skinColorSamplerRectangle2 = Rect(frameWidth / 5 + x, frameHeight / 3 + y, rectangleSize, rectangleSize);
+
+		rectangle(
+			input,
+			skinColorSamplerRectangle1,
+			rectangleColor
+		);
+
+		rectangle(
+			input,
+			skinColorSamplerRectangle2,
+			rectangleColor
+		);
+	}
+
+
 	void SkinDetector::calibrate(Mat input) {
 
 		Mat hsvInput;
@@ -54,6 +78,19 @@ namespace computervision
 		calibrated = true;
 	}
 
+	std::vector<int> SkinDetector::calibrateAndReturn(Mat input)
+	{
+		Mat hsvInput;
+		cvtColor(input, hsvInput, CV_BGR2HSV);
+
+		Mat sample1 = Mat(hsvInput, skinColorSamplerRectangle1);
+		Mat sample2 = Mat(hsvInput, skinColorSamplerRectangle2);
+
+		calibrated = true;
+		return calculateAndReturnTresholds(sample1, sample2);
+
+	}
+
 	void SkinDetector::calculateThresholds(Mat sample1, Mat sample2) {
 		int offsetLowThreshold = 80;
 		int offsetHighThreshold = 30;
@@ -75,6 +112,39 @@ namespace computervision
 		//vHighThreshold = 255;
 	}
 
+	std::vector<int> SkinDetector::calculateAndReturnTresholds(Mat sample1, Mat sample2)
+	{
+		
+		calculateThresholds(sample1, sample2);
+		std::vector<int> res;
+		res.push_back(hLowThreshold);
+		res.push_back(hHighThreshold);
+		res.push_back(sLowThreshold);
+		res.push_back(sHighThreshold);
+		res.push_back(vLowThreshold);
+		res.push_back(vHighThreshold);
+		return res;
+	}
+
+	void SkinDetector::setTresholds(std::vector<int>& tresholds)
+	{
+		if (tresholds.size() != 6)
+		{
+			std::cout << "tresholds array not the right size!" << std::endl;
+			return;
+		}
+
+		hLowThreshold = tresholds[0];
+		hHighThreshold = tresholds[1];
+		sLowThreshold = tresholds[2];
+		sHighThreshold = tresholds[3];
+		vLowThreshold = tresholds[4];
+		vHighThreshold = tresholds[5];
+
+		calibrated = true;
+		
+	}
+
 	Mat SkinDetector::getSkinMask(Mat input) {
 		Mat skinMask;
 

src/computervision/skin_detector.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <opencv2\core.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/imgproc/types_c.h>
+/*
+ Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
+*/
+
+namespace computervision
+{
+	using namespace cv;
+	using namespace std;
+
+	class SkinDetector {
+	public:
+		SkinDetector(void);
+
+		/*
+		* @brief draws the positions in where the skin color will be sampled.
+		* 
+		* @param input the input matrix to sample the skin color from
+		*/
+		void drawSkinColorSampler(Mat input);
+
+		void drawSkinColorSampler(Mat input, int x, int y, int width, int heigth);
+
+
+		/*
+		* @brief calibrates the skin color detector with the given input frame
+		* 
+		* @param input the input frame to calibrate from
+		*/
+		void calibrate(Mat input);
+
+		std::vector<int> calibrateAndReturn(Mat input);
+
+		void setTresholds(std::vector<int>& tresholds);
+
+		/*
+		* @brief gets the mask for the hand
+		* 
+		* @param input the input matrix to get the skin mask from
+		* @returns the skin mask in a new matrix
+		*/
+		Mat getSkinMask(Mat input);
+
+	private:
+
+		// thresholds for hsv calculation
+		int hLowThreshold = 0;
+		int hHighThreshold = 0;
+		int sLowThreshold = 0;
+		int sHighThreshold = 0;
+		int vLowThreshold = 0;
+		int vHighThreshold = 0;
+
+		// wether or not the skindetector has calibrated yet.
+		bool calibrated = false;
+
+		// rectangles that get drawn to show where the skin color will be sampled
+		Rect skinColorSamplerRectangle1, skinColorSamplerRectangle2;
+
+		/*
+		* @brief calculates the skin tresholds for the given samples
+		* 
+		* @param sample1 the first sample
+		* @param sample2 the second sample
+		*/
+		void calculateThresholds(Mat sample1, Mat sample2);
+
+		std::vector<int> calculateAndReturnTresholds(Mat sample1, Mat sample2);
+
+		/**
+		 * @brief the opening. it generates the structuring element and performs the morphological transformations required to detect the hand.
+		 * This needs to be done to get the skin mask.
+		 * 
+		 * @param binaryImage the matrix to perform the opening on. This needs to be a binary image, so consisting of only 1's and 0's.
+		 * @param structuralElementShape the shape to use for the kernel that is used with generating the structuring element
+		 * @param structuralElementSize the size of the kernel that will be used with generating the structuring element.
+		 */
+		void performOpening(Mat binaryImage, int structuralElementShape, Point structuralElementSize);
+	};
+}

src/entities/Camera.cpp

@@ -1,4 +1,6 @@
 #include "camera.h"
+#include <iostream>
+#include "../toolbox/toolbox.h"
 
 namespace entities
 {
@@ -7,26 +9,52 @@ namespace entities
 		rotation(rotation)
 	{}
 
+	void Camera::Follow(glm::vec3 follow_position) {
+		//set position to follow in front of the camera
+		follow_position.z += 100;
+		//set position to follow a bit lower
+		follow_position.y += 50;
+		//move position from original position to given position with smoothing
+		position = toolbox::Lerp(position, follow_position, 0.1);
+	}
+	
 	void Camera::Move(GLFWwindow* window)
 	{
+		float movement_speed = 0;
+		float up_down_speed = 0;
+		float side_speed = 0;
+		
 		if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
 		{
-			position.z -= SPEED;
+			movement_speed -= SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
 		{
-			position.z += SPEED;
+			movement_speed += SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
 		{
-			position.x += SPEED;
+			side_speed += SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
 		{
-			position.x -= SPEED;
+			side_speed -= SPEED;
-		}
+		}
+
+		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+		{
+			up_down_speed += UP_SPEED;
+		}
+		if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
+		{
+			up_down_speed -= UP_SPEED;
+		}
+
+		position.x += side_speed;
+		position.z += movement_speed;
+		position.y += up_down_speed;
 	}
 }

src/entities/Camera.h

@@ -1,23 +1,42 @@
 #pragma once
-
+#include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
 
 namespace entities
 {
+	/*
+	 * This class represents the viewport of the game. The whole game is seen through this class
+	 */
+	
 	class Camera
 	{
 	private:
-		const float SPEED = 0.02f;
+		// The movement speed of the camera
+		const float SPEED = 0.5f;
+		const float UP_SPEED = 1.0f;
 		
 		glm::vec3 position;
 		glm::vec3 rotation;
 
 	public:
+		
 		Camera(const ::glm::vec3& position, const ::glm::vec3& rotation);
 
+		/*
+		 * @brief: This funtion moves the camera's position from the inputs of the keyboard
+		 *
+		 * @param window: The OpenGL window
+		 */
 		void Move(GLFWwindow* window);
 
+		/*
+		 * @brief follows the given position with smoothing
+		 *
+		 * @param follow_position the position of the object the camera has to follow
+		 */
+		void Follow(glm::vec3 follow_position);
+		
 		inline glm::vec3 GetPosition() const{ return position; }
 		inline glm::vec3 GetRotation() const{ return rotation; }
 	};

src/entities/Entity.cpp

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

src/entities/Entity.h

@@ -5,10 +5,15 @@
 
 namespace entities
 {
+	/*
+	 * This class represents a movable model in the game
+	 */
+	
 	class Entity
 	{
-	private:
+	protected:
 		models::TexturedModel model;
+		
 		glm::vec3 position;
 		glm::vec3 rotation;
 		float scale;
@@ -16,7 +21,18 @@ namespace entities
 	public:
 		Entity(const models::TexturedModel& model, const glm::vec3& position, const glm::vec3& rotation, float scale);
 
+		/*
+		 * @brief: This function increases the position of the entity
+		 *
+		 * @param distance: The amount of distance in each axis the entity needs to move
+		 */
 		void IncreasePosition(const glm::vec3& distance);
+
+		/*
+		 * @brief: This function increases the rotation of the entity
+		 *
+		 * @param rotation: The angle of each axis the entity needs to rotate
+		 */
 		void IncreaseRotation(const glm::vec3& rotation);
 		
 		inline models::TexturedModel GetModel() const{return model;}
@@ -24,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

@@ -0,0 +1,49 @@
+#include "collision_entity.h"
+
+namespace entities
+{
+	CollisionEntity::CollisionEntity(const models::TexturedModel& model, const glm::vec3& position,
+		const glm::vec3& rotation, float scale, const collision::Box& bounding_box)
+		: Entity(model, position, rotation, scale),
+		bounding_box(bounding_box)
+	{
+		MoveCollisionBox();
+	}
+
+	void CollisionEntity::OnCollide(const collision::Collision& collision)
+	{
+		if (on_collide != nullptr)
+		{
+			
+				on_collide(collision);
+			
+		}
+	}
+
+	bool CollisionEntity::IsColliding(const glm::vec3& point) const
+	{
+		return (point.x >= min_xyz.x && point.x <= max_xyz.x) &&
+			(point.y >= min_xyz.y && point.y <= max_xyz.y) &&
+			(point.z >= min_xyz.z && point.z <= max_xyz.z);
+	}
+
+	bool CollisionEntity::IsColliding(const CollisionEntity& e) const
+	{
+		return (min_xyz.x <= e.max_xyz.x && max_xyz.x >= e.min_xyz.x) &&
+			(min_xyz.y <= e.max_xyz.y && max_xyz.y >= e.min_xyz.y) &&
+			(min_xyz.z <= e.max_xyz.z && max_xyz.z >= e.min_xyz.z);
+	}
+
+	void CollisionEntity::MoveCollisionBox()
+	{
+		bounding_box.center_pos = position;
+		
+		const glm::vec3 size = bounding_box.size;
+
+		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 = { 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

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "entity.h"
+#include "../collision/collision.h"
+#include <memory>
+#include <functional>
+
+namespace entities
+{
+	/*
+	 * This class is an entity with a collision box
+	 */
+	class CollisionEntity : public Entity
+	{
+	public:
+		collision::Box bounding_box;
+
+		glm::vec3 min_xyz;
+		glm::vec3 max_xyz;
+
+		//void (*on_collide)(const collision::Collision& collision);
+		std::function<void(const collision::Collision&)> on_collide;
+
+	public:
+		CollisionEntity(const models::TexturedModel& model, const glm::vec3& position, const glm::vec3& rotation,
+			float scale, const collision::Box& bounding_box);
+
+		/*
+		 * @brief: A function to do some sort of behaviour when the entity collides
+		 *
+		 * @param collision: The collision
+		 */
+		virtual void OnCollide(const collision::Collision& collision);
+
+		/*
+		 * @brief: A function to check if the entity is colliding with a point in 3D space
+		 *
+		 * @param point: The point to check if its colliding with the entity
+		 *
+		 * @return: True is the entity is colliding, false if not
+		 */
+		bool IsColliding(const glm::vec3& point) const;
+
+		/*
+		 * @brief: A function to check if the entity is colliding with another entity
+		 *
+		 * @param e: The other entity to check if its colliding with this
+		 *
+		 * @return: True is the entity is colliding, false if not
+		 */
+		bool IsColliding(const CollisionEntity& e) const;
+
+		/*
+		 * @brief: A function to set the collision behaviour of the entity
+		 *
+		 * @param function: A function pointer to a function with the collision behaviour
+		 */
+		void SetCollisionBehaviour(std::function<void(const collision::Collision&)> function)
+		{ if (function != nullptr) { on_collide = function; } }
+
+	public:
+
+		/*
+		 * @brief: This method moves the collision to the center of the entity
+		 */
+		void MoveCollisionBox();
+	};
+}

src/entities/house_generator.cpp

@@ -0,0 +1,131 @@
+#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()
+	{
+	}
+
+	void HouseGenerator::GetRandomFurniturePiece(singleton::FurniturePiece* furniture_piece)
+	{
+		singleton::FurnitureType random_type = singleton::FurnitureType::CEILING_OBJECTS;
+		std::deque<singleton::FurnitureModel> furniture_models = singleton::Model_Storage::get_instance()->get_all_furniture_models();
+		
+		while (random_type == singleton::FurnitureType::CEILING_OBJECTS ) {
+			random_type = singleton::FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
+		}
+
+		for (auto it = furniture_models.begin(); it != furniture_models.end(); ++it)
+		{
+			if (it->furniture.type == random_type)
+			{
+				furniture_piece->type = it->furniture.type;
+				furniture_piece->size = it->furniture.size;
+				break;
+			}
+		}
+		
+
+	}
+
+	void HouseGenerator::GetFurniturePiece(singleton::FurnitureType type, singleton::FurniturePiece* furniture_piece)
+	{
+		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)
+			{
+				furniture_piece->type = it->furniture.type;
+				furniture_piece->size = it->furniture.size;
+				break;
+			}
+		}
+	}
+
+	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
+		collision::Box bounding_box = { glm::vec3(0, 0, 0), glm::vec3(0, 0, 0) };
+		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_x = singleton::Model_Storage::get_instance()->get_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 = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.z * (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;
+
+		for (int z = 1; z < 4; z++) {
+			for (int x = 1; x < 4; x++)
+			{
+				//if (toolbox::Random(0, 100) < 90) {
+				singleton::FurniturePiece furniture_piece;
+				GetRandomFurniturePiece(&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 * HOUSE_SIZE };
+					model_box.SetRotation(90);
+					furniture_list->push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box));
+				}
+				//}
+			//}
+			}
+		}
+
+		singleton::FurniturePiece furniture_piece;
+		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_list->push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box));
+
+	}
+
+	models::TexturedModel HouseGenerator::GetFurnitureModel(const singleton::FurniturePiece* furniture)
+	{
+		std::deque<models::TexturedModel> furniture_list;
+		std::deque<singleton::FurnitureModel> furniture_models = singleton::Model_Storage::get_instance()->get_all_furniture_models();
+
+		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)
+			{
+				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.empty())
+		{
+			std::cerr << "OH NEEEEEEEEEEEEEEE";
+		}
+
+		const int modelNumber = toolbox::Random(0, furniture_list.size() - 1);
+
+		return furniture_list.at(modelNumber);
+	}
+}

src/entities/house_generator.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#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
+{
+	class HouseGenerator
+	{
+	private:
+		const float HOUSE_SIZE = 30;
+	public:
+		HouseGenerator();
+		
+		/*
+		 * @brief: This function generates a house with furniture at the given position and rotation
+		 *
+		 * @param position: The position of the house to render
+		 * @param y_rotation: The y rotation the house needs to be rendered with
+		 *
+		 * @return: A list with all the entities of the generated house (the furniture)
+		 */
+		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 singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE; }
+	
+	private:
+		void GetRandomFurniturePiece(singleton::FurniturePiece* furniture_piece);
+		void GetFurniturePiece(singleton::FurnitureType type, singleton::FurniturePiece* furniture_piece);
+
+		/*
+		 * @brief: This funtion chooses and returns a random furniture of the given furniture type
+		 *
+		 * @param furniture: The furniture you want to get
+		 *
+		 * @return: The model of the random furniture of the chosen furniture type
+		 */
+		models::TexturedModel GetFurnitureModel(const singleton::FurniturePiece* furniture);
+	};
+}

src/entities/light.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <glm/vec3.hpp>
+
+namespace entities
+{
+	/*
+	 * This class represents a light in the game 
+	 */
+	
+	class Light
+	{
+	private:
+		glm::vec3 position;
+		glm::vec3 color;
+		glm::vec3 attenuation = { 1, 0, 0 };
+
+	public:
+		Light(const glm::vec3& position, const glm::vec3& color) : position(position), color(color) { }
+		Light(const glm::vec3& position, const glm::vec3& color, const glm::vec3& attenuation)
+			: position(position), color(color), attenuation(attenuation) { }
+
+		glm::vec3 GetPosition() const { return position; }
+		void setPosition(const glm::vec3& position) { this->position = position; }
+		glm::vec3 GetColor() const { return color; }
+		void setColor(const glm::vec3& color) { this->color = color; }
+		glm::vec3 GetAttenuation() const { return attenuation; }
+		void SetAttenuation(const glm::vec3& attenuation) { this->attenuation = attenuation; }
+	};
+}

src/entities/main_character.cpp

@@ -0,0 +1,108 @@
+#include "main_character.h"
+#include "../models/Model.h"
+#include <iostream>
+#include "entity.h"
+#include"../renderEngine/Renderer.h"
+#include"../renderEngine/obj_loader.h"
+#include"../renderEngine/loader.h"
+namespace entities
+{
+	int movement_speed, down_speed, 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) 
+	{
+		is_playing = true;
+	}
+
+	void MainCharacter::Move(std::vector<computervision::HandDetectRegion*> regions)
+	{
+		computervision::HandDetectRegion* reg_left = regions.at(0);
+		computervision::HandDetectRegion* reg_up = regions.at(1);
+		computervision::HandDetectRegion* reg_right = regions.at(2);
+
+		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 
+			//top right
+			SetRotation(glm::vec3(0, 90, 0));
+			if (reg_up->IsHandPresent() && reg_left->IsHandPresent())
+			{
+				side_speed += SIDE_SPEED;
+				down_speed += UP_SPEED/2;
+				SetRotation(glm::vec3(10, 90, 0));
+			}
+			//right
+			if (reg_left->IsHandPresent())
+			{
+				side_speed += SIDE_SPEED;
+			}
+			//top left
+			if (reg_up->IsHandPresent() && reg_right->IsHandPresent())
+			{
+				down_speed += UP_SPEED/2;
+				side_speed -= SIDE_SPEED;
+				SetRotation(glm::vec3(10, 90, 0));
+			}
+			//left
+			if (reg_right->IsHandPresent())
+			{
+				side_speed -= SIDE_SPEED;
+			}
+
+			if (reg_up->IsHandPresent())
+			{
+				down_speed += UP_SPEED;
+				SetRotation(glm::vec3(10, 90, 0));
+			}
+		}
+			IncreasePosition(glm::vec3(side_speed*delta_time, down_speed*delta_time, movement_speed*delta_time));
+			//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 > 150) position.y = 150;
+			else if (position.y < -60) position.y = -60;
+			//Move player bounding box according to the position on screen
+			MoveCollisionBox();
+			if (reg_right->IsHandPresent() && reg_left->IsHandPresent())
+			{
+				is_playing = true;
+			}
+	}
+
+	void MainCharacter::OnCollide(const collision::Collision& collision) {
+		down_speed = -2.0f;
+		movement_speed = 0.0f;
+		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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "collision_entity.h"
+#include "../shaders/entity_shader.h"
+#include "../computervision/hand_detect_region.h"
+
+namespace entities
+{
+	/* 
+	* This class contains the information about the player model
+	*/
+	class MainCharacter : public CollisionEntity {
+		const int SIDE_SPEED = 40;		//Standard movement speed for left/right movement
+		const int UP_SPEED = 100;		//Standard movement speed for up movement
+	public:
+		/*
+		* @brief: Constructor for the main character model
+		* 
+		* @param model: Model to load in as the player model
+		* @param position: Position of the model inside the game window
+		* @param rotation: Rotation of the model inside the game window
+		* @param scale: Size of the model
+		* @param bounding_box: Collision box around the player model
+		*/
+		MainCharacter(const models::TexturedModel& model, const glm::vec3& position,
+			const glm::vec3& rotation, float scale, const collision::Box& bounding_box);
+		
+		/*
+		* @brief: A function to move the character inside the window
+		* 
+		* @param window: The game window
+		* 
+		* @return: Vector with the adjusted side_speed, down_speed, and movement_speed
+		*/
+		void Move(std::vector<computervision::HandDetectRegion*> regions);
+
+		void OnCollide(const collision::Collision& collision) override;
+
+		bool GetOnCollide();
+
+		double UpdateDelta();
+	};
+}

src/gui/gui_element.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <glm/gtc/matrix_transform.hpp>
+#include "../toolbox/toolbox.h"
+
+namespace gui
+{
+	//Represents the type of the entitie
+	enum class GuiType{
+		LABEL, BUTTON
+	};
+
+	/*
+	 * Structure for representing a gui item to display on the screen
+	 *
+	 * texture  = The texture for the gui
+	 * position = The center position of the gui
+	 * scale    = The size (scale) of the gui
+	 */
+	struct GuiTexture
+	{
+		GLuint texture;
+		glm::vec2 position;
+		glm::vec2 scale;
+
+		virtual GuiType GetType() {
+			return GuiType::LABEL;
+		}
+		GuiTexture(GLuint texture, glm::vec2 position, glm::vec2 scale): texture(texture), position(position), scale(scale)
+		{
+			scale.x /= (WINDOW_WIDTH / WINDOW_HEIGHT);
+		}
+	};
+}

src/gui/gui_interactable.cpp

@@ -0,0 +1,118 @@
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include "gui_interactable.h"
+
+#include <iostream>
+
+namespace gui
+{
+	InteractableGui::InteractableGui(int default_texture, glm::vec2 position, glm::vec2 scale)
+		: GuiTexture(default_texture, position, scale)
+	{
+		this->default_texture = default_texture;
+
+		minXY = glm::vec2(position.x - scale.x, position.y - scale.y);
+		maxXY = glm::vec2(position.x + scale.x, position.y + scale.y);
+	}
+
+	void InteractableGui::Update(GLFWwindow* window)
+	{
+		if (IsHoveringAbove(window) && glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS)
+		{
+			if (clicked_texture != 0)
+			{
+				texture = clicked_texture;
+			}
+			else
+			{
+				texture = default_texture;
+			}
+
+			if (!is_clicking)
+			{
+				OnClick();
+				is_clicking = true;
+			}
+		}
+		else
+		{
+			if (is_clicking)
+			{
+				is_clicking = false;
+			}
+		}
+	}
+
+	void InteractableGui::ForceClick( int mouseButton)
+	{
+		if(mouseButton == GLFW_MOUSE_BUTTON_LEFT)
+		{
+			if (clicked_texture != 0)
+			{
+				texture = clicked_texture;
+			}
+			else
+			{
+				texture = default_texture;
+			}
+
+			if (!is_clicking)
+			{
+				OnClick();
+				is_clicking = true;
+			}
+		}
+		else
+		{
+			if (is_clicking)
+			{
+				is_clicking = false;
+			}
+		}
+		
+	}
+	
+	bool InteractableGui::IsHoveringAbove(GLFWwindow* window)
+	{
+		double x_pos, y_pos;
+		glfwGetCursorPos(window, &x_pos, &y_pos);
+		//std::cout << "Cursor pos in method: " << x_pos <<"::" <<  y_pos << std::endl;
+
+		const float x_rel = (x_pos / SCALED_WIDTH / DEFAULT_WIDTH) * 2.0f - 1.0f;
+		const float y_rel = -((y_pos / SCALED_HEIGHT / DEFAULT_HEIGHT) * 2.0f - 1.0f);
+
+		//std::cout << "x_rel And y_rel in method: " << x_rel << "::" << y_rel << std::endl;
+
+
+		if (x_rel >= minXY.x && x_rel <= maxXY.x &&
+			y_rel >= minXY.y && y_rel <= maxXY.y)
+		{
+			if (hover_texture != 0)
+			{
+				texture = hover_texture;
+			}
+			else
+			{
+				texture = default_texture;
+			}
+
+			if (!is_hovering)
+			{
+				OnEnter();
+				is_hovering = true;
+			}
+
+			return true;
+		}
+
+		texture = default_texture;
+
+		if (is_hovering)
+		{
+			OnExit();
+			is_hovering = false;
+		}
+
+		return false;
+	}
+}

src/gui/gui_interactable.h

@@ -0,0 +1,130 @@
+#pragma once
+
+#include <iostream>
+#include <glm/gtc/matrix_transform.hpp>
+#include "../toolbox/toolbox.h"
+#include "gui_element.h"
+#include <functional>
+
+namespace gui
+{
+	/*
+	 * This class represents a gui item which can be interacted with
+	 */
+	class InteractableGui : public GuiTexture
+	{
+	private:
+		int default_texture;
+		int clicked_texture = 0;
+		int hover_texture = 0;
+
+		bool is_hovering = false;
+		bool is_clicking = false;
+
+		glm::vec2 minXY;
+		glm::vec2 maxXY;
+
+	public:
+		InteractableGui(int default_texture, glm::vec2 position, glm::vec2 scale);
+
+		/*
+		 * @brief: Call this function every frame
+		 *
+		 * @param window: An openGL window
+		 */
+		void Update(GLFWwindow* window);
+
+		/*
+		 * @brief: Call this function when you want to perform a mouseclick
+		 *
+		 * @param mousebutton: mouseButton you want to perform the click on
+		 */
+		void ForceClick(int mouseButton);
+
+		
+		/*
+		 * @brief: This function gets called when the InteractabeGui is clicked
+		 */
+		virtual void OnClick() = 0;
+
+		/*
+		 * @brief: This function gets called when the mouse starts hovering above the InteractableGUI
+		 */
+		virtual void OnEnter() = 0;
+
+		/*
+		 * @brief: This function gets called when the mouse stops hovering above the InteractableGUI
+		 */
+		virtual void OnExit() = 0;
+
+		/*
+		 * @brief: This function sets the texture of the InteractableGUI for when the InteractableGUI is clicked
+		 */
+		void SetClickedTexture(int texture)
+		{
+			clicked_texture = texture;
+		}
+
+		/*
+		 * @brief: This function sets the texture of the InteractableGUI for when the mouse is hovering above the InteractableGUI
+		 */
+		void SetHoverTexture(int texture) { hover_texture = texture; }
+
+	private:
+		/*
+		 * @brief: This function checks if the mouse is hovering above the InteractableGUI
+		 *
+		 * @param window: An openGL window
+		 *
+		 * @return: True or false
+		 */
+		bool IsHoveringAbove(GLFWwindow* window);
+	};
+
+
+	
+	/*
+ * This class represents a button
+ */
+	class Button : public InteractableGui
+	{
+	private:
+
+		std::function<void()> on_click_action;
+		std::function<void()> on_enter_action;
+		std::function<void()> on_exit_action;
+
+	public:
+		Button(int default_texture, glm::vec2 position, glm::vec2 scale) : InteractableGui(default_texture, position, scale) {}
+
+		/*
+		 * @brief: This function sets an action (function pointer) to the OnClick function
+		 *
+		 * @param fun: A function pointer to a function (or lambda)
+		 */
+		void SetOnClickAction(std::function<void()> fun) { on_click_action = fun; }
+
+		/*
+		 * @brief: This function sets an action (function pointer) to the OnEnter function
+		 *
+		 * @param fun: A function pointer to a function (or lambda)
+		 */
+		void SetOnEnterAction(std::function<void()> fun) { on_enter_action = fun; }
+
+		/*
+		 * @brief: This function sets an action (function pointer) to the OnExit function
+		 *
+		 * @param fun: A function pointer to a function (or lambda)
+		 */
+		void SetOnExitAction(std::function<void()> fun) { on_exit_action = fun; }
+
+		GuiType GetType() override {
+			return GuiType::BUTTON;
+		}
+
+	protected:
+		void OnClick() override { if (on_click_action != nullptr) on_click_action(); }
+		void OnEnter() override { if (on_enter_action != nullptr) on_enter_action(); }
+		void OnExit() override { if (on_exit_action != nullptr) on_exit_action(); }
+	};
+}

src/main.cpp

@@ -1,34 +1,60 @@
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
+#include <functional>
+#include <vector>
 #define STB_IMAGE_IMPLEMENTATION
+#include <iostream>
+#include <map>
+
 #include "stb_image.h"
 #include <ostream>
+#include <stdlib.h>
+#include <iostream>
 
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/video.hpp>
+
+#include "collision/collision.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/static_shader.h"
+#include "shaders/entity_shader.h"
 #include "toolbox/toolbox.h"
+#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 "scenes/game_Over_Scene.h"
+#include "entities/collision_entity.h"
+#include "computervision/object_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;
 
+scene::Scene* current_scene;
+
+bool points_img_available = false;
+cv::Mat points_img;
 
 int main(void)
 {
 #pragma region OPENGL_SETTINGS
 	if (!glfwInit())
 		throw "Could not inditialize glwf";
-    window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGT, "SDBA", NULL, NULL);
+	window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "SDBA", NULL, NULL);
 	if (!window)
 	{
 		glfwTerminate();
@@ -38,56 +64,68 @@ int main(void)
 	glewInit();
 	glGetError();
 #pragma endregion
+    //current_scene = new scene::Startup_Scene();
+    current_scene = new scene::Loading_Scene();
+    score = 0;
+
 
     glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
         {
             if (key == GLFW_KEY_ESCAPE)
+            {
                 glfwSetWindowShouldClose(window, true);
+            }
+    	
+            current_scene->onKey(window, key, scancode, action, mods);
         });
     
-	
+    bool window_open = true;
-    models::RawModel raw_model = LoadObjModel("res/Tree.obj");
-    models::ModelTexture texture = { render_engine::loader::LoadTexture("res/TreeTexture.png") };
-    models::TexturedModel model = { raw_model, texture };
-    entities::Entity entity(model, glm::vec3(0, -5, -20), glm::vec3(0, 0, 0), 1);
-	
-    shaders::StaticShader shader;
-    shader.Init();
-    render_engine::renderer::Init(shader);
-
-    entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
-
-    computervision::ObjectDetection objDetect;
-    
-    
-    // set up object detection
-    //objDetect.setup();
 
 	// Main game loop
-	while (!glfwWindowShouldClose(window))
+	while (!glfwWindowShouldClose(window) && window_open)
 	{
         //Update
         const double delta = UpdateDelta();
-        entity.IncreaseRotation(glm::vec3(0, 1, 0));
-        camera.Move(window);
 
-		// Render
+        scene::Scenes return_value = current_scene->start(window);
-        render_engine::renderer::Prepare();
+        delete current_scene;
-        shader.Start();
-        shader.LoadViewMatrix(camera);
 
-        render_engine::renderer::Render(entity, shader);
+        switch (return_value) {
+            case scene::Scenes::STOP:
+                window_open = false;
+                break;
 
-        objDetect.setup();
+            case scene::Scenes::LOADING:
+                current_scene = new scene::Loading_Scene();
+                break;
 
-		// Finish up
+            case scene::Scenes::STARTUP:
-        shader.Stop();
+                current_scene = new scene::Startup_Scene();
-		glfwSwapBuffers(window);
+                break;
-		glfwPollEvents();
+
+		
+            case scene::Scenes::INGAME:
+                current_scene = new scene::In_Game_Scene(&score);
+                break;
+                
+            case scene::Scenes::GAMEOVER:
+                current_scene = new scene::Game_Over_Scene(score);
+                break;
+
+            default:
+                std::cout << "Wrong return value!!! ->" << std::endl;
+                break;
         }
         
-	// Clean up
+		// Finish up
-    shader.CleanUp();
+		//shader.Stop();
+		glfwSwapBuffers(window);
+		glfwPollEvents();
+           
+	}
+
+	// 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/models/Model.h

@@ -1,28 +1,36 @@
 #pragma once
 
 #include <GL/glew.h>
+#include <glm/gtc/matrix_transform.hpp>
 
 namespace models
 {
 	/*
-		Structure for storing a vboID and vertex_count.
+		Structure for storing a vboID and vertex_count (this representa a mesh without a model).
 
-		This structure represents a Bare bones Model (A mesh without a texture).
+		vao_id = The openGL id of the model
-		The vao_id, points to an ID stored by openGL and the
+		vertex_count = The amount of vertices in the model
-		vertex_count is how many triangles in the mesh there are.
+		model_size = The size on each axis of the model
 	*/
 	struct RawModel
 	{
 		GLuint vao_id;
 		int vertex_count;
+		glm::vec3 model_size = { -1, -1, -1 };
 	};
 
 	/*
 		Structure for storing a texture (texture_id) to apply to a RawModel.
+
+		texture_id = The openGL id of the textures
+		shine_damper = A damper for the angle the model needs to be look at to see reflections
+		reflectivity = The amount of light the model reflects
 	*/
 	struct ModelTexture
 	{
 		GLuint texture_id;
+		float shine_damper = 1;
+		float reflectivity = 0;
 	};
 	
 	/*

src/renderEngine/Loader.cpp

@@ -1,7 +1,10 @@
 #include <GL/glew.h>
+#include <glm/vec3.hpp>
 #include "../stb_image.h"
 #include "loader.h"
 
+#include <iostream>
+
 namespace render_engine
 {
 	namespace loader
@@ -9,22 +12,38 @@ namespace render_engine
 		static GLuint CreateVao();
 		static void StoreDataInAttributeList(int attribute_number, int coordinate_size, std::vector<float>& data);
 		static void BindIndicesBuffer(std::vector<unsigned int>& indices);
+		static glm::vec3 GetSizeModel(std::vector<float>& positions);
 
 		static std::vector<GLuint> vaos;
 		static std::vector<GLuint> vbos;
 		static std::vector<GLuint> textures;
 
 		/*
-			This function will generate a Model from vertex positions, textureCoordinates and indices.
+			This function will generate a Model from vertex positions, textureCoordinates normals and indices.
 		*/
-		struct models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<unsigned int>& indices)
+		models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<float>& normals, std::vector<unsigned int>& indices)
 		{
-			GLuint vao_id = CreateVao();
+			const GLuint vao_id = CreateVao();
 			BindIndicesBuffer(indices);
 			StoreDataInAttributeList(0, 3, positions);
 			StoreDataInAttributeList(1, 2, texture_coords);
+			StoreDataInAttributeList(2, 3, normals);
 			glBindVertexArray(0);
-			return { vao_id, static_cast<int>(indices.size()) };
+			
+			const glm::vec3 model_size = GetSizeModel(positions);
+			
+			return { vao_id, static_cast<int>(indices.size()), model_size };
+		}
+
+		/*
+			This function will generate a Model from vertex positions.
+		*/
+		models::RawModel LoadToVAO(std::vector<float>& positions)
+		{
+			const GLuint vao_id = CreateVao();
+			StoreDataInAttributeList(0, 2, positions);
+			glBindVertexArray(0);
+			return { vao_id, static_cast<int>(positions.size()) / 2 };
 		}
 
 		/*
@@ -40,6 +59,12 @@ namespace render_engine
 			glEnable(GL_TEXTURE_2D);
 			glBindTexture(GL_TEXTURE_2D, texture_id);
 			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, imgData);
+
+			// Set mipmapping with a constant LOD
+			glGenerateMipmap(GL_TEXTURE_2D);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+			glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -0.4f);
+
 			glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 			glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 			
@@ -113,5 +138,72 @@ namespace render_engine
 			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_id);
 			glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int) * indices.size(), &indices[0], GL_STATIC_DRAW);
 		}
+
+		/**
+		* @brief gets the width, height and depth of a model
+		* @param positions all the points of a model
+		* @returns vec3<float> the size values of a model (width, height and depth)
+		**/
+		static glm::vec3 GetSizeModel(std::vector<float>& positions)
+		{
+			float minX = 100;
+			float maxX = -100;
+
+			float minY = 100;
+			float maxY = -100;
+
+			float minZ = 100;
+			float maxZ = -100;
+			
+			for (int i = 0; i < positions.size(); ++i)
+			{
+				const int index = i % 3;
+				const float value = positions[i];
+				
+				switch (index)
+				{
+				case 0: // x
+					{
+						if (value < minX)
+						{
+							minX = value;
+						} else if (value > maxX)
+						{
+							maxX = value;
+						}
+						break;
+					}
+				case 1: // y
+					{
+						if (value < minY)
+						{
+							minY = value;
+						}
+						else if (value > maxY)
+						{
+							maxY = value;
+						}
+						break;
+					}
+				case 2: // z
+				{
+					if (value < minZ)
+					{
+						minZ = value;
+					}
+					else if (value > maxZ)
+					{
+						maxZ = value;
+					}
+					break;
+				}
+				}
+			}
+
+			const float sizeX = maxX - minX;
+			const float sizeY = maxY - minY;
+			const float sizeZ = maxZ - minZ;
+			return { sizeX, sizeY, sizeZ };
+		}
 	}
 }

src/renderEngine/Loader.h

@@ -9,17 +9,36 @@ namespace render_engine
 	namespace loader
 	{
 		/*
-			This function generates a model from model data.
+		*	@brief: This function generates a model from model data.
+		*
+		*	@param position: The positions of each vertex (in order: x, y, z) in the model
+		*	@param texture_coords: The texture coordinates of the model
+		*	@param normals: The normals of each face of the model
+		*	@param indices: A list with a sort of lookup table to the positions parameter
+		*
+		*	@return: A new rawmodel which represents al the parameters in one struct
 		*/
-		struct models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<unsigned int>& indices);
+		models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<float>& normals, std::vector<unsigned int>& indices);
 
 		/*
-			Loads a texture from a file into openGL using stb_image.h
+		 * @brief: Overloaded function of the function above, but does not need normals and indices.
+		 *         Use this function to for example load GUI items to OpenGL.
+		 *
+		 * @param position: The positions of each vertex (in order: x, y, z) in the model
+		 *
+		 * @return: A new rawmodel which represents al the parameters in one struct
+		 */
+		models::RawModel LoadToVAO(std::vector<float>& positions);
+		
+		/*
+		*	@brief: Loads a texture from a file into openGL using stb_image.h
+		*
+		*	@param file_name: The filepath to the texture
 		 */
 		GLuint LoadTexture(std::string file_name);
 		
 		/*
-			Call this function when cleaning up all the meshes (when exiting the program).
+		*	@brief: Call this function when cleaning up all the meshes (when exiting the program).
 		*/
 		void CleanUp();
 	}

src/renderEngine/Renderer.cpp

@@ -1,8 +1,10 @@
 #include <GL/glew.h>
 #include <glm/gtc/matrix_transform.hpp>
 #include "../models/model.h"
-#include "renderer.h"
+#include "loader.h"
 #include "../toolbox/toolbox.h"
+#include "renderer.h"
+#include <iostream>
 
 namespace render_engine
 {
@@ -12,17 +14,27 @@ namespace render_engine
 		static const float NEAR_PLANE = 0.01f;
 		static const float FAR_PLANE = 1000.0f;
 
-		/*
+		// GUI variables
-			This function will load the projectionMatrix into the shader
+		static models::RawModel quad;
-		 */
-		void Init(shaders::StaticShader& shader)
-		{
-			const glm::mat4 projectionMatrix = 
-				glm::perspective(glm::radians(FOV), (WINDOW_WIDTH / WINDOW_HEIGT), NEAR_PLANE, FAR_PLANE);
 		
+		
+		void Init(shaders::EntityShader& shader)
+		{
+			// Faces which are not facing the camera are not rendered
+			glEnable(GL_CULL_FACE);
+			glCullFace(GL_BACK);
+			
+			const glm::mat4 projectionMatrix = 
+				glm::perspective(glm::radians(FOV), (WINDOW_WIDTH / WINDOW_HEIGHT), NEAR_PLANE, FAR_PLANE);
+
+			// Load the projectionmatrix into the shader
 			shader.Start();
 			shader.LoadProjectionMatrix(projectionMatrix);
 			shader.Stop();
+
+			// Initialize the quad for the GUI
+			std::vector<float> quad_positions = { -1, 1, -1, -1, 1, 1, 1, -1 };
+			quad = loader::LoadToVAO(quad_positions);
 		}
 
 		/*
@@ -32,36 +44,164 @@ namespace render_engine
 		{
 			glEnable(GL_DEPTH_TEST);
 			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-			glClearColor(0.3f, 0.4f, 0.6f, 1.0f);
+			glClearColor(SKY_COLOR.r, SKY_COLOR.g, SKY_COLOR.b, 1.0f);
 		}
 
 		/*
 			This function will Render a Model on the screen.
 		*/
-		void Render(entities::Entity& entity, shaders::StaticShader& shader)
+		void Render(std::shared_ptr<entities::Entity> entity, shaders::EntityShader& shader)
 		{
-			const models::TexturedModel model = entity.GetModel();
+			const models::TexturedModel model = entity.get()->GetModel();
-			const models::RawModel rawModel = model.raw_model;
+			const models::RawModel raw_model = model.raw_model;
+			const models::ModelTexture texture = model.texture;
 			
-			// Enable the model
+			// Enable the model (VAO)
-			glBindVertexArray(rawModel.vao_id);
+			glBindVertexArray(raw_model.vao_id);
 
-			// Enable the inputs for the vertexShader
+			// Enable the VBO's from the model (VAO)
 			glEnableVertexAttribArray(0);
 			glEnableVertexAttribArray(1);
+			glEnableVertexAttribArray(2);
 
 			// Load the transformation of the model into the shader
-			const glm::mat4 modelMatrix = toolbox::CreateModelMatrix(entity.GetPosition(), entity.GetRotation(), entity.GetScale());
+			const glm::mat4 modelMatrix = toolbox::CreateModelMatrix(entity.get()->GetPosition(), entity.get()->GetRotation(), entity.get()->GetScale());
 			shader.LoadModelMatrix(modelMatrix);
+			shader.LoadShineVariables(texture.shine_damper, texture.reflectivity);
 			
 			// Draw the model
 			glActiveTexture(GL_TEXTURE0);
 			glBindTexture(GL_TEXTURE_2D, model.texture.texture_id);
-			glDrawElements(GL_TRIANGLES, rawModel.vertex_count, GL_UNSIGNED_INT, 0);
+			glDrawElements(GL_TRIANGLES, raw_model.vertex_count, GL_UNSIGNED_INT, 0);
 
+			// Disable the VBO's and model (VAO)
 			glDisableVertexAttribArray(0);
 			glDisableVertexAttribArray(1);
+			glDisableVertexAttribArray(2);
 			glBindVertexArray(0);
 		}
+
+		void Render(std::vector<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 (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);
+			}
+
+			// 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);
+
+			// Disable alpha blending
+			glDisable(GL_BLEND);
+
+			// Disable the VBO and VAO
+			glDisableVertexAttribArray(0);
+			glBindVertexArray(0);
+
+			shader.Stop();
+		}
 	}
 }

src/renderEngine/Renderer.h

@@ -1,25 +1,61 @@
 #pragma once
 
+#include <memory>
+#include "../gui/gui_element.h"
 #include "../entities/entity.h"
-#include "../shaders/static_shader.h"
+#include "../shaders/entity_shader.h"
+#include "../shaders/gui_shader.h"
 
 namespace render_engine
 {
 	namespace renderer
 	{
-		/*
+		const glm::vec3 SKY_COLOR = { 0.3f, 0.4f, 0.6f };
-			Call this function when starting the program
-		 */
-		void Init(shaders::StaticShader& shader);
 		
 		/*
-			Call this function before rendering. 
+			@brief: Call this function when starting the program
+
+			@param shader: The shader to render the entities with
+		 */
+		void Init(shaders::EntityShader& shader);
+		
+		/*
+			@brief: Call this function before rendering.
+					This function will enable culling and load the projectionMatrix into the shader.
 		*/
 		void Prepare();
 
 		/*
-			Call this function when wanting to Render a mesh to the screen.
+			@brief: Call this function when wanting to Render a mesh to the screen.
+
+			@param entity: The entity which needs to be rendered
+			@param shader: The shader the entity needs to be rendered with
 		*/
-		void Render(entities::Entity& entity, shaders::StaticShader& shader);
+		void Render(std::shared_ptr<entities::Entity> entity, shaders::EntityShader& shader);
+
+		/*
+			@brief: Call this function to render gui_textures on the screen
+
+			@param guis:  A list with all the GUI textures you want to render
+			@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/renderEngine/obj_loader.cpp

@@ -6,6 +6,8 @@
 #include "loader.h"
 #include "obj_loader.h"
 
+namespace render_engine
+{
     static void Split(const std::string& s, char delim, std::vector<std::string>& elems)
     {
         std::stringstream ss;
@@ -109,7 +111,8 @@ models::RawModel LoadObjModel(std::string file_name)
                     break;
                 }
             }
-    } catch (const std::exception& e)
+        }
+        catch (const std::exception& e)
         {
             // Always go in here
         }
@@ -125,5 +128,6 @@ models::RawModel LoadObjModel(std::string file_name)
             vertex_array[p++] = vertex.z;
         }
 
-    return render_engine::loader::LoadToVAO( vertex_array, texture_array, indices);
+        return render_engine::loader::LoadToVAO(vertex_array, texture_array, normal_array, indices);
+    }
 }

src/renderEngine/obj_loader.h

@@ -3,4 +3,12 @@
 #include <string>
 #include "../models/model.h"
 
+namespace render_engine
+{
+	/*
+	 * @brief: This function retrieves an .obj file, loads it into the VBO and returns a RawModel
+	 *
+	 * @param file_name: The path to the .obj file
+	 */
 	models::RawModel LoadObjModel(std::string file_name);
+}

src/scenes/game_Over_Scene.cpp

@@ -0,0 +1,185 @@
+#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;
+	std::vector<std::shared_ptr<gui::GuiTexture>> score_textures_gameOver;
+	double delta_time = 0;
+	double time = 0;
+	bool game_over = 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;
+		}
+	}
+
+	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([this]()
+			{
+				std::cout << "Back to stop screen!!" << std::endl;
+				return_value = Scenes::STOP;
+				
+			});
+		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 (game_over) button_start_scene.ForceClick(GLFW_MOUSE_BUTTON_LEFT);
+			glfwSwapBuffers(window);
+			glfwPollEvents();			
+		}
+
+		gui_shader_gameOver->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);
+
+		render_engine::renderer::Render(game_over_texture, *gui_shader_gameOver);
+		DrawScore(end_score);
+	}
+
+	/**
+	 * 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);
+		}
+
+		UpdateDeltaTime();
+		time += delta_time;
+
+		if (time >= 5.0)
+		{
+			game_over = true;
+		}
+		
+
+		}
+
+	/**
+	 * 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");
+		}
+	}
+
+	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);
+		}
+	}
+
+	void Game_Over_Scene::UpdateDeltaTime()
+	{
+		double current_time = glfwGetTime();
+		static double last_frame_time = current_time;
+		delta_time = current_time - last_frame_time;
+		last_frame_time = current_time;
+
+	}
+
+	Game_Over_Scene::~Game_Over_Scene()
+	{
+		std::cout << "game over destructor" << std::endl;
+		delete gui_shader_gameOver;
+	}
+}

src/scenes/game_Over_Scene.h

@@ -0,0 +1,37 @@
+#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;
+		void UpdateDeltaTime();
+
+
+	public:
+		Game_Over_Scene(int score);
+		~Game_Over_Scene();
+
+		Scenes start(GLFWwindow* window) override;
+
+		void render() override;
+
+		void update(GLFWwindow* window) override;
+
+		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
+		/**
+		* @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

@@ -0,0 +1,410 @@
+#include "in_Game_Scene.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::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;
+
+	models::RawModel raw_model, raw_model_char;
+	models::ModelTexture texture;
+	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;
+
+	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(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;
+		shader->Init();
+		render_engine::renderer::Init(*shader);
+
+		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?
+	 * just to make some bounding boxes
+	 */
+	collision::Box create_bounding_box(glm::vec3 size, glm::vec3 pos, int scale) {
+		collision::Box box = collision::Box();
+		box.size.x = size.z * scale;
+		box.size.y = size.y * scale;
+		box.size.z = size.x * scale;
+		box.center_pos = pos;
+		return box;
+	}
+	/**
+	 * deletes certain veriables when the object will be deleted, prevents memory leaks
+	 */
+	In_Game_Scene::~In_Game_Scene()
+	{
+		delete shader;
+		delete gui_shader;
+		delete house_generator;
+	}
+
+	
+	void In_Game_Scene::SetupHandDetection()
+	{
+		// 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;
+			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;
+
+	}
+
+	/**
+	 * starts the game scene, calls the render and update methods in a while loop
+	 */
+	scene::Scenes scene::In_Game_Scene::start(GLFWwindow* window)
+	{
+		texture = { render_engine::loader::LoadTexture("res/Texture.png") };
+		texture.shine_damper = 10;
+		texture.reflectivity = 0;
+
+
+		raw_model_char = render_engine::LoadObjModel("res/beeTwo.obj");
+		models::TexturedModel model_char = { raw_model_char, texture };
+		collision::Box char_box = create_bounding_box(raw_model_char.model_size, glm::vec3(0, 0, 0), 1);
+		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);
+		house_generator = new entities::HouseGenerator();
+
+		SetupHandDetection();
+
+		// load the first few house models
+		for (int i = 0; i <= UPCOMING_MODEL_AMOUNT; i++)
+		{
+			LoadChunk(i);
+		}
+
+		lights.push_back(entities::Light(glm::vec3(0, 1000, 7000), glm::vec3(5, 5, 5))); // sun
+		lights.push_back(entities::Light(glm::vec3(0, 0, -30), glm::vec3(2, 0, 2), glm::vec3(0.0001f, 0.0001f, 0.0001f)));
+		lights.push_back(entities::Light(glm::vec3(0, 0, -200), glm::vec3(0, 2, 0), glm::vec3(0.0001f, 0.0001f, 0.0001f)));
+
+		// GUI stuff
+		gui::Button button(render_engine::loader::LoadTexture("res/Mayo.png"), glm::vec2(0.5f, 0.0f), glm::vec2(1, 1));
+		button.SetHoverTexture(render_engine::loader::LoadTexture("res/Texture.png"));
+		button.SetClickedTexture(render_engine::loader::LoadTexture("res/Mayo.png"));
+		button.SetOnClickAction([]()
+			{
+				std::cout << "I got clicked on!" << std::endl;
+			});
+		guis.push_back(&button);
+
+
+		//guis for the pause menu 
+		gui::GuiTexture background(render_engine::loader::LoadTexture("res/background_grey.png"), glm::vec2(0, 0), glm::vec2(1, 1));
+		pause_guis.push_back(&background);
+
+		gui::Button pause_button_resume(render_engine::loader::LoadTexture("res/menu_item_resume1.png"), glm::vec2(0.0f, 0.3f), glm::vec2(0.25f, 0.25f));
+		pause_button_resume.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_resume1_hover.png"));
+		pause_button_resume.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_resume1_click.png"));
+		std::function<void()> resume_fun = [this]()
+		{
+			std::cout << "I got clicked on the resume button!" << std::endl;
+			game_state = scene::Game_State::RUNNING;
+		};
+		pause_button_resume.SetOnClickAction(resume_fun);
+		pause_guis.push_back(&pause_button_resume);
+
+		gui::Button pause_button_quit(render_engine::loader::LoadTexture("res/menu_item_quit1.png"), glm::vec2(0.0f, -0.3f), glm::vec2(0.25f, 0.25f));
+		pause_button_quit.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_hover.png"));
+		pause_button_quit.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_click.png"));
+		std::function<void()> stop_function = [this]()
+		{
+			std::cout << "I got clicked on the quit button!" << std::endl;
+			return_value = scene::Scenes::STOP;
+		};
+		pause_button_quit.SetOnClickAction(stop_function);
+		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)
+		{
+			//checks the current game state, so it can render the correct models for each state
+			switch (game_state)
+			{
+				/*case scene::Game_State::IDLE:
+					break;*/
+
+			case scene::Game_State::PAUSED:
+				render();
+				update_buttons(window);
+				render_pause_menu();
+
+				break;
+
+			case scene::Game_State::RUNNING:
+				update(window);
+				button.Update(window);
+				render();
+				break;
+
+			default:
+				std::cout << "Game state unknown" << std::endl;
+				break;
+			}
+
+
+			glfwSwapBuffers(window);
+			glfwPollEvents();
+		}
+		shader->CleanUp();
+		gui_shader->CleanUp();
+		//render_engine::loader::CleanUp();
+		return return_value;
+	}
+
+	gui::Button* In_Game_Scene::ConvertGuiTextureToButton(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;
+		}
+	}
+
+	/**
+	 * renders the game models
+	 */
+	void scene::In_Game_Scene::render()
+	{
+		// Render
+		render_engine::renderer::Prepare();
+		//starts the shader and begins to render
+		shader->Start();
+		shader->LoadSkyColor(render_engine::renderer::SKY_COLOR);
+		shader->LoadLightsDeque(lights);
+		shader->LoadViewMatrix(*camera);
+
+		for (std::shared_ptr<entities::Entity> model_entity : house_models)
+		{
+			render_engine::renderer::Render(model_entity, *shader);
+		}
+
+		render_engine::renderer::Render(main_character, *shader);
+
+		// Render GUI items
+		//render_engine::renderer::Render(guis, *gui_shader);
+
+		// Stop rendering the entities
+		shader->Stop();
+
+		DrawScore(score);
+	}
+
+	void scene::In_Game_Scene::update_buttons(GLFWwindow* window)
+	{
+		for (gui::GuiTexture* button : pause_guis) {
+			gui::Button* new_button = ConvertGuiTextureToButton(button);
+			if (new_button != NULL)
+				new_button->Update(window);
+		}
+	}
+
+	//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;
+			cv::destroyWindow("camera");
+		}
+
+		camera->Follow(main_character->GetPosition());
+
+		// calculate where the next house model should be loaded
+		static int last_model_pos = 0;
+		int model_pos = -round(camera->GetPosition().z / (house_generator->GetHouseDepth())); // how much models we have passed, minus because we are moving in the negative z axis
+
+		// if we have passed a model, load a new one and delete the one behind us
+		if (last_model_pos != model_pos)
+		{
+			std::cout << "updating score" << std::endl;
+			LoadChunk(model_pos + UPCOMING_MODEL_AMOUNT);
+			score += furniture_count_old;
+			std::cout << "Score: " << score << 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);
+		collision_entities.pop_front();
+	}
+
+	//manages the key input in the game scene
+	void scene::In_Game_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
+	{
+		if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+		{
+			cv::destroyWindow("camera");
+			return_value = scene::Scenes::STOP;
+		}
+		if (glfwGetKey(window, GLFW_KEY_P) == GLFW_PRESS)
+		{
+			game_state = scene::Game_State::PAUSED;
+		}
+		if (glfwGetKey(window, GLFW_KEY_O) == GLFW_PRESS)
+		{
+			game_state = scene::Game_State::RUNNING;
+		}
+	}
+
+	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);
+		reg_right.DetectHand(camera_frame);
+		reg_up.DetectHand(camera_frame);
+
+		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

@@ -0,0 +1,160 @@
+#pragma once
+#include <iostream>
+#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"
+#include "../renderEngine/loader.h"
+#include "../renderEngine/obj_loader.h"
+#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
+{
+	/**
+	* This enum is for managing the game scene state.  
+	* for example: when pressed on a specific button, the game will be in a paused state and nothing about the player or the speed of the game will be updated
+	* and the pause screen will show up.
+	**/
+	enum class Game_State
+	{
+		//IDLE,
+		RUNNING,
+		PAUSED
+	};
+
+	class In_Game_Scene : public scene::Scene
+	{
+	private:
+		//return_value is an enum that is necessary for the scene switching. Whenever this changes, the scene will change to a different scene.
+		scene::Scenes return_value = scene::Scenes::INGAME;
+		//game_state is an enum that keeps track of the current game state. For example: is the game running(thus the user is playing the game) of is the game paused.
+		scene::Game_State game_state = scene::Game_State::RUNNING;
+
+		//entities_to_render is a list of entities, those entities will be rendered in the 3D environment.
+		std::vector<entities::Entity> entities_to_render;
+		//lights is a lost of light points in the game, for example the sun or it can be used to attach light effects to lamps.
+		std::deque<entities::Light> lights;
+		
+		models::RawModel raw_model;
+		models::ModelTexture texture;
+		//the shader that is used for rendering the models.
+		shaders::EntityShader* shader;
+		//the gui_shader is used of rendering the gui models (for example the pause buttons).
+		shaders::GuiShader* gui_shader;
+		//camera is the camera view of the game scene, this camera will be behind the main character.
+		std::unique_ptr<entities::Camera> camera;
+		//guis is a list of all the gui components that needs to be load in the 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
+		 * @param 
+		 * @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);
+
+		void update_buttons(GLFWwindow* window);
+
+		gui::Button* ConvertGuiTextureToButton(gui::GuiTexture* texture);
+	
+	public:
+		In_Game_Scene(int *score_ptr);
+		~In_Game_Scene();
+
+		/**
+		 * @brief the method start is the start of the scene where a while loop runs, this runs the scene.
+		 * @param window the main window of the application
+		 * @return Scene value that indicates in which scene the application is
+		 */
+		Scenes start(GLFWwindow* window) override;
+
+		/**
+		 * @brief this method renders the models for the game scene
+		 * @param 
+		 * @return void
+		 */
+		void render() override;
+
+		/**
+		 * @brief this method updates the models/variables for the game scene
+		 * @param window the main window of the application
+		 * @return void
+		 */
+		void update(GLFWwindow* window) override;
+
+		/**
+		 * @brief this method updates the models/variables for the game scene
+		 * @param window the main window of the application
+		 * @param key this is the keycode on which key has been pressed 
+		 * @param scancode -
+		 * @param action-
+		 * @param mods -
+		 * @return void
+		 */
+		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
+	};
+}
+
+

src/scenes/loading_Scene.cpp

@@ -0,0 +1,146 @@
+#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()
+	{
+		delete gui_shader;
+	}
+
+	Scenes Loading_Scene::start(GLFWwindow* window)
+	{
+		render();
+
+		glfwSwapBuffers(window);
+		glfwPollEvents();
+		
+		load_default_variables();
+		load_all_models();
+		
+		return scene::Scenes::STARTUP;
+	}
+
+	void Loading_Scene::render()
+	{
+		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/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);
+		//shader_test->Stop();
+
+		gui_shader->CleanUp();
+	}
+
+	void Loading_Scene::update(GLFWwindow* window)
+	{
+	}
+
+	
+	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

@@ -0,0 +1,67 @@
+#pragma once
+#include "scene.h"
+#include "../gui/gui_element.h"
+#include "../shaders/gui_shader.h"
+#include "../model_Storage.h"
+
+namespace scene
+{
+	extern GLFWwindow* window;
+	
+
+	class Loading_Scene : public scene::Scene
+	{
+	private:
+		//return_value is an enum that is necessary for the scene switching. Whenever this changes, the scene will change to a different scene.
+		scene::Scenes return_value = scene::Scenes::LOADING;
+		shaders::GuiShader* gui_shader;
+
+
+	private:
+		void load_default_variables();
+		void load_all_models();
+
+	public:
+		/**
+		 * @brief Constructor of the class Loading_Scene
+		 *
+		 */
+		Loading_Scene();
+
+		~Loading_Scene();
+		
+		/**
+		 * @brief
+		 *
+		 * @param window
+		 * @return
+		 */
+		Scenes start(GLFWwindow* window) override;
+
+		/**
+		 * @brief
+		 *
+		 */
+		void render() override;
+
+		/**
+		 * @brief This method updates all the components on the window
+		 *
+		 * @param window Window it updates
+		 */
+		void update(GLFWwindow* window) override;
+
+		/**
+		 * @brief Listener for key events
+		 *
+		 * @param window Window it listens to for key events
+		 * @param key Key of event that is activated
+		 * @param scancode Code of Key
+		 * @param action
+		 * @param mods
+		 */
+		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
+	};
+}
+
+

src/scenes/scene.cpp

@@ -0,0 +1,7 @@
+#include <iostream>
+#include "scene.h"
+
+scene::Scene::~Scene()
+{
+	std::cout << "Main scene class gone!" << std::endl;
+}

src/scenes/scene.h

@@ -0,0 +1,60 @@
+#pragma once
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <map>
+
+
+namespace scene {
+
+	/**
+	 * this enum represents the scenes in the game, those wil help to keep track in which scene the game is.
+	 */
+	enum class Scenes
+	{
+		LOADING,
+		STARTUP,
+		INGAME,
+		GAMEOVER,
+		CALIBRATION,
+		STOP
+	};
+
+	class Scene
+	{		
+	public:
+		virtual ~Scene() = 0;
+		
+		/**
+		 * @brief the method start is the start of a scene where a while loop runs, this runs the scene.
+		 * @param window the main window of the application
+		 * @return Scene value that indicates in which scene the application is
+		 */
+		virtual Scenes start(GLFWwindow* window) = 0;
+
+		/**
+		 * @brief this method renders the models for a scene
+		 * @param
+		 * @return void
+		 */
+		virtual void render() = 0;
+
+		/**
+		 * @brief this method updates the models/variables for a scene
+		 * @param window the main window of the application
+		 * @return void
+		 */
+		virtual void update(GLFWwindow* window) = 0;
+
+		/**
+		 * @brief this method updates the models/variables for a scene
+		 * @param window the main window of the application
+		 * @param key this is the keycode on which key has been pressed
+		 * @param scancode -
+		 * @param action-
+		 * @param mods -
+		 * @return void
+		 */
+		virtual void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) {};
+
+	};
+}

src/scenes/startup_Scene.cpp

@@ -0,0 +1,230 @@
+#include <iostream>
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <map>
+#include "startup_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"
+
+
+
+
+namespace scene
+{
+	shaders::GuiShader* gui_shader1;
+	std::vector<gui::GuiTexture*> guis1;
+  computervision::ObjectDetection objDetect;
+
+	float item_number = 0;
+
+	bool hand_mode = false;
+
+	Startup_Scene::Startup_Scene() {
+		shaders::EntityShader shader;
+		shader.Init();
+		render_engine::renderer::Init(shader);
+		shader.CleanUp();
+
+		gui_shader1 = new shaders::GuiShader();
+		gui_shader1->Init();
+	}
+
+	void Startup_Scene::EnableHandMode()
+	{
+		hand_mode = true;
+	}
+
+	gui::Button* ConvertGuiTextureToButton(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::InteractableGui* ConvertGuiTextureToInteractableGui(gui::GuiTexture* texture) {
+		if (texture != NULL)
+			if (texture->GetType() == gui::GuiType::BUTTON) {
+				return (gui::InteractableGui*)texture;
+			}
+			else {
+				return NULL;
+			}
+
+	}*/
+
+	gui::GuiTexture* GetMenuItem(bool hand_state) {
+		if(hand_state)
+		item_number += 0.10f;
+
+		int temp_item_number = item_number;
+		
+		//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 == guis1.size()) {
+			item_number = 0;
+			temp_item_number = 0;
+		}
+		std::cout << guis1[temp_item_number]->texture << std::endl;
+		return guis1[temp_item_number];
+	}
+
+	scene::Scenes scene::Startup_Scene::start(GLFWwindow *window)
+	{
+		// GUI stuff
+		gui::Button button_start(render_engine::loader::LoadTexture("res/menu_item_start1.png"), glm::vec2(0.0f, 0.3f), glm::vec2(0.25f, 0.25f));
+		button_start.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_start1_hover.png"));
+		button_start.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_start1_click.png"));
+		std::function<void()> start_fun = [this]()
+		{
+			std::cout << "Clicked on button: Start!" << std::endl;
+			return_value = scene::Scenes::INGAME;
+			cv::destroyWindow("camera");
+
+		};
+		button_start.SetOnClickAction(start_fun);
+
+		guis1.push_back(&button_start);
+
+		gui::Button button_quit(render_engine::loader::LoadTexture("res/menu_item_quit1.png"), glm::vec2(0.0f, -0.3f), glm::vec2(0.25f, 0.25f));
+		button_quit.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_hover.png"));
+		button_quit.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_click.png"));
+		std::function<void()> quit_fun = [this]()
+		{
+			std::cout << "Clicked on button: Quit!" << std::endl;
+			return_value = scene::Scenes::STOP;
+			cv::destroyWindow("camera");
+		};
+		button_quit.SetOnClickAction(quit_fun);
+		guis1.push_back(&button_quit);
+
+		cv::Mat cameraFrame;
+		gui::GuiTexture* chosen_item = NULL; //This is the selected menu_item
+		bool hand_closed = false; //Flag to prevent multiple button presses
+		std::function<void()> calibration_func = [this]() {EnableHandMode(); };
+		objDetect.SetCalibrationCallback(calibration_func);
+		while (return_value == scene::Scenes::STARTUP)
+		{
+			render();
+			update(window);
+			
+			if (hand_mode) {
+				cameraFrame = objDetect.ReadCamera();
+
+				//Get hand state from camera
+				bool detect = false;
+				bool hand_detection = objDetect.DetectHand(cameraFrame,detect);
+
+				if (hand_detection)
+				{
+					hand_closed = false;
+					std::cout << "hand is opened" << std::endl;
+
+					//Loop through menu items
+					chosen_item = GetMenuItem(true);
+
+					gui::Button* new_button = ConvertGuiTextureToButton(chosen_item);
+					if (new_button != NULL) {
+						const float x_pos = (chosen_item->position.x + 1.0) * WINDOW_WIDTH / 2;
+						const float y_pos = (1.0 - chosen_item->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 = GetMenuItem(false);
+					gui::Button* new_button = ConvertGuiTextureToButton(chosen_item);
+
+					if (new_button != NULL && !hand_closed) {
+						//Run function click
+						new_button->ForceClick(GLFW_MOUSE_BUTTON_LEFT);
+						hand_closed = true;
+					}
+				}
+			}
+
+			glfwSwapBuffers(window);
+			glfwPollEvents();
+		}
+		gui_shader1->CleanUp();
+		//render_engine::loader::CleanUp();
+		return return_value;
+	}
+
+	/**
+	 * renders the models in the start-up scene
+	 */
+	void scene::Startup_Scene::render() 
+	{
+		render_engine::renderer::Prepare();
+
+		// Render GUI items
+		render_engine::renderer::Render(guis1, *gui_shader1);
+	}
+
+	/**
+	 * updates the variables for the start-up scene
+	 */
+	void scene::Startup_Scene::update(GLFWwindow* window)
+	{
+		for (gui::GuiTexture* button : guis1) {
+			gui::Button* new_button = ConvertGuiTextureToButton(button);
+			if (new_button != NULL)
+				new_button->Update(window);
+		}
+		bool hand_present;
+		objDetect.DetectHand(objDetect.ReadCamera(),hand_present);
+	}
+
+	/**
+	 * manages the key input in the start-up scene
+	 */
+	void scene::Startup_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
+	{
+		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+		{
+
+			return_value = scene::Scenes::INGAME;
+			cv::destroyWindow("camera");
+		}
+		else if (glfwGetKey(window, GLFW_KEY_BACKSPACE) == GLFW_PRESS) {
+			hand_mode = !hand_mode;
+		}
+	}
+
+	Startup_Scene::~Startup_Scene()
+	{
+		std::cout << "startup scene destructor" << std::endl;
+		delete gui_shader1;
+	}
+}

src/scenes/startup_Scene.h

@@ -0,0 +1,59 @@
+#pragma once
+#include "scene.h"
+#include "../gui/gui_element.h"
+
+namespace scene
+{
+	extern GLFWwindow* window;
+
+	class Startup_Scene : public scene::Scene
+	{
+	private:
+		//return_value is an enum that is necessary for the scene switching. Whenever this changes, the scene will change to a different scene.
+		scene::Scenes return_value = scene::Scenes::STARTUP;
+		void EnableHandMode();
+
+	public:
+		/**
+		 * @brief Constructor of the class Startup_Scene
+		 * 
+		 */
+		Startup_Scene();
+
+		~Startup_Scene();
+
+		/**
+		 * @brief 
+		 * 
+		 * @param window
+		 * @return 
+		 */
+		Scenes start(GLFWwindow* window) override;
+
+		/**
+		 * @brief 
+		 * 
+		 */
+		void render() override;
+
+		/**
+		 * @brief This method updates all the components on the window
+		 * 
+		 * @param window Window it updates
+		 */
+		void update(GLFWwindow* window) override;
+
+		/**
+		 * @brief Listener for key events
+		 * 
+		 * @param window Window it listens to for key events
+		 * @param key Key of event that is activated
+		 * @param scancode Code of Key
+		 * @param action 
+		 * @param mods
+		 */
+		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
+	};
+}
+
+

src/shaders/entity_shader.cpp

@@ -0,0 +1,224 @@
+#include "entity_shader.h"
+#include "../toolbox/toolbox.h"
+#include <deque>
+
+namespace shaders
+{
+	static std::string vertex_shader = R"(
+	#version 400 core
+	// The VertexShader is run for each vertex on the screen.
+
+
+	// Position of the vertex
+	in vec3 position;
+	// Coordinates of the texture
+	in vec2 texture_coords;
+	// The normal of the vertex
+	in vec3 normal;
+
+	// Equal to the texture_coords
+	out vec2 pass_texture_coords;
+	out vec3 surface_normal;
+	out vec3 to_light_vector[4];
+	out vec3 to_camera_vector;
+	out float visibility;
+
+	uniform mat4 model_matrix;
+	uniform mat4 projection_matrix;
+	uniform mat4 view_matrix;
+	uniform vec3 light_position[4];
+
+	const float density = 0.0017;
+	const float gradient = 3;
+	
+	void main(void)
+	{
+		// Calculate the real position of the vertex (after rotation and scaling)
+		vec4 world_position = model_matrix * vec4(position, 1.0);
+
+		vec4 position_rel_to_cam = view_matrix * world_position;
+	
+		// Tell OpenGL where to render the vertex
+		gl_Position = projection_matrix * position_rel_to_cam;
+
+		// Pass the textureCoords directly to the fragment shader
+		pass_texture_coords = texture_coords;
+
+		surface_normal = (model_matrix * vec4(normal, 0.0)).xyz;
+		for (int i = 0; i < 4; i++)
+		{
+			to_light_vector[i] = light_position[i] - world_position.xyz;
+		}
+		to_camera_vector = (inverse(view_matrix) * vec4(0.0, 0.0, 0.0, 1.0)).xyz - world_position.xyz;
+
+		// Calculate the density/visibility of the vertex with the fog
+		float distance = length(position_rel_to_cam.xyz);
+		visibility = exp(-pow((distance * density), gradient));
+		visibility = clamp(visibility, 0.0, 1.0);
+	}
+	)";
+	
+
+	static std::string fragment_shader = R"(
+	#version 400 core
+	// The FragmentShader is run for each pixel in a face on the screen.
+
+
+	// Interpolated textureCoordinates of the vertex (relative to the distance to each vertex)
+	in vec2 pass_texture_coords;
+
+	in vec3 surface_normal;
+	in vec3 to_light_vector[4];
+	in vec3 to_camera_vector;
+	in float visibility;
+
+	// Final color of the pixel
+	out vec4 out_color;
+
+	// The texture of the model
+	uniform sampler2D model_texture;
+
+	uniform vec3 light_color[4];
+	uniform vec3 attenuation[4];
+	uniform float shine_damper;
+	uniform float reflectivity;
+	uniform vec3 sky_color;
+
+	const float min_diffuse_lighting = 0.1;
+	
+	void main(void)
+	{
+		vec3 unit_normal = normalize(surface_normal);
+		vec3 unit_camera_vector = normalize(to_camera_vector);
+
+		vec3 total_diffuse = vec3(0.0);
+		vec3 total_specular = vec3(0.0);
+	
+		for (int i = 0; i < 4; i++)
+		{
+			float distance = length(to_light_vector[i]);
+			float att_factor = attenuation[i].x + (attenuation[i].y * distance) + (attenuation[i].z * distance * distance);
+	
+			vec3 unit_light_vector = normalize(to_light_vector[i]);
+
+			// Calculate the diffuse lighting
+			float dot_diffuse = dot(unit_normal, unit_light_vector);
+			float brightness = max(dot_diffuse, 0.0);
+
+			// Calculate the specular lighting
+			vec3 light_direction = -unit_light_vector;
+			vec3 reflected_light_direction = reflect(light_direction, unit_normal);
+			float dot_specular = dot(reflected_light_direction, unit_camera_vector);
+			dot_specular = max(dot_specular, 0.0);
+			float damped_specular = pow(dot_specular, shine_damper);
+		
+			total_diffuse = total_diffuse + (brightness * light_color[i]) / att_factor;
+			total_specular = total_specular + (damped_specular * reflectivity * light_color[i]) / att_factor;
+		}
+
+		total_diffuse = max(total_diffuse, min_diffuse_lighting);
+	
+		out_color = vec4(total_diffuse, 1.0) * texture(model_texture, pass_texture_coords) + vec4(total_specular, 1.0);
+		out_color = mix(vec4(sky_color, 1.0), out_color, visibility);
+	}
+	)";
+	
+	
+	EntityShader::EntityShader(): ShaderProgram(vertex_shader, fragment_shader)
+	{ }
+
+	void EntityShader::LoadModelMatrix(const glm::mat4& matrix) const
+	{
+		LoadMatrix(location_model_matrix, matrix);
+	}
+
+	void EntityShader::LoadProjectionMatrix(const glm::mat4& projection) const
+	{
+		LoadMatrix(location_projection_matrix, projection);
+	}
+
+	void EntityShader::LoadViewMatrix(entities::Camera& camera) const
+	{
+		const glm::mat4 view_matrix = toolbox::CreateViewMatrix(camera);
+		LoadMatrix(location_view_matrix, view_matrix);
+	}
+
+	void EntityShader::LoadLights(std::vector<entities::Light>& lights) const
+	{
+		for (int i = 0; i < MAX_LIGHTS; ++i)
+		{
+			if (i < lights.size())
+			{
+				LoadVector(location_light_position[i], lights[i].GetPosition());
+				LoadVector(location_light_color[i], lights[i].GetColor());
+				LoadVector(location_light_attenuation[i], lights[i].GetAttenuation());
+			} else
+			{
+				LoadVector(location_light_position[i], glm::vec3(0, 0, 0));
+				LoadVector(location_light_color[i], glm::vec3(0, 0, 0));
+				LoadVector(location_light_attenuation[i], glm::vec3(1, 0, 0));
+			}
+		}
+	}
+
+	void EntityShader::LoadLightsDeque(std::deque<entities::Light>& lights) const
+	{
+		for (int i = 0; i < MAX_LIGHTS; ++i)
+		{
+			if (i < lights.size())
+			{
+				LoadVector(location_light_position[i], lights[i].GetPosition());
+				LoadVector(location_light_color[i], lights[i].GetColor());
+				LoadVector(location_light_attenuation[i], lights[i].GetAttenuation());
+			}
+			else
+			{
+				LoadVector(location_light_position[i], glm::vec3(0, 0, 0));
+				LoadVector(location_light_color[i], glm::vec3(0, 0, 0));
+				LoadVector(location_light_attenuation[i], glm::vec3(1, 0, 0));
+			}
+		}
+	}
+
+	void EntityShader::LoadShineVariables(float shine_damper, float reflectivity) const
+	{
+		LoadFloat(location_shine_damper, shine_damper);
+		LoadFloat(location_reflectivity, reflectivity);
+	}
+
+	void EntityShader::LoadSkyColor(glm::vec3 sky_color) const
+	{
+		LoadVector(location_sky_color, sky_color);
+	}
+
+	void EntityShader::SetAttributes() const
+	{
+		// Load the position VBO and textureCoords VBO from the VAO into the shader "in" variables
+		SetAttribute(0, "position");
+		SetAttribute(1, "texture_coords");
+		SetAttribute(2, "normal");
+	}
+
+	void EntityShader::GetAllUniformLocations()
+	{
+		// Get the locations from the uniform variables from the shaders
+		location_model_matrix = GetUniformLocation("model_matrix");
+		location_projection_matrix = GetUniformLocation("projection_matrix");
+		location_view_matrix = GetUniformLocation("view_matrix");
+		location_shine_damper = GetUniformLocation("shine_damper");
+		location_reflectivity = GetUniformLocation("reflectivity");
+		location_sky_color = GetUniformLocation("sky_color");
+
+		for (int i = 0; i < MAX_LIGHTS; ++i)
+		{
+			std::string light_pos = std::string("light_position[") + std::to_string(i) + "]";
+			location_light_position[i] = GetUniformLocation(light_pos.c_str());
+
+			std::string light_color = std::string("light_color[") + std::to_string(i) + "]";
+			location_light_color[i] = GetUniformLocation(light_color.c_str());
+
+			std::string light_attenuation = std::string("attenuation[") + std::to_string(i) + "]";
+			location_light_attenuation[i] = GetUniformLocation(light_attenuation.c_str());
+		}
+	}
+}

src/shaders/entity_shader.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <glm/gtc/matrix_transform.hpp>
+#include <vector>
+#include <deque>
+#include "shader_program.h"
+#include "../entities/camera.h"
+#include "../entities/light.h"
+
+/*
+	This class handles the shaders for the entities.
+ */
+
+namespace shaders
+{	
+	class EntityShader : public ShaderProgram
+	{
+	private:
+		const static int MAX_LIGHTS = 4;
+		
+		GLuint location_model_matrix;
+		GLuint location_projection_matrix;
+		GLuint location_view_matrix;
+		GLuint location_light_position[MAX_LIGHTS];
+		GLuint location_light_color[MAX_LIGHTS];
+		GLuint location_light_attenuation[MAX_LIGHTS];
+		GLuint location_shine_damper;
+		GLuint location_reflectivity;
+		GLuint location_sky_color;
+		
+	public:
+		EntityShader();
+
+		/*
+		 * @brief: A method to load the model matrix into the shader
+		 *
+		 * @param matrix: The model matrix
+		 */
+		void LoadModelMatrix(const glm::mat4& matrix) const;
+
+		/*
+		 * @brief: A method to load the projection matrix into the shader
+		 *
+		 * @param projection: The projection matrix
+		 */
+		void LoadProjectionMatrix(const glm::mat4& projection) const;
+
+		/*
+		 * @brief: A method to load the view matrix (camera) into the shader
+		 *
+		 * @param camera: The camera which the scene needs to be rendered from
+		 */
+		void LoadViewMatrix(entities::Camera& camera) const;
+
+		/*
+		 * @brief: A method to load some lights into the shader
+		 *
+		 * @param lights: The lights
+		 */
+		void LoadLights(std::vector<entities::Light>& lights) const;
+
+		/**
+		 * @brief loads some lights contained in a deque.
+		 * 
+		 * @param lights the deque containing the lights to load
+		 */
+		void LoadLightsDeque(std::deque<entities::Light>& lights) const;
+
+		/*
+		 * @brief: A method to load the the shine variables from a model into the shader
+		 *
+		 * @param shine_damper: The dampening of the angle from when to render reflectivity on the vertex
+		 * @param reflectivity: The amount the model reflects
+		 */
+		void LoadShineVariables(float shine_damper, float reflectivity) const;
+
+		/*
+		 * @brief: A method to load the sky color into the shader. This color will be used for the fog
+		 *
+		 * @param sky_color: The color of the sky
+		 */
+		void LoadSkyColor(glm::vec3 sky_color) const;
+			
+	protected:
+		void SetAttributes() const override;
+		void GetAllUniformLocations() override;
+	};
+}

src/shaders/gui_shader.cpp

@@ -0,0 +1,57 @@
+#include "gui_shader.h"
+
+namespace shaders
+{
+	static std::string vertex_shader = R"(
+	#version 140
+
+	in vec2 position;
+
+	out vec2 texture_coords;
+
+	uniform mat4 model_matrix;
+
+	void main(void)
+	{
+		gl_Position = model_matrix * vec4(position, 0.0, 1.0);
+	
+		// This makes top left corner coordinate (0, 0) and bottom right (1, 1)
+		texture_coords = vec2((position.x + 1.0) / 2.0, 1 - (position.y + 1.0) / 2.0);
+	}
+	)";
+
+
+	static std::string fragment_shader = R"(
+	#version 140
+
+	in vec2 texture_coords;
+
+	out vec4 out_color;
+
+	uniform sampler2D gui_texture;
+
+	void main(void)
+	{
+		out_color = texture(gui_texture, texture_coords);
+	}
+	)";
+
+	
+	GuiShader::GuiShader() : ShaderProgram(vertex_shader, fragment_shader)
+	{ }
+
+	void GuiShader::LoadModelMatrix(const glm::mat4& matrix) const
+	{
+		LoadMatrix(location_model_matrix, matrix);
+	}
+
+	void GuiShader::SetAttributes() const
+	{
+		SetAttribute(0, "position");
+	}
+
+	void GuiShader::GetAllUniformLocations()
+	{
+		location_model_matrix = GetUniformLocation("model_matrix");
+	}
+}

src/shaders/gui_shader.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <glm/gtc/matrix_transform.hpp>
+#include "shader_program.h"
+
+namespace shaders
+{
+	/*
+	 * This class handles the shaders for all the GUI items
+	 */
+	
+	class GuiShader : public ShaderProgram
+	{
+	private:
+		GLuint location_model_matrix;
+
+	public:
+		GuiShader();
+
+		/*
+		 * @brief: A method to load the model matrix into the shader
+		 *
+		 * @param matrix: The model matrix
+		 */
+		void LoadModelMatrix(const glm::mat4& matrix) const;
+
+	protected:
+		void SetAttributes() const override;
+		void GetAllUniformLocations() override;
+	};
+}

src/shaders/shader_program.cpp

@@ -1,4 +1,5 @@
 #include <GL/glew.h>
+#include <GLFW/glfw3.h>
 #include <iostream>
 #include <fstream>
 #include <vector>

src/shaders/shader_program.h

@@ -21,29 +21,87 @@ namespace shaders
 		ShaderProgram(std::string& vertex_shader, std::string& fragment_shader);
 		virtual ~ShaderProgram() = default;
 
-		// Call this function after making the shaderprogram (sets all the attributes of the shader)
+		/*
+		 * @brief: Call this function after making the shaderprogram (sets all the attributes of the shader)
+		 */
 		void Init();
-		// Call this function before rendering
+
+		/*
+		 * @brief: Call this function before rendering
+		 */
 		void Start() const;
-		// Call this function after rendering
+
+		/*
+		 * @brief: Call this function after rendering
+		 */
 		void Stop() const;
-		// Call this function when closing the application
+		
+		/*
+		 * @brief: Call this function when closing the application
+		 */
 		void CleanUp() const;
 
 	protected:
-		// Set the inputs of the vertex shader
+		/*
+		 * @brief: Set the inputs of the vertex shader
+		 */
 		virtual void SetAttributes() const = 0;
+
+		/*
+		 * @brief: Sets/binds a input variable (in) to a VBO from the model
+		 *
+		 * @param attribute: The id of the VBO
+		 * @param variable_name: The name of the "in" variable in the shader
+		 */
 		void SetAttribute(const GLuint attribute, const char* variable_name) const;
 
-		// Loads value's (uniform variables) into the shader
+		/*
+		 * @brief: This function loads a float value into a uniform variable into the shader
+		 *
+		 * @param location: The location of the variable in openGL
+		 * @param value: The value which will be loaded into the variable
+		 */
 		void LoadFloat(GLuint location, GLfloat value) const;
+
+		/*
+		 * @brief: This function loads a vector value into a uniform variable into the shader
+		 *
+		 * @param location: The location of the variable in openGL
+		 * @param vector: The value which will be loaded into the variable
+		 */
 		void LoadVector(GLuint location, glm::vec3 vector) const;
+
+		/*
+		 * @brief: This function loads a 4x4 matrix value into a uniform variable into the shader
+		 *
+		 * @param location: The location of the variable in openGL
+		 * @param matrix: The value which will be loaded into the variable
+		 */
 		void LoadMatrix(GLuint location, glm::mat4 matrix) const;
 
+		/*
+		 * @brief: This function will get all the locations of each uniform variable
+		 */
 		virtual void GetAllUniformLocations() = 0;
+
+		/*
+		 * @brief: This function will retrieve the location of a uniform variable
+		 *
+		 * @param uniform_name: The name of the uniform variable
+		 *
+		 * @return: The location of the uniform variable
+		 */
 		GLuint GetUniformLocation(const GLchar* uniform_name) const;
 	
 	private:
+		/*
+		 * @brief: This function will load a shader into openGL
+		 *
+		 * @param shader_string: The shader as a string (the whole code)
+		 * @param type: The type of the shader (Vertex/Fragment)
+		 *
+		 * @return: The id of the shader given by openGL
+		 */
 		GLuint LoadShader(const std::string& shader_string, GLuint type) const;
 	};
 }

src/shaders/static_shader.cpp

@@ -1,87 +0,0 @@
-#include "static_shader.h"
-#include "../toolbox/toolbox.h"
-
-namespace shaders
-{
-	static std::string vertex_shader = R"(
-	#version 400 core
-	// The VertexShader is run for each vertex on the screen.
-
-
-	// Position of the vertex
-	in vec3 position;
-	// Coordinates of the texture
-	in vec2 texture_coords;
-
-	// Equal to the texture_coords
-	out vec2 pass_texture_coords;
-
-	uniform mat4 model_matrix;
-	uniform mat4 projection_matrix;
-	uniform mat4 view_matrix;
-
-	void main(void)
-	{
-		// Tell OpenGL where to render the vertex
-		gl_Position = projection_matrix * view_matrix * model_matrix * vec4(position, 1.0);
-
-		// Pass the texture_coords directly to the fragment shader
-		pass_texture_coords = texture_coords;
-	}
-	)";
-	
-
-	static std::string fragment_shader = R"(
-	#version 400 core
-	// The FragmentShader is run for each pixel in a face on the screen.
-
-
-	// Interpolated textureCoordinates of the vertex (relative to the distance to each vertex)
-	in vec2 pass_texture_coords;
-
-	// Final color of the pixel
-	out vec4 out_color;
-
-	// The texture of the model
-	uniform sampler2D texture_sampler;
-
-	void main(void)
-	{
-		out_color = texture(texture_sampler, pass_texture_coords);
-	}
-	)";
-	
-	
-	StaticShader::StaticShader(): ShaderProgram(vertex_shader, fragment_shader)
-	{
-	}
-
-	void StaticShader::LoadModelMatrix(const glm::mat4& matrix) const
-	{
-		LoadMatrix(location_model_matrix, matrix);
-	}
-
-	void StaticShader::LoadProjectionMatrix(const glm::mat4& projection) const
-	{
-		LoadMatrix(location_projection_matrix, projection);
-	}
-
-	void StaticShader::LoadViewMatrix(entities::Camera& camera) const
-	{
-		const glm::mat4 view_matrix = toolbox::CreateViewMatrix(camera);
-		LoadMatrix(location_view_matrix, view_matrix);
-	}
-
-	void StaticShader::SetAttributes() const
-	{
-		SetAttribute(0, "position");
-		SetAttribute(1, "texture_coords");
-	}
-
-	void StaticShader::GetAllUniformLocations()
-	{
-		location_model_matrix = GetUniformLocation("model_matrix");
-		location_projection_matrix = GetUniformLocation("projection_matrix");
-		location_view_matrix = GetUniformLocation("view_matrix");
-	}
-}

src/shaders/static_shader.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <glm/gtc/matrix_transform.hpp>
-#include "shader_program.h"
-#include "../entities/camera.h"
-
-/*
-	This class does represents the shaders for the models.
- */
-
-namespace shaders
-{	
-	class StaticShader : public ShaderProgram
-	{
-	private:
-		GLuint location_model_matrix;
-		GLuint location_projection_matrix;
-		GLuint location_view_matrix;
-		
-	public:
-		StaticShader();
-
-		void LoadModelMatrix(const glm::mat4& matrix) const;
-		void LoadProjectionMatrix(const glm::mat4& projection) const;
-		void LoadViewMatrix(entities::Camera& camera) const;
-			
-	protected:
-		void SetAttributes() const override;
-		void GetAllUniformLocations() override;
-	};
-}

src/toolbox/Timer.h

@@ -0,0 +1,48 @@
+#pragma once
+
+namespace toolbox
+{
+	/*
+	 * This class represents a timer which needs to be updated
+	 * every frame to work correctly.
+	 */
+	class Timer
+	{
+	private:
+		float current_time;
+		float final_time;
+		bool has_finished;
+
+	public:
+		/*
+		 * @brief: Constructor to make the timer
+		 *
+		 * @param final_time: The time which the timer needs to count to
+		 */
+		Timer(float final_time): current_time(0), final_time(final_time), has_finished(false) {}
+
+		/*
+		 * @brief: Updates the timer. Call this method once every iteration in the game loop
+		 *
+		 * @param delta: The deltatime of the game
+		 */
+		void UpdateTimer(const double delta)
+		{
+			current_time += delta;
+			
+			if (current_time >= final_time)
+			{
+				has_finished = true;
+			}
+		}
+
+		/*
+		 * @brief: Returns if the timer has finished
+		 *
+		 * @return: True if the timer has finished 
+		 */
+		bool HasFinished() const { return has_finished; }
+
+		void Reset() { current_time = 0; }
+	};
+}

src/toolbox/toolbox.cpp

@@ -1,7 +1,16 @@
+#include <ctime>
 #include "toolbox.h"
-
+#include <iostream>
 namespace toolbox
 {
+	glm::mat4 CreateModelMatrix(glm::vec2 translation, glm::vec2 scale)
+	{
+		glm::mat4 matrix(1.0f);
+		matrix = glm::translate(matrix, glm::vec3(translation.x, translation.y, 0));
+		matrix = glm::scale(matrix, glm::vec3(scale.x, scale.y, 0));
+		return matrix;
+	}
+
 	glm::mat4 CreateModelMatrix(glm::vec3 translation, glm::vec3 rotation, float scale)
 	{
 		glm::mat4 matrix(1.0f);
@@ -23,4 +32,36 @@ namespace toolbox
 		matrix = glm::translate(matrix, negative_cam_pos);
 		return matrix;
 	}
+		float Lerp(float from, float to, float amount)
+	{
+		return from + amount * (to - from);
+	}
+
+	glm::vec3 Lerp(glm::vec3 from, glm::vec3 to, float amount)
+	{
+		glm::vec3 final;
+		final.x = Lerp(from.x, to.x, amount);
+		final.y = Lerp(from.y, to.y, amount);
+		final.z = Lerp(from.z, to.z, amount);
+		return final;
+  }
+  
+	int Random(const int min, const int max)
+	{
+		static bool first = true;
+		if (first)
+		{
+			srand(time(0));
+			first = false;
+		}
+		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,13 +2,90 @@
 
 #include "../entities/camera.h"
 #include <glm/gtc/matrix_transform.hpp>
+#include <vector>
 
 namespace toolbox
 {
-	#define WINDOW_WIDTH 1400.0f
+	// Window macro's
-	#define WINDOW_HEIGT 800.0f
+	    #define DEFAULT_WIDTH 1920
+		#define DEFAULT_HEIGHT 1080
 
+		// Change these macros to change the window size
+		#define WINDOW_WIDTH 1400.0f
+		#define WINDOW_HEIGHT 800.0f
+
+		#define SCALED_WIDTH (WINDOW_WIDTH/DEFAULT_WIDTH)
+		#define SCALED_HEIGHT (WINDOW_HEIGHT/DEFAULT_HEIGHT)
+	//
+	
+	/*
+	 * @brief: This function will create a model matrix
+	 *
+	 * @param translation: The position of the model
+	 * @param scale: The scale of the model
+	 *
+	 * @return: The model matrix of the model
+	 */
+	glm::mat4 CreateModelMatrix(glm::vec2 translation, glm::vec2 scale);
+	
+	/*
+	 * @brief: This function will create a model matrix
+	 *
+	 * @param translation: The position of the model
+	 * @param rotation: The rotation of the model
+	 * @param scale: The scale of the model
+	 *
+	 * @return: The model matrix of the model
+	 */
 	glm::mat4 CreateModelMatrix(glm::vec3 translation, glm::vec3 rotation, float scale);
 
+	/*
+	 * @brief: This function will create a view matrix from the camera's position
+	 *
+	 * @param camera: The camera the view matrix needs to be made from
+	 *
+	 * @return: The view matrix
+	 */
 	glm::mat4 CreateViewMatrix(entities::Camera& camera);
+
+	/*
+	* @biref go to one coordinate to another with smooting
+	*
+	* @param from one coordinate of the start
+	* @param to one coordinate of where to go
+	* @param amount the amount of smoothing (lower is smoother)
+	* 
+	* @return coordinate of where to go
+	*/
+	float Lerp(float from, float to, float amount);
+
+	/*
+	* @biref go from one position to another with smoothing
+	*
+	* @param from position of the start
+	* @param to position of where to go
+	* @param amount the amount of smoothing (lower is smoother)
+	*
+	* @return position of where to go
+	*/
+	glm::vec3 Lerp(glm::vec3 from, glm::vec3 to, float amount);
+  
+  /*
+	 * @brief: This function will return a value between min and max
+	 *
+	 * @param min: The min value
+	 * @param max: The max value
+	 *
+	 * @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,41 +19,81 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="src\computervision\FaceDetector.cpp" />
+    <ClCompile Include="src\model_Storage.cpp" />
-    <ClCompile Include="src\computervision\ObjectDetection.cpp" />
+    <ClCompile Include="src\collision\collision_handler.cpp" />
-    <ClCompile Include="src\computervision\SkinDetector.cpp" />
+    <ClCompile Include="src\entities\main_character.cpp" />
-    <ClCompile Include="src\computervision\FingerCount.cpp" />
+    <ClCompile Include="src\entities\house_generator.cpp" />
-    <ClCompile Include="src\computervision\BackgroundRemover.cpp" />
+    <ClCompile Include="src\computervision\calibration\HandCalibrator.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\object_detection.cpp" />
+    <ClCompile Include="src\computervision\skin_detector.cpp" />
+    <ClCompile Include="src\computervision\finger_count.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" />
+    <ClCompile Include="src\gui\gui_interactable.cpp" />
     <ClCompile Include="src\main.cpp" />
     <ClCompile Include="src\renderEngine\loader.cpp" />
     <ClCompile Include="src\renderEngine\obj_loader.cpp" />
     <ClCompile Include="src\renderEngine\renderer.cpp" />
+    <ClCompile Include="src\scenes\loading_Scene.cpp" />
+    <ClCompile Include="src\scenes\scene.cpp" />
+    <ClCompile Include="src\shaders\gui_shader.cpp" />
     <ClCompile Include="src\shaders\shader_program.cpp" />
-    <ClCompile Include="src\shaders\static_shader.cpp" />
+    <ClCompile Include="src\shaders\entity_shader.cpp" />
     <ClCompile Include="src\toolbox\toolbox.cpp" />
+    <ClCompile Include="src\scenes\startup_Scene.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\computervision\FaceDetector.h" />
+    <ClInclude Include="src\model_Storage.h" />
-    <ClInclude Include="src\computervision\FingerCount.h" />
+    <ClInclude Include="src\collision\collision.h" />
-    <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\collision\collision_handler.h" />
-    <ClInclude Include="src\computervision\SkinDetector.h" />
+    <ClInclude Include="src\entities\main_character.h" />
-    <ClInclude Include="src\computervision\ObjectDetection.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\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\StaticCameraInstance.h" />
+    <ClInclude Include="src\computervision\finger_count.h" />
+    <ClInclude Include="src\computervision\background_remover.h" />
+    <ClInclude Include="src\computervision\MenuTest.h" />
+    <ClInclude Include="src\computervision\skin_detector.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" />
+    <ClInclude Include="src\entities\light.h" />
+    <ClInclude Include="src\gui\gui_element.h" />
+    <ClInclude Include="src\gui\gui_interactable.h" />
     <ClInclude Include="src\models\model.h" />
     <ClInclude Include="src\renderEngine\loader.h" />
     <ClInclude Include="src\renderEngine\obj_loader.h" />
     <ClInclude Include="src\renderEngine\renderer.h" />
+    <ClInclude Include="src\shaders\gui_shader.h" />
     <ClInclude Include="src\shaders\shader_program.h" />
-    <ClInclude Include="src\shaders\static_shader.h" />
+    <ClInclude Include="src\shaders\entity_shader.h" />
     <ClInclude Include="src\stb_image.h" />
+    <ClInclude Include="src\toolbox\Timer.h" />
     <ClInclude Include="src\toolbox\toolbox.h" />
+    <ClInclude Include="src\scenes\startup_Scene.h" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\Avans Hogeschool\Kim Veldhoen - Proftaak 2.4\pose_iter_160000.caffemodel" />
+    <None Include="res\pose\coco\pose_deploy_linevec.prototxt" />
+    <None Include="res\pose\mpi\pose_deploy_linevec_faster_4_stages.prototxt" />
+    <None Include="res\pose\mpi\pose_iter_160000.caffemodel" />
+  </ItemGroup>
   <PropertyGroup Label="Globals">
     <VCProjectVersion>16.0</VCProjectVersion>
     <ProjectGuid>{A7ECF1BE-DB22-4BF7-BFF6-E3BF72691EE6}</ProjectGuid>
@@ -112,14 +152,18 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>C:\opencv\build\include;$(IncludePath)</IncludePath>
+    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
-    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath)</LibraryPath>
+    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);;C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
+    <IncludePath>C:\opencv\build\include\;$(VC_IncludePath);$(WindowsSDK_IncludePath);C:\opencv\opencv\build\include</IncludePath>
+    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -151,7 +195,7 @@
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SolutionDir)lib\glfw-3.3.2\$(Platform);$(SolutionDir)lib\glew-2.1.0\lib\Release\$(Platform);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -192,6 +236,8 @@
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SolutionDir)lib\glfw-3.3.2\$(Platform);$(SolutionDir)lib\glew-2.1.0\lib\Release\$(Platform);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
+      <AdditionalDependencies>opencv_world452.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

wk2_fps.vcxproj.filters

@@ -1,18 +1,36 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <Filter Include="Source Files">
+    <ClCompile Include="src\collision\collision_handler.cpp" />
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+    <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
-      <Extensions>cpp;c;cc;cxx;c++;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    <ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
-    </Filter>
+    <ClCompile Include="src\computervision\object_detection.cpp" />
-    <Filter Include="Header Files">
+    <ClCompile Include="src\computervision\OpenPoseVideo.cpp" />
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+    <ClCompile Include="src\computervision\skin_detector.cpp" />
-      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
+    <ClCompile Include="src\computervision\finger_count.cpp" />
-    </Filter>
+    <ClCompile Include="src\computervision\background_remover.cpp" />
-    <Filter Include="Resource Files">
+    <ClCompile Include="src\entities\camera.cpp" />
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+    <ClCompile Include="src\entities\collision_entity.cpp" />
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    <ClCompile Include="src\entities\entity.cpp" />
-    </Filter>
+    <ClCompile Include="src\gui\gui_interactable.cpp" />
+    <ClCompile Include="src\main.cpp" />
+    <ClCompile Include="src\renderEngine\loader.cpp" />
+    <ClCompile Include="src\renderEngine\obj_loader.cpp" />
+    <ClCompile Include="src\renderEngine\renderer.cpp" />
+    <ClCompile Include="src\shaders\gui_shader.cpp" />
+    <ClCompile Include="src\shaders\shader_program.cpp" />
+    <ClCompile Include="src\shaders\entity_shader.cpp" />
+    <ClCompile Include="src\toolbox\toolbox.cpp" />
+    <ClCompile Include="src\scenes\startup_Scene.cpp" />
+    <ClCompile Include="src\computervision\calibration\HandCalibrator.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">
@@ -33,15 +51,33 @@
     <ClCompile Include="src\shaders\shader_program.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\shaders\static_shader.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="src\renderEngine\obj_loader.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="src\toolbox\toolbox.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\shaders\entity_shader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\shaders\gui_shader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\gui\gui_interactable.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\scenes\in_Game_Scene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\scenes\startup_Scene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\entities\collision_entity.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\collision\collision_handler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="src\computervision\ObjectDetection.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -51,61 +87,79 @@
     <ClCompile Include="src\computervision\FingerCount.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\computervision\FaceDetector.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="src\computervision\BackgroundRemover.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\entities\Camera.h">
+    <ClInclude Include="src\collision\collision.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\collision\collision_handler.h" />
-    </ClInclude>
+    <ClInclude Include="src\scenes\in_Game_Scene.h" />
-    <ClInclude Include="src\entities\Entity.h">
+    <ClInclude Include="src\scenes\scene.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\computervision\async\StaticCameraInstance.h" />
-    </ClInclude>
+    <ClInclude Include="src\computervision\FingerCount.h" />
-    <ClInclude Include="src\models\Model.h">
+    <ClInclude Include="src\computervision\BackgroundRemover.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\computervision\SkinDetector.h" />
-    </ClInclude>
+    <ClInclude Include="src\computervision\ObjectDetection.h" />
-    <ClInclude Include="src\renderEngine\Loader.h">
+    <ClInclude Include="src\entities\camera.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\entities\collision_entity.h" />
-    </ClInclude>
+    <ClInclude Include="src\entities\entity.h" />
-    <ClInclude Include="src\renderEngine\Renderer.h">
+    <ClInclude Include="src\entities\light.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\gui\gui_element.h" />
-    </ClInclude>
+    <ClInclude Include="src\gui\gui_interactable.h" />
-    <ClInclude Include="src\stb_image.h">
+    <ClInclude Include="src\models\model.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\renderEngine\loader.h" />
-    </ClInclude>
+    <ClInclude Include="src\renderEngine\obj_loader.h" />
-    <ClInclude Include="src\shaders\shader_program.h">
+    <ClInclude Include="src\renderEngine\renderer.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\shaders\gui_shader.h" />
-    </ClInclude>
+    <ClInclude Include="src\shaders\shader_program.h" />
-    <ClInclude Include="src\shaders\static_shader.h">
+    <ClInclude Include="src\shaders\entity_shader.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\stb_image.h" />
-    </ClInclude>
+    <ClInclude Include="src\toolbox\Timer.h" />
-    <ClInclude Include="src\renderEngine\obj_loader.h">
+    <ClInclude Include="src\toolbox\toolbox.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\scenes\startup_Scene.h" />
-    </ClInclude>
+    <ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
-    <ClInclude Include="src\toolbox\toolbox.h">
+    <ClInclude Include="src\computervision\hand_detect_region.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
-    </ClInclude>
+    <ClInclude Include="src\collision\collision.h" />
-    <ClInclude Include="src\computervision\ObjectDetection.h">
+    <ClInclude Include="src\collision\collision_handler.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\entities\main_character.h" />
-    </ClInclude>
+    <ClInclude Include="src\entities\house_generator.h" />
-    <ClInclude Include="src\computervision\SkinDetector.h">
+    <ClInclude Include="src\scenes\in_Game_Scene.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\scenes\scene.h" />
-    </ClInclude>
+    <ClInclude Include="src\computervision\finger_count.h" />
-    <ClInclude Include="src\computervision\FingerCount.h">
+    <ClInclude Include="src\computervision\background_remover.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\computervision\MenuTest.h" />
-    </ClInclude>
+    <ClInclude Include="src\computervision\skin_detector.h" />
-    <ClInclude Include="src\computervision\FaceDetector.h">
+    <ClInclude Include="src\computervision\object_detection.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\entities\camera.h" />
-    </ClInclude>
+    <ClInclude Include="src\entities\collision_entity.h" />
-    <ClInclude Include="src\computervision\BackgroundRemover.h">
+    <ClInclude Include="src\entities\entity.h" />
-      <Filter>Header Files</Filter>
+    <ClInclude Include="src\entities\light.h" />
-    </ClInclude>
+    <ClInclude Include="src\gui\gui_element.h" />
+    <ClInclude Include="src\gui\gui_interactable.h" />
+    <ClInclude Include="src\models\model.h" />
+    <ClInclude Include="src\renderEngine\loader.h" />
+    <ClInclude Include="src\renderEngine\obj_loader.h" />
+    <ClInclude Include="src\renderEngine\renderer.h" />
+    <ClInclude Include="src\shaders\gui_shader.h" />
+    <ClInclude Include="src\shaders\shader_program.h" />
+    <ClInclude Include="src\shaders\entity_shader.h" />
+    <ClInclude Include="src\stb_image.h" />
+    <ClInclude Include="src\toolbox\Timer.h" />
+    <ClInclude Include="src\toolbox\toolbox.h" />
+    <ClInclude Include="src\scenes\startup_Scene.h" />
+    <ClInclude Include="src\scenes\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" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\Avans Hogeschool\Kim Veldhoen - Proftaak 2.4\pose_iter_160000.caffemodel" />
+    <None Include="res\pose\coco\pose_deploy_linevec.prototxt" />
+    <None Include="res\pose\mpi\pose_deploy_linevec_faster_4_stages.prototxt" />
+    <None Include="res\pose\mpi\pose_iter_160000.caffemodel" />
+  </ItemGroup>
 </Project>