sem/SDBA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

merge Feature/loading all models into develop #8

Merged
SemvdH merged 13 commits from feature/loading_all_models into develop 2021-06-18 13:33:33 +00:00
Conversation 5 Commits 13 Files Changed 14 +1032 -289
14 changed files with 1032 additions and 289 deletions
Download Patch File Download Diff File Expand all files Collapse all files

340
enc_temp_folder/e14e1bac1d366a32333657ac3b22e523/house_generator.cpp Normal file
View File

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

336
src/entities/house_generator.cpp
View File

@@ -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<std::shared_ptr<CollisionEntity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
void HouseGenerator::GetRandomFurniturePiece(singleton::FurniturePiece* furniture_piece)
{
std::deque<std::shared_ptr<CollisionEntity>> furniture;
singleton::FurnitureType random_type = singleton::FurnitureType::CEILING_OBJECTS;
std::deque<singleton::FurnitureModel> 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<singleton::FurnitureModel> 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<std::shared_ptr<CollisionEntity>>* furniture_list , const glm::vec3& position, float y_rotation)
{
std::deque<std::shared_ptr<Entity>> furniture;
// Add house
collision::Box house_box = { position, glm::vec3(0,0,0) };
furniture.push_front(std::make_shared<CollisionEntity>(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<CollisionEntity>(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<toolbox::Random(1,4);i++)
{
FurnitureType type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
models::TexturedModel model = GetFurnitureModel(type);
glm::vec3 model_pos = glm::vec3(position.x, position.y, position.z);
collision::Box model_box = { model_pos, model.raw_model.model_size };
model_box.SetRotation(-90);
furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box));
}
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<CollisionEntity>(couch, couch_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, couch_box));
models::TexturedModel table = GetFurnitureModel(FurnitureType::TABLE);
glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
collision::Box table_box = { table_pos, table.raw_model.model_size * ((HOUSE_SIZE) * 1.3f) };
furniture.push_back(std::make_shared<CollisionEntity>(table, table_pos, glm::vec3(0, 0, 0), HOUSE_SIZE * 1.3, table_box));
models::TexturedModel chair = GetFurnitureModel(FurnitureType::CHAIR);
glm::vec3 chair_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box chair_box = { chair_pos, chair.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(chair, chair_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, chair_box));
models::TexturedModel plant = GetFurnitureModel(FurnitureType::PLANT);
glm::vec3 plant_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box plant_box = { plant_pos, plant.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(plant, plant_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, plant_box));
models::TexturedModel guitar = GetFurnitureModel(FurnitureType::GUITAR);
glm::vec3 guitar_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box guitar_box = { guitar_pos, guitar.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(guitar, guitar_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, guitar_box));
models::TexturedModel bookshelf = GetFurnitureModel(FurnitureType::BOOKSHELF);
glm::vec3 bookshelf_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box bookshelf_box = { bookshelf_pos, bookshelf.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(bookshelf, bookshelf_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, bookshelf_box));
models::TexturedModel lamp = GetFurnitureModel(FurnitureType::LAMP);
glm::vec3 lamp_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box lamp_box = { lamp_pos, lamp.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(lamp, lamp_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, lamp_box));
models::TexturedModel ceiling_object = GetFurnitureModel(FurnitureType::CEILING_OBJECTS);
glm::vec3 ceiling_object_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
collision::Box ceiling_object_box = { ceiling_object_pos, ceiling_object.raw_model.model_size * (HOUSE_SIZE) };
furniture.push_back(std::make_shared<CollisionEntity>(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<CollisionEntity>(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<CollisionEntity>(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<CollisionEntity>(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<models::TexturedModel> furniture_list;
std::deque<singleton::FurnitureModel> 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<models::TexturedModel> 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<models::TexturedModel> couches;
models::RawModel couch_inside_model = render_engine::LoadObjModel("res/couchThree.obj");
models::TexturedModel couch_inside = { couch_inside_model, default_texture };
couches.push_back(couch_inside);
models::RawModel couch_inside_model2 = render_engine::LoadObjModel("res/Coach.obj");
models::TexturedModel couch_inside2 = { couch_inside_model2, default_texture };
couches.push_back(couch_inside2);
models::RawModel couch_inside_model3 = render_engine::LoadObjModel("res/lawnBenchOne.obj");
models::TexturedModel couch_inside3 = { couch_inside_model3, default_texture };
couches.push_back(couch_inside3);
furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::COUCH, couches));
// Tables
std::deque<models::TexturedModel> tables;
models::RawModel table_model1 = render_engine::LoadObjModel("res/tableOne.obj");
models::TexturedModel table1 = { table_model1, default_texture };
tables.push_back(table1);
models::RawModel table_model2 = render_engine::LoadObjModel("res/tableTwo.obj");
models::TexturedModel table2 = { table_model2, default_texture };
tables.push_back(table2);
models::RawModel table_model3 = render_engine::LoadObjModel("res/bureauOne.obj");
models::TexturedModel table3 = { table_model3, default_texture };
tables.push_back(table3);
furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::TABLE, tables));
// Chairs
std::deque<models::TexturedModel> chairs;
models::RawModel chair_model1 = render_engine::LoadObjModel("res/launchchair.obj");
models::TexturedModel chair1 = { chair_model1, default_texture };
chairs.push_back(chair1);
models::RawModel chair_model2 = render_engine::LoadObjModel("res/lawnChairOne.obj");
models::TexturedModel chair2 = { chair_model2, default_texture };
chairs.push_back(chair2);
models::RawModel chair_model3 = render_engine::LoadObjModel("res/ugly_chair.obj");
models::TexturedModel chair3 = { chair_model3, default_texture };
chairs.push_back(chair3);
furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::CHAIR, chairs));
// Plants
std::deque<models::TexturedModel> plants;
models::RawModel plant_model1 = render_engine::LoadObjModel("res/plantOne.obj");
models::TexturedModel plant1 = { plant_model1, default_texture };
plants.push_back(plant1);
models::RawModel plant_model2 = render_engine::LoadObjModel("res/plantTwo.obj");
models::TexturedModel plant2 = { plant_model2, default_texture };
plants.push_back(plant2);
models::RawModel plant_model3 = render_engine::LoadObjModel("res/plantThree.obj");
models::TexturedModel plant3 = { plant_model3, default_texture };
plants.push_back(plant3);
furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::PLANT, plants));
// Guitars
std::deque<models::TexturedModel> guitars;
models::RawModel guitar_model1 = render_engine::LoadObjModel("res/guitarOne.obj");
models::TexturedModel guitar1 = { guitar_model1, default_texture };
guitars.push_back(guitar1);
models::RawModel guitar_model2 = render_engine::LoadObjModel("res/guitarTwo.obj");
models::TexturedModel guitar2 = { guitar_model2, default_texture };
guitars.push_back(guitar2);
furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::GUITAR, guitars));
// Bookshelves
std::deque<models::TexturedModel> bookshelves;
models::RawModel bookshelf_model1 = render_engine::LoadObjModel("res/bookShelfOne.obj");
models::TexturedModel bookshelf1 = { bookshelf_model1, default_texture };
bookshelves.push_back(bookshelf1);
models::RawModel bookshelf_model2 = render_engine::LoadObjModel("res/bookShelfTwo.obj");
models::TexturedModel bookshelf2 = { bookshelf_model2, default_texture };
bookshelves.push_back(bookshelf2);
models::RawModel bookshelf_model3 = render_engine::LoadObjModel("res/bookShelfThree.obj");
models::TexturedModel bookshelf3 = { bookshelf_model3, default_texture };
bookshelves.push_back(bookshelf3);
furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::BOOKSHELF, bookshelves));
// Lamps
std::deque<models::TexturedModel>lamps;
models::RawModel lamp_model1 = render_engine::LoadObjModel("res/lampOne.obj");
models::TexturedModel lamp1 = { lamp_model1, default_texture };
lamps.push_back(lamp1);
models::RawModel lamp_model2 = render_engine::LoadObjModel("res/lampTwo.obj");
models::TexturedModel lamp2 = { lamp_model2, default_texture };
lamps.push_back(lamp2);
furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::LAMP, lamps));
// Ceiling objects
std::deque<models::TexturedModel>ceiling_Objects;
models::RawModel ceiling_Obj_model1 = render_engine::LoadObjModel("res/ceilingFan.obj");
models::TexturedModel ceiling_Obj1 = { ceiling_Obj_model1, default_texture };
ceiling_Objects.push_back(ceiling_Obj1);
models::RawModel ceiling_Obj_model2 = render_engine::LoadObjModel("res/ceilingFanTwo.obj");
models::TexturedModel ceiling_Obj2 = { ceiling_Obj_model2, default_texture };
ceiling_Objects.push_back(ceiling_Obj2);
models::RawModel ceiling_Obj_model3 = render_engine::LoadObjModel("res/ceilingLampOne.obj");
models::TexturedModel ceiling_Obj3 = { ceiling_Obj_model3, default_texture };
ceiling_Objects.push_back(ceiling_Obj3);
models::RawModel ceiling_Obj_model4 = render_engine::LoadObjModel("res/ceilingLampTwo.obj");
models::TexturedModel ceiling_Obj4 = { ceiling_Obj_model4, default_texture };
ceiling_Objects.push_back(ceiling_Obj4);
furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::CEILING_OBJECTS, ceiling_Objects));
// Miscs
std::deque<models::TexturedModel> miscs;
models::RawModel misc_model1 = render_engine::LoadObjModel("res/tv.obj");
models::TexturedModel misc1 = { misc_model1, default_texture };
miscs.push_back(misc1);
models::RawModel misc_model2 = render_engine::LoadObjModel("res/radio.obj");
models::TexturedModel misc2 = { misc_model2, default_texture };
miscs.push_back(misc2);
models::RawModel misc_model3 = render_engine::LoadObjModel("res/Flowerpot.obj");
models::TexturedModel misc3 = { misc_model3, default_texture };
miscs.push_back(misc3);
furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::MISC, miscs));
}
/*std::deque<std::shared_ptr<CollisionEntity>> HouseGenerator::GetFurnitureCollisions()
{
return furniture_collision;
}*/
}

