[COMMENTS] added some comments for all the scene files

the only thing i could not find was the on key method, the other params are empty(thus no comments)

src/collision/collision.h

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

src/collision/collision_handler.cpp

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

src/collision/collision_handler.h

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

src/computervision/FaceDetector.cpp

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

src/computervision/FaceDetector.h

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

src/computervision/FingerCount.cpp

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

src/computervision/FingerCount.h

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

src/computervision/ObjectDetection.cpp

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

src/computervision/ObjectDetection.h

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

src/computervision/SkinDetector.cpp

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

src/entities/Camera.h

@@ -1,5 +1,5 @@
 #pragma once
-
+#include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
 

src/entities/Entity.h

@@ -11,8 +11,9 @@ namespace entities
 	
 	class Entity
 	{
-	private:
+	protected:
 		models::TexturedModel model;
+		
 		glm::vec3 position;
 		glm::vec3 rotation;
 		float scale;

src/entities/collision_entity.cpp

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

src/entities/collision_entity.h

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

src/gui/gui_interactable.cpp

@@ -1,3 +1,4 @@
+#include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include "gui_interactable.h"
 

src/main.cpp

@@ -3,10 +3,10 @@
 #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>
@@ -19,10 +19,9 @@
 #include "renderEngine/renderer.h"
 #include "shaders/entity_shader.h"
 #include "toolbox/toolbox.h"
-
 #include "scenes/scene.h"
-#include "scenes/startupScene.h"
+#include "scenes/in_Game_Scene.h"
-#include "scenes/inGameScene.h"
+#include "scenes/startup_Scene.h"
 
 #include "computervision/ObjectDetection.h"
 
@@ -33,15 +32,11 @@
 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
+#pragma region OPENGL_SETTINGS
 	if (!glfwInit())
 		throw "Could not inditialize glwf";
 	window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGT, "SDBA", NULL, NULL);
@@ -53,101 +48,52 @@ int main(void)
 	glfwMakeContextCurrent(window);
 	glewInit();
 	glGetError();
-	#pragma endregion
+#pragma endregion
+
+    
+    current_scene = new scene::Startup_Scene();
 
     glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
         {
-            current_scene->onKey(key, scancode, action, mods);
             if (key == GLFW_KEY_ESCAPE)
+            {
                 glfwSetWindowShouldClose(window, true);
-        });
-	
-    scenes[Scenes::STARTUP] = new StartupScene();
-    scenes[Scenes::INGAME] = new InGameScene();
-	
-    models::RawModel raw_model = render_engine::LoadObjModel("res/House.obj");
-    models::ModelTexture texture = { render_engine::loader::LoadTexture("res/Texture.png") };
-    texture.shine_damper = 10;
-    texture.reflectivity = 0;
-    models::TexturedModel model = { raw_model, texture };
-
-    /**
-    * load and add some models (in this case some level sections) to the entities list.
-    * */
-    std::vector<entities::Entity> entities;
-    int z = 0;
-    for (int i = 0; i < 5; ++i)
-    {
-        entities.push_back(entities::Entity(model, glm::vec3(0, -50, -50 - z), glm::vec3(0, 90, 0), 20));
-        z += (raw_model.model_size.x * 20);
             }
     	
-    std::vector<entities::Light> lights;
+            current_scene->onKey(window, key, scancode, action, mods);
-    lights.push_back(entities::Light(glm::vec3(0, 1000, -7000), glm::vec3(5, 5, 5)));
-    lights.push_back(entities::Light(glm::vec3(0, 0, -30), glm::vec3(2, 0, 2), glm::vec3(0.0001f, 0.0001f, 0.0001f)));
-    lights.push_back(entities::Light(glm::vec3(0, 0, -200), glm::vec3(0, 2, 0), glm::vec3(0.0001f, 0.0001f, 0.0001f)));
-
-	shaders::EntityShader shader;
-    shader.Init();
-    render_engine::renderer::Init(shader);
-
-    entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
-
-
-	// GUI stuff
-    shaders::GuiShader gui_shader;
-    gui_shader.Init();
-	
-    std::vector<gui::GuiTexture*> guis;
-    gui::Button button(render_engine::loader::LoadTexture("res/Mayo.png"), glm::vec2(0.5f, 0.0f), glm::vec2(0.25f, 0.25f));
-    button.SetHoverTexture(render_engine::loader::LoadTexture("res/Texture.png"));
-    button.SetClickedTexture(render_engine::loader::LoadTexture("res/Mayo.png"));
-    button.SetOnClickAction([]()
-        {
-            std::cout << "I got clicked on!" << std::endl;
         });
