feat: incremental hot-reload (stack diffing + resetModifications) + visual regression suite

Restructures Context.stack from a flat list into a nested dict
(stack[inputIdx][frameIdx][shaderKey]), which gives Apply entries natural
O(1) dedup and a stable address for diffing — Wait/Timestamp move to a
separate Context.events list since C++ doesn't need them in the stack.

Core::reloadSourceFile now diffs the freshly-executed stack against a
snapshot of the previous one (Core::_stackSnapshot): inputs that didn't
change at all are skipped entirely (mesh/GPU caches + texture descriptors
stay valid), and inputs whose Create entry is unchanged but whose
modifications changed reuse the existing object via the new
AInput::resetModifications() instead of re-running their constructor —
avoiding redundant Image/Video file I/O on every edit-and-reload cycle.
Full reconstruction only happens when Create args changed or the input
set itself changed (Python's sequential index counter gets reshuffled by
add/remove, so positional diffing isn't safe there). Wires 'R' in the
preview window to trigger the reload + texture re-upload.

Adds a --visual-test suite (make test / make test-golden) that renders
scenes headlessly via VulkanHeadlessRenderer and checks two things:
golden-frame regression (rendered frames vs. stored PNGs in
test/visual/golden/) and hot-reload equivalence (does an incremental
reload produce pixel-identical output to a fresh load of the same
scene?) — exercising both the "skip unchanged" and "reuse + replay" paths
above. Test scenes live in test/visual/scenes/, including a
reload_a/reload_b pair built specifically to cover both reuse paths.

Author: anpawo

.gitignore

@@ -54,5 +54,9 @@ wherewasi
 todo
 pgn
 
+# Visual regression golden images — tracked despite the *.png rule above,
+# the test suite needs them to compare against on a fresh checkout.
+!test/visual/golden/*.png
+
 # WebImage
 webimage/

CMakeLists.txt

@@ -123,6 +123,9 @@ set(SOURCES
     # --- Compiler ---
     src/compiler/Compiler.cpp
 
+    # --- Test ---
+    src/test/VisualTest.cpp
+
     # --- Core ---
     src/core/Core.cpp
 

Makefile

@@ -80,6 +80,18 @@ docvid:
 	./$(BINARY_NAME) --generate
 
 
+# Visual regression suite — golden-frame + hot-reload equivalence checks.
+.PHONY: test
+test:
+	./$(BINARY_NAME) --visual-test
+
+
+# (Re)write the golden images the suite compares against.
+.PHONY: test-golden
+test-golden:
+	./$(BINARY_NAME) --visual-test --update-golden
+
+
 # 1. Generate the Readme
 # 2. Copies the generated video to example.gif
 .PHONY: docdoc

include/core/Core.hpp

@@ -68,7 +68,22 @@ namespace VC
 
     private:
 
-        void executeStack(const py::list& stack);
+        void executeStack(const py::dict& stack, const py::list& events);
+
+        ///< (Re)build a single input from its stack subtree (Create + Apply entries),
+        ///< replacing _inputs[idx] in place. Used by both full and incremental rebuilds.
+        ///< When reuseExisting is true and _inputs[idx]'s Create entry is unchanged, the
+        ///< existing AInput is kept alive (skipping its — possibly expensive — constructor,
+        ///< e.g. Image/Video file I/O) and only its modification state is reset + replayed.
+        void rebuildInput(size_t idx, const py::dict& inputData, bool reuseExisting);
+
+        ///< Per-input snapshot of the stack (as JSON) from the last reload — diffed against
+        ///< the freshly-executed stack so reloadSourceFile() only rebuilds inputs that changed.
+        std::map<int, json> _stackSnapshot{};
+
+        ///< Indices of inputs rebuilt during the last executeStack() that need a texture
+        ///< (re)upload — consumed and cleared by uploadTextures().
+        std::vector<size_t> _pendingTextureUpload{};
 
         ///< Config (Window / Framerate / Paths)
         const Config& _config;

include/input/AInput.hpp

@@ -31,6 +31,14 @@ class AInput : public IInput
 
     // -
 
+    // Restores all modification-derived state (metas, effects, timeline) to the
+    // freshly-constructed state, keeping _baseArgs (and any subclass resources, e.g.
+    // a loaded texture or open video file). Lets hot-reload reuse an input whose
+    // Create entry didn't change without re-running its (possibly expensive) constructor.
+    void resetModifications();
+
+    // -
+
     Metadata getMetadata(size_t index) final;
 
     // -

include/test/VisualTest.hpp

@@ -0,0 +1,49 @@
+/*
+** EPITECH PROJECT, 2026
+** video-code
+** File description:
+** VisualTest — golden-frame & hot-reload visual regression suite
+*/
+
+#pragma once
+
+#include <argparse/argparse.hpp>
+#include <opencv2/opencv.hpp>
+#include <string>
+#include <vector>
+
+#include "core/Config.hpp"
+
+namespace VC
+{
+    // -------------------------------------------------------------------------
+    // VisualTest
+    //   Renders a fixed set of scenes headlessly (VulkanHeadlessRenderer, no
+    //   ffmpeg) and compares the resulting frames against golden PNGs stored in
+    //   test/visual/golden/. Also checks that hot-reloading from one scene to
+    //   another (Core::reloadSourceFile) produces pixel-identical output to a
+    //   fresh load of the destination scene — the "reload equivalence" check.
+    //
+    //   Run with `--visual-test`; pass `--update-golden` to (re)write the
+    //   golden images instead of comparing against them.
+    // -------------------------------------------------------------------------
+    class VisualTest
+    {
+    public:
+
+        explicit VisualTest(const argparse::ArgumentParser& parser);
+
+        // Runs every registered case, printing PASS/FAIL per check.
+        // Returns the number of failed checks (0 = everything passed).
+        int run(bool updateGolden);
+
+    private:
+
+        std::vector<cv::Mat> renderFrames(const std::string& scenePath, const std::vector<size_t>& frames);
+        std::vector<cv::Mat> renderFramesAfterReload(
+            const std::string& before, const std::string& after, const std::vector<size_t>& frames);
+
+        const argparse::ArgumentParser& _parser;
+        Config                          _baseConfig;
+    };
+};

include/utils/Logger.hpp

@@ -44,6 +44,7 @@ namespace VC
         constexpr const char* CYAN = "\033[36m";
         constexpr const char* RED = "\033[31m";
         constexpr const char* GREEN = "\033[32m";
+        constexpr const char* YELLOW = "\033[33m";
         constexpr const char* MAGENTA = "\033[35m";
         constexpr const char* RESET = "\033[0m";
     }

