feat: implement plugin system

Author: Hip-po

.github/copilot-instructions.md

@@ -0,0 +1,41 @@
+# Copilot Instructions for Video-Code
+
+## Project context
+- `Video-Code` is a hybrid C++ and Python project for programmatic video generation.
+- Main C++ entrypoint is `src/Main.cpp` and build output binary is `video-code`.
+- Python API lives under `videocode/` and top-level usage examples exist in `video.py` and `test/`.
+
+## Scope and change philosophy
+- Prefer minimal, targeted edits that directly satisfy the user request.
+- Preserve existing public APIs and naming unless change is explicitly requested.
+- Do not refactor unrelated modules while addressing a focused task.
+
+## Build and run workflow
+- Prefer existing project commands and CMake flow:
+  - Configure/build via `make cmake` (uses CMake + Ninja + vcpkg flags).
+  - Debug build via `make debug`.
+  - Clean via `make clean` / `make fclean`.
+- CI uses Ubuntu, GCC 13, Qt 6.2.4, and CMake configure/build in `build/`.
+- If a change impacts runtime behavior, validate by building and (when reasonable) running `./video-code --generate`.
+
+## Testing expectations
+- Run the smallest relevant validation first (targeted build/test), then broader checks only if needed.
+- C++ tests are under `tests/cpp/`; Python tests/helpers are under `tests/python/`.
+- Do not attempt to repair unrelated failing tests; mention them separately if encountered.
+
+## File and directory safety
+- Treat generated/artifact paths as non-source unless explicitly requested:
+  - `build/`, `htmlcov/`, `__pycache__/`, `vcpkg_installed/`, generated videos/images.
+- Do not edit CI/CD workflows unless task explicitly asks for pipeline changes.
+
+## Coding conventions
+- Follow local style in touched files (indentation, includes/import ordering, naming).
+- Avoid adding new dependencies unless necessary; when needed, wire them through existing tooling (`vcpkg.json`, CMake, or Python requirements) consistently.
+- Avoid one-letter variable names and avoid inline comments unless they add real value.
+
+## Documentation updates
+- When behavior, setup, or developer workflow changes, update relevant docs (`README.md` or `docs/`) in the same change.
+
+## Agent behavior
+- Before destructive actions (deletions, large refactors, security-sensitive changes), ask for confirmation.
+- Explain assumptions briefly when requirements are ambiguous and choose the simplest valid implementation path.

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "chat.tools.terminal.autoApprove": {
+        "./video-code": true
+    }
+}

CMakeLists.txt

@@ -107,28 +107,11 @@ set(SOURCES
     # --- Core ---
     src/core/Core.cpp
 
-    # --- Inputs ---
+    # --- Input Runtime ---
     src/input/AInput.cpp
-    # Media
-    src/input/media/Image.cpp
-    src/input/media/WebImage.cpp
-    src/input/media/Video.cpp
-    # Text
-    src/input/text/Text.cpp
-    # Shape
-    src/input/shape/Circle.cpp
-    src/input/shape/Rectangle.cpp
-    src/input/shape/Line.cpp
-
-    # --- Fragment Shader ---
-    src/shader/Grayscale.cpp
-    src/shader/Opacity.cpp
-    src/shader/Blur.cpp
-    src/shader/Gamma.cpp
-    src/shader/Grain.cpp
-    src/shader/Brightness.cpp
-    src/shader/Contrast.cpp
-    src/shader/Sharpen.cpp
+
+    # --- Plugin Runtime ---
+    src/plugin/PluginRegistry.cpp
 )
 
 add_executable(${PROJECT_NAME} ${SOURCES})
