[ADD] added comments to startup_scene.h

you can switch between mouse and hand detection now

.gitignore

@@ -428,4 +428,6 @@ FodyWeavers.xsd
 **/docs/*
 **/doc/*
 
+**/pose_iter_160000.caffemodel
+
 # End of https://www.toptal.com/developers/gitignore/api/c++,visualstudio,visualstudiocode,opencv

src/collision/collision.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#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;
+	};
+
+	/*
+	 * This structure represents a collision between 2 entities
+	 *
+	 * entity1:		The first entity
+	 * entity2:		The second entity
+	 */
+	struct Collision
+	{
+		entities::Entity& entity1;
+		entities::Entity& entity2;
+	};
+}

src/collision/collision_handler.cpp

@@ -0,0 +1,40 @@
+#include "collision_handler.h"
+
+namespace collision
+{
+	void CheckCollisions(std::vector<entities::CollisionEntity*>& entities)
+	{
+		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++)
+		{			
+		 	entities::CollisionEntity* entity = entities[i];
+		 	
+		 	for (int j = i + 1; i < entities.size() - 1; j++)
+		 	{
+		 		entities::CollisionEntity* entity2 = entities[j];
+		 		
+		 		if (entity == entity2)
+		 		{
+		 			continue;
+		 		}
+		 		
+		 		if (entity->IsColliding(*entity2))
+		 		{
+		 			collision::Collision c = { *entity, *entity2 };
+		 			entity->OnCollide(c);
+		 			entity2->OnCollide(c);
+		 			break;
+		 		}
+		 	}
+		}
+	}
+}

src/collision/collision_handler.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <vector>
+#include "../entities/collision_entity.h"
+#include "collision.h"
+
+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::vector<entities::CollisionEntity*>& entities);
+}

src/computervision/FingerCount.cpp

@@ -151,9 +151,16 @@ 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;
 	}
 
+	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,6 +24,13 @@ 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();
+
 	private:
 		// colors to use
 		Scalar color_blue;
@@ -34,6 +41,8 @@ namespace computervision
 		Scalar color_yellow;
 		Scalar color_purple;
 
