[ADD] start for object detection

src/computervision/ObjectDetection.cpp

@@ -0,0 +1,36 @@
+#include "ObjectDetection.h"
+namespace computervision
+{
+	cv::VideoCapture cap(0);
+	cv::Mat img, imgGray, img2, img2Gray, img3, img4;
+
+	ObjectDetection::ObjectDetection()
+	{
+	}
+
+	void ObjectDetection::readWebcam()
+	{
+		cap.read(img);
+	}
+
+	void ObjectDetection::calculateDifference()
+	{
+		cap.read(img);
+		cap.read(img2);
+
+		cv::cvtColor(img, imgGray, cv::COLOR_RGBA2GRAY);
+		cv::cvtColor(img2, img2Gray, cv::COLOR_RGBA2GRAY);
+
+		cv::absdiff(imgGray, img2Gray, img3);
+		cv::threshold(img3, img4, 50, 170, cv::THRESH_BINARY);
+
+		imshow("threshold", img4);
+	}
+
+	void ObjectDetection::showWebcam()
+	{
+		imshow("Webcam image", img);
+	}
+
+
+}

src/computervision/ObjectDetection.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/objdetect.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/highgui/highgui.hpp>
+
+namespace computervision
+{
+	class ObjectDetection
+	{
+	private:
+
+	public:
+		ObjectDetection();
+		void readWebcam();
+		void showWebcam();
+		void calculateDifference();
+
+	};
+
+
+}
+

src/entities/Camera.cpp

