[EDIT] removed uses of face detector

src/computervision/FaceDetector.cpp

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

src/computervision/FaceDetector.h

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

src/computervision/ObjectDetection.cpp

@@ -2,7 +2,6 @@
 #include "ObjectDetection.h"
 #include "BackgroundRemover.h"
 #include "SkinDetector.h"
-#include "FaceDetector.h"
 #include "FingerCount.h"
 
 namespace computervision
@@ -14,7 +13,6 @@ namespace computervision
 	Mat frame, frameOut, handMask, foreground, fingerCountDebug;
 	BackgroundRemover backgroundRemover;
 	SkinDetector skinDetector;
-	FaceDetector faceDetector;
 	FingerCount fingerCount;
 
 
@@ -35,8 +33,6 @@ namespace computervision
 		skinDetector.drawSkinColorSampler(frameOut);
 
 		foreground = backgroundRemover.getForeground(frame);
-
-		faceDetector.removeFaces(frame, foreground);
 		handMask = skinDetector.getSkinMask(foreground);
 		fingerCountDebug = fingerCount.findFingersCount(handMask, frameOut);
 

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

@@ -5,10 +5,16 @@
 
 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,6 +5,10 @@
 
 namespace entities
 {
+	/*
+	 * This class represents a movable model in the game
+	 */
+	
 	class Entity
 	{
 	private:
@@ -16,7 +20,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/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,26 @@
+#pragma once
+
+#include <glm/gtc/matrix_transform.hpp>
+#include "../toolbox/toolbox.h"
+
+namespace gui
+{
+	/*
+	 * 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;
+
+		GuiTexture(int texture, glm::vec2 position, glm::vec2 scale): texture(texture), position(position), scale(scale)
+		{
+			scale.x /= (WINDOW_WIDTH / WINDOW_HEIGT);
+		}
+	};
+}

src/gui/gui_interactable.cpp

@@ -0,0 +1,82 @@
+#include <GLFW/glfw3.h>
+#include "gui_interactable.h"
+
+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;
+			}
+		}
+	}
+
+	bool InteractableGui::IsHoveringAbove(GLFWwindow* window)
+	{
+		double x_pos, y_pos;
+		glfwGetCursorPos(window, &x_pos, &y_pos);
+
+		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);
+
+		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,112 @@
+#pragma once
+
+#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: 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; }
+
+	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,20 +2,28 @@
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
 #define STB_IMAGE_IMPLEMENTATION
+#include <iostream>
+
 #include "stb_image.h"
 #include <ostream>
+#include <map>
 
 #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/inGameScene.h"
+
 #include "computervision/ObjectDetection.h"
 
 #pragma comment(lib, "glfw3.lib")
@@ -26,6 +34,10 @@ static double UpdateDelta();
 
 static GLFWwindow* window;
 
+//Scene management variables
+std::map<Scenes, Scene*> scenes;
+Scene* current_scene = nullptr;
+
 
 int main(void)
 {
@@ -44,57 +56,98 @@ int main(void)
 	#pragma endregion
 
     glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
-    {
+        {
-	    if (key == GLFW_KEY_ESCAPE)
+            current_scene->onKey(key, scancode, action, mods);
-	        glfwSetWindowShouldClose(window, true);
+	        if (key == GLFW_KEY_ESCAPE)
-    });
+	            glfwSetWindowShouldClose(window, true);
+        });
 	
+    scenes[Scenes::STARTUP] = new StartupScene();
+    scenes[Scenes::INGAME] = new InGameScene();
 	
-    models::RawModel raw_model = LoadObjModel("res/Tree.obj");
+    models::RawModel raw_model = render_engine::LoadObjModel("res/House.obj");
-    models::ModelTexture texture = { render_engine::loader::LoadTexture("res/TreeTexture.png") };
+    models::ModelTexture texture = { render_engine::loader::LoadTexture("res/Texture.png") };
+    texture.shine_damper = 10;
+    texture.reflectivity = 0;
     models::TexturedModel model = { raw_model, texture };
-    entities::Entity entity(model, glm::vec3(0, -5, -20), glm::vec3(0, 0, 0), 1);
 
-    shaders::StaticShader shader;
+    /**
+    * load and add some models (in this case some level sections) to the entities list.
+    * */
+    std::vector<entities::Entity> entities;
+    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);
+    }
+
+    std::vector<entities::Light> lights;
+    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)));
+
+	shaders::EntityShader 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;
 
+	// GUI stuff
+    shaders::GuiShader gui_shader;
+    gui_shader.Init();
+	
+    std::vector<gui::GuiTexture*> guis;
+    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);
 	