+		int amount_of_fingers;
+
 		/**
 		 * @brief finds the distance between 2 points.
 		 * 

src/computervision/MenuTest.cpp

@@ -0,0 +1,25 @@
+#include "MenuTest.h"
+#include <iostream>
+
+namespace computervision 
+{
+	int menu_item_array[4] = { 1, 2, 3, 4 };
+	float item_number = 0;
+
+	MenuTest::MenuTest(void) {
+		
+	}
+
+	int MenuTest::GetMenuItem(bool hand_state) {
+		item_number += 0.20f;
+
+		
+		int temp_item_number = item_number;
+		//If temp_item_number is equal to the size of the array, set item_number bac to zero to loop through the array again
+		if (temp_item_number == sizeof(menu_item_array) / sizeof(menu_item_array[0])) {
+			item_number = 0;
+		}
+
+		return menu_item_array[temp_item_number];
+	}
+}

src/computervision/MenuTest.h

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

src/computervision/ObjectDetection.cpp

@@ -1,4 +1,8 @@
 
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/video.hpp>
+
 #include "ObjectDetection.h"
 #include "BackgroundRemover.h"
 #include "SkinDetector.h"
@@ -11,51 +15,63 @@ namespace computervision
 
 	cv::Mat img, imgGray, img2, img2Gray, img3, img4;
 
+	int handMaskStartXPos, handMaskStartYPos, handMaskWidth, handMaskHeight;
+	bool handMaskGenerated = false;
+
 	Mat frame, frameOut, handMask, foreground, fingerCountDebug;
 	BackgroundRemover backgroundRemover;
 	SkinDetector skinDetector;
 	FaceDetector faceDetector;
 	FingerCount fingerCount;
 
-
 	ObjectDetection::ObjectDetection()
 	{
 	}
 
-	bool ObjectDetection::setup() 
+	cv::Mat ObjectDetection::readCamera() {
-	{
+		cap.read(img);
-		if (!cap.isOpened()) {
+		return img;
-			cout << "Can't find camera!" << endl;
-			return false;
 	}
 
-		cap.read(frame);
+	bool ObjectDetection::detectHand(Mat cameraFrame)
-		frameOut = frame.clone();
+	{
+		Mat inputFrame = generateHandMaskSquare(cameraFrame);
+		frameOut = inputFrame.clone();
 
+		// detect skin color
 		skinDetector.drawSkinColorSampler(frameOut);
 
-		foreground = backgroundRemover.getForeground(frame);
+		// remove background from image
+		foreground = backgroundRemover.getForeground(inputFrame);
 
-		faceDetector.removeFaces(frame, foreground);
+		// detect the hand contours
 		handMask = skinDetector.getSkinMask(foreground);
+
+		// count the amount of fingers and put the info on the matrix
 		fingerCountDebug = fingerCount.findFingersCount(handMask, frameOut);
 
-		//backgroundRemover.calibrate(frame);
+		// get the amount of fingers
+		int fingers_amount = fingerCount.getAmountOfFingers();
 
+		// draw the hand rectangle on the camera input, and draw text showing if the hand is open or closed.
+		drawHandMaskRect(&cameraFrame);
+		string hand_text = fingers_amount > 0 ? "open" : "closed";
+		putText(cameraFrame,hand_text, Point(10, 75), FONT_HERSHEY_PLAIN, 2.0, Scalar(255, 0, 255),3);
+		imshow("camera", cameraFrame);
 
-		imshow("output", frameOut);
+		//imshow("output", frameOut);
-		imshow("foreground", foreground);
+		//imshow("foreground", foreground);
-		imshow("handMask", handMask);
+		//imshow("handMask", handMask);
-		imshow("handDetection", fingerCountDebug);
+		//imshow("handDetection", fingerCountDebug);
 
 		int key = waitKey(1);
 
-		if (key == 98) // b
+		if (key == 98) // b, calibrate the background
-			backgroundRemover.calibrate(frame);
+			backgroundRemover.calibrate(inputFrame);
-		else if (key == 115) // s
+		else if (key == 115) // s, calibrate the skin color
-			skinDetector.calibrate(frame);
+			skinDetector.calibrate(inputFrame);
 
-		return true;
+		return fingers_amount > 0;
 	}
 
 	void ObjectDetection::calculateDifference()
@@ -72,14 +88,32 @@ namespace computervision
 		imshow("threshold", img4);
 	}
 
-	void ObjectDetection::detect()
-	{
-		int key = waitKey(1);
 
-		if (key == 98) // b
+	cv::Mat ObjectDetection::generateHandMaskSquare(cv::Mat img)
-			backgroundRemover.calibrate(frame);
+	{
-		else if (key == 115) // s
+		handMaskStartXPos = 20;
-			skinDetector.calibrate(frame);
+		handMaskStartYPos = img.rows / 5;
+		handMaskWidth = img.cols / 3;
+		handMaskHeight = img.cols / 3;
+
+
+		cv::Mat mask = cv::Mat::zeros(img.size(), img.type());
+		cv::Mat dstImg = cv::Mat::zeros(img.size(), img.type());
+
+		cv::rectangle(mask, Rect(handMaskStartXPos, handMaskStartYPos, handMaskWidth, handMaskHeight), Scalar(255, 255, 255), -1);
+
+		img.copyTo(dstImg, mask);
+
+		handMaskGenerated = true;
+		return dstImg;
+
+	}
+
+	bool ObjectDetection::drawHandMaskRect(cv::Mat* input)
+	{
+		if (!handMaskGenerated) return false;
+		rectangle(*input, Rect(handMaskStartXPos, handMaskStartYPos, handMaskWidth, handMaskHeight), Scalar(255, 255, 255));
+		return true;
 	}
 
 	void ObjectDetection::showWebcam()

src/computervision/ObjectDetection.h

@@ -22,13 +22,7 @@ namespace computervision
 		 * 
 		 */
 		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
 		 * 