@@ -9,42 +9,24 @@ namespace entities
 
 	void Camera::Move(GLFWwindow* window)
 	{
-		float movement_speed = 0;
-		
 		if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
 		{
-			movement_speed -= SPEED;
+			position.z -= SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
 		{
-			movement_speed += SPEED;
+			position.z += SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
 		{
-			rotation.y += ROT_SPEED;
+			position.x += SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
 		{
-			rotation.y -= ROT_SPEED;
+			position.x -= 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,20 +1,14 @@
 #pragma once
-#include <GL/glew.h>
+
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
 
 namespace entities
 {
-	/*
-	 * This class represents the viewport of the game. The whole game is seen through this class
-	 */
-	
 	class Camera
 	{
 	private:
-		// The movement speed of the camera
+		const float SPEED = 0.02f;
-		const float SPEED = 0.52f;
-		const float ROT_SPEED = 1.0f;
 		
 		glm::vec3 position;
 		glm::vec3 rotation;
@@ -22,11 +16,6 @@ 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,6 @@
 
 namespace entities
 {
-	/*
-	 * This class represents a movable model in the game
-	 */
-	
 	class Entity
 	{
 	private:
@@ -20,18 +16,7 @@ namespace entities
 	public:
 		Entity(const models::TexturedModel& model, const glm::vec3& position, const glm::vec3& rotation, float scale);
 
-		/*
-		 * @brief: This function increases the position of the entity
-		 *
-		 * @param distance: The amount of distance in each axis the entity needs to move
-		 */
 		void IncreasePosition(const glm::vec3& distance);
-
-		/*
-		 * @brief: This function increases the rotation of the entity
-		 *
-		 * @param rotation: The angle of each axis the entity needs to rotate
-		 */
 		void IncreaseRotation(const glm::vec3& rotation);
 		
 		inline models::TexturedModel GetModel() const{return model;}

src/entities/light.h

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

src/gui/gui_element.h

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

@@ -1,83 +0,0 @@
-#include <GL/glew.h>
-#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

@@ -1,112 +0,0 @@
-#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,24 +2,17 @@
 #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 <opencv2/core.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/entity_shader.h"
+#include "shaders/static_shader.h"
 #include "toolbox/toolbox.h"
-#include "scenes/scene.h"
+
-#include "scenes/in_Game_Scene.h"
+#include "computervision/ObjectDetection.h"
-#include "scenes/startup_Scene.h"
 
 #pragma comment(lib, "glfw3.lib")
 #pragma comment(lib, "glew32s.lib")
@@ -28,7 +21,7 @@
 static double UpdateDelta();
 
 static GLFWwindow* window;
-scene::Scene* current_scene;
+
 
 int main(void)
 {
@@ -46,51 +39,56 @@ 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(window, key, scancode, action, mods);
 	    if (key == GLFW_KEY_ESCAPE)
 	        glfwSetWindowShouldClose(window, true);
     });
 	
-    bool window_open = true;
+	
+    models::RawModel raw_model = LoadObjModel("res/Tree.obj");
+    models::ModelTexture texture = { render_engine::loader::LoadTexture("res/TreeTexture.png") };
+    models::TexturedModel model = { raw_model, texture };
+    entities::Entity entity(model, glm::vec3(0, -5, -20), glm::vec3(0, 0, 0), 1);
+	
+    shaders::StaticShader shader;
+    shader.Init();
+    render_engine::renderer::Init(shader);
+
+    entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
+
+    computervision::ObjectDetection objDetect;
+    
+    
+
+
+	
 	// Main game loop
-	while (!glfwWindowShouldClose(window) && window_open)
+	while (!glfwWindowShouldClose(window))
 	{
         // Update
         const double delta = UpdateDelta();
+        entity.IncreaseRotation(glm::vec3(0, 1, 0));
+        camera.Move(window);
 
-        scene::Scenes return_value = current_scene->start(window);
+		// Render
-        delete current_scene;
+        render_engine::renderer::Prepare();
+        shader.Start();
+        shader.LoadViewMatrix(camera);
 		
-        switch (return_value) {
+        render_engine::renderer::Render(entity, shader);
-            case scene::Scenes::STOP:
-                window_open = false;
-                break;
         
-            case scene::Scenes::STARTUP:
+        objDetect.calculateDifference();
-                current_scene = new scene::Startup_Scene();
-                break;
 
-            case scene::Scenes::INGAME:
+		// Finish up
-                current_scene = new scene::In_Game_Scene();
+        shader.Stop();
-                break;
+		glfwSwapBuffers(window);
-
+		glfwPollEvents();
-            default:
-                std::cout << "Wrong return value!!! ->" << std::endl;
-                break;
-        }
 	}
 
-	// Clean up -> preventing memory leaks!!!
+	// Clean up
-    std::cout << "ending..." << std::endl;
+    shader.CleanUp();
-    delete current_scene;
+    render_engine::loader::CleanUp();
 	glfwTerminate();
     return 0;
 }

src/models/Model.h

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

src/renderEngine/Loader.cpp

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

src/renderEngine/Loader.h

@@ -9,36 +9,17 @@ namespace render_engine
 	namespace loader
 	{
 		/*
-		*	@brief: This function generates a model from model data.
+			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
 		*/
-		models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<float>& normals, std::vector<unsigned int>& indices);
+		struct models::RawModel LoadToVAO(std::vector<float>& positions, std::vector<float>& texture_coords, std::vector<unsigned int>& indices);
 
 		/*
-		 * @brief: Overloaded function of the function above, but does not need normals and indices.
+			Loads a texture from a file into openGL using stb_image.h
-		 *         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);
 		
 		/*
-		*	@brief: Call this function when cleaning up all the meshes (when exiting the program).
+			Call this function when cleaning up all the meshes (when exiting the program).
 		*/
 		void CleanUp();
 	}

src/renderEngine/Renderer.cpp

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

src/renderEngine/Renderer.h

@@ -1,43 +1,25 @@
 #pragma once
 
-#include "../gui/gui_element.h"
 #include "../entities/entity.h"
-#include "../shaders/entity_shader.h"
+#include "../shaders/static_shader.h"
-#include "../shaders/gui_shader.h"
 
 namespace render_engine
 {
 	namespace renderer
 	{
-		const glm::vec3 SKY_COLOR = { 0.3f, 0.4f, 0.6f };
-		
 		/*
-			@brief: Call this function when starting the program
+			Call this function when starting the program
-
-			@param shader: The shader to render the entities with
 		 */
-		void Init(shaders::EntityShader& shader);
+		void Init(shaders::StaticShader& shader);
 		
 		/*
-			@brief: Call this function before rendering.
+			Call this function before rendering. 
-					This function will enable culling and load the projectionMatrix into the shader.
 		*/
 		void Prepare();
 
 		/*
-			@brief: Call this function when wanting to Render a mesh to the screen.
+			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::EntityShader& shader);
+		void Render(entities::Entity& entity, shaders::StaticShader& 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,8 +6,6 @@
 #include "loader.h"
 #include "obj_loader.h"
 
-namespace render_engine
-{
 static void Split(const std::string& s, char delim, std::vector<std::string>& elems)
 {
     std::stringstream ss;
@@ -111,8 +109,7 @@ namespace render_engine
                 break;
             }
         }
-        }
+    } catch (const std::exception& e)
-        catch (const std::exception& e)
     {
     	// Always go in here
     }
@@ -128,6 +125,5 @@ namespace render_engine
         vertex_array[p++] = vertex.z;
     }
 
-        return render_engine::loader::LoadToVAO(vertex_array, texture_array, normal_array, indices);
+    return render_engine::loader::LoadToVAO( vertex_array, texture_array, indices);
-    }
 }

src/renderEngine/obj_loader.h

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

src/scenes/in_Game_Scene.cpp

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

@@ -1,22 +0,0 @@
-#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,7 +0,0 @@
-#include "scene.h"
-
-namespace scene
-{
-
-}
-

src/scenes/scene.h

@@ -1,31 +0,0 @@
-#pragma once
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
-#include <map>
-
-
-namespace scene {
-
-	enum class Scenes
-	{
-		STARTUP,
-		INGAME,
-		GAMEOVER,
-		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/startup_Scene.cpp

@@ -1,40 +0,0 @@
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
-#include <map>
-#include "startup_Scene.h"
-
-namespace scene
-{
-
-	scene::Scenes scene::Startup_Scene::start(GLFWwindow *window)
-	{
-		while (return_value == scene::Scenes::STARTUP)
-		{
-			render();
-			update(window);
-
-			glfwSwapBuffers(window);
-			glfwPollEvents();
-		}
-
-		return return_value;
-	}
-
-	void scene::Startup_Scene::render() 
-	{
-
-	}
-
-	void scene::Startup_Scene::update(GLFWwindow* 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;
-		}
-	}
-}

src/scenes/startup_Scene.h

@@ -1,22 +0,0 @@
-#pragma once
-#include "scene.h"
-#include <map>
-
-namespace scene
-{
-	extern GLFWwindow* window;
-
-	class Startup_Scene : public scene::Scene
-	{
-	private:
-		scene::Scenes return_value = scene::Scenes::STARTUP;
-
-	public:
-		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/shaders/entity_shader.cpp

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

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

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

src/shaders/gui_shader.h

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

src/shaders/shader_program.cpp

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

src/shaders/shader_program.h

@@ -21,87 +21,29 @@ namespace shaders
 		ShaderProgram(std::string& vertex_shader, std::string& fragment_shader);
 		virtual ~ShaderProgram() = default;
 
-		/*
+		// 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

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

src/shaders/static_shader.h

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

src/toolbox/toolbox.cpp

@@ -2,14 +2,6 @@
 
 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,45 +5,10 @@
 
 namespace toolbox
 {
-	// Window macro's
-	    #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,39 +19,29 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
+    <ClCompile Include="src\computervision\ObjectDetection.cpp" />
-    <ClCompile Include="src\scenes\scene.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\entity_shader.cpp" />
+    <ClCompile Include="src\shaders\static_shader.cpp" />
     <ClCompile Include="src\toolbox\toolbox.cpp" />
-    <ClCompile Include="src\scenes\startup_Scene.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\scenes\in_Game_Scene.h" />
+    <ClInclude Include="src\computervision\ObjectDetection.h" />
-    <ClInclude Include="src\scenes\scene.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\entity_shader.h" />
+    <ClInclude Include="src\shaders\static_shader.h" />
     <ClInclude Include="src\stb_image.h" />
     <ClInclude Include="src\toolbox\toolbox.h" />
-    <ClInclude Include="src\scenes\startup_Scene.h" />
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <VCProjectVersion>16.0</VCProjectVersion>
@@ -111,16 +101,14 @@
   </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)</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)</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>
-    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -152,7 +140,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)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -193,7 +181,6 @@
       <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>
     </Link>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

wk2_fps.vcxproj.filters

@@ -33,28 +33,16 @@
     <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">
+    <ClCompile Include="src\computervision\ObjectDetection.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\scene.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>
   </ItemGroup>
@@ -80,34 +68,16 @@
     <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">
+    <ClInclude Include="src\computervision\ObjectDetection.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>
   </ItemGroup>