-    // set up object detection
-    //objDetect.setup();
 	
 	// Main game loop
 	while (!glfwWindowShouldClose(window))
 	{
         // Update
         const double delta = UpdateDelta();
-        entity.IncreaseRotation(glm::vec3(0, 1, 0));
         camera.Move(window);
+        button.Update(window);
 
 		// Render
         render_engine::renderer::Prepare();
+		
+		// Start rendering the entities
         shader.Start();
+        shader.LoadSkyColor(render_engine::renderer::SKY_COLOR);
+        shader.LoadLights(lights);
         shader.LoadViewMatrix(camera);
 		
-        render_engine::renderer::Render(entity, shader);
+        // Renders each entity in the entities list
+		for (entities::Entity& entity : entities)
+		{
+            render_engine::renderer::Render(entity, shader);
+		}
 
-        //objDetect.setup();
+		// Stop rendering the entities
-        objDetect.calculateDifference();
-
-		// Finish up
         shader.Stop();
+
+        // Render GUI items
+        render_engine::renderer::Render(guis, gui_shader);
+
+        // Finish up
 		glfwSwapBuffers(window);
 		glfwPollEvents();
 	}
 
 	// Clean up
     shader.CleanUp();
+    gui_shader.CleanUp();
     render_engine::loader::CleanUp();
+    current_scene->stop();
 	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)