src/Main.cpp

@@ -17,6 +17,7 @@
 #include <opencv2/opencv.hpp>
 
 #include "compiler/Compiler.hpp"
+#include "test/VisualTest.hpp"
 #include "window/Window.hpp"
 
 namespace py = pybind11;
@@ -64,6 +65,16 @@ void setParserArgument(argparse::ArgumentParser &p)
         .add_argument("--showtimeline")
         .flag()
         .help("Show the timeline of the video.");
+
+    p
+        .add_argument("--visual-test")
+        .flag()
+        .help("Run the visual regression suite (golden-frame + hot-reload equivalence checks) and exit.");
+
+    p
+        .add_argument("--update-golden")
+        .flag()
+        .help("With --visual-test, (re)write the golden images instead of comparing against them.");
 }
 
 int main(int argc, char *argv[])
@@ -98,6 +109,12 @@ int main(int argc, char *argv[])
         return EXIT_FAILURE;
     }
 
+    // Visual regression suite (headless — no window, no Qt event loop)
+    if (parser.get<bool>("--visual-test")) {
+        VC::VisualTest visualTest(parser);
+        return visualTest.run(parser.get<bool>("--update-golden"));
+    }
+
     // Generate the video (headless — no window, no Qt event loop)
     if (parser.is_used("--generate")) {
         VC::Compiler compiler(parser);