*

Src/Client/Vulkan/Vulkan.cpp

@@ -584,6 +584,7 @@ void Vulkan::run()
 		// vkAssert(!vkQueueWaitIdle(Graphics.DeviceQueueGraphic));
 
 		{
+			// Эту хрень надо убрать
 			auto lockQueue = Graphics.DeviceQueueGraphic.lock();
 			vkDeviceWaitIdle(Graphics.Device);
 			lockQueue.unlock();

Src/Client/Vulkan/VulkanRenderSession.cpp

@@ -1205,10 +1205,15 @@ void VulkanRenderSession::drawWorld(GlobalTime gTime, float dTime, VkCommandBuff
         Pos::GlobalChunk x64offset = X64Offset >> Pos::Object_t::BS_Bit >> 4;
         Pos::GlobalRegion x64offset_region = x64offset >> 2;
 
-        auto [voxelVertexs, nodeVertexs] = VKCTX->ThreadVertexObj.getChunksForRender(WorldId, Pos, 2, PCO.ProjView, x64offset_region);
+        auto [voxelVertexs, nodeVertexs] = VKCTX->ThreadVertexObj.getChunksForRender(WorldId, Pos, 1, PCO.ProjView, x64offset_region);
+
+        size_t count = 0;
+
 
         glm::mat4 orig = PCO.Model;
         for(auto& [chunkPos, vertexs, vertexCount] : nodeVertexs) {
+            count += vertexCount;
+            
             glm::vec3 cpos(chunkPos-x64offset);
             PCO.Model = glm::translate(orig, cpos*16.f);
             auto [vkBufferN, offset] = vertexs;
@@ -1224,6 +1229,9 @@ void VulkanRenderSession::drawWorld(GlobalTime gTime, float dTime, VkCommandBuff
             vkCmdDraw(drawCmd, vertexCount, 1, offset, 0);
         }
 
+        TOS::Logger LOG = "VRS";
+        LOG.debug() << "Node: drawCals: " << nodeVertexs.size() << " vertexs: " << count;
+
         PCO.Model = orig;
 
         // auto iterWorld = External.ChunkVoxelMesh.find(WorldId);

Src/Common/Abstract.hpp

@@ -396,7 +396,7 @@ using ResourceId = uint32_t;
     Если объекты удаляются, то сторона клиента об этом не уведомляется
 */
 enum class EnumAssets {
-   Nodestate, Patricle, Animation, Model, Texture, Sound, Font, MAX_ENUM
+   Nodestate, Particle, Animation, Model, Texture, Sound, Font, MAX_ENUM
 };
 
 using AssetsNodestate   = ResourceId;

Src/Server/Abstract.cpp

@@ -1,4 +1,5 @@
 #include "Abstract.hpp"
+#include <csignal>
 
 
 namespace LV::Server {
@@ -249,7 +250,7 @@ NodeStateCondition nodestateExpression(const std::vector<NodestateEntry>& entrie
                     case EnumTokenKind::EQ:         value = std::get<int>(leftToken) == std::get<int>(rightToken); break;
                     case EnumTokenKind::NE:         value = std::get<int>(leftToken) != std::get<int>(rightToken); break;
 
-                    default: assert(false);
+                    default: std::unreachable();
                     }
 
 
@@ -273,7 +274,7 @@ NodeStateCondition nodestateExpression(const std::vector<NodestateEntry>& entrie
                     case EnumTokenKind::EQ:         bin.op = Op::EQ;  break;
                     case EnumTokenKind::NE:         bin.op = Op::NE;  break;
 
-                    default: assert(false);
+                    default: std::unreachable();
                     }
 
                     if(int* value = std::get_if<int>(&leftToken)) {
@@ -344,7 +345,7 @@ NodeStateCondition nodestateExpression(const std::vector<NodestateEntry>& entrie
             case Op::Pos: return +rNodeValue;
             case Op::Neg: return -rNodeValue;
             default:
-                assert(false);
+                std::unreachable();
             }
         } else if(const Node::Binary* value = std::get_if<Node::Binary>(&node.v)) {
             int lNodeValue = lambdaCalcNode(value->lhs);
@@ -365,10 +366,10 @@ NodeStateCondition nodestateExpression(const std::vector<NodestateEntry>& entrie
             case Op::And: return lNodeValue&&rNodeValue;
             case Op::Or:  return lNodeValue||rNodeValue;
             default:
-                assert(false);
+                std::unreachable();
             }
         } else {
-            assert(false);
+            std::unreachable();
         }
     };
 

Src/Server/AssetsManager.cpp

@@ -1,18 +1,144 @@
 #include "AssetsManager.hpp"
 #include "Common/Abstract.hpp"
+#include "png++/rgb_pixel.hpp"
 #include <filesystem>
+#include <png.h>
+#include <pngconf.h>
 #include <unordered_map>
 #include <unordered_set>
+#include <utility>
 
 
 namespace LV::Server {
 
 AssetsManager::Resource AssetsManager::loadResourceFromFile(EnumAssets type, fs::path path) const {
-    return AssetsManager::Resource(path);
+    switch(type) {
+    case EnumAssets::Nodestate: return loadResourceFromFile_Nodestate(path);
+    case EnumAssets::Particle: return loadResourceFromFile_Particle(path);
+    case EnumAssets::Animation: return loadResourceFromFile_Animation(path);
+    case EnumAssets::Model: return loadResourceFromFile_Model(path);
+    case EnumAssets::Texture: return loadResourceFromFile_Texture(path);
+    case EnumAssets::Sound: return loadResourceFromFile_Sound(path);
+    case EnumAssets::Font: return loadResourceFromFile_Font(path);
+    default:
+        std::unreachable();
+    }
 }
 
-AssetsManager::Resource AssetsManager::loadResourceFromLua(EnumAssets type, void*) const {
+AssetsManager::Resource AssetsManager::loadResourceFromLua(EnumAssets type, const sol::table& profile) const {
-    return AssetsManager::Resource("assets/null");
+    switch(type) {
+    case EnumAssets::Nodestate: return loadResourceFromLua_Nodestate(profile);
+    case EnumAssets::Particle: return loadResourceFromLua_Particle(profile);
+    case EnumAssets::Animation: return loadResourceFromLua_Animation(profile);
+    case EnumAssets::Model: return loadResourceFromLua_Model(profile);
+    case EnumAssets::Texture: return loadResourceFromLua_Texture(profile);
+    case EnumAssets::Sound: return loadResourceFromLua_Sound(profile);
+    case EnumAssets::Font: return loadResourceFromLua_Font(profile);
+    default:
+        std::unreachable();
+    }
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromFile_Nodestate(fs::path path) const {
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromFile_Particle(fs::path path) const {
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromFile_Animation(fs::path path) const {
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromFile_Model(fs::path path) const {
+    /*
+        json, obj, glTF
+    */
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromFile_Texture(fs::path path) const {
+    Resource res(path);
+
+    if(res.size() < 8)
+        MAKE_ERROR("Файл не является текстурой png или jpeg (недостаточный размер файла)");
+
+    if(png_check_sig(reinterpret_cast<png_bytep>((unsigned char*) res.data()), 8)) {
+        // Это png
+        return res;
+    } else if((int) res.data()[0] == 0xFF && (int) res.data()[1] == 0xD8) {
+        // Это jpeg
+        return res;
+    } else {
+        MAKE_ERROR("Файл не является текстурой png или jpeg");
+    }
+
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromFile_Sound(fs::path path) const {
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromFile_Font(fs::path path) const {
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromLua_Nodestate(const sol::table& profile) const {
+    if(std::optional<std::string> path = profile.get<std::optional<std::string>>("path")) {
+        return AssetsManager::Resource(*path);
+    }
+
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromLua_Particle(const sol::table& profile) const {
+    if(std::optional<std::string> path = profile.get<std::optional<std::string>>("path")) {
+        return AssetsManager::Resource(*path);
+    }
+    
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromLua_Animation(const sol::table& profile) const {
+    if(std::optional<std::string> path = profile.get<std::optional<std::string>>("path")) {
+        return AssetsManager::Resource(*path);
+    }
+    
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromLua_Model(const sol::table& profile) const {
+    if(std::optional<std::string> path = profile.get<std::optional<std::string>>("path")) {
+        return AssetsManager::Resource(*path);
+    }
+    
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromLua_Texture(const sol::table& profile) const {
+    if(std::optional<std::string> path = profile.get<std::optional<std::string>>("path")) {
+        return AssetsManager::Resource(*path);
+    }
+    
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromLua_Sound(const sol::table& profile) const {
+    if(std::optional<std::string> path = profile.get<std::optional<std::string>>("path")) {
+        return AssetsManager::Resource(*path);
+    }
+    
+    std::unreachable();
+}
+
+AssetsManager::Resource AssetsManager::loadResourceFromLua_Font(const sol::table& profile) const {
+    if(std::optional<std::string> path = profile.get<std::optional<std::string>>("path")) {
+        return AssetsManager::Resource(*path);
+    }
+    
+    std::unreachable();
 }
 
 AssetsManager::AssetsManager(asio::io_context& ioc)
@@ -70,14 +196,14 @@ AssetsManager::Out_recheckResources AssetsManager::recheckResources(const Assets
 
                     switch ((EnumAssets) type) {
                     case EnumAssets::Nodestate: file /= "nodestate";   break;
-                    case EnumAssets::Patricle:  file /= "particle";    break;
+                    case EnumAssets::Particle:  file /= "particle";    break;
                     case EnumAssets::Animation: file /= "animation";   break;
                     case EnumAssets::Model:     file /= "model";       break;
                     case EnumAssets::Texture:   file /= "texture";     break;
                     case EnumAssets::Sound:     file /= "sound";       break;
                     case EnumAssets::Font:      file /= "font";        break;
                     default:
-                        assert(false);
+                        std::unreachable();
                     }
 
                     file /= key;
@@ -159,14 +285,14 @@ AssetsManager::Out_recheckResources AssetsManager::recheckResources(const Assets
 
                 switch ((EnumAssets) type) {
                 case EnumAssets::Nodestate: resourcesPath /= "nodestate";   break;
-                case EnumAssets::Patricle:  resourcesPath /= "particle";    break;
+                case EnumAssets::Particle:  resourcesPath /= "particle";    break;
                 case EnumAssets::Animation: resourcesPath /= "animation";   break;
                 case EnumAssets::Model:     resourcesPath /= "model";       break;
                 case EnumAssets::Texture:   resourcesPath /= "texture";     break;
                 case EnumAssets::Sound:     resourcesPath /= "sound";       break;
                 case EnumAssets::Font:      resourcesPath /= "font";        break;
                 default:
-                    assert(false);
+                    std::unreachable();
                 }
 
                 auto& findList = findedResources[type][domain];

Src/Server/AssetsManager.hpp

@@ -92,7 +92,23 @@ private:
         к внутреннему формату и сохраняется в кеше
     */
     Resource loadResourceFromFile   (EnumAssets type, fs::path path) const;
-    Resource loadResourceFromLua(EnumAssets type, void*) const;
+    Resource loadResourceFromLua    (EnumAssets type, const sol::table& profile) const;
+
+    Resource loadResourceFromFile_Nodestate (fs::path path) const;
+    Resource loadResourceFromFile_Particle  (fs::path path) const;
+    Resource loadResourceFromFile_Animation (fs::path path) const;
+    Resource loadResourceFromFile_Model     (fs::path path) const;
+    Resource loadResourceFromFile_Texture   (fs::path path) const;
+    Resource loadResourceFromFile_Sound     (fs::path path) const;
+    Resource loadResourceFromFile_Font      (fs::path path) const;
+
+    Resource loadResourceFromLua_Nodestate  (const sol::table& profile) const;
+    Resource loadResourceFromLua_Particle   (const sol::table& profile) const;
+    Resource loadResourceFromLua_Animation  (const sol::table& profile) const;
+    Resource loadResourceFromLua_Model      (const sol::table& profile) const;
+    Resource loadResourceFromLua_Texture    (const sol::table& profile) const;
+    Resource loadResourceFromLua_Sound      (const sol::table& profile) const;
+    Resource loadResourceFromLua_Font       (const sol::table& profile) const;
 
 public:
     AssetsManager(asio::io_context& ioc);

Src/Server/ContentManager.hpp

@@ -120,7 +120,7 @@ class ContentManager {
                 Profiles_Item.push_back(std::make_unique<TableEntry<DefItem>>()); 
             break;
         default:
-            assert(false);
+            std::unreachable();
         }
 
         return resId;

Src/Server/GameServer.cpp

@@ -1615,7 +1615,7 @@ void GameServer::initLuaAssets() {
     };
 
     core->set_function("register_nodestate",    [&](const std::string& key, const sol::table& profile) { reg(EnumAssets::Nodestate, key, profile); });
-    core->set_function("register_particle",     [&](const std::string& key, const sol::table& profile) { reg(EnumAssets::Patricle, key, profile); });
+    core->set_function("register_particle",     [&](const std::string& key, const sol::table& profile) { reg(EnumAssets::Particle, key, profile); });
     core->set_function("register_animation",    [&](const std::string& key, const sol::table& profile) { reg(EnumAssets::Animation, key, profile); });
     core->set_function("register_model",        [&](const std::string& key, const sol::table& profile) { reg(EnumAssets::Model, key, profile); });
     core->set_function("register_texture",      [&](const std::string& key, const sol::table& profile) { reg(EnumAssets::Texture, key, profile); });

Src/Server/RemoteClient.cpp

@@ -497,7 +497,7 @@ ResourceRequest RemoteClient::pushPreparedPackets() {
 
 void RemoteClient::informateAssets(const std::vector<std::tuple<EnumAssets, ResourceId, const std::string, const std::string, AssetsManager::Resource>>& resources)
 {
-    std::vector<std::tuple<EnumAssets, ResourceId, const std::string, const std::string, Hash_t>> newForClient;
+    std::vector<std::tuple<EnumAssets, ResourceId, const std::string, const std::string, Hash_t, size_t>> newForClient;
 
     for(auto& [type, resId, domain, key, resource] : resources) {
         auto hash = resource.hash();
@@ -525,7 +525,7 @@ void RemoteClient::informateAssets(const std::vector<std::tuple<EnumAssets, Reso
                 && std::get<Hash_t>(iter->second) != hash
             ) {
                 // Требуется перепривязать идентификатор к новому хешу
-                newForClient.push_back({(EnumAssets) type, resId, domain, key, hash});
+                newForClient.push_back({(EnumAssets) type, resId, domain, key, hash, resource.size()});
                 std::get<Hash_t>(iter->second) = hash;
             }
         }
@@ -540,9 +540,9 @@ void RemoteClient::informateAssets(const std::vector<std::tuple<EnumAssets, Reso
         lock->NextPacket << (uint8_t) ToClient::L1::Resource    // Оповещение
             << ((uint8_t) ToClient::L2Resource::Bind) << uint32_t(newForClient.size());
 
-        for(auto& [type, resId, domain, key, hash] : newForClient) {
+        for(auto& [type, resId, domain, key, hash, size] : newForClient) {
             // TODO: может внести ограничение на длину домена и ключа?
-            lock->NextPacket << uint8_t(type) << uint32_t(resId) << domain << key;
+            lock->NextPacket << uint8_t(type) << uint32_t(resId) << domain << key << size;
             lock->NextPacket.write((const std::byte*) hash.data(), hash.size());
         }
     }

Work/imgui.ini

@@ -4,5 +4,5 @@ Size=400,400
 
 [Window][MainMenu]
 Pos=0,0
-Size=1920,1142
+Size=960,540