Allow to load and reload models and textures in App flow

Author: kmarkindev

src/Application.cpp

@@ -59,10 +59,14 @@ void Application::Start()
 {
     CheckInitialization();
 
-    SetupModel();
+    SetupShader();
     SetupCamera();
     SetupLight();
 
+    SetupModel(m_assetsManager->GetAssetPath({"models", "backpack", "Survival_BackPack_2.fbx"}));
+    LoadTexture(m_assetsManager->GetAssetPath({"models", "backpack", "1001_albedo.jpg"}), TextureType::Diffuse);
+    LoadTexture(m_assetsManager->GetAssetPath({"models", "backpack", "1001_metallic.jpg"}), TextureType::Specular);
+
     while (!glfwWindowShouldClose(m_window))
     {
         glfwPollEvents();
@@ -102,24 +106,34 @@ void Application::CheckInitialization()
     }
 }
 
-void Application::SetupModel()
+void Application::SetupShader() 
 {
-    Shader* shader = new Shader(m_assetsManager->GetAssetPath({"shaders", "basic_vertex.vert"}),
+    m_shader = new Shader(m_assetsManager->GetAssetPath({"shaders", "basic_vertex.vert"}),
         m_assetsManager->GetAssetPath({"shaders", "basic_fragment.frag"}));
-    shader->LoadAndCompile();
+    m_shader->LoadAndCompile();
+}
 
-    // Material* material = new Material();
-    // material->diffuse = m_textureLoader
-    //     ->LoadTexture(g_config.modelFolder + g_config.textures.diffuseName, TextureType::Diffuse);
-    // material->specular = m_textureLoader
-    //     ->LoadTexture(g_config.modelFolder + g_config.textures.specularName, TextureType::Specular);
+void Application::SetupModel(std::string path)
+{
+    if(m_model)
+        m_model->Unload();
 
-    // Model* model = m_loader->LoadModel(g_config.GetModelPath());
-    // model->SetShader(shader);
-    // model->SetScale(m_startModelScale);
-    // model->SetMaterial(material);
+    m_model = m_loader->LoadModel(path);
+    m_model->SetShader(m_shader);
+    m_model->SetScale(m_startModelScale);
+    m_model->SetMaterial(new Material());
+}
 
-    // m_model = model;
+void Application::LoadTexture(std::string path, TextureType type) 
+{
+    if(!m_model)
+        throw CannotSetTexture();
+    
+    Texture texture = m_textureLoader
+        ->LoadTexture(path, type);
+
+    Material* material =  m_model->GetMaterial();
+    material->ReplaceTexture(texture, type);
 }
 
 void Application::SetupCamera()

src/Application.h

@@ -37,11 +37,12 @@ class Application
 	TextureLoader* m_textureLoader = nullptr;
 	Renderer* m_renderer = nullptr;
 	AssetsManager* m_assetsManager = nullptr;
+	ImGuiIO* m_imguiIo;
 
 	Camera* m_camera = nullptr;
 	Model* m_model = nullptr;
 	DirLight* m_light = nullptr;
-	ImGuiIO* m_imguiIo;
+	Shader* m_shader = nullptr;
 
 	glm::vec3 m_startCameraPosition = glm::vec3(30.f, 0.f, 0.f);
 	glm::vec4 m_startLightColor = glm::vec4(1.f, 1.f, 1.f, 1.f);
@@ -64,10 +65,14 @@ class Application
 
 	void CheckInitialization();
 
-	void SetupModel();
+	void SetupShader();
+	void SetupModel(std::string path);
+	void LoadTexture(std::string path, TextureType type);
 	void SetupCamera();
 	void SetupLight();
 
+	void UnloadCurrentModel();
+
 	void InitImgui();
 	void ShutdownImgui();
 	void StartImguiFrame();

src/CMakeLists.txt

@@ -12,6 +12,10 @@ target_sources(ModelViewer PRIVATE
 	Mesh.cpp
 	Model.h
 	Model.cpp
+	Material.h
+	Material.cpp
+	Texture.h
+	Texture.cpp
 	Camera.h
 	Camera.cpp
 	Object.h

src/Exceptions.h

@@ -137,4 +137,12 @@ struct CannotConvertException : public CustomException
 	{
 		return "Cannot convert exception";
 	}
+};
+
+struct CannotSetTexture : public CustomException
+{
+	const std::string GetMessage() const noexcept override
+	{
+		return "Cannot set texture exception";
+	}
 };

src/Material.cpp

@@ -0,0 +1,26 @@
+#include "Material.h"
+
+void Material::UnloadMaterial() 
+{
+    specular.Unload();
+    diffuse.Unload();
+}
+
+void Material::ReplaceTexture(Texture newTexture, TextureType type) 
+{
+    Texture* texture = nullptr;
+    switch (type)
+    {
+    case TextureType::Diffuse:
+        texture = &diffuse;
+        break;
+    case TextureType::Specular:
+        texture = &specular;
+        break;
+    default:
+        throw NotImplementedException();
+    }
+
+    texture->Unload();
+    *texture = newTexture;
+}

src/Material.h

@@ -1,9 +1,14 @@
 #pragma once
 
 #include "Texture.h"
+#include "glad/glad.h"
+#include "Exceptions.h"
 
 struct Material
 {
 	Texture diffuse;
 	Texture specular;
+
+	void UnloadMaterial();
+	void ReplaceTexture(Texture newTexture, TextureType type);
 };

src/Mesh.cpp

@@ -8,4 +8,16 @@ MeshData::MeshData(GLuint vao, GLuint vbo, GLuint ebo, unsigned int dataLength)
 Mesh::Mesh(MeshData meshData)
 	: m_meshData(meshData)
 {
+}
+
+void Mesh::Unload() 
+{
+	if(m_meshData.ebo != 0)
+		glDeleteBuffers(1, &m_meshData.ebo);
+
+	if(m_meshData.vao != 0)
+		glDeleteBuffers(1, &m_meshData.vao);
+	
+	if(m_meshData.vbo != 0)
+		glDeleteBuffers(1, &m_meshData.vbo);
 }

src/Mesh.h

@@ -33,5 +33,6 @@ class Mesh
 public:
 
 	Mesh(MeshData meshData);
+	void Unload();
 
 };

src/Model.cpp

@@ -10,6 +10,11 @@ Model::~Model()
 	delete m_meshes;
 }
 
+Material* Model::GetMaterial() 
+{
+	return m_material;
+}
+
 void Model::SetMaterial(Material* material)
 {
 	m_material = material;
@@ -19,3 +24,13 @@ void Model::SetShader(Shader* shader)
 {
 	m_shader = shader;
 }
+
+void Model::Unload() 
+{
+	m_material->UnloadMaterial();
+
+	for(auto mesh : m_meshes[0])
+	{
+		mesh.Unload();
+	}
+}

src/Model.h

@@ -23,7 +23,10 @@ class Model : public Object
 	Model(std::vector<Mesh>* meshesm);
 	~Model();
 
+	Material* GetMaterial();
 	void SetMaterial(Material* material);
 	void SetShader(Shader* shader);
 
+	void Unload();
+
 };

src/Texture.cpp

@@ -0,0 +1,7 @@
+#include "Texture.h"
+
+void Texture::Unload() 
+{
+    if(id != 0)
+        glDeleteTextures(1, &id);
+}

src/Texture.h

@@ -12,4 +12,6 @@ struct Texture
 {
 	TextureType type;
 	GLuint id;
+
+	void Unload();
 };