43
src/entities/house_generator.h
View File

@@ -3,40 +3,22 @@
#include <deque>
#include <memory>
#include <map>
#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<FurnitureType, std::deque<models::TexturedModel>> furniture_models;
//std::deque<std::shared_ptr<CollisionEntity>> 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<std::shared_ptr<CollisionEntity>> GenerateHouse(const glm::vec3& position, float y_rotation);
void GenerateHouse(std::deque<std::shared_ptr<CollisionEntity>>* 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<std::shared_ptr<CollisionEntity>> 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);
};
}

4
src/gui/gui_element.h
View File

@@ -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);
}

15
src/main.cpp
View File

@@ -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;
}

205
src/model_Storage.cpp Normal file
View File

@@ -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<std::mutex> 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<models::TexturedModel> singleton::Model_Storage::get_all_couches()
{
return couches;
}
std::deque<models::TexturedModel> singleton::Model_Storage::get_all_tables()
{
return tables;
}
std::deque<models::TexturedModel> singleton::Model_Storage::get_all_chairs()
{
return chairs;
}
std::deque<models::TexturedModel> singleton::Model_Storage::get_all_plants()
{
return plants;
}
std::deque<models::TexturedModel> singleton::Model_Storage::get_all_guitars()
{
return guitars;
}
std::deque<models::TexturedModel> singleton::Model_Storage::get_all_bookshelves()
{
return bookshelves;
}
std::deque<models::TexturedModel> singleton::Model_Storage::get_all_lamps()
{
return lamps;
}
std::deque<models::TexturedModel> singleton::Model_Storage::get_all_ceiling_objects()
{
return ceiling_objects;
}
std::deque<models::TexturedModel> singleton::Model_Storage::get_all_miscs()
{
return miscs;
}
std::deque<singleton::FurnitureModel> 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;
}

