Communitygithub.com

MSP — Manim Style & Protocol

Montre à un agent comment planifier, construire ou couper « MSP — Manim Style & Protocol » de sorte que la sortie concrète soit une copie ou un script utilisable. La procédure suit une spécification de compétence de qualité professionnelle pour les animations Manim générées par IA, 0. DIRECTIVE PRINCIPALE, 1. ENVIRONNEMENT & VERROUILLAGE DE VERSION. Utilisez-la lorsqu'une nouvelle tâche fait appel à ce savoir-faire.

Qu'est-ce que MSP — Manim Style & Protocol ?

Cette compétence (Skill) spécifie un protocole complet et standardisé pour générer des animations Manim de qualité studio à l'aide d'un système d'IA. Elle est conçue pour tout système d'IA capable de générer du code (Claude Code, Cursor, Codex, etc.) et est compatible avec Manim Community Edition (ManimCE) ≥ v0.18. La compétence va au-delà de simples suggestions de code : elle fournit une directive stricte, des règles d'environnement, une structure de projet, des normes de conception visuelle, des protocoles de morphing et de transformation, des règles de timing et d'accélération, et un flux de travail de rendu. L'objectif est d'éviter la sortie d'animations « bas de gamme » par défaut et de faire en sorte que chaque scène ressemble au travail d'un studio professionnel. En suivant ce protocole, un agent IA produit systématiquement un code propre, bien organisé et visuellement fluide, en utilisant des transformations appropriées (comme TransformMatchingTex), des schémas de couleurs sémantiques, une typographie cohérente, et des techniques de composition de caméra avancées pour les animations 2D et 3D.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Frqme21/MSP-Manim-Style-protocol/tree/HEAD/v1

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait MSP — Manim Style & Protocol ?

Une spécification de compétence de qualité production pour les animations Manim générées par IA

Version: 1.0
Cible: Manim Community Edition (ManimCE) ≥ v0.18
Objectif: Permettre à tout système d'IA de générer par défaut des animations Manim propres, organisées, à morphing fluide et de qualité studio/production — et non comme une exception.

0. DIRECTIVE PRINCIPALE

Chaque scène que vous écrivez doit donner l'impression de provenir d'un studio d'animation professionnel, et non d'un script d'étudiant. Si un choix est ambigu, optez pour l'option la plus fluide, plus propre et plus intentionnelle — jamais le défaut le plus paresseux.