-    guis.push_back(&button);
-	
     
+    bool window_open = true;
 	// Main game loop
-	while (!glfwWindowShouldClose(window))
+	while (!glfwWindowShouldClose(window) && window_open)
 	{
-        // Update
+        //Update
         const double delta = UpdateDelta();
-        camera.Move(window);
-        button.Update(window);
 
-		// Render
+        scene::Scenes return_value = current_scene->start(window);
-        render_engine::renderer::Prepare();
+        delete current_scene;
 
-		// Start rendering the entities
+        switch (return_value) {
-        shader.Start();
+            case scene::Scenes::STOP:
-        shader.LoadSkyColor(render_engine::renderer::SKY_COLOR);
+                window_open = false;
-        shader.LoadLights(lights);
+                break;
-        shader.LoadViewMatrix(camera);
 
-        // Renders each entity in the entities list
+            case scene::Scenes::STARTUP:
-		for (entities::Entity& entity : entities)
+                current_scene = new scene::Startup_Scene();
-		{
+                break;
-            render_engine::renderer::Render(entity, shader);
+
+            case scene::Scenes::INGAME:
+                current_scene = new scene::In_Game_Scene();
+                break;
+
+            default:
+                std::cout << "Wrong return value!!! ->" << std::endl;
+                break;
+        }
 	}
 
-		// Stop rendering the entities
+	// Clean up -> preventing memory leaks!!!
-        shader.Stop();
+    std::cout << "ending..." << std::endl;
-
-        // Render GUI items
-        render_engine::renderer::Render(guis, gui_shader);
-
-        // Finish up
-		glfwSwapBuffers(window);
-		glfwPollEvents();
-	}
-
-	// Clean up
-    shader.CleanUp();
-    gui_shader.CleanUp();
-    render_engine::loader::CleanUp();
-    current_scene->stop();
 	glfwTerminate();
 	return 0;
 }

src/scenes/inGameScene.cpp

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

src/scenes/inGameScene.h

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

src/scenes/in_Game_Scene.cpp

