[ADD] skeleton code for different scenes

.gitignore

@@ -2,8 +2,6 @@
 # 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
@@ -430,6 +428,4 @@ 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

@@ -1,44 +0,0 @@
-#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

@@ -1,44 +0,0 @@
-#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

@@ -1,18 +0,0 @@
-#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.cpp

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

src/computervision/FaceDetector.cpp

@@ -0,0 +1,53 @@
+#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

@@ -0,0 +1,31 @@
+#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.cpp

@@ -1,4 +1,4 @@
-#include "finger_count.h"
+#include "FingerCount.h"
 
 #include "opencv2/imgproc.hpp"
 #include "opencv2/highgui.hpp"
@@ -14,7 +14,6 @@
 
 namespace computervision
 {
-
 	FingerCount::FingerCount(void) {
 		color_blue = Scalar(255, 0, 0);
 		color_green = Scalar(0, 255, 0);
@@ -36,6 +35,9 @@ 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
@@ -43,7 +45,7 @@ namespace computervision
 			return contours_image;
 
 		// find the biggest contour (let's suppose it's our hand)
-		biggest_contour_index = -1;
+		int biggest_contour_index = -1;
 		double biggest_area = 0.0;
 
 		for (int i = 0; i < contours.size(); i++) {
@@ -149,21 +151,9 @@ 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/FingerCount.h

@@ -24,22 +24,7 @@ namespace computervision
 		 */
 		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;
@@ -49,8 +34,6 @@ namespace computervision
 		Scalar color_yellow;
 		Scalar color_purple;
 
-		int amount_of_fingers;
-
 		/**
 		 * @brief finds the distance between 2 points.
 		 * 
@@ -123,7 +106,5 @@ namespace computervision
 		 * @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/MenuTest.cpp

@@ -1,25 +0,0 @@
-#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

@@ -1,18 +0,0 @@
-
-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

@@ -0,0 +1,91 @@
+
+#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

@@ -0,0 +1,53 @@
+#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.cpp

@@ -1,5 +1,4 @@
-#include "skin_detector.h"
-#include <iostream>
+#include "SkinDetector.h"
 
 /*
  Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
@@ -23,8 +22,8 @@ namespace computervision
 	void SkinDetector::drawSkinColorSampler(Mat input) {
 		int frameWidth = input.size().width, frameHeight = input.size().height;
 
-		int rectangleSize = 25;
-		Scalar rectangleColor = Scalar(0, 255, 255);
+		int rectangleSize = 20;
+		Scalar rectangleColor = Scalar(255, 0, 255);
 
 		skinColorSamplerRectangle1 = Rect(frameWidth / 5, frameHeight / 2, rectangleSize, rectangleSize);
 		skinColorSamplerRectangle2 = Rect(frameWidth / 5, frameHeight / 3, rectangleSize, rectangleSize);
@@ -42,29 +41,6 @@ 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;
@@ -78,19 +54,6 @@ 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;
@@ -112,39 +75,6 @@ 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/SkinDetector.h

@@ -24,9 +24,6 @@ namespace computervision
 		*/
 		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
 		* 
@@ -34,10 +31,6 @@ namespace computervision
 		*/
 		void calibrate(Mat input);
 
-		std::vector<int> calibrateAndReturn(Mat input);
-
-		void setTresholds(std::vector<int>& tresholds);
-
 		/*
 		* @brief gets the mask for the hand
 		* 
@@ -70,8 +63,6 @@ namespace computervision
 		*/
 		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.

src/computervision/async/StaticCameraInstance.h

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

src/computervision/calibration/HandCalibrator.cpp

@@ -1,91 +0,0 @@
-
-#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

@@ -1,76 +0,0 @@
-#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/hand_detect_region.cpp

@@ -1,157 +0,0 @@
-
-#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

@@ -1,73 +0,0 @@
-#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

@@ -1,203 +0,0 @@
-
-#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

@@ -1,109 +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>
-#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/entities/Camera.cpp

@@ -1,6 +1,4 @@
 #include "camera.h"
-#include <iostream>
-#include "../toolbox/toolbox.h"
 
 namespace entities
 {
@@ -9,52 +7,26 @@ 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)
 		{
-			movement_speed -= SPEED;
+			position.z -= SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
 		{
-			movement_speed += SPEED;
+			position.z += SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
 		{
-			side_speed += SPEED;
+			position.x += SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
 		{
-			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;
+			position.x -= SPEED;
+		}
 	}
 }

src/entities/Camera.h

@@ -1,42 +1,23 @@
 #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:
-		// The movement speed of the camera
-		const float SPEED = 0.5f;
-		const float UP_SPEED = 1.0f;
+		const float SPEED = 0.02f;
 		
 		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,7 +23,5 @@ namespace entities
 		this->rotation.y += rotation.y;
 		this->rotation.z += rotation.z;
 	}
-
-
 }
 

src/entities/Entity.h

@@ -5,15 +5,10 @@
 
 namespace entities
 {
-	/*
-	 * This class represents a movable model in the game
-	 */
-	
 	class Entity
 	{
-	protected:
+	private:
 		models::TexturedModel model;
-		
 		glm::vec3 position;
 		glm::vec3 rotation;
 		float scale;
@@ -21,18 +16,7 @@ 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;}
@@ -40,7 +24,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; }
-		void SetRotation(const ::glm::vec3& rotation) { this->rotation = rotation; }
+		inline 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

@@ -1,49 +0,0 @@
-#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

@@ -1,68 +0,0 @@
-#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

@@ -1,131 +0,0 @@
-#include "house_generator.h"
-
-#include <functional>
-#include <iostream>
-
-#include "../renderEngine/obj_loader.h"
-#include "../renderEngine/Loader.h"
-#include "../toolbox/toolbox.h"
-#include "collision_entity.h"
-
-namespace entities
-{
-	HouseGenerator::HouseGenerator()
-	{
-	}
-
-	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

@@ -1,50 +0,0 @@
-#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

@@ -1,30 +0,0 @@
-#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

@@ -1,108 +0,0 @@
-#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

@@ -1,43 +0,0 @@
-#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

@@ -1,34 +0,0 @@
-#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

@@ -1,118 +0,0 @@
-#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

@@ -1,130 +0,0 @@
-#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,60 +1,47 @@
 #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 <map>
 
 #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/entity_shader.h"
+#include "shaders/static_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/object_detection.h"
-#include "scenes/game_Over_Scene.h"
-#include "entities/collision_entity.h"
-#include "computervision/object_detection.h"
+#include "scenes/scene.h"
+#include "scenes/startupScene.h"
+#include "scenes/inGameScene.h"
+
+#include "computervision/ObjectDetection.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;
+//Scene management variables
+std::map<Scenes, Scene*> scenes;
+Scene* current_scene = nullptr;
 
-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_HEIGHT, "SDBA", NULL, NULL);
+    window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGT, "SDBA", NULL, NULL);
     if (!window)
     {
         glfwTerminate();
@@ -64,69 +51,65 @@ 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)
         {
+            current_scene->onKey(key, scancode, action, mods);
 	        if (key == GLFW_KEY_ESCAPE)
-            {
 	            glfwSetWindowShouldClose(window, true);
-            }
-    	
-            current_scene->onKey(window, key, scancode, action, mods);
         });
 	