Avant d'écrire du code, parcourez silencieusement cette liste de contrôle :

  1. Quelle est l'unique idée que cette scène communique ?
  2. Quelle est la hiérarchie visuelle (que doit voir l'œil en premier, deuxième, troisième) ?
  3. Quelle palette de couleurs et quelle police est-ce que j'utilise, et est-ce cohérent à l'échelle du projet ?
  4. Comment chaque objet va-t-il entrer, se transformer et sortir — rien ne doit simplement « apparaître » ou « disparaître » sans un verbe d'animation.
  5. Quel est le rythme (budget total de run_time) pour la scène ?

1. ENVIRONNEMENT & VERROUILLAGE DE VERSION

Utilisez toujours par défaut Manim Community Edition, pas ManimGL, sauf si l'utilisateur demande explicitement le style 3b1b de ManimGL.

from manim import *
  • Binaire CLI : manim (pas manimgl)
  • Verbe de création : Create() (pas ShowCreation())
  • Rendu mathématique : MathTex(r"...") (pas Tex(R"..."))

Ne mélangez jamais les API. Si un extrait utilise self.camera.frame sans MovingCameraScene/ThreeDScene, signalez-le — c'est une syntaxe ManimGL qui s'infiltre.


2. STRUCTURE DE FICHIERS DU PROJET

Pour tout ce qui dépasse une scène triviale unique, imposez cette structure — ne mettez jamais tout dans un seul fichier monolithique :

projet/
├── manim.cfg              # configuration de rendu verrouillée (voir §9)
├── theme.py               # couleurs, polices, constantes (source unique de vérité)
├── helpers.py             # constructeurs de mobjects / fonctions de disposition réutilisables
├── scenes/
│   ├── 01_intro.py
│   ├── 02_derivation.py
│   └── 03_outro.py
└── assets/                # svgs, images, audio

Exemple de theme.py (CRÉEZ-EN TOUJOURS UN pour les projets multi-scènes) :

from manim import *

# ---- PALETTE ----
BG_COLOR      = "#0E0E12"
PRIMARY       = "#58C4DD"   # bleu par défaut de manim, ou couleur de marque
SECONDARY     = "#FFD166"
ACCENT        = "#EF476F"
TEXT_MAIN     = "#F5F5F5"
TEXT_MUTED    = "#8A8A8F"
SUCCESS       = "#06D6A0"

# ---- TYPOGRAPHIE ----
FONT_MAIN = "Helvetica"      # ou spécifique au projet
FONT_MONO = "JetBrains Mono"

# ---- CONSTANTES DE TEMPORISATION ----
T_FAST   = 0.5
T_NORMAL = 1.0
T_SLOW   = 1.8
LAG      = 0.08   # lag_ratio par défaut pour les révélations groupées

config.background_color = BG_COLOR

Chaque fichier de scène importe theme.py. Ne codez jamais en dur les couleurs hexadécimales ou les nombres magiques run_time en ligne une fois qu'un fichier de thème existe — c'est le marqueur n°1 d'une sortie non professionnelle et incohérente.


3. NORMES DE CONCEPTION VISUELLE

3.1 Règles de couleur

  • Maximum 4 à 5 couleurs par projet (1 fond, 1 à 2 primaires, 1 à 2 accents). Plus donne une impression de bruit/amateur.
  • Utilisez la couleur sémantiquement : même couleur = même signification dans toute la vidéo (par exemple, toujours bleu pour « donné », toujours rouge pour « inconnu »).
  • Le fond ne doit presque jamais être du noir pur (#000000) ou du blanc pur — utilisez un noir doux proche (#0E0E12) ou un blanc cassé doux pour réduire la fatigue oculaire et donner un aspect « studio ».

3.2 Règles typographiques

  • Text() pour les étiquettes d'interface, les titres, les légendes — rapide, sans dépendance LaTeX.
  • MathTex() pour toutes les notations mathématiques — ne simulez jamais les maths avec Text().
  • Tex() uniquement pour les blocs LaTeX mixtes prose + mathématiques.
  • Définissez un font= global via les constantes de thème ; ne laissez jamais le choix de la police varier d'une scène à l'autre.
  • Convention de titre : .to_edge(UP), poids gras, taille de police cohérente (par exemple, 40pt) dans chaque scène.

3.3 Règles de disposition

  • Respectez la règle des tiers — évitez de centrer par défaut ; utilisez .to_edge(), .shift(), .next_to() délibérément.
  • Maintenez des marges cohérentes (valeurs de buff) — définissez une constante MARGIN = 0.75 et réutilisez-la dans chaque appel .to_edge(..., buff=MARGIN).
  • Regroupez les objets connexes dans un seul VGroup et positionnez/animez le groupe, pas des mobjects individuels lâches — cela garantit que l'alignement reste correct après toute transformation ultérieure.
  • Appelez toujours .arrange() ou .arrange_in_grid() sur les groupes au lieu de calculer manuellement les coordonnées — les coordonnées manuelles sont fragiles et la source n°1 de dispositions cassées sous les modifications ultérieures.

4. LE PROTOCOLE DE MORPHING & DE TRANSFORMATION

C'est le cœur de l'animation « fluide et morphing » — le look signature des vidéos explicatives haut de gamme.

4.1 Règle : Ne jamais couper, toujours transformer

Si un objet devient conceptuellement un autre objet (équation réarrangée, forme devient une autre forme, étiquette mise à jour), ne jamais FadeOut + FadeIn en tant que mobjects distincts non liés — cela se lit comme un jump cut. Utilisez toujours une famille de transformations :

SituationOutil correct
L'équation se réarrange, les termes persistentTransformMatchingTex(ancien, nouveau)
La forme se transforme en une forme différenteTransform(ancien, nouveau) ou ReplacementTransform(ancien, nouveau)
Le groupe de mobjects se restructure (par exemple, liste à puces → diagramme)TransformMatchingShapes(ancien_groupe, nouveau_groupe)
Un objet remplace explicitement un autre dans le graphe de la scèneReplacementTransform (échange l'ancien contre le nouveau dans self.mobjects)
Fondu tout en suggérant une continuité (par exemple, fantôme/superposition)FadeTransform(ancien, nouveau)

Détail du protocole pour TransformMatchingTex : construisez toujours les deux mobjects MathTex avec un regroupement de sous-chaînes cohérent (les mêmes fragments LaTeX en tant que groupes {} séparés) afin que Manim puisse faire correspondre les symboles identiques — c'est ce qui fait que les termes « glissent » visuellement vers leur nouvelle position au lieu d'un fondu enchaîné.

eq1 = MathTex("a", "+", "b", "=", "c")
eq2 = MathTex("c", "=", "a", "+", "b")
self.play(TransformMatchingTex(eq1, eq2), run_time=1.2)

4.2 Règle : Utilisez .animate pour les morphing de propriétés simples

Pour les changements de propriétés continus uniques (position, échelle, couleur, rotation) sur un mobject, préférez la syntaxe .animate — elle est plus propre et Manim interpole la transformation nette automatiquement :

self.play(square.animate.shift(RIGHT * 2).scale(1.5).set_color(ACCENT), run_time=1.0)

Mise en garde (critique, évitez les bugs d'hallucination de l'IA) : les appels .animate enchaînés interpolent l'état net final, et non chaque étape intermédiaire de manière séquentielle. N'enchaînez jamais les appels .animate qui dépendent d'un résultat intermédiaire (par exemple, .animate.move_to(X).rotate(angle_depending_on_position)) — séparez-les en appels self.play() distincts.

4.3 Règle : Utilisez les Updaters pour le mouvement continu/dépendant

Chaque fois que l'état d'un objet doit suivre en continu un autre objet (une étiquette suivant un point, un affichage de valeur suivant un ValueTracker), utilisez add_updater, ne re-jouez jamais manuellement chaque image :

tracker = ValueTracker(0)
label = DecimalNumber(0).add_updater(lambda d: d.set_value(tracker.get_value()))
dot = Dot().add_updater(lambda m: m.move_to(axes.c2p(tracker.get_value(), f(tracker.get_value()))))
self.add(label, dot)
self.play(tracker.animate.set_value(5), run_time=3, rate_func=linear)

Supprimez toujours l'updater (remove_updater) (ou utilisez always_redraw pour une logique de recalcul à partir de zéro plus propre) une fois la phase de dépendance d'un objet terminée, pour éviter les bugs d'updaters obsolètes plus tard dans les longues scènes.


5. PROTOCOLE DE TEMPORISATION, DE RYTHME & D'ACCÉLÉRATION

5.1 Politique de fonction de taux par défaut

  • Par défaut (ne pas remplacer) : smooth — courbe en S ease-in/ease-out. À utiliser pour 90 % des animations — révélations d'équations, création de formes, mouvements standard.
  • linear : obligatoire pour tout ce qui représente un mouvement physique littéral à taux constant — points en orbite, vecteurs à vitesse uniforme, aiguilles d'horloge en rotation, barres de progression liées au temps réel écoulé.
  • rush_into / rush_from : à utiliser pour les entrées/sorties d'accentuation où quelque chose doit sembler se mettre en place ou s'élancer.
  • there_and_back / there_and_back_with_pause : à utiliser pour les impulsions d'attention de type Indicate, jamais pour les changements d'état permanents.
  • ease_out_bounce / ease_out_elastic : réservez pour un contenu ludique et informel uniquement — jamais dans une dérivation mathématique/scientifique formelle, où cela semble non professionnel.

5.2 Règles de budget de temporisation

  • Gardez le run_time individuel entre 0,4 s et 3 s. En dessous de 0,4 s, c'est saccadé ; au-dessus de 3 s (sans raison narrative), ça traîne.
  • Entrées de titres/en-têtes de section : 0,8–1,2 s.
  • Transformations d'équations/diagrammes : 1,0–1,5 s.
  • Impulsions d'accentuation (Indicate, Flash, Circumscribe) : 0,5–0,8 s.
  • Mouvements de caméra (move_camera, self.camera.frame.animate) : 1,5–3 s — les mouvements de caméra plus rapides donnent la nausée.
  • Insérez des respirations self.wait(0,3–1,0) délibérées après chaque révélation majeure — n'enchaînez jamais les appels self.play() dos à dos sans pause ; cela submerge le spectateur.

5.3 Protocole de composition

  • Événements simultanés mais indépendants → un seul appel self.play(AnimA, AnimB, ...).
  • Simultané avec départ décalé (par exemple, 6 points de puce apparaissant en séquence mais se chevauchant) → LaggedStart(*anims, lag_ratio=0,15).
  • Événements strictement séquentiels et dépendants → Succession(*anims) ou appels self.play() séparés.
  • Révélations de listes/grilles (puces, grilles de formes) → toujours LaggedStartMap(FadeIn, group, lag_ratio=0,08, shift=UP*0.3) au lieu d'un seul FadeIn(group) simultané — le décalage est ce qui rend les entrées de groupe organiques plutôt que robotiques.

6. PROTOCOLE D'ORGANISATION DES SCÈNES & DU CODE

6.1 Forme de la méthode construct

Décomposez toujours construct() en phases nommées clairement délimitées via des commentaires ou des méthodes d'aide — jamais un bloc ininterrompu de 100 lignes :

class DerivationScene(Scene):
    def construct(self):
        self.setup_title()
        self.show_initial_equation()
        self.derive_steps()
        self.highlight_result()
        self.cleanup()

    def setup_title(self):
        self.title = Text("Dérivation de la formule quadratique", font=FONT_MAIN).to_edge(UP)
        self.play(Write(self.title), run_time=T_NORMAL)
        self.wait(T_FAST)

    def show_initial_equation(self):
        ...

Pour les longues vidéos, divisez en plusieurs classes de scène (une par section logique) plutôt qu'un seul construct() géant — cela permet un rendu ciblé via -n et une itération parallèle.

6.2 Protocole de construction des mobjects

  • Construisez des visuels personnalisés complexes (diagrammes, graphiques, icônes) en tant que fonctions autonomes dans helpers.py retournant un VGroup, et non en ligne dans construct() :
# helpers.py
def make_neuron(radius=0.3, color=PRIMARY) -> VGroup:
    circle = Circle(radius=radius, color=color, fill_opacity=0.8)
    label = Text("n", font_size=20).move_to(circle)
    return VGroup(circle, label)
  • Nommez toujours les mobjects de manière significative (title, eq_initial, graph_group) — ne laissez jamais de littéraux anonymes non référencés que vous devrez modifier ou transformer plus tard.
  • Utilisez z_index explicitement pour toute scène avec des couches qui se chevauchent (ne vous fiez pas uniquement à l'ordre d'ajout une fois qu'il y a plus de 2 couches).

6.3 Règles de style / linting

  • snake_case pour les variables/méthodes, PascalCase pour les sous-classes de Scene.
  • Une ligne vide entre les « temps forts » d'animation dans le code pour la lisibilité — la structure du code doit refléter visuellement le rythme de la vidéo.
  • Pas de nombres magiques nus pour la couleur/position/timing — référencez toujours les constantes de theme.py.
  • Type-hint pour les fonctions d'aide (def make_axes() -> Axes:) pour la maintenabilité sur les grands projets.

7. PROTOCOLE DE COMPOSITION & DE CAMÉRA (2D & 3D)

2D

  • Utilisez MovingCameraScene lorsque la vidéo doit panoramiquer/zoomer en 2D (par exemple, se concentrer sur une sous-région d'un diagramme) — animez via self.camera.frame.animate.move_to(...).set(width=...), toujours avec un run_time explicite.

3D

  • Sous-classez ThreeDScene.
  • Définissez l'orientation initiale avec self.set_camera_orientation(phi=70*DEGREES, theta=-45*DEGREES, zoom=1) dans une étape de configuration dédiée — ne laissez jamais l'orientation par défaut sauf si c'est intentionnel.
  • Pour tout repositionnement de caméra que le spectateur doit percevoir comme un mouvement, utilisez self.move_camera(phi=..., theta=..., run_time=2.5) — ne faites jamais de jump cut via set_camera_orientation au milieu d'une scène.
  • Utilisez self.begin_ambient_camera_rotation(rate=0.15) pour une rotation lente au repos sous narration ; associez toujours à self.stop_ambient_camera_rotation() avant tout move_camera délibéré ultérieur.
  • HUD/étiquettes/titres qui doivent rester lisibles quel que soit l'angle de la caméra → self.add_fixed_in_frame_mobjects(label).
  • Étiquettes qui doivent suivre des objets 3D mais rester lisibles → self.add_fixed_orientation_mobjects(label).
  • Gardez les tuples de résolution de surface 3D bas (par exemple, (24,24)) pendant l'itération ; augmentez uniquement pour le rendu de production final — c'est purement une règle de performance/flux de travail, pas visuelle.

8. PROTOCOLE D'ACCENTUATION & D'ATTENTION

Ne laissez jamais un résultat clé visuellement identique au contenu de support. Après avoir révélé le « payoff » d'une scène (équation finale, idée clé, résultat), appliquez exactement une technique d'accentuation — n'en empilez pas plus d'une ou cela semble frénétique :

  • Circumscribe(mobject, color=ACCENT, run_time=1.2) — dessine une forme autour de lui.
  • Indicate(mobject, scale_factor=1.15) — brève impulsion d'échelle + flash de couleur.
  • Flash(point, color=ACCENT) — rafale radiale, bien pour un point/intersection spécifique.
  • mobject.animate.set_color(ACCENT) combiné à une légère échelle — pour un recoloriage permanent signalant "c'est la réponse."

9. PROTOCOLE DE RENDU & D'EXPORTATION

9.1 Fichier de configuration verrouillé (validez-le — ne vous fiez jamais aux indicateurs ad hoc pour la livraison finale)

manim.cfg :

[CLI]
quality = production_quality
preview = False
background_color = "#0E0E12"
output_file = {scene_name}
frame_rate = 60
pixel_height = 1080
pixel_width = 1920

9.2 Étapes du flux de travail (suivez toujours cet ordre, ne rendez jamais la qualité finale en premier)

  1. Passe de brouillon : manim -pql scenes/02_derivation.py DerivationScene — itération rapide, vérifiez la logique/le timing.
  2. Passe de vérification ponctuelle : manim -pqh -s scenes/02_derivation.py DerivationScene — vérification haute qualité d'une seule image de la composition/couleur.
  3. Passe de rendu final : manim -pqh scenes/02_derivation.py DerivationScene — rendu complet haute qualité.

9.3 Rendu en mode transparent (écran vert / alpha)

Pour tout contenu qui sera superposé à un autre métrage ou arrière-plan, utilisez un fond transparent :

config.frame_rate = 60
config.pixel_height = 1080
config.pixel_width = 1920
config.background_color = "#00000000"  # Chaîne hexadécimale 8 caractères avec transparence

Ensuite, rendez avec le drapeau --write_all pour écrire chaque image animée sous forme de séquence PNG avec canal alpha :

manim scenes/02_derivation.py DerivationScene -pqh --write_all

Combinez ensuite les images via le pipeline vidéo de votre choix (FFmpeg, AE, etc.).


10. PROTOCOLE DE RÉFÉRENCE DE LA DOCUMENTATION & DES FONCTIONS

Pour toute fonction d'API Manim dont vous n'êtes pas sûr à 100 % de la signature, de l'ordre des paramètres ou de la version dans laquelle elle a été introduite/supprimée :

  1. Ne l'inventez pas. Ne remplacez pas un paramètre booléen fill_color manquant par color et n'assumez pas que l'API a une fonctionnalité qu'elle n'a pas.
  2. Consultez la documentation officielle via l'exploration de code (pas une estimation nuancée) : https://docs.manim.community/en/stable/reference/<ClasseMobject>.html.
  3. Les API héritées/manimGL courantes à éviter : ShowCreation, FadeInFromDown, get_center, get_top, set_color_by_gradient (utilisez set_color_by_gradient de ManimCE), add_foreground_mobject. Utilisez toujours les alternatives modernes de ManimCE.

11. RÈGLES ANTI-BOUCLES INFINIES & DE SÉCURITÉ

  • Fixez toujours un run_time explicite pour chaque self.play() — les valeurs par défaut non définies peuvent être extrêmement lentes ou boucler indéfiniment dans des cas extrêmes.
  • Ne créez jamais d'updaters qui se modifient eux-mêmes récursivement. Exemple de bug :
# MAUVAIS — modifie la position en fonction du temps, puis appelle play, ce qui ajoute +t, boucle infinie
self.time = 0
def bad_updater(mob):
    self.time += self.dt
    mob.move_to(RIGHT * np.sin(self.time))
    self.play(mob.animate.shift(UP))  # BOUCLE ! Ne faites jamais play dans un updater
  • Les transformations (Transform, ReplacementTransform) doivent avoir des diplômes (degrees de soi ou de la scène) compatibles ; si les mobjects source et cible ont des structures de sous-mobjects radicalement différentes, utilisez TransformMatchingShapes qui fonctionne par correspondance de courbes.
  • Si une animation nécessite plus de 3 transformations simultanées, refactorez en une seule animation de groupe avec un seul appel self.play() — 5 self.play() simultanés séparent conceptuellement les événements que l'œil perçoit comme un seul mouvement, ce qui entraîne une désynchronisation visuelle.

12. PROTOCOLE AUDIO (OPTIONNEL MAIS RECOMMANDÉ)

Si un fichier audio de narration ou de fond est fourni, l'animation doit être une interprétation visuelle directe du rythme et des points d'emphase de la piste audio :

  1. Analysez les indices temporels de l'audio (soit depuis un fichier .srt, soit depuis des repères temporels explicites fournis) — alignez chaque révélation majeure sur un mot/syllabe accentué.
  2. Concaténez les scènes + audio dans le montage final en utilisant un outil externe (FFmpeg, DaVinci Resolve, AE) — ne cherchez pas à rendre l'audio exactement dans Manim ; Manim n'est pas un outil de montage non linéaire.
  3. Si aucun audio n'est fourni, supposez un rythme de narration lent et délibéré (~150 mots/min) et espacez les animations en conséquence — plus de self.wait() que pour une vidéo muette.

13. PROTOCOLE DE REVUE & D'AUTO-VÉRIFICATION

Avant de finaliser un rendu, parcourez cette liste de contrôle de manière algorithmique — ne la sautez jamais, même pour un « petit » changement :

  • Tous les run_time sont-ils dans la plage acceptée (0,4–3 s) ?
  • Les entrées et sorties ont-elles des verbes d'animation ? (Pas d'apparitions/disparitions soudaines)
  • Les transformations sont-elles de la bonne famille ? (Transform vs. TransformMatchingTex vs. FadeTransform)
  • Les couleurs sont-elles référencées depuis theme.py et non codées en dur ?
  • Tous les appels self.play() ont-ils un run_time ou lag_ratio explicite ?
  • La composition suit-elle la règle des tiers ou une disposition intentionnelle ? (Pas de centrage par défaut qui a une belle apparence ?)
  • Les appels simultanés self.play() sont-ils logiquement regroupés (même « temps » dans l'esprit du spectateur) ?
  • Y a-t-il une wait() après les révélations majeures ?
  • La scène importe-t-elle theme.py et utilise-t-elle ses constantes ?
  • Les mobjects ont-ils des noms significatifs ? (Pas de v1, v2, temp)
  • La fonction rate_func est-elle correcte pour le mouvement ? (linear pour le mouvement à taux constant, smooth pour tout le reste)
  • Le code évite-t-il d'utiliser des API Markdown ? (Aucune répétition de balises markdown dans les chaînes de code Python — codez les animations Manim en Python pur, pas de balisage markdown dans les appels de fonction).

14. EXEMPLE DE SCÈNE COMPLÈTE (RÉFÉRENCE DE FONCTIONNEMENT)

# scenes/example.py
from theme import *

class ExampleScene(Scene):
    def construct(self):
        # 1. Titre
        title = Text("Loi de Gauss", font=FONT_MAIN).to_edge(UP)
        self.play(Write(title), run_time=T_NORMAL)
        self.wait(T_FAST)

        # 2. Équation initiale
        eq = MathTex(r"\oint \mathbf{E} \cdot d\mathbf{A} = \frac{Q_{\text{enc}}}{\epsilon_0}")
        self.play(Write(eq), run_time=T_NORMAL)
        self.wait(T_FAST)

        # 3. Transformer pour développer
        eq2 = MathTex(r"\oint \mathbf{E} \cdot d\mathbf{A}", "=", r"\frac{Q_{\text{enc}}}{\epsilon_0}")
        self.play(TransformMatchingTex(eq, eq2), run_time=T_SLOW)
        self.wait(T_NORMAL)

        # 4. Mettre en évidence des parties
        box = SurroundingRectangle(eq2[2], color=ACCENT, buff=0.1)
        self.play(Create(box), run_time=T_FAST)
        self.wait()

Fin de MSP — Manim Style & Protocol v1.0

Skills associés