@@ -0,0 +1,186 @@
+#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
+{
+	/**
+	 * sets up the first things when the objects has been made
+	 */
+	In_Game_Scene::In_Game_Scene()
+	{
+		camera = new entities::Camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
+
+		shader = new shaders::EntityShader;
+		shader->Init();	
+		render_engine::renderer::Init(*shader);
+
+		gui_shader = new shaders::GuiShader();
+		gui_shader->Init();
+	}
+	/**
+	 * deletes certain veriables when the object will be deleted, prevents memory leaks
+	 */
+	In_Game_Scene::~In_Game_Scene()
+	{
+		delete camera;
+		delete shader;
+		delete gui_shader;
+	}
+
+	/**
+	 * starts the game scene, calls the render and update methods in a while loop
+	 */
+	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_to_render.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(1, 1));
+		button.SetHoverTexture(render_engine::loader::LoadTexture("res/Texture.png"));
+		button.SetClickedTexture(render_engine::loader::LoadTexture("res/Mayo.png"));
+		button.SetOnClickAction([]()
+		{
+			std::cout << "I got clicked on!" << std::endl;
+		});
+		guis.push_back(&button);
+	
+
+		//guis for the pause menu 
+		gui::GuiTexture background(render_engine::loader::LoadTexture("res/background_grey.png"), glm::vec2(0, 0), glm::vec2(1, 1));
+		pause_guis.push_back(&background);
+
+		gui::Button pause_button_resume(render_engine::loader::LoadTexture("res/Mayo.png"), glm::vec2(0, 0), glm::vec2(0.25f, 0.25f));
+		pause_button_resume.SetHoverTexture(render_engine::loader::LoadTexture("res/Texture.png"));
+		pause_button_resume.SetClickedTexture(render_engine::loader::LoadTexture("res/Mayo.png"));
+		pause_button_resume.SetOnClickAction([]()
+			{
+				std::cout << "I got clicked on the resume button!" << std::endl;
+			});
+		pause_guis.push_back(&pause_button_resume);
+
+		gui::Button pause_button_quit(render_engine::loader::LoadTexture("res/Mayo.png"), glm::vec2(0.3f, 0.0f), glm::vec2(0.25f, 0.25f));
+		pause_button_quit.SetHoverTexture(render_engine::loader::LoadTexture("res/Texture.png"));
+		pause_button_quit.SetClickedTexture(render_engine::loader::LoadTexture("res/Mayo.png"));
+		pause_button_quit.SetOnClickAction([]()
+			{
+				std::cout << "I got clicked on the quit button!" << std::endl;
+			});
+		pause_guis.push_back(&pause_button_quit);
+
+
+		//the scene loop, this while loop represent the scene
+		while (return_value == scene::Scenes::INGAME)
+		{
+			//checks the current game state, so it can render the correct models for each state
+			switch (game_state) 
+			{
+			/*case scene::Game_State::IDLE:
+				break;*/
+
+			case scene::Game_State::PAUSED:
+				render();
+				render_pause_menu();
+				break;
+
+			case scene::Game_State::RUNNING:
+				update(window);
+				button.Update(window);
+				render();
+				break;
+
+			default:
+				std::cout << "Game state unknown" << std::endl;
+				break;
+			}
+			
+
+			glfwSwapBuffers(window);
+			glfwPollEvents();
+		}
+		shader->CleanUp();
+		gui_shader->CleanUp();
+		render_engine::loader::CleanUp();
+		return return_value;
+	}
+
+	/**
+	 * renders the game models
+	 */
+	void scene::In_Game_Scene::render()
+	{
+		// Render
+		render_engine::renderer::Prepare();
+		//starts the shader and begins to render
+		shader->Start();
+		shader->LoadSkyColor(render_engine::renderer::SKY_COLOR);
+		shader->LoadLights(lights);
+		shader->LoadViewMatrix(*camera);
+
+		// Renders each entity in the entities list
+		for (entities::Entity& entity : entities_to_render)
+		{
+			render_engine::renderer::Render(entity, *shader);
+		}
+
+		// Render GUI items
+		//render_engine::renderer::Render(guis, *gui_shader);
+
+		// Stop rendering the entities
+		shader->Stop();
+	}
+
+	//updates certain variables 
+	void scene::In_Game_Scene::update(GLFWwindow* window)
+	{
+		camera->Move(window);
+	}
+
+	//renders the models for the pause menu
+	void In_Game_Scene::render_pause_menu()
+	{
+		render_engine::renderer::Render(pause_guis, *gui_shader);
+	}
+
+	//manages the key input in the game scene
+	void scene::In_Game_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
+	{
+		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+		{
+			return_value = scene::Scenes::STOP;
+		}
+		if (glfwGetKey(window, GLFW_KEY_P) == GLFW_PRESS)
+		{
+			game_state = scene::Game_State::PAUSED;
+		}
+		if (glfwGetKey(window, GLFW_KEY_O) == GLFW_PRESS)
+		{
+			game_state = scene::Game_State::RUNNING;
+		}
+	}
+}

src/scenes/in_Game_Scene.h