@@ -145,6 +128,7 @@ target_link_libraries(${PROJECT_NAME}
     argparse::argparse
     nlohmann_json::nlohmann_json
     ${OpenCV_LIBS}
+    ${CMAKE_DL_LIBS}
     ${FFMPEG_LIBRARIES}
     Qt6::Widgets
     Qt6::Core

docs/user/user.md

@@ -45,15 +45,20 @@ go to [qt6](https://www.qt.io/download) and download the latest version of qt6.
     cp build/video-code video-code
     ```
 
+5. **Build plugins (decoupled from main build):**
+  ```sh
+  ./scripts/build_plugins.sh plugins/build
+  ```
+
 ### Launch
 
 To launch the project, run:
 ```sh
-./video-code --file path/to/your/script.py
+./video-code --file path/to/your/script.py --plugin-dir plugins/build
 ```
 If you want to generate a video directly, use:
 ```sh
-./video-code --file path/to/your/script.py --generate
+./video-code --file path/to/your/script.py --generate output.mp4 --plugin-dir plugins/build
 
 ```
 

include/core/Core.hpp

@@ -13,6 +13,7 @@
 #include <opencv2/opencv.hpp>
 
 #include "input/IInput.hpp"
+#include "plugin/PluginRegistry.hpp"
 
 namespace VC
 {
@@ -64,6 +65,7 @@ namespace VC
         ///< Source & Output file
         const std::string _sourceFile;
         const std::string _outputFile;
+        const std::string _pluginDir;
 
         ///< Background frame, black with alpha 0
         const cv::Mat _bgFrame;
@@ -80,5 +82,8 @@ namespace VC
 
         ///< Stack containing the steps of the video
         json::array_t _stack{};
+
+        ///< Runtime plugin registry
+        PluginRegistry _pluginRegistry{};
     };
 };

include/input/AInput.hpp

@@ -10,6 +10,7 @@
 #include <memory>
 #include <nlohmann/json.hpp>
 #include <opencv2/core/mat.hpp>
+#include <string>
 #include <vector>
 
 #include "input/IInput.hpp"
@@ -29,6 +30,8 @@ class AInput : public IInput
 
     void add(nlohmann::basic_json<>& modification) final;
 
+    void setShaderFactory(void* context, ShaderFactoryCallback callback) final;
+
     // -
 
     Metadata getMetadata(size_t index);
@@ -41,6 +44,9 @@ class AInput : public IInput
 
 protected:
 
+    void* _shaderFactoryContext{nullptr};
+    ShaderFactoryCallback _shaderFactory{nullptr};
+
     ///< Arguments needed to generate the Input's matrix
     const json::object_t _baseArgs;
 

include/input/IInput.hpp

@@ -7,15 +7,22 @@
 
 #pragma once
 
+#include <functional>
+#include <memory>
 #include <nlohmann/json.hpp>
 #include <opencv2/core/mat.hpp>
+#include <string>
+
+#include "shader/IFragmentShader.hpp"
 
 using json = nlohmann::json;
 
 class IInput
 {
 public:
 
+    using ShaderFactoryCallback = std::unique_ptr<IFragmentShader> (*)(void* context, const std::string& name, const json::object_t& args);
+
     IInput() = default;
     virtual ~IInput() = default;
 
@@ -32,4 +39,12 @@ class IInput
     virtual void overlay(cv::Mat& bg, size_t t) = 0;
 
     // -
+
+    virtual void setShaderFactory(void* context, ShaderFactoryCallback callback) = 0;
+
+    // -
+
+    virtual size_t maxFrameHint() const { return 0; }
+
+    // -
 };

include/plugin/PluginAPI.hpp

@@ -0,0 +1,34 @@
+/*
+** EPITECH PROJECT, 2026
+** video-code
+** File description:
+** Plugin API
+*/
+
+#pragma once
+
+#include <memory>
+#include <nlohmann/json.hpp>
+
+#include "input/IInput.hpp"
+#include "shader/IFragmentShader.hpp"
+
+namespace VC
+{
+    using InputFactoryFunction = std::unique_ptr<IInput> (*)(nlohmann::json::object_t&& args);
+    using FragmentShaderFactoryFunction = std::unique_ptr<IFragmentShader> (*)(const nlohmann::json::object_t& args);
+
+    using RegisterInputFunction = void (*)(void* context, const char* name, InputFactoryFunction factory);
+    using RegisterFragmentShaderFunction = void (*)(void* context, const char* name, FragmentShaderFactoryFunction factory);
+
+    struct PluginRegistrar
+    {
+        void* context;
+        RegisterInputFunction registerInput;
+        RegisterFragmentShaderFunction registerFragmentShader;
+    };
+}
+
+extern "C" {
+using VCRegisterPluginFunction = void (*)(VC::PluginRegistrar* registrar);
+}

include/plugin/PluginRegistry.hpp

@@ -0,0 +1,42 @@
+/*
+** EPITECH PROJECT, 2026
+** video-code
+** File description:
+** Plugin registry
+*/
+
+#pragma once
+
+#include <filesystem>
+#include <map>
+#include <memory>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <vector>
+
+#include "plugin/PluginAPI.hpp"
+
+namespace VC
+{
+    class PluginRegistry
+    {
+    public:
+
+        void registerInput(const std::string& name, InputFactoryFunction factory);
+        void registerFragmentShader(const std::string& name, FragmentShaderFactoryFunction factory);
+
+        std::unique_ptr<IInput> createInput(const std::string& name, nlohmann::json::object_t&& args) const;
+        std::unique_ptr<IFragmentShader> createFragmentShader(const std::string& name, const nlohmann::json::object_t& args) const;
+
+        void loadPluginDirectories(const std::vector<std::string>& directories);
+
+    private:
+
+        void loadMetadataFile(const std::filesystem::path& metadataPath);
+        void loadCppPlugin(const std::filesystem::path& metadataPath, const std::filesystem::path& libraryPath);
+
+        std::map<std::string, InputFactoryFunction> _inputFactories{};
+        std::map<std::string, FragmentShaderFactoryFunction> _shaderFactories{};
+        std::vector<void*> _libraryHandles{};
+    };
+}

plugins/sources/blur/cpp/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.21)
+project(vc-plugin-blur LANGUAGES CXX)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+if(NOT VIDEO_CODE_ROOT)
+  message(FATAL_ERROR "VIDEO_CODE_ROOT must be provided")
+endif()
+find_package(OpenCV REQUIRED)
+find_package(nlohmann_json CONFIG REQUIRED)
+add_library(blur_plugin SHARED blur_plugin.cpp)
+target_include_directories(blur_plugin PRIVATE ${VIDEO_CODE_ROOT}/include)
+target_link_libraries(blur_plugin PRIVATE ${OpenCV_LIBS} nlohmann_json::nlohmann_json)
+set_target_properties(blur_plugin PROPERTIES OUTPUT_NAME "blur_plugin")