[TRY] trying to manage some data storage

src/gui/gui_element.h

@@ -19,7 +19,7 @@ namespace gui
 	 */
 	struct GuiTexture
 	{
-		int texture;
+		unsigned int texture;
 		glm::vec2 position;
 		glm::vec2 scale;
 

src/main.cpp

@@ -27,6 +27,8 @@
 #include "scenes/scene.h"
 #include "scenes/in_Game_Scene.h"
 #include "scenes/startup_Scene.h"
+#include "scenes/loading_Scene.h"
+#include "model_Storage.h"
 
 #include "computervision/ObjectDetection.h"
 //#include "computervision/OpenPoseImage.h"
@@ -72,8 +74,8 @@ int main(void)
 	glGetError();
 #pragma endregion
 
-    
-    current_scene = new scene::Startup_Scene();
+    //current_scene = new scene::Startup_Scene();
+    current_scene = new scene::Loading_Scene();
 
     glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods)
         {
@@ -103,6 +105,10 @@ int main(void)
                 window_open = false;
                 break;
 
+            case scene::Scenes::LOADING:
+                current_scene = new scene::Loading_Scene();
+                break;
+
             case scene::Scenes::STARTUP:
                 current_scene = new scene::Startup_Scene();
                 break;
@@ -126,6 +132,7 @@ int main(void)
 
 	// Clean up -> preventing memory leaks!!!
     std::cout << "ending..." << std::endl;
+    singleton::Model_Storage::
 	glfwTerminate();
 	return 0;
 }

src/model_Storage.cpp