-    bool window_open = true;
+    scenes[Scenes::STARTUP] = new StartupScene();
+    scenes[Scenes::INGAME] = new InGameScene();
 	
+    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));
+
+    // create object detection object instance
+    computervision::ObjectDetection objDetect;
+    
+    
+    // set up object detection
+    //objDetect.setup();
+
+    current_scene->start();
 	// Main game loop
-	while (!glfwWindowShouldClose(window) && window_open)
+	while (!glfwWindowShouldClose(window))
 	{
         // Update
         const double delta = UpdateDelta();
+        entity.IncreaseRotation(glm::vec3(0, 1, 0));
+        camera.Move(window);
+        current_scene->update(window);
 
-        scene::Scenes return_value = current_scene->start(window);
-        delete current_scene;
+		// Render
+        render_engine::renderer::Prepare();
+        shader.Start();
+        shader.LoadViewMatrix(camera);
+        current_scene->render();
+        render_engine::renderer::Render(entity, shader);
 
-        switch (return_value) {
-            case scene::Scenes::STOP:
-                window_open = false;
-                break;
-
-            case scene::Scenes::LOADING:
-                current_scene = new scene::Loading_Scene();
-                break;
-
-            case scene::Scenes::STARTUP:
-                current_scene = new scene::Startup_Scene();
-                break;
-
-		
-            case scene::Scenes::INGAME:
-                current_scene = new scene::In_Game_Scene(&score);
-                break;
-                
-            case scene::Scenes::GAMEOVER:
-                current_scene = new scene::Game_Over_Scene(score);
-                break;
-
-            default:
-                std::cout << "Wrong return value!!! ->" << std::endl;
-                break;
-        }
+        //objDetect.setup();
+        objDetect.calculateDifference();
 
 		// Finish up
-		//shader.Stop();
+        shader.Stop();
 		glfwSwapBuffers(window);
 		glfwPollEvents();
-           
 	}
 
