feat: post-processing effects

src/assets/Assets.hpp

@@ -16,7 +16,16 @@
 
 class Assets;
 
-enum class AssetType { TEXTURE, SHADER, FONT, ATLAS, LAYOUT, SOUND, MODEL };
+enum class AssetType {
+    TEXTURE,
+    SHADER,
+    FONT,
+    ATLAS,
+    LAYOUT,
+    SOUND,
+    MODEL,
+    POST_EFFECT
+};
 
 namespace assetload {
     /// @brief final work to do in the main thread
@@ -91,6 +100,20 @@ public:
         return static_cast<T*>(found->second.get());
     }
 
+    template <class T>
+    std::shared_ptr<T> getShared(const std::string& name) const {
+        const auto& mapIter = assets.find(typeid(T));
+        if (mapIter == assets.end()) {
+            return nullptr;
+        }
+        const auto& map = mapIter->second;
+        const auto& found = map.find(name);
+        if (found == map.end()) {
+            return nullptr;
+        }
+        return std::static_pointer_cast<T>(found->second);
+    }
+
     template <class T>
     T& require(const std::string& name) const {
         T* asset = get<T>(name);

src/assets/AssetsLoader.cpp

@@ -34,6 +34,7 @@ AssetsLoader::AssetsLoader(Engine& engine, Assets& assets, const ResPaths& paths
     addLoader(AssetType::LAYOUT, assetload::layout);
     addLoader(AssetType::SOUND, assetload::sound);
     addLoader(AssetType::MODEL, assetload::model);
+    addLoader(AssetType::POST_EFFECT, assetload::posteffect);
 }
 
 void AssetsLoader::addLoader(AssetType tag, aloader_func func) {
@@ -131,6 +132,8 @@ static std::string assets_def_folder(AssetType tag) {
             return SOUNDS_FOLDER;
         case AssetType::MODEL:
             return MODELS_FOLDER;
+        case AssetType::POST_EFFECT:
+            return POST_EFFECTS_FOLDER;
     }
     return "<error>";
 }
@@ -196,6 +199,7 @@ void AssetsLoader::processPreloadConfig(const io::path& file) {
     processPreloadList(AssetType::TEXTURE, root["textures"]);
     processPreloadList(AssetType::SOUND, root["sounds"]);
     processPreloadList(AssetType::MODEL, root["models"]);
+    processPreloadList(AssetType::POST_EFFECT, root["post-effects"]);
     // layouts are loaded automatically
 }
 

src/assets/assetload_funcs.cpp

@@ -60,13 +60,7 @@ assetload::postfunc assetload::texture(
     }
 }
 
-assetload::postfunc assetload::shader(
-    AssetsLoader*,
-    const ResPaths& paths,
-    const std::string& filename,
-    const std::string& name,
-    const std::shared_ptr<AssetCfg>&
-) {
+static auto process_program(const ResPaths& paths, const std::string& filename) {
     io::path vertexFile = paths.find(filename + ".glslv");
     io::path fragmentFile = paths.find(filename + ".glslf");
 
@@ -75,8 +69,25 @@ assetload::postfunc assetload::shader(
 
     auto& preprocessor = *Shader::preprocessor;
 
-    vertexSource = preprocessor.process(vertexFile, vertexSource).code;
-    fragmentSource = preprocessor.process(fragmentFile, fragmentSource).code;
+    auto vertex = preprocessor.process(vertexFile, vertexSource);
+    auto fragment = preprocessor.process(fragmentFile, fragmentSource);
+    return std::make_pair(vertex, fragment);
+}
+
+assetload::postfunc assetload::shader(
+    AssetsLoader*,
+    const ResPaths& paths,
+    const std::string& filename,
+    const std::string& name,
+    const std::shared_ptr<AssetCfg>&
+) {
+    auto [vertex, fragment] = process_program(paths, filename);
+
+    io::path vertexFile = paths.find(filename + ".glslv");
+    io::path fragmentFile = paths.find(filename + ".glslf");
+
+    std::string vertexSource = std::move(vertex.code);
+    std::string fragmentSource = std::move(fragment.code);
 
     return [=](auto assets) {
         assets->store(
@@ -91,6 +102,40 @@ assetload::postfunc assetload::shader(
     };
 }
 
+assetload::postfunc assetload::posteffect(
+    AssetsLoader*,
+    const ResPaths& paths,
+    const std::string& file,
+    const std::string& name,
+    const std::shared_ptr<AssetCfg>& settings
+) {
+    io::path effectFile = paths.find(file + ".glsl");
+    std::string effectSource = io::read_string(effectFile);
+
+    auto& preprocessor = *Shader::preprocessor;
+    preprocessor.addHeader(
+        "__effect__", preprocessor.process(effectFile, effectSource, true)
+    );
+
+    auto [vertex, fragment] = process_program(paths, SHADERS_FOLDER + "/effect");
+    auto params = std::move(fragment.params);
+
+    std::string vertexSource = std::move(vertex.code);
+    std::string fragmentSource = std::move(fragment.code);
+
+    return [=](auto assets) {
+        auto program = Shader::create(
+            effectFile.string(),
+            effectFile.string(),
+            vertexSource,
+            fragmentSource
+        );
+        assets->store(
+            std::make_shared<PostEffect>(std::move(program), params), name
+        );
+    };
+}
+
 static bool append_atlas(AtlasBuilder& atlas, const io::path& file) {
     std::string name = file.stem();
     // skip duplicates

src/assets/assetload_funcs.hpp

@@ -62,4 +62,11 @@ namespace assetload {
         const std::string& name,
         const std::shared_ptr<AssetCfg>& settings
     );
+    postfunc posteffect(
+        AssetsLoader*,
+        const ResPaths& paths,
+        const std::string& file,
+        const std::string& name,
+        const std::shared_ptr<AssetCfg>& settings
+    );
 }