@@ -0,0 +1,187 @@
+#include "model_Storage.h"
+
+
+singleton::Model_Storage* singleton::Model_Storage::instance{nullptr};
+std::mutex singleton::Model_Storage::mutex;
+
+singleton::Model_Storage::~Model_Storage()
+{
+	delete instance;
+}
+
+singleton::Model_Storage* singleton::Model_Storage::get_instance()
+{
+	std::lock_guard<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::addd_ceiling_object(models::TexturedModel co)
+{
+	ceiling_objects.push_back(co);
+}
+
+void singleton::Model_Storage::add_misc(models::TexturedModel misc)
+{
+	miscs.push_back(misc);
+}
+
+/**
+ * getters 
+ */
+
+std::deque<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;
+}
+
+models::TexturedModel singleton::Model_Storage::get_couch(int index)
+{
+	return couches[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_table(int index)
+{
+	return tables[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_chair(int index)
+{
+	return chairs[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_plant(int index)
+{
+	return plants[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_guitar(int index)
+{
+	return guitars[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_bookshelf(int index)
+{
+	return bookshelves[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_lamp(int index)
+{
+	return lamps[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_ceiling_object(int index)
+{
+	return ceiling_objects[index];
+}
+
+models::TexturedModel singleton::Model_Storage::get_misc(int index)
+{
+	return miscs[index];
+}
+
+
+//getters for default variables
+models::TexturedModel singleton::Model_Storage::get_house_model()
+{
+	return models::TexturedModel();
+}
+
+models::ModelTexture singleton::Model_Storage::get_default_texture()
+{
+	return models::ModelTexture();
+}
+
+ //setters for deafult variables
+void singleton::Model_Storage::set_house_model(models::TexturedModel house)
+{
+	house_model = house;
+}
+
+void singleton::Model_Storage::set_default_texture(models::ModelTexture texture)
+{
+	default_texture = texture;
+}
+
+

src/model_Storage.h

@@ -0,0 +1,99 @@
+#pragma once
+#include <deque>
+#include <mutex>
+#include "models/Model.h"
+
+namespace singleton {
+	class Model_Storage
+	{
+	private:
+		static Model_Storage* instance;
+		static std::mutex mutex;
+
+		//model of the house
+		models::TexturedModel house_model;
+		//default texture
+		models::ModelTexture default_texture;
+
+		//list of furniture:
+		//couches
+		std::deque<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() {}
+		~Model_Storage();
+
+	public:
+		Model_Storage(Model_Storage& other) = delete;
+		void operator=(const Model_Storage&) = delete;
+
+		static Model_Storage* get_instance();
+
+		//some methods to execute on its instance:
+		void add_couch(models::TexturedModel couch);
+		void add_table(models::TexturedModel table);
+		void add_chair(models::TexturedModel chair);
+		void add_plant(models::TexturedModel plant);
+		void add_guitar(models::TexturedModel guitar);
+		void add_bookshelf(models::TexturedModel bookshelf);
+		void add_lamp(models::TexturedModel lamp);
+		void addd_ceiling_object(models::TexturedModel co);
+		void add_misc(models::TexturedModel misc);
+
+		//getters for the whole list
+		std::deque<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();
+
+		//getters for one model
+		models::TexturedModel get_couch(int index);
+		models::TexturedModel get_table(int index);
+		models::TexturedModel get_chair(int index);
+		models::TexturedModel get_plant(int index);
+		models::TexturedModel get_guitar(int index);
+		models::TexturedModel get_bookshelf(int index);
+		models::TexturedModel get_lamp(int index);
+		models::TexturedModel get_ceiling_object(int index);
+		models::TexturedModel get_misc(int index);
+
+		//getters for the standard variables
+		models::TexturedModel get_house_model();
+		models::ModelTexture get_default_texture();
+
+		//setters for the standard variables
+		void set_house_model(models::TexturedModel house);
+		void set_default_texture(models::ModelTexture texture);
+	};
+}
+
+

src/scenes/loading_Scene.cpp

@@ -1,11 +1,11 @@
 #include "loading_Scene.h"
 #include "../renderEngine/Renderer.h"
 #include "../renderEngine/Loader.h"
+#include "../renderEngine/obj_loader.h"
 #include "../gui/gui_element.h"
 
 namespace scene
 {
-	
 	Loading_Scene::Loading_Scene()
 	{
 		gui_shader = new shaders::GuiShader();
@@ -20,6 +20,8 @@ namespace scene
 	Scenes Loading_Scene::start(GLFWwindow* window)
 	{
 		render();
+		load_default_variables();
+		load_all_models();
 		
 	}
 
@@ -27,7 +29,7 @@ namespace scene
 	{
 		render_engine::renderer::Prepare();
 		
-		gui::GuiTexture loading_image = { render_engine::loader::LoadTexture("res/menu_item_start1.png"),
+		gui::GuiTexture loading_image = { render_engine::loader::LoadTexture("res/loading_screen.png"),
 			glm::vec2(0,0),glm::vec2(1,1) };
 		
 		std::vector<gui::GuiTexture*> image_list;
@@ -44,4 +46,22 @@ namespace scene
 	void Loading_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
 	{
 	}
+
+
+	void Loading_Scene::load_default_variables()
+	{
+		models::RawModel raw_model = render_engine::LoadObjModel("res/HouseNew.obj");
+		models::ModelTexture default_texture = { render_engine::loader::LoadTexture("res/Texture.png") };
+		default_texture.shine_damper = 10;
+
+		models::TexturedModel house = { raw_model, default_texture };
+
+		singleton::Model_Storage::get_instance()->set_default_texture(default_texture);
+		singleton::Model_Storage::get_instance()->set_house_model(house);
+	}
+
+	void Loading_Scene::load_all_models() 
+	{
+
+	}
 }

src/scenes/loading_Scene.h

@@ -1,8 +1,8 @@
 #pragma once
-#pragma once
 #include "scene.h"
 #include "../gui/gui_element.h"
 #include "../shaders/gui_shader.h"
+#include "../model_Storage.h"
 
 namespace scene
 {
@@ -17,9 +17,13 @@ namespace scene
 		shaders::GuiShader* gui_shader;
 
 
+	private:
+		void load_default_variables();
+		void load_all_models();
+
 	public:
 		/**
-		 * @brief Constructor of the class Startup_Scene
+		 * @brief Constructor of the class Loading_Scene
 		 *
 		 */
 		Loading_Scene();

wk2_fps.vcxproj

@@ -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" />
@@ -49,6 +50,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" />

wk2_fps.vcxproj.filters

@@ -29,6 +29,7 @@
     <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" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\entities\Camera.cpp">
@@ -150,6 +151,7 @@
     <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" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />