Implemented Material caching.

Author: htmlboss

MP-APS/.vs/MP-APS/v15/.suo

@@ -221,13 +221,13 @@ void RenderSystem::renderModelsWithTextures(GLShaderProgram& shader, const std::
 const auto meshes = model->GetMeshes();
 for (const auto& mesh : meshes) {
 glActiveTexture(GL_TEXTURE3);
-glBindTexture(GL_TEXTURE_2D, mesh.Material.AlbedoMap);
+glBindTexture(GL_TEXTURE_2D, mesh.Material->AlbedoMap);
 glActiveTexture(GL_TEXTURE4);
-glBindTexture(GL_TEXTURE_2D, mesh.Material.NormalMap);
+glBindTexture(GL_TEXTURE_2D, mesh.Material->NormalMap);
 glActiveTexture(GL_TEXTURE5);
-glBindTexture(GL_TEXTURE_2D, mesh.Material.MetallicMap);
+glBindTexture(GL_TEXTURE_2D, mesh.Material->MetallicMap);
 glActiveTexture(GL_TEXTURE6);
-glBindTexture(GL_TEXTURE_2D, mesh.Material.RoughnessMap);
+glBindTexture(GL_TEXTURE_2D, mesh.Material->RoughnessMap);
 //glActiveTexture(GL_TEXTURE7);
 //glBindTexture(GL_TEXTURE_2D, mesh.Material.AOMap);
 

MP-APS/.vs/MP-APS/v15/Browse.VC.db

@@ -7,7 +7,7 @@ Mesh::Mesh(const std::vector<Vertex>& vertices, const std::vector<GLuint>& indic
 }
 
 /***********************************************************************************/
-Mesh::Mesh(const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices, const PBRMaterial& material) :
+Mesh::Mesh(const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices, const PBRMaterialPtr& material) :
 IndexCount(indices.size()),
 Material(material) {
 

MP-APS/Core/RenderSystem.cpp

@@ -10,15 +10,15 @@
 /***********************************************************************************/
 struct Mesh {
 Mesh(const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices);
-Mesh(const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices, const PBRMaterial& material);
+Mesh(const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices, const PBRMaterialPtr& material);
 
 void Clear();
 
 auto GetTriangleCount() const noexcept { return IndexCount / 3; }
 
 const std::size_t IndexCount;
 GLVertexArray VAO;
-PBRMaterial Material;
+PBRMaterialPtr Material;
 
 private:
 void setupMesh(const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices);

MP-APS/Mesh.cpp

@@ -8,6 +8,7 @@
 
 #include <iostream>
 #include <ppl.h>
+#include "ResourceManager.h"
 
 /***********************************************************************************/
 Model::Model(const std::string_view Path, const std::string_view Name, const bool flipWindingOrder, const bool loadMaterial) : m_name(Name), m_path(Path) {
@@ -18,13 +19,13 @@ Model::Model(const std::string_view Path, const std::string_view Name, const boo
 }
 
 /***********************************************************************************/
-Model::Model(const std::string_view Name, const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices, const PBRMaterial& material) noexcept : m_name(Name) { 
+Model::Model(const std::string_view Name, const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices, const PBRMaterialPtr& material) noexcept : m_name(Name) {
 m_meshes.emplace_back(vertices, indices, material); 
 }
 
 /***********************************************************************************/
 Model::Model(const std::string_view Name, const Mesh& mesh) noexcept : m_name(Name) {
-m_meshes.push_back(std::move(mesh));
+m_meshes.push_back(mesh);
 }
 
 /***********************************************************************************/
@@ -203,12 +204,17 @@ Mesh Model::processMesh(aiMesh* mesh, const aiScene* scene, const bool loadMater
 // http://assimp.sourceforge.net/lib_html/structai_material.html
 if (loadMaterial) {
 if (mesh->mMaterialIndex >= 0) {
-PBRMaterial material;
 const auto* mat = scene->mMaterials[mesh->mMaterialIndex];
 
 aiString name;
 mat->Get(AI_MATKEY_NAME, name);
 
+// Is the material cached?
+const auto cachedMaterial = ResourceManager::GetInstance().GetMaterial(name.C_Str());
+if (cachedMaterial.has_value()) {
+return Mesh(vertices, indices, cachedMaterial.value());
+}
+
 // Get the first texture for each texture type we need
 // since there could be multiple textures per type
 aiString albedoPath;
@@ -226,20 +232,16 @@ Mesh Model::processMesh(aiMesh* mesh, const aiScene* scene, const bool loadMater
 aiString alphaMaskPath;
 mat->GetTexture(aiTextureType_OPACITY, 0, &alphaMaskPath);
 
-std::cout << "MATERIAL NAME: " << name.C_Str() << std::endl;
-
-material.Init(name.C_Str(),
+const auto newMaterial = ResourceManager::GetInstance().CacheMaterial(name.C_Str(),
 m_path + albedoPath.C_Str(),
 "",
 m_path + metallicPath.C_Str(),
 m_path + normalPath.C_Str(),
 m_path + roughnessPath.C_Str(),
-m_path + alphaMaskPath.C_Str()
-);
+m_path + alphaMaskPath.C_Str());
 
 ++m_numMats;
-std::cout << "NUMBER OF MATERIALS: " << m_numMats << std::endl;
-return Mesh(vertices, indices, material);
+return Mesh(vertices, indices, newMaterial);
 }
 }
 

MP-APS/Mesh.h

@@ -15,7 +15,7 @@ class Model {
 public:
 Model() = default;
 Model(const std::string_view Path, const std::string_view Name, const bool flipWindingOrder = false, const bool loadMaterial = true);
-Model(const std::string_view Name, const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices, const PBRMaterial& material) noexcept;
+Model(const std::string_view Name, const std::vector<Vertex>& vertices, const std::vector<GLuint>& indices, const PBRMaterialPtr& material) noexcept;
 Model(const std::string_view Name, const Mesh& mesh) noexcept;
 virtual ~Model() = default;
 

MP-APS/Model.cpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string_view>
+#include <memory>
 
 // Material for a PBR pipeline
 struct PBRMaterial {
@@ -26,4 +27,6 @@ struct PBRMaterial {
 unsigned int RoughnessMap;
 unsigned int AlphaMask;
 // unsigned int HeightMap;
-};
+};
+
+using PBRMaterialPtr = std::shared_ptr<PBRMaterial>;

MP-APS/Model.h

@@ -165,6 +165,27 @@ ModelPtr ResourceManager::CacheModel(const std::string_view name, const Model mo
 return m_modelCache.try_emplace(name.data(), std::make_shared<Model>(model)).first->second;
 }
 
+/***********************************************************************************/
+std::optional<PBRMaterialPtr> ResourceManager::GetMaterial(const std::string_view name) const {
+
+// Check if material exists
+const auto val = m_materialCache.find(name.data());
+
+if (val == m_materialCache.end()) {
+return std::optional<PBRMaterialPtr>();
+}
+
+return std::make_optional<PBRMaterialPtr>(val->second);
+}
+
+/***********************************************************************************/
+PBRMaterialPtr ResourceManager::CacheMaterial(const std::string_view name, const std::string_view albedoPath, const std::string_view aoPath, const std::string_view metallicPath, const std::string_view normalPath, const std::string_view roughnessPath, const std::string_view alphaMaskPath) {
+auto mat = PBRMaterial();
+mat.Init(name, albedoPath, aoPath, metallicPath, normalPath, roughnessPath, alphaMaskPath);
+
+return m_materialCache.try_emplace(name.data(), std::make_shared<PBRMaterial>(mat)).first->second;
+}
+
 /***********************************************************************************/
 void ResourceManager::UnloadModel(const std::string_view modelName) {
 auto model = m_modelCache.find(modelName.data());

MP-APS/PBRMaterial.h

@@ -3,6 +3,7 @@
 #include "Model.h"
 
 #include <unordered_map>
+#include <optional>
 
 class ResourceManager {
 ResourceManager() = default;
@@ -32,13 +33,28 @@ class ResourceManager {
 // Add a loaded model the the model cache
 ModelPtr CacheModel(const std::string_view name, const Model model, const bool overwriteIfExists = false);
 
+// Checks if a named material is cached. If so, we get an initialized optional. Otherwise we get an empty one.
+// It's up to the caller to check the result.
+std::optional<PBRMaterialPtr> GetMaterial(const std::string_view name) const;
+// Cache a material and get a handle back. Usually called if GetMaterial returns empty.
+PBRMaterialPtr CacheMaterial(const std::string_view name,
+const std::string_view albedoPath,
+const std::string_view aoPath,
+const std::string_view metallicPath,
+const std::string_view normalPath,
+const std::string_view roughnessPath,
+const std::string_view alphaMaskPath);
+
+
 // Removes a named model from cache.
 void UnloadModel(const std::string_view modelName);
 
 auto GetNumLoadedTextures() const noexcept { return m_textureCache.size(); }
 auto GetNumLoadedModels() const noexcept { return m_modelCache.size(); }
+auto GetNumMaterials() const noexcept { return m_materialCache.size(); }
 
 private:
 std::unordered_map<std::string, ModelPtr> m_modelCache;
 std::unordered_map<std::string, unsigned int> m_textureCache;
+std::unordered_map<std::string, PBRMaterialPtr> m_materialCache;
 };