Fix Bug Uncreate() with rate_func via introducing new parameter reversed to class Animation (ManimCommunity#2597)

* `Uncreate()` works with `rate_func` ,fix ManimCommunity#2469

Place the reverse of `rate_func` to become part of the process in `Uncreate()`.

The original `uncreate()` is implemented by setting a specific value to `rate_func`.

Now, if you want to set parameter`rate_func` when using `Uncreate()`, you can set the parameter `reverse_rate_func` to `Uncreate()`.

Examples

```python
.. manim:: ShowUncreate

        class ShowUncreate(Scene):
            def construct(self):
                self.play(Uncreate(Square(), reverse_rate_func=linear))
```

But problems remains when you try to pass parameter `rate_func` to `Scene.play()`

* fix issue ManimCommunity#2469

* Add parameter reversed to class Animation

Fix an error in the last [commit](darkway-s@47b5196). The "remover" decided whether it would reverse. Now it correctly passes the power of decision to "reversed".
Add a bool parameter `reversed` to class `Animation`. It decides whether the animation need to be played backwards. Default to be False.

* Add unit tests for usages of `Uncreate()`

* Add control data for the new unit test

* change the implementation of `Unwrite` to the same logic as `Uncreate`

* Rename parameter `reversed`, add descriptions, style ManimCommunity#2597

Rename `reversed` to the more explicit `reverse_rate_function`, in class Animation.
Explicitly mention in documentation that setting `reverse_rate_function` doesn't have any effect on `remover` and `introducer`.

* improve documentation of parameter `reverse_rate_function`, doc ManimCommunity#2597

improve documentation of parameter `reverse_rate_function` in class `Animation`

Co-authored-by: Benjamin Hackl <[email protected]>

* doc: remove unnecessary comments in creation.py

The comment was added because the name of the parameter `reversed` was similar to reverse, which is a also parameter, but defined in Write().
Now the parameter has a more explicit name `reverse_rate_function`. Developers can get the main idea from its name. So we don't need the comment to tell.

Co-authored-by: Sefik-Palazoglu <[email protected]>
Co-authored-by: Benjamin Hackl <[email protected]>

Author: 3 people

manim/animation/animation.py

@@ -49,6 +49,13 @@ class Animation:
 
         For example ``rate_func(0.5)`` is the proportion of the animation that is done
         after half of the animations run time.
+
+
+    reverse_rate_function
+        Reverses the rate function of the animation. Setting ``reverse_rate_function``
+        does not have any effect on ``remover`` or ``introducer``. These need to be
+        set explicitly if an introducer-animation should be turned into a remover one
+        and vice versa.
     name
         The name of the animation. This gets displayed while rendering the animation.
         Defaults to <class-name>(<Mobject-name>).
@@ -123,6 +130,7 @@ def __init__(
         lag_ratio: float = DEFAULT_ANIMATION_LAG_RATIO,
         run_time: float = DEFAULT_ANIMATION_RUN_TIME,
         rate_func: Callable[[float], float] = smooth,
+        reverse_rate_function: bool = False,
         name: str = None,
         remover: bool = False,  # remove a mobject from the screen?
         suspend_mobject_updating: bool = True,
@@ -134,6 +142,7 @@ def __init__(
         self._typecheck_input(mobject)
         self.run_time: float = run_time
         self.rate_func: Callable[[float], float] = rate_func
+        self.reverse_rate_function: bool = reverse_rate_function
         self.name: str | None = name
         self.remover: bool = remover
         self.introducer: bool = introducer
@@ -361,7 +370,10 @@ def get_sub_alpha(self, alpha: float, index: int, num_submobjects: int) -> float
         full_length = (num_submobjects - 1) * lag_ratio + 1
         value = alpha * full_length
         lower = index * lag_ratio
-        return self.rate_func(value - lower)
+        if self.reverse_rate_function:
+            return self.rate_func(1 - (value - lower))
+        else:
+            return self.rate_func(value - lower)
 
     # Getters and setters
     def set_run_time(self, run_time: float) -> Animation:

manim/animation/creation.py

@@ -191,13 +191,13 @@ def construct(self):
     def __init__(
         self,
         mobject: VMobject | OpenGLVMobject,
-        rate_func: Callable[[float], float] = lambda t: smooth(1 - t),
+        reverse_rate_function: bool = True,
         remover: bool = True,
         **kwargs,
     ) -> None:
         super().__init__(
             mobject,
-            rate_func=rate_func,
+            reverse_rate_function=reverse_rate_function,
             introducer=False,
             remover=remover,
             **kwargs,
@@ -405,7 +405,7 @@ def __init__(
             vmobject,
             run_time=run_time,
             lag_ratio=lag_ratio,
-            rate_func=lambda t: -rate_func(t) + 1,
+            reverse_rate_function=True,
             reverse=reverse,
             **kwargs,
         )

tests/test_graphical_units/control_data/creation/uncreate_rate_func.npz

@@ -19,6 +19,13 @@ def test_uncreate(scene):
     scene.play(Uncreate(square))
 
 
+@frames_comparison(last_frame=False)
+def test_uncreate_rate_func(scene):
+    square = Square()
+    scene.add(square)
+    scene.play(Uncreate(square), rate_func=linear)
+
+
 @frames_comparison(last_frame=False)
 def test_DrawBorderThenFill(scene):
     square = Square(fill_opacity=1)