[ADD] skeleton code for different scenes

.gitignore

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

src/collision/collision.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <glm/gtc/matrix_transform.hpp>
-#include "../entities/entity.h"
-
-namespace collision
-{
-	/*
-	 * This structure represents a collision box inside the world.
-	 *
-	 * center_pos:	The center position of the collision box
-	 * size:		The size in each axis of the collision box
-	 */
-	struct Box
-	{
-		glm::vec3 center_pos;
-		glm::vec3 size;
-	};
-
-	/*
-	 * This structure represents a collision between 2 entities
-	 *
-	 * entity1:		The first entity
-	 * entity2:		The second entity
-	 */
-	struct Collision
-	{
-		entities::Entity& entity1;
-		entities::Entity& entity2;
-	};
-}

src/collision/collision_handler.cpp

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

src/collision/collision_handler.h

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

src/computervision/FingerCount.cpp

@@ -151,16 +151,9 @@ namespace computervision
 		drawVectorPoints(frame, filtered_finger_points, color_yellow, false);
 		putText(frame, to_string(filtered_finger_points.size()), center_bounding_rect, FONT_HERSHEY_PLAIN, 3, color_purple);
 
-		amount_of_fingers = filtered_finger_points.size();
-
 		return contours_image;
 	}
 
-	int FingerCount::getAmountOfFingers()
-	{
-		return amount_of_fingers;
-	}
-
 	double FingerCount::findPointsDistance(Point a, Point b) {
 		Point difference = a - b;
 		return sqrt(difference.ddot(difference));

src/computervision/FingerCount.h

@@ -24,13 +24,6 @@ namespace computervision
 		 */
 		Mat findFingersCount(Mat input_image, Mat frame);
 
-		/**
-		 * @brief gets the currently held-up finger count.
-		 * 
-		 * @return the currently held-up finger count
-		 */
-		int getAmountOfFingers();
-
 	private:
 		// colors to use
 		Scalar color_blue;
@@ -41,8 +34,6 @@ namespace computervision
 		Scalar color_yellow;
 		Scalar color_purple;
 
-		int amount_of_fingers;
-
 		/**
 		 * @brief finds the distance between 2 points.
 		 * 

src/computervision/ObjectDetection.cpp

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

src/computervision/ObjectDetection.h

@@ -22,7 +22,13 @@ namespace computervision
 		 * 
 		 */
 		ObjectDetection();
-
+		/**
+		 * @brief Initializes the object detection, captures a frame and modifies it
+		 *  so it is ready to use for object detection
+		 * 
+		 * @return return true if webcam is connected, returns false if it isn't
+		 */
+		bool setup();
 		/**
 		 * @brief Displays an image of the current webcam-footage
 		 * 
@@ -34,36 +40,11 @@ namespace computervision
 		 * 
 		 */
 		void calculateDifference();
-
 		/**
-		 * @brief generates the square that will hold the mask in which the hand will be detected.
+		 * @brief Listens for keypresses and handles them
 		 * 
-		 * @param img the current camear frame
-		 * @return a matrix containing the mask
 		 */
-		cv::Mat generateHandMaskSquare(cv::Mat img);
-
-		/**
-		 * @brief reads the camera and returns it in a matrix.
-		 * 
-		 * @return the camera frame in a matrix
-		 */
-		cv::Mat readCamera();
-
-		/**
-		 * @brief detects a hand based on the given hand mask input frame.
-		 * 
-		 * @param inputFrame the input frame from the camera
-		 * @return true if hand is open, false if hand is closed
-		 */
-		bool detectHand(cv::Mat cameraFrame);
-
-		/**
-		 * @brief draws the hand mask rectangle on the given input matrix.
-		 * 
-		 * @param input the input matrix to draw the rectangle on
-		 */
-		bool drawHandMaskRect(cv::Mat *input);
+		void detect();
 
 	};
 

src/computervision/SkinDetector.cpp

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

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

src/entities/collision_entity.cpp

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

src/entities/collision_entity.h

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

src/entities/light.h

@@ -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,26 +2,24 @@
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
 #define STB_IMAGE_IMPLEMENTATION
-#include <iostream>
-#include <map>
-
 #include "stb_image.h"
 #include <ostream>
+#include <map>
 
 #include <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/entity_shader.h"
