[EDIT] models now generate in a 3x3 grid with always 9 models

Good enough

.gitignore

@@ -2,6 +2,8 @@
 # Created by https://www.toptal.com/developers/gitignore/api/c++,visualstudio,visualstudiocode,opencv
 # Edit at https://www.toptal.com/developers/gitignore?templates=c++,visualstudio,visualstudiocode,opencv
 
+res/**
+
 ### C++ ###
 # Prerequisites
 *.d

enc_temp_folder/e14e1bac1d366a32333657ac3b22e523/house_generator.cpp

@@ -0,0 +1,340 @@
+#include "house_generator.h"
+
+#include <functional>
+#include <iostream>
+
+#include "../renderEngine/obj_loader.h"
+#include "../renderEngine/Loader.h"
+#include "../toolbox/toolbox.h"
+#include "collision_entity.h"
+
+namespace entities
+{
+	HouseGenerator::HouseGenerator()
+	{
+		models::RawModel raw_model = render_engine::LoadObjModel("res/HouseNew.obj");
+		default_texture = { render_engine::loader::LoadTexture("res/Texture.png") };
+		default_texture.shine_damper = 10;
+		house_model = { raw_model, default_texture };
+
+		GenerateFurnitureModels();
+	}
+
+	const FurniturePiece* HouseGenerator::GetRandomFurniturePiece()
+	{
+		FurnitureType random_type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
+
+		for(std::deque<FurnitureModel>::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it)
+		{
+			if(it->furniture.type == random_type)
+			{
+				return &it->furniture;
+			}
+		}
+		
+		return nullptr;
+	}
+	
+	std::deque<std::shared_ptr<Entity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
+	{
+		std::deque<std::shared_ptr<Entity>> furniture;
+
+		// Add house
+		furniture.push_front(std::make_shared<Entity>(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE));
+		int house_size = house_model.raw_model.model_size.x * HOUSE_SIZE;
+		int offset_x = house_model.raw_model.model_size.z * (HOUSE_SIZE/2);
+		int offset_z = house_model.raw_model.model_size.x *( HOUSE_SIZE/2);
+		double multiplier_x = house_size/2;
+		double multiplier_z = house_size / 3;
+		
+		for (int z = 1; z < 4; z++) {
+			for (int x = 1; x < 3; x++)
+			{
+				//if (toolbox::Random(0, 100) < 50) {
+						const FurniturePiece* furniture_piece = GetRandomFurniturePiece();
+						models::TexturedModel model = GetFurnitureModel(furniture_piece);
+						//if (//check of size van furniture nog past in huidige grid vlakje, of ie geen 2 size op t laatste vakje neerzet) {
+						glm::vec3 model_pos = glm::vec3(position.x + (x * multiplier_x) - (multiplier_x/2) - offset_x, position.y, position.z + (z * multiplier_z) - (multiplier_z / 2) + offset_z);
+
+						collision::Box model_box = { model_pos, model.raw_model.model_size };
+						model_box.SetRotation(-90);
+						furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box));
+					//}
+					//}
+				}
+			}
+
+		return furniture;
+		
+		/*
+		// Add furniture
+		models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH);
+		glm::vec3 couch_pos = glm::vec3(position.x + 200, position.y, position.z + 10);
+		collision::Box couch_box = { couch_pos, couch.raw_model.model_size };
+		couch_box.SetRotation(-90);
+		furniture.push_back(std::make_shared<CollisionEntity>(couch, couch_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, couch_box));
+
+		models::TexturedModel table = GetFurnitureModel(FurnitureType::TABLE);
+		glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
+		collision::Box table_box = { table_pos, table.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(table, table_pos, glm::vec3(0, 0, 0), HOUSE_SIZE * 1.3, table_box));
+
+		models::TexturedModel chair = GetFurnitureModel(FurnitureType::CHAIR);
+		glm::vec3 chair_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box chair_box = { chair_pos, chair.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(chair, chair_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, chair_box));
+
+		models::TexturedModel plant = GetFurnitureModel(FurnitureType::PLANT);
+		glm::vec3 plant_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box plant_box = { plant_pos, plant.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(plant, plant_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, plant_box));
+
+		models::TexturedModel guitar = GetFurnitureModel(FurnitureType::GUITAR);
+		glm::vec3 guitar_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box guitar_box = { guitar_pos, guitar.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(guitar, guitar_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, guitar_box));
+		
+		models::TexturedModel bookshelf = GetFurnitureModel(FurnitureType::BOOKSHELF);
+		glm::vec3 bookshelf_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box bookshelf_box = { bookshelf_pos, bookshelf.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(bookshelf, bookshelf_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, bookshelf_box));
+
+		models::TexturedModel lamp = GetFurnitureModel(FurnitureType::LAMP);
+		glm::vec3 lamp_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box lamp_box = { lamp_pos, lamp.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(lamp, lamp_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, lamp_box));
+
+		models::TexturedModel ceiling_object = GetFurnitureModel(FurnitureType::CEILING_OBJECTS);
+		glm::vec3 ceiling_object_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box ceiling_object_box = { ceiling_object_pos, ceiling_object.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(ceiling_object, ceiling_object_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, ceiling_object_box));
+
+		models::TexturedModel misc = GetFurnitureModel(FurnitureType::MISC);
+		glm::vec3 misc_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box misc_box = { misc_pos, misc.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box));
+		*/
+		
+	}
+
+	models::TexturedModel HouseGenerator::GetFurnitureModel(const FurniturePiece* furniture)
+	{
+		std::deque<models::TexturedModel> *furniture_list = nullptr;
+		
+		for (std::deque<FurnitureModel>::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it)
+		{
+			if(it->furniture.type == furniture->type)
+			{
+				furniture_list = &it->texture;
+			}
+		}
+		
+		if (furniture_list == nullptr)
+		{
+			std::cerr << "OH NEEEEEEEEEEEEEEE";
+		}
+		
+		const int modelNumber = toolbox::Random(0, furniture_list->size() - 1);
+		
+		return furniture_list->at(modelNumber);
+		
+		//return {};
+	}
+
+	void HouseGenerator::GenerateFurnitureModels()
+	{
+		// Couches
+		std::deque<models::TexturedModel> couches;
+		
+		models::RawModel couch_inside_model = render_engine::LoadObjModel("res/couchThree.obj");
+		models::TexturedModel couch_inside = { couch_inside_model, default_texture };
+		couches.push_back(couch_inside);
+
+		models::RawModel couch_inside_model2 = render_engine::LoadObjModel("res/Coach.obj");
+		models::TexturedModel couch_inside2 = { couch_inside_model2, default_texture };
+		couches.push_back(couch_inside2);
+
+		models::RawModel couch_inside_model3 = render_engine::LoadObjModel("res/lawnBenchOne.obj");
+		models::TexturedModel couch_inside3 = { couch_inside_model3, default_texture };
+		couches.push_back(couch_inside3);
+
+		FurnitureModel couch;
+		couch.furniture = {
+		FurnitureType::COUCH, 2 };
+		couch.texture = couches;
+		
+		furniture_models.push_back(couch);
+
+		// Tables
+		std::deque<models::TexturedModel> tables;
+
+		models::RawModel table_model1 = render_engine::LoadObjModel("res/tableOne.obj");
+		models::TexturedModel table1 = { table_model1, default_texture };
+		tables.push_back(table1);
+
+		models::RawModel table_model2 = render_engine::LoadObjModel("res/tableTwo.obj");
+		models::TexturedModel table2 = { table_model2, default_texture };
+		tables.push_back(table2);
+
+		models::RawModel table_model3 = render_engine::LoadObjModel("res/bureauOne.obj");
+		models::TexturedModel table3 = { table_model3, default_texture };
+		tables.push_back(table3);
+		
+		FurnitureModel table;
+		table.furniture = {
+		FurnitureType::TABLE, 2 };
+		table.texture = tables;
+		
+		furniture_models.push_back(table);
+
+		// Chairs
+		std::deque<models::TexturedModel> chairs;
+
+		models::RawModel chair_model1 = render_engine::LoadObjModel("res/launchchair.obj");
+		models::TexturedModel chair1 = { chair_model1, default_texture };
+		chairs.push_back(chair1);
+
+		models::RawModel chair_model2 = render_engine::LoadObjModel("res/lawnChairOne.obj");
+		models::TexturedModel chair2 = { chair_model2, default_texture };
+		chairs.push_back(chair2);
+
+		models::RawModel chair_model3 = render_engine::LoadObjModel("res/ugly_chair.obj");
+		models::TexturedModel chair3 = { chair_model3, default_texture };
+		chairs.push_back(chair3);
+
+		FurnitureModel chair;
+		chair.furniture = {
+		FurnitureType::CHAIR, 1 };
+		chair.texture = chairs;
+
+		furniture_models.push_back(chair);
+
+		// Plants
+		std::deque<models::TexturedModel> plants;
+
+		models::RawModel plant_model1 = render_engine::LoadObjModel("res/plantOne.obj");
+		models::TexturedModel plant1 = { plant_model1, default_texture };
+		plants.push_back(plant1);
+
+		models::RawModel plant_model2 = render_engine::LoadObjModel("res/plantTwo.obj");
+		models::TexturedModel plant2 = { plant_model2, default_texture };
+		plants.push_back(plant2);
+
+		models::RawModel plant_model3 = render_engine::LoadObjModel("res/plantThree.obj");
+		models::TexturedModel plant3 = { plant_model3, default_texture };
+		plants.push_back(plant3);
+
+		FurnitureModel plant;
+		plant.furniture = {
+		FurnitureType::PLANT, 1 };
+		plant.texture = plants;
+
+		furniture_models.push_back(plant);
+
+		// Guitars
+		std::deque<models::TexturedModel> guitars;
+
+		models::RawModel guitar_model1 = render_engine::LoadObjModel("res/guitarOne.obj");
+		models::TexturedModel guitar1 = { guitar_model1, default_texture };
+		guitars.push_back(guitar1);
+
+		models::RawModel guitar_model2 = render_engine::LoadObjModel("res/guitarTwo.obj");
+		models::TexturedModel guitar2 = { guitar_model2, default_texture };
+		guitars.push_back(guitar2);
+
+		FurnitureModel guitar;
+		guitar.furniture = {
+		FurnitureType::GUITAR, 1 };
+		guitar.texture = guitars;
+
+		furniture_models.push_back(guitar);
+
+		// Bookshelves
+		std::deque<models::TexturedModel> bookshelves;
+
+		models::RawModel bookshelf_model1 = render_engine::LoadObjModel("res/bookShelfOne.obj");
+		models::TexturedModel bookshelf1 = { bookshelf_model1, default_texture };
+		bookshelves.push_back(bookshelf1);
+
+		models::RawModel bookshelf_model2 = render_engine::LoadObjModel("res/bookShelfTwo.obj");
+		models::TexturedModel bookshelf2 = { bookshelf_model2, default_texture };
+		bookshelves.push_back(bookshelf2);
+
+		models::RawModel bookshelf_model3 = render_engine::LoadObjModel("res/bookShelfThree.obj");
+		models::TexturedModel bookshelf3 = { bookshelf_model3, default_texture };
+		bookshelves.push_back(bookshelf3);
+
+		FurnitureModel bookshelf;
+		bookshelf.furniture = {
+		FurnitureType::BOOKSHELF, 1 };
+		bookshelf.texture = bookshelves;
+
+		furniture_models.push_back(bookshelf);
+
+		// Lamps
+		std::deque<models::TexturedModel>lamps;
+
+		models::RawModel lamp_model1 = render_engine::LoadObjModel("res/lampOne.obj");
+		models::TexturedModel lamp1 = { lamp_model1, default_texture };
+		lamps.push_back(lamp1);
+
+		models::RawModel lamp_model2 = render_engine::LoadObjModel("res/lampTwo.obj");
+		models::TexturedModel lamp2 = { lamp_model2, default_texture };
+		lamps.push_back(lamp2);
+
+		FurnitureModel lamp;
+		lamp.furniture = {
+		FurnitureType::LAMP, 1 };
+		lamp.texture = lamps;
+
+		furniture_models.push_back(lamp);
+
+		// Ceiling objects
+		std::deque<models::TexturedModel>ceiling_Objects;
+
+		models::RawModel ceiling_Obj_model1 = render_engine::LoadObjModel("res/ceilingFan.obj");
+		models::TexturedModel ceiling_Obj1 = { ceiling_Obj_model1, default_texture };
+		ceiling_Objects.push_back(ceiling_Obj1);
+
+		models::RawModel ceiling_Obj_model2 = render_engine::LoadObjModel("res/ceilingFanTwo.obj");
+		models::TexturedModel ceiling_Obj2 = { ceiling_Obj_model2, default_texture };
+		ceiling_Objects.push_back(ceiling_Obj2);
+
+		models::RawModel ceiling_Obj_model3 = render_engine::LoadObjModel("res/ceilingLampOne.obj");
+		models::TexturedModel ceiling_Obj3 = { ceiling_Obj_model3, default_texture };
+		ceiling_Objects.push_back(ceiling_Obj3);
+
+		models::RawModel ceiling_Obj_model4 = render_engine::LoadObjModel("res/ceilingLampTwo.obj");
+		models::TexturedModel ceiling_Obj4 = { ceiling_Obj_model4, default_texture };
+		ceiling_Objects.push_back(ceiling_Obj4);
+
+		FurnitureModel ceiling_object;
+		ceiling_object.furniture = {
+		FurnitureType::CEILING_OBJECTS, 1 };
+		ceiling_object.texture = ceiling_Objects;
+
+		furniture_models.push_back(ceiling_object);
+
+		// Miscs
+		std::deque<models::TexturedModel> miscs;
+
+		models::RawModel misc_model1 = render_engine::LoadObjModel("res/tv.obj");
+		models::TexturedModel misc1 = { misc_model1, default_texture };
+		miscs.push_back(misc1);
+
+		models::RawModel misc_model2 = render_engine::LoadObjModel("res/radio.obj");
+		models::TexturedModel misc2 = { misc_model2, default_texture };
+		miscs.push_back(misc2);
+
+		models::RawModel misc_model3 = render_engine::LoadObjModel("res/Flowerpot.obj");
+		models::TexturedModel misc3 = { misc_model3, default_texture };
+		miscs.push_back(misc3);
+
+		FurnitureModel misc;
+		misc.furniture = {
+		FurnitureType::MISC, 1 };
+		misc.texture = miscs;
+
+		furniture_models.push_back(misc);		
+	}
+}

