From bce2ccf889ab840565ef1e1fda05476ad7e3fbb3 Mon Sep 17 00:00:00 2001 From: Jasper Date: Fri, 11 Jun 2021 11:43:46 +0200 Subject: [PATCH 01/11] [ADD] added base for loading scene --- src/scenes/loading_Scene.cpp | 47 +++++++++++++ src/scenes/loading_Scene.h | 63 ++++++++++++++++++ src/scenes/scene.h | 1 + src/scenes/startup_Scene.cpp | 1 + wk2_fps.vcxproj | 2 + wk2_fps.vcxproj.filters | 124 ++++++++++------------------------- 6 files changed, 148 insertions(+), 90 deletions(-) create mode 100644 src/scenes/loading_Scene.cpp create mode 100644 src/scenes/loading_Scene.h diff --git a/src/scenes/loading_Scene.cpp b/src/scenes/loading_Scene.cpp new file mode 100644 index 0000000..3c9e245 --- /dev/null +++ b/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(); + + } + + 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 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) + { + } +} diff --git a/src/scenes/loading_Scene.h b/src/scenes/loading_Scene.h new file mode 100644 index 0000000..abe3ea0 --- /dev/null +++ b/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; + }; +} + + diff --git a/src/scenes/scene.h b/src/scenes/scene.h index 4db2fe5..396a6f5 100644 --- a/src/scenes/scene.h +++ b/src/scenes/scene.h @@ -11,6 +11,7 @@ namespace scene { */ enum class Scenes { + LOADING, STARTUP, INGAME, GAMEOVER, diff --git a/src/scenes/startup_Scene.cpp b/src/scenes/startup_Scene.cpp index b734214..d83d2fb 100644 --- a/src/scenes/startup_Scene.cpp +++ b/src/scenes/startup_Scene.cpp @@ -211,6 +211,7 @@ namespace scene { if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) { + return_value = scene::Scenes::INGAME; cv::destroyWindow("camera"); } diff --git a/wk2_fps.vcxproj b/wk2_fps.vcxproj index f9065d6..9f078f2 100644 --- a/wk2_fps.vcxproj +++ b/wk2_fps.vcxproj @@ -40,6 +40,7 @@ + @@ -56,6 +57,7 @@ + diff --git a/wk2_fps.vcxproj.filters b/wk2_fps.vcxproj.filters index fad9c5f..bf45e7b 100644 --- a/wk2_fps.vcxproj.filters +++ b/wk2_fps.vcxproj.filters @@ -24,6 +24,11 @@ + + + + + @@ -83,98 +88,8 @@ Source Files - - Source Files - - - Source Files - - - Source Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - @@ -206,6 +121,35 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From f6fad79c2ea66468abbebc046be84bd56e8d94a5 Mon Sep 17 00:00:00 2001 From: Lars Date: Fri, 11 Jun 2021 15:56:34 +0200 Subject: [PATCH 02/11] [TRY] trying to manage some data storage --- src/gui/gui_element.h | 2 +- src/main.cpp | 11 ++- src/model_Storage.cpp | 187 +++++++++++++++++++++++++++++++++++ src/model_Storage.h | 99 +++++++++++++++++++ src/scenes/loading_Scene.cpp | 24 ++++- src/scenes/loading_Scene.h | 8 +- wk2_fps.vcxproj | 2 + wk2_fps.vcxproj.filters | 2 + 8 files changed, 328 insertions(+), 7 deletions(-) create mode 100644 src/model_Storage.cpp create mode 100644 src/model_Storage.h diff --git a/src/gui/gui_element.h b/src/gui/gui_element.h index 9887c68..79a4613 100644 --- a/src/gui/gui_element.h +++ b/src/gui/gui_element.h @@ -19,7 +19,7 @@ namespace gui */ struct GuiTexture { - int texture; + unsigned int texture; glm::vec2 position; glm::vec2 scale; diff --git a/src/main.cpp b/src/main.cpp index be9e1bc..4e571e3 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -27,6 +27,8 @@ #include "scenes/scene.h" #include "scenes/in_Game_Scene.h" #include "scenes/startup_Scene.h" +#include "scenes/loading_Scene.h" +#include "model_Storage.h" #include "computervision/ObjectDetection.h" //#include "computervision/OpenPoseImage.h" @@ -72,8 +74,8 @@ int main(void) glGetError(); #pragma endregion - - current_scene = new scene::Startup_Scene(); + //current_scene = new scene::Startup_Scene(); + current_scene = new scene::Loading_Scene(); glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods) { @@ -103,6 +105,10 @@ int main(void) window_open = false; break; + case scene::Scenes::LOADING: + current_scene = new scene::Loading_Scene(); + break; + case scene::Scenes::STARTUP: current_scene = new scene::Startup_Scene(); break; @@ -126,6 +132,7 @@ int main(void) // Clean up -> preventing memory leaks!!! std::cout << "ending..." << std::endl; + singleton::Model_Storage:: glfwTerminate(); return 0; } diff --git a/src/model_Storage.cpp b/src/model_Storage.cpp new file mode 100644 index 0000000..8753bea --- /dev/null +++ b/src/model_Storage.cpp @@ -0,0 +1,187 @@ +#include "model_Storage.h" + + +singleton::Model_Storage* singleton::Model_Storage::instance{nullptr}; +std::mutex singleton::Model_Storage::mutex; + +singleton::Model_Storage::~Model_Storage() +{ + delete instance; +} + +singleton::Model_Storage* singleton::Model_Storage::get_instance() +{ + std::lock_guard lock(mutex); + if (instance == nullptr) + instance = new Model_Storage(); + + return instance; +} + +/** + * add methods + */ + +void singleton::Model_Storage::add_couch(models::TexturedModel couch) +{ + couches.push_back(couch); +} + +void singleton::Model_Storage::add_table(models::TexturedModel table) +{ + tables.push_back(table); +} + +void singleton::Model_Storage::add_chair(models::TexturedModel chair) +{ + chairs.push_back(chair); +} + +void singleton::Model_Storage::add_plant(models::TexturedModel plant) +{ + plants.push_back(plant); +} + +void singleton::Model_Storage::add_guitar(models::TexturedModel guitar) +{ + guitars.push_back(guitar); +} + +void singleton::Model_Storage::add_bookshelf(models::TexturedModel bookshelf) +{ + bookshelves.push_back(bookshelf); +} + +void singleton::Model_Storage::add_lamp(models::TexturedModel lamp) +{ + lamps.push_back(lamp); +} + +void singleton::Model_Storage::addd_ceiling_object(models::TexturedModel co) +{ + ceiling_objects.push_back(co); +} + +void singleton::Model_Storage::add_misc(models::TexturedModel misc) +{ + miscs.push_back(misc); +} + +/** + * getters + */ + +std::deque singleton::Model_Storage::get_all_couches() +{ + return couches; +} + +std::deque singleton::Model_Storage::get_all_tables() +{ + return tables; +} + +std::deque singleton::Model_Storage::get_all_chairs() +{ + return chairs; +} + +std::deque singleton::Model_Storage::get_all_plants() +{ + return plants; +} + +std::deque singleton::Model_Storage::get_all_guitars() +{ + return guitars; +} + +std::deque singleton::Model_Storage::get_all_bookshelves() +{ + return bookshelves; +} + +std::deque singleton::Model_Storage::get_all_lamps() +{ + return lamps; +} + +std::deque singleton::Model_Storage::get_all_ceiling_objects() +{ + return ceiling_objects; +} + +std::deque singleton::Model_Storage::get_all_miscs() +{ + return miscs; +} + +models::TexturedModel singleton::Model_Storage::get_couch(int index) +{ + return couches[index]; +} + +models::TexturedModel singleton::Model_Storage::get_table(int index) +{ + return tables[index]; +} + +models::TexturedModel singleton::Model_Storage::get_chair(int index) +{ + return chairs[index]; +} + +models::TexturedModel singleton::Model_Storage::get_plant(int index) +{ + return plants[index]; +} + +models::TexturedModel singleton::Model_Storage::get_guitar(int index) +{ + return guitars[index]; +} + +models::TexturedModel singleton::Model_Storage::get_bookshelf(int index) +{ + return bookshelves[index]; +} + +models::TexturedModel singleton::Model_Storage::get_lamp(int index) +{ + return lamps[index]; +} + +models::TexturedModel singleton::Model_Storage::get_ceiling_object(int index) +{ + return ceiling_objects[index]; +} + +models::TexturedModel singleton::Model_Storage::get_misc(int index) +{ + return miscs[index]; +} + + +//getters for default variables +models::TexturedModel singleton::Model_Storage::get_house_model() +{ + return models::TexturedModel(); +} + +models::ModelTexture singleton::Model_Storage::get_default_texture() +{ + return models::ModelTexture(); +} + + //setters for deafult variables +void singleton::Model_Storage::set_house_model(models::TexturedModel house) +{ + house_model = house; +} + +void singleton::Model_Storage::set_default_texture(models::ModelTexture texture) +{ + default_texture = texture; +} + + diff --git a/src/model_Storage.h b/src/model_Storage.h new file mode 100644 index 0000000..8ef742d --- /dev/null +++ b/src/model_Storage.h @@ -0,0 +1,99 @@ +#pragma once +#include +#include +#include "models/Model.h" + +namespace singleton { + class Model_Storage + { + private: + static Model_Storage* instance; + static std::mutex mutex; + + //model of the house + models::TexturedModel house_model; + //default texture + models::ModelTexture default_texture; + + //list of furniture: + //couches + std::deque couches; + + //tables + std::deque tables; + + //chairs + std::deque chairs; + + //plants + std::deque plants; + + //guitars + std::deque guitars; + + //bookshelves + std::deque bookshelves; + + //lamps + std::dequelamps; + + //ceiling objects + std::dequeceiling_objects; + + //misc + std::deque miscs; + + protected: + Model_Storage() {} + ~Model_Storage(); + + public: + Model_Storage(Model_Storage& other) = delete; + void operator=(const Model_Storage&) = delete; + + static Model_Storage* get_instance(); + + //some methods to execute on its instance: + void add_couch(models::TexturedModel couch); + void add_table(models::TexturedModel table); + void add_chair(models::TexturedModel chair); + void add_plant(models::TexturedModel plant); + void add_guitar(models::TexturedModel guitar); + void add_bookshelf(models::TexturedModel bookshelf); + void add_lamp(models::TexturedModel lamp); + void addd_ceiling_object(models::TexturedModel co); + void add_misc(models::TexturedModel misc); + + //getters for the whole list + std::deque get_all_couches(); + std::deque get_all_tables(); + std::deque get_all_chairs(); + std::deque get_all_plants(); + std::deque get_all_guitars(); + std::deque get_all_bookshelves(); + std::deque get_all_lamps(); + std::deque get_all_ceiling_objects(); + std::deque get_all_miscs(); + + //getters for one model + models::TexturedModel get_couch(int index); + models::TexturedModel get_table(int index); + models::TexturedModel get_chair(int index); + models::TexturedModel get_plant(int index); + models::TexturedModel get_guitar(int index); + models::TexturedModel get_bookshelf(int index); + models::TexturedModel get_lamp(int index); + models::TexturedModel get_ceiling_object(int index); + models::TexturedModel get_misc(int index); + + //getters for the standard variables + models::TexturedModel get_house_model(); + models::ModelTexture get_default_texture(); + + //setters for the standard variables + void set_house_model(models::TexturedModel house); + void set_default_texture(models::ModelTexture texture); + }; +} + + diff --git a/src/scenes/loading_Scene.cpp b/src/scenes/loading_Scene.cpp index 3c9e245..bf84000 100644 --- a/src/scenes/loading_Scene.cpp +++ b/src/scenes/loading_Scene.cpp @@ -1,11 +1,11 @@ #include "loading_Scene.h" #include "../renderEngine/Renderer.h" #include "../renderEngine/Loader.h" +#include "../renderEngine/obj_loader.h" #include "../gui/gui_element.h" namespace scene { - Loading_Scene::Loading_Scene() { gui_shader = new shaders::GuiShader(); @@ -20,6 +20,8 @@ namespace scene Scenes Loading_Scene::start(GLFWwindow* window) { render(); + load_default_variables(); + load_all_models(); } @@ -27,7 +29,7 @@ namespace scene { render_engine::renderer::Prepare(); - gui::GuiTexture loading_image = { render_engine::loader::LoadTexture("res/menu_item_start1.png"), + gui::GuiTexture loading_image = { render_engine::loader::LoadTexture("res/loading_screen.png"), glm::vec2(0,0),glm::vec2(1,1) }; std::vector image_list; @@ -44,4 +46,22 @@ namespace scene void Loading_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods) { } + + + void Loading_Scene::load_default_variables() + { + models::RawModel raw_model = render_engine::LoadObjModel("res/HouseNew.obj"); + models::ModelTexture default_texture = { render_engine::loader::LoadTexture("res/Texture.png") }; + default_texture.shine_damper = 10; + + models::TexturedModel house = { raw_model, default_texture }; + + singleton::Model_Storage::get_instance()->set_default_texture(default_texture); + singleton::Model_Storage::get_instance()->set_house_model(house); + } + + void Loading_Scene::load_all_models() + { + + } } diff --git a/src/scenes/loading_Scene.h b/src/scenes/loading_Scene.h index abe3ea0..5aa8362 100644 --- a/src/scenes/loading_Scene.h +++ b/src/scenes/loading_Scene.h @@ -1,8 +1,8 @@ #pragma once -#pragma once #include "scene.h" #include "../gui/gui_element.h" #include "../shaders/gui_shader.h" +#include "../model_Storage.h" namespace scene { @@ -17,9 +17,13 @@ namespace scene shaders::GuiShader* gui_shader; + private: + void load_default_variables(); + void load_all_models(); + public: /** - * @brief Constructor of the class Startup_Scene + * @brief Constructor of the class Loading_Scene * */ Loading_Scene(); diff --git a/wk2_fps.vcxproj b/wk2_fps.vcxproj index 9f078f2..2250702 100644 --- a/wk2_fps.vcxproj +++ b/wk2_fps.vcxproj @@ -19,6 +19,7 @@ + @@ -49,6 +50,7 @@ + diff --git a/wk2_fps.vcxproj.filters b/wk2_fps.vcxproj.filters index bf45e7b..1d4f859 100644 --- a/wk2_fps.vcxproj.filters +++ b/wk2_fps.vcxproj.filters @@ -29,6 +29,7 @@ + @@ -150,6 +151,7 @@ + From fb70d10c470cf1c64074bc34d6440d83b7572f41 Mon Sep 17 00:00:00 2001 From: Jasper Date: Fri, 11 Jun 2021 15:58:28 +0200 Subject: [PATCH 03/11] [EDIT] made a grid for the models to load in Some items still clip through the wall --- .../house_generator.cpp | 340 ++++++++++++++++++ src/entities/house_generator.cpp | 142 ++++++-- src/entities/house_generator.h | 28 +- 3 files changed, 476 insertions(+), 34 deletions(-) create mode 100644 enc_temp_folder/e14e1bac1d366a32333657ac3b22e523/house_generator.cpp diff --git a/enc_temp_folder/e14e1bac1d366a32333657ac3b22e523/house_generator.cpp b/enc_temp_folder/e14e1bac1d366a32333657ac3b22e523/house_generator.cpp new file mode 100644 index 0000000..529b313 --- /dev/null +++ b/enc_temp_folder/e14e1bac1d366a32333657ac3b22e523/house_generator.cpp @@ -0,0 +1,340 @@ +#include "house_generator.h" + +#include +#include + +#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::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it) + { + if(it->furniture.type == random_type) + { + return &it->furniture; + } + } + + return nullptr; + } + + std::deque> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation) + { + std::deque> furniture; + + // Add house + furniture.push_front(std::make_shared(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(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(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(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(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(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(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(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(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(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(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box)); + */ + + } + + models::TexturedModel HouseGenerator::GetFurnitureModel(const FurniturePiece* furniture) + { + std::deque *furniture_list = nullptr; + + for (std::deque::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 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 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 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 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 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 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::dequelamps; + + 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::dequeceiling_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 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); + } +} diff --git a/src/entities/house_generator.cpp b/src/entities/house_generator.cpp index 6573701..ea3f00b 100644 --- a/src/entities/house_generator.cpp +++ b/src/entities/house_generator.cpp @@ -20,22 +20,51 @@ namespace entities GenerateFurnitureModels(); } + const FurniturePiece* HouseGenerator::GetRandomFurniturePiece() + { + FurnitureType random_type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1)); + + for(std::deque::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it) + { + if(it->furniture.type == random_type) + { + return &it->furniture; + } + } + + return nullptr; + } + std::deque> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation) { std::deque> furniture; // Add house furniture.push_front(std::make_shared(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); - for(int i = 0; i(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box)); - } + collision::Box model_box = { model_pos, model.raw_model.model_size }; + model_box.SetRotation(-90); + furniture.push_back(std::make_shared(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box)); + //} + } + } + } + + return furniture; /* // Add furniture @@ -85,22 +114,31 @@ namespace entities collision::Box misc_box = { misc_pos, misc.raw_model.model_size }; furniture.push_back(std::make_shared(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box)); */ - return furniture; + } - models::TexturedModel HouseGenerator::GetFurnitureModel(FurnitureType furniture) + models::TexturedModel HouseGenerator::GetFurnitureModel(const FurniturePiece* furniture) { - const auto found = furniture_models.find(furniture); - if (found == furniture_models.end()) + std::deque *furniture_list = nullptr; + + for (std::deque::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"; } - auto models = found->second; - - const int modelNumber = toolbox::Random(0, models.size() - 1); + const int modelNumber = toolbox::Random(0, furniture_list->size() - 1); - return models[modelNumber]; + return furniture_list->at(modelNumber); + + //return {}; } void HouseGenerator::GenerateFurnitureModels() @@ -119,8 +157,13 @@ namespace entities 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.insert(std::pair>(FurnitureType::COUCH, couches)); + furniture_models.push_back(couch); // Tables std::deque tables; @@ -137,7 +180,12 @@ namespace entities models::TexturedModel table3 = { table_model3, default_texture }; tables.push_back(table3); - furniture_models.insert(std::pair>(FurnitureType::TABLE, tables)); + FurnitureModel table; + table.furniture = { + FurnitureType::TABLE, 2 }; + table.texture = tables; + + furniture_models.push_back(table); // Chairs std::deque chairs; @@ -154,8 +202,12 @@ namespace entities models::TexturedModel chair3 = { chair_model3, default_texture }; chairs.push_back(chair3); - furniture_models.insert(std::pair>(FurnitureType::CHAIR, chairs)); + FurnitureModel chair; + chair.furniture = { + FurnitureType::CHAIR, 1 }; + chair.texture = chairs; + furniture_models.push_back(chair); // Plants std::deque plants; @@ -171,8 +223,13 @@ namespace entities 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::PLANT, plants)); + + FurnitureModel plant; + plant.furniture = { + FurnitureType::PLANT, 1 }; + plant.texture = plants; + + furniture_models.push_back(plant); // Guitars std::deque guitars; @@ -184,8 +241,13 @@ namespace entities 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::GUITAR, guitars)); + + FurnitureModel guitar; + guitar.furniture = { + FurnitureType::GUITAR, 1 }; + guitar.texture = guitars; + + furniture_models.push_back(guitar); // Bookshelves std::deque bookshelves; @@ -202,7 +264,12 @@ namespace entities models::TexturedModel bookshelf3 = { bookshelf_model3, default_texture }; bookshelves.push_back(bookshelf3); - furniture_models.insert(std::pair>(FurnitureType::BOOKSHELF, bookshelves)); + FurnitureModel bookshelf; + bookshelf.furniture = { + FurnitureType::BOOKSHELF, 1 }; + bookshelf.texture = bookshelves; + + furniture_models.push_back(bookshelf); // Lamps std::dequelamps; @@ -214,8 +281,13 @@ namespace entities 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::LAMP, lamps)); + + FurnitureModel lamp; + lamp.furniture = { + FurnitureType::LAMP, 1 }; + lamp.texture = lamps; + + furniture_models.push_back(lamp); // Ceiling objects std::dequeceiling_Objects; @@ -235,8 +307,13 @@ namespace entities 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::CEILING_OBJECTS, ceiling_Objects)); + + FurnitureModel ceiling_object; + ceiling_object.furniture = { + FurnitureType::CEILING_OBJECTS, 1 }; + ceiling_object.texture = ceiling_Objects; + + furniture_models.push_back(ceiling_object); // Miscs std::deque miscs; @@ -253,6 +330,11 @@ namespace entities models::TexturedModel misc3 = { misc_model3, default_texture }; miscs.push_back(misc3); - furniture_models.insert(std::pair>(FurnitureType::MISC, miscs)); + FurnitureModel misc; + misc.furniture = { + FurnitureType::MISC, 1 }; + misc.texture = miscs; + + furniture_models.push_back(misc); } } diff --git a/src/entities/house_generator.h b/src/entities/house_generator.h index 12fbfa0..84d8f42 100644 --- a/src/entities/house_generator.h +++ b/src/entities/house_generator.h @@ -20,6 +20,24 @@ namespace entities CEILING_OBJECTS, MISC }; + struct FurniturePiece + { + FurnitureType type; + int size; + }; + + struct FurnitureModel + { + FurniturePiece furniture; + std::deque texture; + + bool operator<(FurnitureModel a) + { + return true; + } + }; + + class HouseGenerator { @@ -29,11 +47,11 @@ namespace entities models::TexturedModel house_model; models::ModelTexture default_texture; - std::map> furniture_models; - + //std::map> furniture_models; + std::deque furniture_models; public: HouseGenerator(); - + /* * @brief: This function generates a house with furniture at the given position and rotation * @@ -50,6 +68,8 @@ namespace entities float GetHouseDepth() const { return house_model.raw_model.model_size.x * HOUSE_SIZE; } private: + const FurniturePiece* GetRandomFurniturePiece(); + /* * @brief: This function loads all the 3D furniture models */ @@ -62,6 +82,6 @@ namespace entities * * @return: The model of the random furniture of the chosen furniture type */ - models::TexturedModel GetFurnitureModel(FurnitureType furniture); + models::TexturedModel GetFurnitureModel(const FurniturePiece* furniture); }; } From 001f28d198b3b86b3912d895a33be7a56d429b66 Mon Sep 17 00:00:00 2001 From: Lars Date: Fri, 11 Jun 2021 16:01:17 +0200 Subject: [PATCH 04/11] [forget] --- src/main.cpp | 1 - src/scenes/loading_Scene.cpp | 13 +++++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/src/main.cpp b/src/main.cpp index 4e571e3..d2d5a86 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -132,7 +132,6 @@ int main(void) // Clean up -> preventing memory leaks!!! std::cout << "ending..." << std::endl; - singleton::Model_Storage:: glfwTerminate(); return 0; } diff --git a/src/scenes/loading_Scene.cpp b/src/scenes/loading_Scene.cpp index bf84000..d7d3fbe 100644 --- a/src/scenes/loading_Scene.cpp +++ b/src/scenes/loading_Scene.cpp @@ -1,4 +1,7 @@ #include "loading_Scene.h" + +#include + #include "../renderEngine/Renderer.h" #include "../renderEngine/Loader.h" #include "../renderEngine/obj_loader.h" @@ -23,6 +26,16 @@ namespace scene load_default_variables(); load_all_models(); + int vertices = singleton::Model_Storage::get_instance()->get_house_model().raw_model.vertex_count; + GLuint number = singleton::Model_Storage::get_instance()->get_house_model().raw_model.vao_id; + + std::cout << "amount of vertices of the house model: " << vertices << std::endl; + std::cout << "GLUint of the house model: " << number << std::endl; + + while (true) { + + } + return scene::Scenes::STARTUP; } void Loading_Scene::render() From 24285b971467f98db89e293b031cb36523c0a499 Mon Sep 17 00:00:00 2001 From: Jasper Date: Fri, 11 Jun 2021 16:34:25 +0200 Subject: [PATCH 05/11] [ADD] added an extra layer to the grid for the lamps and fans. Grid now generates correctly. Good enough --- src/entities/house_generator.cpp | 89 ++++++++++++++++++++------------ src/entities/house_generator.h | 1 + 2 files changed, 57 insertions(+), 33 deletions(-) diff --git a/src/entities/house_generator.cpp b/src/entities/house_generator.cpp index ea3f00b..8b09e40 100644 --- a/src/entities/house_generator.cpp +++ b/src/entities/house_generator.cpp @@ -24,48 +24,71 @@ namespace entities { FurnitureType random_type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1)); - for(std::deque::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it) + for (std::deque::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it) { - if(it->furniture.type == random_type) + if (it->furniture.type == random_type) { return &it->furniture; } } - + return nullptr; } - + + const FurniturePiece* HouseGenerator::GetFurniturePiece(FurnitureType type) + { + for (std::deque::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it) + { + if (it->furniture.type == type) + { + return &it->furniture; + } + } + return nullptr; + } + std::deque> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation) { std::deque> furniture; // Add house furniture.push_front(std::make_shared(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; - + 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 / 2; + double multiplier_z = house_size_z / 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(); + 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 (//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); + 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(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box)); - //} + collision::Box model_box = { model_pos, model.raw_model.model_size }; + model_box.SetRotation(-90); + furniture.push_back(std::make_shared(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(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box)); return furniture; - + /* // Add furniture models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH); @@ -93,7 +116,7 @@ namespace entities 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(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 }; @@ -114,30 +137,30 @@ namespace entities collision::Box misc_box = { misc_pos, misc.raw_model.model_size }; furniture.push_back(std::make_shared(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box)); */ - + } models::TexturedModel HouseGenerator::GetFurnitureModel(const FurniturePiece* furniture) { - std::deque *furniture_list = nullptr; - + std::deque* furniture_list = nullptr; + for (std::deque::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it) { - if(it->furniture.type == furniture->type) + 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 {}; } @@ -145,7 +168,7 @@ namespace entities { // Couches std::deque 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); @@ -162,7 +185,7 @@ namespace entities couch.furniture = { FurnitureType::COUCH, 2 }; couch.texture = couches; - + furniture_models.push_back(couch); // Tables @@ -179,12 +202,12 @@ namespace entities 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 @@ -335,6 +358,6 @@ namespace entities FurnitureType::MISC, 1 }; misc.texture = miscs; - furniture_models.push_back(misc); + furniture_models.push_back(misc); } } diff --git a/src/entities/house_generator.h b/src/entities/house_generator.h index 84d8f42..b54c68d 100644 --- a/src/entities/house_generator.h +++ b/src/entities/house_generator.h @@ -69,6 +69,7 @@ namespace entities private: const FurniturePiece* GetRandomFurniturePiece(); + const FurniturePiece* GetFurniturePiece(FurnitureType type); /* * @brief: This function loads all the 3D furniture models From 26d438e4d17c04e0da3491733af0f6d35591fed3 Mon Sep 17 00:00:00 2001 From: Jasper Date: Fri, 18 Jun 2021 09:58:08 +0200 Subject: [PATCH 06/11] [EDIT] models now generate in a 3x3 grid with always 9 models --- src/entities/house_generator.cpp | 17 ++++++++++------- src/gui/gui_element.h | 2 +- src/scenes/loading_Scene.cpp | 6 +++--- 3 files changed, 14 insertions(+), 11 deletions(-) diff --git a/src/entities/house_generator.cpp b/src/entities/house_generator.cpp index 8b09e40..c589338 100644 --- a/src/entities/house_generator.cpp +++ b/src/entities/house_generator.cpp @@ -22,7 +22,10 @@ namespace entities const FurniturePiece* HouseGenerator::GetRandomFurniturePiece() { - FurnitureType random_type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1)); + 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::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it) { @@ -59,25 +62,25 @@ namespace entities 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 / 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 < 3; x++) + for (int x = 1; x < 4; x++) { - if (toolbox::Random(0, 100) < 90) { + //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)) { + //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(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box)); } - } - } + //} + //} } } diff --git a/src/gui/gui_element.h b/src/gui/gui_element.h index 9887c68..17bdc17 100644 --- a/src/gui/gui_element.h +++ b/src/gui/gui_element.h @@ -19,7 +19,7 @@ namespace gui */ struct GuiTexture { - int texture; + GLuint texture; glm::vec2 position; glm::vec2 scale; diff --git a/src/scenes/loading_Scene.cpp b/src/scenes/loading_Scene.cpp index 3c9e245..dd42165 100644 --- a/src/scenes/loading_Scene.cpp +++ b/src/scenes/loading_Scene.cpp @@ -20,12 +20,12 @@ namespace scene Scenes Loading_Scene::start(GLFWwindow* window) { render(); - + return Scenes::STARTUP; } void Loading_Scene::render() { - render_engine::renderer::Prepare(); + /*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) }; @@ -33,7 +33,7 @@ namespace scene std::vector image_list; image_list.push_back(&loading_image); - render_engine::renderer::Render(image_list, *gui_shader); + render_engine::renderer::Render(image_list, *gui_shader);*/ } void Loading_Scene::update(GLFWwindow* window) From 8dbe088a9183bd7efe023f7ecb0946381e08d8f1 Mon Sep 17 00:00:00 2001 From: Lars Date: Fri, 18 Jun 2021 10:08:16 +0200 Subject: [PATCH 07/11] [add] add some code + singleton, not working properly yet --- src/model_Storage.cpp | 19 +++++++++++++++++-- src/model_Storage.h | 10 +++++++++- src/scenes/loading_Scene.cpp | 35 ++++++++++++++++++++++++++++++++++- 3 files changed, 60 insertions(+), 4 deletions(-) diff --git a/src/model_Storage.cpp b/src/model_Storage.cpp index 8753bea..a175fb2 100644 --- a/src/model_Storage.cpp +++ b/src/model_Storage.cpp @@ -165,12 +165,12 @@ models::TexturedModel singleton::Model_Storage::get_misc(int index) //getters for default variables models::TexturedModel singleton::Model_Storage::get_house_model() { - return models::TexturedModel(); + return house_model; } models::ModelTexture singleton::Model_Storage::get_default_texture() { - return models::ModelTexture(); + return default_texture; } //setters for deafult variables @@ -185,3 +185,18 @@ void singleton::Model_Storage::set_default_texture(models::ModelTexture texture) } + + +void singleton::Model_Storage::set_shared_test(entities::Entity* temp) +{ + test_pointer = temp; +} + +entities::Entity* singleton::Model_Storage::get_test_pointer() +{ + return test_pointer; +} + + + + diff --git a/src/model_Storage.h b/src/model_Storage.h index 8ef742d..bfcd67e 100644 --- a/src/model_Storage.h +++ b/src/model_Storage.h @@ -1,7 +1,9 @@ #pragma once +#include #include #include #include "models/Model.h" +#include "entities/Entity.h" namespace singleton { class Model_Storage @@ -15,6 +17,8 @@ namespace singleton { //default texture models::ModelTexture default_texture; + entities::Entity* test_pointer; + //list of furniture: //couches std::deque couches; @@ -44,7 +48,7 @@ namespace singleton { std::deque miscs; protected: - Model_Storage() {} + Model_Storage() { std::cout << "MAKING A NEW SINGLETON!!!" << std::endl; } ~Model_Storage(); public: @@ -93,6 +97,10 @@ namespace singleton { //setters for the standard variables void set_house_model(models::TexturedModel house); void set_default_texture(models::ModelTexture texture); + + void set_shared_test(entities::Entity* pointer); + entities::Entity* get_test_pointer(); + }; } diff --git a/src/scenes/loading_Scene.cpp b/src/scenes/loading_Scene.cpp index d7d3fbe..d2be46e 100644 --- a/src/scenes/loading_Scene.cpp +++ b/src/scenes/loading_Scene.cpp @@ -6,13 +6,24 @@ #include "../renderEngine/Loader.h" #include "../renderEngine/obj_loader.h" #include "../gui/gui_element.h" +#include "../entities/collision_entity.h" namespace scene { + std::unique_ptr camera_test; + shaders::EntityShader* shader_test; + Loading_Scene::Loading_Scene() { + shader_test = new shaders::EntityShader; + shader_test->Init(); + render_engine::renderer::Init(*shader_test); + gui_shader = new shaders::GuiShader(); gui_shader->Init(); + + camera_test = std::make_unique(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0)); + } Loading_Scene::~Loading_Scene() @@ -29,11 +40,18 @@ namespace scene int vertices = singleton::Model_Storage::get_instance()->get_house_model().raw_model.vertex_count; GLuint number = singleton::Model_Storage::get_instance()->get_house_model().raw_model.vao_id; + std::cout << "check shine damper: " << singleton::Model_Storage::get_instance()->get_test_pointer()->GetModel().texture.shine_damper << std::endl; + std::cout << "check texture id: " << singleton::Model_Storage::get_instance()->get_test_pointer()->GetModel().texture.texture_id << std::endl; + + std::cout << "" << std::endl; std::cout << "amount of vertices of the house model: " << vertices << std::endl; std::cout << "GLUint of the house model: " << number << std::endl; while (true) { + render(); + glfwSwapBuffers(window); + glfwPollEvents(); } return scene::Scenes::STARTUP; } @@ -41,6 +59,15 @@ namespace scene void Loading_Scene::render() { render_engine::renderer::Prepare(); + //starts the shader and begins to render + shader_test->Start(); + shader_test->LoadSkyColor(render_engine::renderer::SKY_COLOR); + shader_test->LoadViewMatrix(*camera_test); + + + //render_engine::renderer::Render(singleton::Model_Storage::get_instance()->get_test_pointer(), *shader_test); + + /*render_engine::renderer::Prepare(); gui::GuiTexture loading_image = { render_engine::loader::LoadTexture("res/loading_screen.png"), glm::vec2(0,0),glm::vec2(1,1) }; @@ -48,7 +75,8 @@ namespace scene std::vector image_list; image_list.push_back(&loading_image); - render_engine::renderer::Render(image_list, *gui_shader); + render_engine::renderer::Render(image_list, *gui_shader);*/ + shader_test->Stop(); } void Loading_Scene::update(GLFWwindow* window) @@ -64,13 +92,18 @@ namespace scene void Loading_Scene::load_default_variables() { models::RawModel raw_model = render_engine::LoadObjModel("res/HouseNew.obj"); + std::cout << "raw model vertices: " << raw_model.vertex_count << std::endl; models::ModelTexture default_texture = { render_engine::loader::LoadTexture("res/Texture.png") }; default_texture.shine_damper = 10; models::TexturedModel house = { raw_model, default_texture }; + std::cout << "house struct vertices: " << house.raw_model.vertex_count << std::endl; + + entities::Entity temp = entities::Entity(singleton::Model_Storage::get_instance()->get_house_model(), glm::vec3(0, -100, -500), glm::vec3(0, 90, 0), 30); singleton::Model_Storage::get_instance()->set_default_texture(default_texture); singleton::Model_Storage::get_instance()->set_house_model(house); + singleton::Model_Storage::get_instance()->set_shared_test(&temp); } void Loading_Scene::load_all_models() From 773e8e9a96466ecc8eb00c7f69ec100eeba28acc Mon Sep 17 00:00:00 2001 From: Lars Date: Fri, 18 Jun 2021 10:43:26 +0200 Subject: [PATCH 08/11] [FIX + check] cleaned up the singleton and loading scene, only loading the models should be the only thing to do. besides checking it in another scene! --- src/model_Storage.cpp | 13 ------------- src/model_Storage.h | 4 ---- src/scenes/loading_Scene.cpp | 28 +++------------------------- 3 files changed, 3 insertions(+), 42 deletions(-) diff --git a/src/model_Storage.cpp b/src/model_Storage.cpp index a175fb2..4fa763f 100644 --- a/src/model_Storage.cpp +++ b/src/model_Storage.cpp @@ -187,16 +187,3 @@ void singleton::Model_Storage::set_default_texture(models::ModelTexture texture) -void singleton::Model_Storage::set_shared_test(entities::Entity* temp) -{ - test_pointer = temp; -} - -entities::Entity* singleton::Model_Storage::get_test_pointer() -{ - return test_pointer; -} - - - - diff --git a/src/model_Storage.h b/src/model_Storage.h index bfcd67e..665fbf5 100644 --- a/src/model_Storage.h +++ b/src/model_Storage.h @@ -17,7 +17,6 @@ namespace singleton { //default texture models::ModelTexture default_texture; - entities::Entity* test_pointer; //list of furniture: //couches @@ -98,9 +97,6 @@ namespace singleton { void set_house_model(models::TexturedModel house); void set_default_texture(models::ModelTexture texture); - void set_shared_test(entities::Entity* pointer); - entities::Entity* get_test_pointer(); - }; } diff --git a/src/scenes/loading_Scene.cpp b/src/scenes/loading_Scene.cpp index d2be46e..f6dfd63 100644 --- a/src/scenes/loading_Scene.cpp +++ b/src/scenes/loading_Scene.cpp @@ -12,6 +12,7 @@ namespace scene { std::unique_ptr camera_test; shaders::EntityShader* shader_test; + std::deque> test; Loading_Scene::Loading_Scene() { @@ -37,22 +38,6 @@ namespace scene load_default_variables(); load_all_models(); - int vertices = singleton::Model_Storage::get_instance()->get_house_model().raw_model.vertex_count; - GLuint number = singleton::Model_Storage::get_instance()->get_house_model().raw_model.vao_id; - - std::cout << "check shine damper: " << singleton::Model_Storage::get_instance()->get_test_pointer()->GetModel().texture.shine_damper << std::endl; - std::cout << "check texture id: " << singleton::Model_Storage::get_instance()->get_test_pointer()->GetModel().texture.texture_id << std::endl; - - std::cout << "" << std::endl; - std::cout << "amount of vertices of the house model: " << vertices << std::endl; - std::cout << "GLUint of the house model: " << number << std::endl; - - while (true) { - render(); - - glfwSwapBuffers(window); - glfwPollEvents(); - } return scene::Scenes::STARTUP; } @@ -63,10 +48,9 @@ namespace scene shader_test->Start(); shader_test->LoadSkyColor(render_engine::renderer::SKY_COLOR); shader_test->LoadViewMatrix(*camera_test); + - //render_engine::renderer::Render(singleton::Model_Storage::get_instance()->get_test_pointer(), *shader_test); - /*render_engine::renderer::Prepare(); gui::GuiTexture loading_image = { render_engine::loader::LoadTexture("res/loading_screen.png"), @@ -92,18 +76,12 @@ namespace scene void Loading_Scene::load_default_variables() { models::RawModel raw_model = render_engine::LoadObjModel("res/HouseNew.obj"); - std::cout << "raw model vertices: " << raw_model.vertex_count << std::endl; models::ModelTexture default_texture = { render_engine::loader::LoadTexture("res/Texture.png") }; default_texture.shine_damper = 10; - models::TexturedModel house = { raw_model, default_texture }; - std::cout << "house struct vertices: " << house.raw_model.vertex_count << std::endl; - entities::Entity temp = entities::Entity(singleton::Model_Storage::get_instance()->get_house_model(), glm::vec3(0, -100, -500), glm::vec3(0, 90, 0), 30); - - singleton::Model_Storage::get_instance()->set_default_texture(default_texture); singleton::Model_Storage::get_instance()->set_house_model(house); - singleton::Model_Storage::get_instance()->set_shared_test(&temp); + singleton::Model_Storage::get_instance()->set_default_texture(default_texture); } void Loading_Scene::load_all_models() From 06a6930c58f8279fbc3be8464e43d42c88263246 Mon Sep 17 00:00:00 2001 From: Jasper Date: Fri, 18 Jun 2021 11:13:26 +0200 Subject: [PATCH 09/11] [ADD] filled the method load_all_models() in loading_Scene --- src/scenes/loading_Scene.cpp | 43 ++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/src/scenes/loading_Scene.cpp b/src/scenes/loading_Scene.cpp index f6dfd63..4deb23c 100644 --- a/src/scenes/loading_Scene.cpp +++ b/src/scenes/loading_Scene.cpp @@ -86,6 +86,49 @@ namespace scene void Loading_Scene::load_all_models() { + // Couches + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/couchThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/Coach.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/lawnBenchOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + + // Tables + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/tableOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/tableTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/bureauOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + + // Chairs + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/launchchair.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/lawnChairOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/ugly_chair.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + + // Plants + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/plantOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/plantTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/plantThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + + // Guitars + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/guitarOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/guitarTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + + // Bookshelves + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/bookShelfOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/bookShelfTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/bookShelfThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + + // Lamps + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/lampOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/lampTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + + // Ceiling objects + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/ceilingFan.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/ceilingFanTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/ceilingLampOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/ceilingLampTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + + // Miscs + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/tv.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/radio.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/Flowerpot.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); } } From ad2d651d41c778244b70d3f5eca195539b5ac955 Mon Sep 17 00:00:00 2001 From: Jasper Date: Fri, 18 Jun 2021 14:53:16 +0200 Subject: [PATCH 10/11] [FIX] fixed the loading scene, everything runs correctly now --- src/entities/house_generator.cpp | 356 ++++++------------------------- src/entities/house_generator.h | 53 +---- src/main.cpp | 1 + src/model_Storage.cpp | 18 +- src/model_Storage.h | 38 +++- src/scenes/in_Game_Scene.cpp | 5 +- src/scenes/loading_Scene.cpp | 59 ++--- src/scenes/startup_Scene.cpp | 2 +- 8 files changed, 158 insertions(+), 374 deletions(-) diff --git a/src/entities/house_generator.cpp b/src/entities/house_generator.cpp index c589338..4e0e49f 100644 --- a/src/entities/house_generator.cpp +++ b/src/entities/house_generator.cpp @@ -12,56 +12,55 @@ 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() + void HouseGenerator::GetRandomFurniturePiece(singleton::FurniturePiece* furniture_piece) { - FurnitureType random_type = FurnitureType::CEILING_OBJECTS; - while (random_type == FurnitureType::CEILING_OBJECTS ) { - random_type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1)); + singleton::FurnitureType random_type = singleton::FurnitureType::CEILING_OBJECTS; + std::deque furniture_models = singleton::Model_Storage::get_instance()->get_all_furniture_models(); + + while (random_type == singleton::FurnitureType::CEILING_OBJECTS ) { + random_type = singleton::FurnitureType(toolbox::Random(0, furniture_models.size() - 1)); } - for (std::deque::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it) + for (auto it = furniture_models.begin(); it != furniture_models.end(); ++it) { if (it->furniture.type == random_type) { - return &it->furniture; + furniture_piece->type = it->furniture.type; + furniture_piece->size = it->furniture.size; + break; } } - - return nullptr; + } - const FurniturePiece* HouseGenerator::GetFurniturePiece(FurnitureType type) + void HouseGenerator::GetFurniturePiece(singleton::FurnitureType type, singleton::FurniturePiece* furniture_piece) { - for (std::deque::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it) + std::deque furniture_models = singleton::Model_Storage::get_instance()->get_all_furniture_models(); + for (auto it = furniture_models.begin(); it != furniture_models.end(); ++it) { if (it->furniture.type == type) { - return &it->furniture; + furniture_piece->type = it->furniture.type; + furniture_piece->size = it->furniture.size; + break; } } - return nullptr; } - std::deque> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation) + void HouseGenerator::GenerateHouse(std::deque>* furniture_list , const glm::vec3& position, float y_rotation) { std::deque> furniture; // Add house - furniture.push_front(std::make_shared(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; + furniture_list->push_front(std::make_shared(singleton::Model_Storage::get_instance()->get_house_model(), position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE)); + int house_size_x = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE; + int house_size_y = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE; + int house_size_z = singleton::Model_Storage::get_instance()->get_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); + int offset_x = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.z * (HOUSE_SIZE / 2); + int offset_z = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * (HOUSE_SIZE / 2); double multiplier_x = house_size_x / 4; double multiplier_z = house_size_z / 3; @@ -69,298 +68,63 @@ namespace entities 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); + singleton::FurniturePiece furniture_piece; + GetRandomFurniturePiece(&furniture_piece); + if (furniture_piece.type != singleton::FurnitureType::CEILING_OBJECTS) { + std::cout << "Furniture Piece: " << int(furniture_piece.type) << std::endl; + 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(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box)); - } - //} + collision::Box model_box = { model_pos, model.raw_model.model_size }; + model_box.SetRotation(-90); + furniture_list->push_back(std::make_shared(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); + singleton::FurniturePiece furniture_piece; + GetFurniturePiece(singleton::FurnitureType::CEILING_OBJECTS, &furniture_piece); + models::TexturedModel model = GetFurnitureModel(&furniture_piece); + 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(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(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(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(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(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(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(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(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(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(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box)); - */ + furniture_list->push_back(std::make_shared(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box)); } - models::TexturedModel HouseGenerator::GetFurnitureModel(const FurniturePiece* furniture) + models::TexturedModel HouseGenerator::GetFurnitureModel(const singleton::FurniturePiece* furniture) { - std::deque* furniture_list = nullptr; + std::deque furniture_list; + std::deque furniture_models = singleton::Model_Storage::get_instance()->get_all_furniture_models(); - for (std::deque::iterator it = furniture_models.begin(); it != furniture_models.end(); ++it) + std::cout << "type of furniture_piece: " << int(furniture->type) << std::endl; + + for (auto it = furniture_models.begin(); it != furniture_models.end(); ++it) { if (it->furniture.type == furniture->type) { - furniture_list = &it->texture; + std::deque textures = it->texture; + for (int i = 0; i< textures.size(); i++) + { + furniture_list.push_back(textures.at(i)); + } + std::cout << "Size of textures: " << textures.size() << std::endl; + std::cout << "Size of furniture_list: " << furniture_list.size() << std::endl; + break; } } - - if (furniture_list == nullptr) + std::cout << "Size of furniture_list after for loop: " << furniture_list.size() << std::endl; + if (furniture_list.empty()) { std::cerr << "OH NEEEEEEEEEEEEEEE"; } - const int modelNumber = toolbox::Random(0, furniture_list->size() - 1); + const int modelNumber = toolbox::Random(0, furniture_list.size() - 1); - return furniture_list->at(modelNumber); - - //return {}; - } - - void HouseGenerator::GenerateFurnitureModels() - { - // Couches - std::deque 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 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 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 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 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 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::dequelamps; - - 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::dequeceiling_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 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); + return furniture_list.at(modelNumber); } + } diff --git a/src/entities/house_generator.h b/src/entities/house_generator.h index b54c68d..ef62c38 100644 --- a/src/entities/house_generator.h +++ b/src/entities/house_generator.h @@ -5,50 +5,14 @@ #include #include "../models/Model.h" #include "../collision/collision.h" +#include "../model_Storage.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 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> furniture_models; - std::deque furniture_models; public: HouseGenerator(); @@ -60,21 +24,16 @@ namespace entities * * @return: A list with all the entities of the generated house (the furniture) */ - std::deque> GenerateHouse(const glm::vec3& position, float y_rotation); + void GenerateHouse(std::deque>* furniture_list, 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; } + float GetHouseDepth() const { return singleton::Model_Storage::get_instance()->get_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(); + void GetRandomFurniturePiece(singleton::FurniturePiece* furniture_piece); + void GetFurniturePiece(singleton::FurnitureType type, singleton::FurniturePiece* furniture_piece); /* * @brief: This funtion chooses and returns a random furniture of the given furniture type @@ -83,6 +42,6 @@ namespace entities * * @return: The model of the random furniture of the chosen furniture type */ - models::TexturedModel GetFurnitureModel(const FurniturePiece* furniture); + models::TexturedModel GetFurnitureModel(const singleton::FurniturePiece* furniture); }; } diff --git a/src/main.cpp b/src/main.cpp index d2d5a86..2cc5640 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -132,6 +132,7 @@ int main(void) // Clean up -> preventing memory leaks!!! std::cout << "ending..." << std::endl; + render_engine::loader::CleanUp(); glfwTerminate(); return 0; } diff --git a/src/model_Storage.cpp b/src/model_Storage.cpp index 4fa763f..17a2f9e 100644 --- a/src/model_Storage.cpp +++ b/src/model_Storage.cpp @@ -6,6 +6,7 @@ std::mutex singleton::Model_Storage::mutex; singleton::Model_Storage::~Model_Storage() { + std::cout << "DELETING...." << std::endl; delete instance; } @@ -57,7 +58,7 @@ void singleton::Model_Storage::add_lamp(models::TexturedModel lamp) lamps.push_back(lamp); } -void singleton::Model_Storage::addd_ceiling_object(models::TexturedModel co) +void singleton::Model_Storage::add_ceiling_object(models::TexturedModel co) { ceiling_objects.push_back(co); } @@ -67,6 +68,11 @@ void singleton::Model_Storage::add_misc(models::TexturedModel misc) miscs.push_back(misc); } +void singleton::Model_Storage::add_furniture_model(FurnitureModel model) +{ + furniture_models.push_back(model); +} + /** * getters */ @@ -116,6 +122,11 @@ std::deque singleton::Model_Storage::get_all_miscs() return miscs; } +std::deque singleton::Model_Storage::get_all_furniture_models() +{ + return furniture_models; +} + models::TexturedModel singleton::Model_Storage::get_couch(int index) { return couches[index]; @@ -161,6 +172,11 @@ models::TexturedModel singleton::Model_Storage::get_misc(int index) return miscs[index]; } +singleton::FurnitureModel singleton::Model_Storage::get_furniture_model(int index) +{ + return furniture_models[index]; +} + //getters for default variables models::TexturedModel singleton::Model_Storage::get_house_model() diff --git a/src/model_Storage.h b/src/model_Storage.h index 665fbf5..6e19bb7 100644 --- a/src/model_Storage.h +++ b/src/model_Storage.h @@ -6,6 +6,35 @@ #include "entities/Entity.h" namespace singleton { + 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 texture; + + bool operator<(FurnitureModel a) + { + return true; + } + }; + class Model_Storage { private: @@ -17,7 +46,9 @@ namespace singleton { //default texture models::ModelTexture default_texture; - + //list that sorts furniture_models on type + std::deque furniture_models; + //list of furniture: //couches std::deque couches; @@ -64,8 +95,9 @@ namespace singleton { void add_guitar(models::TexturedModel guitar); void add_bookshelf(models::TexturedModel bookshelf); void add_lamp(models::TexturedModel lamp); - void addd_ceiling_object(models::TexturedModel co); + void add_ceiling_object(models::TexturedModel co); void add_misc(models::TexturedModel misc); + void add_furniture_model(FurnitureModel model); //getters for the whole list std::deque get_all_couches(); @@ -77,6 +109,7 @@ namespace singleton { std::deque get_all_lamps(); std::deque get_all_ceiling_objects(); std::deque get_all_miscs(); + std::deque get_all_furniture_models(); //getters for one model models::TexturedModel get_couch(int index); @@ -88,6 +121,7 @@ namespace singleton { models::TexturedModel get_lamp(int index); models::TexturedModel get_ceiling_object(int index); models::TexturedModel get_misc(int index); + FurnitureModel get_furniture_model(int index); //getters for the standard variables models::TexturedModel get_house_model(); diff --git a/src/scenes/in_Game_Scene.cpp b/src/scenes/in_Game_Scene.cpp index 0ddaad9..9bcb229 100644 --- a/src/scenes/in_Game_Scene.cpp +++ b/src/scenes/in_Game_Scene.cpp @@ -113,7 +113,8 @@ namespace scene } int z_offset = model_pos * (house_generator->GetHouseDepth()); // how much "in the distance" we should load the model - std::deque> furniture = house_generator->GenerateHouse(glm::vec3(0, -75, -50 - z_offset), 90); + std::deque> furniture; + house_generator->GenerateHouse(&furniture, glm::vec3(0, -75, -50 - z_offset), 90); furniture_count = furniture.size(); house_models.insert(house_models.end(), furniture.begin(), furniture.end()); @@ -212,7 +213,7 @@ namespace scene } shader->CleanUp(); gui_shader->CleanUp(); - render_engine::loader::CleanUp(); + //render_engine::loader::CleanUp(); return return_value; } diff --git a/src/scenes/loading_Scene.cpp b/src/scenes/loading_Scene.cpp index 4deb23c..20308f3 100644 --- a/src/scenes/loading_Scene.cpp +++ b/src/scenes/loading_Scene.cpp @@ -90,45 +90,54 @@ namespace scene singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/couchThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/Coach.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/lawnBenchOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - + singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::COUCH, 2}, singleton::Model_Storage::get_instance()->get_all_couches() }); + // Tables - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/tableOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/tableTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/bureauOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_table({ render_engine::LoadObjModel("res/tableOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_table({ render_engine::LoadObjModel("res/tableTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_table({ render_engine::LoadObjModel("res/bureauOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::TABLE, 2}, singleton::Model_Storage::get_instance()->get_all_tables() }); // Chairs - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/launchchair.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/lawnChairOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/ugly_chair.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_chair({ render_engine::LoadObjModel("res/launchchair.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_chair({ render_engine::LoadObjModel("res/lawnChairOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_chair({ render_engine::LoadObjModel("res/ugly_chair.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::CHAIR, 1}, singleton::Model_Storage::get_instance()->get_all_chairs() }); // Plants - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/plantOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/plantTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/plantThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_plant({ render_engine::LoadObjModel("res/plantOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_plant({ render_engine::LoadObjModel("res/plantTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_plant({ render_engine::LoadObjModel("res/plantThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::PLANT, 1}, singleton::Model_Storage::get_instance()->get_all_plants() }); // Guitars - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/guitarOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/guitarTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - + singleton::Model_Storage::get_instance()->add_guitar({ render_engine::LoadObjModel("res/guitarOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_guitar({ render_engine::LoadObjModel("res/guitarTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::GUITAR, 1}, singleton::Model_Storage::get_instance()->get_all_guitars() }); + // Bookshelves - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/bookShelfOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/bookShelfTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/bookShelfThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_bookshelf({ render_engine::LoadObjModel("res/bookShelfOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_bookshelf({ render_engine::LoadObjModel("res/bookShelfTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_bookshelf({ render_engine::LoadObjModel("res/bookShelfThree.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::BOOKSHELF, 1}, singleton::Model_Storage::get_instance()->get_all_bookshelves() }); // Lamps - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/lampOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/lampTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_lamp({ render_engine::LoadObjModel("res/lampOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_lamp({ render_engine::LoadObjModel("res/lampTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::LAMP, 1}, singleton::Model_Storage::get_instance()->get_all_lamps() }); // Ceiling objects - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/ceilingFan.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/ceilingFanTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/ceilingLampOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/ceilingLampTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_ceiling_object({ render_engine::LoadObjModel("res/ceilingFan.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_ceiling_object({ render_engine::LoadObjModel("res/ceilingFanTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_ceiling_object({ render_engine::LoadObjModel("res/ceilingLampOne.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_ceiling_object({ render_engine::LoadObjModel("res/ceilingLampTwo.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::CEILING_OBJECTS, 1}, singleton::Model_Storage::get_instance()->get_all_ceiling_objects() }); // Miscs - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/tv.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/radio.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); - singleton::Model_Storage::get_instance()->add_couch({ render_engine::LoadObjModel("res/Flowerpot.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_misc({ render_engine::LoadObjModel("res/tv.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_misc({ render_engine::LoadObjModel("res/radio.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_misc({ render_engine::LoadObjModel("res/Flowerpot.obj"), singleton::Model_Storage::get_instance()->get_default_texture() }); + singleton::Model_Storage::get_instance()->add_furniture_model({ {singleton::FurnitureType::MISC, 1}, singleton::Model_Storage::get_instance()->get_all_miscs() }); } } diff --git a/src/scenes/startup_Scene.cpp b/src/scenes/startup_Scene.cpp index d83d2fb..7e814e5 100644 --- a/src/scenes/startup_Scene.cpp +++ b/src/scenes/startup_Scene.cpp @@ -175,7 +175,7 @@ namespace scene glfwPollEvents(); } gui_shader1->CleanUp(); - render_engine::loader::CleanUp(); + //render_engine::loader::CleanUp(); return return_value; } From 17b585190a8654a87120c4c5b8368fd10f971a0d Mon Sep 17 00:00:00 2001 From: Jasper Date: Fri, 18 Jun 2021 15:09:30 +0200 Subject: [PATCH 11/11] [EDIT] loadingscreen now has a background, and got rid of some memory leaks --- src/entities/house_generator.cpp | 7 ++++--- src/entities/house_generator.h | 4 +++- src/gui/gui_element.h | 2 +- src/scenes/in_Game_Scene.cpp | 2 +- src/scenes/loading_Scene.cpp | 25 ++++++++++++++----------- 5 files changed, 23 insertions(+), 17 deletions(-) diff --git a/src/entities/house_generator.cpp b/src/entities/house_generator.cpp index 4e0e49f..f316bed 100644 --- a/src/entities/house_generator.cpp +++ b/src/entities/house_generator.cpp @@ -49,12 +49,13 @@ namespace entities } } - void HouseGenerator::GenerateHouse(std::deque>* furniture_list , const glm::vec3& position, float y_rotation) + void HouseGenerator::GenerateHouse(std::deque>* furniture_list , const glm::vec3& position, float y_rotation) { std::deque> furniture; // Add house - furniture_list->push_front(std::make_shared(singleton::Model_Storage::get_instance()->get_house_model(), position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE)); + collision::Box bounding_box = { glm::vec3(0, 0, 0), glm::vec3(0, 0, 0) }; + furniture_list->push_front(std::make_shared(singleton::Model_Storage::get_instance()->get_house_model(), position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE, bounding_box)); int house_size_x = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE; int house_size_y = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE; int house_size_z = singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE; @@ -76,7 +77,7 @@ namespace entities //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 }; + collision::Box model_box = { model_pos, model.raw_model.model_size * HOUSE_SIZE }; model_box.SetRotation(-90); furniture_list->push_back(std::make_shared(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box)); } diff --git a/src/entities/house_generator.h b/src/entities/house_generator.h index ef62c38..b552b4c 100644 --- a/src/entities/house_generator.h +++ b/src/entities/house_generator.h @@ -3,6 +3,8 @@ #include #include #include + +#include "collision_entity.h" #include "../models/Model.h" #include "../collision/collision.h" #include "../model_Storage.h" @@ -24,7 +26,7 @@ namespace entities * * @return: A list with all the entities of the generated house (the furniture) */ - void GenerateHouse(std::deque>* furniture_list, const glm::vec3& position, float y_rotation); + void GenerateHouse(std::deque>* furniture_list, const glm::vec3& position, float y_rotation); /* * @brief: Returns the depth of the house (chunk) diff --git a/src/gui/gui_element.h b/src/gui/gui_element.h index 17bdc17..d02c57c 100644 --- a/src/gui/gui_element.h +++ b/src/gui/gui_element.h @@ -26,7 +26,7 @@ namespace gui virtual GuiType GetType() { return GuiType::LABEL; } - GuiTexture(int texture, glm::vec2 position, glm::vec2 scale): texture(texture), position(position), scale(scale) + GuiTexture(GLuint texture, glm::vec2 position, glm::vec2 scale): texture(texture), position(position), scale(scale) { scale.x /= (WINDOW_WIDTH / WINDOW_HEIGHT); } diff --git a/src/scenes/in_Game_Scene.cpp b/src/scenes/in_Game_Scene.cpp index 9bcb229..f8aa2e1 100644 --- a/src/scenes/in_Game_Scene.cpp +++ b/src/scenes/in_Game_Scene.cpp @@ -113,7 +113,7 @@ namespace scene } int z_offset = model_pos * (house_generator->GetHouseDepth()); // how much "in the distance" we should load the model - std::deque> furniture; + std::deque> furniture; house_generator->GenerateHouse(&furniture, glm::vec3(0, -75, -50 - z_offset), 90); furniture_count = furniture.size(); diff --git a/src/scenes/loading_Scene.cpp b/src/scenes/loading_Scene.cpp index 20308f3..bb7a78f 100644 --- a/src/scenes/loading_Scene.cpp +++ b/src/scenes/loading_Scene.cpp @@ -19,7 +19,8 @@ namespace scene shader_test = new shaders::EntityShader; shader_test->Init(); render_engine::renderer::Init(*shader_test); - + delete shader_test; + gui_shader = new shaders::GuiShader(); gui_shader->Init(); @@ -35,6 +36,10 @@ namespace scene Scenes Loading_Scene::start(GLFWwindow* window) { render(); + + glfwSwapBuffers(window); + glfwPollEvents(); + load_default_variables(); load_all_models(); @@ -45,22 +50,20 @@ namespace scene { render_engine::renderer::Prepare(); //starts the shader and begins to render - shader_test->Start(); - shader_test->LoadSkyColor(render_engine::renderer::SKY_COLOR); - shader_test->LoadViewMatrix(*camera_test); - - - - /*render_engine::renderer::Prepare(); - + //shader_test->Start(); + //shader_test->LoadSkyColor(render_engine::renderer::SKY_COLOR); + //shader_test->LoadViewMatrix(*camera_test); + gui::GuiTexture loading_image = { render_engine::loader::LoadTexture("res/loading_screen.png"), glm::vec2(0,0),glm::vec2(1,1) }; std::vector image_list; image_list.push_back(&loading_image); - render_engine::renderer::Render(image_list, *gui_shader);*/ - shader_test->Stop(); + render_engine::renderer::Render(image_list, *gui_shader); + //shader_test->Stop(); + + gui_shader->CleanUp(); } void Loading_Scene::update(GLFWwindow* window)