+#include "shaders/static_shader.h"
 #include "toolbox/toolbox.h"
+
 #include "scenes/scene.h"
-#include "scenes/in_Game_Scene.h"
-#include "scenes/startup_Scene.h"
+#include "scenes/startupScene.h"
+#include "scenes/inGameScene.h"
 
 #include "computervision/ObjectDetection.h"
 
@@ -32,77 +30,95 @@
 static double UpdateDelta();
 
 static GLFWwindow* window;
-scene::Scene* current_scene;
+
+//Scene management variables
+std::map<Scenes, Scene*> scenes;
+Scene* current_scene = nullptr;
+
 
 int main(void)
 {
-#pragma region OPENGL_SETTINGS
-	if (!glfwInit())
-		throw "Could not inditialize glwf";
-	window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGT, "SDBA", NULL, NULL);
-	if (!window)
-	{
-		glfwTerminate();
-		throw "Could not initialize glwf";
-	}
-	glfwMakeContextCurrent(window);
-	glewInit();
-	glGetError();
-#pragma endregion
-
-    
-    current_scene = new scene::Startup_Scene();
+	#pragma region OPENGL_SETTINGS
+    if (!glfwInit())
+        throw "Could not inditialize glwf";
+    window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGT, "SDBA", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        throw "Could not initialize glwf";
+    }
+    glfwMakeContextCurrent(window);
+    glewInit();
+    glGetError();
+	#pragma endregion
 
     glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
         {
-            if (key == GLFW_KEY_ESCAPE)
-            {
-                glfwSetWindowShouldClose(window, true);
-            }
-    	
-            current_scene->onKey(window, key, scancode, action, mods);
+            current_scene->onKey(key, scancode, action, mods);
+	        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::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);
 
-    bool window_open = true;
+    entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
+
+    // create object detection object instance
+    computervision::ObjectDetection objDetect;
+    
+    
+    // set up object detection
+    //objDetect.setup();
+
+    current_scene->start();
 	// Main game loop
-	while (!glfwWindowShouldClose(window) && window_open)
+	while (!glfwWindowShouldClose(window))
 	{
-        //Update
+        // Update
         const double delta = UpdateDelta();
+        entity.IncreaseRotation(glm::vec3(0, 1, 0));
+        camera.Move(window);
+        current_scene->update(window);
 
-        scene::Scenes return_value = current_scene->start(window);
-        delete current_scene;
+		// Render
+        render_engine::renderer::Prepare();
+        shader.Start();
+        shader.LoadViewMatrix(camera);
+        current_scene->render();
+        render_engine::renderer::Render(entity, shader);
 
-        switch (return_value) {
-            case scene::Scenes::STOP:
-                window_open = false;
-                break;
+        //objDetect.setup();
+        objDetect.calculateDifference();
 
-            case scene::Scenes::STARTUP:
-                current_scene = new scene::Startup_Scene();
-                break;
-
-            case scene::Scenes::INGAME:
-                current_scene = new scene::In_Game_Scene();
-                break;
-
-            default:
-                std::cout << "Wrong return value!!! ->" << std::endl;
-                break;
-        }
+		// Finish up
+        shader.Stop();
+		glfwSwapBuffers(window);
+		glfwPollEvents();
 	}
 
-	// Clean up -> preventing memory leaks!!!
-    std::cout << "ending..." << std::endl;
+	// Clean up
+    shader.CleanUp();
+    render_engine::loader::CleanUp();
+    current_scene->stop();
 	glfwTerminate();
-	return 0;
+    return 0;
 }
 
 static double UpdateDelta()
 {
-	double current_time = glfwGetTime();
-	static double last_frame_time = current_time;
-	double delt_time = current_time - last_frame_time;
-	last_frame_time = current_time;
-	return delt_time;
-}
+    double current_time = glfwGetTime();
+    static double last_frame_time = current_time;
+    double delt_time = current_time - last_frame_time;
+    last_frame_time = current_time;
+    return delt_time;
+}

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

src/renderEngine/Loader.cpp

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

src/renderEngine/Loader.h

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

src/renderEngine/Renderer.cpp

@@ -1,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 <iostream>
+#include "../toolbox/toolbox.h"
 
 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;
-		
-		
-		void Init(shaders::EntityShader& shader)
+		/*
+			This function will load the projectionMatrix into the shader
+		 */
+		void Init(shaders::StaticShader& shader)
 		{
-			// Faces which are not facing the camera are not rendered
-			glEnable(GL_CULL_FACE);
-			glCullFace(GL_BACK);
-			
 			const glm::mat4 projectionMatrix = 
 				glm::perspective(glm::radians(FOV), (WINDOW_WIDTH / WINDOW_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::ModelTexture texture = model.texture;
+			const models::RawModel rawModel = model.raw_model;
 
-			// Enable the model (VAO)
-			glBindVertexArray(raw_model.vao_id);
+			// Enable the model
+			glBindVertexArray(rawModel.vao_id);
 
-			// Enable the VBO's from the model (VAO)
+			// Enable the inputs for the vertexShader
 			glEnableVertexAttribArray(0);
 			glEnableVertexAttribArray(1);
-			glEnableVertexAttribArray(2);
 
 			// Load the transformation of the model into the shader
 			const glm::mat4 modelMatrix = toolbox::CreateModelMatrix(entity.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);
-
-			// Disable the VBO's and model (VAO)
+			glDrawElements(GL_TRIANGLES, rawModel.vertex_count, GL_UNSIGNED_INT, 0);
+			
 			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/gui_shader.h"
+#include "../shaders/static_shader.h"
 
 namespace render_engine
 {
 	namespace renderer
 	{
-		const glm::vec3 SKY_COLOR = { 0.3f, 0.4f, 0.6f };
-		
 		/*
-			@brief: Call this function when starting the program
-
-			@param shader: The shader to render the entities with
+			Call this function when starting the program
 		 */
-		void Init(shaders::EntityShader& shader);
+		void Init(shaders::StaticShader& shader);
 		
 		/*
-			@brief: Call this function before rendering.
-					This function will enable culling and load the projectionMatrix into the shader.
+			Call this function before rendering. 
 		*/
 		void Prepare();
 
 		/*
-			@brief: Call this function when wanting to Render a mesh to the screen.
-
-			@param entity: The entity which needs to be rendered
-			@param shader: The shader the entity needs to be rendered with
+			Call this function when wanting to Render a mesh to the screen.
 		*/
-		void Render(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);
+		void Render(entities::Entity& entity, shaders::StaticShader& shader);
 	}
 }

src/renderEngine/obj_loader.cpp

@@ -6,128 +6,124 @@
 #include "loader.h"
 #include "obj_loader.h"
 
-namespace render_engine
+static void Split(const std::string& s, char delim, std::vector<std::string>& elems)
 {
-    static void Split(const std::string& s, char delim, std::vector<std::string>& elems)
-    {
-        std::stringstream ss;
-        ss.str(s);
-        std::string item;
-        while (getline(ss, item, delim)) {
-            elems.push_back(item);
-        }
+    std::stringstream ss;
+    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)
+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() ) 
     {
-        std::vector<std::string> elems;
-        Split(s, delim, elems);
-        return elems;
+        throw std::runtime_error ( "Could not open model file " + file_name + ".obj!" );
     }
-
-    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)
+    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
     {
-        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())
+        while (std::getline(inFile, line))
         {
-            throw std::runtime_error("Could not open model file " + file_name + ".obj!");
-        }
-        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))
+            std::vector<std::string> split_line = Split(line, ' ');
+            if (split_line.at(0) == "v")
             {
-                std::vector<std::string> split_line = Split(line, ' ');
-                if (split_line.at(0) == "v")
-                {
-                    glm::vec3 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;
-                }
+                glm::vec3 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);
             }
-
-            while (true)
+            else if (split_line.at(0) == "vt")
             {
-                std::vector<std::string> split = Split(line, ' ');
-                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;
-                }
+                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;
             }
         }
-        catch (const std::exception& e)
+    	
+        while (true)
         {
-            // Always go in here
+            std::vector<std::string> split = Split(line, ' ');
+            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;
+            }
         }
-
-        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, normal_array, indices);
+    } catch (const std::exception& e)
+    {
+    	// Always go in here
     }
+
+    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,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);
-}
+models::RawModel LoadObjModel(std::string file_name);

src/scenes/inGameScene.cpp

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

src/scenes/inGameScene.h

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

src/scenes/in_Game_Scene.cpp

