Merge pull request #2 from SemvdH/feature/house-generation

Feature/house generation into develop

.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

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/entities/Camera.cpp

@@ -33,12 +33,14 @@ namespace entities
 
 		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
 		{
-			rotation.x -= ROT_SPEED;
+			//rotation.x -= ROT_SPEED;
+			position.y += 5;
 		}
 
 		if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
 		{
-			rotation.x += ROT_SPEED;
+			//rotation.x += ROT_SPEED;
+			position.y -= 5;
 		}
 
 		float dx = glm::cos(glm::radians(rotation.y + 90)) * movement_speed;

src/entities/Camera.h

@@ -13,7 +13,7 @@ namespace entities
 	{
 	private:
 		// The movement speed of the camera
-		const float SPEED = 0.52f;
+		const float SPEED = 2.0f;
 		const float ROT_SPEED = 1.0f;
 		
 		glm::vec3 position;

src/entities/house_generator.cpp

@@ -0,0 +1,258 @@
+#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();
+	}
+
+	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));
+
+		for(int i = 0; i<toolbox::Random(1,4);i++)
+		{
+			FurnitureType type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
+			models::TexturedModel model = GetFurnitureModel(type);
+			glm::vec3 model_pos = glm::vec3(position.x, position.y, 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 * 2, model_box));
+		}
+		
+		/*
+		// 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));
+		*/
+		return furniture;
+	}
+
+	models::TexturedModel HouseGenerator::GetFurnitureModel(FurnitureType furniture)
+	{
+		const auto found = furniture_models.find(furniture);
+		if (found == furniture_models.end())
+		{
+			std::cerr << "OH NEEEEEEEEEEEEEEE";
+		}
+		
+		auto models = found->second;
+
+		const int modelNumber = toolbox::Random(0, models.size() - 1);
+		
+		return models[modelNumber];
+	}
+
+	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);
+		
+		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::COUCH, couches));
+
+		// 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);
+		
+		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::TABLE, tables));
+
+		// 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);
+
+		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::CHAIR, chairs));
+
+
+		// 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);
+		
+		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::PLANT, plants));
+
+		// 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);
+		
+		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::GUITAR, guitars));
+
+		// 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);
+
+		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::BOOKSHELF, bookshelves));
+
+		// 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);
+		
+		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::LAMP, lamps));
+
+		// 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);
+		
+		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::CEILING_OBJECTS, ceiling_Objects));
+
+		// 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);
+
+		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::MISC, miscs));
+	}
+}

src/entities/house_generator.h