137
src/model_Storage.h Normal file
View File

@@ -0,0 +1,137 @@
#pragma once
#include <iostream>
#include <deque>
#include <mutex>
#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<models::TexturedModel> 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<FurnitureModel> furniture_models;
//list of furniture:
//couches
std::deque<models::TexturedModel> couches;
//tables
std::deque<models::TexturedModel> tables;
//chairs
std::deque<models::TexturedModel> chairs;
//plants
std::deque<models::TexturedModel> plants;
//guitars
std::deque<models::TexturedModel> guitars;
//bookshelves
std::deque<models::TexturedModel> bookshelves;
//lamps
std::deque<models::TexturedModel>lamps;
//ceiling objects
std::deque<models::TexturedModel>ceiling_objects;
//misc
std::deque<models::TexturedModel> 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<models::TexturedModel> get_all_couches();
std::deque<models::TexturedModel> get_all_tables();
std::deque<models::TexturedModel> get_all_chairs();
std::deque<models::TexturedModel> get_all_plants();
std::deque<models::TexturedModel> get_all_guitars();
std::deque<models::TexturedModel> get_all_bookshelves();
std::deque<models::TexturedModel> get_all_lamps();
std::deque<models::TexturedModel> get_all_ceiling_objects();
std::deque<models::TexturedModel> get_all_miscs();
std::deque<FurnitureModel> 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);
};
}

5
src/scenes/in_Game_Scene.cpp
View File

@@ -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<std::shared_ptr<entities::CollisionEntity>> furniture = house_generator->GenerateHouse(glm::vec3(0, -75, -50 - z_offset), 90);
std::deque<std::shared_ptr<entities::CollisionEntity>> 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;
}

146
src/scenes/loading_Scene.cpp Normal file
View File

