compiles again

src/Engine/Asset/AssetRegistry.cpp

@@ -193,28 +193,28 @@ void AssetRegistry::peekAsset(ArchiveBuffer& buffer)
 
     AssetFolder* folder = getOrCreateFolder(folderPath);
 
-    PAsset asset;
+    OAsset asset;
     switch (identifier)
     {
     case TextureAsset::IDENTIFIER:
         asset = new TextureAsset(folderPath, name);
-        folder->textures[asset->getName()] = asset;
+        folder->textures[name] = std::move(asset);
         break;
     case MeshAsset::IDENTIFIER:
         asset = new MeshAsset(folderPath, name);
-        folder->meshes[asset->getName()] = asset;
+        folder->meshes[name] = std::move(asset);
         break;
     case MaterialAsset::IDENTIFIER:
         asset = new MaterialAsset(folderPath, name);
-        folder->materials[asset->getName()] = asset;
+        folder->materials[name] = std::move(asset);
         break;
     case MaterialInstanceAsset::IDENTIFIER:
         asset = new MaterialInstanceAsset(folderPath, name);
-        // TODO
+        folder->instances[name] = std::move(asset);
         break;
     case FontAsset::IDENTIFIER:
         asset = new FontAsset(folderPath, name);
-        folder->fonts[asset->getName()] = asset;
+        folder->fonts[name] = std::move(asset);
         break;
     default:
         throw new std::logic_error("Unknown Identifier");
@@ -241,20 +241,19 @@ void AssetRegistry::loadAsset(ArchiveBuffer& buffer)
     switch (identifier)
     {
     case TextureAsset::IDENTIFIER:
-        asset = folder->textures.at(name);
+        asset = PTextureAsset(folder->textures.at(name));
         break;
     case MeshAsset::IDENTIFIER:
-        asset = folder->meshes.at(name);
+        asset = PMeshAsset(folder->meshes.at(name));
         break;
     case MaterialAsset::IDENTIFIER:
-        asset = folder->materials.at(name);
+        asset = PMaterialAsset(folder->materials.at(name));
         break;
     case MaterialInstanceAsset::IDENTIFIER:
-        //asset = new MaterialInstanceAsset(path);
-        // TODO
+        asset = PMaterialInstanceAsset(folder->instances.at(name));
         break;
     case FontAsset::IDENTIFIER:
-        asset = folder->fonts.at(name);
+        asset = PFontAsset(folder->fonts.at(name));
         break;
     default:
         throw new std::logic_error("Unknown Identifier");
@@ -272,19 +271,23 @@ void AssetRegistry::saveFolder(const std::filesystem::path& folderPath, AssetFol
     std::filesystem::create_directory(rootFolder / folderPath);
     for (const auto& [name, texture] : folder->textures)
     {
-        saveAsset(texture, TextureAsset::IDENTIFIER, folderPath, name);
+        saveAsset(PTextureAsset(texture), TextureAsset::IDENTIFIER, folderPath, name);
     }
     for (const auto& [name, mesh] : folder->meshes)
     {
-        saveAsset(mesh, MeshAsset::IDENTIFIER, folderPath, name);
+        saveAsset(PMeshAsset(mesh), MeshAsset::IDENTIFIER, folderPath, name);
     }
     for (const auto& [name, material] : folder->materials)
     {
-        saveAsset(material, MaterialAsset::IDENTIFIER, folderPath, name);
+        saveAsset(PMaterialAsset(material), MaterialAsset::IDENTIFIER, folderPath, name);
+    }
+    for (const auto& [name, material] : folder->instances)
+    {
+        saveAsset(PMaterialInstanceAsset(material), MaterialInstanceAsset::IDENTIFIER, folderPath, name);
     }
     for (const auto& [name, font] : folder->fonts)
     {
-        saveAsset(font, FontAsset::IDENTIFIER, folderPath, name);
+        saveAsset(PFontAsset(font), FontAsset::IDENTIFIER, folderPath, name);
     }
     for (auto& [name, child] : folder->children)
     {
@@ -316,28 +319,34 @@ std::filesystem::path AssetRegistry::getRootFolder()
     return get().rootFolder;
 }
 
-void AssetRegistry::registerMesh(PMeshAsset mesh) 
+void AssetRegistry::registerMesh(OMeshAsset mesh) 
 {
     AssetFolder* folder = getOrCreateFolder(mesh->getFolderPath());
-    folder->meshes[mesh->getName()] = mesh;
+    folder->meshes[mesh->getName()] = std::move(mesh);
 }
 
-void AssetRegistry::registerTexture(PTextureAsset texture) 
+void AssetRegistry::registerTexture(OTextureAsset texture) 
 {
     AssetFolder* folder = getOrCreateFolder(texture->getFolderPath());
-    folder->textures[texture->getName()] = texture;
+    folder->textures[texture->getName()] = std::move(texture);
 }
 
-void AssetRegistry::registerFont(PFontAsset font)
+void AssetRegistry::registerFont(OFontAsset font)
 {
     AssetFolder* folder = getOrCreateFolder(font->getFolderPath());
-    folder->fonts[font->getName()] = font;
+    folder->fonts[font->getName()] = std::move(font);
 }
 
-void AssetRegistry::registerMaterial(PMaterialAsset material)
+void AssetRegistry::registerMaterial(OMaterialAsset material)
 {
     AssetFolder* folder = getOrCreateFolder(material->getFolderPath());
-    folder->materials[material->getName()] = material;
+    folder->materials[material->getName()] = std::move(material);
+}
+
+void AssetRegistry::registerMaterialInstance(OMaterialInstanceAsset material)
+{
+    AssetFolder* folder = getOrCreateFolder(material->getFolderPath());
+    folder->instances[material->getName()] = std::move(material);
 }
 
 AssetRegistry::AssetFolder* AssetRegistry::getOrCreateFolder(std::string fullPath)

src/Engine/Asset/AssetRegistry.h

@@ -10,8 +10,8 @@ DECLARE_REF(TextureAsset)
 DECLARE_REF(FontAsset)
 DECLARE_REF(MeshAsset)
 DECLARE_REF(MaterialAsset)
+DECLARE_REF(MaterialInstanceAsset)
 DECLARE_NAME_REF(Gfx, Graphics)
-
 class AssetRegistry
 {
 public:
@@ -24,6 +24,7 @@ public:
     static PTextureAsset findTexture(const std::string& filePath);
     static PFontAsset findFont(const std::string& name);
     static PMaterialAsset findMaterial(const std::string& filePath);
+    static PMaterialInstanceAsset findMaterialInstance(const std::string& filePath);
 
     static std::ofstream createWriteStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode = std::ios::out);
     static std::ifstream createReadStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode = std::ios::in);
@@ -36,10 +37,11 @@ public:
     {
         std::string folderPath;
         Map<std::string, AssetFolder*> children;
-        Map<std::string, PTextureAsset> textures;
-        Map<std::string, PFontAsset> fonts;
-        Map<std::string, PMeshAsset> meshes;
-        Map<std::string, PMaterialAsset> materials;
+        Map<std::string, OTextureAsset> textures;
+        Map<std::string, OFontAsset> fonts;
+        Map<std::string, OMeshAsset> meshes;
+        Map<std::string, OMaterialAsset> materials;
+        Map<std::string, OMaterialInstanceAsset> instances;
         AssetFolder(std::string_view folderPath);
         ~AssetFolder();
     };
@@ -59,10 +61,11 @@ private:
     void saveFolder(const std::filesystem::path& folderPath, AssetFolder* folder);
     void saveAsset(PAsset asset, uint64 identifier, const std::filesystem::path& folderPath, std::string name);
 
-    void registerMesh(PMeshAsset mesh);
-    void registerTexture(PTextureAsset texture);
-    void registerFont(PFontAsset font);
-    void registerMaterial(PMaterialAsset material);
+    void registerMesh(OMeshAsset mesh);
+    void registerTexture(OTextureAsset texture);
+    void registerFont(OFontAsset font);
+    void registerMaterial(OMaterialAsset material);
+    void registerMaterialInstance(OMaterialInstanceAsset instance);
 
     std::ofstream internalCreateWriteStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode = std::ios::out);
     std::ifstream internalCreateReadStream(const std::filesystem::path& relaitvePath, std::ios_base::openmode openmode = std::ios::in);

src/Engine/Asset/FontAsset.cpp

@@ -117,7 +117,9 @@ void FontAsset::load(ArchiveBuffer& buffer)
             .usage = Gfx::SE_IMAGE_USAGE_SAMPLED_BIT,
         };
 
