fix(tesseratos): handleImport function

engine/include/cubos/engine/assets/assets.hpp

@@ -7,6 +7,7 @@
 #include <condition_variable>
 #include <deque>
 #include <memory>
+#include <optional>
 #include <shared_mutex>
 #include <string>
 #include <thread>
@@ -57,6 +58,7 @@ namespace cubos::engine
             Unloaded, ///< The asset is not loaded.
             Loading,  ///< The asset is being loaded.
             Loaded,   ///< The asset is loaded.
+            Failed,   ///< The asset failed to load.
         };
 
         ~Assets();
@@ -86,6 +88,11 @@ namespace cubos::engine
         /// @param path Path to load metadata from.
         void importAll(std::string_view path);
 
+        /// @brief Get AssetHandle from Path.
+        /// @param path Path to get handle from.
+        /// @return AssetHandle from Path, or a null handle if unable to find.
+        AnyAsset getAsset(std::string_view path);
+
         /// @brief Loads all metadata from the virtual filesystem, in the given path. If the path
         /// points to a directory, it will be recursively searched for metadata files.
         /// @param path Path to load metadata from.
@@ -152,6 +159,28 @@ namespace cubos::engine
             return AssetRead<T>(*data, std::move(lock));
         }
 
+        /// @brief Gets read-only access to the asset data associated with the given handle.
+        ///
+        /// If the asset is not loaded, this blocks until it is. If the asset cannot be loaded,
+        /// returns std::nullopt.
+        ///
+        /// @tparam T Type of the asset data.
+        /// @param handle Handle to get the asset data for.
+        /// @return Reference to the asset data.
+        template <typename T>
+        inline std::optional<std::reference_wrapper<const T>> tryRead(Asset<T> handle) const
+        {
+            // Create a strong handle to the asset, so that the asset starts loading if it isn't already.
+            auto strong = this->load(handle);
+            auto lock = this->lockRead(strong);
+            auto data = static_cast<const T*>(this->tryAccess(strong, core::reflection::reflect<T>(), lock, false));
+            if (data == nullptr)
+            {
+                return std::nullopt;
+            }
+            return std::cref(*data);
+        }
+
         /// @brief Gets read-write access to the asset data associated with the given handle.
         ///
         /// If the asset is not loaded, this blocks until it is. If the asset cannot be loaded,
@@ -302,6 +331,21 @@ namespace cubos::engine
         template <typename Lock>
         void* access(const AnyAsset& handle, const core::reflection::Type& type, Lock& lock, bool incVersion) const;
 
+        /// @brief Gets a pointer to the asset data associated with the given handle.
+        ///
+        /// If the asset is not loaded, this blocks until it is. If the asset cannot be loaded,
+        /// return nullpt. If this function is called from the loader thread, instead of waiting
+        /// for the asset to load, it will be loaded synchronously.
+        ///
+        /// @tparam Lock The type of the lock guard.
+        /// @param handle Handle to get the asset data for.
+        /// @param type Expected type of the asset data.
+        /// @param lock Lock guard for the asset.
+        /// @param incVersion Whether to increase the asset's version.
+        /// @return Pointer to the asset's data.
+        template <typename Lock>
+        void* tryAccess(const AnyAsset& handle, const core::reflection::Type& type, Lock& lock, bool incVersion) const;
+
         /// @brief Locks the given asset for reading.
         /// @param handle Handle to lock.
         /// @return Lock guard.

engine/include/cubos/engine/voxels/voxel_model.hpp

@@ -47,7 +47,11 @@ namespace cubos::engine
 
         const VoxelPalette& getPalette() const;
 
-        VoxelGrid& getGrid(uint16_t index);
+        void setPalette(const VoxelPalette& palette);
+
+        const VoxelGrid& getGrid(uint16_t index) const;
+
+        void setGrid(uint16_t index, const VoxelGrid& grid, const glm::ivec3& position);
 
         /// @brief Loads the grid's data from the given stream.
         ///

engine/src/assets/assets.cpp

@@ -108,7 +108,7 @@ void Assets::importAll(std::string_view path)
             child = child->sibling();
         }
     }
-    // Skip files that already have a .meta extension.
+    // Skip meta files.
     else if (!file->name().ends_with(".meta"))
     {
         // Check if the .meta file exists.
@@ -141,6 +141,19 @@ void Assets::importAll(std::string_view path)
     }
 }
 
