*

Src/Client/Vulkan/VulkanRenderSession.hpp

@@ -386,22 +386,29 @@ public:
     std::vector<AssetsNodestate> onNodestateChanges(std::vector<std::tuple<AssetsNodestate, Resource>> newOrChanged, std::vector<AssetsNodestate> lost, std::vector<AssetsModel> changedModels) {
         std::vector<AssetsNodestate> result;
 
-        
+
 
 
         return result;
     }
 
-    std::vector<Model> getModelsForNode(DefNodeId id, uint8_t meta) {
+    struct StateInfo {
+        std::string Name;
+        std::vector<std::string> Variable;
+        int Variations = 0;
+    };
 
+    // Выдаёт модели в зависимости от состояний
+    // statesInfo - Описание состояний ноды
+    // states     - Текущие значения состояний ноды
+    std::vector<Model> getModelsForNode(AssetsNodestate id, const std::vector<StateInfo>& statesInfo, const std::unordered_map<std::string, int>& states) {
+        
     }
 
 private:
     Logger LOG = "Client>NodestateProvider";
     ModelProvider& MP;
-
-
-
+    std::unordered_map<AssetsNodestate, PreparedNodeState> Nodestates;
 };
 
 /*

Src/Common/Abstract.cpp

@@ -874,11 +874,11 @@ PreparedNodeState::PreparedNodeState(const std::u8string& data) {
     uint16_t size;
     lr >> size;
 
-    ModelToLocalId.reserve(size);
+    LocalToModel.reserve(size);
     for(int counter = 0; counter < size; counter++) {
-        std::string domain, key;
-        lr >> domain >> key;
-        ModelToLocalId.emplace_back(std::move(domain), std::move(key));
+        AssetsModel modelId;
+        lr >> modelId;
+        LocalToModel.push_back(modelId);
     }
 
     lr >> size;
@@ -989,14 +989,12 @@ std::u8string PreparedNodeState::dump() const {
     Net::Packet result;
 
     // ResourceToLocalId
-    assert(ModelToLocalId.size() < (1 << 16));
-    result << uint16_t(ModelToLocalId.size());
+    assert(LocalToModelKD.size() < (1 << 16));
+    assert(LocalToModelKD.size() == LocalToModel.size());
+    result << uint16_t(LocalToModel.size());
 
-    for(const auto& [domain, key] : ModelToLocalId) {
-        assert(domain.size() < 32);
-        result << domain;
-        assert(key.size() < 32);
-        result << key;
+    for(AssetsModel modelId : LocalToModel) {
+        result << modelId;
     }
 
     // Nodes
@@ -1448,15 +1446,15 @@ std::pair<float, std::variant<PreparedNodeState::Model, PreparedNodeState::Vecto
         auto [domain, key] = parseDomainKey((std::string) *model_key, modid);
         
         uint16_t resId = 0;
-        for(auto& [lDomain, lKey] : ModelToLocalId) {
+        for(auto& [lDomain, lKey] : LocalToModelKD) {
             if(lDomain == domain && lKey == key)
                 break;
 
             resId++;
         }
 
-        if(resId == ModelToLocalId.size()) {
-            ModelToLocalId.emplace_back(domain, key);
+        if(resId == LocalToModelKD.size()) {
+            LocalToModelKD.emplace_back(domain, key);
         }
 
         result.Id = resId;
@@ -1483,15 +1481,15 @@ std::pair<float, std::variant<PreparedNodeState::Model, PreparedNodeState::Vecto
             auto [domain, key] = parseDomainKey((std::string) js_obj.at("model").as_string(), modid);
         
             uint16_t resId = 0;
-            for(auto& [lDomain, lKey] : ModelToLocalId) {
+            for(auto& [lDomain, lKey] : LocalToModelKD) {
                 if(lDomain == domain && lKey == key)
                     break;
 
                 resId++;
             }
 
-            if(resId == ModelToLocalId.size()) {
-                ModelToLocalId.emplace_back(domain, key);
+            if(resId == LocalToModelKD.size()) {
+                LocalToModelKD.emplace_back(domain, key);
             }
 
             subModel.Id = resId;

Src/Common/Abstract.hpp

@@ -636,7 +636,9 @@ struct PreparedNodeState {
     };
 
     // Локальный идентификатор в именной ресурс
-    std::vector<std::pair<std::string, std::string>> ModelToLocalId;
+    std::vector<std::pair<std::string, std::string>> LocalToModelKD;
+    // Локальный идентификатор в глобальный идентификатор
+    std::vector<AssetsModel> LocalToModel;
     // Ноды выражений
     std::vector<Node> Nodes;
     // Условия -> вариации модели + веса

Src/Server/AssetsManager.cpp

@@ -77,10 +77,7 @@ void AssetsManager::loadResourceFromFile_Nodestate(ResourceChangeObj& out, const
     Resource res(path);
     js::object obj = js::parse(std::string_view((const char*) res.data(), res.size())).as_object();
     PreparedNodeState pns(domain, obj);
-    std::u8string data = pns.dump();
-    Resource result((const uint8_t*) data.data(), data.size());
-    out.Nodestates[domain].emplace_back(key, std::move(pns));
-    out.NewOrChange[(int) EnumAssets::Nodestate][domain].emplace_back(key, result, fs::last_write_time(path));
+    out.NewOrChange_Nodestates[domain].emplace_back(key, std::move(pns), fs::last_write_time(path));
 }
 
 void AssetsManager::loadResourceFromFile_Particle(ResourceChangeObj& out, const std::string& domain, const std::string& key, fs::path path) const {
@@ -491,28 +488,33 @@ AssetsManager::Out_applyResourceChange AssetsManager::applyResourceChange(const
         std::set_difference(l.begin(), l.end(), noc.begin(), noc.end(), std::back_inserter(result.Lost[type]));
     }
 
-    if(!orr.Nodestates.empty())
+    // Приёмка новых/изменённых описаний состояний нод
+    if(!orr.NewOrChange_Nodestates.empty())
     {
         auto lock = LocalObj.lock();
-        for(auto& [domain, table] : orr.Nodestates) {
-            for(auto& [key, value] : table) {
+        for(auto& [domain, table] : orr.NewOrChange_Nodestates) {
+            for(auto& [key, _nodestate, ftt] : table) {
                 ResourceId resId = lock->getId(EnumAssets::Nodestate, domain, key);
+                std::optional<DataEntry>& data = lock->Table[(int) EnumAssets::Nodestate][resId / TableEntry<DataEntry>::ChunkSize]->Entries[resId % TableEntry<DataEntry>::ChunkSize];
+                PreparedNodeState nodestate = _nodestate;
 
-                std::vector<AssetsModel> models;
-
-                for(auto& [domain2, key2] : value.ModelToLocalId) {
-                    models.push_back(lock->getId(EnumAssets::Model, domain2, key2));
+                // Ресолвим модели
+                for(const auto& [lKey, lDomain] : nodestate.LocalToModelKD) {
+                    nodestate.LocalToModel.push_back(lock->getId(EnumAssets::Nodestate, lDomain, lKey));
                 }
 
-                {
-                    std::sort(models.begin(), models.end());
-                    auto iterErase = std::unique(models.begin(), models.end());
-                    models.erase(iterErase, models.end());
-                    models.shrink_to_fit();
-                }
+                // Сдампим для отправки клиенту (Кеш в пролёте?)
+                Resource res(nodestate.dump());
+
+                // На оповещение
+                result.NewOrChange[(int) EnumAssets::Model].push_back({resId, res});
+
+                // Запись в таблице ресурсов
+                data.emplace(ftt, res, domain, key);
+                lock->HashToId[res.hash()] = {EnumAssets::Nodestate, resId};
 
                 lock->Table_NodeState[resId / TableEntry<DataEntry>::ChunkSize]
-                    ->Entries[resId % TableEntry<DataEntry>::ChunkSize] = std::move(models);
+                    ->Entries[resId % TableEntry<DataEntry>::ChunkSize] = nodestate.LocalToModel;
             }
         }
     }

Src/Server/AssetsManager.hpp

@@ -65,12 +65,12 @@ public:
         std::unordered_map<std::string, std::vector<std::string>> Lost[(int) EnumAssets::MAX_ENUM];
         // Домен и ключ ресурса
         std::unordered_map<std::string, std::vector<std::tuple<std::string, Resource, fs::file_time_type>>> NewOrChange[(int) EnumAssets::MAX_ENUM];
+        std::unordered_map<std::string, std::vector<std::tuple<std::string, PreparedNodeState, fs::file_time_type>>> NewOrChange_Nodestates;
         std::unordered_map<std::string, std::vector<std::tuple<std::string, std::variant<
             LV::PreparedModel,
             PreparedGLTF
         >, fs::file_time_type>>> NewOrChange_Models;
         
-        std::unordered_map<std::string, std::vector<std::pair<std::string, PreparedNodeState>>> Nodestates;
         // std::unordered_map<std::string, std::vector<std::pair<std::string, PreparedModel>>> Models;
     };