-        glyph.texture = buffer.getGraphics()->createTexture2D(createInfo);
+        Gfx::OTexture2D texture = buffer.getGraphics()->createTexture2D(createInfo);
+        glyph.texture = texture;
+        usedTextures.add(std::move(texture));
 
         ktxTexture_Destroy(ktxTexture(kTexture));
 

src/Engine/Asset/FontAsset.h

@@ -18,13 +18,14 @@ public:
 
     struct Glyph
     {
-        Gfx::OTexture2D texture;
+        Gfx::PTexture2D texture;
         IVector2 size;
         IVector2 bearing;
         uint32 advance;
     };
     const Map<uint32, Glyph> getGlyphData() const { return glyphs; }
 private:
+    Array<Gfx::OTexture2D> usedTextures;
     Map<uint32, Glyph> glyphs;
     friend class FontLoader;
 };

src/Engine/Asset/MaterialAsset.cpp

@@ -1,6 +1,7 @@
 #include "MaterialAsset.h"
 #include "Material/Material.h"
 #include "Graphics/Graphics.h"
+#include "MaterialInstanceAsset.h"
 
 using namespace Seele;
 
@@ -29,3 +30,13 @@ void MaterialAsset::load(ArchiveBuffer& buffer)
     material->compile();
 }
 
+OMaterialInstanceAsset Seele::MaterialAsset::instantiate(const InstantiationParameter& params)
+{
+    OMaterialInstance instance = material->instantiate();
+    instance->setBaseMaterial(this);
+    OMaterialInstanceAsset asset = new MaterialInstanceAsset(params.folderPath, params.name);
+    asset->setHandle(std::move(instance));
+    return asset;
+}
+
+

src/Engine/Asset/MaterialAsset.h

@@ -4,6 +4,12 @@
 namespace Seele
 {
 DECLARE_REF(Material)
+DECLARE_REF(MaterialInstanceAsset)
+struct InstantiationParameter
+{
+    std::string name;
+    std::string folderPath;
+};
 class MaterialAsset : public Asset
 {
 public:
@@ -14,8 +20,9 @@ public:
     virtual void save(ArchiveBuffer& buffer) const override;
     virtual void load(ArchiveBuffer& buffer) override;
     PMaterial getMaterial() const { return material; }
+    OMaterialInstanceAsset instantiate(const InstantiationParameter& params);
 private:
-    PMaterial material;
+    OMaterial material;
     friend class MaterialLoader;
 };
 DEFINE_REF(MaterialAsset)

src/Engine/Asset/MaterialInstanceAsset.cpp

@@ -2,6 +2,7 @@
 #include "Material/MaterialInstance.h"
 #include "Material/Material.h"
 #include "Graphics/Graphics.h"
+#include "Asset/AssetRegistry.h"
 
 using namespace Seele;
 
@@ -21,8 +22,15 @@ MaterialInstanceAsset::~MaterialInstanceAsset()
 
 void MaterialInstanceAsset::save(ArchiveBuffer& buffer) const
 {
+    Serialization::save(buffer, baseMaterial->getAssetIdentifier());
+    material->save(buffer);
 }
 
 void MaterialInstanceAsset::load(ArchiveBuffer& buffer)
 {
+    std::string id;
+    Serialization::load(buffer, id);
+    material->load(buffer);
+    baseMaterial = AssetRegistry::findMaterial(id);
+    material->setBaseMaterial(baseMaterial);
 }

src/Engine/Asset/MaterialInstanceAsset.h

@@ -13,8 +13,11 @@ public:
     virtual ~MaterialInstanceAsset();
     virtual void save(ArchiveBuffer& buffer) const override;
     virtual void load(ArchiveBuffer& buffer) override;
+    void setHandle(OMaterialInstance handle) { material = std::move(handle); }
+    void setBase(PMaterialAsset base) { baseMaterial = base; }
 private:
-    PMaterialInstance material;
+    OMaterialInstance material;
+    PMaterialAsset baseMaterial;
 };
 DEFINE_REF(MaterialInstanceAsset)
 } // namespace Seele

src/Engine/Asset/MeshAsset.h

@@ -16,7 +16,7 @@ public:
     virtual void save(ArchiveBuffer& buffer) const override;
     virtual void load(ArchiveBuffer& buffer) override;
     //Workaround while no editor
-    Array<PMesh> meshes;
+    Array<OMesh> meshes;
     Component::Collider physicsMesh;
 };
 DEFINE_REF(MeshAsset)

src/Engine/Asset/TextureAsset.h

@@ -13,16 +13,16 @@ public:
     virtual ~TextureAsset();
     virtual void save(ArchiveBuffer& buffer) const override;
     virtual void load(ArchiveBuffer& buffer) override;
-    void setTexture(Gfx::PTexture _texture)
+    void setTexture(Gfx::OTexture _texture)
     {
-        texture = _texture;
+        texture = std::move(_texture);
     }
     Gfx::PTexture getTexture()
     {
         return texture;
     }
 private:
-    Gfx::PTexture texture;
+    Gfx::OTexture texture;
     friend class TextureLoader;
 };
 DEFINE_REF(TextureAsset)