-	// Clean up -> preventing memory leaks!!!
-    std::cout << "ending..." << std::endl;
+	// Clean up
+    shader.CleanUp();
     render_engine::loader::CleanUp();
+    current_scene->stop();
 	glfwTerminate();
     return 0;
 }

src/model_Storage.cpp

@@ -1,205 +0,0 @@
-#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

@@ -1,137 +0,0 @@
-#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,36 +1,28 @@
 #pragma once
 
 #include <GL/glew.h>
-#include <glm/gtc/matrix_transform.hpp>
 
 namespace models
 {
 	/*
-		Structure for storing a vboID and vertex_count (this representa a mesh without a model).
+		Structure for storing a vboID and vertex_count.
 
-		vao_id = The openGL id of the model
-		vertex_count = The amount of vertices in the model
-		model_size = The size on each axis of the model
+		This structure represents a Bare bones Model (A mesh without a texture).
+		The vao_id, points to an ID stored by openGL and the
+		vertex_count is how many triangles in the mesh there are.
 	*/
 	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,10 +1,7 @@
 #include <GL/glew.h>
-#include <glm/vec3.hpp>
 #include "../stb_image.h"
 #include "loader.h"
 
-#include <iostream>
-
 namespace render_engine
 {
 	namespace loader
@@ -12,38 +9,22 @@ 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 normals and indices.
+			This function will generate a Model from vertex positions, textureCoordinates and indices.
 		*/
-		models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<float>& normals, std::vector<unsigned int>& indices)
+		struct models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<unsigned int>& indices)
 		{
-			const GLuint vao_id = CreateVao();
+			GLuint vao_id = CreateVao();
 			BindIndicesBuffer(indices);
 			StoreDataInAttributeList(0, 3, positions);
 			StoreDataInAttributeList(1, 2, texture_coords);
-			StoreDataInAttributeList(2, 3, normals);
 			glBindVertexArray(0);
-			
-			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 };
+			return { vao_id, static_cast<int>(indices.size()) };
 		}
 
 		/*
@@ -59,12 +40,6 @@ 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);
 			
@@ -138,72 +113,5 @@ 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,36 +9,17 @@ namespace render_engine
 	namespace loader
 	{
 		/*
-		*	@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
+			This function generates a model from model data.
 		*/
-		models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<float>& normals, std::vector<unsigned int>& indices);
+		struct models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<unsigned int>& indices);
 
 		/*
-		 * @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
+			Loads a texture from a file into openGL using stb_image.h
 		 */
 		GLuint LoadTexture(std::string file_name);
 		
 		/*
-		*	@brief: Call this function when cleaning up all the meshes (when exiting the program).
+			Call this function when cleaning up all the meshes (when exiting the program).
 		*/
 		void CleanUp();
 	}

src/renderEngine/Renderer.cpp

@@ -1,10 +1,8 @@
 #include <GL/glew.h>
 #include <glm/gtc/matrix_transform.hpp>
 #include "../models/model.h"
-#include "loader.h"
-#include "../toolbox/toolbox.h"
 #include "renderer.h"
