feat:

  - Group: template effects (moveTo, scaleTo, rotateTo, alignTo, fadeIn, fadeOut, moveBy, scaleBy, rotateBy) now broadcast to children via _broadcast instead of using the group's phantom meta as animation source
  - moveTo, scaleTo, alignTo snapshot src at call time to prevent mutation during animation loop
  - Offset now syncs self.meta.position with _basePosition so chained moveBy calls read the right source
  - apply() overloaded with singledispatch to accept (IShader, start, duration) tuples — used by click()
  - click(): fixed frame index passed as seconds (unit mismatch causing laggy animation) and phase overlap (i resets to 0 per phase)
  - inputCreation and trackProps typed with ParamSpec + TypeVar so decorated __init__ signatures are preserved in the IDE

Author: anpawo

include/shader/IVertexShader.hpp

@@ -31,7 +31,7 @@ enum VertexShader {
     Align,
     Position,
     Scale,
-    Rotate,
+    Rotation,
     Opacity,
     Hide,
     Show,
@@ -46,7 +46,7 @@ const std::map<std::string, VertexShader> getTransformFromString = {
     {"Position", VertexShader::Position},
     {"Scale", VertexShader::Scale},
     {"Align", VertexShader::Align},
-    {"Rotate", VertexShader::Rotate},
+    {"Rotation", VertexShader::Rotation},
     {"Opacity", VertexShader::Opacity},
     {"Hide", VertexShader::Hide},
     {"Show", VertexShader::Show},
@@ -125,7 +125,7 @@ inline void getMetadataFromArgs(VertexShader t, const json::object_t& args, Meta
             meta.scale.y = args.at("y");
             break;
         }
-        case Rotate: {
+        case Rotation: {
             meta.rotation = args.at("degree");
             break;
         }

include/utils/Logger.hpp

@@ -0,0 +1,65 @@
+/*
+** EPITECH PROJECT, 2026
+** video-code
+** File description:
+** Logger
+*/
+
+#pragma once
+
+#include <format>
+#include <iostream>
+#include <nlohmann/json.hpp>
+#include <string>
+
+namespace VC
+{
+    namespace Color
+    {
+        constexpr const char* CYAN = "\033[36m";
+        constexpr const char* RED = "\033[31m";
+        constexpr const char* GREEN = "\033[32m";
+        constexpr const char* MAGENTA = "\033[35m";
+        constexpr const char* RESET = "\033[0m";
+    }
+
+    struct Logger
+    {
+        const std::string prefix;
+        const char*       color;
+        std::ostream&     out;
+
+        Logger(std::string prefix, const char* color, std::ostream& out = std::cerr)
+            : prefix(std::move(prefix)), color(color), out(out)
+        {
+        }
+
+        template <typename T>
+        void log(const T& msg) const
+        {
+            out << msg << "\n";
+        }
+
+        void logStack(const nlohmann::json& s) const
+        {
+            std::string action = s["action"];
+            std::string msg;
+
+            if (action == "Create") {
+                msg = std::format("{}[CREATE]:{}{}[{}]:{} {}", Color::CYAN, Color::RESET, Color::CYAN, s["type"].get<std::string>(), Color::RESET, s["args"].dump());
+            } else if (action == "Apply") {
+                msg = std::format("{}[APPLY]:[{}]:[{}]:{} {}", Color::MAGENTA, s["name"].get<std::string>(), s["input"].get<int>(), Color::RESET, s["args"].dump());
+            } else if (action == "Wait") {
+                msg = std::format("{}[WAIT]:{}{}", Color::MAGENTA, Color::RED, s["n"].get<int>());
+            } else if (action == "Timestamp") {
+                msg = std::format("{}[TIMESTAMP]:{} {}  at frame {}", Color::GREEN, Color::RESET, s["name"].get<std::string>(), s["time"].get<size_t>());
+            } else {
+                msg = s.dump();
+            }
+
+            log(msg);
+        }
+    };
+
+    inline Logger Debug{"Debug", Color::CYAN};
+}

src/core/Core.cpp

@@ -8,6 +8,7 @@
 #include "core/Core.hpp"
 
 #include <cstddef>
+#include <format>
 #include <iostream>
 #include <memory>
 #include <string>
@@ -20,6 +21,7 @@
 #include "input/media/WebImage.hpp"
 // #include "input/media/Video.hpp"
 #include "utils/Exception.hpp"
+#include "utils/Logger.hpp"
 #include "window/VulkanWidget.hpp"
 
 VC::Core::Core(const argparse::ArgumentParser& parser, const Config& config)
@@ -75,9 +77,8 @@ std::string VC::Core::serializeScene()
 void VC::Core::executeStack()
 {
     for (auto& s : _stack) {
-        if (_showstack) {
-            std::cout << s << std::endl;
-        }
+        if (_showstack)
+            VC::Debug.logStack(s);
 
         if (s["action"] == "Create") {
             _inputs.push_back(Factory::inputs.at(s["type"])(s["args"]));

src/input/shape/BezierPath.cpp

@@ -7,6 +7,8 @@
 
 #include "input/shape/BezierPath.hpp"
 
+#include <mapbox/earcut.hpp>
+
 #include "vulkan/MeshFactory.hpp"
 
 BezierPath::BezierPath(json::object_t&& args)
@@ -79,25 +81,21 @@ Mesh BezierPath::getMesh(const Metadata& meta, const Config& config)
         }
     }
 
-    // Fill triangulation — always occupies the full shape boundary.
+    // Fill triangulation — earcut handles non-convex polygons correctly.
     if (fillColor[3] > 0 && poly.size() >= 3) {
-        cv::Vec2f centroid{0.f, 0.f};
-        for (const auto& p : poly) centroid += p;
-        centroid *= (1.f / static_cast<float>(poly.size()));
+        std::vector<std::vector<std::array<float, 2>>> polygon(1);
+        polygon[0].reserve(poly.size());
+        for (const auto& p : poly)
+            polygon[0].push_back({p[0], p[1]});
 
-        uint16_t centerIdx = factory.vertexCount();
-        factory.addVertex(centroid[0], centroid[1], fillColor);
+        auto earIndices = mapbox::earcut<uint16_t>(polygon);
 
         uint16_t firstPolyIdx = factory.vertexCount();
         for (const auto& p : poly)
             factory.addVertex(p[0], p[1], fillColor);
 
-        size_t polySize = poly.size();
-        for (size_t i = 0; i < polySize; ++i) {
-            factory.mesh.indices.push_back(centerIdx);
-            factory.mesh.indices.push_back(firstPolyIdx + static_cast<uint16_t>(i));
-            factory.mesh.indices.push_back(firstPolyIdx + static_cast<uint16_t>((i + 1) % polySize));
-        }
+        for (auto idx : earIndices)
+            factory.mesh.indices.push_back(firstPolyIdx + idx);
     }
 
     // Stroke rendered on top of fill, extruded inward so it stays within the boundary.

video.py

@@ -5,7 +5,8 @@
 from videocode import *
 
 # --- Marius' Test (Do not remove, just comment it, you should try it also)
-example0()
+example5()
+
 
 # p = Plane()
 # s = Triangle().align(0, 0)

videocode/constants.py

@@ -60,14 +60,12 @@
 GREEN       = rgba(0, 255, 0)
 BLUE        = rgba(0, 0, 255)
 
-LIGHT_RED   = rgba(255, 104, 104)
-LIGHT_GREEN = rgba(115, 255, 115)
-LIGHT_BLUE  = rgba(132, 204, 255)
+RED_A       = rgba("#FC6255")
+RED_B       = rgba("#ED7F7B")
 
-DARK_RED    = rgba(255, 37, 37)
-DARK_GREEN  = rgba(42, 255, 23)
-DARK_BLUE   = rgba(32, 50, 255)
+GREEN_A     = rgba("#9ADF8E")
 
-BLUE_A      = rgba("#58C4DD")
-RED_C       = rgba("#FC6255")
+BLUE_A      = rgba("#58C4DD") # light blue
+BLUE_B      = rgba("#0B142B") # very dark blue
+BLUE_C      = rgba("#69A5F1")
 # fmt: on

videocode/context.py

@@ -25,12 +25,12 @@ def __init__(self, *, interface: bool = False) -> None:
         # --- Align ---
         self.align: v2[number] = v2(0.5, 0.5)
 
-        # --- Scale ---
-        self.scale: v2[number] = v2(1, 1)
-
         # --- Rotation ---
         self.rotation: number = 0
 
+        # --- Scale ---
+        self.scale: v2[number] = v2(1, 1)
+
         # --- Opacity ---
         self.opacity: number = 255
 
@@ -56,11 +56,11 @@ def __init__(self, *, interface: bool = False) -> None:
         """
         Setting an Attribute will trigger an `apply(args(attr))`
         """
-        self.pendingSetattrStart: defaultable[sec] = default(0)
+        self.pendingSetattrStart: sec = 0
         """
         Keep start through setattr.
         """
-        self.pendingSetattrDuration: defaultable[sec] = default(1)
+        self.pendingSetattrDuration: sec = 1
         """
         Keep duration through setattr.
         """
@@ -129,6 +129,6 @@ def timestamp(name: str) -> None:
         {
             "action": "Timestamp",
             "name": name,
-            "time": Context.waitOffset,
+            "time": Context.lastEverAffectedFrame,
         }
     )

videocode/input/group/Group.py

@@ -5,60 +5,80 @@
 
 
 from videocode.input.input import *
-from videocode.input.offset.Offset import Offset
-from videocode.shader.vertexShader.position import position
 
 
 class Group(Input):
+    # fmt: off
     """
     A `Group` contains many inputs and will apply each transformations it gets to all of its inputs.
+
+    Also used to create bigger things that link many Inputs.  
+    You create a class that inherits from `Group`, setup your things and then super().__init__().
     """
+    # fmt: on
 
     def __new__(cls, *args, **kwargs) -> Self:
         instance = object.__new__(cls)
         instance.meta = Metadata(interface=True)
         return instance
 
     def __init__(self, *inputs: Input):
-        self.inputs = [i for i in inputs]
+        self._inputs = [i for i in inputs]
 
     def addInput(self, *inputs: Input) -> Self:
         for i in inputs:
-            self.inputs.append(i)
+            self._inputs.append(i)
         return self
 
     def flush(self) -> Self:
         """
         Appends the `frames` of `self` to the `timeline`.
         """
-        for i in self.inputs:
+        for i in self._inputs:
             i.flush()
 
         return self
 
-    def apply(self, *shaders: IShader, start: defaultable[sec] = default(0), duration: defaultable[sec] = default(1)) -> Self:
+    def apply(self, *shaders: IShader, start: sec = 0, duration: sec = 1) -> Self:
         """
         Applies the `Transformations` `ts` to all the `Inputs` of the `Group`.
         """
         for s in shaders:
-            for i in self.inputs:
+            for i in self._inputs:
                 i.apply(copy.deepcopy(s), start=start, duration=duration)
 
         return self
 
     def waitForOthers(self, n: sec = 0, updateContext=False) -> Self:
-        lastAffectedFramePlusN = max(i.meta.lastAffectedFrame for i in self.inputs) + int(n * FRAMERATE)
+        lastAffectedFramePlusN = max(i.meta.lastAffectedFrame for i in self._inputs) + int(n * FRAMERATE)
 
-        for i in self.inputs:
+        for i in self._inputs:
             i.waitTo(lastAffectedFramePlusN)
 
         if updateContext and lastAffectedFramePlusN >= Context.lastEverAffectedFrame:
             Context.waitOffset = Context.lastEverAffectedFrame = lastAffectedFramePlusN
 
         return self
 
+    def _broadcast(self, name: str, *args, **kwargs) -> Self:
+        for child in self._inputs:
+            getattr(child, name)(*args, **kwargs)
+        return self
+
+    # fmt: off
+    def moveTo(self, *args, **kwargs) -> Self: return self._broadcast('moveTo', *args, **kwargs)
+    def moveBy(self, *args, **kwargs) -> Self: return self._broadcast('moveBy', *args, **kwargs)
+    def scaleTo(self, *args, **kwargs) -> Self: return self._broadcast('scaleTo', *args, **kwargs)
+    def scaleBy(self, *args, **kwargs) -> Self: return self._broadcast('scaleBy', *args, **kwargs)
+    def rotateTo(self, *args, **kwargs) -> Self: return self._broadcast('rotateTo', *args, **kwargs)
+    def rotateBy(self, *args, **kwargs) -> Self: return self._broadcast('rotateBy', *args, **kwargs)
+    def alignTo(self, *args, **kwargs) -> Self: return self._broadcast('alignTo', *args, **kwargs)
+    def fadeIn(self, *args, **kwargs) -> Self: return self._broadcast('fadeIn', *args, **kwargs)
+    def fadeOut(self, *args, **kwargs) -> Self: return self._broadcast('fadeOut', *args, **kwargs)
+    # fmt: on
+
     def __str__(self) -> str:
-        return "".join(f"idx=[{idx}], i=[{type(i).__name__}]]\n" for idx, i in enumerate(self.inputs))
+        return "".join(f"idx=[{idx}], i=[{type(i).__name__}]]\n" for idx, i in enumerate(self._inputs))
 
     def __repr__(self) -> str:
         return self.__str__()