@@ -1,168 +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"
-#include <deque>
-
-#define MAX_MODEL_DEQUE_SIZE 6 // max amount of models to load at the same time
-#define UPCOMING_MODEL_AMOUNT 4 // how much models should be loaded in front of us
-
-
-namespace scene
-{
-	std::deque<entities::Entity> house_models;
-	std::deque<entities::Light> lights;
-	std::deque<entities::Entity> trees;
-
-	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;
-
-	models::TexturedModel model;
-	models::TexturedModel tree;
-
-
-	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();
-	}
-
-	/**
-	 * @brief loads a new chunk in front of the camera, and deletes the chunk behind the camera.
-	 * 
-	 * @param model_pos the amount of models the camera has passed already. This is the rounded result of (z position of camera) / (size of model)
-	 * 
-	 */
-	void load_chunk(int model_pos)
-	{
-		std::cout << "loading model chunk" << std::endl;
-		if (house_models.size() >= MAX_MODEL_DEQUE_SIZE)
-		{
-			house_models.pop_back();
-			trees.pop_back();
-		}
-		int z_offset = model_pos * (model.raw_model.model_size.x * 20); // how much "in the distance" we should load the model
-		house_models.push_front(entities::Entity(model, glm::vec3(0, -50, -50 - z_offset), glm::vec3(0, 90, 0), 20));
-
-		trees.push_front(entities::Entity(tree, glm::vec3(0, 0, -50 - z_offset), glm::vec3(0, 90, 0), 3));
-	}
-
-
-	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;
-		model = { raw_model, texture };
-
-		models::RawModel raw_tree_model = render_engine::LoadObjModel("res/Tree.obj");
-		models::ModelTexture tree_texture = { render_engine::loader::LoadTexture("res/TreeTexture.png") };
-		tree = { raw_tree_model, tree_texture };
-		
-
-		// load the first few house models
-		for (int i = 0; i <= UPCOMING_MODEL_AMOUNT; i++)
-		{
-			load_chunk(i);
-		}
-
-		lights.push_back(entities::Light(glm::vec3(0, 1000, -7000), glm::vec3(5, 5, 5))); // sun
-		lights.push_back(entities::Light(glm::vec3(0, 0, -30), glm::vec3(2, 0, 2), glm::vec3(0.0001f, 0.0001f, 0.0001f)));
-		lights.push_back(entities::Light(glm::vec3(0, 0, -200), glm::vec3(0, 2, 0), glm::vec3(0.0001f, 0.0001f, 0.0001f)));
-
-		// GUI stuff
-		gui::Button button(render_engine::loader::LoadTexture("res/Mayo.png"), glm::vec2(0.5f, 0.0f), glm::vec2(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->LoadLightsDeque(lights);
-		shader->LoadViewMatrix(camera);
-
-		for (entities::Entity& model_entity : house_models)
-		{
-			render_engine::renderer::Render(model_entity, *shader);
-		}
-
-		for (entities::Entity& tree_entity : trees)
-		{
-			render_engine::renderer::Render(tree_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);
-
-		// calculate where the next house model should be loaded
-		static int last_model_pos = 0;
-		int model_pos = -round(camera.GetPosition().z / (model.raw_model.model_size.x * 20)); // how much models we have passed, minus because we are moving in the negative z axis
-
-		// if we have passed a model, load a new one and delete the one behind us
-		if (last_model_pos != model_pos)
-		{
-			load_chunk(model_pos + UPCOMING_MODEL_AMOUNT);
-		}
-		// remember the position at which the new model was added
-		last_model_pos = model_pos;
-	}
-
-	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

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

src/scenes/scene.h

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

src/scenes/startupScene.cpp

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

src/scenes/startupScene.h

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

src/scenes/startup_Scene.cpp

@@ -1,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,224 +0,0 @@
-#include "entity_shader.h"
-#include "../toolbox/toolbox.h"
-#include <deque>
-
-namespace shaders
-{
-	static std::string vertex_shader = R"(
-	#version 400 core
-	// The VertexShader is run for each vertex on the screen.
-
-
-	// Position of the vertex
-	in vec3 position;
-	// Coordinates of the texture
-	in vec2 texture_coords;
-	// The normal of the vertex
-	in vec3 normal;
-
-	// Equal to the texture_coords
-	out vec2 pass_texture_coords;
-	out vec3 surface_normal;
-	out vec3 to_light_vector[4];
-	out vec3 to_camera_vector;
-	out float visibility;
-
-	uniform mat4 model_matrix;
-	uniform mat4 projection_matrix;
-	uniform mat4 view_matrix;
-	uniform vec3 light_position[4];
-
-	const float density = 0.0017;
-	const float gradient = 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::LoadLightsDeque(std::deque<entities::Light>& lights) const
-	{
-		for (int i = 0; i < MAX_LIGHTS; ++i)
-		{
-			if (i < lights.size())
-			{
-				LoadVector(location_light_position[i], lights[i].GetPosition());
-				LoadVector(location_light_color[i], lights[i].GetColor());
-				LoadVector(location_light_attenuation[i], lights[i].GetAttenuation());
-			}
-			else
-			{
-				LoadVector(location_light_position[i], glm::vec3(0, 0, 0));
-				LoadVector(location_light_color[i], glm::vec3(0, 0, 0));
-				LoadVector(location_light_attenuation[i], glm::vec3(1, 0, 0));
-			}
-		}
-	}
-
-	void EntityShader::LoadShineVariables(float shine_damper, float reflectivity) const
-	{
-		LoadFloat(location_shine_damper, shine_damper);
-		LoadFloat(location_reflectivity, reflectivity);
-	}
-
-	void EntityShader::LoadSkyColor(glm::vec3 sky_color) const
-	{
-		LoadVector(location_sky_color, sky_color);
-	}
-
-	void EntityShader::SetAttributes() const
-	{
-		// Load the position VBO and textureCoords VBO from the VAO into the shader "in" variables
-		SetAttribute(0, "position");
-		SetAttribute(1, "texture_coords");
-		SetAttribute(2, "normal");
-	}
-
-	void EntityShader::GetAllUniformLocations()
-	{
-		// Get the locations from the uniform variables from the shaders
-		location_model_matrix = GetUniformLocation("model_matrix");
-		location_projection_matrix = GetUniformLocation("projection_matrix");
-		location_view_matrix = GetUniformLocation("view_matrix");
-		location_shine_damper = GetUniformLocation("shine_damper");
-		location_reflectivity = GetUniformLocation("reflectivity");
-		location_sky_color = GetUniformLocation("sky_color");
-
-		for (int i = 0; i < MAX_LIGHTS; ++i)
-		{
-			std::string light_pos = std::string("light_position[") + std::to_string(i) + "]";
-			location_light_position[i] = GetUniformLocation(light_pos.c_str());
-
-			std::string light_color = std::string("light_color[") + std::to_string(i) + "]";
-			location_light_color[i] = GetUniformLocation(light_color.c_str());
-
-			std::string light_attenuation = std::string("attenuation[") + std::to_string(i) + "]";
-			location_light_attenuation[i] = GetUniformLocation(light_attenuation.c_str());
-		}
-	}
-}

src/shaders/entity_shader.h

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

src/shaders/gui_shader.cpp

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

src/shaders/gui_shader.h

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

src/shaders/shader_program.cpp

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

src/shaders/shader_program.h

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

src/shaders/static_shader.cpp

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

src/shaders/static_shader.h

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

src/toolbox/Timer.h

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

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)
-	//
+	#define WINDOW_WIDTH 1400
+	#define WINDOW_HEIGT 800
 	
-	/*
-	 * @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,31 +19,26 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="src\collision\collision_handler.cpp" />
-    <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
+    <ClCompile Include="src\scenes\inGameScene.cpp" />
+    <ClCompile Include="src\scenes\scene.cpp" />
     <ClCompile Include="src\computervision\FaceDetector.cpp" />
     <ClCompile Include="src\computervision\ObjectDetection.cpp" />
     <ClCompile Include="src\computervision\SkinDetector.cpp" />
     <ClCompile Include="src\computervision\FingerCount.cpp" />
     <ClCompile Include="src\computervision\BackgroundRemover.cpp" />
     <ClCompile Include="src\entities\camera.cpp" />
-    <ClCompile Include="src\entities\collision_entity.cpp" />
     <ClCompile Include="src\entities\entity.cpp" />
-    <ClCompile Include="src\gui\gui_interactable.cpp" />
     <ClCompile Include="src\main.cpp" />
     <ClCompile Include="src\renderEngine\loader.cpp" />
     <ClCompile Include="src\renderEngine\obj_loader.cpp" />
     <ClCompile Include="src\renderEngine\renderer.cpp" />
-    <ClCompile Include="src\shaders\gui_shader.cpp" />
     <ClCompile Include="src\shaders\shader_program.cpp" />
-    <ClCompile Include="src\shaders\entity_shader.cpp" />
+    <ClCompile Include="src\shaders\static_shader.cpp" />
     <ClCompile Include="src\toolbox\toolbox.cpp" />
-    <ClCompile Include="src\scenes\startup_Scene.cpp" />
+    <ClCompile Include="src\scenes\startupScene.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\collision\collision.h" />
-    <ClInclude Include="src\collision\collision_handler.h" />
-    <ClInclude Include="src\scenes\in_Game_Scene.h" />
+    <ClInclude Include="src\scenes\inGameScene.h" />
     <ClInclude Include="src\scenes\scene.h" />
     <ClInclude Include="src\computervision\FaceDetector.h" />
     <ClInclude Include="src\computervision\FingerCount.h" />
@@ -51,22 +46,16 @@
     <ClInclude Include="src\computervision\SkinDetector.h" />
     <ClInclude Include="src\computervision\ObjectDetection.h" />
     <ClInclude Include="src\entities\camera.h" />
-    <ClInclude Include="src\entities\collision_entity.h" />
     <ClInclude Include="src\entities\entity.h" />
-    <ClInclude Include="src\entities\light.h" />
-    <ClInclude Include="src\gui\gui_element.h" />
-    <ClInclude Include="src\gui\gui_interactable.h" />
     <ClInclude Include="src\models\model.h" />
     <ClInclude Include="src\renderEngine\loader.h" />
     <ClInclude Include="src\renderEngine\obj_loader.h" />
     <ClInclude Include="src\renderEngine\renderer.h" />
-    <ClInclude Include="src\shaders\gui_shader.h" />
     <ClInclude Include="src\shaders\shader_program.h" />
-    <ClInclude Include="src\shaders\entity_shader.h" />
+    <ClInclude Include="src\shaders\static_shader.h" />
     <ClInclude Include="src\stb_image.h" />
-    <ClInclude Include="src\toolbox\Timer.h" />
     <ClInclude Include="src\toolbox\toolbox.h" />
-    <ClInclude Include="src\scenes\startup_Scene.h" />
+    <ClInclude Include="src\scenes\startupScene.h" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />
@@ -129,16 +118,16 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
-    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
+    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include</IncludePath>
+    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);;C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
-    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
+    <IncludePath>$(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>
@@ -170,7 +159,7 @@
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SolutionDir)lib\glfw-3.3.2\$(Platform);$(SolutionDir)lib\glew-2.1.0\lib\Release\$(Platform);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
+      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies); opencv_world452.lib</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -211,7 +200,7 @@
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SolutionDir)lib\glfw-3.3.2\$(Platform);$(SolutionDir)lib\glew-2.1.0\lib\Release\$(Platform);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
+      <AdditionalDependencies>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,33 +33,15 @@
     <ClCompile Include="src\shaders\shader_program.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\shaders\static_shader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="src\renderEngine\obj_loader.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="src\toolbox\toolbox.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\shaders\entity_shader.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\shaders\gui_shader.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\gui\gui_interactable.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\scenes\in_Game_Scene.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\scenes\startup_Scene.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\entities\collision_entity.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\collision\collision_handler.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="src\computervision\ObjectDetection.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -75,6 +57,15 @@
     <ClCompile Include="src\computervision\BackgroundRemover.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\scenes\scene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\scenes\startupScene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\scenes\inGameScene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="src\entities\Camera.h">
@@ -98,45 +89,15 @@
     <ClInclude Include="src\shaders\shader_program.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="src\shaders\static_shader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="src\renderEngine\obj_loader.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="src\toolbox\toolbox.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\entities\light.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\shaders\entity_shader.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\shaders\gui_shader.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\gui\gui_element.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\gui\gui_interactable.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\scenes\scene.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\scenes\in_Game_Scene.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\scenes\startup_Scene.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\entities\collision_entity.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\collision\collision.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="src\collision\collision_handler.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="src\computervision\ObjectDetection.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -152,7 +113,13 @@
     <ClInclude Include="src\computervision\BackgroundRemover.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\toolbox\Timer.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>