-#include <iostream>
+#include "../toolbox/toolbox.h"
 
 namespace render_engine
 {
@@ -14,27 +12,17 @@ namespace render_engine
 		static const float NEAR_PLANE = 0.01f;
 		static const float FAR_PLANE = 1000.0f;
 
-		// GUI variables
-		static models::RawModel quad;
-		
-		
-		void Init(shaders::EntityShader& shader)
+		/*
+			This function will load the projectionMatrix into the shader
+		 */
+		void Init(shaders::StaticShader& 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);
+				glm::perspective(glm::radians(FOV), (WINDOW_WIDTH / WINDOW_HEIGT), 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);
 		}
 
 		/*
@@ -44,164 +32,36 @@ namespace render_engine
 		{
 			glEnable(GL_DEPTH_TEST);
 			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-			glClearColor(SKY_COLOR.r, SKY_COLOR.g, SKY_COLOR.b, 1.0f);
+			glClearColor(0.3f, 0.4f, 0.6f, 1.0f);
 		}
 
 		/*
 			This function will Render a Model on the screen.
 		*/
-		void Render(std::shared_ptr<entities::Entity> entity, shaders::EntityShader& shader)
+		void Render(entities::Entity& entity, shaders::StaticShader& shader)
 		{
-			const models::TexturedModel model = entity.get()->GetModel();
-			const models::RawModel raw_model = model.raw_model;
-			const models::ModelTexture texture = model.texture;
+			const models::TexturedModel model = entity.GetModel();
+			const models::RawModel rawModel = model.raw_model;
 
-			// Enable the model (VAO)
-			glBindVertexArray(raw_model.vao_id);
+			// Enable the model
+			glBindVertexArray(rawModel.vao_id);
 
-			// Enable the VBO's from the model (VAO)
+			// Enable the inputs for the vertexShader
 			glEnableVertexAttribArray(0);
 			glEnableVertexAttribArray(1);
-			glEnableVertexAttribArray(2);
 
 			// Load the transformation of the model into the shader
-			const glm::mat4 modelMatrix = toolbox::CreateModelMatrix(entity.get()->GetPosition(), entity.get()->GetRotation(), entity.get()->GetScale());
+			const glm::mat4 modelMatrix = toolbox::CreateModelMatrix(entity.GetPosition(), entity.GetRotation(), entity.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, raw_model.vertex_count, GL_UNSIGNED_INT, 0);
+			glDrawElements(GL_TRIANGLES, rawModel.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,61 +1,25 @@
 #pragma once
 
-#include <memory>
-#include "../gui/gui_element.h"
 #include "../entities/entity.h"
-#include "../shaders/entity_shader.h"
-#include "../shaders/gui_shader.h"
+#include "../shaders/static_shader.h"
 
 namespace render_engine
 {
 	namespace renderer
 	{
-		const glm::vec3 SKY_COLOR = { 0.3f, 0.4f, 0.6f };
-		
 		/*
-			@brief: Call this function when starting the program
-
-			@param shader: The shader to render the entities with
+			Call this function when starting the program
 		 */
-		void Init(shaders::EntityShader& shader);
+		void Init(shaders::StaticShader& shader);
 		
 		/*
-			@brief: Call this function before rendering.
-					This function will enable culling and load the projectionMatrix into the shader.
+			Call this function before rendering. 
 		*/
 		void Prepare();
 
 		/*
-			@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
+			Call this function when wanting to Render a mesh to the screen.
 		*/
-		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);
+		void Render(entities::Entity& entity, shaders::StaticShader& shader);
 	}
 }

src/renderEngine/obj_loader.cpp

@@ -6,8 +6,6 @@
 #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;
@@ -111,8 +109,7 @@ namespace render_engine
                 break;
             }
         }
-        }
-        catch (const std::exception& e)
+    } catch (const std::exception& e)
     {
     	// Always go in here
     }
@@ -128,6 +125,5 @@ namespace render_engine
         vertex_array[p++] = vertex.z;
     }
 
-        return render_engine::loader::LoadToVAO(vertex_array, texture_array, normal_array, indices);
-    }
+    return render_engine::loader::LoadToVAO( vertex_array, texture_array, indices);
 }

src/renderEngine/obj_loader.h

@@ -3,12 +3,4 @@
 #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

@@ -1,185 +0,0 @@
-#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

@@ -1,37 +0,0 @@
-#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/inGameScene.cpp

@@ -0,0 +1,30 @@
+#include "inGameScene.h"
+#include <GLFW/glfw3.h>
+
+void start()
+{
+
+}
+
+void stop()
+{
+
+}
+
+void render()
+{
+
+}
+
+void update(GLFWwindow* window)
+{
+
+}
+
+void onKey(int key, int scancode, int action, int mods)
+{
+	/**
+	* misschien iets van als niet in settings dan hoeft alleen escape een knop zijn als reserve optie. Als wel in settings, dan heb je hetzelfde hoe je in het in het begin scherm hebt.
+	**/
+}
+

src/scenes/inGameScene.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "scene.h"
+class InGameScene : public Scene
+{
+private:
+
+
+public:
+	virtual void start() override;
+	virtual void stop() override;
+	virtual void render() override;
+	virtual void update(GLFWwindow* window) override;
+	virtual void onKey(int key, int scancode, int action, int mods) override;
+};
+

src/scenes/in_Game_Scene.cpp

@@ -1,410 +0,0 @@
-#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

@@ -1,160 +0,0 @@
-#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

@@ -1,146 +0,0 @@
-#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

@@ -1,67 +0,0 @@
-#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

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

src/scenes/scene.h

@@ -1,60 +1,23 @@
 #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 start() = 0;
+	virtual void stop() = 0;
 	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) {};
-
+	virtual void onKey(int key, int scancode, int action, int mods) {};
+};
+
+
+
+enum class Scenes
+{
+	STARTUP,
+	INGAME,
+	GAMEOVER,
+	SETTINGS,
+	CALIBRATION
 };
-}

src/scenes/startupScene.cpp

@@ -0,0 +1,31 @@
+#include "startupScene.h"
+#include <GLFW/glfw3.h>
+
+void start() 
+{
+
+}
+
+void stop() 
+{
+
+}
+
+void render() 
+{
+
+}
+
+void update(GLFWwindow* window) 
+{
+
+}
+
+void onKey(int key, int scancode, int action, int mods) 
+{
+	if (key == GLFW_KEY_DOWN && action == GLFW_RELEASE)
+	{
+		//ideetje voor het scrollen door het menu heen
+		menuIndex = (menuIndex + 1) % 4;
+	}
+}

src/scenes/startupScene.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "scene.h"
+class StartupScene : public Scene
+{
+private:
+	int menuIndex;
+
+public:
+	virtual void start() override;
+	virtual void stop() override;
+	virtual void render() override;
+	virtual void update(GLFWwindow* window) override;
+	virtual void onKey(int key, int scancode, int action, int mods) override;
+};
+

src/scenes/startup_Scene.cpp

@@ -1,230 +0,0 @@
-#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

@@ -1,59 +0,0 @@
-#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

@@ -1,224 +0,0 @@
-#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

@@ -1,88 +0,0 @@
-#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

@@ -1,57 +0,0 @@
-#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

@@ -1,31 +0,0 @@
-#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,5 +1,4 @@
 #include <GL/glew.h>
-#include <GLFW/glfw3.h>
 #include <iostream>
 #include <fstream>
 #include <vector>

src/shaders/shader_program.h

@@ -21,87 +21,29 @@ namespace shaders
 		ShaderProgram(std::string& vertex_shader, std::string& fragment_shader);
 		virtual ~ShaderProgram() = default;
 
-		/*
-		 * @brief: Call this function after making the shaderprogram (sets all the attributes of the shader)
-		 */
+		// Call this function after making the shaderprogram (sets all the attributes of the shader)
 		void Init();
-
-		/*
-		 * @brief: Call this function before rendering
-		 */
+		// Call this function before rendering
 		void Start() const;
-
-		/*
-		 * @brief: Call this function after rendering
-		 */
+		// Call this function after rendering
 		void Stop() const;