@@ -40,11 +34,36 @@ namespace computervision
 		 * 
 		 */
 		void calculateDifference();
+
 		/**
-		 * @brief Listens for keypresses and handles them
+		 * @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
 		 */
-		void detect();
+		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
+		 * @return true if hand is open, false if hand is closed
+		 */
+		bool detectHand(cv::Mat cameraFrame);
+
+		/**
+		 * @brief draws the hand mask rectangle on the given input matrix.
+		 * 
+		 * @param input the input matrix to draw the rectangle on
+		 */
+		bool drawHandMaskRect(cv::Mat *input);
 
 	};
 

src/computervision/SkinDetector.cpp

@@ -22,7 +22,7 @@ namespace computervision
 	void SkinDetector::drawSkinColorSampler(Mat input) {
 		int frameWidth = input.size().width, frameHeight = input.size().height;
 
-		int rectangleSize = 20;
+		int rectangleSize = 25;
 		Scalar rectangleColor = Scalar(255, 0, 255);
 
 		skinColorSamplerRectangle1 = Rect(frameWidth / 5, frameHeight / 2, rectangleSize, rectangleSize);

src/entities/Camera.cpp

@@ -9,24 +9,42 @@ namespace entities
 
 	void Camera::Move(GLFWwindow* window)
 	{
+		float movement_speed = 0;
+		
 		if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
 		{
-			position.z -= SPEED;
+			movement_speed -= SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
 		{
-			position.z += SPEED;
+			movement_speed += SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
 		{
-			position.x += SPEED;
+			rotation.y += ROT_SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
 		{
-			position.x -= SPEED;
+			rotation.y -= ROT_SPEED;
-		}
+		}
+
+		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+		{
+			rotation.x -= ROT_SPEED;
+		}
+
+		if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
+		{
+			rotation.x += ROT_SPEED;
+		}
+
+		float dx = glm::cos(glm::radians(rotation.y + 90)) * movement_speed;
+		float dz = glm::sin(glm::radians(rotation.y + 90)) * movement_speed;
+
+		position.x += dx;
+		position.z += dz;
 	}
 }

src/entities/Camera.h

@@ -1,14 +1,20 @@
 #pragma once
-
+#include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
 
 namespace entities
 {
+	/*
+	 * This class represents the viewport of the game. The whole game is seen through this class
+	 */
+	
 	class Camera
 	{
 	private:
-		const float SPEED = 0.02f;
+		// The movement speed of the camera
+		const float SPEED = 0.52f;
+		const float ROT_SPEED = 1.0f;
 		
 		glm::vec3 position;
 		glm::vec3 rotation;
@@ -16,6 +22,11 @@ namespace entities
 	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);
 		
 		inline glm::vec3 GetPosition() const{ return position; }

src/entities/Entity.h

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

src/entities/collision_entity.cpp

@@ -0,0 +1,44 @@
+#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;
+		max_xyz = glm::vec3(min_xyz.x + size.x, min_xyz.y + size.y, min_xyz.z + size.z);
+	}
+}

src/entities/collision_entity.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "entity.h"
+#include "../collision/collision.h"
+
+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);
+
+	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(void (*function)(const collision::Collision& collision))
+		{ if (function != nullptr) { on_collide = function; } }
+
+	protected:
+
+		/*
+		 * @brief: This method moves the collision to the center of the entity
+		 */
+		void MoveCollisionBox();
+	};
+}

src/entities/light.h

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

src/gui/gui_element.h

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

src/gui/gui_interactable.cpp

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

src/gui/gui_interactable.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include <iostream>
+#include <glm/gtc/matrix_transform.hpp>
+#include "../toolbox/toolbox.h"
+#include "gui_element.h"
+
+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:
+		void (*on_click_action)();
+		void (*on_enter_action)();
+		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(void (*fun)()) { on_click_action = fun; }
+
+		/*
+		 * @brief: This function sets an action (function pointer) to the OnEnter function
+		 *
+		 * @param fun: A function pointer to a function (or lambda)
+		 */
+		void SetOnEnterAction(void (*fun)()) { on_enter_action = fun; }
+
+		/*
+		 * @brief: This function sets an action (function pointer) to the OnExit function
+		 *
+		 * @param fun: A function pointer to a function (or lambda)
+		 */
+		void SetOnExitAction(void (*fun)()) { on_exit_action = fun; }
+
+		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