@@ -0,0 +1,146 @@
#include "loading_Scene.h"
#include <iostream>
#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<entities::Camera> camera_test;
shaders::EntityShader* shader_test;
std::deque<std::shared_ptr<entities::Entity>> 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<entities::Camera>(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<gui::GuiTexture*> 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() });
}
}

67
src/scenes/loading_Scene.h Normal file
View File

@@ -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;
};
}

1
src/scenes/scene.h
View File

@@ -11,6 +11,7 @@ namespace scene {
*/
enum class Scenes
{
LOADING,
STARTUP,
INGAME,
GAMEOVER,

3
src/scenes/startup_Scene.cpp
View File

@@ -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");
}

4
wk2_fps.vcxproj
View File

@@ -19,6 +19,7 @@
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\model_Storage.cpp" />
<ClCompile Include="src\collision\collision_handler.cpp" />
<ClCompile Include="src\entities\main_character.cpp" />
<ClCompile Include="src\entities\house_generator.cpp" />
@@ -41,6 +42,7 @@
<ClCompile Include="src\renderEngine\loader.cpp" />
<ClCompile Include="src\renderEngine\obj_loader.cpp" />
<ClCompile Include="src\renderEngine\renderer.cpp" />
<ClCompile Include="src\scenes\loading_Scene.cpp" />
<ClCompile Include="src\scenes\scene.cpp" />
<ClCompile Include="src\shaders\gui_shader.cpp" />
<ClCompile Include="src\shaders\shader_program.cpp" />
@@ -49,6 +51,7 @@
<ClCompile Include="src\scenes\startup_Scene.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="src\model_Storage.h" />
<ClInclude Include="src\collision\collision.h" />
<ClInclude Include="src\collision\collision_handler.h" />
<ClInclude Include="src\entities\main_character.h" />
@@ -58,6 +61,7 @@
<ClInclude Include="src\scenes\game_Over_Scene.h" />
<ClInclude Include="src\computervision\hand_detect_region.h" />
<ClInclude Include="src\scenes\in_Game_Scene.h" />
<ClInclude Include="src\scenes\loading_Scene.h" />
<ClInclude Include="src\scenes\scene.h" />
<ClInclude Include="src\computervision\async\StaticCameraInstance.h" />
<ClInclude Include="src\computervision\finger_count.h" />

15
wk2_fps.vcxproj.filters
View File

@@ -3,19 +3,12 @@
<ItemGroup>
<ClCompile Include="src\collision\collision_handler.cpp" />
<ClCompile Include="src\scenes\in_Game_Scene.cpp" />
<<<<<<< HEAD
<ClCompile Include="src\computervision\ObjectDetection.cpp" />
<ClCompile Include="src\computervision\SkinDetector.cpp" />
<ClCompile Include="src\computervision\FingerCount.cpp" />
<ClCompile Include="src\computervision\BackgroundRemover.cpp" />
=======
<ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
<ClCompile Include="src\computervision\object_detection.cpp" />
<ClCompile Include="src\computervision\OpenPoseVideo.cpp" />
<ClCompile Include="src\computervision\skin_detector.cpp" />
<ClCompile Include="src\computervision\finger_count.cpp" />
<ClCompile Include="src\computervision\background_remover.cpp" />
>>>>>>> develop
<ClCompile Include="src\entities\camera.cpp" />
<ClCompile Include="src\entities\collision_entity.cpp" />
<ClCompile Include="src\entities\entity.cpp" />
@@ -30,15 +23,13 @@
<ClCompile Include="src\toolbox\toolbox.cpp" />
<ClCompile Include="src\scenes\startup_Scene.cpp" />
<ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
<<<<<<< HEAD
<ClCompile Include="src\computervision\HandDetectRegion.cpp" />
=======
<ClCompile Include="src\computervision\hand_detect_region.cpp" />
>>>>>>> develop
<ClCompile Include="src\entities\main_character.cpp" />
<ClCompile Include="src\entities\house_generator.cpp" />
<ClCompile Include="src\computervision\MenuTest.cpp" />
<ClCompile Include="src\scenes\scene.cpp" />
<ClCompile Include="src\scenes\loading_Scene.cpp" />
<ClCompile Include="src\model_Storage.cpp" />
<ClCompile Include="src\scenes\game_Over_Scene.cpp" />
</ItemGroup>
<ItemGroup>
@@ -158,6 +149,8 @@
<ClInclude Include="src\toolbox\Timer.h" />
<ClInclude Include="src\toolbox\toolbox.h" />
<ClInclude Include="src\scenes\startup_Scene.h" />
<ClInclude Include="src\scenes\loading_Scene.h" />
<ClInclude Include="src\model_Storage.h" />
<ClInclude Include="src\scenes\game_Over_Scene.h" />
</ItemGroup>
<ItemGroup>