@@ -0,0 +1,102 @@
+#pragma once
+#include <iostream>
+#include <ostream>
+#include <vector>
+#include "scene.h"
+#include "../gui/gui_interactable.h"
+#include "../models/model.h"
+#include "../renderEngine/loader.h"
+#include "../renderEngine/obj_loader.h"
+#include "../renderEngine/renderer.h"
+#include "../shaders/entity_shader.h"
+#include "../toolbox/toolbox.h"
+
+
+namespace scene
+{
+	/**
+	* This enum is for managing the game scene state.  
+	* for example: when pressed on a specific button, the game will be in a paused state and nothing about the player or the speed of the game will be updated
+	* and the pause screen will show up.
+	**/
+	enum class Game_State
+	{
+		//IDLE,
+		RUNNING,
+		PAUSED
+	};
+
+
+	class In_Game_Scene : public scene::Scene
+	{
+	private:
+		//return_value is an enum that is necessary for the scene switching. Whenever this changes, the scene will change to a different scene.
+		scene::Scenes return_value = scene::Scenes::INGAME;
+		//game_state is an enum that keeps track of the current game state. For example: is the game running(thus the user is playing the game) of is the game paused.
+		scene::Game_State game_state = scene::Game_State::RUNNING;
+
+		//entities_to_render is a list of entities, those entities will be rendered in the 3D environment.
+		std::vector<entities::Entity> entities_to_render;
+		//lights is a lost of light points in the game, for example the sun or it can be used to attach light effects to lamps.
+		std::vector<entities::Light> lights;
+		
+		models::RawModel raw_model;
+		models::ModelTexture texture;
+		//the shader that is used for rendering the models.
+		shaders::EntityShader* shader;
+		//the gui_shader is used of rendering the gui models (for example the pause buttons).
+		shaders::GuiShader* gui_shader;
+		//camera is the camera view of the game scene, this camera will be behind the main character.
+		entities::Camera *camera;
+		//guis is a list of all the gui components that needs to be load in the scene.
+		std::vector<gui::GuiTexture*> guis;
+		//pause_guis is a list of components that will be rendered when the game is paused.
+		std::vector<gui::GuiTexture*> pause_guis;
+
+		/**
+		 * @brief renders the objects/gui models
+		 * @param 
+		 * @return void
+		 */
+		void render_pause_menu();
+
+	
+	public:
+		In_Game_Scene();
+		~In_Game_Scene();
+
+		/**
+		 * @brief the method start is the start of the scene where a while loop runs, this runs the scene.
+		 * @param window the main window of the application
+		 * @return Scene value that indicates in which scene the application is
+		 */
+		Scenes start(GLFWwindow* window) override;
+
+		/**
+		 * @brief this method renders the models for the game scene
+		 * @param 
+		 * @return void
+		 */
+		void render() override;
+
+		/**
+		 * @brief this method updates the models/variables for the game scene
+		 * @param window the main window of the application
+		 * @return void
+		 */
+		void update(GLFWwindow* window) override;
+
+		/**
+		 * @brief this method updates the models/variables for the game scene
+		 * @param window the main window of the application
+		 * @param key this is the keycode on which key has been pressed 
+		 * @param scancode -
+		 * @param action-
+		 * @param mods -
+		 * @return void
+		 */
+		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
+	};
+}
+
+

src/scenes/scene.cpp

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

src/scenes/scene.h

@@ -1,23 +1,60 @@
 #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
+	/**
-{
+	 * this enum represents the scenes in the game, those wil help to keep track in which scene the game is.
+	 */
+	enum class Scenes
+	{
 		STARTUP,
 		INGAME,
 		GAMEOVER,
-	SETTINGS,
+		CALIBRATION,
-	CALIBRATION
+		STOP
-};
+	};
+
+	class Scene
+	{
+	public:
+		virtual ~Scene() = 0;
+
+		/**
+		 * @brief the method start is the start of a scene where a while loop runs, this runs the scene.
+		 * @param window the main window of the application
+		 * @return Scene value that indicates in which scene the application is
+		 */
+		virtual Scenes start(GLFWwindow* window) = 0;
+
+		/**
+		 * @brief this method renders the models for a scene
+		 * @param
+		 * @return void
+		 */
+		virtual void render() = 0;
+
+		/**
+		 * @brief this method updates the models/variables for a scene
+		 * @param window the main window of the application
+		 * @return void
+		 */
+		virtual void update(GLFWwindow* window) = 0;
+
+		/**
+		 * @brief this method updates the models/variables for a scene
+		 * @param window the main window of the application
+		 * @param key this is the keycode on which key has been pressed
+		 * @param scancode -
+		 * @param action-
+		 * @param mods -
+		 * @return void
+		 */
+		virtual void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) {};
+	};
+}
+
+

