implemented basic shader expressions

src/Engine/Asset/Asset.cpp

@@ -31,6 +31,13 @@ Asset::~Asset()
 {
 }
 
+void Asset::updateByteSize()
+{
+    ArchiveBuffer buffer;
+    save(buffer);
+    byteSize = buffer.size();
+}
+
 std::string Asset::getFolderPath() const
 {
     return folderPath;

src/Engine/Asset/Asset.h

@@ -18,6 +18,8 @@ public:
     Asset(std::string_view folderPath, std::string_view name);
     virtual ~Asset();
 
+    void updateByteSize();
+
     virtual void save(ArchiveBuffer& buffer) const = 0;
     virtual void load(ArchiveBuffer& buffer) = 0;
     
@@ -27,6 +29,8 @@ public:
     std::string getFolderPath() const;
     // returns the identifier with which it can be found from the asset registry
     std::string getAssetIdentifier() const;
+    // returns the size of the assets data in bytes(excluding name and folder)
+    uint64 getByteSize() const { return byteSize; }
 
     constexpr Status getStatus() 
     {
@@ -41,7 +45,7 @@ protected:
     std::string name;
     std::string assetId;
     Status status;
-    uint32 byteSize;
+    uint64 byteSize;
 };
 DEFINE_REF(Asset)
 } // namespace Seele

src/Engine/Asset/AssetRegistry.cpp

@@ -4,10 +4,6 @@
 #include "TextureAsset.h"
 #include "MaterialAsset.h"
 #include "MaterialInstanceAsset.h"
-#include "FontLoader.h"
-#include "TextureLoader.h"
-#include "MaterialLoader.h"
-#include "MeshLoader.h"
 #include "Graphics/Mesh.h"
 #include "Graphics/Graphics.h"
 #include "Window/WindowManager.h"
@@ -29,46 +25,6 @@ void AssetRegistry::init(const std::string& rootFolder, Gfx::PGraphics graphics)
     get().initialize(rootFolder, graphics);
 }
 
-void AssetRegistry::importMesh(MeshImportArgs args)
-{
-    if (get().getOrCreateFolder(args.importPath)->meshes.contains(args.filePath.stem().string()))
-    {
-        // skip importing duplicates
-        return;
-    }
-    get().meshLoader->importAsset(args);
-}
-
-void AssetRegistry::importTexture(TextureImportArgs args)
-{
-    if (get().getOrCreateFolder(args.importPath)->textures.contains(args.filePath.stem().string()))
-    {
-        // skip importing duplicates
-        return;
-    }
-    get().textureLoader->importAsset(args);
-}
-
-void AssetRegistry::importFont(FontImportArgs args)
-{
-    if (get().getOrCreateFolder(args.importPath)->fonts.contains(args.filePath.stem().string()))
-    {
-        // skip importing duplicates
-        return;
-    }
-    get().fontLoader->importAsset(args);
-}
-
-void AssetRegistry::importMaterial(MaterialImportArgs args)
-{
-    if (get().getOrCreateFolder(args.importPath)->materials.contains(args.filePath.stem().string()))
-    {
-        // skip importing duplicates
-        return;
-    }
-    get().materialLoader->importAsset(args);
-}
-
 PMeshAsset AssetRegistry::findMesh(const std::string &filePath)
 {
     AssetFolder* folder = get().assetRoot;
@@ -150,15 +106,12 @@ void AssetRegistry::saveRegistry()
     get().saveRegistryInternal();
 }
 
+
 void AssetRegistry::initialize(const std::filesystem::path &_rootFolder, Gfx::PGraphics _graphics)
 {
     this->graphics = _graphics;
     this->rootFolder = _rootFolder;
     this->assetRoot = new AssetFolder("");
-    this->fontLoader = new FontLoader(graphics);
-    this->meshLoader = new MeshLoader(graphics);
-    this->textureLoader = new TextureLoader(graphics);
-    this->materialLoader = new MaterialLoader(graphics);
     loadRegistryInternal();
 }
 
@@ -168,7 +121,6 @@ void AssetRegistry::loadRegistryInternal()
     loadFolder(assetRoot);
 }
 
-
 void AssetRegistry::peekFolder(AssetFolder* folder)
 {
     for (const auto& entry : std::filesystem::directory_iterator(rootFolder / folder->folderPath))
@@ -192,49 +144,10 @@ void AssetRegistry::peekFolder(AssetFolder* folder)
 
         ArchiveBuffer buffer(graphics);
         buffer.readFromStream(stream);
-
-        // Read asset type
-        uint64 identifier;
-        Serialization::load(buffer, identifier);
-
-        // Read name
-        std::string name;
-        Serialization::load(buffer, name);
-
-        // Read folder
-        std::string folderPath;
-        Serialization::load(buffer, folderPath);
-
-        PAsset asset;
-        switch (identifier)
-        {
-        case TextureAsset::IDENTIFIER:
-            asset = new TextureAsset(folderPath, name);
-            folder->textures[asset->getName()] = asset;
-            break;
-        case MeshAsset::IDENTIFIER:
-            asset = new MeshAsset(folderPath, name);
-            folder->meshes[asset->getName()] = asset;
-            break;
-        case MaterialAsset::IDENTIFIER:
-            asset = new MaterialAsset(folderPath, name);
-            folder->materials[asset->getName()] = asset;
-            break;
-        case MaterialInstanceAsset::IDENTIFIER:
-            asset = new MaterialInstanceAsset(folderPath, name);
-            // TODO
-            break;
-        case FontAsset::IDENTIFIER:
-            asset = new FontAsset(folderPath, name);
-            folder->fonts[asset->getName()] = asset;
-            break;
-        default:
-            throw new std::logic_error("Unknown Identifier");
-        }
+        peekAsset(buffer);
     }
 }
 
-
 void AssetRegistry::loadFolder(AssetFolder* folder)
 {
     for (const auto& entry : std::filesystem::directory_iterator(rootFolder / folder->folderPath))
@@ -251,45 +164,101 @@ void AssetRegistry::loadFolder(AssetFolder* folder)
 
         ArchiveBuffer buffer(graphics);
         buffer.readFromStream(stream);
-
-        // Read asset type
-        uint64 identifier;
-        Serialization::load(buffer, identifier);
-
-        // Read name
-        std::string name;
-        Serialization::load(buffer, name);
-        
-        // Read folder
-        std::string folderPath;
-        Serialization::load(buffer, folderPath);
-
-        PAsset asset;
-        switch (identifier)
-        {
-        case TextureAsset::IDENTIFIER:
-            asset = folder->textures.at(name);
-            break;
-        case MeshAsset::IDENTIFIER:
-            asset = folder->meshes.at(name);
-            break;
-        case MaterialAsset::IDENTIFIER:
-            asset = folder->materials.at(name);
-            break;
-        case MaterialInstanceAsset::IDENTIFIER:
-            //asset = new MaterialInstanceAsset(path);
-            // TODO
-            break;
-        case FontAsset::IDENTIFIER:
-            asset = folder->fonts.at(name);
-            break;
-        default:
-            throw new std::logic_error("Unknown Identifier");
-        }
-        asset->load(buffer);
+        loadAsset(buffer);
     }
 }
 