src/collision/collision.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <iostream>
 #include <glm/gtc/matrix_transform.hpp>
 #include "../entities/entity.h"
 
@@ -15,6 +16,18 @@ namespace collision
 	{
 		glm::vec3 center_pos;
 		glm::vec3 size;
+
+		void SetRotation(float angle)
+		{
+			double sinTheta = glm::sin(glm::radians(angle));
+			double cosTheta = glm::cos(glm::radians(angle));
+
+			float x = size.x * cosTheta + size.z * sinTheta;
+			float z = size.z * cosTheta - size.x * sinTheta;
+			
+			size.x = x < 0 ? -x : x;
+			size.z = z < 0 ? -z : z;
+		}
 	};
 
 	/*

src/collision/collision_handler.cpp

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

src/collision/collision_handler.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>
 #include <vector>
 #include "../entities/collision_entity.h"
 #include "collision.h"
@@ -12,5 +13,5 @@ namespace collision
 	 *
 	 * @param entities: A list with all the collision entities.
 	 */
-	void CheckCollisions(std::vector<entities::CollisionEntity*>& entities);
+	void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>> entities);
 }

src/computervision/MenuTest.cpp

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

src/computervision/MenuTest.h

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

src/computervision/ObjectDetection.cpp

@@ -69,8 +69,6 @@ namespace computervision
 		hand_calibrator.DrawHandCalibrationText(camera_frame);
 		imshow("camera", camera_frame);
 
-
-
 		/*imshow("output", frame_out);
 		imshow("foreground", foreground);
 		imshow("handMask", handMask);

src/entities/Camera.cpp

@@ -1,4 +1,6 @@
 #include "camera.h"
+#include <iostream>
+#include "../toolbox/toolbox.h"
 
 namespace entities
 {
@@ -7,9 +9,20 @@ namespace entities
 		rotation(rotation)
 	{}
 
+	void Camera::Follow(glm::vec3 follow_position) {
+		//set position to follow in front of the camera
+		follow_position.z += 100;
+		//set position to follow a bit lower
+		follow_position.y += 50;
+		//move position from original position to given position with smoothing
+		position = toolbox::Lerp(position, follow_position, 0.1);
+	}
+	
 	void Camera::Move(GLFWwindow* window)
 	{
 		float movement_speed = 0;
+		float up_down_speed = 0;
+		float side_speed = 0;
 		
 		if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
 		{
@@ -23,28 +36,25 @@ namespace entities
 
 		if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
 		{
-			rotation.y += ROT_SPEED;
+			side_speed += SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
 		{
-			rotation.y -= ROT_SPEED;
+			side_speed -= SPEED;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
 		{
-			rotation.x -= ROT_SPEED;
+			up_down_speed += UP_SPEED;
 		}
-
 		if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
 		{
-			rotation.x += ROT_SPEED;
+			up_down_speed -= UP_SPEED;
 		}
 
-		float dx = glm::cos(glm::radians(rotation.y + 90)) * movement_speed;
+		position.x += side_speed;
-		float dz = glm::sin(glm::radians(rotation.y + 90)) * movement_speed;
+		position.z += movement_speed;
-
+		position.y += up_down_speed;
-		position.x += dx;
-		position.z += dz;
 	}
 }

src/entities/Camera.h

@@ -13,13 +13,14 @@ namespace entities
 	{
 	private:
 		// The movement speed of the camera
-		const float SPEED = 0.52f;
+		const float SPEED = 0.5f;
-		const float ROT_SPEED = 1.0f;
+		const float UP_SPEED = 1.0f;
 		
 		glm::vec3 position;
 		glm::vec3 rotation;
 
 	public:
+		
 		Camera(const ::glm::vec3& position, const ::glm::vec3& rotation);
 
 		/*
@@ -29,6 +30,13 @@ namespace entities
 		 */
 		void Move(GLFWwindow* window);
 
+		/*
+		 * @brief follows the given position with smoothing
+		 *
+		 * @param follow_position the position of the object the camera has to follow
+		 */
+		void Follow(glm::vec3 follow_position);
+		
 		inline glm::vec3 GetPosition() const{ return position; }
 		inline glm::vec3 GetRotation() const{ return rotation; }
 	};

src/entities/collision_entity.cpp

@@ -14,7 +14,9 @@ namespace entities
 	{
 		if (on_collide != nullptr)
 		{
-			on_collide(collision);
+			
+				on_collide(collision);
+			
 		}
 	}
 

src/entities/collision_entity.h

@@ -2,6 +2,8 @@
 
 #include "entity.h"
 #include "../collision/collision.h"