+		
+		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_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);
 		}
 
 		/*
@@ -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,124 +6,128 @@
 #include "loader.h"
 #include "obj_loader.h"
 
-static void Split(const std::string& s, char delim, std::vector<std::string>& elems)
+namespace render_engine
 {
-    std::stringstream ss;
+    static void Split(const std::string& s, char delim, std::vector<std::string>& elems)
-    ss.str(s);
-    std::string item;
-    while (getline(ss, item, delim)) {
-        elems.push_back(item);
-    }
-}
-
-static std::vector<std::string> Split(const std::string& s, char delim)
-{
-    std::vector<std::string> elems;
-    Split(s, delim, elems);
-    return elems;
-}
-
-static void ProcessVertex(const std::vector<std::string>& vertex_data,
-    const std::vector<glm::vec3>& normals,
-    const std::vector<glm::vec2>& textures,
-    std::vector<GLuint>& indices,
-    std::vector<GLfloat>& texture_array,
-    std::vector<GLfloat>& normal_array)
-{
-    GLuint current_vertex_pointer = std::stoi(vertex_data.at(0)) - 1;
-    indices.push_back(current_vertex_pointer);
-
-    glm::vec2 current_texture = textures.at(std::stoi(vertex_data.at(1)) - 1);
-    texture_array[(current_vertex_pointer * 2) % texture_array.size()] = current_texture.x;
-    texture_array[(current_vertex_pointer * 2 + 1) % texture_array.size()] = 1 - current_texture.y;
-
-    glm::vec3 current_norm = normals.at(std::stoi(vertex_data.at(2)) - 1);
-    normal_array[current_vertex_pointer * 3] = current_norm.x;
-    normal_array[current_vertex_pointer * 3 + 1] = current_norm.y;
-    normal_array[current_vertex_pointer * 3 + 2] = current_norm.z;
-}
-
-models::RawModel LoadObjModel(std::string file_name)
-{
-    std::ifstream inFile (file_name);
-    if ( !inFile.is_open() ) 
     {
-        throw std::runtime_error ( "Could not open model file " + file_name + ".obj!" );
+        std::stringstream ss;
+        ss.str(s);
+        std::string item;
+        while (getline(ss, item, delim)) {
+            elems.push_back(item);
+        }
     }
-    std::vector<glm::vec3> vertices;
-    std::vector<glm::vec3> normals;
-    std::vector<glm::vec2> textures;
-    std::vector<GLuint> indices;
-    std::vector<GLfloat> vertex_array;
-    std::vector<GLfloat> normal_array;
-    std::vector<GLfloat> texture_array;
-    std::string line;
 
-    try
+    static std::vector<std::string> Split(const std::string& s, char delim)
     {
-        while (std::getline(inFile, line))
+        std::vector<std::string> elems;
+        Split(s, delim, elems);
+        return elems;
+    }
+
+    static void ProcessVertex(const std::vector<std::string>& vertex_data,
+        const std::vector<glm::vec3>& normals,
+        const std::vector<glm::vec2>& textures,
+        std::vector<GLuint>& indices,
+        std::vector<GLfloat>& texture_array,
+        std::vector<GLfloat>& normal_array)
+    {
+        GLuint current_vertex_pointer = std::stoi(vertex_data.at(0)) - 1;
+        indices.push_back(current_vertex_pointer);
+
+        glm::vec2 current_texture = textures.at(std::stoi(vertex_data.at(1)) - 1);
+        texture_array[(current_vertex_pointer * 2) % texture_array.size()] = current_texture.x;
+        texture_array[(current_vertex_pointer * 2 + 1) % texture_array.size()] = 1 - current_texture.y;
+
+        glm::vec3 current_norm = normals.at(std::stoi(vertex_data.at(2)) - 1);
+        normal_array[current_vertex_pointer * 3] = current_norm.x;
+        normal_array[current_vertex_pointer * 3 + 1] = current_norm.y;
+        normal_array[current_vertex_pointer * 3 + 2] = current_norm.z;
+    }
+
+    models::RawModel LoadObjModel(std::string file_name)
+    {
+        std::ifstream inFile(file_name);
+        if (!inFile.is_open())
         {
-            std::vector<std::string> split_line = Split(line, ' ');
+            throw std::runtime_error("Could not open model file " + file_name + ".obj!");
-            if (split_line.at(0) == "v")
+        }
+        std::vector<glm::vec3> vertices;
+        std::vector<glm::vec3> normals;
+        std::vector<glm::vec2> textures;
+        std::vector<GLuint> indices;
+        std::vector<GLfloat> vertex_array;
+        std::vector<GLfloat> normal_array;
+        std::vector<GLfloat> texture_array;
+        std::string line;
+
+        try
+        {
+            while (std::getline(inFile, line))
             {
-                glm::vec3 vertex;
+                std::vector<std::string> split_line = Split(line, ' ');
-                vertex.x = std::stof(split_line.at(1));
+                if (split_line.at(0) == "v")
-                vertex.y = std::stof(split_line.at(2));
+                {
-                vertex.z = std::stof(split_line.at(3));
+                    glm::vec3 vertex;
-                vertices.push_back(vertex);
+                    vertex.x = std::stof(split_line.at(1));
+                    vertex.y = std::stof(split_line.at(2));
+                    vertex.z = std::stof(split_line.at(3));
+                    vertices.push_back(vertex);
+                }
+                else if (split_line.at(0) == "vt")
+                {
+                    glm::vec2 texture;
+                    texture.x = std::stof(split_line.at(1));
+                    texture.y = std::stof(split_line.at(2));
+                    textures.push_back(texture);
+                }
+                else if (split_line.at(0) == "vn")
+                {
+                    glm::vec3 normal;
+                    normal.x = std::stof(split_line.at(1));
+                    normal.y = std::stof(split_line.at(2));
+                    normal.z = std::stof(split_line.at(3));
+                    normals.push_back(normal);
+                }
+                else if (split_line.at(0) == "f")
+                {
+                    normal_array = std::vector<GLfloat>(vertices.size() * 3);
+                    texture_array = std::vector<GLfloat>(textures.size() * 2);
+                    break;
+                }
             }
-            else if (split_line.at(0) == "vt")
+
+            while (true)
             {
-                glm::vec2 texture;
+                std::vector<std::string> split = Split(line, ' ');
-                texture.x = std::stof(split_line.at(1));
+                std::vector<std::string> vertex1 = Split(split.at(1), '/');
-                texture.y = std::stof(split_line.at(2));
+                std::vector<std::string> vertex2 = Split(split.at(2), '/');
-                textures.push_back(texture);
+                std::vector<std::string> vertex3 = Split(split.at(3), '/');
-            }
+                ProcessVertex(vertex1, normals, textures, indices, texture_array, normal_array);
-            else if (split_line.at(0) == "vn")
+                ProcessVertex(vertex2, normals, textures, indices, texture_array, normal_array);
-            {
+                ProcessVertex(vertex3, normals, textures, indices, texture_array, normal_array);
-                glm::vec3 normal;
+                if (!std::getline(inFile, line))
-                normal.x = std::stof(split_line.at(1));
+                {
-                normal.y = std::stof(split_line.at(2));
+                    break;
-                normal.z = std::stof(split_line.at(3));
+                }
-                normals.push_back(normal);
-            }
-            else if (split_line.at(0) == "f")
-            {
-                normal_array = std::vector<GLfloat>(vertices.size() * 3);
-                texture_array = std::vector<GLfloat>(textures.size() * 2);
-                break;
             }
         }
-    	
+        catch (const std::exception& e)
-        while (true)
         {
-            std::vector<std::string> split = Split(line, ' ');
+            // Always go in here
-            std::vector<std::string> vertex1 = Split(split.at(1), '/');
-            std::vector<std::string> vertex2 = Split(split.at(2), '/');
-            std::vector<std::string> vertex3 = Split(split.at(3), '/');
-            ProcessVertex(vertex1, normals, textures, indices, texture_array, normal_array);
-            ProcessVertex(vertex2, normals, textures, indices, texture_array, normal_array);
-            ProcessVertex(vertex3, normals, textures, indices, texture_array, normal_array);
-            if (!std::getline(inFile, line))
-            {
-                break;
-            }
         }
-    } catch (const std::exception& e)
+
-    {
+        inFile.close();
-    	// Always go in here
+
+        vertex_array = std::vector<GLfloat>(vertices.size() * 3);
+        int p = 0;
+        for (auto& vertex : vertices)
+        {
+            vertex_array[p++] = vertex.x;
+            vertex_array[p++] = vertex.y;
+            vertex_array[p++] = vertex.z;
+        }
+
+        return render_engine::loader::LoadToVAO(vertex_array, texture_array, normal_array, indices);
     }
-
-    inFile.close();
-	
-    vertex_array = std::vector<GLfloat>( vertices.size() * 3 );
-    int p = 0;
-    for ( auto& vertex : vertices ) 
-    {
-        vertex_array[p++] = vertex.x;
-        vertex_array[p++] = vertex.y;
-        vertex_array[p++] = vertex.z;
-    }
-
-    return render_engine::loader::LoadToVAO( vertex_array, texture_array, indices);
 }

src/renderEngine/obj_loader.h

@@ -3,4 +3,12 @@
 #include <string>
 #include "../models/model.h"
 
-models::RawModel LoadObjModel(std::string file_name);
+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

@@ -0,0 +1,29 @@
+#include "inGameScene.h"
+#include <GLFW/glfw3.h>
+
+void InGameScene::start()
+{
+
+}
+
+void InGameScene::stop()
+{
+
+}
+
+void InGameScene::render()
+{
+
+}
+
+void InGameScene::update(GLFWwindow* window)
+{
+
+}
+
+void InGameScene::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,17 @@
+#pragma once
+#include "scene.h"
+class InGameScene : public Scene
+{
+private:
+
+
+public:
+	void start() override;
+	void stop() override;
+	void render() override;
+	void update(GLFWwindow* window) override;
+	void onKey(int key, int scancode, int action, int mods) override;
+
+	
+};
+

src/scenes/scene.cpp

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

src/scenes/scene.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <GLFW/glfw3.h>
+
+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) {};
+};
+
+
+
+enum class Scenes
+{
+	STARTUP,
+	INGAME,
+	GAMEOVER,
+	SETTINGS,
+	CALIBRATION
+};

src/scenes/startupScene.cpp

@@ -0,0 +1,31 @@
+#include "startupScene.h"
+#include <GLFW/glfw3.h>
+
+void StartupScene::start()
+{
+
+}
+
+void StartupScene::stop()
+{
+
+}
+
+void StartupScene::render()
+{
+
+}
+
+void StartupScene::update(GLFWwindow* window)
+{
+
+}
+
+void StartupScene::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:
+	void start() override;
+	void stop() override;
+	void render() override;
+	void update(GLFWwindow* window) override;
+	void onKey(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.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/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_HEIGT 800.0f
+
+		#define SCALED_WIDTH (WINDOW_WIDTH/DEFAULT_WIDTH)
+		#define SCALED_HEIGHT (WINDOW_HEIGT/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,37 +19,47 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="src\computervision\FaceDetector.cpp" />
+    <ClCompile Include="src\scenes\inGameScene.cpp" />
+    <ClCompile Include="src\scenes\scene.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\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" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\computervision\FaceDetector.h" />
+    <ClInclude Include="src\scenes\inGameScene.h" />
+    <ClInclude Include="src\scenes\scene.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\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\toolbox.h" />
+    <ClInclude Include="src\scenes\startupScene.h" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />

wk2_fps.vcxproj.filters

@@ -33,15 +33,21 @@
     <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\computervision\ObjectDetection.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -51,10 +57,16 @@
     <ClCompile Include="src\computervision\FingerCount.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\computervision\FaceDetector.cpp">
+    <ClCompile Include="src\computervision\BackgroundRemover.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\computervision\BackgroundRemover.cpp">
+    <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>
@@ -80,15 +92,27 @@
     <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\computervision\ObjectDetection.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -98,10 +122,16 @@
     <ClInclude Include="src\computervision\FingerCount.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\computervision\FaceDetector.h">
+    <ClInclude Include="src\computervision\BackgroundRemover.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\computervision\BackgroundRemover.h">
+    <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>