@@ -0,0 +1,67 @@
+#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
+	};
+	
+	class HouseGenerator
+	{
+	private:
+		const float HOUSE_SIZE = 30;
+		
+		models::TexturedModel house_model;
+		models::ModelTexture default_texture;
+		
+		std::map<FurnitureType, std::deque<models::TexturedModel>> 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:
+		/*
+		 * @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(FurnitureType furniture);
+	};
+}

src/main.cpp

@@ -14,6 +14,7 @@
 #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"

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
@@ -51,12 +50,12 @@ 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;
-
+			
 			// Enable the model (VAO)
 			glBindVertexArray(raw_model.vao_id);
 
@@ -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

@@ -10,39 +10,62 @@
 #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::vector<entities::Light> lights;
+	entities::HouseGenerator* house_generator;
+	std::deque<std::shared_ptr<entities::Entity>> house_models;
+	std::deque<entities::Light> lights;
+	std::deque<std::shared_ptr<entities::Entity>> trees;
+
 	models::RawModel raw_model;
 	models::ModelTexture texture;
-	shaders::EntityShader *shader;
-	shaders::GuiShader *gui_shader;
-	entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
+	shaders::EntityShader* shader;
+	shaders::GuiShader* gui_shader;
+	entities::Camera camera(glm::vec3(0, -50, 0), glm::vec3(0, 0, 0));
 	std::vector<gui::GuiTexture*> guis;
 
 
 	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);
 
-	
 	In_Game_Scene::In_Game_Scene()
 	{
 		shader = new shaders::EntityShader;
-		shader->Init();	
+		shader->Init();
 		render_engine::renderer::Init(*shader);
 
 		gui_shader = new shaders::GuiShader();
 		gui_shader->Init();
 	}
 
-	scene::Scenes scene::In_Game_Scene::start(GLFWwindow* window)
+	In_Game_Scene::~In_Game_Scene()
 	{
+		delete house_generator;
+	}
+
+	/**
+	 * @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
@@ -52,22 +75,34 @@ namespace scene
 		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);
-
-
-		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)
+		std::cout << "loading model chunk" << std::endl;
+		if (house_models.size() >= MAX_MODEL_DEQUE_SIZE * furniture_count)
 		{
-			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);
+			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();
+		
+		house_models.insert(house_models.end(), furniture.begin(), furniture.end());
+	}
+
+
+	scene::Scenes scene::In_Game_Scene::start(GLFWwindow* window)
+	{
+		house_generator = new entities::HouseGenerator();
+		// load the first few house models
+		for (int i = 0; i <= UPCOMING_MODEL_AMOUNT; i++)
+		{
+			load_chunk(i);
 		}
 
-		lights.push_back(entities::Light(glm::vec3(0, 1000, -7000), glm::vec3(5, 5, 5)));
+		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)));
 
@@ -76,11 +111,11 @@ namespace scene
 		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);
-	
+
 
 		while (return_value == scene::Scenes::INGAME)
 		{
@@ -104,13 +139,17 @@ namespace scene
 
 		shader->Start();
 		shader->LoadSkyColor(render_engine::renderer::SKY_COLOR);
-		shader->LoadLights(lights);
+		shader->LoadLightsDeque(lights);
 		shader->LoadViewMatrix(camera);
 
-		// Renders each entity in the entities list
-		for (entities::Entity& entity : entities)
+		for (std::shared_ptr<entities::Entity> model_entity : house_models)
 		{
-			render_engine::renderer::Render(entity, *shader);
+			render_engine::renderer::Render(model_entity, *shader);
+		}
+
+		for (std::shared_ptr<entities::Entity> tree_entity : trees)
+		{
+			render_engine::renderer::Render(tree_entity, *shader);
 		}
 
 		// Render GUI items
@@ -123,12 +162,25 @@ namespace scene
 	void scene::In_Game_Scene::update(GLFWwindow* window)
 	{
 		camera.Move(window);
+
+		// calculate where the next house model should be loaded
+		static int last_model_pos = 0;
+		int model_pos = -round(camera.GetPosition().z / (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);
+		}
+		// remember the position at which the new model was added
+		last_model_pos = model_pos;
+    
 		update_hand_detection();
 	}
 
 	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;

src/scenes/in_Game_Scene.h

@@ -12,6 +12,7 @@ namespace scene
 	
 	public:
 		In_Game_Scene();
+		~In_Game_Scene();
 
 		Scenes start(GLFWwindow* window) override;
 		void render() 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,15 @@ namespace toolbox
 		matrix = glm::translate(matrix, negative_cam_pos);
 		return matrix;
 	}
+
+	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

@@ -46,4 +46,14 @@ namespace toolbox
 	 * @return: The view matrix
 	 */
 	glm::mat4 CreateViewMatrix(entities::Camera& camera);
+
+	/*
+	 * @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,6 +20,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\collision\collision_handler.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" />
@@ -46,6 +47,7 @@
   <ItemGroup>
     <ClInclude Include="src\collision\collision.h" />
     <ClInclude Include="src\collision\collision_handler.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" />

wk2_fps.vcxproj.filters

@@ -26,6 +26,152 @@
     <ClCompile Include="src\computervision\HandDetectRegion.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\FaceDetector.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\computervision\BackgroundRemover.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\entities\house_generator.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="src\entities\Camera.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\entities\Entity.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\models\Model.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\renderEngine\Loader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\renderEngine\Renderer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\stb_image.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\shaders\shader_program.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\renderEngine\obj_loader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\toolbox\toolbox.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\entities\light.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\shaders\entity_shader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\shaders\gui_shader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\gui\gui_element.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\gui\gui_interactable.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\scenes\scene.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\scenes\in_Game_Scene.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\scenes\startup_Scene.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\entities\collision_entity.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\collision\collision.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\collision\collision_handler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\computervision\ObjectDetection.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\computervision\SkinDetector.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <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\toolbox\Timer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\entities\house_generator.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="src\collision\collision.h" />
     <ClInclude Include="src\collision\collision_handler.h" />
     <ClInclude Include="src\scenes\in_Game_Scene.h" />