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 8df1e76..04f52a5 100644 --- a/src/entities/house_generator.cpp +++ b/src/entities/house_generator.cpp @@ -12,256 +12,120 @@ namespace entities { HouseGenerator::HouseGenerator() { - models::RawModel raw_model = render_engine::LoadObjModel("res/HouseNew.obj"); - default_texture = { render_engine::loader::LoadTexture("res/Texture.png") }; - default_texture.shine_damper = 10; - house_model = { raw_model, default_texture }; - - GenerateFurnitureModels(); } - std::deque> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation) + void HouseGenerator::GetRandomFurniturePiece(singleton::FurniturePiece* furniture_piece) { - std::deque> furniture; + 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 (auto it = furniture_models.begin(); it != furniture_models.end(); ++it) + { + if (it->furniture.type == random_type) + { + furniture_piece->type = it->furniture.type; + furniture_piece->size = it->furniture.size; + break; + } + } + + + } + + void HouseGenerator::GetFurniturePiece(singleton::FurnitureType type, singleton::FurniturePiece* furniture_piece) + { + 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) + { + furniture_piece->type = it->furniture.type; + furniture_piece->size = it->furniture.size; + break; + } + } + } + + void HouseGenerator::GenerateHouse(std::deque>* furniture_list , const glm::vec3& position, float y_rotation) + { + std::deque> furniture; // Add house - collision::Box house_box = { position, glm::vec3(0,0,0) }; - furniture.push_front(std::make_shared(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE, house_box)); + 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; - for(int i = 0; i(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box)); - - } + 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; - //furniture_collision.pop_front(); - - - // 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 * (HOUSE_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 * ((HOUSE_SIZE) * 1.3f) }; - 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 * (HOUSE_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 * (HOUSE_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 * (HOUSE_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 * (HOUSE_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 * (HOUSE_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 * (HOUSE_SIZE) }; - furniture.push_back(std::make_shared(ceiling_object, ceiling_object_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, ceiling_object_box)); + for (int z = 1; z < 4; z++) { + for (int x = 1; x < 4; x++) + { + //if (toolbox::Random(0, 100) < 90) { + 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 * 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)); + } + //} + //} + } + } + + 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_list->push_back(std::make_shared(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE, model_box)); - models::TexturedModel misc = GetFurnitureModel(FurnitureType::MISC); - glm::vec3 misc_pos = glm::vec3(position.x - 50, position.y - 10, position.z + 220); - collision::Box misc_box = { misc_pos, misc.raw_model.model_size * (HOUSE_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 singleton::FurniturePiece* furniture) { - const auto found = furniture_models.find(furniture); - if (found == furniture_models.end()) + std::deque furniture_list; + std::deque furniture_models = singleton::Model_Storage::get_instance()->get_all_furniture_models(); + + 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) + { + 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; + } + } + std::cout << "Size of furniture_list after for loop: " << furniture_list.size() << std::endl; + if (furniture_list.empty()) { std::cerr << "OH NEEEEEEEEEEEEEEE"; } - - auto models = found->second; - const int modelNumber = toolbox::Random(0, models.size() - 1); - - return models[modelNumber]; + const int modelNumber = toolbox::Random(0, furniture_list.size() - 1); + + return furniture_list.at(modelNumber); } - - 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); - - furniture_models.insert(std::pair>(FurnitureType::COUCH, couches)); - - // 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); - - furniture_models.insert(std::pair>(FurnitureType::TABLE, tables)); - - // 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); - - furniture_models.insert(std::pair>(FurnitureType::CHAIR, chairs)); - - - // 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); - - furniture_models.insert(std::pair>(FurnitureType::PLANT, plants)); - - // 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); - - furniture_models.insert(std::pair>(FurnitureType::GUITAR, guitars)); - - // 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); - - furniture_models.insert(std::pair>(FurnitureType::BOOKSHELF, bookshelves)); - - // 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); - - furniture_models.insert(std::pair>(FurnitureType::LAMP, lamps)); - - // 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); - - furniture_models.insert(std::pair>(FurnitureType::CEILING_OBJECTS, ceiling_Objects)); - - // 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); - - furniture_models.insert(std::pair>(FurnitureType::MISC, miscs)); - } - - /*std::deque> HouseGenerator::GetFurnitureCollisions() - { - return furniture_collision; - }*/ } diff --git a/src/entities/house_generator.h b/src/entities/house_generator.h index fcd734d..10e8149 100644 --- a/src/entities/house_generator.h +++ b/src/entities/house_generator.h @@ -3,40 +3,22 @@ #include #include #include + +#include "collision_entity.h" #include "../models/Model.h" #include "../collision/collision.h" +#include "../model_Storage.h" #include "collision_entity.h" namespace entities { - enum class FurnitureType - { - COUCH, - TABLE, - CHAIR, - PLANT, - GUITAR, - BOOKSHELF, - LAMP, - CEILING_OBJECTS, - MISC - }; - class HouseGenerator { private: const float HOUSE_SIZE = 30; - - models::TexturedModel house_model; - models::ModelTexture default_texture; - - std::map> furniture_models; - //std::deque> furniture_collision; - - public: HouseGenerator(); - + /* * @brief: This function generates a house with furniture at the given position and rotation * @@ -45,23 +27,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; - - } - - //std::deque> GetFurnitureCollisions(); - + float GetHouseDepth() const { return singleton::Model_Storage::get_instance()->get_house_model().raw_model.model_size.x * HOUSE_SIZE; } private: - /* - * @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 @@ -70,6 +45,6 @@ namespace entities * * @return: The model of the random furniture of the chosen furniture type */ - models::TexturedModel GetFurnitureModel(FurnitureType furniture); + models::TexturedModel GetFurnitureModel(const singleton::FurniturePiece* furniture); }; } diff --git a/src/gui/gui_element.h b/src/gui/gui_element.h index 9887c68..d02c57c 100644 --- a/src/gui/gui_element.h +++ b/src/gui/gui_element.h @@ -19,14 +19,14 @@ namespace gui */ struct GuiTexture { - int texture; + GLuint texture; glm::vec2 position; glm::vec2 scale; virtual GuiType GetType() { return GuiType::LABEL; } - GuiTexture(int texture, glm::vec2 position, glm::vec2 scale): texture(texture), position(position), scale(scale) + 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/main.cpp b/src/main.cpp index 118c873..40645f7 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -27,6 +27,10 @@ #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 "scenes/game_Over_Scene.h" #include "entities/collision_entity.h" #include "computervision/object_detection.h" @@ -60,10 +64,10 @@ int main(void) glewInit(); glGetError(); #pragma endregion - - //TODO change back to 0, only to show how score is visible on end screen + //current_scene = new scene::Startup_Scene(); + current_scene = new scene::Loading_Scene(); score = 0; - current_scene = new scene::Startup_Scene(); + glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods) { @@ -91,6 +95,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; @@ -118,6 +126,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 new file mode 100644 index 0000000..17a2f9e --- /dev/null +++ b/src/model_Storage.cpp @@ -0,0 +1,205 @@ +#include "model_Storage.h" + + +singleton::Model_Storage* singleton::Model_Storage::instance{nullptr}; +std::mutex singleton::Model_Storage::mutex; + +singleton::Model_Storage::~Model_Storage() +{ + std::cout << "DELETING...." << std::endl; + 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::add_ceiling_object(models::TexturedModel co) +{ + ceiling_objects.push_back(co); +} + +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 + */ + +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; +} + +std::deque singleton::Model_Storage::get_all_furniture_models() +{ + return furniture_models; +} + +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]; +} + +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() +{ + return house_model; +} + +models::ModelTexture singleton::Model_Storage::get_default_texture() +{ + return default_texture; +} + + //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..6e19bb7 --- /dev/null +++ b/src/model_Storage.h @@ -0,0 +1,137 @@ +#pragma once +#include +#include +#include +#include "models/Model.h" +#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: + static Model_Storage* instance; + static std::mutex mutex; + + //model of the house + models::TexturedModel house_model; + //default texture + models::ModelTexture default_texture; + + //list that sorts furniture_models on type + std::deque furniture_models; + + //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() { std::cout << "MAKING A NEW SINGLETON!!!" << std::endl; } + ~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 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(); + 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(); + std::deque get_all_furniture_models(); + + //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); + FurnitureModel get_furniture_model(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/in_Game_Scene.cpp b/src/scenes/in_Game_Scene.cpp index 3ece8dd..c28dde0 100644 --- a/src/scenes/in_Game_Scene.cpp +++ b/src/scenes/in_Game_Scene.cpp @@ -117,7 +117,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()); @@ -225,7 +226,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 new file mode 100644 index 0000000..bb7a78f --- /dev/null +++ b/src/scenes/loading_Scene.cpp @@ -0,0 +1,146 @@ +#include "loading_Scene.h" + +#include + +#include "../renderEngine/Renderer.h" +#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; + std::deque> test; + + Loading_Scene::Loading_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(); + + camera_test = std::make_unique(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0)); + + } + + Loading_Scene::~Loading_Scene() + { + delete gui_shader; + } + + Scenes Loading_Scene::start(GLFWwindow* window) + { + render(); + + glfwSwapBuffers(window); + glfwPollEvents(); + + load_default_variables(); + load_all_models(); + + return scene::Scenes::STARTUP; + } + + 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); + + 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(); + + gui_shader->CleanUp(); + } + + void Loading_Scene::update(GLFWwindow* window) + { + } + + + 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_house_model(house); + singleton::Model_Storage::get_instance()->set_default_texture(default_texture); + } + + 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() }); + 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_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_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_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_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_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_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_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_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/loading_Scene.h b/src/scenes/loading_Scene.h new file mode 100644 index 0000000..5aa8362 --- /dev/null +++ b/src/scenes/loading_Scene.h @@ -0,0 +1,67 @@ +#pragma once +#include "scene.h" +#include "../gui/gui_element.h" +#include "../shaders/gui_shader.h" +#include "../model_Storage.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; + + + private: + void load_default_variables(); + void load_all_models(); + + public: + /** + * @brief Constructor of the class Loading_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 e550a73..5d3be79 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 4d69e21..6e6c88f 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; } @@ -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 836b85d..8132452 100644 --- a/wk2_fps.vcxproj +++ b/wk2_fps.vcxproj @@ -19,6 +19,7 @@ + @@ -41,6 +42,7 @@ + @@ -49,6 +51,7 @@ + @@ -58,6 +61,7 @@ + diff --git a/wk2_fps.vcxproj.filters b/wk2_fps.vcxproj.filters index 957f4b7..79510d5 100644 --- a/wk2_fps.vcxproj.filters +++ b/wk2_fps.vcxproj.filters @@ -3,19 +3,12 @@ -<<<<<<< HEAD - - - - -======= ->>>>>>> develop @@ -30,15 +23,13 @@ -<<<<<<< HEAD - -======= ->>>>>>> develop + + @@ -158,6 +149,8 @@ + +