+AnyAsset Assets::getAsset(std::string_view path)
+{
+    for (const auto& [uuid, entry] : mEntries)
+    {
+        auto path_meta = entry->meta.get("path");
+        if (path_meta.has_value() && path_meta.value() == path)
+        {
+            return AnyAsset(uuid);
+        }
+    }
+    return {};
+}
+
 void Assets::loadMeta(std::string_view path)
 {
     auto file = core::data::FileSystem::find(path);
@@ -524,13 +537,77 @@ void* Assets::access(const AnyAsset& handle, const Type& type, Lock& lock, bool
     return assetEntry->data;
 }
 
+template <typename Lock>
+void* Assets::tryAccess(const AnyAsset& handle, const Type& type, Lock& lock, bool incVersion) const
+{
+    CUBOS_ASSERT(!handle.isNull(), "Could not access asset");
+
+    // Get the entry for the asset.
+    auto assetEntry = this->entry(handle);
+    CUBOS_ASSERT(assetEntry != nullptr, "Could not access asset");
+
+    // If the asset hasn't been loaded yet, and its bridge isn't asynchronous, or we're in the loader thread, then load
+    // it now.
+    if (assetEntry->status != Status::Loaded)
+    {
+        auto bridge = this->bridge(handle);
+        CUBOS_ASSERT(bridge != nullptr, "Could not access asset");
+
+        if (!bridge->asynchronous() || std::this_thread::get_id() == mLoaderThread.get_id())
+        {
+            CUBOS_DEBUG("Loading asset {} as a dependency", handle);
+
+            // Load the asset - the const_cast is okay since the const qualifiers are only used to make
+            // the interface more readable. We need to unlock temporarily to avoid a deadlock, since the
+            // bridge will call back into the asset manager.
+            lock.unlock();
+            if (!bridge->load(const_cast<Assets&>(*this), handle))
+            {
+                CUBOS_CRITICAL("Could not load asset {}", handle);
+                abort();
+            }
+            lock.lock();
+        }
+    }
+
+    // Wait until the asset finishes loading.
+    while (assetEntry->status == Status::Loading)
+    {
+        assetEntry->cond.wait(lock);
+    }
+
+    if (assetEntry->status != Status::Loaded || assetEntry->data == nullptr)
+    {
+        CUBOS_ERROR("Could not access asset");
+        return nullptr;
+    }
+
+    if (assetEntry->type != &type)
+    {
+        CUBOS_ERROR("Type mismatch, expected {}, got {}", type.name(), assetEntry->type->name());
+        return nullptr;
+    }
+
+    if (incVersion)
+    {
+        assetEntry->version++;
+        CUBOS_DEBUG("Incremented version of asset {}", handle);
+    }
+
+    return assetEntry->data;
+}
+
 // Define the explicit instantiations of the access() function, one for each lock type.
 // Necessary because the function is template - would otherwise cause linker errors.
 
 template void* Assets::access<std::shared_lock<std::shared_mutex>>(const AnyAsset&, const Type&,
                                                                    std::shared_lock<std::shared_mutex>&, bool) const;
 template void* Assets::access<std::unique_lock<std::shared_mutex>>(const AnyAsset&, const Type&,
                                                                    std::unique_lock<std::shared_mutex>&, bool) const;
+template void* Assets::tryAccess<std::shared_lock<std::shared_mutex>>(const AnyAsset&, const Type&,
+                                                                      std::shared_lock<std::shared_mutex>&, bool) const;
+template void* Assets::tryAccess<std::unique_lock<std::shared_mutex>>(const AnyAsset&, const Type&,
+                                                                      std::unique_lock<std::shared_mutex>&, bool) const;
 
 std::shared_lock<std::shared_mutex> Assets::lockRead(const AnyAsset& handle) const
 {
@@ -680,7 +757,7 @@ void Assets::loader()
 
             auto assetEntry = this->entry(task.handle);
             CUBOS_ASSERT(assetEntry != nullptr, "This should never happen");
-            assetEntry->status = Assets::Status::Unloaded;
+            assetEntry->status = Assets::Status::Failed;
             assetEntry->cond.notify_all();
         }
         else

engine/src/voxels/voxel_model.cpp

@@ -33,11 +33,26 @@ const VoxelPalette& VoxelModel::getPalette() const
     return palette;
 }
 
-VoxelGrid& VoxelModel::getGrid(uint16_t index)
+void VoxelModel::setPalette(const VoxelPalette& palette)
+{
+    this->palette = palette;
+}
+
+const VoxelGrid& VoxelModel::getGrid(uint16_t index) const
 {
     return matrices[index].grid;
 }
 
+void VoxelModel::setGrid(uint16_t index, const VoxelGrid& grid, const glm::ivec3& position)
+{
+    if (index >= matrices.size())
+    {
+        matrices.resize(index + 1);
+    }
+    matrices[index].grid = grid;
+    matrices[index].position = position;
+}
+
 bool VoxelModel::loadFrom(Stream& stream)
 {
     uint8_t version[4] = {0, 0, 0, 0};