-		
-		/*
-		 * @brief: Call this function when closing the application
-		 */
+		// Call this function when closing the application
 		void CleanUp() const;
 
 	protected:
-		/*
-		 * @brief: Set the inputs of the vertex shader
-		 */
+		// 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;
 
-		/*
-		 * @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
-		 */
+		// Loads value's (uniform variables) into the shader
 		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

@@ -0,0 +1,87 @@
+#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

@@ -0,0 +1,31 @@
+#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

@@ -1,48 +0,0 @@
-#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,16 +1,7 @@
-#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);
@@ -32,36 +23,4 @@ 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,90 +2,13 @@
 
 #include "../entities/camera.h"
 #include <glm/gtc/matrix_transform.hpp>
-#include <vector>
 
 namespace toolbox
 {
-	// Window macro's
-	    #define DEFAULT_WIDTH 1920
-		#define DEFAULT_HEIGHT 1080
+	#define WINDOW_WIDTH 1400
+	#define WINDOW_HEIGT 800
 	
-		// 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,81 +19,47 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="src\model_Storage.cpp" />
-    <ClCompile Include="src\collision\collision_handler.cpp" />
-    <ClCompile Include="src\entities\main_character.cpp" />
-    <ClCompile Include="src\entities\house_generator.cpp" />
-    <ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
-    <ClCompile Include="src\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\scenes\inGameScene.cpp" />
+    <ClCompile Include="src\scenes\scene.cpp" />
+    <ClCompile Include="src\computervision\FaceDetector.cpp" />
+    <ClCompile Include="src\computervision\ObjectDetection.cpp" />
+    <ClCompile Include="src\computervision\SkinDetector.cpp" />
+    <ClCompile Include="src\computervision\FingerCount.cpp" />
+    <ClCompile Include="src\computervision\BackgroundRemover.cpp" />
     <ClCompile Include="src\entities\camera.cpp" />
-    <ClCompile Include="src\entities\collision_entity.cpp" />
     <ClCompile Include="src\entities\entity.cpp" />
-    <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\entity_shader.cpp" />
+    <ClCompile Include="src\shaders\static_shader.cpp" />
     <ClCompile Include="src\toolbox\toolbox.cpp" />
-    <ClCompile Include="src\scenes\startup_Scene.cpp" />
+    <ClCompile Include="src\scenes\startupScene.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\model_Storage.h" />
-    <ClInclude Include="src\collision\collision.h" />
-    <ClInclude Include="src\collision\collision_handler.h" />
-    <ClInclude Include="src\entities\main_character.h" />
-    <ClInclude Include="src\entities\house_generator.h" />
-    <ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
-    <ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
-    <ClInclude Include="src\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\inGameScene.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\computervision\FaceDetector.h" />
+    <ClInclude Include="src\computervision\FingerCount.h" />
+    <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\computervision\SkinDetector.h" />
+    <ClInclude Include="src\computervision\ObjectDetection.h" />
     <ClInclude Include="src\entities\camera.h" />
-    <ClInclude Include="src\entities\collision_entity.h" />
     <ClInclude Include="src\entities\entity.h" />
-    <ClInclude Include="src\entities\light.h" />
-    <ClInclude Include="src\gui\gui_element.h" />
-    <ClInclude Include="src\gui\gui_interactable.h" />
     <ClInclude Include="src\models\model.h" />
     <ClInclude Include="src\renderEngine\loader.h" />
     <ClInclude Include="src\renderEngine\obj_loader.h" />
     <ClInclude Include="src\renderEngine\renderer.h" />
-    <ClInclude Include="src\shaders\gui_shader.h" />
     <ClInclude Include="src\shaders\shader_program.h" />
-    <ClInclude Include="src\shaders\entity_shader.h" />
+    <ClInclude Include="src\shaders\static_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\startupScene.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>
@@ -152,18 +118,16 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
-    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
+    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include</IncludePath>
+    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\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>
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);;C:\opencv\opencv\build\include</IncludePath>
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -195,7 +159,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); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
+      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies); opencv_world452.lib</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -236,8 +200,7 @@
       <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>
+      <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</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

wk2_fps.vcxproj.filters

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