@@ -2,26 +2,28 @@
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
 #define STB_IMAGE_IMPLEMENTATION
+#include <iostream>
+#include <map>
+
 #include "stb_image.h"
 #include <ostream>
-#include <map>
+#include <stdlib.h>
+#include <iostream>
 
 #include <opencv2/core.hpp>
 #include <opencv2/videoio.hpp>
 #include <opencv2/video.hpp>
 
+#include "gui/gui_interactable.h"
 #include "models/model.h"
 #include "renderEngine/loader.h"
 #include "renderEngine/obj_loader.h"
 #include "renderEngine/renderer.h"
-#include "shaders/static_shader.h"
+#include "shaders/entity_shader.h"
 #include "toolbox/toolbox.h"
-
 #include "scenes/scene.h"
-#include "scenes/startupScene.h"
+#include "scenes/in_Game_Scene.h"
-#include "scenes/inGameScene.h"
+#include "scenes/startup_Scene.h"
-
-#include "computervision/ObjectDetection.h"
 
 #pragma comment(lib, "glfw3.lib")
 #pragma comment(lib, "glew32s.lib")
@@ -31,17 +33,14 @@ static double UpdateDelta();
 
 static GLFWwindow* window;
 
-//Scene management variables
+scene::Scene* current_scene;
-std::map<Scenes, Scene*> scenes;
-Scene* current_scene = nullptr;
-
 
 int main(void)
 {
 #pragma region OPENGL_SETTINGS
 	if (!glfwInit())
 		throw "Could not inditialize glwf";
-    window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGT, "SDBA", NULL, NULL);
+	window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "SDBA", NULL, NULL);
 	if (!window)
 	{
 		glfwTerminate();
@@ -52,64 +51,60 @@ int main(void)
 	glGetError();
 #pragma endregion
 
+    
+    current_scene = new scene::Startup_Scene();
+
     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);
         });
 
-    scenes[Scenes::STARTUP] = new StartupScene();
+    bool window_open = true;
-    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))
+	while (!glfwWindowShouldClose(window) && window_open)
 	{
         //Update
         const double delta = UpdateDelta();
-        entity.IncreaseRotation(glm::vec3(0, 1, 0));
-        camera.Move(window);
-        current_scene->update(window);
 
-		// Render
+        scene::Scenes return_value = current_scene->start(window);
-        render_engine::renderer::Prepare();
+        delete current_scene;
-        shader.Start();
-        shader.LoadViewMatrix(camera);
-        current_scene->render();
-        render_engine::renderer::Render(entity, shader);
 
-        //objDetect.setup();
+        switch (return_value) {
-        objDetect.calculateDifference();
+            case scene::Scenes::STOP:
+                window_open = false;
+                break;
 
-		// Finish up
+            case scene::Scenes::STARTUP:
-        shader.Stop();
+                current_scene = new scene::Startup_Scene();
-		glfwSwapBuffers(window);
+                break;
-		glfwPollEvents();
+
+		
+            case scene::Scenes::INGAME:
+                current_scene = new scene::In_Game_Scene();
+                break;
+                
+            default:
+                std::cout << "Wrong return value!!! ->" << std::endl;
+                break;
         }
         
-	// Clean up
+		// Finish up
-    shader.CleanUp();
+		//shader.Stop();
-    render_engine::loader::CleanUp();
+		glfwSwapBuffers(window);
-    current_scene->stop();
+		glfwPollEvents();
+           
+	}
+
+	// Clean up -> preventing memory leaks!!!
+    std::cout << "ending..." << std::endl;
 	glfwTerminate();
 	return 0;
 }

src/models/Model.h

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

src/renderEngine/Loader.cpp

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

src/renderEngine/Loader.h

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

src/renderEngine/Renderer.cpp

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

src/renderEngine/Renderer.h

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

src/renderEngine/obj_loader.cpp

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

src/renderEngine/obj_loader.h

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

src/scenes/inGameScene.cpp

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

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

@@ -0,0 +1,118 @@
+#include <iostream>
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include "in_Game_Scene.h"
+#include "startup_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"
+
+
+namespace scene
+{
+	std::vector<entities::Entity> entities;
+	std::vector<entities::Light> lights;
+	models::RawModel raw_model;
+	models::ModelTexture texture;
+	shaders::EntityShader *shader;
+	shaders::GuiShader *gui_shader;
+	entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
+	std::vector<gui::GuiTexture*> guis;
+
+	
+	In_Game_Scene::In_Game_Scene()
+	{
+		shader = new shaders::EntityShader;
+		shader->Init();	
+		render_engine::renderer::Init(*shader);
+
+		gui_shader = new shaders::GuiShader();
+		gui_shader->Init();
+	}
+
+	scene::Scenes scene::In_Game_Scene::start(GLFWwindow* window)
+	{
+		raw_model = render_engine::LoadObjModel("res/House.obj");
+		texture = { render_engine::loader::LoadTexture("res/Texture.png") };
+		texture.shine_damper = 10;
+		texture.reflectivity = 0;
+		models::TexturedModel model = { raw_model, texture };
+		
+		int z = 0;
+		for (int i = 0; i < 5; ++i)
+		{
+			entities.push_back(entities::Entity(model, glm::vec3(0, -50, -50 - z), glm::vec3(0, 90, 0), 20));
+			z += (raw_model.model_size.x * 20);
+		}
+
+		lights.push_back(entities::Light(glm::vec3(0, 1000, -7000), glm::vec3(5, 5, 5)));
+		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(0.25f, 0.25f));
+		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);
+	
+
+		while (return_value == scene::Scenes::INGAME)
+		{
+			update(window);
+			button.Update(window);
+			render();
+
+			glfwSwapBuffers(window);
+			glfwPollEvents();
+		}
+		shader->CleanUp();
+		gui_shader->CleanUp();
+		render_engine::loader::CleanUp();
+		return return_value;
+	}
+
+	void scene::In_Game_Scene::render()
+	{
+		// Render
+		render_engine::renderer::Prepare();
+
+		shader->Start();
+		shader->LoadSkyColor(render_engine::renderer::SKY_COLOR);
+		shader->LoadLights(lights);
+		shader->LoadViewMatrix(camera);
+
+		// Renders each entity in the entities list
+		for (entities::Entity& entity : entities)
+		{
+			render_engine::renderer::Render(entity, *shader);
+		}
+
+		// Render GUI items
+		render_engine::renderer::Render(guis, *gui_shader);
+
+		// Stop rendering the entities
+		shader->Stop();
+	}
+
+	void scene::In_Game_Scene::update(GLFWwindow* window)
+	{
+		camera.Move(window);
+	}
+
+	void scene::In_Game_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
+	{
+		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+		{
+			return_value = scene::Scenes::STOP;
+		}
+	}
+
+}

src/scenes/in_Game_Scene.h

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

src/scenes/scene.cpp

@@ -1 +0,0 @@
-#include "scene.h"

src/scenes/scene.h

@@ -1,23 +1,31 @@
 #pragma once
+#include <GL/glew.h>
 #include <GLFW/glfw3.h>
-
+#include <map>
-class Scene
-{
-public:
-	virtual void start() = 0;
-	virtual void stop() = 0;
-	virtual void render() = 0;
-	virtual void update(GLFWwindow* window) = 0;
-	virtual void onKey(int key, int scancode, int action, int mods) {};
-};
 
 
+namespace scene {
 
 	enum class Scenes
 	{
 		STARTUP,
 		INGAME,
 		GAMEOVER,
-	SETTINGS,
+		CALIBRATION,
-	CALIBRATION
+		STOP
 	};
+
+	class Scene
+	{
+	public:
+		virtual Scenes start(GLFWwindow* window) = 0;
+		virtual void render() = 0;
+		virtual void update(GLFWwindow* window) = 0;
+		virtual void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) {};
+
+	};
+
+	
+}
+
+

src/scenes/startupScene.cpp

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

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

@@ -0,0 +1,194 @@
+#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/ObjectDetection.h"
+
+
+
+
+namespace scene
+{
+	shaders::GuiShader* gui_shader1;
+	std::vector<gui::GuiTexture*> guis1;
+
+	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();
+	}
+
+	gui::Button* ConvertGuiTextureToButton(gui::GuiTexture* texture) {
+		if (texture != NULL)
+			if (texture->GetType() == gui::GuiType::BUTTON) {
+				
+				gui::Button* button = (gui::Button*)texture;
+				return button;
+			}
+			else {
+				return NULL;
+			}
+	}
+
+	/*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.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 == 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.6f), glm::vec2(0.25f, 0.25f));
+		button_start.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_start1_hover.png"));
+		button_start.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_start1_click.png"));
+		button_start.SetOnClickAction([]()
+			{
+				std::cout << "Clicked on button: Start!" << std::endl;
+				
+			});
+		guis1.push_back(&button_start);
+
+		gui::Button button_calibrate(render_engine::loader::LoadTexture("res/menu_item_calibrate1.png"), glm::vec2(0.0f, 0.0f), glm::vec2(0.25f, 0.25f));
+		button_calibrate.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_calibrate1_hover.png"));
+		button_calibrate.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_calibrate1_click.png"));
+		button_calibrate.SetOnClickAction([]()
+			{
+				std::cout << "Clicked on button: Calibrate!" << std::endl;
+
+			});
+		guis1.push_back(&button_calibrate);
+
+		gui::Button button_quit(render_engine::loader::LoadTexture("res/menu_item_quit1.png"), glm::vec2(0.0f, -0.6f), glm::vec2(0.25f, 0.25f));
+		button_quit.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_hover.png"));
+		button_quit.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_click.png"));
+		button_quit.SetOnClickAction([]()
+			{
+				std::cout << "Clicked on button: Quit!" << std::endl;
+			});
+		guis1.push_back(&button_quit);
+
+		computervision::ObjectDetection objDetect;
+		cv::Mat cameraFrame;
+		gui::GuiTexture* chosen_item = NULL; //This is the selected menu_item
+		bool hand_closed = false; //Flag to prevent multiple button presses
+		
+		while (return_value == scene::Scenes::STARTUP)
+		{
+			render();
+			update(window);
+			
+			if (hand_mode) {
+				cameraFrame = objDetect.readCamera();
+
+				//Get hand state from camera
+				bool hand_detection = objDetect.detectHand(cameraFrame);
+
+				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;
+	}
+
+	void scene::Startup_Scene::render() 
+	{
+		render_engine::renderer::Prepare();
+
+		// Render GUI items
+		render_engine::renderer::Render(guis1, *gui_shader1);
+	}
+
+	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);
+		}
+	}
+
+	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;
+		}
+		else if (glfwGetKey(window, GLFW_KEY_BACKSPACE) == GLFW_PRESS) {
+			hand_mode = !hand_mode;
+		}
+	}
+}

src/scenes/startup_Scene.h

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

src/shaders/entity_shader.cpp

@@ -0,0 +1,204 @@
+#include "entity_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;
+	// 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 = 4;
+	
+	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::LoadShineVariables(float shine_damper, float reflectivity) const
+	{
+		LoadFloat(location_shine_damper, shine_damper);
+		LoadFloat(location_reflectivity, reflectivity);
+	}
+
+	void EntityShader::LoadSkyColor(glm::vec3 sky_color) const
+	{
+		LoadVector(location_sky_color, sky_color);
+	}
+
+	void EntityShader::SetAttributes() const
+	{
+		// Load the position VBO and textureCoords VBO from the VAO into the shader "in" variables
+		SetAttribute(0, "position");
+		SetAttribute(1, "texture_coords");
+		SetAttribute(2, "normal");
+	}
+
+	void EntityShader::GetAllUniformLocations()
+	{
+		// Get the locations from the uniform variables from the shaders
+		location_model_matrix = GetUniformLocation("model_matrix");
+		location_projection_matrix = GetUniformLocation("projection_matrix");
+		location_view_matrix = GetUniformLocation("view_matrix");
+		location_shine_damper = GetUniformLocation("shine_damper");
+		location_reflectivity = GetUniformLocation("reflectivity");
+		location_sky_color = GetUniformLocation("sky_color");
+
+		for (int i = 0; i < MAX_LIGHTS; ++i)
+		{
+			std::string light_pos = std::string("light_position[") + std::to_string(i) + "]";
+			location_light_position[i] = GetUniformLocation(light_pos.c_str());
+
+			std::string light_color = std::string("light_color[") + std::to_string(i) + "]";
+			location_light_color[i] = GetUniformLocation(light_color.c_str());
+
+			std::string light_attenuation = std::string("attenuation[") + std::to_string(i) + "]";
+			location_light_attenuation[i] = GetUniformLocation(light_attenuation.c_str());
+		}
+	}
+}

src/shaders/entity_shader.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <glm/gtc/matrix_transform.hpp>
+#include <vector>
+#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: A method to load the the shine variables from a model into the shader
+		 *
+		 * @param shine_damper: The dampening of the angle from when to render reflectivity on the vertex
+		 * @param reflectivity: The amount the model reflects
+		 */
+		void LoadShineVariables(float shine_damper, float reflectivity) const;
+
+		/*
+		 * @brief: A method to load the sky color into the shader. This color will be used for the fog
+		 *
+		 * @param sky_color: The color of the sky
+		 */
+		void LoadSkyColor(glm::vec3 sky_color) const;
+			
+	protected:
+		void SetAttributes() const override;
+		void GetAllUniformLocations() override;
+	};
+}