+void AssetRegistry::peekAsset(ArchiveBuffer& buffer)
+{
+    // Read asset type
+    uint64 identifier;
+    Serialization::load(buffer, identifier);
+
+    // Read name
+    std::string name;
+    Serialization::load(buffer, name);
+
+    // Read folder
+    std::string folderPath;
+    Serialization::load(buffer, folderPath);
+
+    uint64 assetSize;
+    Serialization::load(buffer, assetSize);
+
+    AssetFolder* folder = getOrCreateFolder(folderPath);
+
+    PAsset asset;
+    switch (identifier)
+    {
+    case TextureAsset::IDENTIFIER:
+        asset = new TextureAsset(folderPath, name);
+        folder->textures[asset->getName()] = asset;
+        break;
+    case MeshAsset::IDENTIFIER:
+        asset = new MeshAsset(folderPath, name);
+        folder->meshes[asset->getName()] = asset;
+        break;
+    case MaterialAsset::IDENTIFIER:
+        asset = new MaterialAsset(folderPath, name);
+        folder->materials[asset->getName()] = asset;
+        break;
+    case MaterialInstanceAsset::IDENTIFIER:
+        asset = new MaterialInstanceAsset(folderPath, name);
+        // TODO
+        break;
+    case FontAsset::IDENTIFIER:
+        asset = new FontAsset(folderPath, name);
+        folder->fonts[asset->getName()] = asset;
+        break;
+    default:
+        throw new std::logic_error("Unknown Identifier");
+    }
+}
+
+void AssetRegistry::loadAsset(ArchiveBuffer& buffer)
+{
+    // Read asset type
+    uint64 identifier;
+    Serialization::load(buffer, identifier);
+
+    // Read name
+    std::string name;
+    Serialization::load(buffer, name);
+
+    // Read folder
+    std::string folderPath;
+    Serialization::load(buffer, folderPath);
+
+    uint64 assetSize;
+    Serialization::load(buffer, assetSize);
+
+    AssetFolder* folder = getOrCreateFolder(folderPath);
+
+    PAsset asset;
+    switch (identifier)
+    {
+    case TextureAsset::IDENTIFIER:
+        asset = folder->textures.at(name);
+        break;
+    case MeshAsset::IDENTIFIER:
+        asset = folder->meshes.at(name);
+        break;
+    case MaterialAsset::IDENTIFIER:
+        asset = folder->materials.at(name);
+        break;
+    case MaterialInstanceAsset::IDENTIFIER:
+        //asset = new MaterialInstanceAsset(path);
+        // TODO
+        break;
+    case FontAsset::IDENTIFIER:
+        asset = folder->fonts.at(name);
+        break;
+    default:
+        throw new std::logic_error("Unknown Identifier");
+    }
+    asset->load(buffer);
+}
+
 void AssetRegistry::saveRegistryInternal()
 {   
     saveFolder("", assetRoot);
@@ -334,6 +303,9 @@ void AssetRegistry::saveAsset(PAsset asset, uint64 identifier, const std::filesy
     Serialization::save(assetBuffer, name);
     // write folder
     Serialization::save(assetBuffer, folderPath.string());
+    // write the asset size
+    asset->updateByteSize();
+    Serialization::save(assetBuffer, asset->getByteSize());
     // write asset data
     asset->save(assetBuffer);
     assetBuffer.writeToStream(assetStream);
@@ -420,3 +392,4 @@ AssetRegistry::AssetFolder::~AssetFolder()
         delete child;
     }
 }
+

src/Engine/Asset/AssetRegistry.h

@@ -6,10 +6,6 @@
 
 namespace Seele
 {
-DECLARE_REF(TextureLoader)
-DECLARE_REF(FontLoader)
-DECLARE_REF(MeshLoader)
-DECLARE_REF(MaterialLoader)
 DECLARE_REF(TextureAsset)
 DECLARE_REF(FontAsset)
 DECLARE_REF(MeshAsset)
@@ -32,22 +28,14 @@ public:
     static std::ofstream createWriteStream(const std::string& relativePath, std::ios_base::openmode openmode = std::ios::out);
     static std::ifstream createReadStream(const std::string& relativePath, std::ios_base::openmode openmode = std::ios::in);
 
-    static void importMesh(struct MeshImportArgs args);
-    static void importTexture(struct TextureImportArgs args);
-    static void importFont(struct FontImportArgs args);
-    static void importMaterial(struct MaterialImportArgs args);
     static void set(AssetRegistry registry);
 
     static void loadRegistry();
     static void saveRegistry();
-
-    AssetRegistry();
-private:
     struct AssetFolder
     {
         std::string folderPath;
         Map<std::string, AssetFolder*> children;
-        //Todo: Seele::Map doesn't really work with strings for some reason, so just use std::map for now
         Map<std::string, PTextureAsset> textures;
         Map<std::string, PFontAsset> fonts;
         Map<std::string, PMeshAsset> meshes;
@@ -55,13 +43,17 @@ private:
         AssetFolder(std::string_view folderPath);
         ~AssetFolder();
     };
-
+    AssetFolder* getOrCreateFolder(std::string foldername);
+    AssetRegistry();
+private:
     static AssetRegistry& get();
 
     void initialize(const std::filesystem::path& rootFolder, Gfx::PGraphics graphics);
     void loadRegistryInternal();
     void peekFolder(AssetFolder* folder);
     void loadFolder(AssetFolder* folder);
+    void peekAsset(ArchiveBuffer& buffer);
+    void loadAsset(ArchiveBuffer& buffer);
     void saveRegistryInternal();
     void saveFolder(const std::filesystem::path& folderPath, AssetFolder* folder);
     void saveAsset(PAsset asset, uint64 identifier, const std::filesystem::path& folderPath, std::string name);
@@ -71,18 +63,14 @@ private:
     void registerFont(PFontAsset font);
     void registerMaterial(PMaterialAsset material);
 
-    AssetFolder* getOrCreateFolder(std::string foldername);
-
     std::ofstream internalCreateWriteStream(const std::string& relativePath, std::ios_base::openmode openmode = std::ios::out);
     std::ifstream internalCreateReadStream(const std::string& relaitvePath, std::ios_base::openmode openmode = std::ios::in);
 
     std::filesystem::path rootFolder;
     AssetFolder* assetRoot;
     Gfx::PGraphics graphics;
-    UPTextureLoader textureLoader;
-    UPFontLoader fontLoader;
-    UPMeshLoader meshLoader;
-    UPMaterialLoader materialLoader;
+    ArchiveBuffer assetBuffer;
+    bool release = false;
     friend class TextureLoader;
     friend class FontLoader;
     friend class MaterialLoader;

src/Engine/Asset/CMakeLists.txt

@@ -6,22 +6,14 @@ target_sources(Engine
         AssetRegistry.cpp
         FontAsset.h
         FontAsset.cpp
-        FontLoader.h
-        FontLoader.cpp
         MaterialAsset.h
         MaterialAsset.cpp
         MaterialInstanceAsset.h
         MaterialInstanceAsset.cpp
-        MaterialLoader.h
-        MaterialLoader.cpp
         MeshAsset.h
         MeshAsset.cpp
-        MeshLoader.h
-        MeshLoader.cpp
         TextureAsset.h
-        TextureAsset.cpp
-        TextureLoader.h
-        TextureLoader.cpp)
+        TextureAsset.cpp)
 
 target_sources(Engine
     PUBLIC FILE_SET HEADERS
@@ -29,11 +21,7 @@ target_sources(Engine
             Asset.h
             AssetRegistry.h
             FontAsset.h
-            FontLoader.h
             MaterialAsset.h
             MaterialInstanceAsset.h
-            MaterialLoader.h
             MeshAsset.h
-            MeshLoader.h
-            TextureAsset.h
-            TextureLoader.h)
+            TextureAsset.h)

src/Engine/Asset/FontAsset.cpp

@@ -22,10 +22,9 @@ FontAsset::~FontAsset()
 void FontAsset::save(ArchiveBuffer& buffer) const
 {
     uint64 numGlyphs = glyphs.size();
-    buffer.writeBytes(&numGlyphs, sizeof(uint64));
+    Serialization::save(buffer, numGlyphs);
     for (auto& [index, glyph] : glyphs)
     {
-        Serialization::save(buffer, index);
 
         Array<uint8> textureData;
         ktxTexture2* kTexture;
@@ -36,6 +35,7 @@ void FontAsset::save(ArchiveBuffer& buffer) const
             .baseDepth = glyph.texture->getSizeZ(),
             .numDimensions = glyph.texture->getSizeZ() > 1 ? 3u : glyph.texture->getSizeY() > 1 ? 2u : 1u,
             .numLevels = glyph.texture->getMipLevels(),
+            .numLayers = glyph.texture->getSizeZ(),
             .numFaces = glyph.texture->getNumFaces(),
             .isArray = false,
             .generateMipmaps = false,
@@ -64,9 +64,13 @@ void FontAsset::save(ArchiveBuffer& buffer) const
         ktx_size_t texSize;
         ktxTexture_WriteToMemory(ktxTexture(kTexture), &texData, &texSize);
 
-        buffer.writeBytes(texData, texSize);
+        Array<uint8> rawData(texSize);
+        std::memcpy(rawData.data(), texData, texSize);
+
         free(texData);
 
+        Serialization::save(buffer, index);
+        Serialization::save(buffer, rawData);
         Serialization::save(buffer, glyph.size);
         Serialization::save(buffer, glyph.bearing);
         Serialization::save(buffer, glyph.advance);
@@ -77,7 +81,7 @@ void FontAsset::save(ArchiveBuffer& buffer) const
 void FontAsset::load(ArchiveBuffer& buffer)
 {
     uint64 numGlyphs = glyphs.size();
-    buffer.readBytes(&numGlyphs, sizeof(uint64));
+    Serialization::load(buffer, numGlyphs);
     for (uint64 x = 0; x < numGlyphs; ++x)
     {
         uint32 index;
@@ -85,11 +89,8 @@ void FontAsset::load(ArchiveBuffer& buffer)
 
         Glyph& glyph = glyphs[index];
 
-        uint64 texSize;
-        buffer.readBytes(&texSize, sizeof(uint64));
         Array<uint8> rawTex;
-        rawTex.resize(texSize);
-        buffer.readBytes(rawTex.data(), rawTex.size());
+        Serialization::load(buffer, rawTex);
 
         ktxTexture2* kTexture;
         ktxTexture2_CreateFromMemory(rawTex.data(),

src/Engine/Asset/FontLoader.cpp

@@ -1,76 +0,0 @@
-#include "FontLoader.h"
-#include "Graphics/Graphics.h"
-#include "FontAsset.h"
-#include "AssetRegistry.h"
-#include "Graphics/GraphicsResources.h"
-#include <ft2build.h>
-#include FT_FREETYPE_H
-
-using namespace Seele;
-
-FontLoader::FontLoader(Gfx::PGraphics graphics)
-    : graphics(graphics)
-{
-    
-}
-
-FontLoader::~FontLoader()
-{
-}
-
-void FontLoader::importAsset(FontImportArgs args)
-{
-    std::filesystem::path assetPath = args.filePath.filename();
-    assetPath.replace_extension("asset");
-    PFontAsset asset = new FontAsset(args.importPath, assetPath.stem().string());
-    asset->setStatus(Asset::Status::Loading);
-    AssetRegistry::get().registerFont(asset);
-    import(args, asset);
-}
-
-// in case of the space character there is no bitmap
-// so we create a single pixel empty texture
-uint8 transparentPixel = 0;
-void FontLoader::import(FontImportArgs args, PFontAsset asset)
-{
-    FT_Library ft;
-    FT_Error error = FT_Init_FreeType(&ft);
-    assert(!error);
-    FT_Face face;
-    error = FT_New_Face(ft, args.filePath.string().c_str(), 0, &face);
-    assert(!error);
-    FT_Set_Pixel_Sizes(face, 0, 48);
-    for(uint32 c = 0; c < 256; ++c)
-    {
-        if(FT_Load_Char(face, c, FT_LOAD_RENDER))
-        {
-            std::cout << "error loading " << (char)c << std::endl;
-            continue;
-        }
-        FontAsset::Glyph& glyph = asset->glyphs[c];
-        glyph.size = IVector2(face->glyph->bitmap.width, face->glyph->bitmap.rows);
-        glyph.bearing = IVector2(face->glyph->bitmap_left, face->glyph->bitmap_top);
-        glyph.advance = face->glyph->advance.x;
-        TextureCreateInfo imageData;
-        imageData.format = Gfx::SE_FORMAT_R8_UINT;
-        imageData.width = face->glyph->bitmap.width;
-        imageData.height = face->glyph->bitmap.rows;
-        imageData.resourceData.data = face->glyph->bitmap.buffer;
-        imageData.resourceData.size = imageData.width * imageData.height;
-        if(imageData.width == 0 || imageData.height == 0)
-        {
-            glyph.size.x = 1;
-            glyph.size.y = 1;
-            glyph.bearing.x = 0;
-            glyph.bearing.y = 0;
-            imageData.width = 1;
-            imageData.height = 1;
-            imageData.resourceData.size = sizeof(uint8);
-            imageData.resourceData.data = &transparentPixel;
-        }
-        glyph.texture = graphics->createTexture2D(imageData);
-    }
-    FT_Done_Face(face);
-    FT_Done_FreeType(ft);
-    asset->setStatus(Asset::Status::Ready);
-}

src/Engine/Asset/FontLoader.h

@@ -1,26 +0,0 @@
-#pragma once
-#include "MinimalEngine.h"
-#include "Containers/List.h"
-#include <filesystem>
-
-namespace Seele
-{
-DECLARE_REF(FontAsset)
-DECLARE_NAME_REF(Gfx, Graphics)
-struct FontImportArgs
-{
-    std::filesystem::path filePath;
-    std::string importPath;
-};
-class FontLoader
-{
-public:
-    FontLoader(Gfx::PGraphics graphic);
-    ~FontLoader();
-    void importAsset(FontImportArgs args);
-private:
-    void import(FontImportArgs args, PFontAsset asset);
-    Gfx::PGraphics graphics;
-};
-DEFINE_REF(FontLoader)
-} // namespace Seele

src/Engine/Asset/MaterialLoader.cpp

@@ -1,149 +0,0 @@
-#include "MaterialLoader.h"
-#include "Graphics/Graphics.h"
-#include "MaterialAsset.h"
-#include "AssetRegistry.h"
-#include "Material/Material.h"
-#include "Material/BRDF.h"
-#include "Window/WindowManager.h"
-#include "Material/ShaderExpression.h"
-#include "TextureAsset.h"
-#include <nlohmann/json.hpp>
-
-using namespace Seele;
-using json = nlohmann::json;
-
-MaterialLoader::MaterialLoader(Gfx::PGraphics graphics)
-    : graphics(graphics)
-{
-    importAsset(MaterialImportArgs{
-        .filePath = std::filesystem::absolute("./shaders/Placeholder.asset"),
-        .importPath = "",
-        });
-}
-
-MaterialLoader::~MaterialLoader()
-{
-}
-
-void MaterialLoader::importAsset(MaterialImportArgs args)
-{
-    std::filesystem::path assetPath = args.filePath.filename();
-    assetPath.replace_extension("asset");
-    PMaterialAsset asset = new MaterialAsset(args.importPath, assetPath.stem().string());
-    asset->setStatus(Asset::Status::Loading);
-    AssetRegistry::get().registerMaterial(asset);
-    import(args, asset);
-}
-
-void MaterialLoader::import(MaterialImportArgs args, PMaterialAsset asset)
-{
-    auto stream = std::ifstream(args.filePath.c_str());
-    json j;
-    stream >> j;
-    std::string materialName = j["name"].get<std::string>() + "Material";
-    Gfx::PDescriptorLayout layout = graphics->createDescriptorLayout(materialName + "Layout");
-    //Shader file needs to conform to the slang standard, which prohibits _
-    materialName.erase(std::remove(materialName.begin(), materialName.end(), '_'), materialName.end());
-    materialName.erase(std::remove(materialName.begin(), materialName.end(), '.'), materialName.end());
-    std::ofstream codeStream("./shaders/generated/"+materialName+".slang");
-    std::string profile = j["profile"].get<std::string>();
-
-    codeStream << "import Material;" << std::endl;
-    codeStream << "import BRDF;" << std::endl;
-    codeStream << "import MaterialParameter;" << std::endl << std::endl;
-
-    codeStream << "struct " << materialName << " : IMaterial {" << std::endl;
-    uint32 uniformBufferOffset = 0;
-    uint32 bindingCounter = 0; // Uniform buffers are always binding 0
-    uint32 uniformBinding = -1;
-    Array<PShaderParameter> parameters;
-    for(auto param : j["params"].items())
-    {
-        std::string type = param.value()["type"].get<std::string>();
-        auto defaultValue = param.value().find("default");
-        // TODO: ALIGNMENT RULES
-        if(type.compare("float") == 0)
-        {
-            PFloatParameter p = new FloatParameter(param.key(), uniformBufferOffset, 0);
-            codeStream << "\tlayout(offset = " << uniformBufferOffset << ")";
-            if(uniformBinding == -1)
-            {
-                layout->addDescriptorBinding(bindingCounter, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
-                uniformBinding = bindingCounter++;
-            }
-            uniformBufferOffset += 4;
-            if(defaultValue != param.value().end())
-            {
-                p->data = std::stof(defaultValue.value().get<std::string>());
-            }
-            parameters.add(p);
-        }
-        // TODO: ALIGNMENT RULES
-        else if(type.compare("float3") == 0)
-        {
-            PVectorParameter p = new VectorParameter(param.key(), uniformBufferOffset, 0);
-            codeStream << "\tlayout(offset = " << uniformBufferOffset << ")";
-            if(uniformBinding == -1)
-            {
-                layout->addDescriptorBinding(bindingCounter, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
-                uniformBinding = bindingCounter++;
-            }
-            uniformBufferOffset += 12;
-            if(defaultValue != param.value().end())
-            {
-                p->data = parseVector(defaultValue.value().get<std::string>().c_str());
-            }
-            parameters.add(p);
-        }
-        else if(type.compare("Texture2D") == 0)
-        {
-            PTextureParameter p = new TextureParameter(param.key(), 0, bindingCounter);
-            layout->addDescriptorBinding(bindingCounter++, Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
-            if(defaultValue != param.value().end())
-            {
-                std::string defaultString = defaultValue.value().get<std::string>();
-                p->data = AssetRegistry::findTexture(defaultString);
-            }
-            if(p->data == nullptr)
-            {
-                p->data = AssetRegistry::findTexture(""); // this will return placeholder texture
-            }
-            parameters.add(p);
-        }
-        else if(type.compare("SamplerState") == 0)
-        {
-            PSamplerParameter p = new SamplerParameter(param.key(), 0, bindingCounter);
-            layout->addDescriptorBinding(bindingCounter++, Gfx::SE_DESCRIPTOR_TYPE_SAMPLER);
-            p->data = graphics->createSamplerState({});
-            parameters.add(p);
-        }
-        else
-        {
-            std::cout << "Error unsupported parameter type" << std::endl;
-        }
-        codeStream << "\t" << type << " " << param.key() << ";\n";
-    }
-    uint32 uniformDataSize = uniformBufferOffset;
-    
-    BRDF* brdf = BRDF::getBRDFByName(profile);
-    brdf->generateMaterialCode(codeStream, j["code"]);
-    codeStream << "};";
-    codeStream.close();
-    layout->create();
-    asset->material = new Material(
-        graphics,
-        std::move(parameters),
-        std::move(layout),
-        uniformDataSize,
-        uniformBinding,
-        materialName
-    );
-    graphics->getShaderCompiler()->registerMaterial(asset->material);
-    asset->setStatus(Asset::Status::Ready);
-    ////co_return;
-}
-
-PMaterialAsset MaterialLoader::getPlaceHolderMaterial() 
-{
-    return placeholderMaterial;
-}

src/Engine/Asset/MaterialLoader.h

@@ -1,28 +0,0 @@
-#pragma once
-#include "MinimalEngine.h"
-#include "Containers/List.h"
-#include <filesystem>
-
-namespace Seele
-{
-DECLARE_REF(MaterialAsset)
-DECLARE_NAME_REF(Gfx, Graphics)
-struct MaterialImportArgs
-{
-    std::filesystem::path filePath;
-    std::string importPath;
-};
-class MaterialLoader
-{
-public:
-    MaterialLoader(Gfx::PGraphics graphic);
-    ~MaterialLoader();
-    void importAsset(MaterialImportArgs args);
-    PMaterialAsset getPlaceHolderMaterial();
-private:
-    void import(MaterialImportArgs args, PMaterialAsset asset);
-    Gfx::PGraphics graphics;
-    PMaterialAsset placeholderMaterial;
-};
-DEFINE_REF(MaterialLoader)
-} // namespace Seele

src/Engine/Asset/MeshLoader.cpp

@@ -1,311 +0,0 @@
-#include "MeshLoader.h"
-#include "Graphics/GraphicsResources.h"
-#include "Graphics/Graphics.h"
-#include "MeshAsset.h"
-#include "Graphics/Mesh.h"
-#include "Graphics/StaticMeshVertexInput.h"
-#include "AssetRegistry.h"
-#include "MaterialAsset.h"
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <stb_image_write.h>
-#include <assimp/config.h>
-#include <assimp/Importer.hpp>
-#include <assimp/scene.h>
-#include <assimp/postprocess.h>
-#include <assimp/material.h>
-#include <Asset/MaterialLoader.h>
-#include <Asset/TextureLoader.h>
-
-using namespace Seele;
-
-MeshLoader::MeshLoader(Gfx::PGraphics graphics)
-    : graphics(graphics)
-{
-}
-
-MeshLoader::~MeshLoader()
-{
-}
-
-void MeshLoader::importAsset(MeshImportArgs args)
-{
-    std::filesystem::path assetPath = args.filePath.filename();
-    assetPath.replace_extension("asset");
-    PMeshAsset asset = new MeshAsset(args.importPath, assetPath.stem().string());
-    asset->setStatus(Asset::Status::Loading);
-    AssetRegistry::get().registerMesh(asset);
-    import(args, asset);
-}
-
-void MeshLoader::loadMaterials(const aiScene* scene, const std::string& baseName, const std::filesystem::path& meshDirectory, const std::string& importPath, Array<PMaterialAsset>& globalMaterials)
-{
-    using json = nlohmann::json;
-    for(uint32 i = 0; i < scene->mNumMaterials; ++i)
-    {
-        aiMaterial* material = scene->mMaterials[i];
-        json matCode;
-        matCode["name"] = baseName + material->GetName().C_Str();
-        matCode["profile"] = "BlinnPhong"; //TODO: other shading models
-        aiString texPath;
-        //TODO make samplers based on used textures
-        matCode["params"]["textureSampler"] =
-            {
-                {"type", "SamplerState"}
-            };
-        if(material->GetTexture(aiTextureType_DIFFUSE, 0, &texPath) == AI_SUCCESS)
-        {
-            std::string texFilename = std::filesystem::path(texPath.C_Str()).replace_extension("asset").stem().string();
-            matCode["params"]["diffuseTexture"] = 
-                {
-                    {"type", "Texture2D"}, 
-                    {"default", texFilename}
-                };
-            matCode["code"]["baseColor"] = "return diffuseTexture.Sample(textureSampler, input.texCoords[0]).xyz;";
-        }
-        else
-        {
-            matCode["code"]["baseColor"] = "return input.vertexColor.xyz;";
-        }
-        if(material->GetTexture(aiTextureType_SPECULAR, 0, &texPath) == AI_SUCCESS)
-        {
-            std::string texFilename = std::filesystem::path(texPath.C_Str()).replace_extension("asset").stem().string();
-            matCode["params"]["specularTexture"] =
-                {
-                    {"type", "Texture2D"},
-                    {"default", texFilename}
-                };
-            matCode["code"]["specular"] = "return specularTexture.Sample(textureSampler, input.texCoords[0]).x;";
-        }
-        if(material->GetTexture(aiTextureType_NORMALS, 0, &texPath) == AI_SUCCESS)
-        {
-            std::string texFilename = std::filesystem::path(texPath.C_Str()).replace_extension("asset").stem().string();
-            matCode["params"]["normalTexture"] =
-                {
-                    {"type", "Texture2D"},
-                    {"default", texFilename}
-                };
-            matCode["code"]["normal"] = "return normalTexture.Sample(textureSampler, input.texCoords[0]).xyz;";
-        }
-        std::string outMatFilename = matCode["name"].get<std::string>().append(".asset");
-        std::ofstream outMatFile = std::ofstream(meshDirectory / outMatFilename);
-        outMatFile << std::setw(4) << matCode;
-        outMatFile.flush();
-        outMatFile.close();
-
-        std::cout << "writing json to " << outMatFilename << std::endl;
-        AssetRegistry::importMaterial(MaterialImportArgs{
-            .filePath = meshDirectory / outMatFilename,
-            .importPath = importPath,
-            });
-        globalMaterials[i] = AssetRegistry::findMaterial(matCode["name"].get<std::string>());
-    }
-}
-
-
-void findMeshRoots(aiNode *node, List<aiNode *> &meshNodes)
-{
-    if (node->mNumMeshes > 0)
-    {
-        meshNodes.add(node);
-        return;
-    }
-    for (uint32 i = 0; i < node->mNumChildren; ++i)
-    {
-        findMeshRoots(node->mChildren[i], meshNodes);
-    }
-}
-VertexStreamComponent createVertexStream(uint32 size, aiVector3D* sourceData, Gfx::PGraphics graphics)
-{
-    Array<Vector> buffer(size);
-    for(uint32 i = 0; i < size; ++i)
-    {
-        buffer[i] = Vector(sourceData[i].x, sourceData[i].y, sourceData[i].z);
-    }
-    VertexBufferCreateInfo vbInfo;
-    vbInfo.numVertices = size;
-    vbInfo.vertexSize = sizeof(Vector);
-    vbInfo.resourceData.data = (uint8 *)buffer.data();
-    vbInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
-    vbInfo.resourceData.size = sizeof(Vector) * buffer.size();
-    Gfx::PVertexBuffer vertexBuffer = graphics->createVertexBuffer(vbInfo);
-    vertexBuffer->transferOwnership(Gfx::QueueType::GRAPHICS);
-    return VertexStreamComponent(vertexBuffer, 0, vbInfo.vertexSize, Gfx::SE_FORMAT_R32G32B32_SFLOAT);
-}
-VertexStreamComponent createVertexStream(uint32 size, aiVector2D* sourceData, Gfx::PGraphics graphics)
-{
-    Array<Vector2> buffer(size);
-    for(uint32 i = 0; i < size; ++i)
-    {
-        buffer[i] = Vector2(sourceData[i].x, sourceData[i].y);
-    }    
-    VertexBufferCreateInfo vbInfo;
-    vbInfo.numVertices = size;
-    vbInfo.vertexSize = sizeof(Vector2);
-    vbInfo.resourceData.data = (uint8 *)buffer.data();
-    vbInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
-    vbInfo.resourceData.size = sizeof(Vector2) * buffer.size();
-    Gfx::PVertexBuffer vertexBuffer = graphics->createVertexBuffer(vbInfo);
-    vertexBuffer->transferOwnership(Gfx::QueueType::GRAPHICS);
-    return VertexStreamComponent(vertexBuffer, 0, vbInfo.vertexSize, Gfx::SE_FORMAT_R32G32_SFLOAT);
-}
-VertexStreamComponent createVertexStream(uint32 size, aiColor4D* sourceData, Gfx::PGraphics graphics)
-{
-    Array<Vector4> buffer(size);
-    for(uint32 i = 0; i < size; ++i)
-    {
-        buffer[i] = Vector4(sourceData[i].r, sourceData[i].g, sourceData[i].b, sourceData[i].a);
-    }    
-    VertexBufferCreateInfo vbInfo;
-    vbInfo.numVertices = size;
-    vbInfo.vertexSize = sizeof(Vector4);
-    vbInfo.resourceData.data = (uint8 *)buffer.data();
-    vbInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
-    vbInfo.resourceData.size = sizeof(Vector4) * buffer.size();
-    Gfx::PVertexBuffer vertexBuffer = graphics->createVertexBuffer(vbInfo);
-    vertexBuffer->transferOwnership(Gfx::QueueType::GRAPHICS);
-    return VertexStreamComponent(vertexBuffer, 0, vbInfo.vertexSize, Gfx::SE_FORMAT_R32G32B32A32_SFLOAT);
-}
-void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialAsset>& materials, Array<PMesh>& globalMeshes, Component::Collider& collider)
-{
-    for (uint32 meshIndex = 0; meshIndex < scene->mNumMeshes; ++meshIndex)
-    {
-        aiMesh *mesh = scene->mMeshes[meshIndex];
-        collider.boundingbox.adjust(Vector(mesh->mAABB.mMin.x, mesh->mAABB.mMin.y, mesh->mAABB.mMin.z));
-        collider.boundingbox.adjust(Vector(mesh->mAABB.mMax.x, mesh->mAABB.mMax.y, mesh->mAABB.mMax.z));
-
-        //! \todo duplicate from createVertexStream, clean up
-        Array<Vector> vertices(mesh->mNumVertices);
-        for(uint32 i = 0; i < mesh->mNumVertices; ++i)
-        {
-            vertices[i] = Vector(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z);
-        }
-
-        PStaticMeshVertexInput vertexShaderInput = new StaticMeshVertexInput(std::string(mesh->mName.C_Str()));
-        StaticMeshDataType data;
-        data.positionStream = createVertexStream(mesh->mNumVertices, mesh->mVertices, graphics);
-
-        for(uint32 i = 0; i < MAX_TEXCOORDS; ++i)
-        {
-            if(mesh->HasTextureCoords(i))
-            {
-                data.textureCoordinates[i] = createVertexStream(mesh->mNumVertices, mesh->mTextureCoords[i], graphics);
-            }
-        }
-        if(mesh->HasNormals())
-        {
-            data.tangentBasisComponents[0] = createVertexStream(mesh->mNumVertices, mesh->mNormals, graphics);
-        }
-        if(mesh->HasTangentsAndBitangents())
-        {
-            //TODO: use bitangent to calculate sign for 4th coordinate of tangentstream
-            data.tangentBasisComponents[1] = createVertexStream(mesh->mNumVertices, mesh->mTangents, graphics);
-            data.tangentBasisComponents[2] = createVertexStream(mesh->mNumVertices, mesh->mBitangents, graphics);
-        }
-        if(mesh->HasVertexColors(0))
-        {
-            data.colorComponent = createVertexStream(mesh->mNumVertices, mesh->mColors[0], graphics);
-        }
-        vertexShaderInput->setData(std::move(data));
-        vertexShaderInput->init(graphics);
-
-        Array<uint32> indices(mesh->mNumFaces * 3);
-        for (uint32 faceIndex = 0; faceIndex < mesh->mNumFaces; ++faceIndex)
-        {
-            indices[faceIndex * 3 + 0] = mesh->mFaces[faceIndex].mIndices[0];
-            indices[faceIndex * 3 + 1] = mesh->mFaces[faceIndex].mIndices[1];
-            indices[faceIndex * 3 + 2] = mesh->mFaces[faceIndex].mIndices[2];
-        }
-
-        collider.physicsMesh.addCollider(vertices, indices, Matrix4(1.0f));
-
-        IndexBufferCreateInfo idxInfo;
-        idxInfo.indexType = Gfx::SE_INDEX_TYPE_UINT32;
-        idxInfo.resourceData.data = (uint8 *)indices.data();
-        idxInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
-        idxInfo.resourceData.size = sizeof(uint32) * indices.size();
-        Gfx::PIndexBuffer indexBuffer = graphics->createIndexBuffer(idxInfo);
-        indexBuffer->transferOwnership(Gfx::QueueType::GRAPHICS);
-
-        globalMeshes[meshIndex] = new Mesh(vertexShaderInput, indexBuffer);
-        globalMeshes[meshIndex]->referencedMaterial = materials[mesh->mMaterialIndex];
-    }
-}
-void MeshLoader::convertAssimpARGB(unsigned char* dst, aiTexel* src, uint32 numPixels)
-{
-    for(uint32 i = 0; i < numPixels; ++i)
-    {
-        dst[i * 4 + 0] = src[i].r;
-        dst[i * 4 + 1] = src[i].g;
-        dst[i * 4 + 2] = src[i].b;
-        dst[i * 4 + 3] = src[i].a;
-    }
-}
-void MeshLoader::loadTextures(const aiScene* scene, const std::filesystem::path& meshDirectory, const std::string& importPath)
-{
-    for (uint32 i = 0; i < scene->mNumTextures; ++i)
-    {
-        aiTexture* tex = scene->mTextures[i];
-        auto texPath = std::filesystem::path(tex->mFilename.C_Str());
-        auto texPngPath = meshDirectory;
-        texPngPath.append(texPath.filename().string());
-        if(tex->mHeight == 0)
-        {
-            // already compressed, just dump it to the disk
-            std::ofstream file(texPngPath, std::ios::binary);
-            file.write((const char*)tex->pcData, tex->mWidth);
-            file.flush();
-        }
-        else
-        {
-            // recompress data so that the TextureLoader can read it
-            unsigned char* texData = new unsigned char[tex->mWidth * tex->mHeight * 4];
-            convertAssimpARGB(texData, tex->pcData, tex->mWidth * tex->mHeight);
-            stbi_write_png(texPngPath.string().c_str(), tex->mWidth, tex->mHeight, 4, tex->pcData, tex->mWidth * 32);
-            delete[] texData;
-        }
-        std::cout << "Loading model texture " << texPngPath.string() << std::endl;
-        AssetRegistry::importTexture(TextureImportArgs {
-            .filePath = texPath,
-            .importPath = importPath,
-            });
-    }
-}
-void MeshLoader::import(MeshImportArgs args, PMeshAsset meshAsset)
-{
-    std::cout << "Starting to import "<<args.filePath<< std::endl;
-    meshAsset->setStatus(Asset::Status::Loading);
-    Assimp::Importer importer;
-    importer.ReadFile(args.filePath.string().c_str(), (uint32)(
-        aiProcess_FlipUVs |
-        aiProcess_Triangulate |
-        aiProcess_SortByPType |
-        aiProcess_GenBoundingBoxes |
-        aiProcess_GenSmoothNormals |
-        aiProcess_GenUVCoords |
-        aiProcess_FindDegenerates));
-    const aiScene *scene = importer.ApplyPostProcessing(aiProcess_CalcTangentSpace);
-    
-    Array<PMaterialAsset> globalMaterials(scene->mNumMaterials);
-    loadTextures(scene, args.filePath.parent_path(), args.importPath);
-    loadMaterials(scene, args.filePath.stem().string(), args.filePath.parent_path(), args.importPath, globalMaterials);
-    
-    Array<PMesh> globalMeshes(scene->mNumMeshes);
-    Component::Collider collider;
-    loadGlobalMeshes(scene, globalMaterials, globalMeshes, collider);
-
-    List<aiNode *> meshNodes;
-    findMeshRoots(scene->mRootNode, meshNodes);
-    
-    for (auto meshNode : meshNodes)
-    {
-        for(uint32 i = 0; i < meshNode->mNumMeshes; ++i)
-        {
-            meshAsset->addMesh(globalMeshes[meshNode->mMeshes[i]]);
-        }
-    }
-    meshAsset->physicsMesh = std::move(collider);
-    meshAsset->setStatus(Asset::Status::Ready);
-    std::cout << "Finished loading " << args.filePath<< std::endl;
-}

src/Engine/Asset/MeshLoader.h

@@ -1,36 +0,0 @@
-#pragma once
-#include "MinimalEngine.h"
-#include "Containers/List.h"
-#include "Component/Collider.h"
-#include <filesystem>
-
-struct aiScene;
-struct aiTexel;
-namespace Seele
-{
-DECLARE_REF(Mesh)
-DECLARE_REF(MeshAsset)
-DECLARE_REF(MaterialAsset)
-DECLARE_NAME_REF(Gfx, Graphics)
-struct MeshImportArgs
-{
-    std::filesystem::path filePath;
-    std::string importPath;
-};
-class MeshLoader
-{
-public:
-    MeshLoader(Gfx::PGraphics graphic);
-    ~MeshLoader();
-    void importAsset(MeshImportArgs args);
-private:
-    void loadMaterials(const aiScene* scene, const std::string& baseName, const std::filesystem::path& meshDirectory, const std::string& importPath, Array<PMaterialAsset>& globalMaterials);
-    void loadTextures(const aiScene* scene, const std::filesystem::path& meshDirectory, const std::string& importPath);
-    void loadGlobalMeshes(const aiScene* scene, const Array<PMaterialAsset>& materials, Array<PMesh>& globalMeshes, Component::Collider& collider);
-    void convertAssimpARGB(unsigned char* dst, aiTexel* src, uint32 numPixels);
-
-    void import(MeshImportArgs args, PMeshAsset meshAsset);
-    Gfx::PGraphics graphics;
-};
-DEFINE_REF(MeshLoader)
-} // namespace Seele

src/Engine/Asset/TextureAsset.cpp

@@ -25,7 +25,7 @@ TextureAsset::~TextureAsset()
 
 void TextureAsset::save(ArchiveBuffer& buffer) const
 {
-    Array<uint8> textureData;
+    /*Array<uint8> textureData;
     ktxTexture2* kTexture;
     ktxTextureCreateInfo createInfo = {
         .vkFormat = (uint32_t)texture->getFormat(),
@@ -66,25 +66,28 @@ void TextureAsset::save(ArchiveBuffer& buffer) const
     Array<uint8> rawData(texSize);
     std::memcpy(rawData.data(), texData, texSize);
     free(texData);
-    
-    Serialization::save(buffer, rawData);
+    */
+    Serialization::save(buffer, textureData);
 }
 
 void TextureAsset::load(ArchiveBuffer& buffer) 
 {
-    setStatus(Status::Loading);
-
     Array<uint8> rawData;
     Serialization::load(buffer, rawData);
+    createFromMemory(std::move(rawData), buffer.getGraphics());
+}
 
+void TextureAsset::createFromMemory(Array<uint8> memory, Gfx::PGraphics graphics)
+{
+    textureData = std::move(memory);
     ktxTexture2* kTexture;
     std::cout << "Loading texture " << name << std::endl;
-    KTX_CHECK(ktxTexture_CreateFromMemory(rawData.data(),
-        rawData.size(),
-        KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, 
-        (ktxTexture**) & kTexture));
+    KTX_CHECK(ktxTexture_CreateFromMemory(textureData.data(),
+        textureData.size(),
+        KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT,
+        (ktxTexture**)&kTexture));
 
-    //ktxTexture2_TranscodeBasis(kTexture, KTX_TTF_BC7_RGBA, 0);
+    ktxTexture2_TranscodeBasis(kTexture, KTX_TTF_BC7_RGBA, 0);
 
     TextureCreateInfo createInfo = {
             .resourceData = {
@@ -101,21 +104,18 @@ void TextureAsset::load(ArchiveBuffer& buffer)
             .format = Vulkan::cast((VkFormat)kTexture->vkFormat),
             .usage = Gfx::SE_IMAGE_USAGE_SAMPLED_BIT,
     };
-    Gfx::PTexture tex;
     if (kTexture->isCubemap)
     {
-        tex = buffer.getGraphics()->createTextureCube(createInfo);
+        texture = graphics->createTextureCube(createInfo);
     }
     else if (kTexture->isArray)
     {
-        tex = buffer.getGraphics()->createTexture3D(createInfo);
+        texture = graphics->createTexture3D(createInfo);
     }
     else
     {
-        tex = buffer.getGraphics()->createTexture2D(createInfo);
+        texture = graphics->createTexture2D(createInfo);
     }
-    tex->transferOwnership(Gfx::QueueType::GRAPHICS);
-    setTexture(tex);
+    texture->transferOwnership(Gfx::QueueType::GRAPHICS);
     ktxTexture_Destroy(ktxTexture(kTexture));
-    setStatus(Asset::Status::Ready);
 }

src/Engine/Asset/TextureAsset.h

@@ -13,6 +13,7 @@ public:
     virtual ~TextureAsset();
     virtual void save(ArchiveBuffer& buffer) const override;
     virtual void load(ArchiveBuffer& buffer) override;
+    void createFromMemory(Array<uint8> memory, Gfx::PGraphics graphics);
     void setTexture(Gfx::PTexture _texture)
     {
         texture = _texture;
@@ -22,6 +23,7 @@ public:
         return texture;
     }
 private:
+    Array<uint8> textureData;
     Gfx::PTexture texture;
     friend class TextureLoader;
 };

src/Engine/Asset/TextureLoader.cpp

@@ -1,154 +0,0 @@
-#include "TextureLoader.h"
-#include "TextureAsset.h"
-#include "Graphics/Graphics.h"
-#include "AssetRegistry.h"
-#include "Graphics/Vulkan/VulkanGraphicsEnums.h"
-#define STB_IMAGE_IMPLEMENTATION
-#include <stb_image.h>
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#include <stb_image_write.h>
-#include "ktx.h"
-
-using namespace Seele;
-
-TextureLoader::TextureLoader(Gfx::PGraphics graphics)
-    : graphics(graphics)
-{
-    //(std::filesystem::absolute("./textures/placeholder.ktx"));
-    //placeholderAsset->load(graphics);
-    //AssetRegistry::get().assetRoot.textures[""] = placeholderAsset;
-    placeholderAsset = new TextureAsset();
-    import(TextureImportArgs{
-        .filePath = std::filesystem::absolute("./textures/placeholder.png"),
-        .importPath = "",
-        }, placeholderAsset);
-    AssetRegistry::get().assetRoot->textures[""] = placeholderAsset;
-}
-
-TextureLoader::~TextureLoader()
-{
-}
-
-void TextureLoader::importAsset(TextureImportArgs args)
-{
-    std::filesystem::path assetPath = args.filePath.filename();
-    assetPath.replace_extension("asset");
-    PTextureAsset asset = new TextureAsset(args.importPath, assetPath.stem().string());
-    asset->setStatus(Asset::Status::Loading);
-    asset->setTexture(placeholderAsset->getTexture());
-    AssetRegistry::get().registerTexture(asset);
-    import(args, asset);
-}
-
-PTextureAsset TextureLoader::getPlaceholderTexture() 
-{
-    return placeholderAsset;
-}
-
-void TextureLoader::import(TextureImportArgs args, PTextureAsset textureAsset)
-{
-    int totalWidth, totalHeight, n;
-    unsigned char* data = stbi_load(args.filePath.string().c_str(), &totalWidth, &totalHeight, &n, 4);
-    ktxTexture2* kTexture;
-    ktxTextureCreateInfo createInfo;
-    createInfo.vkFormat = VK_FORMAT_R8G8B8A8_UNORM;
-    createInfo.baseDepth = 1;
-    createInfo.numLevels = 1;
-    createInfo.numLayers = 1;
-    createInfo.isArray = false;
-    createInfo.generateMipmaps = false;
-
-    if (args.type == TextureImportType::TEXTURE_CUBEMAP)
-    {
-        uint32 faceWidth = totalWidth / 4;
-        uint32 faceHeight = totalHeight / 3;
-        // Cube map
-        createInfo.baseWidth = totalWidth / 4;
-        createInfo.baseHeight = totalHeight / 3;
-        createInfo.numFaces = 6;
-        createInfo.numDimensions = 2;
-
-        ktxTexture2_Create(&createInfo,
-            KTX_TEXTURE_CREATE_ALLOC_STORAGE,
-            &kTexture);
-
-        auto loadCubeFace = [&kTexture, &faceWidth, &totalWidth, &data](int xPos, int yPos, int faceName)
-        {
-            std::vector<unsigned char> vec(faceWidth * faceWidth * 4);
-            for (int y = 0; y < faceWidth; ++y)
-            {
-                for (int x = 0; x < faceWidth; ++x)
-                {
-                    int imgX = x + (xPos * faceWidth);
-                    int imgY = y + (yPos * faceWidth);
-                    std::memcpy(&vec[(x + (faceWidth * y)) * 4], &data[(imgX + (totalWidth * imgY)) * 4], 4);
-                }
-            }
-            ktxTexture_SetImageFromMemory(ktxTexture(kTexture),
-                0, 0, faceName, vec.data(), vec.size());
-        };
-        loadCubeFace(2, 1, 0); // +X
-        loadCubeFace(0, 1, 1); // -X
-        loadCubeFace(1, 0, 2); // +Y
-        loadCubeFace(1, 2, 3); // -Y
-        loadCubeFace(1, 1, 4); // +Z
-        loadCubeFace(3, 1, 5); // -Z
-    }
-    else
-    {
-        createInfo.baseWidth = totalWidth;
-        createInfo.baseHeight = totalHeight;
-        createInfo.numFaces = 1;
-        createInfo.numDimensions = 1 + (totalHeight > 1);
-
-        ktxTexture2_Create(&createInfo,
-            KTX_TEXTURE_CREATE_ALLOC_STORAGE,
-            &kTexture);
-
-        ktxTexture_SetImageFromMemory(ktxTexture(kTexture),
-            0, 0, 0, data, totalWidth * totalHeight * 4 * sizeof(unsigned char));
-    }
-    std::cout << "starting compression of " << textureAsset->getAssetIdentifier() << std::endl;
-    ktxBasisParams params = {
-        .structSize = sizeof(ktxBasisParams),
-        .uastc = KTX_TRUE,
-        .threadCount = std::thread::hardware_concurrency(),
-        .qualityLevel = 0,
-    };
-    //ktx_error_code_e error = ktxTexture2_CompressBasisEx(kTexture, &params);
-    //assert(error == KTX_SUCCESS);
-
-    //error = ktxTexture2_TranscodeBasis(kTexture, KTX_TTF_BC7_RGBA, 0);
-    //assert(error == KTX_SUCCESS);
-    
-    stbi_image_free(data);
-
-    TextureCreateInfo texInfo = {
-        .resourceData = {
-            .size = ktxTexture_GetDataSize(ktxTexture(kTexture)),
-            .data = ktxTexture_GetData(ktxTexture(kTexture)),
-        },
-        .width = createInfo.baseWidth,
-        .height = createInfo.baseHeight,
-        .depth = createInfo.baseDepth,
-        .bArray = false,
-        .arrayLayers = createInfo.numFaces,
-        .mipLevels = 1,
-        .samples = 1,
-        .format = (Gfx::SeFormat)kTexture->vkFormat,
-        .usage = args.usage,
-    };
-
-    if (createInfo.numFaces == 1)
-    {
-        textureAsset->setTexture(graphics->createTexture2D(texInfo));
-    }
-    else
-    {
-        textureAsset->setTexture(graphics->createTextureCube(texInfo));
-    }
-
-    ktxTexture_Destroy(ktxTexture(kTexture));
-    textureAsset->setStatus(Asset::Status::Ready);
-    ////co_return;
-}

src/Engine/Asset/TextureLoader.h

@@ -1,37 +0,0 @@
-#pragma once
-#include "MinimalEngine.h"
-#include "Containers/List.h"
-#include "Graphics/GraphicsEnums.h"
-#include <filesystem>
-
-namespace Seele
-{
-DECLARE_REF(TextureAsset)
-DECLARE_NAME_REF(Gfx, Graphics)
-DECLARE_NAME_REF(Gfx, Texture2D)
-enum class TextureImportType
-{
-    TEXTURE_2D,
-    TEXTURE_CUBEMAP,
-};
-struct TextureImportArgs
-{
-    std::filesystem::path filePath;
-    std::string importPath;
-    TextureImportType type = TextureImportType::TEXTURE_2D;
-    Gfx::SeImageUsageFlagBits usage = Gfx::SE_IMAGE_USAGE_SAMPLED_BIT;
-};
-class TextureLoader
-{
-public:
-    TextureLoader(Gfx::PGraphics graphic);
-    ~TextureLoader();
-    void importAsset(TextureImportArgs args);
-    PTextureAsset getPlaceholderTexture();
-private:
-    void import(TextureImportArgs args, PTextureAsset asset);
-    Gfx::PGraphics graphics;
-    PTextureAsset placeholderAsset;
-};
-DEFINE_REF(TextureLoader)
-} // namespace Seele