+#include <memory>
+#include <functional>
 
 namespace entities
 {
@@ -16,7 +18,8 @@ namespace entities
 		glm::vec3 min_xyz;
 		glm::vec3 max_xyz;
 
-		void (*on_collide)(const collision::Collision& collision);
+		//void (*on_collide)(const collision::Collision& collision);
+		std::function<void(const collision::Collision&)> on_collide;
 
 	public:
 		CollisionEntity(const models::TexturedModel& model, const glm::vec3& position, const glm::vec3& rotation,
@@ -52,7 +55,7 @@ namespace entities
 		 *
 		 * @param function: A function pointer to a function with the collision behaviour
 		 */
-		void SetCollisionBehaviour(void (*function)(const collision::Collision& collision))
+		void SetCollisionBehaviour(std::function<void(const collision::Collision&)> function)
 		{ if (function != nullptr) { on_collide = function; } }
 
 	protected:

src/entities/house_generator.cpp

@@ -0,0 +1,366 @@
+#include "house_generator.h"
+
+#include <functional>
+#include <iostream>
+
+#include "../renderEngine/obj_loader.h"
+#include "../renderEngine/Loader.h"
+#include "../toolbox/toolbox.h"
+#include "collision_entity.h"
+
+namespace entities
+{
+	HouseGenerator::HouseGenerator()
+	{
+		models::RawModel raw_model = render_engine::LoadObjModel("res/HouseNew.obj");
+		default_texture = { render_engine::loader::LoadTexture("res/Texture.png") };
+		default_texture.shine_damper = 10;
+		house_model = { raw_model, default_texture };
+
+		GenerateFurnitureModels();
+	}
+
+	const FurniturePiece* HouseGenerator::GetRandomFurniturePiece()
+	{
+		FurnitureType random_type = FurnitureType::CEILING_OBJECTS;
+		while (random_type == FurnitureType::CEILING_OBJECTS ) {
+			random_type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
+		}
+
+		for (std::deque<FurnitureModel>::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it)
+		{
+			if (it->furniture.type == random_type)
+			{
+				return &it->furniture;
+			}
+		}
+
+		return nullptr;
+	}
+
+	const FurniturePiece* HouseGenerator::GetFurniturePiece(FurnitureType type)
+	{
+		for (std::deque<FurnitureModel>::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it)
+		{
+			if (it->furniture.type == type)
+			{
+				return &it->furniture;
+			}
+		}
+		return nullptr;
+	}
+
+	std::deque<std::shared_ptr<Entity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
+	{
+		std::deque<std::shared_ptr<Entity>> furniture;
+
+		// Add house
+		furniture.push_front(std::make_shared<Entity>(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE));
+		int house_size_x = house_model.raw_model.model_size.x * HOUSE_SIZE;
+		int house_size_y = house_model.raw_model.model_size.x * HOUSE_SIZE;
+		int house_size_z = house_model.raw_model.model_size.x * HOUSE_SIZE;
+
+		int offset_x = house_model.raw_model.model_size.z * (HOUSE_SIZE / 2);
+		int offset_z = house_model.raw_model.model_size.x * (HOUSE_SIZE / 2);
+		double multiplier_x = house_size_x / 4;
+		double multiplier_z = house_size_z / 3;
+
+		for (int z = 1; z < 4; z++) {
+			for (int x = 1; x < 4; x++)
+			{
+				//if (toolbox::Random(0, 100) < 90) {
+					const FurniturePiece* furniture_piece = GetRandomFurniturePiece();
+					if (furniture_piece->type != FurnitureType::CEILING_OBJECTS) {
+						models::TexturedModel model = GetFurnitureModel(furniture_piece);
+						//if (!(furniture_piece->size > 1 && x > 1)) {
+							glm::vec3 model_pos = glm::vec3(position.x + (x * multiplier_x) - (multiplier_x / 2) - offset_x, position.y, position.z + (z * multiplier_z) - (multiplier_z / 2) + offset_z);
+
+							collision::Box model_box = { model_pos, model.raw_model.model_size };
+							model_box.SetRotation(-90);
+							furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box));
+						}
+					//}
+				//}
+			}
+		}
+
+		models::TexturedModel model = GetFurnitureModel(GetFurniturePiece(FurnitureType::CEILING_OBJECTS));
+		glm::vec3 model_pos = glm::vec3(position.x, position.y + (house_size_y/5 *3), position.z);
+		collision::Box model_box = { model_pos, model.raw_model.model_size };
+		model_box.SetRotation(-90);
+		furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box));
+
+		return furniture;
+
+		/*
+		// Add furniture
+		models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH);
+		glm::vec3 couch_pos = glm::vec3(position.x + 200, position.y, position.z + 10);
+		collision::Box couch_box = { couch_pos, couch.raw_model.model_size };
+		couch_box.SetRotation(-90);
+		furniture.push_back(std::make_shared<CollisionEntity>(couch, couch_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, couch_box));
+
+		models::TexturedModel table = GetFurnitureModel(FurnitureType::TABLE);
+		glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
+		collision::Box table_box = { table_pos, table.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(table, table_pos, glm::vec3(0, 0, 0), HOUSE_SIZE * 1.3, table_box));
+
+		models::TexturedModel chair = GetFurnitureModel(FurnitureType::CHAIR);
+		glm::vec3 chair_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box chair_box = { chair_pos, chair.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(chair, chair_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, chair_box));
+
+		models::TexturedModel plant = GetFurnitureModel(FurnitureType::PLANT);
+		glm::vec3 plant_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box plant_box = { plant_pos, plant.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(plant, plant_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, plant_box));
+
+		models::TexturedModel guitar = GetFurnitureModel(FurnitureType::GUITAR);
+		glm::vec3 guitar_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box guitar_box = { guitar_pos, guitar.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(guitar, guitar_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, guitar_box));
+
+		models::TexturedModel bookshelf = GetFurnitureModel(FurnitureType::BOOKSHELF);
+		glm::vec3 bookshelf_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box bookshelf_box = { bookshelf_pos, bookshelf.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(bookshelf, bookshelf_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, bookshelf_box));
+
+		models::TexturedModel lamp = GetFurnitureModel(FurnitureType::LAMP);
+		glm::vec3 lamp_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box lamp_box = { lamp_pos, lamp.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(lamp, lamp_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, lamp_box));
+
+		models::TexturedModel ceiling_object = GetFurnitureModel(FurnitureType::CEILING_OBJECTS);
+		glm::vec3 ceiling_object_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box ceiling_object_box = { ceiling_object_pos, ceiling_object.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(ceiling_object, ceiling_object_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, ceiling_object_box));
+
+		models::TexturedModel misc = GetFurnitureModel(FurnitureType::MISC);
+		glm::vec3 misc_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box misc_box = { misc_pos, misc.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box));
+		*/
+
+	}
+
+	models::TexturedModel HouseGenerator::GetFurnitureModel(const FurniturePiece* furniture)
+	{
+		std::deque<models::TexturedModel>* furniture_list = nullptr;
+
+		for (std::deque<FurnitureModel>::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it)
+		{
+			if (it->furniture.type == furniture->type)
+			{
+				furniture_list = &it->texture;
+			}
+		}
+
+		if (furniture_list == nullptr)
+		{
+			std::cerr << "OH NEEEEEEEEEEEEEEE";
+		}
+
+		const int modelNumber = toolbox::Random(0, furniture_list->size() - 1);
+
+		return furniture_list->at(modelNumber);
+
+		//return {};
+	}
+
+	void HouseGenerator::GenerateFurnitureModels()
+	{
+		// Couches
+		std::deque<models::TexturedModel> couches;
+
+		models::RawModel couch_inside_model = render_engine::LoadObjModel("res/couchThree.obj");
+		models::TexturedModel couch_inside = { couch_inside_model, default_texture };
+		couches.push_back(couch_inside);
+
+		models::RawModel couch_inside_model2 = render_engine::LoadObjModel("res/Coach.obj");
+		models::TexturedModel couch_inside2 = { couch_inside_model2, default_texture };
+		couches.push_back(couch_inside2);
+
+		models::RawModel couch_inside_model3 = render_engine::LoadObjModel("res/lawnBenchOne.obj");
+		models::TexturedModel couch_inside3 = { couch_inside_model3, default_texture };
+		couches.push_back(couch_inside3);
+
+		FurnitureModel couch;
+		couch.furniture = {
+		FurnitureType::COUCH, 2 };
+		couch.texture = couches;
+
+		furniture_models.push_back(couch);
+
+		// Tables
+		std::deque<models::TexturedModel> tables;
+
+		models::RawModel table_model1 = render_engine::LoadObjModel("res/tableOne.obj");
+		models::TexturedModel table1 = { table_model1, default_texture };
+		tables.push_back(table1);
+
+		models::RawModel table_model2 = render_engine::LoadObjModel("res/tableTwo.obj");
+		models::TexturedModel table2 = { table_model2, default_texture };
+		tables.push_back(table2);
+
+		models::RawModel table_model3 = render_engine::LoadObjModel("res/bureauOne.obj");
+		models::TexturedModel table3 = { table_model3, default_texture };
+		tables.push_back(table3);
+
+		FurnitureModel table;
+		table.furniture = {
+		FurnitureType::TABLE, 2 };
+		table.texture = tables;
+
+		furniture_models.push_back(table);
+
+		// Chairs
+		std::deque<models::TexturedModel> chairs;
+
+		models::RawModel chair_model1 = render_engine::LoadObjModel("res/launchchair.obj");
+		models::TexturedModel chair1 = { chair_model1, default_texture };
+		chairs.push_back(chair1);
+
+		models::RawModel chair_model2 = render_engine::LoadObjModel("res/lawnChairOne.obj");
+		models::TexturedModel chair2 = { chair_model2, default_texture };
+		chairs.push_back(chair2);
+
+		models::RawModel chair_model3 = render_engine::LoadObjModel("res/ugly_chair.obj");
+		models::TexturedModel chair3 = { chair_model3, default_texture };
+		chairs.push_back(chair3);
+
+		FurnitureModel chair;
+		chair.furniture = {
+		FurnitureType::CHAIR, 1 };
+		chair.texture = chairs;
+
+		furniture_models.push_back(chair);
+
+		// Plants
+		std::deque<models::TexturedModel> plants;
+
+		models::RawModel plant_model1 = render_engine::LoadObjModel("res/plantOne.obj");
+		models::TexturedModel plant1 = { plant_model1, default_texture };
+		plants.push_back(plant1);
+
+		models::RawModel plant_model2 = render_engine::LoadObjModel("res/plantTwo.obj");
+		models::TexturedModel plant2 = { plant_model2, default_texture };
+		plants.push_back(plant2);
+
+		models::RawModel plant_model3 = render_engine::LoadObjModel("res/plantThree.obj");
+		models::TexturedModel plant3 = { plant_model3, default_texture };
+		plants.push_back(plant3);
+
+		FurnitureModel plant;
+		plant.furniture = {
+		FurnitureType::PLANT, 1 };
+		plant.texture = plants;
+
+		furniture_models.push_back(plant);
+
+		// Guitars
+		std::deque<models::TexturedModel> guitars;
+
+		models::RawModel guitar_model1 = render_engine::LoadObjModel("res/guitarOne.obj");
+		models::TexturedModel guitar1 = { guitar_model1, default_texture };
+		guitars.push_back(guitar1);
+
+		models::RawModel guitar_model2 = render_engine::LoadObjModel("res/guitarTwo.obj");
+		models::TexturedModel guitar2 = { guitar_model2, default_texture };
+		guitars.push_back(guitar2);
+
+		FurnitureModel guitar;
+		guitar.furniture = {
+		FurnitureType::GUITAR, 1 };
+		guitar.texture = guitars;
+
+		furniture_models.push_back(guitar);
+
+		// Bookshelves
+		std::deque<models::TexturedModel> bookshelves;
+
+		models::RawModel bookshelf_model1 = render_engine::LoadObjModel("res/bookShelfOne.obj");
+		models::TexturedModel bookshelf1 = { bookshelf_model1, default_texture };
+		bookshelves.push_back(bookshelf1);
+
+		models::RawModel bookshelf_model2 = render_engine::LoadObjModel("res/bookShelfTwo.obj");
+		models::TexturedModel bookshelf2 = { bookshelf_model2, default_texture };
+		bookshelves.push_back(bookshelf2);
+
+		models::RawModel bookshelf_model3 = render_engine::LoadObjModel("res/bookShelfThree.obj");
+		models::TexturedModel bookshelf3 = { bookshelf_model3, default_texture };
+		bookshelves.push_back(bookshelf3);
+
+		FurnitureModel bookshelf;
+		bookshelf.furniture = {
+		FurnitureType::BOOKSHELF, 1 };
+		bookshelf.texture = bookshelves;
+
+		furniture_models.push_back(bookshelf);
+
+		// Lamps
+		std::deque<models::TexturedModel>lamps;
+
+		models::RawModel lamp_model1 = render_engine::LoadObjModel("res/lampOne.obj");
+		models::TexturedModel lamp1 = { lamp_model1, default_texture };
+		lamps.push_back(lamp1);
+
+		models::RawModel lamp_model2 = render_engine::LoadObjModel("res/lampTwo.obj");
+		models::TexturedModel lamp2 = { lamp_model2, default_texture };
+		lamps.push_back(lamp2);
+
+		FurnitureModel lamp;
+		lamp.furniture = {
+		FurnitureType::LAMP, 1 };
+		lamp.texture = lamps;
+
+		furniture_models.push_back(lamp);
+
+		// Ceiling objects
+		std::deque<models::TexturedModel>ceiling_Objects;
+
+		models::RawModel ceiling_Obj_model1 = render_engine::LoadObjModel("res/ceilingFan.obj");
+		models::TexturedModel ceiling_Obj1 = { ceiling_Obj_model1, default_texture };
+		ceiling_Objects.push_back(ceiling_Obj1);
+
+		models::RawModel ceiling_Obj_model2 = render_engine::LoadObjModel("res/ceilingFanTwo.obj");
+		models::TexturedModel ceiling_Obj2 = { ceiling_Obj_model2, default_texture };
+		ceiling_Objects.push_back(ceiling_Obj2);
+
+		models::RawModel ceiling_Obj_model3 = render_engine::LoadObjModel("res/ceilingLampOne.obj");
+		models::TexturedModel ceiling_Obj3 = { ceiling_Obj_model3, default_texture };
+		ceiling_Objects.push_back(ceiling_Obj3);
+
+		models::RawModel ceiling_Obj_model4 = render_engine::LoadObjModel("res/ceilingLampTwo.obj");
+		models::TexturedModel ceiling_Obj4 = { ceiling_Obj_model4, default_texture };
+		ceiling_Objects.push_back(ceiling_Obj4);
+
+		FurnitureModel ceiling_object;
+		ceiling_object.furniture = {
+		FurnitureType::CEILING_OBJECTS, 1 };
+		ceiling_object.texture = ceiling_Objects;
+
+		furniture_models.push_back(ceiling_object);
+
+		// Miscs
+		std::deque<models::TexturedModel> miscs;
+
+		models::RawModel misc_model1 = render_engine::LoadObjModel("res/tv.obj");
+		models::TexturedModel misc1 = { misc_model1, default_texture };
+		miscs.push_back(misc1);
+
+		models::RawModel misc_model2 = render_engine::LoadObjModel("res/radio.obj");
+		models::TexturedModel misc2 = { misc_model2, default_texture };
+		miscs.push_back(misc2);
+
+		models::RawModel misc_model3 = render_engine::LoadObjModel("res/Flowerpot.obj");
+		models::TexturedModel misc3 = { misc_model3, default_texture };
+		miscs.push_back(misc3);
+
+		FurnitureModel misc;
+		misc.furniture = {
+		FurnitureType::MISC, 1 };
+		misc.texture = miscs;
+
+		furniture_models.push_back(misc);
+	}
+}

