Separate scene

.github/workflows/sonarcloud.yml

@@ -55,14 +55,32 @@ jobs:
         run: |
             /opt/homebrew/opt/llvm/bin/llvm-profdata merge -sparse coverage/*.profraw -o coverage/coverage.profdata
 
-            SOURCE_FILES=$(find Libraries Sandbox -type f \( -name "*.cpp" -o -name "*.h" -o -name "*.hpp" \) | tr '\n' ' ')
-            TEST_BINS=$(find Tests -type f -name "Test.*" -perm +111 | tr '\n' ' ')
+             # Collect all test binaries into an array
+            TEST_BINS=()
+            while IFS= read -r bin; do
+              TEST_BINS+=("$bin")
+            done < <(find Tests -type f -name "Test.*" -perm +111)
 
-            /opt/homebrew/opt/llvm/bin/llvm-cov show $TEST_BINS \
-            --show-branches=count \
-            -instr-profile=coverage/coverage.profdata \
-            --ignore-filename-regex='.*(/usr/|/opt/|/Library/|\.h$)' \
-            > coverage/coverage.txt
+            if [ ${#TEST_BINS[@]} -eq 0 ]; then
+              echo "No test binaries found!"
+              exit 1
+            fi
+
+            # Build -object flags for every binary after the first
+            OBJECT_FLAGS=()
+            for bin in "${TEST_BINS[@]:1}"; do
+              OBJECT_FLAGS+=(-object "$bin")
+            done
+
+            /opt/homebrew/opt/llvm/bin/llvm-cov show "${TEST_BINS[0]}" \
+              "${OBJECT_FLAGS[@]}" \
+              --show-branches=count \
+              -instr-profile=coverage/coverage.profdata \
+              --ignore-filename-regex='.*(/usr/|/opt/|/Library/)' \
+              > coverage/coverage.txt
+
+            # Sanity check — print coverage size so you can see it in logs
+            wc -l coverage/coverage.txt
 
       # ---- MANAGED BUILD ----
       - name: Generate managed solution

Libraries/LibAsset/Asset.h

@@ -2,38 +2,40 @@
 
 #include "AssetTypes.h"
 
+#include <LibCore/Base.h>
 #include <LibCore/Hash.h>
+#include <LibCore/RefCounted.h>
 
+#include <LibCore/RefPtr.h>
 #include <concepts>
 #include <string>
 
 namespace Terran {
 namespace Asset {
 
-class Asset {
+class AssetManager;
+class Asset : public Core::RefCounted {
 public:
     Asset() = default;
-    virtual ~Asset() = default;
-    Asset(AssetHandle const& handle)
-        : m_handle(handle)
+    explicit Asset(AssetId const& handle)
+        : m_id(handle)
     {
     }
 
     bool is_valid()
     {
-        return m_handle.is_valid();
+        return m_id.is_valid();
     }
 
-    AssetHandle const& handle()
+    AssetId const& id() const
     {
-        return m_handle;
+        return m_id;
     }
 
     virtual AssetTypeId type() const = 0;
 
-protected:
-    AssetHandle m_handle;
-    AssetTypeId m_type_id;
+private:
+    AssetId m_id;
     friend class AssetManager;
 };
 
@@ -43,8 +45,8 @@ concept HasStaticType = requires(T) {
 }; 
 
 #define TR_DECLARE_ASSET_TYPE(type_name)                                                  \
-    static AssetTypeId static_type() { return Terran::Core::Hash::fnv1a_64(#type_name); } \
-    virtual AssetTypeId type() const override { return static_type(); }
+    static Terran::Asset::AssetTypeId static_type() { return Terran::Core::Hash::fnv1a_64(#type_name); } \
+    virtual Terran::Asset::AssetTypeId type() const override { return static_type(); }
 
 class TextAsset final : public Asset {
 public:

Libraries/LibAsset/AssetError.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <string_view>
+
+namespace Terran::Asset {
+
+class AssetError {
+public:
+    virtual ~AssetError() = default;
+    [[nodiscard]] virtual std::string_view message() const = 0;
+    [[nodiscard]] virtual std::string_view source() const = 0;
+};
+
+}

Libraries/LibAsset/AssetEvents.h

@@ -8,30 +8,30 @@ namespace Terran::Asset {
 
 class AssetRemovedEvent {
 public:
-    constexpr AssetRemovedEvent(AssetHandle const& handle) noexcept
+    constexpr AssetRemovedEvent(AssetId const& handle) noexcept
         : m_handle(handle)
     {
     }
 
-    [[nodiscard]] constexpr AssetHandle const& handle() const noexcept
+    [[nodiscard]] constexpr AssetId const& handle() const noexcept
     {
         return m_handle;
     }
 
 private:
-    AssetHandle m_handle;
+    AssetId m_handle;
 };
 
 class AssetRenamedEvent {
 public:
-    AssetRenamedEvent(AssetHandle const& handle, std::filesystem::path const& new_file_name, std::filesystem::path const& old_file_name)
+    AssetRenamedEvent(AssetId const& handle, std::filesystem::path const& new_file_name, std::filesystem::path const& old_file_name)
         : m_handle(handle)
         , m_new_file_name(new_file_name)
         , m_old_file_name(old_file_name)
     {
     }
 
-    [[nodiscard]] constexpr AssetHandle const& handle() const noexcept
+    [[nodiscard]] constexpr AssetId const& handle() const noexcept
     {
         return m_handle;
     }
@@ -40,13 +40,14 @@ class AssetRenamedEvent {
     {
         return m_old_file_name;
     }
-
-    [[nodiscard]] constexpr std::filesystem::path const& new_file_name() const noexcept {
+
+    [[nodiscard]] constexpr std::filesystem::path const& new_file_name() const noexcept
+    {
         return m_new_file_name;
     }
 
 private:
-    AssetHandle m_handle;
+    AssetId m_handle;
     std::filesystem::path m_new_file_name;
     std::filesystem::path m_old_file_name;
 };

Libraries/LibAsset/AssetHandle.cpp

@@ -0,0 +1,16 @@
+#include "AssetHandle.h"
+#include "AssetManager.h"
+
+namespace Terran::Asset {
+
+AssetHandle::~AssetHandle()
+{
+    m_asset_manager->enqueue_asset_for_deletion(m_id);
+}
+
+bool AssetHandle::is_valid() const
+{
+    return m_asset_manager->is_asset_loaded(m_id);
+}
+
+}

Libraries/LibAsset/AssetHandle.h

@@ -0,0 +1,50 @@
+#pragma once
+#include "AssetTypes.h"
+
+#include <LibCore/Base.h>
+#include <LibCore/Event.h>
+#include <LibCore/RefPtr.h>
+#include <LibCore/UUID.h>
+#include <LibCore/RefCounted.h>
+#include <LibCore/WeakRef.h>
+
+namespace Terran::Asset {
+
+class AssetManager;
+class AssetHandle : public Core::RefCounted {
+public:
+    virtual ~AssetHandle() override;
+
+    constexpr AssetId const& id() const
+    {
+        return m_id;
+    }
+
+    bool is_valid() const;
+    explicit(false) constexpr operator bool() const {
+        return is_valid();
+    }
+
+private:
+    // A nifty trick to ensure AssetHandle is only used with RefPtr or WeakPtr
+    AssetHandle(AssetId const& id, Core::RawPtr<AssetManager const> asset_manager)
+        : m_id(id)
+        , m_asset_manager(asset_manager)
+    {
+    }
+
+private:
+    AssetId m_id;
+    Core::RawPtr<AssetManager const> m_asset_manager;
+    template<Core::IsRefCounted T>
+    friend class Core::RefPtr;
+
+    template<Core::IsRefCounted T>
+    friend class Core::WeakPtr;
+};
+
+using StrongAssetHandle = Core::RefPtr<AssetHandle>;
+using WeakAssetHandle = Core::WeakPtr<AssetHandle>;
+
+}
+

Libraries/LibAsset/AssetImporter.h

@@ -2,20 +2,26 @@
 
 #include "AssetMetadata.h"
 #include "Asset.h"
+#include "AssetTypes.h"
+#include "AssetError.h"
 
-#include <LibAsset/AssetTypes.h>
 #include <LibCore/Base.h>
+#include <LibCore/Result.h>
+#include <LibCore/RefPtr.h>
+
 #include <filesystem>
 
 namespace Terran::Asset {
 
+using AssetLoadResult = Core::Result<Core::RefPtr<Asset>, Core::Shared<AssetError>>;
+
 class AssetImporter {
 public:
     virtual ~AssetImporter() = default;
-    virtual void load(AssetMetadata const& assetInfo, Terran::Core::Shared<Asset>& asset) = 0;
-    virtual bool save(AssetMetadata const& assetInfo, Terran::Core::Shared<Asset> const& asset) = 0;
-    virtual bool can_handle(std::filesystem::path const& assetPath) = 0;
-    virtual AssetTypeId asset_type() = 0;
+    [[nodiscard]] virtual AssetLoadResult load(AssetMetadata const& assetMetadata) = 0;
+    virtual bool save(AssetMetadata const& assetMetadata, Core::RefPtr<Asset> const& asset) = 0;
+    [[nodiscard]] virtual bool can_handle(std::filesystem::path const& assetPath) = 0;
+    [[nodiscard]] virtual AssetTypeId asset_type() = 0;
 };
 
 }

Libraries/LibAsset/AssetImporterError.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "AssetError.h"
+
+#include <cstdint>
+#include <string_view>
+
+namespace Terran::Asset {
+
+class AssetImporterError final : public AssetError {
+public:
+    enum class Code : uint8_t {
+        ImporterNotFound,
+    };
+
+    explicit AssetImporterError(Code code)
+        : m_code(code)
+    {
+    }
+
+    ~AssetImporterError() override = default;
+
+    [[nodiscard]] std::string_view message() const override
+    {
+        if (m_code == Code::ImporterNotFound) {
+            return "No importer registered for asset type";
+        }
+
+        return "Unknown error";
+    }
+
+    [[nodiscard]] std::string_view source() const override
+    {
+        return "Asset";
+    }
+
+private:
+    Code m_code;
+};
+
+}

Libraries/LibAsset/AssetImporterRegistry.cpp

@@ -1,36 +1,43 @@
 #include "AssetImporterRegistry.h"
 #include "Asset.h"
 #include "AssetImporter.h"
+#include "AssetImporterError.h"
 #include "AssetMetadata.h"
 #include "AssetTypes.h"
 
 #include <LibCore/Base.h>
 #include <LibCore/Log.h>
+#include <LibCore/RefPtr.h>
 
+#include <LibCore/Result.h>
 #include <unordered_map>
 
 namespace Terran::Asset {
 
 std::unordered_map<AssetTypeId, Terran::Core::Shared<AssetImporter>> AssetImporterRegistry::s_loaders;
 
-void AssetImporterRegistry::load(AssetMetadata const& assetMetadata, Terran::Core::Shared<Asset>& asset)
+AssetLoadResult AssetImporterRegistry::load(AssetMetadata const& assetMetadata)
 {
     AssetTypeId const type_id = assetMetadata.Type;
     if (s_loaders.contains(type_id)) {
-        s_loaders[type_id]->load(assetMetadata, asset);
-        return;
+        return s_loaders[type_id]->load(assetMetadata);
     }
 
-    TR_CORE_ERROR(TR_LOG_ASSET, "Invalid asset type for asset: {0}", assetMetadata.Path);
+    TR_ERROR(TR_LOG_ASSET, "Invalid asset type for asset: {0}", assetMetadata.Path);
+    return { Core::CreateShared<AssetImporterError>(AssetImporterError::Code::ImporterNotFound) };
 }
 
-bool AssetImporterRegistry::save(AssetMetadata const& assetMetadata, Terran::Core::Shared<Asset> const& asset)
+bool AssetImporterRegistry::save(AssetMetadata const& assetMetadata, Core::RefPtr<Asset> const& asset)
 {
+    if(assetMetadata.Type != asset->type()) {
+        return false;
+    }
+
     AssetTypeId const type_id = assetMetadata.Type;
     if (s_loaders.contains(type_id))
         return s_loaders[type_id]->save(assetMetadata, asset);
 
-    TR_CORE_ERROR(TR_LOG_ASSET, "Invalid asset type for asset: {0}", assetMetadata.Path);
+    TR_ERROR(TR_LOG_ASSET, "Invalid asset type for asset: {0}", assetMetadata.Path);
     return false;
 }