src/shaders/gui_shader.cpp

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

src/shaders/gui_shader.h

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

src/shaders/shader_program.cpp

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

src/shaders/shader_program.h

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

src/shaders/static_shader.cpp

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

src/shaders/static_shader.h

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

src/toolbox/Timer.h

@@ -0,0 +1,46 @@
+#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; }
+	};
+}

src/toolbox/toolbox.cpp

@@ -2,6 +2,14 @@
 
 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);

src/toolbox/toolbox.h

@@ -5,10 +5,45 @@
 
 namespace toolbox
 {
-	#define WINDOW_WIDTH 1400
+	// Window macro's
-	#define WINDOW_HEIGT 800
+	    #define DEFAULT_WIDTH 1920
+		#define DEFAULT_HEIGHT 1080
 
+		// Change these macros to change the window size
+		#define WINDOW_WIDTH 1400.0f
+		#define WINDOW_HEIGHT 800.0f
+
+		#define SCALED_WIDTH (WINDOW_WIDTH/DEFAULT_WIDTH)
+		#define SCALED_HEIGHT (WINDOW_HEIGHT/DEFAULT_HEIGHT)
+	//
+	
+	/*
+	 * @brief: This function will create a model matrix
+	 *
+	 * @param translation: The position of the model
+	 * @param scale: The scale of the model
+	 *
+	 * @return: The model matrix of the model
+	 */
+	glm::mat4 CreateModelMatrix(glm::vec2 translation, glm::vec2 scale);
+	
+	/*
+	 * @brief: This function will create a model matrix
+	 *
+	 * @param translation: The position of the model
+	 * @param rotation: The rotation of the model
+	 * @param scale: The scale of the model
+	 *
+	 * @return: The model matrix of the model
+	 */
 	glm::mat4 CreateModelMatrix(glm::vec3 translation, glm::vec3 rotation, float scale);
 
+	/*
+	 * @brief: This function will create a view matrix from the camera's position
+	 *
+	 * @param camera: The camera the view matrix needs to be made from
+	 *
+	 * @return: The view matrix
+	 */
 	glm::mat4 CreateViewMatrix(entities::Camera& camera);
 }

wk2_fps.vcxproj

@@ -19,43 +19,56 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="src\scenes\inGameScene.cpp" />
+    <ClCompile Include="src\collision\collision_handler.cpp" />
-    <ClCompile Include="src\scenes\scene.cpp" />
+    <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
     <ClCompile Include="src\computervision\FaceDetector.cpp" />
+    <ClCompile Include="src\computervision\MenuTest.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\shaders\gui_shader.cpp" />
     <ClCompile Include="src\shaders\shader_program.cpp" />
-    <ClCompile Include="src\shaders\static_shader.cpp" />
+    <ClCompile Include="src\shaders\entity_shader.cpp" />
     <ClCompile Include="src\toolbox\toolbox.cpp" />
-    <ClCompile Include="src\scenes\startupScene.cpp" />
+    <ClCompile Include="src\scenes\startup_Scene.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\scenes\inGameScene.h" />
+    <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\FaceDetector.h" />
     <ClInclude Include="src\computervision\FingerCount.h" />
     <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\computervision\MenuTest.h" />
     <ClInclude Include="src\computervision\SkinDetector.h" />
     <ClInclude Include="src\computervision\ObjectDetection.h" />
     <ClInclude Include="src\entities\camera.h" />
+    <ClInclude Include="src\entities\collision_entity.h" />
     <ClInclude Include="src\entities\entity.h" />
+    <ClInclude Include="src\entities\light.h" />
+    <ClInclude Include="src\gui\gui_element.h" />
+    <ClInclude Include="src\gui\gui_interactable.h" />
     <ClInclude Include="src\models\model.h" />
     <ClInclude Include="src\renderEngine\loader.h" />
     <ClInclude Include="src\renderEngine\obj_loader.h" />
     <ClInclude Include="src\renderEngine\renderer.h" />
+    <ClInclude Include="src\shaders\gui_shader.h" />
     <ClInclude Include="src\shaders\shader_program.h" />
-    <ClInclude Include="src\shaders\static_shader.h" />
+    <ClInclude Include="src\shaders\entity_shader.h" />
     <ClInclude Include="src\stb_image.h" />
+    <ClInclude Include="src\toolbox\Timer.h" />
     <ClInclude Include="src\toolbox\toolbox.h" />
-    <ClInclude Include="src\scenes\startupScene.h" />
+    <ClInclude Include="src\scenes\startup_Scene.h" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />
@@ -118,16 +131,16 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include</IncludePath>
+    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
-    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
+    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);;C:\opencv\opencv\build\include</IncludePath>
+    <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</LibraryPath>
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -159,7 +172,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</AdditionalDependencies>
+      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -200,7 +213,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</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;opencv_world452d.lib</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

wk2_fps.vcxproj.filters

@@ -33,15 +33,33 @@
     <ClCompile Include="src\shaders\shader_program.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\shaders\static_shader.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="src\renderEngine\obj_loader.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="src\toolbox\toolbox.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\shaders\entity_shader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\shaders\gui_shader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\gui\gui_interactable.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\scenes\in_Game_Scene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\scenes\startup_Scene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\entities\collision_entity.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\collision\collision_handler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="src\computervision\ObjectDetection.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -57,13 +75,7 @@
     <ClCompile Include="src\computervision\BackgroundRemover.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\scenes\scene.cpp">
+    <ClCompile Include="src\computervision\MenuTest.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>
@@ -89,15 +101,45 @@
     <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\entities\light.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\shaders\entity_shader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\shaders\gui_shader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\gui\gui_element.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\gui\gui_interactable.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\scenes\scene.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\scenes\in_Game_Scene.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\scenes\startup_Scene.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\entities\collision_entity.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\collision\collision.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\collision\collision_handler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="src\computervision\ObjectDetection.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -113,13 +155,10 @@
     <ClInclude Include="src\computervision\BackgroundRemover.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\scenes\scene.h">
+    <ClInclude Include="src\toolbox\Timer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\scenes\startupScene.h">
+    <ClInclude Include="src\computervision\MenuTest.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\scenes\inGameScene.h">
       <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>