src/scenes/startupScene.cpp

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

src/scenes/startupScene.h

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

src/scenes/startup_Scene.cpp

@@ -0,0 +1,60 @@
+#include <iostream>
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <map>
+#include "startup_Scene.h"
+
+namespace scene
+{
+	/**
+	 * deletes certain variables to prevent memory leaks
+	 */
+	Startup_Scene::~Startup_Scene()
+	{
+		std::cout << "startup scene gone!" << std::endl;
+	}
+
+	/**
+	 * starts the start-up scene, calls the render and update methods in a while loop
+	 */
+	scene::Scenes scene::Startup_Scene::start(GLFWwindow *window)
+	{
+		while (return_value == scene::Scenes::STARTUP)
+		{
+			render();
+			update(window);
+
+			glfwSwapBuffers(window);
+			glfwPollEvents();
+		}
+
+		return return_value;
+	}
+
+	/**
+	 * renders the models in the start-up scene
+	 */
+	void scene::Startup_Scene::render() 
+	{
+
+	}
+
+	/**
+	 * updates the variables for the start-up scene
+	 */
+	void scene::Startup_Scene::update(GLFWwindow* window)
+	{
+
+	}
+
+	/**
+	 * manages the key input in the start-up scene
+	 */
+	void scene::Startup_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
+	{
+		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+		{
+			return_value = scene::Scenes::INGAME;
+		}
+	}
+}

src/scenes/startup_Scene.h

@@ -0,0 +1,52 @@
+#pragma once
+#include "scene.h"
+#include <map>
+
+namespace scene
+{
+	extern GLFWwindow* window;
+
+	class Startup_Scene : public scene::Scene
+	{
+	private:
+		//return_value is an enum that is necessary for the scene switching. Whenever this changes, the scene will change to a different scene.
+		scene::Scenes return_value = scene::Scenes::STARTUP;
+
+	public:
+		~Startup_Scene();
+
+		/**
+		 * @brief the method start is the start of the start-up scene where a while loop runs, this runs the scene.
+		 * @param window the main window of the application
+		 * @return Scene value that indicates in which scene the application is
+		 */
+		Scenes start(GLFWwindow* window) override;
+
+		/**
+		 * @brief this method renders the models for the start-up scene
+		 * @param
+		 * @return void
+		 */
+		void render() override;
+
+		/**
+		 * @brief this method updates the models/variables for the start-up scene
+		 * @param window the main window of the application
+		 * @return void
+		 */
+		void update(GLFWwindow* window) override;
+
+		/**
+		 * @brief this method updates the models/variables for the start-up scene
+		 * @param window the main window of the application
+		 * @param key this is the keycode on which key has been pressed
+		 * @param scancode -
+		 * @param action-
+		 * @param mods -
+		 * @return void
+		 */
+		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
+	};
+}
+
+

src/shaders/shader_program.cpp

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

src/toolbox/Timer.h

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

wk2_fps.vcxproj

@@ -19,33 +19,40 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="src\scenes\inGameScene.cpp" />
+    <ClCompile Include="src\collision\collision_handler.cpp" />
-    <ClCompile Include="src\scenes\scene.cpp" />
+    <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
+    <ClCompile Include="src\computervision\FaceDetector.cpp" />
     <ClCompile Include="src\computervision\ObjectDetection.cpp" />
     <ClCompile Include="src\computervision\SkinDetector.cpp" />
     <ClCompile Include="src\computervision\FingerCount.cpp" />
     <ClCompile Include="src\computervision\BackgroundRemover.cpp" />
     <ClCompile Include="src\entities\camera.cpp" />
+    <ClCompile Include="src\entities\collision_entity.cpp" />
     <ClCompile Include="src\entities\entity.cpp" />
     <ClCompile Include="src\gui\gui_interactable.cpp" />
     <ClCompile Include="src\main.cpp" />
     <ClCompile Include="src\renderEngine\loader.cpp" />
     <ClCompile Include="src\renderEngine\obj_loader.cpp" />
     <ClCompile Include="src\renderEngine\renderer.cpp" />
+    <ClCompile Include="src\scenes\scene.cpp" />
     <ClCompile Include="src\shaders\gui_shader.cpp" />
     <ClCompile Include="src\shaders\shader_program.cpp" />
     <ClCompile Include="src\shaders\entity_shader.cpp" />
     <ClCompile Include="src\toolbox\toolbox.cpp" />
-    <ClCompile Include="src\scenes\startupScene.cpp" />
+    <ClCompile Include="src\scenes\startup_Scene.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\scenes\inGameScene.h" />
+    <ClInclude Include="src\collision\collision.h" />
+    <ClInclude Include="src\collision\collision_handler.h" />
+    <ClInclude Include="src\scenes\in_Game_Scene.h" />
     <ClInclude Include="src\scenes\scene.h" />
+    <ClInclude Include="src\computervision\FaceDetector.h" />
     <ClInclude Include="src\computervision\FingerCount.h" />
     <ClInclude Include="src\computervision\BackgroundRemover.h" />
     <ClInclude Include="src\computervision\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" />
@@ -58,8 +65,9 @@
     <ClInclude Include="src\shaders\shader_program.h" />
     <ClInclude Include="src\shaders\entity_shader.h" />
     <ClInclude Include="src\stb_image.h" />
+    <ClInclude Include="src\toolbox\Timer.h" />
     <ClInclude Include="src\toolbox\toolbox.h" />
-    <ClInclude Include="src\scenes\startupScene.h" />
+    <ClInclude Include="src\scenes\startup_Scene.h" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />
@@ -122,16 +130,16 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include</IncludePath>
+    <IncludePath>C:\opencv\build\include;$(IncludePath);C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
-    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
+    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(LibraryPath);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);;C:\opencv\opencv\build\include</IncludePath>
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);;C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
-    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -163,7 +171,7 @@
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SolutionDir)lib\glfw-3.3.2\$(Platform);$(SolutionDir)lib\glew-2.1.0\lib\Release\$(Platform);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies); opencv_world452.lib</AdditionalDependencies>
+      <AdditionalDependencies>opencv_world452d.lib;%(AdditionalDependencies); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -204,7 +212,7 @@
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SolutionDir)lib\glfw-3.3.2\$(Platform);$(SolutionDir)lib\glew-2.1.0\lib\Release\$(Platform);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies); opencv_world452.lib</AdditionalDependencies>
+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

wk2_fps.vcxproj.filters

@@ -48,6 +48,18 @@
     <ClCompile Include="src\gui\gui_interactable.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\scenes\in_Game_Scene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\scenes\startup_Scene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\entities\collision_entity.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\collision\collision_handler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="src\computervision\ObjectDetection.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -57,18 +69,15 @@
     <ClCompile Include="src\computervision\FingerCount.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\computervision\FaceDetector.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="src\computervision\BackgroundRemover.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="src\scenes\scene.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\scenes\startupScene.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="src\scenes\inGameScene.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="src\entities\Camera.h">
@@ -113,6 +122,24 @@
     <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>
@@ -122,16 +149,13 @@
     <ClInclude Include="src\computervision\FingerCount.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="src\computervision\FaceDetector.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="src\computervision\BackgroundRemover.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\scenes\scene.h">
+    <ClInclude Include="src\toolbox\Timer.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>