Fix LimonModel support

It was caused by changes to the model structure that were not
reflected. The changes are not backwards compatible.

Author: enginmanap

src/Assets/AssetManager.h

@@ -230,6 +230,7 @@ class AssetManager {
 
     explicit AssetManager(GraphicsInterface* graphicsWrapper, ALHelper *alHelper) : graphicsWrapper(graphicsWrapper), alHelper(alHelper) {
         nextMaterialIndex.store(1);
+        nextAssetIndex.store(0);
         loadAssetList();
         size_t num_threads = std::thread::hardware_concurrency();
         for (size_t i = 0; i < num_threads; ++i) {
@@ -245,7 +246,7 @@ class AssetManager {
     template<class T>
     std::vector<std::shared_ptr<T>>parallelLoadAssetList(const std::vector<std::vector<std::string>> filesList) {
         std::vector<std::shared_ptr<T>> loadedAssets;
-        std::unordered_set<int> startedAssetIds;
+        std::unordered_set<uint32_t> startedAssetIds;
         for(const auto &files : filesList) {
             if (assets.count(files) == 0) {
                 uint32_t nextAssetIndexLocal = getNextAssetIndex();
@@ -258,6 +259,10 @@ class AssetManager {
                         std::ifstream is(files[0], std::ios::binary);
                         cereal::BinaryInputArchive archive(is);
                         assets[files] = std::make_pair(std::make_shared<T>(this, nextAssetIndexLocal, files, archive), 0);
+                        assets[files].first->setLoadState(Asset::LoadState::CPU_LOAD_DONE);
+
+                        startedAssetIds.insert(nextAssetIndexLocal);
+                        assetLoadGPUQueue.pushBack(assets[files].first, true);
 #else
                         std::cerr << "Limon compiled without limonmodel support. Please acquire a release version. Exiting..." << std::endl;
                     std::cerr << "Compile should define \"CEREAL_SUPPORT\"." << std::endl;
@@ -315,6 +320,10 @@ class AssetManager {
                     std::ifstream is(files[0], std::ios::binary);
                     cereal::BinaryInputArchive archive(is);
                     assets[files] = std::make_pair(std::make_shared<T>(this, nextAssetIndexLocal, files, archive), 0);
+                    assets[files].first->setLoadState(Asset::LoadState::CPU_LOAD_DONE);
+
+                    assetLoadGPUQueue.pushBack(assets[files].first, true);
+
 #else
                     std::cerr << "Limon compiled without limonmodel support. Please acquire a release version. Exiting..." << std::endl;
                 std::cerr << "Compile should define \"CEREAL_SUPPORT\"." << std::endl;
@@ -360,6 +369,8 @@ class AssetManager {
                     std::ifstream is(files[0], std::ios::binary);
                     cereal::BinaryInputArchive archive(is);
                     assets[files] = std::make_pair(std::make_shared<T>(this, getNextAssetIndex(), files, archive), 0);
+                    assets[files].first->loadGPUPart();
+                    assets[files].first->setLoadState(Asset::LoadState::DONE);
 #else
                     std::cerr << "Limon compiled without limonmodel support. Please acquire a release version. Exiting..." << std::endl;
                     std::cerr << "Compile should define \"CEREAL_SUPPORT\"." << std::endl;

src/Assets/MeshAsset.h

@@ -32,7 +32,7 @@ class MeshAsset {
 
     std::vector<glm::vec3> vertices;
     std::vector<glm::vec3> normals;
-    std::vector<glm::mediump_uvec3> faces;
+    std::vector<glm::mediump_uvec3> faces; //Possible reason for non portable data
     std::vector<glm::vec2> textureCoordinates;
     std::string name;
 
@@ -60,15 +60,14 @@ class MeshAsset {
     bool setTriangles(const aiMesh *currentMesh);
 
     void normalizeTextureCoordinates(glm::vec2 &textureCoordinates) const;
-    void buildBulletMesh();
 #ifdef CEREAL_SUPPORT
     friend class cereal::access;
 #endif
     MeshAsset(){}
 public:
     MeshAsset(const aiMesh *currentMesh, std::string name, std::shared_ptr<const BoneNode> meshSkeleton,
               const glm::mat4 &parentTransform, const bool isPartOfAnimated);
-
+    void buildBulletMesh();
     /**
      * This method sets GPU side of the deserialization, and uses AssetManager to access GPU with getGraphicsWrapper
      *
@@ -123,7 +122,7 @@ class MeshAsset {
 #ifdef CEREAL_SUPPORT
     template<class Archive>
     void serialize(Archive & archive){
-        archive( vertices, normals, textureCoordinates, faces, vertexCount, triangleCount, skeleton, bones, boneIDs, boneWeights, boneAttachedMeshes, boneIdMap, name, isPartOfAnimated, parentTransform);
+        archive( vertices, normals, textureCoordinates, faces, vertexCount, triangleCount, offsets, skeleton, bones, boneIDs, boneWeights, boneAttachedMeshes, boneIdMap, name, isPartOfAnimated, parentTransform);
     }
 #endif
 };

src/Assets/ModelAsset.h

@@ -225,14 +225,36 @@ class ModelAsset : public Asset {
             index++;
             embeddedTexture = assetManager->getEmbeddedTextures(name, index);
         }
-        ar(assetID, boneIDCounter, boneIDCounterPerMesh, textures,                   hasAnimation, rootNode, boundingBoxMax, boundingBoxMin, centerOffset, boneInformationMap, simplifiedMeshes, meshes, animations, animationSections, customizationAfterSave, materialMap, transparentMaterialUsed);
+        ar(name, boneIDCounter, boneIDCounterPerMesh, textures,                   hasAnimation, rootNode, boundingBoxMax, boundingBoxMin, centerOffset, boneInformationMap, simplifiedMeshes, meshes, animations, animationSections, customizationAfterSave, materialMap, meshMaterialMap, transparentMaterialUsed);
     }
 
     template<class Archive>
     void load( Archive & ar ) {
+        std::map<std::shared_ptr<MeshAsset>,std::shared_ptr<Material>> tempMeshMaterialMap;
         temporaryEmbeddedTextures = std::make_unique<std::vector<std::shared_ptr<const AssetManager::EmbeddedTexture>>>();
-        ar(assetID, boneIDCounter, boneIDCounterPerMesh, *temporaryEmbeddedTextures, hasAnimation, rootNode, boundingBoxMax, boundingBoxMin, centerOffset, boneInformationMap, simplifiedMeshes, meshes, animations, animationSections, customizationAfterSave, materialMap, transparentMaterialUsed);
+        ar(name,boneIDCounter, boneIDCounterPerMesh, *temporaryEmbeddedTextures, hasAnimation, rootNode, boundingBoxMax, boundingBoxMin, centerOffset, boneInformationMap, simplifiedMeshes, meshes, animations, animationSections, customizationAfterSave, materialMap, tempMeshMaterialMap, transparentMaterialUsed);
         //now update embedded textures to assetManager
+        for (size_t i = 0; i < meshes.size(); ++i) {
+            meshes[i]->buildBulletMesh();
+        }
+
+        for (const auto& tempMeshMaterialPair:tempMeshMaterialMap) {
+            meshMaterialMap[tempMeshMaterialPair.first] = tempMeshMaterialPair.second;
+        }
+        for (auto& materialPair:materialMap) {
+            std::map<const std::shared_ptr<const MeshAsset>,std::shared_ptr<Material>>::iterator meshMaterialToUpdateIt;
+            for (std::map<const std::shared_ptr<const MeshAsset>,std::shared_ptr<Material>>::iterator it = meshMaterialMap.begin(); it != meshMaterialMap.end(); ++it) {
+                if(it->second == materialPair.second) {
+                    meshMaterialToUpdateIt = it;
+                    break;
+                }
+            }
+            materialPair.second = assetManager->registerMaterial(materialPair.second);
+            if (meshMaterialToUpdateIt != meshMaterialMap.end()) {
+                meshMaterialMap[meshMaterialToUpdateIt->first] = materialPair.second;
+            }
+            materialPair.second->afterLoad(assetManager);
+        }
         buildPhysicsMeshes();
     }
 #endif

src/Assets/TextureAsset.h

@@ -41,7 +41,7 @@ class TextureAsset : public Asset {
         assert(false && "TextureAsset doesn't support Cereal Loading");
     }
 #endif
-    ~TextureAsset();
+    ~TextureAsset() override;
 
     uint32_t getID() const {
         return texture->getTextureID();

src/Material.h

@@ -49,6 +49,11 @@ class Material {
      *
      * vector has vector<string>, because embedded textures are saved with pairs, first element is the index, second element is the model file itself.
      */
+
+//FIXME
+    //std::vector<std::vector<std::string>>* textureNames = nullptr;
+    std::vector<std::string> ambientTextureNames, diffuseTextureNames, specularTextureNames, normalTextureNames, opacityTextureNames;
+
     friend struct std::hash<Material>;
     std::shared_ptr<TextureAsset> ambientTexture = nullptr;
     std::shared_ptr<TextureAsset> diffuseTexture = nullptr;
@@ -334,25 +339,57 @@ class Material {
 
     template<class Archive>
     void load(Archive & archive)  {
-    std::cerr << "LimonModel Material load needs reimplementing" << std::endl;
-    getchar();
-    /*
-     * Old implementation below
-     *
-        textureNameListList = std::make_unique<std::vector<std::vector<std::string>>>();
-        for (int i = 0; i < 5; ++i) {
-            textureNameListList->push_back(std::vector<std::string>());
-        }
 
-        std::vector<std::string> &ambientTextureNames  = textureNameListList->at(0);
-        std::vector<std::string> &diffuseTextureNames  = textureNameListList->at(1);
-        std::vector<std::string> &specularTextureNames = textureNameListList->at(2);
-        std::vector<std::string> &normalTextureNames   = textureNameListList->at(3);
-        std::vector<std::string> &opacityTextureNames  = textureNameListList->at(4);
-    */
         archive(name, specularExponent, maps, ambientColor, diffuseColor, specularColor, isAmbientMap, isDiffuseMap, isSpecularMap, isNormalMap, isOpacityMap, refractionIndex
-                //,ambientTextureNames, diffuseTextureNames, specularTextureNames, normalTextureNames, opacityTextureNames);
-        );
+                ,ambientTextureNames, diffuseTextureNames, specularTextureNames, normalTextureNames, opacityTextureNames);
+    }
+
+    void afterLoad(AssetManager* assetManager) {
+        this->assetManager = assetManager;
+        if(!ambientTextureNames.empty()) {
+            if (ambientTextureNames.size() > 1) {
+                this->setAmbientTexture(ambientTextureNames[0], &ambientTextureNames[1]);
+            } else {
+                this->setAmbientTexture(ambientTextureNames[0]);
+            }
+            ambientTextureNames.clear();
+        }
+
+        if(!diffuseTextureNames.empty()) {
+            if (diffuseTextureNames.size() > 1) {
+                this->setDiffuseTexture(diffuseTextureNames[0], &diffuseTextureNames[1]);
+            } else {
+                this->setDiffuseTexture(diffuseTextureNames[0]);
+            }
+            diffuseTextureNames.clear();
+        }
+
+        if(!specularTextureNames.empty()) {
+            if (specularTextureNames.size() > 1) {
+                this->setSpecularTexture(specularTextureNames[0], &specularTextureNames[1]);
+            } else {
+                this->setSpecularTexture(specularTextureNames[0]);
+            }
+            specularTextureNames.clear();
+        }
+
+        if(!normalTextureNames.empty()) {
+            if (normalTextureNames.size() > 1) {
+                this->setNormalTexture(normalTextureNames[0], &normalTextureNames[1]);
+            } else {
+                this->setNormalTexture(normalTextureNames[0]);
+            }
+            normalTextureNames.clear();
+        }
+
+        if(!opacityTextureNames.empty()) {
+            if (opacityTextureNames.size() > 1) {
+                this->setOpacityTexture(opacityTextureNames[0], &opacityTextureNames[1]);
+            } else {
+                this->setOpacityTexture(opacityTextureNames[0]);
+            }
+            opacityTextureNames.clear();
+        }
     }
 #endif
 };