src/entities/house_generator.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <deque>
+#include <memory>
+#include <map>
+#include "../models/Model.h"
+#include "../collision/collision.h"
+
+namespace entities
+{
+	enum class FurnitureType
+	{
+		COUCH,
+		TABLE,
+		CHAIR,
+		PLANT,
+		GUITAR,
+		BOOKSHELF,
+		LAMP,
+		CEILING_OBJECTS,
+		MISC
+	};
+	struct FurniturePiece
+	{
+		FurnitureType type;
+		int size;
+	};
+
+	struct FurnitureModel
+	{
+		FurniturePiece furniture;
+		std::deque<models::TexturedModel> texture;
+
+		bool operator<(FurnitureModel a)
+		{
+			return true;
+		}
+	};
+
+	
+	
+	class HouseGenerator
+	{
+	private:
+		const float HOUSE_SIZE = 30;
+		
+		models::TexturedModel house_model;
+		models::ModelTexture default_texture;
+		
+		//std::map<FurniturePiece, std::deque<models::TexturedModel>> furniture_models;
+		std::deque<FurnitureModel> furniture_models;
+	public:
+		HouseGenerator();
+		
+		/*
+		 * @brief: This function generates a house with furniture at the given position and rotation
+		 *
+		 * @param position: The position of the house to render
+		 * @param y_rotation: The y rotation the house needs to be rendered with
+		 *
+		 * @return: A list with all the entities of the generated house (the furniture)
+		 */
+		std::deque<std::shared_ptr<Entity>> GenerateHouse(const glm::vec3& position, float y_rotation);
+
+		/*
+		 * @brief: Returns the depth of the house (chunk)
+		 */
+		float GetHouseDepth() const { return house_model.raw_model.model_size.x * HOUSE_SIZE; }
+	
+	private:
+		const FurniturePiece* GetRandomFurniturePiece();
+		const FurniturePiece* GetFurniturePiece(FurnitureType type);
+
+		/*
+		 * @brief: This function loads all the 3D furniture models
+		 */
+		void GenerateFurnitureModels();
+
+		/*
+		 * @brief: This funtion chooses and returns a random furniture of the given furniture type
+		 *
+		 * @param furniture: The furniture you want to get
+		 *
+		 * @return: The model of the random furniture of the chosen furniture type
+		 */
+		models::TexturedModel GetFurnitureModel(const FurniturePiece* furniture);
+	};
+}

src/entities/main_character.cpp

