362 fix texture loader missing some assets

Source/Core/Loader/ERS_ModelLoader/ERS_CLASS_AssetStreamingManager.cpp

@@ -52,20 +52,14 @@ void ERS_CLASS_AssetStreamingManager::UpdateSceneStreamingQueue(ERS_STRUCT_Scene
     }
 
     // Sort All Models Based On Distance From Each Camera
-    std::vector<std::map<float, unsigned int>> DistancesFromCamera = SortModelsByDistanceFromCameras(Scene, Cameras);
+    std::vector<std::vector<std::pair<float, unsigned int>>> DistancesFromCamera = SortModelsByDistanceFromCameras(Scene, Cameras);
 
-    std::map<unsigned int, int> CameraUpdateQuota = CalculateCameraMaxUpdates(100, Cameras);
+    std::map<unsigned int, int> CameraUpdateQuota = CalculateCameraMaxUpdates(10, Cameras);
     SortSceneModels(CameraUpdateQuota, DistancesFromCamera, Scene);
 
 }
 
-void ERS_CLASS_AssetStreamingManager::SortSceneModels(std::map<unsigned int, int> CameraUpdatesQuota, std::vector<std::map<float, unsigned int>> DistancesFromCamera, ERS_STRUCT_Scene* Scene) {
-
-    // Reset All Target Distances
-    // for (unsigned int i = 0; i < Scene->Models.size(); i++) {
-    //     Scene->Models[i]->TargetTextureLevelVRAM = 0;
-    //     Scene->Models[i]->TargetTextureLevelRAM = 0;
-    // }
+void ERS_CLASS_AssetStreamingManager::SortSceneModels(std::map<unsigned int, int> CameraUpdatesQuota, std::vector<std::vector<std::pair<float, unsigned int>>> DistancesFromCamera, ERS_STRUCT_Scene* Scene) {
 
     // Iterate Over All Cameras, Make Recomendations From There
     for (unsigned int CameraIndex = 0; CameraIndex < CameraUpdatesQuota.size(); CameraIndex++) {
@@ -107,16 +101,9 @@ void ERS_CLASS_AssetStreamingManager::SortSceneModels(std::map<unsigned int, int
                 TargetTextureLevelRAM = std::min(MaxLOD_, TargetTextureLevelRAM);
                 TargetTextureLevelVRAM = std::min(MaxLOD_, TargetTextureLevelVRAM);
             }
-            if (TargetTextureLevelVRAM > NumberTextureLevels - 1) {
-                TargetTextureLevelVRAM = NumberTextureLevels - 1;
-            } else if (TargetTextureLevelVRAM < 0) {
-                TargetTextureLevelVRAM = 0;
-            }
-            if (TargetTextureLevelRAM > NumberTextureLevels - 1) {
-                TargetTextureLevelRAM = NumberTextureLevels - 1;
-            } else if (TargetTextureLevelRAM < 0) {
-                TargetTextureLevelRAM = 0;
-            }
+            TargetTextureLevelVRAM = std::min(TargetTextureLevelVRAM, Model->TargetTextureLevelRAM);
+
+
             if (MaxTextureResolution_ > 0 && Model->Textures_.size() > 0) {
                 while (Model->Textures_[0].TextureLevels[TargetTextureLevelRAM].LevelResolution.first > MaxTextureResolution_) {
                     TargetTextureLevelRAM -=1;
@@ -128,10 +115,12 @@ void ERS_CLASS_AssetStreamingManager::SortSceneModels(std::map<unsigned int, int
             } else if (MaxTextureResolution_ < 0) {
                 MaxTextureResolution_ = 0;
             }
-            TargetTextureLevelVRAM = std::min(TargetTextureLevelVRAM, Model->TargetTextureLevelRAM);
-
-
 
+            TargetTextureLevelRAM  = std::min(NumberTextureLevels - 1, TargetTextureLevelRAM);
+            TargetTextureLevelVRAM = std::min(NumberTextureLevels - 1, TargetTextureLevelVRAM);
+            TargetTextureLevelRAM  = std::max(0, TargetTextureLevelRAM);
+            TargetTextureLevelVRAM = std::max(0, TargetTextureLevelVRAM);
+
             // Calculate Texture Size
             int TextureSizeVRAM = 0;
             int TextureSizeRAM = 0;
@@ -149,7 +138,9 @@ void ERS_CLASS_AssetStreamingManager::SortSceneModels(std::map<unsigned int, int
             if (!AlreadyHasVRAMLevel && !VRAMUpdateQuotaExceeded && TextureFitsInVRAM) {
                 if (Model->TargetTextureLevelVRAM < TargetTextureLevelVRAM) {
                     Model->TargetTextureLevelVRAM = TargetTextureLevelVRAM;
-                    CameraVRAMUpdates++;
+                    if (Model->TargetTextureLevelVRAM > 0) {
+                        CameraVRAMUpdates++;
+                    }
                 }
             } else if (Model->TextureLevelInVRAM_ > TargetTextureLevelVRAM) {
                 Model->TargetTextureLevelVRAM = TargetTextureLevelVRAM;
@@ -164,7 +155,9 @@ void ERS_CLASS_AssetStreamingManager::SortSceneModels(std::map<unsigned int, int
             if (!AlreadyHasRAMLevel && !RAMUpdateQuotaExceeded && TextureFitsInRAM) {
                 if (Model->TargetTextureLevelRAM < TargetTextureLevelRAM) {
                     Model->TargetTextureLevelRAM = TargetTextureLevelRAM;
-                    CameraRAMUpdates++;
+                    if (Model->TargetTextureLevelRAM > 0) {
+                        CameraRAMUpdates++;
+                    }
                 }
             } else if (Model->TextureLevelInRAM_ > TargetTextureLevelRAM) {
                 Model->TargetTextureLevelRAM = TargetTextureLevelRAM;
@@ -303,25 +296,29 @@ std::map<unsigned int, int> ERS_CLASS_AssetStreamingManager::CalculateCameraMaxU
 
 }
 
-std::vector<std::map<float, unsigned int>> ERS_CLASS_AssetStreamingManager::SortModelsByDistanceFromCameras(ERS_STRUCT_Scene* Scene, std::vector<ERS_STRUCT_Camera*> Cameras) {
+std::vector<std::vector<std::pair<float, unsigned int>>> ERS_CLASS_AssetStreamingManager::SortModelsByDistanceFromCameras(ERS_STRUCT_Scene* Scene, std::vector<ERS_STRUCT_Camera*> Cameras) {
 
-    std::vector<std::map<float, unsigned int>> DistancesFromCamera;
+    std::vector<std::vector<std::pair<float, unsigned int>>> DistancesFromCamera;
     for (unsigned int i = 0; i < Cameras.size(); i++) {
         DistancesFromCamera.push_back(SortModelsByDistanceFromCamera(Scene, Cameras[i]));
     }
     return DistancesFromCamera;
 
 }
 
-std::map<float, unsigned int> ERS_CLASS_AssetStreamingManager::SortModelsByDistanceFromCamera(ERS_STRUCT_Scene* Scene, ERS_STRUCT_Camera* Camera) {
+std::vector<std::pair<float, unsigned int>> ERS_CLASS_AssetStreamingManager::SortModelsByDistanceFromCamera(ERS_STRUCT_Scene* Scene, ERS_STRUCT_Camera* Camera) {
 
     // Create Sorted List Of Distances Based On Position
-    std::map<float, unsigned int> Distances;        
+    std::vector<std::pair<float, unsigned int>> Distances;        
     for (unsigned int i = 0; i < Scene->Models.size(); i++) {
 
 
         float TotalDistance = glm::distance(Camera->GetPosition(), Scene->Models[i]->ModelPosition);
 
+        // if (Scene->Models[i]->Name == "ApartmentCeiling") {
+        //         std::cout<<"DistSort: "<<TotalDistance<<" Index: "<<i<<std::endl;
+        // }
+
         // glm::vec3 UnscaledAngle = Camera->GetPosition() - Scene->Models[i]->ModelPosition;
         // float MaxSide = UnscaledAngle.x;
         // if (UnscaledAngle.y > MaxSide) {
@@ -344,16 +341,17 @@ std::map<float, unsigned int> ERS_CLASS_AssetStreamingManager::SortModelsByDista
         } else if (ApproxCubeBoundryDistance < CubeBoundryBox.z) {
             ApproxCubeBoundryDistance = CubeBoundryBox.z;
         }
-
-
         float Distance = TotalDistance - ApproxCubeBoundryDistance;
+
+        // Cap Distance At 0 - We don't want negative distance, (thats happens if the camera is inside the bounding box of the model)
         Distance = std::max(0.0f, Distance);
-
-        Distances.insert(std::make_pair(Distance, i));
+        Distances.push_back(std::make_pair(Distance, i));
     }
-    std::map<float, unsigned int> SortedDistances; 
-    for (auto const& Entry : Distances) {
-        SortedDistances.insert(std::make_pair(Entry.first, Entry.second));
+
+
+    std::vector<std::pair<float, unsigned int>> SortedDistances; 
+    for (std::pair<float, unsigned int> Entry : Distances) {
+        SortedDistances.push_back(std::make_pair(Entry.first, Entry.second));
     }
 
     return SortedDistances;

Source/Core/Loader/ERS_ModelLoader/ERS_CLASS_AssetStreamingManager.h

@@ -90,7 +90,7 @@ class ERS_CLASS_AssetStreamingManager {
      * @param Camera 
      * @return std::map<float, unsigned int> 
      */
-    std::map<float, unsigned int> SortModelsByDistanceFromCamera(ERS_STRUCT_Scene* Scene, ERS_STRUCT_Camera* Camera);
+    std::vector<std::pair<float, unsigned int>> SortModelsByDistanceFromCamera(ERS_STRUCT_Scene* Scene, ERS_STRUCT_Camera* Camera);
 
     /**
      * @brief Sorts all models in the scene for every camera.
@@ -100,7 +100,7 @@ class ERS_CLASS_AssetStreamingManager {
      * @param Cameras 
      * @return std::vector<std::map<float, unsigned int>> 
      */
-    std::vector<std::map<float, unsigned int>> SortModelsByDistanceFromCameras(ERS_STRUCT_Scene* Scene, std::vector<ERS_STRUCT_Camera*> Cameras);
+    std::vector<std::vector<std::pair<float, unsigned int>>> SortModelsByDistanceFromCameras(ERS_STRUCT_Scene* Scene, std::vector<ERS_STRUCT_Camera*> Cameras);
 
     /**
      * @brief Generates a dictionary based on the camera's pointer indicating how many loads/unloads should be allowed for every camera
@@ -143,7 +143,7 @@ class ERS_CLASS_AssetStreamingManager {
      * @param DistancesFromCamera 
      * @param Scene 
      */
-    void SortSceneModels(std::map<unsigned int, int> CameraUpdatesQuota, std::vector<std::map<float, unsigned int>> DistancesFromCamera, ERS_STRUCT_Scene* Scene);
+    void SortSceneModels(std::map<unsigned int, int> CameraUpdatesQuota, std::vector<std::vector<std::pair<float, unsigned int>>> DistancesFromCamera, ERS_STRUCT_Scene* Scene);
 
 
 

Source/Core/Loader/ERS_ModelLoader/ERS_CLASS_AsyncTextureUpdater.cpp

@@ -372,7 +372,7 @@ void ERS_CLASS_AsyncTextureUpdater::SetLevelRAM(ERS_STRUCT_Model* Model, bool Lo
         // Also apparenly I don't know how to spell...
         // Load New Levels Into Memory
         if (Model->TextureLevelInRAM_ < Model->TargetTextureLevelRAM) {
-            for (unsigned int LevelToLoad = (unsigned int)Model->TextureLevelInRAM_; LevelToLoad <= (unsigned int)Model->TargetTextureLevelRAM; LevelToLoad++) {
+            for (int LevelToLoad = Model->TextureLevelInRAM_; LevelToLoad <= Model->TargetTextureLevelRAM; LevelToLoad++) {
                 for (unsigned int TextureIndex = 0; TextureIndex < Model->Textures_.size(); TextureIndex++) {
                     LoadImageDataRAM(&Model->Textures_[TextureIndex], LevelToLoad, LogEnable);
                 }
@@ -383,7 +383,7 @@ void ERS_CLASS_AsyncTextureUpdater::SetLevelRAM(ERS_STRUCT_Model* Model, bool Lo
 
         // Unload Old 
         else if (Model->TextureLevelInRAM_ > Model->TargetTextureLevelRAM) {
-            for (unsigned int LevelToUnload = (unsigned int)Model->TextureLevelInRAM_; LevelToUnload > (unsigned int)Model->TargetTextureLevelRAM; LevelToUnload--) {
+            for (int LevelToUnload = Model->TextureLevelInRAM_; LevelToUnload > Model->TargetTextureLevelRAM; LevelToUnload--) {
                 for (unsigned int TextureIndex = 0; TextureIndex < Model->Textures_.size(); TextureIndex++) {
                     UnloadImageDataRAM(&Model->Textures_[TextureIndex], LevelToUnload, LogEnable);
                 }
@@ -405,12 +405,7 @@ void ERS_CLASS_AsyncTextureUpdater::SetLevelVRAM(ERS_STRUCT_Model* Model, bool L
                 // Requested Level
                 LoadImageDataVRAM(&Model->Textures_[TextureIndex], LevelToLoad, LogEnable);
                 Model->Textures_[TextureIndex].BestAvailableOpenGLID = Model->Textures_[TextureIndex].TextureLevels[LevelToLoad].LevelTextureOpenGLID;
-
-                // Ensure That Level 0 Is Always Loaded
-                if (!Model->Textures_[TextureIndex].TextureLevels[0].LevelLoadedInVRAM) {
-                    LoadImageDataVRAM(&Model->Textures_[TextureIndex], 0, LogEnable);
-                    Model->Textures_[TextureIndex].HasAnyLevelReady = true;
-                }
+                Model->Textures_[TextureIndex].HasAnyLevelReady = true;
 
             }
             Model->TextureLevelInVRAM_ = LevelToLoad;
@@ -419,36 +414,41 @@ void ERS_CLASS_AsyncTextureUpdater::SetLevelVRAM(ERS_STRUCT_Model* Model, bool L
         else if (Model->TextureLevelInVRAM_ > Model->TargetTextureLevelVRAM) {
 
             // Here, we unload *all* levels that are above the target (if they're loaded)
-            for (unsigned int LevelToUnload = (unsigned int)Model->TextureLevelInVRAM_; LevelToUnload > (unsigned int)Model->TargetTextureLevelVRAM; LevelToUnload--) {
+            for (int LevelToUnload = Model->TextureLevelInVRAM_; LevelToUnload > Model->TargetTextureLevelVRAM; LevelToUnload--) {
                 for (unsigned int TextureIndex = 0; TextureIndex < Model->Textures_.size(); TextureIndex++) {
 
-                    // Ensure That The Level Prior Is Loaded
+                    // Make Sure We Don't Unload Level 0
                     int PriorLevel = LevelToUnload - 1;
-                    if (PriorLevel > 0) {
+                    if (PriorLevel >= 0) {
+
+                        // Ensure Prior Level Is Loaded
                         if (!Model->Textures_[TextureIndex].TextureLevels[PriorLevel].LevelLoadedInVRAM) {
                             LoadImageDataVRAM(&Model->Textures_[TextureIndex], PriorLevel, LogEnable);
                         }
-                    }
 
-                    // Check If Level Already Loaded, Otherwise, Don't Try To Unload It
-                    if (Model->Textures_[TextureIndex].TextureLevels[LevelToUnload].LevelLoadedInVRAM) {
-                        UnloadImageDataVRAM(&Model->Textures_[TextureIndex], LevelToUnload, LogEnable);
-                    }
+                        // Check If Level Already Loaded, Otherwise, Don't Try To Unload It
+                        if (Model->Textures_[TextureIndex].TextureLevels[LevelToUnload].LevelLoadedInVRAM) {
+                            UnloadImageDataVRAM(&Model->Textures_[TextureIndex], LevelToUnload, LogEnable);
+                        }
 
-                    // Find New Best OpenGL ID
-                    for (unsigned int i = 0; i < Model->Textures_[TextureIndex].TextureLevels.size(); i++) {
-                        if (Model->Textures_[TextureIndex].TextureLevels[i].LevelLoadedInVRAM) {
-                            Model->Textures_[TextureIndex].BestAvailableOpenGLID = Model->Textures_[TextureIndex].TextureLevels[i].LevelTextureOpenGLID;
+                        // Find New Best OpenGL ID
+                        for (unsigned int i = 0; i < Model->Textures_[TextureIndex].TextureLevels.size(); i++) {
+                            if (Model->Textures_[TextureIndex].TextureLevels[i].LevelLoadedInVRAM) {
+                                Model->Textures_[TextureIndex].BestAvailableOpenGLID = Model->Textures_[TextureIndex].TextureLevels[i].LevelTextureOpenGLID;
+                                Model->Textures_[TextureIndex].HasAnyLevelReady = true;
+                            }
                         }
+
                     }
+
 
                 }
 
             }
 
             // Detect New Level Loaded In Memory
             if (Model->Textures_.size() > 0) {
-                for (int i = 0; i < Model->Textures_[0].TextureLevels.size(); i++) {
+                for (unsigned int i = 0; i < Model->Textures_[0].TextureLevels.size(); i++) {
                     if (Model->Textures_[0].TextureLevels[i].LevelLoadedInVRAM) {
                         Model->TextureLevelInVRAM_ = i;
                     }

Source/Core/Loader/ERS_ModelLoader/ERS_FUNCTION_ModelMetadataDecoderV0.0.0.cpp

@@ -15,14 +15,15 @@ bool ERS_FUNCTION_DecodeModelMetadataV000(YAML::Node Metadata, ERS_STRUCT_Model*
     // Attempt To Decode, Handle Errors
     try {
 
-
-        if (Metadata["Name"]) {
-            std::string Name = Metadata["Name"].as<std::string>();
-            Model->Name = Name.substr(Name.find_last_of("/") + 1, Name.length()-1);
-        } else {
-            Model->Name = "_Error_";
-            SystemUtils->Logger_->Log(std::string("Error Loading Name From Model Metadata '") + std::to_string(AssetID) + "'", 7); 
-            DecodeStatus = false;
+        if (Model->Name == "Loading...") {
+            if (Metadata["Name"]) {
+                std::string Name = Metadata["Name"].as<std::string>();
+                Model->Name = Name.substr(Name.find_last_of("/") + 1, Name.length()-1);
+            } else {
+                Model->Name = "_Error_";
+                SystemUtils->Logger_->Log(std::string("Error Loading Name From Model Metadata '") + std::to_string(AssetID) + "'", 7); 
+                DecodeStatus = false;
+            }
         }
 
         if (Metadata["ModelID"]) {

Source/Core/Loader/ERS_ModelLoader/ERS_FUNCTION_ModelMetadataDecoderV0.0.1.cpp

@@ -2,7 +2,7 @@
 // This file is part of the BrainGenix-ERS Environment Rendering System //
 //======================================================================//
 
-#include <ERS_FUNCTION_ModelMetadataDecoderV0.0.0.h>
+#include <ERS_FUNCTION_ModelMetadataDecoderV0.0.1.h>
 
 
 bool ERS_FUNCTION_DecodeModelMetadataV001(YAML::Node Metadata, ERS_STRUCT_Model* Model, ERS_STRUCT_SystemUtils* SystemUtils, long AssetID, bool LogEnable) {
@@ -16,13 +16,15 @@ bool ERS_FUNCTION_DecodeModelMetadataV001(YAML::Node Metadata, ERS_STRUCT_Model*
 
         SystemUtils->Logger_->Log("Decoding Model Metadata", 3, LogEnable);
 
-        if (Metadata["Name"]) {
-            std::string Name = Metadata["Name"].as<std::string>();
-            Model->Name = Name.substr(Name.find_last_of("/") + 1, Name.length()-1);
-        } else {
-            Model->Name = "_Error_";
-            SystemUtils->Logger_->Log(std::string("Error Loading Name From Model Metadata '") + std::to_string(AssetID) + "'", 7); 
-            DecodeStatus = false;
+        if (Model->Name == "Loading...") {
+            if (Metadata["Name"]) {
+                std::string Name = Metadata["Name"].as<std::string>();
+                Model->Name = Name.substr(Name.find_last_of("/") + 1, Name.length()-1);
+            } else {
+                Model->Name = "_Error_";
+                SystemUtils->Logger_->Log(std::string("Error Loading Name From Model Metadata '") + std::to_string(AssetID) + "'", 7); 
+                DecodeStatus = false;
+            }
         }
 
         if (Metadata["ModelID"]) {

Source/Core/Renderer/ERS_CLASS_RendererManager/RendererManager.cpp

@@ -193,9 +193,20 @@ void RendererManager::UpdateLoop(float DeltaTime) {
     // Log Any Issues
     ReportOpenGLErrors();
 
+
+
     ERS_STRUCT_Scene* TargetScene = ProjectUtils_->SceneManager_->Scenes_[ProjectUtils_->SceneManager_->ActiveScene_].get();
     ProjectUtils_->ModelLoader_->AssetStreamingManager_->AsyncTextureUpdater_->SortModels(TargetScene);
 
+    std::vector<ERS_STRUCT_Camera*> Cameras;
+    for (unsigned int i = 0; i < VisualRenderer_->Viewports_.size(); i++) {
+        Cameras.push_back(VisualRenderer_->Viewports_[i]->Camera.get());
+    }
+    ProjectUtils_->ModelLoader_->AssetStreamingManager_->UpdateSceneStreamingQueue(ProjectUtils_->SceneManager_->Scenes_[ProjectUtils_->SceneManager_->ActiveScene_].get(), Cameras);
+
+
+
+
     // Update Window Title
     std::string SceneTitle = ProjectUtils_->ProjectManager_->Project_.ProjectName + std::string(" - BrainGenix-ERS");
     glfwSetWindowTitle(Window_, SceneTitle.c_str());