@@ -0,0 +1,100 @@
+#include "main_character.h"
+#include "../models/Model.h"
+#include <iostream>
+#include "entity.h"
+#include"../renderEngine/Renderer.h"
+#include"../renderEngine/obj_loader.h"
+#include"../renderEngine/loader.h"
+namespace entities
+{
+	float movement_speed;	
+	float down_speed;		
+	float side_speed;
+	bool is_playing;
+
+	MainCharacter::MainCharacter(const models::TexturedModel& model, const glm::vec3& position,
+		const glm::vec3& rotation, float scale, const collision::Box& bounding_box)
+		: CollisionEntity(model, position, rotation, scale, bounding_box) 
+	{
+		is_playing = true;
+	}
+
+	void MainCharacter::Move(GLFWwindow* window)
+	{
+		if (is_playing) {
+			movement_speed = -0.5f;	//Forward speed adjustment, bee is moving at a standard speedrate
+			down_speed = -1.0f;		//Down speed adjustment, downspeed is difference between down_speed and UP_SPEED	
+			side_speed = 0;			//Side speed adjustment
+
+			//For gameplay with use of keyboard keys: W, A, S, D
+			//W: Go forward
+			//A: Go left
+			//S: Go backwards
+			//D: Go right
+			//TODO Implement CV actions 
+			SetRotation(glm::vec3(0, 90, 0));
+			if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
+			{
+				movement_speed -= SIDE_SPEED;
+			}
+
+			if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
+			{
+				movement_speed += SIDE_SPEED;
+			}
+			//top right
+			if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS)
+			{
+				side_speed += SIDE_SPEED;
+				down_speed += UP_SPEED;
+			}
+			//right
+			if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
+			{
+				side_speed += SIDE_SPEED;
+			}
+			//top left
+			if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS)
+			{
+				down_speed += UP_SPEED;
+				side_speed -= SIDE_SPEED;
+			}
+			//left
+			if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
+			{
+				side_speed -= SIDE_SPEED;
+			}
+
+			if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
+			{
+				down_speed += UP_SPEED;
+				SetRotation(glm::vec3(10, 90, 0));
+			}
+			if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
+			{
+				down_speed -= UP_SPEED;
+			}
+		}
+			IncreasePosition(glm::vec3(side_speed, down_speed, movement_speed));
+
+			//Use only for binding bee to house, such that it doesn't go outside of the room.
+			//TODO delete when boundingbox is implemented!
+			if (position.x > 190) position.x = 190;
+			else if (position.x < -190) position.x = -190;
+			if (position.y > 350) position.y = 350;
+			else if (position.y < -40) position.y = -40;
+			//Move player bounding box according to the position on screen
+			MoveCollisionBox();
+			if (glfwGetKey(window, GLFW_KEY_Z) == GLFW_PRESS)
+			{
+				is_playing = true;
+			}
+	}
+
+	void MainCharacter::OnCollide(const collision::Collision& collision) {
+		down_speed = -2.0f;
+		movement_speed = 0.0f;
+		is_playing = false;
+		std::cout << "collision" << std::endl;
+	}
+}

src/entities/main_character.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "collision_entity.h"
+#include "../shaders/entity_shader.h"
+
+namespace entities
+{
+	/* 
+	* This class contains the information about the player model
+	*/
+	class MainCharacter : public CollisionEntity {
+		const float SIDE_SPEED = 0.8f;		//Standard movement speed for left/right movement
+		const float UP_SPEED = 2.0f;		//Standard movement speed for up movement
+	public:
+		/*
+		* @brief: Constructor for the main character model
+		* 
+		* @param model: Model to load in as the player model
+		* @param position: Position of the model inside the game window
+		* @param rotation: Rotation of the model inside the game window
+		* @param scale: Size of the model
+		* @param bounding_box: Collision box around the player model
+		*/
+		MainCharacter(const models::TexturedModel& model, const glm::vec3& position,
+			const glm::vec3& rotation, float scale, const collision::Box& bounding_box);
+		
+		/*
+		* @brief: A function to move the character inside the window
+		* 
+		* @param window: The game window
+		* 
+		* @return: Vector with the adjusted side_speed, down_speed, and movement_speed
+		*/
+		void Move(GLFWwindow* window);
+
+		void OnCollide(const collision::Collision& collision) override;
+	};
+}

src/gui/gui_element.h

@@ -5,6 +5,11 @@
 
 namespace gui
 {
+	//Represents the type of the entitie
+	enum class GuiType{
+		LABEL, BUTTON
+	};
+
 	/*
 	 * Structure for representing a gui item to display on the screen
 	 *
@@ -14,13 +19,16 @@ namespace gui
 	 */
 	struct GuiTexture
 	{
-		int texture;
+		GLuint texture;
 		glm::vec2 position;
 		glm::vec2 scale;
 
+		virtual GuiType GetType() {
+			return GuiType::LABEL;
+		}
 		GuiTexture(int texture, glm::vec2 position, glm::vec2 scale): texture(texture), position(position), scale(scale)
 		{
-			scale.x /= (WINDOW_WIDTH / WINDOW_HEIGT);
+			scale.x /= (WINDOW_WIDTH / WINDOW_HEIGHT);
 		}
 	};
 }

src/gui/gui_interactable.cpp

@@ -2,6 +2,8 @@
 #include <GLFW/glfw3.h>
 #include "gui_interactable.h"
 
+#include <iostream>
+
 namespace gui
 {
 	InteractableGui::InteractableGui(int default_texture, glm::vec2 position, glm::vec2 scale)
@@ -41,14 +43,47 @@ namespace gui
 		}
 	}
 
+	void InteractableGui::ForceClick( int mouseButton)
+	{
+		if(mouseButton == GLFW_MOUSE_BUTTON_LEFT)
+		{
+			if (clicked_texture != 0)
+			{
+				texture = clicked_texture;
+			}
+			else
+			{
+				texture = default_texture;
+			}
+
+			if (!is_clicking)
+			{
+				OnClick();
+				is_clicking = true;
+			}
+		}
+		else
+		{
+			if (is_clicking)
+			{
+				is_clicking = false;
+			}
+		}
+		
+	}
+	
 	bool InteractableGui::IsHoveringAbove(GLFWwindow* window)
 	{
 		double x_pos, y_pos;
 		glfwGetCursorPos(window, &x_pos, &y_pos);
+		//std::cout << "Cursor pos in method: " << x_pos <<"::" <<  y_pos << std::endl;
 
 		const float x_rel = (x_pos / SCALED_WIDTH / DEFAULT_WIDTH) * 2.0f - 1.0f;
 		const float y_rel = -((y_pos / SCALED_HEIGHT / DEFAULT_HEIGHT) * 2.0f - 1.0f);
 
+		//std::cout << "x_rel And y_rel in method: " << x_rel << "::" << y_rel << std::endl;
+
+
 		if (x_rel >= minXY.x && x_rel <= maxXY.x &&
 			y_rel >= minXY.y && y_rel <= maxXY.y)
 		{

src/gui/gui_interactable.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <iostream>
 #include <glm/gtc/matrix_transform.hpp>
 #include "../toolbox/toolbox.h"
 #include "gui_element.h"
@@ -32,6 +33,14 @@ namespace gui
 		 */
 		void Update(GLFWwindow* window);
 
+		/*
+		 * @brief: Call this function when you want to perform a mouseclick
+		 *
+		 * @param mousebutton: mouseButton you want to perform the click on
+		 */
+		void ForceClick(int mouseButton);
+
+		
 		/*
 		 * @brief: This function gets called when the InteractabeGui is clicked
 		 */
@@ -50,7 +59,10 @@ namespace gui
 		/*
 		 * @brief: This function sets the texture of the InteractableGUI for when the InteractableGUI is clicked
 		 */
-		void SetClickedTexture(int texture) { clicked_texture = texture; }
+		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
@@ -104,6 +116,10 @@ namespace gui
 		 */
 		void SetOnExitAction(void (*fun)()) { on_exit_action = fun; }
 
+		GuiType GetType() override {
+			return GuiType::BUTTON;
+		}
+
 	protected:
 		void OnClick() override { if (on_click_action != nullptr) on_click_action(); }
 		void OnEnter() override { if (on_enter_action != nullptr) on_enter_action(); }

src/main.cpp

@@ -9,11 +9,14 @@
 
 #include "stb_image.h"
 #include <ostream>
+#include <stdlib.h>
+#include <iostream>
 
 #include <opencv2/core.hpp>
 #include <opencv2/videoio.hpp>
 #include <opencv2/video.hpp>
 
+#include "collision/collision.h"
 #include "gui/gui_interactable.h"
 #include "models/model.h"
 #include "renderEngine/loader.h"
@@ -37,9 +40,10 @@
 
 static double UpdateDelta();
 
+static GLFWwindow* window;
+
 scene::Scene* current_scene;
 
-static GLFWwindow* window;
 bool points_img_available = false;
 cv::Mat points_img;
 
@@ -57,7 +61,7 @@ int main(void)
 #pragma region OPENGL_SETTINGS
 	if (!glfwInit())
 		throw "Could not inditialize glwf";
-	window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGT, "SDBA", NULL, NULL);
+	window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "SDBA", NULL, NULL);
 	if (!window)
 	{
 		glfwTerminate();
@@ -82,6 +86,9 @@ int main(void)
         });
     
     bool window_open = true;
+
+	
+
 	// Main game loop
 	while (!glfwWindowShouldClose(window) && window_open)
 	{
@@ -100,6 +107,7 @@ int main(void)
                 current_scene = new scene::Startup_Scene();
                 break;
 
+		
             case scene::Scenes::INGAME:
                 current_scene = new scene::In_Game_Scene();
                 break;
@@ -108,6 +116,12 @@ int main(void)
                 std::cout << "Wrong return value!!! ->" << std::endl;
                 break;
         }
+        
+		// Finish up
+		//shader.Stop();
+		glfwSwapBuffers(window);
+		glfwPollEvents();
+           
 	}
 
 	// Clean up -> preventing memory leaks!!!

src/models/Model.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <GL/glew.h>
+#include <glm/gtc/matrix_transform.hpp>
 
 namespace models
 {

src/renderEngine/Renderer.cpp

@@ -4,7 +4,6 @@
 #include "loader.h"
 #include "../toolbox/toolbox.h"
 #include "renderer.h"
-
 #include <iostream>
 
 namespace render_engine
@@ -26,7 +25,7 @@ namespace render_engine
 			glCullFace(GL_BACK);
 			
 			const glm::mat4 projectionMatrix = 
-				glm::perspective(glm::radians(FOV), (WINDOW_WIDTH / WINDOW_HEIGT), NEAR_PLANE, FAR_PLANE);
+				glm::perspective(glm::radians(FOV), (WINDOW_WIDTH / WINDOW_HEIGHT), NEAR_PLANE, FAR_PLANE);
 
 			// Load the projectionmatrix into the shader
 			shader.Start();
@@ -51,9 +50,9 @@ namespace render_engine
 		/*
 			This function will Render a Model on the screen.
 		*/
-		void Render(entities::Entity& entity, shaders::EntityShader& shader)
+		void Render(std::shared_ptr<entities::Entity> entity, shaders::EntityShader& shader)
 		{
-			const models::TexturedModel model = entity.GetModel();
+			const models::TexturedModel model = entity.get()->GetModel();
 			const models::RawModel raw_model = model.raw_model;
 			const models::ModelTexture texture = model.texture;
 			
@@ -66,7 +65,7 @@ namespace render_engine
 			glEnableVertexAttribArray(2);
 
 			// Load the transformation of the model into the shader
-			const glm::mat4 modelMatrix = toolbox::CreateModelMatrix(entity.GetPosition(), entity.GetRotation(), entity.GetScale());
+			const glm::mat4 modelMatrix = toolbox::CreateModelMatrix(entity.get()->GetPosition(), entity.get()->GetRotation(), entity.get()->GetScale());
 			shader.LoadModelMatrix(modelMatrix);
 			shader.LoadShineVariables(texture.shine_damper, texture.reflectivity);
 			

src/renderEngine/Renderer.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>
 #include "../gui/gui_element.h"
 #include "../entities/entity.h"
 #include "../shaders/entity_shader.h"
@@ -30,7 +31,7 @@ namespace render_engine
 			@param entity: The entity which needs to be rendered
 			@param shader: The shader the entity needs to be rendered with
 		*/
-		void Render(entities::Entity& entity, shaders::EntityShader& shader);
+		void Render(std::shared_ptr<entities::Entity> entity, shaders::EntityShader& shader);
 
 		/*
 			@brief: Call this function to render gui_textures on the screen

src/scenes/in_Game_Scene.cpp

@@ -1,8 +1,11 @@
 #include <iostream>
+#include <memory>
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include "in_Game_Scene.h"
 #include "startup_Scene.h"
+#include "../entities/main_character.h"
+#include "../collision/collision_handler.h"
 #include "../gui/gui_interactable.h"
 #include "../models/model.h"
 #include "../renderEngine/loader.h"
@@ -10,83 +13,199 @@
 #include "../renderEngine/renderer.h"
 #include "../shaders/entity_shader.h"
 #include "../toolbox/toolbox.h"
+#include "../entities/house_generator.h"
+#include <deque>
+#include <functional>
+#include <memory>
+#include <queue>
 #include <opencv2/core/base.hpp>
 #include "../computervision/HandDetectRegion.h"
 #include "../computervision/ObjectDetection.h"
 
+#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::vector<entities::Entity> entities;
+	std::shared_ptr<entities::MainCharacter>main_character;
-	std::vector<entities::Light> lights;
+	std::vector<std::shared_ptr<entities::CollisionEntity>> collision_entities;
-	models::RawModel raw_model;
+	entities::HouseGenerator* house_generator;
+	std::deque<std::shared_ptr<entities::Entity>> house_models;
+
+	models::RawModel raw_model, raw_model_char;
 	models::ModelTexture texture;
-	shaders::EntityShader *shader;
+	shaders::EntityShader* shader;
-	shaders::GuiShader *gui_shader;
+	shaders::GuiShader* gui_shader;
-	entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
 	std::vector<gui::GuiTexture*> guis;
 
+	int furniture_count_old;
+	int score;
 
 	std::vector<computervision::HandDetectRegion> regions;
 	computervision::HandDetectRegion reg_left("left", 0, 0, 150, 150), reg_right("right", 0, 0, 150, 150), reg_up("up", 0, 0, 150, 150);
 
-	
+	/**
+	 * sets up the first things when the objects has been made
+	 */
 	In_Game_Scene::In_Game_Scene()
 	{
+		camera = std::make_unique<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();
+		score = 0;
+	}
+	/**
+	 * temporary!!!!
+	 * just to make some bounding boxes
+	 */
+	collision::Box create_bounding_box(glm::vec3 size, glm::vec3 pos, int scale) {
+		collision::Box box = collision::Box();
+		box.size.x = size.z * scale;
+		box.size.y = size.y * scale;
+		box.size.z = size.x * scale;
+		box.center_pos = pos;
+		return box;
+	}
+	/**
+	 * deletes certain veriables when the object will be deleted, prevents memory leaks
+	 */
+	In_Game_Scene::~In_Game_Scene()
+	{
+		delete shader;
+		delete gui_shader;
+		delete house_generator;
 	}
 
-	scene::Scenes scene::In_Game_Scene::start(GLFWwindow* window)
+
+	/**
+	 * @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)
 	{
+		static unsigned int furniture_count = 0;
+
 		// set up squares according to size of camera input
 		cv::Mat camera_frame;
 		static_camera::getCap().read(camera_frame); // get camera frame to know the width and heigth
 		reg_left.SetXPos(10);
-		reg_left.SetYPos(camera_frame.rows / 2 - reg_left.GetHeight()/2);
+		reg_left.SetYPos(camera_frame.rows / 2 - reg_left.GetHeight() / 2);
 		reg_right.SetXPos(camera_frame.cols - 10 - reg_right.GetWidth());
-		reg_right.SetYPos(camera_frame.rows / 2 - reg_right.GetHeight()/2);
+		reg_right.SetYPos(camera_frame.rows / 2 - reg_right.GetHeight() / 2);
 		reg_up.SetXPos(camera_frame.cols / 2 - reg_up.GetWidth() / 2);
 		reg_up.SetYPos(10);
+		std::cout << "loading model chunk" << std::endl;
+		if (house_models.size() >= MAX_MODEL_DEQUE_SIZE * furniture_count)
+		{
+			for (int i = 0; i < furniture_count; i++)
+			{
+				house_models.pop_front();
+			}
+		}
+		int z_offset = model_pos * (house_generator->GetHouseDepth()); // how much "in the distance" we should load the model
 
+		std::deque<std::shared_ptr<entities::Entity>> furniture = house_generator->GenerateHouse(glm::vec3(0, -75, -50 - z_offset), 90);
+		furniture_count = furniture.size();
 
-		raw_model = render_engine::LoadObjModel("res/House.obj");
+		house_models.insert(house_models.end(), furniture.begin(), furniture.end());
+		std::cout << "funriture_count in load chunk (house included): " << furniture_count << std::endl;
+		furniture_count_old = furniture_count - 1;
+	}
+
+	/**
+	 * starts the game scene, calls the render and update methods in a while loop
+	 */
+	scene::Scenes scene::In_Game_Scene::start(GLFWwindow* window)
+	{
 		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)
+		raw_model_char = render_engine::LoadObjModel("res/beeTwo.obj");
+		models::TexturedModel model_char = { raw_model_char, texture };
+		collision::Box char_box = create_bounding_box(raw_model_char.model_size, glm::vec3(0, 0, 0), 1);
+		main_character = std::make_shared<entities::MainCharacter>(model_char, glm::vec3(0, -50, -100), glm::vec3(0, 90, 0), 5, char_box);
+		collision_entities.push_back(main_character);
+		house_generator = new entities::HouseGenerator();
+		// load the first few house models
+		for (int i = 0; i <= UPCOMING_MODEL_AMOUNT; i++)
 		{
-			entities.push_back(entities::Entity(model, glm::vec3(0, -50, -50 - z), glm::vec3(0, 90, 0), 20));
+			load_chunk(i);
-			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, 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));
+		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;
+				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)
 		{
-			update(window);
+			//checks the current game state, so it can render the correct models for each state
-			button.Update(window);
+			switch (game_state)
-			render();
+			{
+				/*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();
@@ -97,42 +216,78 @@ namespace scene
 		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->LoadLightsDeque(lights);
-		shader->LoadViewMatrix(camera);
+		shader->LoadViewMatrix(*camera);
 
-		// Renders each entity in the entities list
+		for (std::shared_ptr<entities::Entity> model_entity : house_models)
-		for (entities::Entity& entity : entities)
 		{
-			render_engine::renderer::Render(entity, *shader);
+			render_engine::renderer::Render(model_entity, *shader);
 		}
 
+		render_engine::renderer::Render(main_character, *shader);
+
 		// Render GUI items
-		render_engine::renderer::Render(guis, *gui_shader);
+		//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);
+		//camera.Move(window);
+
+		main_character->Move(window);
+
+		//std::cout << "x get: " << movement.x << "\ny get: " << movement.y << "\nz get: " << movement.z << "\n";
+		camera->Follow(main_character->GetPosition());
+
+		// calculate where the next house model should be loaded
+		static int last_model_pos = 0;
+		int model_pos = -round(camera->GetPosition().z / (house_generator->GetHouseDepth())); // 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);
+			score += furniture_count_old;
+			std::cout << "Score: " << score << std::endl;
+			std::cout << "Funriture_count_old in model (house excluded): " << furniture_count_old << std::endl;
+		}
+		// remember the position at which the new model was added
+		last_model_pos = model_pos;
+
+		collision::CheckCollisions(collision_entities);
 		update_hand_detection();
 	}
 
+	//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)
+		if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
 		{
 			cv::destroyWindow("camera");
 			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;
+		}
 
 		if (glfwGetKey(window, GLFW_KEY_B) == GLFW_PRESS)
 		{
@@ -159,4 +314,10 @@ namespace scene
 
 		cv::imshow("camera", camera_frame);
 	}
+
+	//renders the models for the pause menu
+	void In_Game_Scene::render_pause_menu()
+	{
+		render_engine::renderer::Render(pause_guis, *gui_shader);
+	}
 }

src/scenes/in_Game_Scene.h

@@ -1,21 +1,101 @@
 #pragma once
+#include <iostream>
+#include <ostream>
+#include <vector>
+#include <memory>
 #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::deque<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.
+		std::unique_ptr<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();
 		void update_hand_detection();
 	
 	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/loading_Scene.cpp

@@ -0,0 +1,47 @@
+#include "loading_Scene.h"
+#include "../renderEngine/Renderer.h"
+#include "../renderEngine/Loader.h"
+#include "../gui/gui_element.h"
+
+namespace scene
+{
+	
+	Loading_Scene::Loading_Scene()
+	{
+		gui_shader = new shaders::GuiShader();
+		gui_shader->Init();
+	}
+
+	Loading_Scene::~Loading_Scene()
+	{
+		delete gui_shader;
+	}
+
+	Scenes Loading_Scene::start(GLFWwindow* window)
+	{
+		render();
+		return Scenes::STARTUP;
+	}
+
+	void Loading_Scene::render()
+	{
+		/*render_engine::renderer::Prepare();
+		
+		gui::GuiTexture loading_image = { render_engine::loader::LoadTexture("res/menu_item_start1.png"),
+			glm::vec2(0,0),glm::vec2(1,1) };
+		
+		std::vector<gui::GuiTexture*> image_list;
+		image_list.push_back(&loading_image);
+		
+		render_engine::renderer::Render(image_list, *gui_shader);*/
+	}
+
+	void Loading_Scene::update(GLFWwindow* window)
+	{
+	}
+
+	
+	void Loading_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
+	{
+	}
+}

src/scenes/loading_Scene.h

@@ -0,0 +1,63 @@
+#pragma once
+#pragma once
+#include "scene.h"
+#include "../gui/gui_element.h"
+#include "../shaders/gui_shader.h"
+
+namespace scene
+{
+	extern GLFWwindow* window;
+	
+
+	class Loading_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::LOADING;
+		shaders::GuiShader* gui_shader;
+
+
+	public:
+		/**
+		 * @brief Constructor of the class Startup_Scene
+		 *
+		 */
+		Loading_Scene();
+
+		~Loading_Scene();
+		
+		/**
+		 * @brief
+		 *
+		 * @param window
+		 * @return
+		 */
+		Scenes start(GLFWwindow* window) override;
+
+		/**
+		 * @brief
+		 *
+		 */
+		void render() override;
+
+		/**
+		 * @brief This method updates all the components on the window
+		 *
+		 * @param window Window it updates
+		 */
+		void update(GLFWwindow* window) override;
+
+		/**
+		 * @brief Listener for key events
+		 *
+		 * @param window Window it listens to for key events
+		 * @param key Key of event that is activated
+		 * @param scancode Code of Key
+		 * @param action
+		 * @param mods
+		 */
+		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
+	};
+}
+
+

src/scenes/scene.cpp

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

src/scenes/scene.h

@@ -6,8 +6,12 @@
 
 namespace scene {
 
+	/**
+	 * this enum represents the scenes in the game, those wil help to keep track in which scene the game is.
+	 */
 	enum class Scenes
 	{
+		LOADING,
 		STARTUP,
 		INGAME,
 		GAMEOVER,
@@ -18,14 +22,40 @@ namespace scene {
 	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/startup_Scene.cpp

@@ -1,45 +1,222 @@
+#include <iostream>
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include <map>
 #include "startup_Scene.h"
+#include <iostream>
+#include <opencv2/core/mat.hpp>
+
+#include "../models/model.h"
+#include "../renderEngine/loader.h"
+#include "../renderEngine/obj_loader.h"
+#include "../renderEngine/renderer.h"
+#include "../shaders/entity_shader.h"
+#include "../gui/gui_interactable.h"
+#include "../toolbox/toolbox.h"
+#include "../computervision/MenuTest.h"
 #include "../computervision/ObjectDetection.h"
 #include "../computervision/HandDetectRegion.h"
-#include <iostream>
+
+
+
 
 namespace scene
 {
-	computervision::ObjectDetection objDetect;
+	shaders::GuiShader* gui_shader1;
+	std::vector<gui::GuiTexture*> guis1;
+  computervision::ObjectDetection objDetect;
+
+	float item_number = 0;
+
+	bool hand_mode = false;
+
+	Startup_Scene::Startup_Scene() {
+		shaders::EntityShader shader;
+		shader.Init();
+		render_engine::renderer::Init(shader);
+		shader.CleanUp();
+
+		gui_shader1 = new shaders::GuiShader();
+		gui_shader1->Init();
+	}
+
+	gui::Button* ConvertGuiTextureToButton(gui::GuiTexture* texture) {
+		gui::Button* button;
+		if (texture != NULL)
+		{
+
+			if (texture->GetType() == gui::GuiType::BUTTON) {
+				
+				button = (gui::Button*)texture;
+				return button;
+			}
+			else {
+				button = nullptr;
+				return button;
+			}
+		}
+		else {
+			button = nullptr;
+			return button;
+		}
+
+
+	}
+
+	/*gui::InteractableGui* ConvertGuiTextureToInteractableGui(gui::GuiTexture* texture) {
+		if (texture != NULL)
+			if (texture->GetType() == gui::GuiType::BUTTON) {
+				return (gui::InteractableGui*)texture;
+			}
+			else {
+				return NULL;
+			}
+
+	}*/
+
+	gui::GuiTexture* GetMenuItem(bool hand_state) {
+		if(hand_state)
+		item_number += 0.20f;
+
+		int temp_item_number = item_number;
+		
+		//If temp_item_number is equal to the size of the array, set item_number bac to zero to loop through the array again
+		if (temp_item_number == guis1.size()) {
+			item_number = 0;
+			temp_item_number = 0;
+		}
+		std::cout << guis1[temp_item_number]->texture << std::endl;
+		return guis1[temp_item_number];
+	}
+
 	scene::Scenes scene::Startup_Scene::start(GLFWwindow *window)
 	{
+		// GUI stuff
+		gui::Button button_start(render_engine::loader::LoadTexture("res/menu_item_start1.png"), glm::vec2(0.0f, 0.6f), glm::vec2(0.25f, 0.25f));
+		button_start.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_start1_hover.png"));
+		button_start.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_start1_click.png"));
+		button_start.SetOnClickAction([]()
+			{
+				std::cout << "Clicked on button: Start!" << std::endl;
+				
+			});
+		guis1.push_back(&button_start);
+
+		gui::Button button_calibrate(render_engine::loader::LoadTexture("res/menu_item_calibrate1.png"), glm::vec2(0.0f, 0.0f), glm::vec2(0.25f, 0.25f));
+		button_calibrate.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_calibrate1_hover.png"));
+		button_calibrate.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_calibrate1_click.png"));
+		button_calibrate.SetOnClickAction([]()
+			{
+				std::cout << "Clicked on button: Calibrate!" << std::endl;
+
+			});
+		guis1.push_back(&button_calibrate);
+
+		gui::Button button_quit(render_engine::loader::LoadTexture("res/menu_item_quit1.png"), glm::vec2(0.0f, -0.6f), glm::vec2(0.25f, 0.25f));
+		button_quit.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_hover.png"));
+		button_quit.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_click.png"));
+		button_quit.SetOnClickAction([]()
+			{
+				std::cout << "Clicked on button: Quit!" << std::endl;
+			});
+		guis1.push_back(&button_quit);
+
+		computervision::ObjectDetection objDetect;
+		cv::Mat cameraFrame;
+		gui::GuiTexture* chosen_item = NULL; //This is the selected menu_item
+		bool hand_closed = false; //Flag to prevent multiple button presses
+		
 		while (return_value == scene::Scenes::STARTUP)
 		{
 			render();
 			update(window);
 			
+			if (hand_mode) {
+				cameraFrame = objDetect.ReadCamera();
+
+				//Get hand state from camera
+				bool detect = false;
+				bool hand_detection = objDetect.DetectHand(cameraFrame,detect);
+
+				if (hand_detection)
+				{
+					hand_closed = false;
+					std::cout << "hand is opened" << std::endl;
+
+					//Loop through menu items
+					chosen_item = GetMenuItem(true);
+
+					gui::Button* new_button = ConvertGuiTextureToButton(chosen_item);
+					if (new_button != NULL) {
+						const float x_pos = (chosen_item->position.x + 1.0) * WINDOW_WIDTH / 2;
+						const float y_pos = (1.0 - chosen_item->position.y) * WINDOW_HEIGHT / 2;
+
+						//Set cursor to location of selected menu_item
+						glfwSetCursorPos(window, x_pos, y_pos);
+					}
+				}
+				else if (!hand_detection)
+				{
+					std::cout << "hand is closed" << std::endl;
+
+					//Gets selected menu_item
+					chosen_item = GetMenuItem(false);
+					gui::Button* new_button = ConvertGuiTextureToButton(chosen_item);
+
+					if (new_button != NULL && !hand_closed) {
+						//Run function click
+						new_button->ForceClick(GLFW_MOUSE_BUTTON_LEFT);
+						hand_closed = true;
+					}
+				}
+			}
+
 			glfwSwapBuffers(window);
 			glfwPollEvents();
 		}
-
+		gui_shader1->CleanUp();
+		render_engine::loader::CleanUp();
 		return return_value;
 	}
 
+	/**
+	 * renders the models in the start-up scene
+	 */
 	void scene::Startup_Scene::render() 
 	{
+		render_engine::renderer::Prepare();
 
+		// Render GUI items
+		render_engine::renderer::Render(guis1, *gui_shader1);
 	}
 
+	/**
+	 * updates the variables for the start-up scene
+	 */
 	void scene::Startup_Scene::update(GLFWwindow* window)
 	{
+		for (gui::GuiTexture* button : guis1) {
+			gui::Button* new_button = ConvertGuiTextureToButton(button);
+			if (new_button != NULL)
+				new_button->Update(window);
+		}
 		bool hand_present;
 		objDetect.DetectHand(objDetect.ReadCamera(),hand_present);
 	}
 
+	/**
+	 * 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;
 			cv::destroyWindow("camera");
 		}
+		else if (glfwGetKey(window, GLFW_KEY_BACKSPACE) == GLFW_PRESS) {
+			hand_mode = !hand_mode;
+		}
 	}
 }

src/scenes/startup_Scene.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "scene.h"
-#include <map>
+#include "../gui/gui_element.h"
 
 namespace scene
 {
@@ -9,12 +9,46 @@ namespace scene
 	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:
+		/**
+		 * @brief Constructor of the class Startup_Scene
+		 * 
+		 */
+		Startup_Scene();
+
+		/**
+		 * @brief 
+		 * 
+		 * @param window
+		 * @return 
+		 */
 		Scenes start(GLFWwindow* window) override;
+
+		/**
+		 * @brief 
+		 * 
+		 */
 		void render() override;
+
+		/**
+		 * @brief This method updates all the components on the window
+		 * 
+		 * @param window Window it updates
+		 */
 		void update(GLFWwindow* window) override;
+
+		/**
+		 * @brief Listener for key events
+		 * 
+		 * @param window Window it listens to for key events
+		 * @param key Key of event that is activated
+		 * @param scancode Code of Key
+		 * @param action 
+		 * @param mods
+		 */
 		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
 	};
 }

src/shaders/entity_shader.cpp

@@ -1,5 +1,6 @@
 #include "entity_shader.h"
 #include "../toolbox/toolbox.h"
+#include <deque>
 
 namespace shaders
 {
@@ -28,7 +29,7 @@ namespace shaders
 	uniform vec3 light_position[4];
 
 	const float density = 0.0017;
-	const float gradient = 4;
+	const float gradient = 3;
 	
 	void main(void)
 	{
@@ -160,6 +161,25 @@ namespace shaders
 		}
 	}
 
+	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);

src/shaders/entity_shader.h

@@ -2,6 +2,7 @@
 
 #include <glm/gtc/matrix_transform.hpp>
 #include <vector>
+#include <deque>
 #include "shader_program.h"
 #include "../entities/camera.h"
 #include "../entities/light.h"
@@ -58,6 +59,13 @@ namespace shaders
 		 */
 		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
 		 *

src/toolbox/toolbox.cpp

@@ -1,3 +1,4 @@
+#include <ctime>
 #include "toolbox.h"
 
 namespace toolbox
@@ -31,4 +32,28 @@ namespace toolbox
 		matrix = glm::translate(matrix, negative_cam_pos);
 		return matrix;
 	}
+		float Lerp(float from, float to, float amount)
+	{
+		return from + amount * (to - from);
+	}
+
+	glm::vec3 Lerp(glm::vec3 from, glm::vec3 to, float amount)
+	{
+		glm::vec3 final;
+		final.x = Lerp(from.x, to.x, amount);
+		final.y = Lerp(from.y, to.y, amount);
+		final.z = Lerp(from.z, to.z, amount);
+		return final;
+  }
+  
+	int Random(const int min, const int max)
+	{
+		static bool first = true;
+		if (first)
+		{
+			srand(time(0));
+			first = false;
+		}
+		return min + rand() % ((max + 1) - min);
+	}
 }

src/toolbox/toolbox.h

@@ -11,10 +11,10 @@ namespace toolbox
 
 		// Change these macros to change the window size
 		#define WINDOW_WIDTH 1400.0f
-		#define WINDOW_HEIGT 800.0f
+		#define WINDOW_HEIGHT 800.0f
 
 		#define SCALED_WIDTH (WINDOW_WIDTH/DEFAULT_WIDTH)
-		#define SCALED_HEIGHT (WINDOW_HEIGT/DEFAULT_HEIGHT)
+		#define SCALED_HEIGHT (WINDOW_HEIGHT/DEFAULT_HEIGHT)
 	//
 	
 	/*
@@ -46,4 +46,36 @@ namespace toolbox
 	 * @return: The view matrix
 	 */
 	glm::mat4 CreateViewMatrix(entities::Camera& camera);
+
+	/*
+	* @biref go to one coordinate to another with smooting
+	*
+	* @param from one coordinate of the start
+	* @param to one coordinate of where to go
+	* @param amount the amount of smoothing (lower is smoother)
+	* 
+	* @return coordinate of where to go
+	*/
+	float Lerp(float from, float to, float amount);
+
+	/*
+	* @biref go from one position to another with smoothing
+	*
+	* @param from position of the start
+	* @param to position of where to go
+	* @param amount the amount of smoothing (lower is smoother)
+	*
+	* @return position of where to go
+	*/
+	glm::vec3 Lerp(glm::vec3 from, glm::vec3 to, float amount);
+  
+  /*
+	 * @brief: This function will return a value between min and max
+	 *
+	 * @param min: The min value
+	 * @param max: The max value
+	 *
+	 * @return: The random number
+	 */
+	int Random(const int min, const int max);
 }

wk2_fps.vcxproj

@@ -20,9 +20,12 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\collision\collision_handler.cpp" />
+    <ClCompile Include="src\entities\main_character.cpp" />
+    <ClCompile Include="src\entities\house_generator.cpp" />
     <ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
     <ClCompile Include="src\computervision\HandDetectRegion.cpp" />
     <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
+    <ClCompile Include="src\computervision\MenuTest.cpp" />
     <ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
     <ClCompile Include="src\computervision\ObjectDetection.cpp" />
     <ClCompile Include="src\computervision\OpenPoseVideo.cpp" />
@@ -37,6 +40,8 @@
     <ClCompile Include="src\renderEngine\loader.cpp" />
     <ClCompile Include="src\renderEngine\obj_loader.cpp" />
     <ClCompile Include="src\renderEngine\renderer.cpp" />
+    <ClCompile Include="src\scenes\loading_Scene.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" />
@@ -46,15 +51,19 @@
   <ItemGroup>
     <ClInclude Include="src\collision\collision.h" />
     <ClInclude Include="src\collision\collision_handler.h" />
+    <ClInclude Include="src\entities\main_character.h" />
+    <ClInclude Include="src\entities\house_generator.h" />
     <ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
     <ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
     <ClInclude Include="src\computervision\HandDetectRegion.h" />
     <ClInclude Include="src\scenes\in_Game_Scene.h" />
+    <ClInclude Include="src\scenes\loading_Scene.h" />
     <ClInclude Include="src\scenes\scene.h" />
     <ClInclude Include="src\computervision\async\async_arm_detection.h" />
     <ClInclude Include="src\computervision\async\StaticCameraInstance.h" />
     <ClInclude Include="src\computervision\FingerCount.h" />
     <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\computervision\MenuTest.h" />
     <ClInclude Include="src\computervision\OpenPoseVideo.h" />
     <ClInclude Include="src\computervision\SkinDetector.h" />
     <ClInclude Include="src\computervision\ObjectDetection.h" />

wk2_fps.vcxproj.filters

@@ -24,6 +24,70 @@
     <ClCompile Include="src\scenes\startup_Scene.cpp" />
     <ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
     <ClCompile Include="src\computervision\HandDetectRegion.cpp" />
+    <ClCompile Include="src\entities\main_character.cpp" />
+    <ClCompile Include="src\entities\house_generator.cpp" />
+    <ClCompile Include="src\computervision\MenuTest.cpp" />
+    <ClCompile Include="src\scenes\scene.cpp" />
+    <ClCompile Include="src\scenes\loading_Scene.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\entities\Camera.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\entities\Entity.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\renderEngine\Loader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\renderEngine\Renderer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\shaders\shader_program.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>
+    <ClCompile Include="src\computervision\SkinDetector.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\computervision\FingerCount.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\computervision\BackgroundRemover.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="src\collision\collision.h" />
@@ -57,6 +121,35 @@
     <ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
     <ClInclude Include="src\computervision\HandDetectRegion.h" />
     <ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
+    <ClInclude Include="src\collision\collision.h" />
+    <ClInclude Include="src\collision\collision_handler.h" />
+    <ClInclude Include="src\entities\main_character.h" />
+    <ClInclude Include="src\entities\house_generator.h" />
+    <ClInclude Include="src\scenes\in_Game_Scene.h" />
+    <ClInclude Include="src\scenes\scene.h" />
+    <ClInclude Include="src\computervision\FingerCount.h" />
+    <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\computervision\MenuTest.h" />
+    <ClInclude Include="src\computervision\SkinDetector.h" />
+    <ClInclude Include="src\computervision\ObjectDetection.h" />
+    <ClInclude Include="src\entities\camera.h" />
+    <ClInclude Include="src\entities\collision_entity.h" />
+    <ClInclude Include="src\entities\entity.h" />
+    <ClInclude Include="src\entities\light.h" />
+    <ClInclude Include="src\gui\gui_element.h" />
+    <ClInclude Include="src\gui\gui_interactable.h" />
+    <ClInclude Include="src\models\model.h" />
+    <ClInclude Include="src\renderEngine\loader.h" />
+    <ClInclude Include="src\renderEngine\obj_loader.h" />
+    <ClInclude Include="src\renderEngine\renderer.h" />
+    <ClInclude Include="src\shaders\gui_shader.h" />
+    <ClInclude Include="src\shaders\shader_program.h" />
+    <ClInclude Include="src\shaders\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\startup_Scene.h" />
+    <ClInclude Include="src\scenes\loading_Scene.h" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />