release: ready to release v1.5.0

workflow: only build wheels for python 3.6+
Merge branch 'master' of https://github.com/3b1b/manim
2026-01-13 08:27:54 -05:00 · 2022-02-16 12:01:03 +08:00 · 2022-02-16 11:59:33 +08:00 · 2022-02-16 11:21:20 +08:00 · 2022-02-16 11:20:08 +08:00 · 2022-02-16 11:17:37 +08:00
40 changed files with 1425 additions and 1185 deletions
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -8,6 +8,11 @@ jobs:
  deploy:
    runs-on: ubuntu-latest

+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["py36", "py37", "py38", "py39", "py310"]
+
    steps:
    - uses: actions/checkout@v2

@@ -20,11 +25,13 @@ jobs:
      run: |
        python -m pip install --upgrade pip
        pip install setuptools wheel twine build
-    
-    - name: Build and publish
+
+    - name: Build wheels
+      run: python setup.py bdist_wheel --python-tag ${{ matrix.python }}
+
+    - name: Upload wheels
      env:
        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
      run: |
-        python -m build
        twine upload dist/*
--- a/docs/source/development/changelog.rst
+++ b/docs/source/development/changelog.rst
@@ -1,69 +1,152 @@
 Changelog
 =========

+v1.5.0
+------
+
+Fixed bugs
+^^^^^^^^^^
+- Bug fix for the case of calling ``Write`` on a null object (`#1740 <https://github.com/3b1b/manim/pull/1740>`__)
+
+
+New Features
+^^^^^^^^^^^^
+- Added ``TransformMatchingMTex`` (`#1725 <https://github.com/3b1b/manim/pull/1725>`__)
+- Added ``ImplicitFunction`` (`#1727 <https://github.com/3b1b/manim/pull/1727>`__)
+- Added ``Polyline`` (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
+- Allowed ``Mobject.set_points`` to take in an empty list, and added ``Mobject.add_point`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/a64259158538eae6043566aaf3d3329ff4ac394b>`__)
+- Added ``Scene.refresh_locked_data`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/33d2894c167c577a15fdadbaf26488ff1f5bff87>`__)
+- Added presenter mode to scenes with ``-p`` option (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/9a9cc8bdacb7541b7cd4a52ad705abc21f3e27fe>`__ and `#1742 <https://github.com/3b1b/manim/pull/1742>`__)
+- Allowed for an embed by hitting ``ctrl+shift+e`` during interaction (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/9df12fcb7d8360e51cd7021d6877ca1a5c31835e>`__ and `#1746 <https://github.com/3b1b/manim/pull/1746>`__)
+- Added ``Mobject.set_min_width/height/depth`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/2798d15591a0375ae6bb9135473e6f5328267323>`__)
+- Allowed ``Mobject.match_coord/x/y/z`` to take in a point (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/29a4d3e82ba94c007c996b2d1d0f923941452698>`__)
+- Added ``text_config`` to ``DecimalNumber`` (`#1744 <https://github.com/3b1b/manim/pull/1744>`__)
+
+
+Refactor
+^^^^^^^^
+- Refactored ``MTex`` (`#1725 <https://github.com/3b1b/manim/pull/1725>`__)
+- Refactored ``SVGMobject`` with svgelements (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
+- Made sure ``ParametricCurve`` has at least one point (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/2488b9e866fb1ecb842a27dd9f4956ec167e3dee>`__)
+- Set default to no tips on ``Axes`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/6c6d387a210756c38feca7d34838aa9ac99bb58a>`__)
+- Stopped displaying when writing tex string is happening (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/58e06e8f6b7c5059ff315d51fd0018fec5cfbb05>`__)
+- Reorganize inheriting order and refactor SVGMobject (`#1745 <https://github.com/3b1b/manim/pull/1745>`__)
+
+
+Dependencies
+^^^^^^^^^^^^
+- Added dependency on ``isosurfaces`` (`#1727 <https://github.com/3b1b/manim/pull/1727>`__)
+- Removed dependency on ``argparse`` since it's a built-in module (`#1728 <https://github.com/3b1b/manim/pull/1728>`__)
+- Removed dependency on ``pyreadline`` (`#1728 <https://github.com/3b1b/manim/pull/1728>`__)
+- Removed dependency on ``cssselect2`` (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
+- Added dependency on ``svgelements`` (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
+
+
+v1.4.1
+------
+
+Fixed bugs 
+^^^^^^^^^^
+- Temporarily fixed boolean operations' bug  (`#1724 <https://github.com/3b1b/manim/pull/1724>`__)
+- Import ``Iterable`` from ``collections.abc`` instead of ``collections`` which is deprecated since python 3.9 (`d2e0811 <https://github.com/3b1b/manim/commit/d2e0811285f7908e71a65e664fec88b1af1c6144>`__)
+
+v1.4.0
+------
+
+Fixed bugs
+^^^^^^^^^^
+- Temporarily fixed ``Lightbulb`` (`f1996f8 <https://github.com/3b1b/manim/pull/1697/commits/f1996f8479f9e33d626b3b66e9eb6995ce231d86>`__)
+- Fixed some bugs of ``SVGMobject`` (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
+- Fixed some bugs of SVG path string parser (`#1717 <https://github.com/3b1b/manim/pull/1717>`__)
+- Fixed some bugs of ``MTex`` (`#1720 <https://github.com/3b1b/manim/pull/1720>`__)
+
+New Features
+^^^^^^^^^^^^
+- Added option to add ticks on x-axis in ``BarChart`` (`#1694 <https://github.com/3b1b/manim/pull/1694>`__)
+- Added ``lable_buff`` config parameter for ``Brace`` (`#1704 <https://github.com/3b1b/manim/pull/1704>`__)
+- Added support for ``rotate skewX skewY`` transform in SVG  (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
+- Added style support to ``SVGMobject`` (`#1717 <https://github.com/3b1b/manim/pull/1717>`__)
+- Added parser to <style> element of SVG  (`#1719 <https://github.com/3b1b/manim/pull/1719>`__)
+- Added support for <line> element in ``SVGMobject`` (`#1719 <https://github.com/3b1b/manim/pull/1719>`__)
+
+Refactor 
+^^^^^^^^
+- Used ``FFMPEG_BIN`` instead of ``"ffmpeg"`` for sound incorporation (`5aa8d15 <https://github.com/3b1b/manim/pull/1697/commits/5aa8d15d85797f68a8f169ca69fd90d441a3abbe>`__)
+- Decorated ``CoordinateSystem.get_axes`` and ``.get_all_ranges`` as abstract method  (`#1709 <https://github.com/3b1b/manim/pull/1709>`__)
+- Refactored SVG path string parser (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
+- Allowed ``Mobject.scale`` to receive iterable ``scale_factor`` (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
+- Refactored ``MTex`` (`#1716 <https://github.com/3b1b/manim/pull/1716>`__)
+- Improved config helper (``manimgl --config``) (`#1721 <https://github.com/3b1b/manim/pull/1721>`__)
+- Refactored ``MTex`` (`#1723 <https://github.com/3b1b/manim/pull/1723>`__)
+
+Dependencies
+^^^^^^^^^^^^
+- Added dependency on python package `cssselect2 <https://github.com/Kozea/cssselect2>`__ (`#1719 <https://github.com/3b1b/manim/pull/1719>`__)
+
+
 v1.3.0
 ------

 Fixed bugs 
 ^^^^^^^^^^

- `#1653 <https://github.com/3b1b/manim/pull/1653>`__: Fixed ``Mobject.stretch_to_fit_depth``
- `#1655 <https://github.com/3b1b/manim/pull/1655>`__: Fixed the bug of rotating camera
- `c73d507 <https://github.com/3b1b/manim/pull/1688/commits/c73d507c76af5c8602d4118bc7538ba04c03ebae>`__: Fixed ``SurfaceMesh`` to be evenly spaced
- `82bd02d <https://github.com/3b1b/manim/pull/1688/commits/82bd02d21fbd89b71baa21e077e143f440df9014>`__: Fixed ``angle_between_vectors`` add ``rotation_between_vectors``
- `a717314 <https://github.com/3b1b/manim/pull/1688/commits/a7173142bf93fd309def0cc10f3c56f5e6972332>`__: Fixed ``VMobject.fade``
- `fbc329d <https://github.com/3b1b/manim/pull/1688/commits/fbc329d7ce3b11821d47adf6052d932f7eff724a>`__: Fixed ``angle_between_vectors``
- `bcd0990 <https://github.com/3b1b/manim/pull/1688/commits/bcd09906bea5eaaa5352e7bee8f3153f434cf606>`__: Fixed bug in ``ShowSubmobjectsOneByOne``
- `7023548 <https://github.com/3b1b/manim/pull/1691/commits/7023548ec62c4adb2f371aab6a8c7f62deb7c33c>`__: Fixed bug in ``TransformMatchingParts``
+- Fixed ``Mobject.stretch_to_fit_depth`` (`#1653 <https://github.com/3b1b/manim/pull/1653>`__)
+- Fixed the bug of rotating camera (`#1655 <https://github.com/3b1b/manim/pull/1655>`__)
+- Fixed ``SurfaceMesh`` to be evenly spaced (`c73d507 <https://github.com/3b1b/manim/pull/1688/commits/c73d507c76af5c8602d4118bc7538ba04c03ebae>`__)
+- Fixed ``angle_between_vectors`` add ``rotation_between_vectors`` (`82bd02d <https://github.com/3b1b/manim/pull/1688/commits/82bd02d21fbd89b71baa21e077e143f440df9014>`__)
+- Fixed ``VMobject.fade`` (`a717314 <https://github.com/3b1b/manim/pull/1688/commits/a7173142bf93fd309def0cc10f3c56f5e6972332>`__)
+- Fixed ``angle_between_vectors`` (`fbc329d <https://github.com/3b1b/manim/pull/1688/commits/fbc329d7ce3b11821d47adf6052d932f7eff724a>`__)
+- Fixed bug in ``ShowSubmobjectsOneByOne`` (`bcd0990 <https://github.com/3b1b/manim/pull/1688/commits/bcd09906bea5eaaa5352e7bee8f3153f434cf606>`__)
+- Fixed bug in ``TransformMatchingParts`` (`7023548 <https://github.com/3b1b/manim/pull/1691/commits/7023548ec62c4adb2f371aab6a8c7f62deb7c33c>`__)

 New Features
 ^^^^^^^^^^^^

- `e10f850 <https://github.com/3b1b/manim/commit/e10f850d0d9f971931cc85d44befe67dc842af6d>`__: Added CLI flag ``--log-level`` to specify log level
- `#1667 <https://github.com/3b1b/manim/pull/1667>`__: Added operations (``+`` and ``*``) for ``Mobject``
- `#1675 <https://github.com/3b1b/manim/pull/1675>`__: Added 4 boolean operations for ``VMobject`` in ``manimlib/mobject/boolean_ops.py``
+- Added CLI flag ``--log-level`` to specify log level (`e10f850 <https://github.com/3b1b/manim/commit/e10f850d0d9f971931cc85d44befe67dc842af6d>`__)
+- Added operations (``+`` and ``*``) for ``Mobject`` (`#1667 <https://github.com/3b1b/manim/pull/1667>`__)
+- Added 4 boolean operations for ``VMobject`` in ``manimlib/mobject/boolean_ops.py`` (`#1675 <https://github.com/3b1b/manim/pull/1675>`__)

  - ``Union(*vmobjects, **kwargs)``  
  - ``Difference(subject, clip, **kwargs)`` 
  - ``Intersection(*vmobjects, **kwargs)`` 
  - ``Exclusion(*vmobjects, **kwargs)`` 
- `81c3ae3 <https://github.com/3b1b/manim/pull/1688/commits/81c3ae30372e288dc772633dbd17def6e603753e>`__: Added reflectiveness
- `2c7689e <https://github.com/3b1b/manim/pull/1688/commits/2c7689ed9e81229ce87c648f97f26267956c0bc9>`__: Enabled ``glow_factor`` on ``DotCloud``
- `d065e19 <https://github.com/3b1b/manim/pull/1688/commits/d065e1973d1d6ebd2bece81ce4bdf0c2fff7c772>`__: Added option ``-e`` to insert embed line from the command line
- `0e78027 <https://github.com/3b1b/manim/pull/1688/commits/0e78027186a976f7e5fa8d586f586bf6e6baab8d>`__: Improved ``point_from_proportion`` to account for arc length
- `781a993 <https://github.com/3b1b/manim/pull/1688/commits/781a9934fda6ba11f22ba32e8ccddcb3ba78592e>`__: Added shortcut ``set_backstroke`` for setting black background stroke
- `0b898a5 <https://github.com/3b1b/manim/pull/1688/commits/0b898a5594203668ed9cad38b490ab49ba233bd4>`__: Added ``Suface.always_sort_to_camera``
- `e899604 <https://github.com/3b1b/manim/pull/1688/commits/e899604a2d05f78202fcb3b9824ec34647237eae>`__: Added getter methods for specific euler angles
- `407c53f <https://github.com/3b1b/manim/pull/1688/commits/407c53f97c061bfd8a53beacd88af4c786f9e9ee>`__: Hade ``rotation_between_vectors`` handle identical/similar vectors
- `49743da <https://github.com/3b1b/manim/pull/1688/commits/49743daf3244bfa11a427040bdde8e2bb79589e8>`__: Added ``Mobject.insert_submobject`` method
- `9dd1f47 <https://github.com/3b1b/manim/pull/1688/commits/9dd1f47dabca1580d6102e34e44574b0cba556e7>`__: Created single progress display for full scene render
- `264f7b1 <https://github.com/3b1b/manim/pull/1691/commits/264f7b11726e9e736f0fe472f66e38539f74e848>`__: Added ``Circle.get_radius``
- `83841ae <https://github.com/3b1b/manim/pull/1691/commits/83841ae41568a9c9dff44cd163106c19a74ac281>`__: Added ``Dodecahedron``
- `a1d5147 <https://github.com/3b1b/manim/pull/1691/commits/a1d51474ea1ce3b7aa3efbe4c5e221be70ee2f5b>`__: Added ``GlowDot``
- `#1678 <https://github.com/3b1b/manim/pull/1678>`__: Added ``MTex`` , see `#1678 <https://github.com/3b1b/manim/pull/1678>`__ for details
+- Added reflectiveness (`81c3ae3 <https://github.com/3b1b/manim/pull/1688/commits/81c3ae30372e288dc772633dbd17def6e603753e>`__)
+- Enabled ``glow_factor`` on ``DotCloud`` (`2c7689e <https://github.com/3b1b/manim/pull/1688/commits/2c7689ed9e81229ce87c648f97f26267956c0bc9>`__)
+- Added option ``-e`` to insert embed line from the command line (`d065e19 <https://github.com/3b1b/manim/pull/1688/commits/d065e1973d1d6ebd2bece81ce4bdf0c2fff7c772>`__)
+- Improved ``point_from_proportion`` to account for arc length (`0e78027 <https://github.com/3b1b/manim/pull/1688/commits/0e78027186a976f7e5fa8d586f586bf6e6baab8d>`__)
+- Added shortcut ``set_backstroke`` for setting black background stroke (`781a993 <https://github.com/3b1b/manim/pull/1688/commits/781a9934fda6ba11f22ba32e8ccddcb3ba78592e>`__)
+- Added ``Suface.always_sort_to_camera`` (`0b898a5 <https://github.com/3b1b/manim/pull/1688/commits/0b898a5594203668ed9cad38b490ab49ba233bd4>`__)
+- Added getter methods for specific euler angles (`e899604 <https://github.com/3b1b/manim/pull/1688/commits/e899604a2d05f78202fcb3b9824ec34647237eae>`__)
+- Hade ``rotation_between_vectors`` handle identical/similar vectors (`407c53f <https://github.com/3b1b/manim/pull/1688/commits/407c53f97c061bfd8a53beacd88af4c786f9e9ee>`__)
+- Added ``Mobject.insert_submobject`` method (`49743da <https://github.com/3b1b/manim/pull/1688/commits/49743daf3244bfa11a427040bdde8e2bb79589e8>`__)
+- Created single progress display for full scene render (`9dd1f47 <https://github.com/3b1b/manim/pull/1688/commits/9dd1f47dabca1580d6102e34e44574b0cba556e7>`__)
+- Added ``Circle.get_radius`` (`264f7b1 <https://github.com/3b1b/manim/pull/1691/commits/264f7b11726e9e736f0fe472f66e38539f74e848>`__)
+- Added ``Dodecahedron`` (`83841ae <https://github.com/3b1b/manim/pull/1691/commits/83841ae41568a9c9dff44cd163106c19a74ac281>`__)
+- Added ``GlowDot`` (`a1d5147 <https://github.com/3b1b/manim/pull/1691/commits/a1d51474ea1ce3b7aa3efbe4c5e221be70ee2f5b>`__)
+- Added ``MTex`` , see `#1678 <https://github.com/3b1b/manim/pull/1678>`__ for details (`#1678 <https://github.com/3b1b/manim/pull/1678>`__)

 Refactor
 ^^^^^^^^

- `#1662 <https://github.com/3b1b/manim/pull/1662>`__: Refactored support for command ``A`` in path of SVG 
- `#1662 <https://github.com/3b1b/manim/pull/1662>`__: Refactored ``SingleStringTex.balance_braces``
- `8b454fb <https://github.com/3b1b/manim/pull/1688/commits/8b454fbe9335a7011e947093230b07a74ba9c653>`__: Slight tweaks to how saturation_factor works on newton-fractal
- `317a5d6 <https://github.com/3b1b/manim/pull/1688/commits/317a5d6226475b6b54a78db7116c373ef84ea923>`__: Made it possible to set full screen preview as a default
- `e764da3 <https://github.com/3b1b/manim/pull/1688/commits/e764da3c3adc5ae2a4ce877b340d2b6abcddc2fc>`__: Used ``quick_point_from_proportion`` for graph points
- `d2182b9 <https://github.com/3b1b/manim/pull/1688/commits/d2182b9112300558b6c074cefd685f97c10b3898>`__: Made sure ``Line.set_length`` returns self
- `eea3c6b <https://github.com/3b1b/manim/pull/1688/commits/eea3c6b29438f9e9325329c4355e76b9f635e97a>`__: Better align ``SurfaceMesh`` to the corresponding surface polygons
- `ee1594a <https://github.com/3b1b/manim/pull/1688/commits/ee1594a3cb7a79b8fc361e4c4397a88c7d20c7e3>`__: Match ``fix_in_frame`` status for ``FlashAround`` mobject
- `ba23fbe <https://github.com/3b1b/manim/pull/1688/commits/ba23fbe71e4a038201cd7df1d200514ed1c13bc2>`__: Made sure ``Mobject.is_fixed_in_frame`` stays updated with uniforms
- `98b0d26 <https://github.com/3b1b/manim/pull/1691/commits/98b0d266d2475926a606331923cca3dc1dea97ad>`__: Made sure ``skip_animations`` and ``start_at_animation_number`` play well together
- `f8e6e7d <https://github.com/3b1b/manim/pull/1691/commits/f8e6e7df3ceb6f3d845ced4b690a85b35e0b8d00>`__: Updated progress display for full scene render
- `8f1dfab <https://github.com/3b1b/manim/pull/1691/commits/8f1dfabff04a8456f5c4df75b0f97d50b2755003>`__: ``VectorizedPoint`` should call ``__init__`` for both super classes
- `758f329 <https://github.com/3b1b/manim/pull/1691/commits/758f329a06a0c198b27a48c577575d94554305bf>`__: Used array copy when checking need for refreshing triangulation
+- Refactored support for command ``A`` in path of SVG  (`#1662 <https://github.com/3b1b/manim/pull/1662>`__)
+- Refactored ``SingleStringTex.balance_braces`` (`#1662 <https://github.com/3b1b/manim/pull/1662>`__)
+- Slight tweaks to how saturation_factor works on newton-fractal (`8b454fb <https://github.com/3b1b/manim/pull/1688/commits/8b454fbe9335a7011e947093230b07a74ba9c653>`__)
+- Made it possible to set full screen preview as a default (`317a5d6 <https://github.com/3b1b/manim/pull/1688/commits/317a5d6226475b6b54a78db7116c373ef84ea923>`__)
+- Used ``quick_point_from_proportion`` for graph points (`e764da3 <https://github.com/3b1b/manim/pull/1688/commits/e764da3c3adc5ae2a4ce877b340d2b6abcddc2fc>`__)
+- Made sure ``Line.set_length`` returns self (`d2182b9 <https://github.com/3b1b/manim/pull/1688/commits/d2182b9112300558b6c074cefd685f97c10b3898>`__)
+- Better align ``SurfaceMesh`` to the corresponding surface polygons (`eea3c6b <https://github.com/3b1b/manim/pull/1688/commits/eea3c6b29438f9e9325329c4355e76b9f635e97a>`__)
+- Match ``fix_in_frame`` status for ``FlashAround`` mobject (`ee1594a <https://github.com/3b1b/manim/pull/1688/commits/ee1594a3cb7a79b8fc361e4c4397a88c7d20c7e3>`__)
+- Made sure ``Mobject.is_fixed_in_frame`` stays updated with uniforms (`ba23fbe <https://github.com/3b1b/manim/pull/1688/commits/ba23fbe71e4a038201cd7df1d200514ed1c13bc2>`__)
+- Made sure ``skip_animations`` and ``start_at_animation_number`` play well together (`98b0d26 <https://github.com/3b1b/manim/pull/1691/commits/98b0d266d2475926a606331923cca3dc1dea97ad>`__)
+- Updated progress display for full scene render (`f8e6e7d <https://github.com/3b1b/manim/pull/1691/commits/f8e6e7df3ceb6f3d845ced4b690a85b35e0b8d00>`__)
+- ``VectorizedPoint`` should call ``__init__`` for both super classes (`8f1dfab <https://github.com/3b1b/manim/pull/1691/commits/8f1dfabff04a8456f5c4df75b0f97d50b2755003>`__)
+- Used array copy when checking need for refreshing triangulation (`758f329 <https://github.com/3b1b/manim/pull/1691/commits/758f329a06a0c198b27a48c577575d94554305bf>`__)


 Dependencies
 ^^^^^^^^^^^^

- `#1675 <https://github.com/3b1b/manim/pull/1675>`__: Added dependency on python packages `skia-pathops <https://github.com/fonttools/skia-pathops>`__
+- Added dependency on python package `skia-pathops <https://github.com/fonttools/skia-pathops>`__ (`#1675 <https://github.com/3b1b/manim/pull/1675>`__)

 v1.2.0
 ------
@@ -71,57 +154,57 @@ v1.2.0
 Fixed bugs
 ^^^^^^^^^^

- `#1592 <https://github.com/3b1b/manim/pull/1592>`__: Fixed ``put_start_and_end_on`` in 3D
- `#1601 <https://github.com/3b1b/manim/pull/1601>`__: Fixed ``DecimalNumber``'s scaling issue
- `56df154 <https://github.com/3b1b/manim/commit/56df15453f3e3837ed731581e52a1d76d5692077>`__: Fixed bug with common range array used for all coordinate systems
- `8645894 <https://github.com/3b1b/manim/commit/86458942550c639a241267d04d57d0e909fcf252>`__: Fixed ``CoordinateSystem`` init bug
- `0dc096b <https://github.com/3b1b/manim/commit/0dc096bf576ea900b351e6f4a80c13a77676f89b>`__: Fixed bug for single-valued ``ValueTracker``
- `54ad355 <https://github.com/3b1b/manim/commit/54ad3550ef0c0e2fda46b26700a43fa8cde0973f>`__: Fixed bug with SVG rectangles
- `d45ea28 <https://github.com/3b1b/manim/commit/d45ea28dc1d92ab9c639a047c00c151382eb0131>`__: Fixed ``DotCloud.set_radii``
- `b543cc0 <https://github.com/3b1b/manim/commit/b543cc0e32d45399ee81638b6d4fb631437664cd>`__: Temporarily fixed bug for ``PMobject`` array resizing
- `5f878a2 <https://github.com/3b1b/manim/commit/5f878a2c1aa531b7682bd048468c72d2835c7fe5>`__: Fixed ``match_style``
- `719c81d <https://github.com/3b1b/manim/commit/719c81d72b00dcf49f148d7c146774b22e0fe348>`__: Fixed negative ``path_arc`` case
- `c726eb7 <https://github.com/3b1b/manim/commit/c726eb7a180b669ee81a18555112de26a8aff6d6>`__: Fixed bug with ``CoordinateSystem.get_lines_parallel_to_axis``
- `7732d2f <https://github.com/3b1b/manim/commit/7732d2f0ee10449c5731499396d4911c03e89648>`__: Fixed ``ComplexPlane`` -i display bug
+- Fixed ``put_start_and_end_on`` in 3D (`#1592 <https://github.com/3b1b/manim/pull/1592>`__)
+- Fixed ``DecimalNumber``'s scaling issue (`#1601 <https://github.com/3b1b/manim/pull/1601>`__)
+- Fixed bug with common range array used for all coordinate systems (`56df154 <https://github.com/3b1b/manim/commit/56df15453f3e3837ed731581e52a1d76d5692077>`__)
+- Fixed ``CoordinateSystem`` init bug (`8645894 <https://github.com/3b1b/manim/commit/86458942550c639a241267d04d57d0e909fcf252>`__)
+- Fixed bug for single-valued ``ValueTracker`` (`0dc096b <https://github.com/3b1b/manim/commit/0dc096bf576ea900b351e6f4a80c13a77676f89b>`__)
+- Fixed bug with SVG rectangles (`54ad355 <https://github.com/3b1b/manim/commit/54ad3550ef0c0e2fda46b26700a43fa8cde0973f>`__)
+- Fixed ``DotCloud.set_radii`` (`d45ea28 <https://github.com/3b1b/manim/commit/d45ea28dc1d92ab9c639a047c00c151382eb0131>`__)
+- Temporarily fixed bug for ``PMobject`` array resizing (`b543cc0 <https://github.com/3b1b/manim/commit/b543cc0e32d45399ee81638b6d4fb631437664cd>`__)
+- Fixed ``match_style`` (`5f878a2 <https://github.com/3b1b/manim/commit/5f878a2c1aa531b7682bd048468c72d2835c7fe5>`__)
+- Fixed negative ``path_arc`` case (`719c81d <https://github.com/3b1b/manim/commit/719c81d72b00dcf49f148d7c146774b22e0fe348>`__)
+- Fixed bug with ``CoordinateSystem.get_lines_parallel_to_axis`` (`c726eb7 <https://github.com/3b1b/manim/commit/c726eb7a180b669ee81a18555112de26a8aff6d6>`__)
+- Fixed ``ComplexPlane`` -i display bug (`7732d2f <https://github.com/3b1b/manim/commit/7732d2f0ee10449c5731499396d4911c03e89648>`__)

 New Features 
 ^^^^^^^^^^^^

- `#1598 <https://github.com/3b1b/manim/pull/1598>`__: Supported the elliptical arc command ``A`` for ``SVGMobject``
- `#1607 <https://github.com/3b1b/manim/pull/1607>`__: Added ``FlashyFadeIn``
- `#1607 <https://github.com/3b1b/manim/pull/1607>`__: Save triangulation 
- `#1625 <https://github.com/3b1b/manim/pull/1625>`__: Added new ``Code`` mobject
- `#1637 <https://github.com/3b1b/manim/pull/1637>`__: Add warnings and use rich to display log
- `bd356da <https://github.com/3b1b/manim/commit/bd356daa99bfe3134fcb192a5f72e0d76d853801>`__: Added ``VCube``
- `6d72893 <https://github.com/3b1b/manim/commit/6d7289338234acc6658b9377c0f0084aa1fa7119>`__: Supported ``ValueTracker`` to track vectors
- `3bb8f3f <https://github.com/3b1b/manim/commit/3bb8f3f0422a5dfba0da6ef122dc0c01f31aff03>`__: Added ``set_max_width``, ``set_max_height``, ``set_max_depth`` to ``Mobject``
- `a35dd5a <https://github.com/3b1b/manim/commit/a35dd5a3cbdeffa3891d5aa5f80287c18dba2f7f>`__: Added ``TracgTail``
- `acba13f <https://github.com/3b1b/manim/commit/acba13f4991b78d54c0bf93cce7ca3b351c25476>`__: Added ``Scene.point_to_mobject``
- `f84b8a6 <https://github.com/3b1b/manim/commit/f84b8a66fe9e8b3872e5c716c5c240c14bb555ee>`__: Added poly_fractal shader
- `b24ba19 <https://github.com/3b1b/manim/commit/b24ba19dec48ba4e38acbde8eec6d3a308b6ab83>`__: Added kwargs to ``TipableVMobject.set_length``
- `17c2772 <https://github.com/3b1b/manim/commit/17c2772b84abf6392a4170030e36e981de4737d0>`__: Added ``Mobject.replicate``
- `33fa76d <https://github.com/3b1b/manim/commit/33fa76dfac36e70bb5fad69dc6a336800c6dacce>`__: Added mandelbrot_fractal shader
- `f22a341 <https://github.com/3b1b/manim/commit/f22a341e8411eae9331d4dd976b5e15bc6db08d9>`__: Saved state before each embed
- `e10a752 <https://github.com/3b1b/manim/commit/e10a752c0001e8981038faa03be4de2603d3565f>`__: Allowed releasing of Textures
- `14fbed7 <https://github.com/3b1b/manim/commit/14fbed76da4b493191136caebb8a955e2d41265b>`__: Consolidated and renamed newton_fractal shader
- `6cdbe0d <https://github.com/3b1b/manim/commit/6cdbe0d67a11ab14a6d84840a114ae6d3af10168>`__: Hade ``ImageMoject`` remember the filepath to the Image
+- Supported the elliptical arc command ``A`` for ``SVGMobject`` (`#1598 <https://github.com/3b1b/manim/pull/1598>`__)
+- Added ``FlashyFadeIn`` (`#1607 <https://github.com/3b1b/manim/pull/1607>`__)
+- Save triangulation  (`#1607 <https://github.com/3b1b/manim/pull/1607>`__)
+- Added new ``Code`` mobject (`#1625 <https://github.com/3b1b/manim/pull/1625>`__)
+- Add warnings and use rich to display log (`#1637 <https://github.com/3b1b/manim/pull/1637>`__)
+- Added ``VCube`` (`bd356da <https://github.com/3b1b/manim/commit/bd356daa99bfe3134fcb192a5f72e0d76d853801>`__)
+- Supported ``ValueTracker`` to track vectors (`6d72893 <https://github.com/3b1b/manim/commit/6d7289338234acc6658b9377c0f0084aa1fa7119>`__)
+- Added ``set_max_width``, ``set_max_height``, ``set_max_depth`` to ``Mobject`` (`3bb8f3f <https://github.com/3b1b/manim/commit/3bb8f3f0422a5dfba0da6ef122dc0c01f31aff03>`__)
+- Added ``TracgTail`` (`a35dd5a <https://github.com/3b1b/manim/commit/a35dd5a3cbdeffa3891d5aa5f80287c18dba2f7f>`__)
+- Added ``Scene.point_to_mobject`` (`acba13f <https://github.com/3b1b/manim/commit/acba13f4991b78d54c0bf93cce7ca3b351c25476>`__)
+- Added poly_fractal shader (`f84b8a6 <https://github.com/3b1b/manim/commit/f84b8a66fe9e8b3872e5c716c5c240c14bb555ee>`__)
+- Added kwargs to ``TipableVMobject.set_length`` (`b24ba19 <https://github.com/3b1b/manim/commit/b24ba19dec48ba4e38acbde8eec6d3a308b6ab83>`__)
+- Added ``Mobject.replicate`` (`17c2772 <https://github.com/3b1b/manim/commit/17c2772b84abf6392a4170030e36e981de4737d0>`__)
+- Added mandelbrot_fractal shader (`33fa76d <https://github.com/3b1b/manim/commit/33fa76dfac36e70bb5fad69dc6a336800c6dacce>`__)
+- Saved state before each embed (`f22a341 <https://github.com/3b1b/manim/commit/f22a341e8411eae9331d4dd976b5e15bc6db08d9>`__)
+- Allowed releasing of Textures (`e10a752 <https://github.com/3b1b/manim/commit/e10a752c0001e8981038faa03be4de2603d3565f>`__)
+- Consolidated and renamed newton_fractal shader (`14fbed7 <https://github.com/3b1b/manim/commit/14fbed76da4b493191136caebb8a955e2d41265b>`__)
+- Hade ``ImageMoject`` remember the filepath to the Image (`6cdbe0d <https://github.com/3b1b/manim/commit/6cdbe0d67a11ab14a6d84840a114ae6d3af10168>`__)

 Refactor
 ^^^^^^^^

- `#1601 <https://github.com/3b1b/manim/pull/1601>`__: Changed back to simpler ``Mobject.scale`` implementation
- `b667db2 <https://github.com/3b1b/manim/commit/b667db2d311a11cbbca2a6ff511d2c3cf1675486>`__: Simplified ``Square``
- `40290ad <https://github.com/3b1b/manim/commit/40290ada8343f10901fa9151cbdf84689667786d>`__: Removed unused parameter ``triangulation_locked``
- `8647a64 <https://github.com/3b1b/manim/commit/8647a6429dd0c52cba14e971b8c09194a93cfd87>`__: Reimplemented ``Arrow``
- `d8378d8 <https://github.com/3b1b/manim/commit/d8378d8157040cd797cc47ef9576beffd8607863>`__: Used ``make_approximately_smooth`` for ``set_points_smoothly`` by default
- `7b4199c <https://github.com/3b1b/manim/commit/7b4199c674e291f1b84678828b63b6bd4fcc6b17>`__: Refactored to call ``_handle_scale_side_effects`` after scaling takes place
- `7356a36 <https://github.com/3b1b/manim/commit/7356a36fa70a8279b43ae74e247cbd43b2bfd411>`__: Refactored to only call ``throw_error_if_no_points`` once for ``get_start_and_end``
- `0787c4f <https://github.com/3b1b/manim/commit/0787c4f36270a6560b50ce3e07b30b0ec5f2ba3e>`__: Made sure framerate is 30 for previewed scenes
- `c635f19 <https://github.com/3b1b/manim/commit/c635f19f2a33e916509e53ded46f55e2afa8f5f2>`__: Pushed ``pixel_coords_to_space_coords`` to ``Window``
- `d5a88d0 <https://github.com/3b1b/manim/commit/d5a88d0fa457cfcf4cb9db417a098c37c95c7051>`__: Refactored to pass tuples and not arrays to uniforms
- `9483f26 <https://github.com/3b1b/manim/commit/9483f26a3b056de0e34f27acabd1a946f1adbdf9>`__: Refactored to copy uniform arrays in ``Mobject.copy``
- `ed1fc4d <https://github.com/3b1b/manim/commit/ed1fc4d5f94467d602a568466281ca2d0368b506>`__: Added ``bounding_box`` as exceptional key to point_cloud mobject
- `329d2c6 <https://github.com/3b1b/manim/commit/329d2c6eaec3d88bfb754b555575a3ea7c97a7e0>`__: Made sure stroke width is always a float
+- Changed back to simpler ``Mobject.scale`` implementation (`#1601 <https://github.com/3b1b/manim/pull/1601>`__)
+- Simplified ``Square`` (`b667db2 <https://github.com/3b1b/manim/commit/b667db2d311a11cbbca2a6ff511d2c3cf1675486>`__)
+- Removed unused parameter ``triangulation_locked`` (`40290ad <https://github.com/3b1b/manim/commit/40290ada8343f10901fa9151cbdf84689667786d>`__)
+- Reimplemented ``Arrow`` (`8647a64 <https://github.com/3b1b/manim/commit/8647a6429dd0c52cba14e971b8c09194a93cfd87>`__)
+- Used ``make_approximately_smooth`` for ``set_points_smoothly`` by default (`d8378d8 <https://github.com/3b1b/manim/commit/d8378d8157040cd797cc47ef9576beffd8607863>`__)
+- Refactored to call ``_handle_scale_side_effects`` after scaling takes place (`7b4199c <https://github.com/3b1b/manim/commit/7b4199c674e291f1b84678828b63b6bd4fcc6b17>`__)
+- Refactored to only call ``throw_error_if_no_points`` once for ``get_start_and_end`` (`7356a36 <https://github.com/3b1b/manim/commit/7356a36fa70a8279b43ae74e247cbd43b2bfd411>`__)
+- Made sure framerate is 30 for previewed scenes (`0787c4f <https://github.com/3b1b/manim/commit/0787c4f36270a6560b50ce3e07b30b0ec5f2ba3e>`__)
+- Pushed ``pixel_coords_to_space_coords`` to ``Window`` (`c635f19 <https://github.com/3b1b/manim/commit/c635f19f2a33e916509e53ded46f55e2afa8f5f2>`__)
+- Refactored to pass tuples and not arrays to uniforms (`d5a88d0 <https://github.com/3b1b/manim/commit/d5a88d0fa457cfcf4cb9db417a098c37c95c7051>`__)
+- Refactored to copy uniform arrays in ``Mobject.copy`` (`9483f26 <https://github.com/3b1b/manim/commit/9483f26a3b056de0e34f27acabd1a946f1adbdf9>`__)
+- Added ``bounding_box`` as exceptional key to point_cloud mobject (`ed1fc4d <https://github.com/3b1b/manim/commit/ed1fc4d5f94467d602a568466281ca2d0368b506>`__)
+- Made sure stroke width is always a float (`329d2c6 <https://github.com/3b1b/manim/commit/329d2c6eaec3d88bfb754b555575a3ea7c97a7e0>`__)


 v1.1.0
--- a/docs/source/getting_started/configuration.rst
+++ b/docs/source/getting_started/configuration.rst
@@ -43,6 +43,7 @@ flag                                                       abbr   function
 ``--hd``                                                          Render at a 1080p quality
 ``--uhd``                                                         Render at a 4k quality
 ``--full_screen``                                          ``-f`` Show window in full screen
+``--presenter_mode``                                       ``-p`` Scene will stay paused during wait calls until space bar or right arrow is hit, like a slide show
 ``--save_pngs``                                            ``-g`` Save each frame as a png
 ``--save_as_gif``                                          ``-i`` Save the video as gif
 ``--transparent``                                          ``-t`` Render to a movie file with an alpha channel
@@ -58,7 +59,7 @@ flag                                                       abbr   function
 ``--frame_rate FRAME_RATE``                                       Frame rate, as an integer
 ``--color COLOR``                                          ``-c`` Background color
 ``--leave_progress_bars``                                         Leave progress bars displayed in terminal
-``--video_dir VIDEO_DIR``                                         directory to write video
+``--video_dir VIDEO_DIR``                                         Directory to write video
 ``--config_file CONFIG_FILE``                                     Path to the custom configuration file
 ========================================================== ====== =================================================================================================================================================================================================

--- a/example_scenes.py
+++ b/example_scenes.py
@@ -274,7 +274,7 @@ class UpdatersExample(Scene):
        square = Square()
        square.set_fill(BLUE_E, 1)

-        # On all all frames, the constructor Brace(square, UP) will
+        # On all frames, the constructor Brace(square, UP) will
        # be called, and the mobject brace will set its data to match
        # that of the newly constructed object
        brace = always_redraw(Brace, square, UP)
--- a/manimlib/init.py
+++ b/manimlib/init.py
@@ -68,4 +68,3 @@ from manimlib.utils.rate_functions import *
 from manimlib.utils.simple_functions import *
 from manimlib.utils.sounds import *
 from manimlib.utils.space_ops import *
-from manimlib.utils.strings import *
--- a/manimlib/animation/creation.py
+++ b/manimlib/animation/creation.py
@@ -1,7 +1,6 @@
 from manimlib.animation.animation import Animation
 from manimlib.animation.composition import Succession
 from manimlib.mobject.types.vectorized_mobject import VMobject
-from manimlib.mobject.mobject import Group
 from manimlib.utils.bezier import integer_interpolate
 from manimlib.utils.config_ops import digest_config
 from manimlib.utils.rate_functions import linear
@@ -147,7 +146,7 @@ class Write(DrawBorderThenFill):
            else:
                self.run_time = 2
        if self.lag_ratio is None:
-            self.lag_ratio = min(4.0 / length, 0.2)
+            self.lag_ratio = min(4.0 / (length + 1.0), 0.2)


 class ShowIncreasingSubsets(Animation):
--- a/manimlib/animation/specialized.py
+++ b/manimlib/animation/specialized.py
@@ -17,7 +17,6 @@ class Broadcast(LaggedStart):
        "remover": True,
        "lag_ratio": 0.2,
        "run_time": 3,
-        "remover": True,
    }

    def __init__(self, focal_point, **kwargs):
--- a/manimlib/animation/transform_matching_parts.py
+++ b/manimlib/animation/transform_matching_parts.py
@@ -1,16 +1,20 @@
 import numpy as np
+import itertools as it

 from manimlib.animation.composition import AnimationGroup
 from manimlib.animation.fading import FadeTransformPieces
 from manimlib.animation.fading import FadeInFromPoint
 from manimlib.animation.fading import FadeOutToPoint
+from manimlib.animation.transform import ReplacementTransform
 from manimlib.animation.transform import Transform

 from manimlib.mobject.mobject import Mobject
 from manimlib.mobject.mobject import Group
+from manimlib.mobject.svg.mtex_mobject import MTex
 from manimlib.mobject.types.vectorized_mobject import VGroup
 from manimlib.mobject.types.vectorized_mobject import VMobject
 from manimlib.utils.config_ops import digest_config
+from manimlib.utils.iterables import remove_list_redundancies


 class TransformMatchingParts(AnimationGroup):
@@ -139,3 +143,108 @@ class TransformMatchingTex(TransformMatchingParts):
    @staticmethod
    def get_mobject_key(mobject):
        return mobject.get_tex()
+
+
+class TransformMatchingMTex(AnimationGroup):
+    CONFIG = {
+        "key_map": dict(),
+    }
+
+    def __init__(self, source_mobject, target_mobject, **kwargs):
+        digest_config(self, kwargs)
+        assert isinstance(source_mobject, MTex)
+        assert isinstance(target_mobject, MTex)
+        anims = []
+        rest_source_submobs = source_mobject.submobjects.copy()
+        rest_target_submobs = target_mobject.submobjects.copy()
+
+        def add_anim_from(anim_class, func, source_attr, target_attr=None):
+            if target_attr is None:
+                target_attr = source_attr
+            source_parts = func(source_mobject, source_attr)
+            target_parts = func(target_mobject, target_attr)
+            filtered_source_parts = [
+                submob_part for submob_part in source_parts
+                if all([
+                    submob in rest_source_submobs
+                    for submob in submob_part
+                ])
+            ]
+            filtered_target_parts = [
+                submob_part for submob_part in target_parts
+                if all([
+                    submob in rest_target_submobs
+                    for submob in submob_part
+                ])
+            ]
+            if not (filtered_source_parts and filtered_target_parts):
+                return
+            anims.append(anim_class(
+                VGroup(*filtered_source_parts),
+                VGroup(*filtered_target_parts),
+                **kwargs
+            ))
+            for submob in it.chain(*filtered_source_parts):
+                rest_source_submobs.remove(submob)
+            for submob in it.chain(*filtered_target_parts):
+                rest_target_submobs.remove(submob)
+
+        def get_submobs_from_keys(mobject, keys):
+            if not isinstance(keys, tuple):
+                keys = (keys,)
+            indices = []
+            for key in keys:
+                if isinstance(key, int):
+                    indices.append(key)
+                elif isinstance(key, range):
+                    indices.extend(key)
+                elif isinstance(key, str):
+                    all_parts = mobject.get_parts_by_tex(key)
+                    indices.extend(it.chain(*[
+                        mobject.indices_of_part(part) for part in all_parts
+                    ]))
+                else:
+                    raise TypeError(key)
+            return VGroup(VGroup(*[
+                mobject[i] for i in remove_list_redundancies(indices)
+            ]))
+
+        for source_key, target_key in self.key_map.items():
+            add_anim_from(
+                ReplacementTransform, get_submobs_from_keys,
+                source_key, target_key
+            )
+
+        common_specified_substrings = sorted(list(
+            set(source_mobject.get_specified_substrings()).intersection(
+                target_mobject.get_specified_substrings()
+            )
+        ), key=len, reverse=True)
+        for part_tex_string in common_specified_substrings:
+            add_anim_from(
+                FadeTransformPieces, MTex.get_parts_by_tex, part_tex_string
+            )
+
+        common_submob_tex_strings = {
+            source_submob.get_tex() for source_submob in source_mobject
+        }.intersection({
+            target_submob.get_tex() for target_submob in target_mobject
+        })
+        for tex_string in common_submob_tex_strings:
+            add_anim_from(
+                FadeTransformPieces,
+                lambda mobject, attr: VGroup(*[
+                    VGroup(mob) for mob in mobject
+                    if mob.get_tex() == attr
+                ]),
+                tex_string
+            )
+
+        anims.append(FadeOutToPoint(
+            VGroup(*rest_source_submobs), target_mobject.get_center(), **kwargs
+        ))
+        anims.append(FadeInFromPoint(
+            VGroup(*rest_target_submobs), source_mobject.get_center(), **kwargs
+        ))
+
+        super().__init__(*anims)
--- a/manimlib/config.py
+++ b/manimlib/config.py
@@ -23,7 +23,7 @@ def parse_cli():
        module_location.add_argument(
            "file",
            nargs="?",
-            help="path to file holding the python code for the scene",
+            help="Path to file holding the python code for the scene",
        )
        parser.add_argument(
            "scene_names",
@@ -65,6 +65,12 @@ def parse_cli():
            action="store_true",
            help="Show window in full screen",
        )
+        parser.add_argument(
+            "-p", "--presenter_mode",
+            action="store_true",
+            help="Scene will stay paused during wait calls until "
+                 "space bar or right arrow is hit, like a slide show"
+        )
        parser.add_argument(
            "-g", "--save_pngs",
            action="store_true",
@@ -306,6 +312,7 @@ def get_configuration(args):
        "start_at_animation_number": args.start_at_animation_number,
        "end_at_animation_number": None,
        "preview": not write_file,
+        "presenter_mode": args.presenter_mode,
        "leave_progress_bars": args.leave_progress_bars,
    }

--- a/manimlib/extract_scene.py
+++ b/manimlib/extract_scene.py
@@ -64,6 +64,7 @@ def get_scene_config(config):
            "end_at_animation_number",
            "leave_progress_bars",
            "preview",
+            "presenter_mode",
        ]
    ])

--- a/manimlib/mobject/boolean_ops.py
+++ b/manimlib/mobject/boolean_ops.py
@@ -41,7 +41,7 @@ def _convert_skia_path_to_vmobject(path, vmobject):
                vmobject.add_quadratic_bezier_curve_to(*points)
            else:
                raise Exception(f"Unsupported: {path_verb}")
-    return vmobject
+    return vmobject.reverse_points()


 class Union(VMobject):
--- a/manimlib/mobject/coordinate_systems.py
+++ b/manimlib/mobject/coordinate_systems.py
@@ -1,3 +1,4 @@
+from abc import abstractmethod
 import numpy as np
 import numbers

@@ -55,9 +56,11 @@ class CoordinateSystem():
    def get_origin(self):
        return self.c2p(*[0] * self.dimension)

+    @abstractmethod
    def get_axes(self):
        raise Exception("Not implemented")

+    @abstractmethod
    def get_all_ranges(self):
        raise Exception("Not implemented")

@@ -274,7 +277,7 @@ class CoordinateSystem():
 class Axes(VGroup, CoordinateSystem):
    CONFIG = {
        "axis_config": {
-            "include_tip": True,
+            "include_tip": False,
            "numbers_to_exclude": [0],
        },
        "x_axis_config": {},
--- a/manimlib/mobject/functions.py
+++ b/manimlib/mobject/functions.py
@@ -1,3 +1,5 @@
+from isosurfaces import plot_isoline
+
 from manimlib.constants import *
 from manimlib.mobject.types.vectorized_mobject import VMobject
 from manimlib.utils.config_ops import digest_config
@@ -42,6 +44,8 @@ class ParametricCurve(VMobject):
            self.add_points_as_corners(points[1:])
        if self.use_smoothing:
            self.make_approximately_smooth()
+        if not self.has_points():
+            self.set_points([self.t_func(t_min)])
        return self


@@ -68,3 +72,40 @@ class FunctionGraph(ParametricCurve):

    def get_point_from_function(self, x):
        return self.t_func(x)
+
+
+class ImplicitFunction(VMobject):
+    CONFIG = {
+        "x_range": [-FRAME_X_RADIUS, FRAME_X_RADIUS],
+        "y_range": [-FRAME_Y_RADIUS, FRAME_Y_RADIUS],
+        "min_depth": 5,
+        "max_quads": 1500,
+        "use_smoothing": True
+    }
+
+    def __init__(self, func, x_range=None, y_range=None, **kwargs):
+        digest_config(self, kwargs)
+        self.function = func
+        super().__init__(**kwargs)
+
+    def init_points(self):
+        p_min, p_max = (
+            np.array([self.x_range[0], self.y_range[0]]),
+            np.array([self.x_range[1], self.y_range[1]]),
+        )
+        curves = plot_isoline(
+            fn=lambda u: self.function(u[0], u[1]),
+            pmin=p_min,
+            pmax=p_max,
+            min_depth=self.min_depth,
+            max_quads=self.max_quads,
+        )  # returns a list of lists of 2D points
+        curves = [
+            np.pad(curve, [(0, 0), (0, 1)]) for curve in curves if curve != []
+        ]  # add z coord as 0
+        for curve in curves:
+            self.start_new_path(curve[0])
+            self.add_points_as_corners(curve[1:])
+        if self.use_smoothing:
+            self.make_smooth()
+        return self
--- a/manimlib/mobject/geometry.py
+++ b/manimlib/mobject/geometry.py
@@ -849,6 +849,11 @@ class Polygon(VMobject):
        return self


+class Polyline(Polygon):
+    def init_points(self):
+        self.set_points_as_corners(self.vertices)
+
+
 class RegularPolygon(Polygon):
    CONFIG = {
        "start_angle": None,
--- a/manimlib/mobject/matrix.py
+++ b/manimlib/mobject/matrix.py
@@ -112,7 +112,7 @@ class Matrix(VMobject):
            "\\left[",
            "\\begin{array}{c}",
            *height * ["\\quad \\\\"],
-            "\\end{array}"
+            "\\end{array}",
            "\\right]",
        ]))[0]
        bracket_pair.set_height(
--- a/manimlib/mobject/mobject.py
+++ b/manimlib/mobject/mobject.py
@@ -4,6 +4,7 @@ import random
 import sys
 import moderngl
 from functools import wraps
+from collections.abc import Iterable

 import numpy as np

@@ -596,7 +597,10 @@ class Mobject(object):
        Otherwise, if about_point is given a value, scaling is done with
        respect to that point.
        """
-        scale_factor = max(scale_factor, min_scale_factor)
+        if isinstance(scale_factor, Iterable):
+            scale_factor = np.array(scale_factor).clip(min=min_scale_factor)
+        else:
+            scale_factor = max(scale_factor, min_scale_factor)
        self.apply_points_function(
            lambda points: scale_factor * points,
            about_point=about_point,
@@ -813,6 +817,21 @@ class Mobject(object):
            self.set_depth(max_depth, **kwargs)
        return self

+    def set_min_width(self, min_width, **kwargs):
+        if self.get_width() < min_width:
+            self.set_width(min_width, **kwargs)
+        return self
+
+    def set_min_height(self, min_height, **kwargs):
+        if self.get_height() < min_height:
+            self.set_height(min_height, **kwargs)
+        return self
+
+    def set_min_depth(self, min_depth, **kwargs):
+        if self.get_depth() < min_depth:
+            self.set_depth(min_depth, **kwargs)
+        return self
+
    def set_coord(self, value, dim, direction=ORIGIN):
        curr = self.get_coord(dim, direction)
        shift_vect = np.zeros(self.dim)
@@ -1177,21 +1196,21 @@ class Mobject(object):
    def match_depth(self, mobject, **kwargs):
        return self.match_dim_size(mobject, 2, **kwargs)

-    def match_coord(self, mobject, dim, direction=ORIGIN):
-        return self.set_coord(
-            mobject.get_coord(dim, direction),
-            dim=dim,
-            direction=direction,
-        )
+    def match_coord(self, mobject_or_point, dim, direction=ORIGIN):
+        if isinstance(mobject_or_point, Mobject):
+            coord = mobject_or_point.get_coord(dim, direction)
+        else:
+            coord = mobject_or_point[dim]
+        return self.set_coord(coord, dim=dim, direction=direction)

-    def match_x(self, mobject, direction=ORIGIN):
-        return self.match_coord(mobject, 0, direction)
+    def match_x(self, mobject_or_point, direction=ORIGIN):
+        return self.match_coord(mobject_or_point, 0, direction)

-    def match_y(self, mobject, direction=ORIGIN):
-        return self.match_coord(mobject, 1, direction)
+    def match_y(self, mobject_or_point, direction=ORIGIN):
+        return self.match_coord(mobject_or_point, 1, direction)

-    def match_z(self, mobject, direction=ORIGIN):
-        return self.match_coord(mobject, 2, direction)
+    def match_z(self, mobject_or_point, direction=ORIGIN):
+        return self.match_coord(mobject_or_point, 2, direction)

    def align_to(self, mobject_or_point, direction=ORIGIN):
        """
--- a/manimlib/mobject/numbers.py
+++ b/manimlib/mobject/numbers.py
@@ -2,6 +2,7 @@ from manimlib.constants import *
 from manimlib.mobject.svg.tex_mobject import SingleStringTex
 from manimlib.mobject.svg.text_mobject import Text
 from manimlib.mobject.types.vectorized_mobject import VMobject
+from manimlib.utils.iterables import hash_obj


 string_to_mob_map = {}
@@ -20,23 +21,23 @@ class DecimalNumber(VMobject):
        "include_background_rectangle": False,
        "edge_to_fix": LEFT,
        "font_size": 48,
+        "text_config": {} # Do not pass in font_size here
    }

    def __init__(self, number=0, **kwargs):
        super().__init__(**kwargs)
        self.set_submobjects_from_number(number)
-        self.init_colors()

    def set_submobjects_from_number(self, number):
        self.number = number
        self.set_submobjects([])
-
+        string_to_mob_ = lambda s: self.string_to_mob(s, **self.text_config)
        num_string = self.get_num_string(number)
-        self.add(*map(self.string_to_mob, num_string))
+        self.add(*map(string_to_mob_, num_string))

        # Add non-numerical bits
        if self.show_ellipsis:
-            dots = self.string_to_mob("...")
+            dots = string_to_mob_("...")
            dots.arrange(RIGHT, buff=2 * dots[0].get_width())
            self.add(dots)
        if self.unit is not None:
@@ -85,10 +86,10 @@ class DecimalNumber(VMobject):
    def get_font_size(self):
        return self.data["font_size"][0]

-    def string_to_mob(self, string, mob_class=Text):
-        if string not in string_to_mob_map:
-            string_to_mob_map[string] = mob_class(string, font_size=1)
-        mob = string_to_mob_map[string].copy()
+    def string_to_mob(self, string, mob_class=Text, **kwargs):
+        if (string, hash_obj(kwargs)) not in string_to_mob_map:
+            string_to_mob_map[(string, hash_obj(kwargs))] = mob_class(string, font_size=1, **kwargs)
+        mob = string_to_mob_map[(string, hash_obj(kwargs))].copy()
        mob.scale(self.get_font_size())
        return mob

--- a/manimlib/mobject/probability.py
+++ b/manimlib/mobject/probability.py
@@ -149,7 +149,9 @@ class BarChart(VGroup):
        "height": 4,
        "width": 6,
        "n_ticks": 4,
+        "include_x_ticks": False,
        "tick_width": 0.2,
+        "tick_height": 0.15,
        "label_y_axis": True,
        "y_axis_label_height": 0.25,
        "max_value": 1,
@@ -165,6 +167,7 @@ class BarChart(VGroup):
        if self.max_value is None:
            self.max_value = max(values)

+        self.n_ticks_x = len(values)
        self.add_axes()
        self.add_bars(values)
        self.center()
@@ -172,31 +175,42 @@ class BarChart(VGroup):
    def add_axes(self):
        x_axis = Line(self.tick_width * LEFT / 2, self.width * RIGHT)
        y_axis = Line(MED_LARGE_BUFF * DOWN, self.height * UP)
-        ticks = VGroup()
+        y_ticks = VGroup()
        heights = np.linspace(0, self.height, self.n_ticks + 1)
        values = np.linspace(0, self.max_value, self.n_ticks + 1)
        for y, value in zip(heights, values):
-            tick = Line(LEFT, RIGHT)
-            tick.set_width(self.tick_width)
-            tick.move_to(y * UP)
-            ticks.add(tick)
-        y_axis.add(ticks)
+            y_tick = Line(LEFT, RIGHT)
+            y_tick.set_width(self.tick_width)
+            y_tick.move_to(y * UP)
+            y_ticks.add(y_tick)
+        y_axis.add(y_ticks)
+
+        if self.include_x_ticks == True:
+            x_ticks = VGroup()
+            widths = np.linspace(0, self.width, self.n_ticks_x + 1)
+            label_values = np.linspace(0, len(self.bar_names), self.n_ticks_x + 1)
+            for x, value in zip(widths, label_values):
+                x_tick = Line(UP, DOWN)
+                x_tick.set_height(self.tick_height)
+                x_tick.move_to(x * RIGHT)
+                x_ticks.add(x_tick)
+            x_axis.add(x_ticks)

        self.add(x_axis, y_axis)
        self.x_axis, self.y_axis = x_axis, y_axis

        if self.label_y_axis:
            labels = VGroup()
-            for tick, value in zip(ticks, values):
+            for y_tick, value in zip(y_ticks, values):
                label = Tex(str(np.round(value, 2)))
                label.set_height(self.y_axis_label_height)
-                label.next_to(tick, LEFT, SMALL_BUFF)
+                label.next_to(y_tick, LEFT, SMALL_BUFF)
                labels.add(label)
            self.y_axis_labels = labels
            self.add(labels)

    def add_bars(self, values):
-        buff = float(self.width) / (2 * len(values) + 1)
+        buff = float(self.width) / (2 * len(values))
        bars = VGroup()
        for i, value in enumerate(values):
            bar = Rectangle(
@@ -205,7 +219,7 @@ class BarChart(VGroup):
                stroke_width=self.bar_stroke_width,
                fill_opacity=self.bar_fill_opacity,
            )
-            bar.move_to((2 * i + 1) * buff * RIGHT, DOWN + LEFT)
+            bar.move_to((2 * i + 0.5) * buff * RIGHT, DOWN + LEFT * 5)
            bars.add(bar)
        bars.set_color_by_gradient(*self.bar_colors)

--- a/manimlib/mobject/svg/brace.py
+++ b/manimlib/mobject/svg/brace.py
@@ -1,5 +1,6 @@
 import numpy as np
 import math
+import copy

 from manimlib.animation.composition import AnimationGroup
 from manimlib.constants import *
@@ -88,6 +89,7 @@ class BraceLabel(VMobject):
    CONFIG = {
        "label_constructor": Tex,
        "label_scale": 1,
+        "label_buff": DEFAULT_MOBJECT_TO_MOBJECT_BUFFER  
    }

    def __init__(self, obj, text, brace_direction=DOWN, **kwargs):
@@ -104,7 +106,7 @@ class BraceLabel(VMobject):
        if self.label_scale != 1:
            self.label.scale(self.label_scale)

-        self.brace.put_at_tip(self.label)
+        self.brace.put_at_tip(self.label, buff=self.label_buff)
        self.set_submobjects([self.brace, self.label])

    def creation_anim(self, label_anim=FadeIn, brace_anim=GrowFromCenter):
--- a/manimlib/mobject/svg/drawings.py
+++ b/manimlib/mobject/svg/drawings.py
@@ -50,6 +50,7 @@ class Lightbulb(SVGMobject):

    def __init__(self, **kwargs):
        super().__init__("lightbulb", **kwargs)
+        self.insert_n_curves(25)


 class Speedometer(VMobject):
--- a/manimlib/mobject/svg/mtex_mobject.py
+++ b/manimlib/mobject/svg/mtex_mobject.py
--- a/manimlib/mobject/svg/svg_mobject.py
+++ b/manimlib/mobject/svg/svg_mobject.py
@@ -1,38 +1,31 @@
-import itertools as it
-import re
-import string
-import warnings
 import os
 import hashlib
+import itertools as it
+from xml.etree import ElementTree as ET

-from xml.dom import minidom
-
-from manimlib.constants import DEFAULT_STROKE_WIDTH
-from manimlib.constants import ORIGIN, UP, DOWN, LEFT, RIGHT
-from manimlib.constants import BLACK
-from manimlib.constants import WHITE
-from manimlib.constants import DEGREES, PI
+import svgelements as se
+import numpy as np

+from manimlib.constants import RIGHT
+from manimlib.mobject.geometry import Line
 from manimlib.mobject.geometry import Circle
+from manimlib.mobject.geometry import Polygon
+from manimlib.mobject.geometry import Polyline
 from manimlib.mobject.geometry import Rectangle
 from manimlib.mobject.geometry import RoundedRectangle
-from manimlib.mobject.types.vectorized_mobject import VGroup
 from manimlib.mobject.types.vectorized_mobject import VMobject
-from manimlib.utils.color import *
 from manimlib.utils.config_ops import digest_config
 from manimlib.utils.directories import get_mobject_data_dir
 from manimlib.utils.images import get_full_vector_image_path
-from manimlib.utils.simple_functions import clip
+from manimlib.utils.iterables import hash_obj
+from manimlib.logger import log


-def string_to_numbers(num_string):
-    num_string = num_string.replace("-", ",-")
-    num_string = num_string.replace("e,-", "e-")
-    return [
-        float(s)
-        for s in re.split("[ ,]", num_string)
-        if s != ""
-    ]
+SVG_HASH_TO_MOB_MAP = {}
+
+
+def _convert_point_to_3d(x, y):
+    return np.array([x, y, 0.0])


 class SVGMobject(VMobject):
@@ -40,25 +33,234 @@ class SVGMobject(VMobject):
        "should_center": True,
        "height": 2,
        "width": None,
-        # Must be filled in in a subclass, or when called
        "file_name": None,
-        "unpack_groups": True,  # if False, creates a hierarchy of VGroups
-        # TODO, style components should be read in, not defaulted
-        "stroke_width": DEFAULT_STROKE_WIDTH,
-        "fill_opacity": 1.0,
-        "path_string_config": {}
+        # Style that overrides the original svg
+        "color": None,
+        "opacity": None,
+        "fill_color": None,
+        "fill_opacity": None,
+        "stroke_width": None,
+        "stroke_color": None,
+        "stroke_opacity": None,
+        # Style that fills only when not specified
+        # If None, regarded as default values from svg standard
+        "svg_default": {
+            "color": None,
+            "opacity": None,
+            "fill_color": None,
+            "fill_opacity": None,
+            "stroke_width": None,
+            "stroke_color": None,
+            "stroke_opacity": None,
+        },
+        "path_string_config": {},
    }

    def __init__(self, file_name=None, **kwargs):
-        digest_config(self, kwargs)
-        self.file_name = file_name or self.file_name
-        if file_name is None:
-            raise Exception("Must specify file for SVGMobject")
-        self.file_path = get_full_vector_image_path(file_name)
-
        super().__init__(**kwargs)
+        self.file_name = file_name or self.file_name
+        self.init_svg_mobject()
+        self.init_colors()
        self.move_into_position()

+    def init_svg_mobject(self):
+        hash_val = hash_obj(self.hash_seed)
+        if hash_val in SVG_HASH_TO_MOB_MAP:
+            mob = SVG_HASH_TO_MOB_MAP[hash_val].copy()
+            self.add(*mob)
+            return
+
+        self.generate_mobject()
+        SVG_HASH_TO_MOB_MAP[hash_val] = self.copy()
+
+    @property
+    def hash_seed(self):
+        # Returns data which can uniquely represent the result of `init_points`.
+        # The hashed value of it is stored as a key in `SVG_HASH_TO_MOB_MAP`.
+        return (
+            self.__class__.__name__,
+            self.svg_default,
+            self.path_string_config,
+            self.file_name
+        )
+
+    def generate_mobject(self):
+        file_path = self.get_file_path()
+        element_tree = ET.parse(file_path)
+        new_tree = self.modify_xml_tree(element_tree)
+        # Create a temporary svg file to dump modified svg to be parsed
+        modified_file_path = file_path.replace(".svg", "_.svg")
+        new_tree.write(modified_file_path)
+
+        svg = se.SVG.parse(modified_file_path)
+        os.remove(modified_file_path)
+
+        mobjects = self.get_mobjects_from(svg)
+        self.add(*mobjects)
+        self.flip(RIGHT)  # Flip y
+
+    def get_file_path(self):
+        if self.file_name is None:
+            raise Exception("Must specify file for SVGMobject")
+        return get_full_vector_image_path(self.file_name)
+
+    def modify_xml_tree(self, element_tree):
+        config_style_dict = self.generate_config_style_dict()
+        style_keys = (
+            "fill",
+            "fill-opacity",
+            "stroke",
+            "stroke-opacity",
+            "stroke-width",
+            "style"
+        )
+        root = element_tree.getroot()
+        root_style_dict = {
+            k: v for k, v in root.attrib.items()
+            if k in style_keys
+        }
+
+        new_root = ET.Element("svg", {})
+        config_style_node = ET.SubElement(new_root, "g", config_style_dict)
+        root_style_node = ET.SubElement(config_style_node, "g", root_style_dict)
+        root_style_node.extend(root)
+        return ET.ElementTree(new_root)
+
+    def generate_config_style_dict(self):
+        keys_converting_dict = {
+            "fill": ("color", "fill_color"),
+            "fill-opacity": ("opacity", "fill_opacity"),
+            "stroke": ("color", "stroke_color"),
+            "stroke-opacity": ("opacity", "stroke_opacity"),
+            "stroke-width": ("stroke_width",)
+        }
+        svg_default_dict = self.svg_default
+        result = {}
+        for svg_key, style_keys in keys_converting_dict.items():
+            for style_key in style_keys:
+                if svg_default_dict[style_key] is None:
+                    continue
+                result[svg_key] = str(svg_default_dict[style_key])
+        return result
+
+    def get_mobjects_from(self, svg):
+        result = []
+        for shape in svg.elements():
+            if isinstance(shape, se.Group):
+                continue
+            mob = self.get_mobject_from(shape)
+            if mob is None:
+                continue
+            if isinstance(shape, se.Transformable) and shape.apply:
+                self.handle_transform(mob, shape.transform)
+            result.append(mob)
+        return result
+
+    @staticmethod
+    def handle_transform(mob, matrix):
+        mat = np.array([
+            [matrix.a, matrix.c],
+            [matrix.b, matrix.d]
+        ])
+        vec = np.array([matrix.e, matrix.f, 0.0])
+        mob.apply_matrix(mat)
+        mob.shift(vec)
+        return mob
+
+    def get_mobject_from(self, shape):
+        shape_class_to_func_map = {
+            se.Path: self.path_to_mobject,
+            se.SimpleLine: self.line_to_mobject,
+            se.Rect: self.rect_to_mobject,
+            se.Circle: self.circle_to_mobject,
+            se.Ellipse: self.ellipse_to_mobject,
+            se.Polygon: self.polygon_to_mobject,
+            se.Polyline: self.polyline_to_mobject,
+            # se.Text: self.text_to_mobject,  # TODO
+        }
+        for shape_class, func in shape_class_to_func_map.items():
+            if isinstance(shape, shape_class):
+                mob = func(shape)
+                self.apply_style_to_mobject(mob, shape)
+                return mob
+
+        shape_class_name = shape.__class__.__name__
+        if shape_class_name != "SVGElement":
+            log.warning(f"Unsupported element type: {shape_class_name}")
+        return None
+
+    @staticmethod
+    def apply_style_to_mobject(mob, shape):
+        mob.set_style(
+            stroke_width=shape.stroke_width,
+            stroke_color=shape.stroke.hex,
+            stroke_opacity=shape.stroke.opacity,
+            fill_color=shape.fill.hex,
+            fill_opacity=shape.fill.opacity
+        )
+        return mob
+
+    def path_to_mobject(self, path):
+        return VMobjectFromSVGPath(path, **self.path_string_config)
+
+    def line_to_mobject(self, line):
+        return Line(
+            start=_convert_point_to_3d(line.x1, line.y1),
+            end=_convert_point_to_3d(line.x2, line.y2)
+        )
+
+    def rect_to_mobject(self, rect):
+        if rect.rx == 0 or rect.ry == 0:
+            mob = Rectangle(
+                width=rect.width,
+                height=rect.height,
+            )
+        else:
+            mob = RoundedRectangle(
+                width=rect.width,
+                height=rect.height * rect.rx / rect.ry,
+                corner_radius=rect.rx
+            )
+            mob.stretch_to_fit_height(rect.height)
+        mob.shift(_convert_point_to_3d(
+            rect.x + rect.width / 2,
+            rect.y + rect.height / 2
+        ))
+        return mob
+
+    def circle_to_mobject(self, circle):
+        # svgelements supports `rx` & `ry` but `r`
+        mob = Circle(radius=circle.rx)
+        mob.shift(_convert_point_to_3d(
+            circle.cx, circle.cy
+        ))
+        return mob
+
+    def ellipse_to_mobject(self, ellipse):
+        mob = Circle(radius=ellipse.rx)
+        mob.stretch_to_fit_height(2 * ellipse.ry)
+        mob.shift(_convert_point_to_3d(
+            ellipse.cx, ellipse.cy
+        ))
+        return mob
+
+    def polygon_to_mobject(self, polygon):
+        points = [
+            _convert_point_to_3d(*point)
+            for point in polygon
+        ]
+        return Polygon(*points)
+
+    def polyline_to_mobject(self, polyline):
+        points = [
+            _convert_point_to_3d(*point)
+            for point in polyline
+        ]
+        return Polyline(*points)
+
+    def text_to_mobject(self, text):
+        pass
+
    def move_into_position(self):
        if self.should_center:
            self.center()
@@ -67,275 +269,26 @@ class SVGMobject(VMobject):
        if self.width is not None:
            self.set_width(self.width)

-    def init_points(self):
-        doc = minidom.parse(self.file_path)
-        self.ref_to_element = {}

-        for svg in doc.getElementsByTagName("svg"):
-            mobjects = self.get_mobjects_from(svg)
-            if self.unpack_groups:
-                self.add(*mobjects)
-            else:
-                self.add(*mobjects[0].submobjects)
-        doc.unlink()
-
-    def get_mobjects_from(self, element):
-        result = []
-        if not isinstance(element, minidom.Element):
-            return result
-        if element.tagName == 'defs':
-            self.update_ref_to_element(element)
-        elif element.tagName == 'style':
-            pass  # TODO, handle style
-        elif element.tagName in ['g', 'svg', 'symbol']:
-            result += it.chain(*(
-                self.get_mobjects_from(child)
-                for child in element.childNodes
-            ))
-        elif element.tagName == 'path':
-            result.append(self.path_string_to_mobject(
-                element.getAttribute('d')
-            ))
-        elif element.tagName == 'use':
-            result += self.use_to_mobjects(element)
-        elif element.tagName == 'rect':
-            result.append(self.rect_to_mobject(element))
-        elif element.tagName == 'circle':
-            result.append(self.circle_to_mobject(element))
-        elif element.tagName == 'ellipse':
-            result.append(self.ellipse_to_mobject(element))
-        elif element.tagName in ['polygon', 'polyline']:
-            result.append(self.polygon_to_mobject(element))
-        else:
-            pass  # TODO
-            # warnings.warn("Unknown element type: " + element.tagName)
-        result = [m for m in result if m is not None]
-        self.handle_transforms(element, VGroup(*result))
-        if len(result) > 1 and not self.unpack_groups:
-            result = [VGroup(*result)]
-
-        return result
-
-    def g_to_mobjects(self, g_element):
-        mob = VGroup(*self.get_mobjects_from(g_element))
-        self.handle_transforms(g_element, mob)
-        return mob.submobjects
-
-    def path_string_to_mobject(self, path_string):
-        return VMobjectFromSVGPathstring(
-            path_string,
-            **self.path_string_config,
-        )
-
-    def use_to_mobjects(self, use_element):
-        # Remove initial "#" character
-        ref = use_element.getAttribute("xlink:href")[1:]
-        if ref not in self.ref_to_element:
-            warnings.warn(f"{ref} not recognized")
-            return VGroup()
-        return self.get_mobjects_from(
-            self.ref_to_element[ref]
-        )
-
-    def attribute_to_float(self, attr):
-        stripped_attr = "".join([
-            char for char in attr
-            if char in string.digits + "." + "-"
-        ])
-        return float(stripped_attr)
-
-    def polygon_to_mobject(self, polygon_element):
-        path_string = polygon_element.getAttribute("points")
-        for digit in string.digits:
-            path_string = path_string.replace(f" {digit}", f"L {digit}")
-        path_string = path_string.replace("L", "M", 1)
-        return self.path_string_to_mobject(path_string)
-
-    def circle_to_mobject(self, circle_element):
-        x, y, r = [
-            self.attribute_to_float(
-                circle_element.getAttribute(key)
-            )
-            if circle_element.hasAttribute(key)
-            else 0.0
-            for key in ("cx", "cy", "r")
-        ]
-        return Circle(radius=r).shift(x * RIGHT + y * DOWN)
-
-    def ellipse_to_mobject(self, circle_element):
-        x, y, rx, ry = [
-            self.attribute_to_float(
-                circle_element.getAttribute(key)
-            )
-            if circle_element.hasAttribute(key)
-            else 0.0
-            for key in ("cx", "cy", "rx", "ry")
-        ]
-        result = Circle()
-        result.stretch(rx, 0)
-        result.stretch(ry, 1)
-        result.shift(x * RIGHT + y * DOWN)
-        return result
-
-    def rect_to_mobject(self, rect_element):
-        fill_color = rect_element.getAttribute("fill")
-        stroke_color = rect_element.getAttribute("stroke")
-        stroke_width = rect_element.getAttribute("stroke-width")
-        corner_radius = rect_element.getAttribute("rx")
-
-        # input preprocessing
-        fill_opacity = 1
-        if fill_color in ["", "none", "#FFF", "#FFFFFF"] or Color(fill_color) == Color(WHITE):
-            fill_opacity = 0
-            fill_color = BLACK  # shdn't be necessary but avoids error msgs
-        if fill_color in ["#000", "#000000"]:
-            fill_color = WHITE
-        if stroke_color in ["", "none", "#FFF", "#FFFFFF"] or Color(stroke_color) == Color(WHITE):
-            stroke_width = 0
-            stroke_color = BLACK
-        if stroke_color in ["#000", "#000000"]:
-            stroke_color = WHITE
-        if stroke_width in ["", "none", "0"]:
-            stroke_width = 0
-
-        if corner_radius in ["", "0", "none"]:
-            corner_radius = 0
-
-        corner_radius = float(corner_radius)
-
-        if corner_radius == 0:
-            mob = Rectangle(
-                width=self.attribute_to_float(
-                    rect_element.getAttribute("width")
-                ),
-                height=self.attribute_to_float(
-                    rect_element.getAttribute("height")
-                ),
-                stroke_width=stroke_width,
-                stroke_color=stroke_color,
-                fill_color=fill_color,
-                fill_opacity=fill_opacity
-            )
-        else:
-            mob = RoundedRectangle(
-                width=self.attribute_to_float(
-                    rect_element.getAttribute("width")
-                ),
-                height=self.attribute_to_float(
-                    rect_element.getAttribute("height")
-                ),
-                stroke_width=stroke_width,
-                stroke_color=stroke_color,
-                fill_color=fill_color,
-                fill_opacity=opacity,
-                corner_radius=corner_radius
-            )
-
-        mob.shift(mob.get_center() - mob.get_corner(UP + LEFT))
-        return mob
-
-    def handle_transforms(self, element, mobject):
-        # TODO, this could use some cleaning...
-        x, y = 0, 0
-        try:
-            x = self.attribute_to_float(element.getAttribute('x'))
-            # Flip y
-            y = -self.attribute_to_float(element.getAttribute('y'))
-            mobject.shift([x, y, 0])
-        except Exception:
-            pass
-
-        transform = element.getAttribute('transform')
-
-        try:  # transform matrix
-            prefix = "matrix("
-            suffix = ")"
-            if not transform.startswith(prefix) or not transform.endswith(suffix):
-                raise Exception()
-            transform = transform[len(prefix):-len(suffix)]
-            transform = string_to_numbers(transform)
-            transform = np.array(transform).reshape([3, 2])
-            x = transform[2][0]
-            y = -transform[2][1]
-            matrix = np.identity(self.dim)
-            matrix[:2, :2] = transform[:2, :]
-            matrix[1] *= -1
-            matrix[:, 1] *= -1
-
-            for mob in mobject.family_members_with_points():
-                mob.apply_matrix(matrix.T)
-            mobject.shift(x * RIGHT + y * UP)
-        except:
-            pass
-
-        try:  # transform scale
-            prefix = "scale("
-            suffix = ")"
-            if not transform.startswith(prefix) or not transform.endswith(suffix):
-                raise Exception()
-            transform = transform[len(prefix):-len(suffix)]
-            scale_values = string_to_numbers(transform)
-            if len(scale_values) == 2:
-                scale_x, scale_y = scale_values
-                mobject.scale(np.array([scale_x, scale_y, 1]), about_point=ORIGIN)
-            elif len(scale_values) == 1:
-                scale = scale_values[0]
-                mobject.scale(np.array([scale, scale, 1]), about_point=ORIGIN)
-        except:
-            pass
-
-        try:  # transform translate
-            prefix = "translate("
-            suffix = ")"
-            if not transform.startswith(prefix) or not transform.endswith(suffix):
-                raise Exception()
-            transform = transform[len(prefix):-len(suffix)]
-            x, y = string_to_numbers(transform)
-            mobject.shift(x * RIGHT + y * DOWN)
-        except:
-            pass
-        # TODO, ...
-
-    def flatten(self, input_list):
-        output_list = []
-        for i in input_list:
-            if isinstance(i, list):
-                output_list.extend(self.flatten(i))
-            else:
-                output_list.append(i)
-        return output_list
-
-    def get_all_childNodes_have_id(self, element):
-        all_childNodes_have_id = []
-        if not isinstance(element, minidom.Element):
-            return
-        if element.hasAttribute('id'):
-            return [element]
-        for e in element.childNodes:
-            all_childNodes_have_id.append(self.get_all_childNodes_have_id(e))
-        return self.flatten([e for e in all_childNodes_have_id if e])
-
-    def update_ref_to_element(self, defs):
-        new_refs = dict([(e.getAttribute('id'), e) for e in self.get_all_childNodes_have_id(defs)])
-        self.ref_to_element.update(new_refs)
-
-
-class VMobjectFromSVGPathstring(VMobject):
+class VMobjectFromSVGPath(VMobject):
    CONFIG = {
        "long_lines": False,
        "should_subdivide_sharp_curves": False,
        "should_remove_null_curves": False,
    }

-    def __init__(self, path_string, **kwargs):
-        self.path_string = path_string
+    def __init__(self, path_obj, **kwargs):
+        # Get rid of arcs
+        path_obj.approximate_arcs_with_quads()
+        self.path_obj = path_obj
        super().__init__(**kwargs)

    def init_points(self):
        # After a given svg_path has been converted into points, the result
        # will be saved to a file so that future calls for the same path
        # don't need to retrace the same computation.
-        hasher = hashlib.sha256(self.path_string.encode())
+        path_string = self.path_obj.d()
+        hasher = hashlib.sha256(path_string.encode())
        path_hash = hasher.hexdigest()[:16]
        points_filepath = os.path.join(get_mobject_data_dir(), f"{path_hash}_points.npy")
        tris_filepath = os.path.join(get_mobject_data_dir(), f"{path_hash}_tris.npy")
@@ -352,177 +305,23 @@ class VMobjectFromSVGPathstring(VMobject):
            if self.should_remove_null_curves:
                # Get rid of any null curves
                self.set_points(self.get_points_without_null_curves())
-            # SVG treats y-coordinate differently
-            self.stretch(-1, 1, about_point=ORIGIN)
            # Save to a file for future use
            np.save(points_filepath, self.get_points())
            np.save(tris_filepath, self.get_triangulation())

-    def get_commands_and_coord_strings(self):
-        all_commands = list(self.get_command_to_function_map().keys())
-        all_commands += [c.lower() for c in all_commands]
-        pattern = "[{}]".format("".join(all_commands))
-        return zip(
-            re.findall(pattern, self.path_string),
-            re.split(pattern, self.path_string)[1:]
-        )
-
    def handle_commands(self):
-        relative_point = ORIGIN
-        for command, coord_string in self.get_commands_and_coord_strings():
-            func, number_types_str = self.command_to_function(command)
-            upper_command = command.upper()
-            if upper_command == "Z":
-                func()  # `close_path` takes no arguments
-                continue
-
-            number_types = np.array(list(number_types_str))
-            n_numbers = len(number_types_str)
-            number_groups = np.array(string_to_numbers(coord_string)).reshape((-1, n_numbers))
-
-            for numbers in number_groups:
-                if command.islower():
-                    # Treat it as a relative command
-                    numbers[number_types == "x"] += relative_point[0]
-                    numbers[number_types == "y"] += relative_point[1]
-
-                if upper_command == "A":
-                    args = [*numbers[:5], np.array([*numbers[5:7], 0.0])]
-                elif upper_command == "H":
-                    args = [np.array([numbers[0], relative_point[1], 0.0])]
-                elif upper_command == "V":
-                    args = [np.array([relative_point[0], numbers[0], 0.0])]
-                else:
-                    args = list(np.hstack((
-                        numbers.reshape((-1, 2)), np.zeros((n_numbers // 2, 1))
-                    )))
-                func(*args)
-                relative_point = self.get_last_point()
-
-
-    def add_elliptical_arc_to(self, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, point):
-        def close_to_zero(a, threshold=1e-5):
-            return abs(a) < threshold
-
-        def solve_2d_linear_equation(a, b, c):
-            """
-            Using Crammer's rule to solve the linear equation `[a b]x = c`
-            where `a`, `b` and `c` are all 2d vectors.
-            """
-            def det(a, b):
-                return a[0] * b[1] - a[1] * b[0]
-            d = det(a, b)
-            if close_to_zero(d):
-                raise Exception("Cannot handle 0 determinant.")
-            return [det(c, b) / d, det(a, c) / d]
-
-        def get_arc_center_and_angles(x0, y0, rx, ry, phi, large_arc_flag, sweep_flag, x1, y1):
-            """
-            The parameter functions of an ellipse rotated `phi` radians counterclockwise is (on `alpha`):
-                x = cx + rx * cos(alpha) * cos(phi) + ry * sin(alpha) * sin(phi),
-                y = cy + rx * cos(alpha) * sin(phi) - ry * sin(alpha) * cos(phi).
-            Now we have two points sitting on the ellipse: `(x0, y0)`, `(x1, y1)`, corresponding to 4 equations,
-            and we want to hunt for 4 variables: `cx`, `cy`, `alpha0` and `alpha_1`.
-            Let `d_alpha = alpha1 - alpha0`, then:
-            if `sweep_flag = 0` and `large_arc_flag = 1`, then `PI <= d_alpha < 2 * PI`;
-            if `sweep_flag = 0` and `large_arc_flag = 0`, then `0 < d_alpha <= PI`;
-            if `sweep_flag = 1` and `large_arc_flag = 0`, then `-PI <= d_alpha < 0`;
-            if `sweep_flag = 1` and `large_arc_flag = 1`, then `-2 * PI < d_alpha <= -PI`.
-            """
-            xd = x1 - x0
-            yd = y1 - y0
-            if close_to_zero(xd) and close_to_zero(yd):
-                raise Exception("Cannot find arc center since the start point and the end point meet.")
-            # Find `p = cos(alpha1) - cos(alpha0)`, `q = sin(alpha1) - sin(alpha0)`
-            eq0 = [rx * np.cos(phi), ry * np.sin(phi), xd]
-            eq1 = [rx * np.sin(phi), -ry * np.cos(phi), yd]
-            p, q = solve_2d_linear_equation(*zip(eq0, eq1))
-            # Find `s = (alpha1 - alpha0) / 2`, `t = (alpha1 + alpha0) / 2`
-            # If `sin(s) = 0`, this requires `p = q = 0`,
-            # implying `xd = yd = 0`, which is impossible.
-            sin_s = (p ** 2 + q ** 2) ** 0.5 / 2
-            if sweep_flag:
-                sin_s = -sin_s
-            sin_s = clip(sin_s, -1, 1)
-            s = np.arcsin(sin_s)
-            if large_arc_flag:
-                if not sweep_flag:
-                    s = PI - s
-                else:
-                    s = -PI - s
-            sin_t = -p / (2 * sin_s)
-            cos_t = q / (2 * sin_s)
-            cos_t = clip(cos_t, -1, 1)
-            t = np.arccos(cos_t)
-            if sin_t <= 0:
-                t = -t
-            # We can make sure `0 < abs(s) < PI`, `-PI <= t < PI`.
-            alpha0 = t - s
-            alpha_1 = t + s
-            cx = x0 - rx * np.cos(alpha0) * np.cos(phi) - ry * np.sin(alpha0) * np.sin(phi)
-            cy = y0 - rx * np.cos(alpha0) * np.sin(phi) + ry * np.sin(alpha0) * np.cos(phi)
-            return cx, cy, alpha0, alpha_1
-
-        def get_point_on_ellipse(cx, cy, rx, ry, phi, angle):
-            return np.array([
-                cx + rx * np.cos(angle) * np.cos(phi) + ry * np.sin(angle) * np.sin(phi),
-                cy + rx * np.cos(angle) * np.sin(phi) - ry * np.sin(angle) * np.cos(phi),
-                0
-            ])
-
-        def convert_elliptical_arc_to_quadratic_bezier_curve(
-            cx, cy, rx, ry, phi, start_angle, end_angle, n_components=8
-        ):
-            theta = (end_angle - start_angle) / n_components / 2
-            handles = np.array([
-                get_point_on_ellipse(cx, cy, rx / np.cos(theta), ry / np.cos(theta), phi, a)
-                for a in np.linspace(
-                    start_angle + theta,
-                    end_angle - theta,
-                    n_components,
-                )
-            ])
-            anchors = np.array([
-                get_point_on_ellipse(cx, cy, rx, ry, phi, a)
-                for a in np.linspace(
-                    start_angle + theta * 2,
-                    end_angle,
-                    n_components,
-                )
-            ])
-            return handles, anchors
-
-        phi = x_axis_rotation * DEGREES
-        x0, y0 = self.get_last_point()[:2]
-        cx, cy, start_angle, end_angle = get_arc_center_and_angles(
-            x0, y0, rx, ry, phi, large_arc_flag, sweep_flag, point[0], point[1]
-        )
-        handles, anchors = convert_elliptical_arc_to_quadratic_bezier_curve(
-            cx, cy, rx, ry, phi, start_angle, end_angle
-        )
-        for handle, anchor in zip(handles, anchors):
-            self.add_quadratic_bezier_curve_to(handle, anchor)
-
-    def command_to_function(self, command):
-        return self.get_command_to_function_map()[command.upper()]
-
-    def get_command_to_function_map(self):
-        """
-        Associates svg command to VMobject function, and
-        the types of arguments it takes in
-        """
-        return {
-            "M": (self.start_new_path, "xy"),
-            "L": (self.add_line_to, "xy"),
-            "H": (self.add_line_to, "x"),
-            "V": (self.add_line_to, "y"),
-            "C": (self.add_cubic_bezier_curve_to, "xyxyxy"),
-            "S": (self.add_smooth_cubic_curve_to, "xyxy"),
-            "Q": (self.add_quadratic_bezier_curve_to, "xyxy"),
-            "T": (self.add_smooth_curve_to, "xy"),
-            "A": (self.add_elliptical_arc_to, "-----xy"),
-            "Z": (self.close_path, ""),
+        segment_class_to_func_map = {
+            se.Move: (self.start_new_path, ("end",)),
+            se.Close: (self.close_path, ()),
+            se.Line: (self.add_line_to, ("end",)),
+            se.QuadraticBezier: (self.add_quadratic_bezier_curve_to, ("control", "end")),
+            se.CubicBezier: (self.add_cubic_bezier_curve_to, ("control1", "control2", "end"))
        }
-
-    def get_original_path_string(self):
-        return self.path_string
+        for segment in self.path_obj:
+            segment_class = segment.__class__
+            func, attr_names = segment_class_to_func_map[segment_class]
+            points = [
+                _convert_point_to_3d(*segment.__getattribute__(attr_name))
+                for attr_name in attr_names
+            ]
+            func(*points)
--- a/manimlib/mobject/svg/tex_mobject.py
+++ b/manimlib/mobject/svg/tex_mobject.py
@@ -5,7 +5,6 @@ import re
 from manimlib.constants import *
 from manimlib.mobject.geometry import Line
 from manimlib.mobject.svg.svg_mobject import SVGMobject
-from manimlib.mobject.types.vectorized_mobject import VMobject
 from manimlib.mobject.types.vectorized_mobject import VGroup
 from manimlib.utils.config_ops import digest_config
 from manimlib.utils.tex_file_writing import tex_to_svg_file
@@ -16,49 +15,51 @@ from manimlib.utils.tex_file_writing import display_during_execution
 SCALE_FACTOR_PER_FONT_POINT = 0.001


-tex_string_to_mob_map = {}
-
-
-class SingleStringTex(VMobject):
+class SingleStringTex(SVGMobject):
    CONFIG = {
+        "height": None,
        "fill_opacity": 1.0,
        "stroke_width": 0,
-        "should_center": True,
+        "svg_default": {
+            "color": WHITE,
+        },
+        "path_string_config": {
+            "should_subdivide_sharp_curves": True,
+            "should_remove_null_curves": True,
+        },
        "font_size": 48,
-        "height": None,
-        "organize_left_to_right": False,
        "alignment": "\\centering",
        "math_mode": True,
+        "organize_left_to_right": False,
    }

    def __init__(self, tex_string, **kwargs):
-        super().__init__(**kwargs)
-        assert(isinstance(tex_string, str))
+        assert isinstance(tex_string, str)
        self.tex_string = tex_string
-        if tex_string not in tex_string_to_mob_map:
-            with display_during_execution(f" Writing \"{tex_string}\""):
-                full_tex = self.get_tex_file_body(tex_string)
-                filename = tex_to_svg_file(full_tex)
-                svg_mob = SVGMobject(
-                    filename,
-                    height=None,
-                    path_string_config={
-                        "should_subdivide_sharp_curves": True,
-                        "should_remove_null_curves": True,
-                    }
-                )
-                tex_string_to_mob_map[tex_string] = svg_mob
-        self.add(*(
-            sm.copy()
-            for sm in tex_string_to_mob_map[tex_string]
-        ))
-        self.init_colors()
+        super().__init__(**kwargs)

        if self.height is None:
            self.scale(SCALE_FACTOR_PER_FONT_POINT * self.font_size)
        if self.organize_left_to_right:
            self.organize_submobjects_left_to_right()

+    @property
+    def hash_seed(self):
+        return (
+            self.__class__.__name__,
+            self.svg_default,
+            self.path_string_config,
+            self.tex_string,
+            self.alignment,
+            self.math_mode
+        )
+
+    def get_file_path(self):
+        full_tex = self.get_tex_file_body(self.tex_string)
+        with display_during_execution(f"Writing \"{self.tex_string}\""):
+            file_path = tex_to_svg_file(full_tex)
+        return file_path
+
    def get_tex_file_body(self, tex_string):
        new_tex = self.get_modified_expression(tex_string)
        if self.math_mode:
@@ -132,7 +133,11 @@ class SingleStringTex(VMobject):
        Makes Tex resiliant to unmatched braces
        """
        num_unclosed_brackets = 0
-        for char in tex:
+        for i in range(len(tex)):
+            if i > 0 and tex[i - 1] == "\\":
+                # So as to not count '\{' type expressions
+                continue
+            char = tex[i]
            if char == "{":
                num_unclosed_brackets += 1
            elif char == "}":
--- a/manimlib/mobject/svg/text_mobject.py
+++ b/manimlib/mobject/svg/text_mobject.py
@@ -3,7 +3,6 @@ import os
 import re
 import io
 import typing
-import warnings
 import xml.etree.ElementTree as ET
 import functools
 import pygments
@@ -14,6 +13,7 @@ from contextlib import contextmanager
 from pathlib import Path

 import manimpango
+from manimlib.logger import log
 from manimlib.constants import *
 from manimlib.mobject.geometry import Dot
 from manimlib.mobject.svg.svg_mobject import SVGMobject
@@ -54,10 +54,9 @@ class Text(SVGMobject):
        self.full2short(kwargs)
        digest_config(self, kwargs)
        if self.size:
-            warnings.warn(
-                "self.size has been deprecated and will "
+            log.warning(
+                "`self.size` has been deprecated and will "
                "be removed in future.",
-                DeprecationWarning
            )
            self.font_size = self.size
        if self.lsh == -1:
--- a/manimlib/mobject/three_dimensions.py
+++ b/manimlib/mobject/three_dimensions.py
@@ -7,7 +7,6 @@ from manimlib.mobject.types.vectorized_mobject import VGroup
 from manimlib.mobject.types.vectorized_mobject import VMobject
 from manimlib.mobject.geometry import Square
 from manimlib.mobject.geometry import Polygon
-from manimlib.mobject.geometry import Line
 from manimlib.utils.bezier import interpolate
 from manimlib.utils.config_ops import digest_config
 from manimlib.utils.space_ops import get_norm
--- a/manimlib/mobject/types/point_cloud_mobject.py
+++ b/manimlib/mobject/types/point_cloud_mobject.py
@@ -21,6 +21,8 @@ class PMobject(Mobject):
        return self

    def set_points(self, points):
+        if len(points) == 0:
+            points = np.zeros((0, 3))
        super().set_points(points)
        self.resize_points(len(points))
        return self
@@ -34,14 +36,18 @@ class PMobject(Mobject):
        if color is not None:
            if opacity is None:
                opacity = self.data["rgbas"][-1, 3]
-            new_rgbas = np.repeat(
+            rgbas = np.repeat(
                [color_to_rgba(color, opacity)],
                len(points),
                axis=0
            )
-        elif rgbas is not None:
-            new_rgbas = rgbas
-        self.data["rgbas"][-len(new_rgbas):] = new_rgbas
+        if rgbas is not None:
+            self.data["rgbas"][-len(rgbas):] = rgbas
+        return self
+
+    def add_point(self, point, rgba=None, color=None, opacity=None):
+        rgbas = None if rgba is None else [rgba]
+        self.add_points([point], rgbas, color, opacity)
        return self

    def set_color_by_gradient(self, *colors):
--- a/manimlib/mobject/types/vectorized_mobject.py
+++ b/manimlib/mobject/types/vectorized_mobject.py
@@ -382,7 +382,10 @@ class VMobject(Mobject):

    def add_smooth_cubic_curve_to(self, handle, point):
        self.throw_error_if_no_points()
-        new_handle = self.get_reflection_of_last_handle()
+        if self.get_num_points() == 1:
+            new_handle = self.get_points()[-1]
+        else:
+            new_handle = self.get_reflection_of_last_handle()
        self.add_cubic_bezier_curve_to(new_handle, handle, point)

    def has_new_path_started(self):
--- a/manimlib/once_useful_constructs/graph_theory.py
+++ b/manimlib/once_useful_constructs/graph_theory.py
@@ -277,7 +277,6 @@ class DiscreteGraphScene(Scene):
    def trace_cycle(self, cycle=None, color="yellow", run_time=2.0):
        if cycle is None:
            cycle = self.graph.region_cycles[0]
-        time_per_edge = run_time / len(cycle)
        next_in_cycle = it.cycle(cycle)
        next(next_in_cycle)  # jump one ahead
        self.traced_cycle = Mobject(*[
--- a/manimlib/scene/scene.py
+++ b/manimlib/scene/scene.py
@@ -36,6 +36,7 @@ class Scene(object):
        "end_at_animation_number": None,
        "leave_progress_bars": False,
        "preview": True,
+        "presenter_mode": False,
        "linger_after_completion": True,
    }

@@ -62,6 +63,7 @@ class Scene(object):
        # Items associated with interaction
        self.mouse_point = Point()
        self.mouse_drag_point = Point()
+        self.hold_on_wait = self.presenter_mode

        # Much nicer to work with deterministic scenes
        if self.random_seed is not None:
@@ -114,7 +116,7 @@ class Scene(object):
        if self.quit_interaction:
            self.unlock_mobject_data()

-    def embed(self):
+    def embed(self, close_scene_on_exit=True):
        if not self.preview:
            # If the scene is just being
            # written, ignore embed calls
@@ -139,8 +141,9 @@ class Scene(object):
        log.info("Tips: Now the embed iPython terminal is open. But you can't interact with"
                 " the window directly. To do so, you need to type `touch()` or `self.interact()`")
        shell(local_ns=local_ns, stack_depth=2)
-        # End scene when exiting an embed.
-        raise EndSceneEarlyException()
+        # End scene when exiting an embed
+        if close_scene_on_exit:
+            raise EndSceneEarlyException()

    def __str__(self):
        return self.__class__.__name__
@@ -432,6 +435,11 @@ class Scene(object):
    def unlock_mobject_data(self):
        self.camera.release_static_mobjects()

+    def refresh_locked_data(self):
+        self.unlock_mobject_data()
+        self.lock_static_mobject_data()
+        return self
+
    def begin_animations(self, animations):
        for animation in animations:
            animation.begin()
@@ -477,19 +485,30 @@ class Scene(object):
        self.unlock_mobject_data()

    @handle_play_like_call
-    def wait(self, duration=DEFAULT_WAIT_TIME, stop_condition=None):
+    def wait(self,
+             duration=DEFAULT_WAIT_TIME,
+             stop_condition=None,
+             note=None,
+             ignore_presenter_mode=False):
+        if note:
+            log.info(note)
        self.update_mobjects(dt=0)  # Any problems with this?
        self.lock_static_mobject_data()
-        time_progression = self.get_wait_time_progression(duration, stop_condition)
-        last_t = 0
-        for t in time_progression:
-            dt = t - last_t
-            last_t = t
-            self.update_frame(dt)
-            self.emit_frame()
-            if stop_condition is not None and stop_condition():
-                time_progression.close()
-                break
+        if self.presenter_mode and not self.skip_animations and not ignore_presenter_mode:
+            while self.hold_on_wait:
+                self.update_frame(dt=1 / self.camera.frame_rate)
+            self.hold_on_wait = True
+        else:
+            time_progression = self.get_wait_time_progression(duration, stop_condition)
+            last_t = 0
+            for t in time_progression:
+                dt = t - last_t
+                last_t = t
+                self.update_frame(dt)
+                self.emit_frame()
+                if stop_condition is not None and stop_condition():
+                    time_progression.close()
+                    break
        self.unlock_mobject_data()
        return self

@@ -610,6 +629,10 @@ class Scene(object):
            self.camera.frame.to_default_state()
        elif char == "q":
            self.quit_interaction = True
+        elif char == " " or symbol == 65363:  # Space or right arrow
+            self.hold_on_wait = False
+        elif char == "e" and modifiers == 3:  # ctrl + shift + e
+            self.embed(close_scene_on_exit=False)

    def on_resize(self, width: int, height: int):
        self.camera.reset_pixel_shape(width, height)
--- a/manimlib/scene/scene_file_writer.py
+++ b/manimlib/scene/scene_file_writer.py
@@ -308,7 +308,7 @@ class SceneFileWriter(object):
        )
        temp_file_path = stem + "_temp" + ext
        commands = [
-            "ffmpeg",
+            FFMPEG_BIN,
            "-i", movie_file_path,
            "-i", sound_file_path,
            '-y',  # overwrite output file if it exists
--- a/manimlib/scene/vector_space_scene.py
+++ b/manimlib/scene/vector_space_scene.py
@@ -287,9 +287,6 @@ class LinearTransformationScene(VectorScene):
        },
        "background_plane_kwargs": {
            "color": GREY,
-            "axis_config": {
-                "stroke_color": GREY_B,
-            },
            "axis_config": {
                "color": GREY,
            },
--- a/manimlib/utils/bezier.py
+++ b/manimlib/utils/bezier.py
@@ -14,10 +14,10 @@ def bezier(points):
    n = len(points) - 1

    def result(t):
-        return sum([
+        return sum(
            ((1 - t)**(n - k)) * (t**k) * choose(n, k) * point
            for k, point in enumerate(points)
-        ])
+        )

    return result

--- a/manimlib/utils/color.py
+++ b/manimlib/utils/color.py
@@ -7,8 +7,6 @@ from manimlib.constants import WHITE
 from manimlib.constants import COLORMAP_3B1B
 from manimlib.utils.bezier import interpolate
 from manimlib.utils.iterables import resize_with_interpolation
-from manimlib.utils.simple_functions import clip_in_place
-from manimlib.utils.space_ops import normalize


 def color_to_rgb(color):
@@ -105,16 +103,6 @@ def random_color():
    return Color(rgb=(random.random() for i in range(3)))


-def get_shaded_rgb(rgb, point, unit_normal_vect, light_source):
-    to_sun = normalize(light_source - point)
-    factor = 0.5 * np.dot(unit_normal_vect, to_sun)**3
-    if factor < 0:
-        factor *= 0.5
-    result = rgb + factor
-    clip_in_place(rgb + factor, 0, 1)
-    return result
-
-
 def get_colormap_list(map_name="viridis", n_colors=9):
    """
    Options for map_name:
--- a/manimlib/utils/init_config.py
+++ b/manimlib/utils/init_config.py
@@ -1,5 +1,28 @@
-import yaml
 import os
+import yaml
+import inspect
+import importlib 
+
+from rich import box
+from rich.rule import Rule 
+from rich.table import Table
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+
+
+def get_manim_dir():
+    manimlib_module = importlib.import_module("manimlib")
+    manimlib_dir = os.path.dirname(inspect.getabsfile(manimlib_module))
+    return os.path.abspath(os.path.join(manimlib_dir, ".."))
+
+
+def remove_empty_value(dictionary):
+    for key in list(dictionary.keys()):
+        if dictionary[key] == "":
+            dictionary.pop(key)
+        elif isinstance(dictionary[key], dict):
+            remove_empty_value(dictionary[key])
+

 def init_customization():
    configuration = {
@@ -24,6 +47,7 @@ def init_customization():
        },
        "window_position": "UR",
        "window_monitor": 0,
+        "full_screen": False,
        "break_into_partial_movies": False,
        "camera_qualities": {
            "low": {
@@ -46,41 +70,103 @@ def init_customization():
        }
    }

-    print("Initialize configuration")
-    scope = input(" Please select the scope of the configuration [global/local]: ")
-    if scope == "global":
-        from manimlib.config import get_manim_dir
-        file_name = os.path.join(get_manim_dir(), "manimlib", "default_config.yml")
-    else:
-        file_name = os.path.join(os.getcwd(), "custom_config.yml")
+    console = Console()
+    console.print(Rule("[bold]Configuration Guide[/bold]"))
+    # print("Initialize configuration")
+    try:
+        scope = Prompt.ask(
+            "  Select the scope of the configuration", 
+            choices=["global", "local"],
+            default="local"
+        )

-    print("\n directories:")
-    configuration["directories"]["output"] = input("  [1/8] Where should manim output video and image files place: ")
-    configuration["directories"]["raster_images"] = input("  [2/8] Which folder should manim find raster images (.jpg .png .gif) in (optional): ")
-    configuration["directories"]["vector_images"] = input("  [3/8] Which folder should manim find vector images (.svg .xdv) in (optional): ")
-    configuration["directories"]["sounds"] = input("  [4/8] Which folder should manim find sound files (.mp3 .wav) in (optional): ")
-    configuration["directories"]["temporary_storage"] = input("  [5/8] Which folder should manim storage temporary files: ")
+        console.print("[bold]Directories:[/bold]")
+        dir_config = configuration["directories"]
+        dir_config["output"] = Prompt.ask(
+            "  Where should manim [bold]output[/bold] video and image files place [prompt.default](optional, default is none)",
+            default="",
+            show_default=False
+        )
+        dir_config["raster_images"] = Prompt.ask(
+            "  Which folder should manim find [bold]raster images[/bold] (.jpg .png .gif) in "
+            "[prompt.default](optional, default is none)",
+            default="",
+            show_default=False
+        )
+        dir_config["vector_images"] = Prompt.ask(
+            "  Which folder should manim find [bold]vector images[/bold] (.svg .xdv) in "
+            "[prompt.default](optional, default is none)",
+            default="",
+            show_default=False
+        )
+        dir_config["sounds"] = Prompt.ask(
+            "  Which folder should manim find [bold]sound files[/bold] (.mp3 .wav) in "
+            "[prompt.default](optional, default is none)",
+            default="",
+            show_default=False
+        )
+        dir_config["temporary_storage"] = Prompt.ask(
+            "  Which folder should manim storage [bold]temporary files[/bold] "
+            "[prompt.default](recommended, use system temporary folder by default)",
+            default="",
+            show_default=False
+        )

-    print("\n tex:")
-    tex = input("  [6/8] Which executable file to use to compile [latex/xelatex]: ")
-    if tex == "latex":
-        configuration["tex"]["executable"] = "latex"
-        configuration["tex"]["template_file"] = "tex_template.tex"
-        configuration["tex"]["intermediate_filetype"] = "dvi"
-    else:
-        configuration["tex"]["executable"] = "xelatex -no-pdf"
-        configuration["tex"]["template_file"] = "ctex_template.tex"
-        configuration["tex"]["intermediate_filetype"] = "xdv"
+        console.print("[bold]LaTeX:[/bold]")
+        tex_config = configuration["tex"]
+        tex = Prompt.ask(
+            "  Select an executable program to use to compile a LaTeX source file",
+            choices=["latex", "xelatex"],
+            default="latex"
+        )
+        if tex == "latex":
+            tex_config["executable"] = "latex"
+            tex_config["template_file"] = "tex_template.tex"
+            tex_config["intermediate_filetype"] = "dvi"
+        else:
+            tex_config["executable"] = "xelatex -no-pdf"
+            tex_config["template_file"] = "ctex_template.tex"
+            tex_config["intermediate_filetype"] = "xdv"
+        
+        console.print("[bold]Styles:[/bold]")
+        configuration["style"]["background_color"] = Prompt.ask(
+            "  Which [bold]background color[/bold] do you want [italic](hex code)",
+            default="#333333"
+        )

-    print("\n style:")
-    configuration["style"]["background_color"] = input("  [7/8] Which background color do you want (hex code): ")
+        console.print("[bold]Camera qualities:[/bold]")
+        table = Table(
+            "low", "medium", "high", "ultra_high",
+            title="Four defined qualities",
+            box=box.ROUNDED
+        )
+        table.add_row("480p15", "720p30", "1080p60", "2160p60")
+        console.print(table)
+        configuration["camera_qualities"]["default_quality"] = Prompt.ask(
+            "  Which one to choose as the default rendering quality",
+            choices=["low", "medium", "high", "ultra_high"],
+            default="high"
+        )

-    print("\n camera_qualities:")
-    print("  Four defined qualities: low: 480p15  medium: 720p30  high: 1080p60  ultra_high: 2160p60")
-    configuration["camera_qualities"]["default_quality"] = input("  [8/8] Which one to choose as the default rendering quality [low/medium/high/ultra_high]: ")
+        write_to_file = Confirm.ask(
+            "\n[bold]Are you sure to write these configs to file?[/bold]",
+            default=True
+        )
+        if not write_to_file:
+            raise KeyboardInterrupt

-    with open(file_name, 'w', encoding="utf_8") as file:
-        yaml.dump(configuration, file)
+        global_file_name = os.path.join(get_manim_dir(), "manimlib", "default_config.yml")
+        if scope == "global":
+            file_name = global_file_name
+        else:
+            if os.path.exists(global_file_name):
+                remove_empty_value(configuration)
+            file_name = os.path.join(os.getcwd(), "custom_config.yml")
+        with open(file_name, "w", encoding="utf-8") as f:
+            yaml.dump(configuration, f)
+        
+        console.print(f"\n:rocket: You have successfully set up a {scope} configuration file!")
+        console.print(f"You can manually modify it in: [cyan]`{file_name}`[/cyan]")

-    print(f"\nYou have set up a {scope} configuration file")
-    print(f"You can manually modify it again in: {file_name}\n")
+    except KeyboardInterrupt:
+        console.print("\n[green]Exit configuration guide[/green]")
--- a/manimlib/utils/iterables.py
+++ b/manimlib/utils/iterables.py
@@ -139,3 +139,14 @@ def remove_nones(sequence):

 def concatenate_lists(*list_of_lists):
    return [item for l in list_of_lists for item in l]
+
+
+def hash_obj(obj):
+    if isinstance(obj, dict):
+        new_obj = {k: hash_obj(v) for k, v in obj.items()}
+        return hash(tuple(frozenset(sorted(new_obj.items()))))
+
+    if isinstance(obj, (set, tuple, list)):
+        return hash(tuple(hash_obj(e) for e in obj))
+
+    return hash(obj)
--- a/manimlib/utils/simple_functions.py
+++ b/manimlib/utils/simple_functions.py
@@ -1,34 +1,20 @@
-from functools import reduce
 import inspect
 import numpy as np
-import operator as op
+import math
+from functools import lru_cache


 def sigmoid(x):
    return 1.0 / (1 + np.exp(-x))


-CHOOSE_CACHE = {}
+@lru_cache(maxsize=10)
+def choose(n, k):
+    return math.comb(n, k)


-def choose_using_cache(n, r):
-    if n not in CHOOSE_CACHE:
-        CHOOSE_CACHE[n] = {}
-    if r not in CHOOSE_CACHE[n]:
-        CHOOSE_CACHE[n][r] = choose(n, r, use_cache=False)
-    return CHOOSE_CACHE[n][r]
-
-
-def choose(n, r, use_cache=True):
-    if use_cache:
-        return choose_using_cache(n, r)
-    if n < r:
-        return 0
-    if r == 0:
-        return 1
-    denom = reduce(op.mul, range(1, r + 1), 1)
-    numer = reduce(op.mul, range(n, n - r, -1), 1)
-    return numer // denom
+def gen_choose(n, r):
+    return np.prod(np.arange(n, n - r, -1)) / math.factorial(r)


 def get_num_args(function):
@@ -53,14 +39,6 @@ def clip(a, min_a, max_a):
    return a


-def clip_in_place(array, min_val=None, max_val=None):
-    if max_val is not None:
-        array[array > max_val] = max_val
-    if min_val is not None:
-        array[array < min_val] = min_val
-    return array
-
-
 def fdiv(a, b, zero_over_zero_value=None):
    if zero_over_zero_value is not None:
        out = np.full_like(a, zero_over_zero_value)
--- a/manimlib/utils/strings.py
+++ b/manimlib/utils/strings.py
@@ -1,42 +0,0 @@
-import re
-import string
-
-
-def to_camel_case(name):
-    return "".join([
-        [c for c in part if c not in string.punctuation + string.whitespace].capitalize()
-        for part in name.split("_")
-    ])
-
-
-def initials(name, sep_values=[" ", "_"]):
-    return "".join([
-        (s[0] if s else "")
-        for s in re.split("|".join(sep_values), name)
-    ])
-
-
-def camel_case_initials(name):
-    return [c for c in name if c.isupper()]
-
-
-def complex_string(complex_num):
-    return [c for c in str(complex_num) if c not in "()"]
-
-
-def split_string_to_isolate_substrings(full_string, *isolate):
-    """
-    Given a string, and an arbitrary number of possible substrings,
-    to isolate, this returns a list of strings which would concatenate
-    to make the full string, and in which these special substrings
-    appear as their own elements.
-
-    For example,split_string_to_isolate_substrings("to be or not to be", "to", "be")
-    would return ["to", " ", "be", " or not ", "to", " ", "be"]
-    """
-    pattern = "|".join(*(
-        "({})".format(re.escape(ss))
-        for ss in isolate
-    ))
-    pieces = re.split(pattern, full_string)
-    return list(filter(lambda s: s, pieces))
--- a/manimlib/utils/tex_file_writing.py
+++ b/manimlib/utils/tex_file_writing.py
@@ -126,6 +126,9 @@ def dvi_to_svg(dvi_file, regen_if_exists=False):
 def display_during_execution(message):
    # Only show top line
    to_print = message.split("\n")[0]
+    max_characters = os.get_terminal_size().columns - 1
+    if len(to_print) > max_characters:
+        to_print = to_print[:max_characters - 3] + "..."
    try:
        print(to_print, end="\r")
        yield
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,3 @@
-argparse
 colour
 numpy
 Pillow
@@ -15,8 +14,9 @@ pygments
 pyyaml
 rich
 screeninfo
-pyreadline; sys_platform == 'win32'
 validators
 ipython
 PyOpenGL
 manimpango>=0.2.0,<0.4.0
+isosurfaces
+svgelements
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,6 +1,6 @@
 [metadata]
 name = manimgl
-version = 1.3.0
+version = 1.5.0
 author = Grant Sanderson
 author_email= grant@3blue1brown.com
 description = Animation engine for explanatory math videos
@@ -12,12 +12,24 @@ project_urls =
    Documentation = https://3b1b.github.io/manim/
    Source Code = https://github.com/3b1b/manim
 license = MIT
+classifiers =
+    Development Status :: 4 - Beta
+    License :: OSI Approved :: MIT License
+    Topic :: Scientific/Engineering
+    Topic :: Multimedia :: Video
+    Topic :: Multimedia :: Graphics
+    Programming Language :: Python :: 3.6
+    Programming Language :: Python :: 3.7
+    Programming Language :: Python :: 3.8
+    Programming Language :: Python :: 3.9
+    Programming Language :: Python :: 3.10
+    Programming Language :: Python :: 3 :: Only
+    Natural Language :: English

 [options]
 packages = find:
-include_package_data=True
-install_requires = 
-    argparse
+include_package_data = True
+install_requires =
    colour
    numpy
    Pillow
@@ -34,11 +46,12 @@ install_requires =
    pyyaml
    rich
    screeninfo
-    pyreadline; sys_platform == 'win32'
    validators
    ipython
    PyOpenGL
    manimpango>=0.2.0,<0.4.0
+    isosurfaces
+    svgelements

 [options.entry_points]
 console_scripts =
Author	SHA1	Message	Date
TonyCrane	4356c42e00	release: ready to release v1.5.0	2022-02-16 12:01:03 +08:00
TonyCrane	aea79be6cc	workflow: only build wheels for python 3.6+	2022-02-16 11:59:33 +08:00
TonyCrane	8ef42fae24	Merge branch 'master' of https://github.com/3b1b/manim	2022-02-16 11:21:20 +08:00
TonyCrane	6be6bd3075	docs: change the style of changelog	2022-02-16 11:20:08 +08:00
TonyCrane	a33eac7aa8	docs: update changelog for #1742 #1744 #1745 #1746	2022-02-16 11:17:37 +08:00
Grant Sanderson	9d6a28bc29	Merge pull request #1746 from 3b1b/video-work Change interaction-to-embed keybinding	2022-02-15 10:14:18 -08:00
Grant Sanderson	06405d5758	Merge branch 'master' of github.com:3b1b/manim into video-work	2022-02-15 10:11:35 -08:00
Grant Sanderson	46e356e791	Change keyboard shortcut to drop into an embedding to be ctrl+shift+e	2022-02-15 10:10:57 -08:00
Grant Sanderson	97ca42d454	Merge pull request #1745 from YishiMichael/master Reorganize inheriting order and refactor SVGMobject	2022-02-15 10:05:53 -08:00
Grant Sanderson	a4eee6f44c	Merge pull request #1744 from TurkeyBilly/patch-3 Add text_config for DecimalNumber	2022-02-15 09:59:46 -08:00
YishiMichael	8cac16b452	Update display_during_execution	2022-02-15 21:59:09 +08:00
YishiMichael	719cd8cde3	Remove redundant brackets	2022-02-15 21:54:56 +08:00
Bill Xi	0bb9216c14	Update hash_obj method	2022-02-15 21:50:14 +08:00
YishiMichael	6f9df8db26	Improve hashing algorithm	2022-02-15 21:38:22 +08:00
YishiMichael	3756605a45	Update display_during_execution	2022-02-15 20:55:44 +08:00
YishiMichael	0cab23b2ba	Reorganize inheriting order of SVGMobject	2022-02-15 20:16:15 +08:00
Bill Xi	aef02bfcf9	changed hashing	2022-02-15 11:45:17 +08:00
Bill Xi	9d04e287d7	Removed init_colors	2022-02-15 10:20:06 +08:00
Bill Xi	97c0f4857b	Update numbers.py Added config passing for text	2022-02-15 09:35:10 +08:00
Grant Sanderson	7f9b0a7eac	Merge pull request #1742 from 3b1b/video-work Presenter mode bug fix	2022-02-14 07:58:55 -08:00
Grant Sanderson	133724d29a	Allow for using right arrow in presenter mode	2022-02-14 07:56:26 -08:00
Grant Sanderson	559b96e7ce	Small bug fix for presenter mode	2022-02-14 07:52:06 -08:00
TonyCrane	f29ef87bba	style/docs: fix argument help style and update docs for it	2022-02-14 19:50:30 +08:00
TonyCrane	fc1e916f42	docs: update changelog for #1725 #1727 #1728 #1731 #1739 #1740	2022-02-14 14:03:51 +08:00
Grant Sanderson	b3b7d214ad	Fix Write bug (#1740 ) * Avoid division by zero error for calling Write on null objects	2022-02-13 20:04:05 -08:00
Grant Sanderson	602809758e	Video work (#1739 ) * Enable setting points to a null list, and adding one point at a time. * Add refresh_locked_data * Add presenter mode to scenes with -p option * Allow for an embed by hitting e during interaction * Add set_min_height, etc. * Make sure null parametric curve has at least one point * Account for edge case where \{ is used in Tex * Allow for logging notes in wait calls, useful for presenter mode * Simplify choose, and add gen_choose for fractional amounts * Default to no top on axes * Allow match_x, match_y, etc. to take in a point * Allow wait calls to ignore presenter mode * Just use math.combo, no caching with choose(n, r) * Use generator instead of list in bezier * Bubble init_colors should override * Account for "px" values read in from an svg * Stop displaying when writing is happening * Update the way Bubble override SVG colors	2022-02-13 15:16:16 -08:00
Elisha Hollander	f9351536e4	minor fixes (#1737 )	2022-02-13 11:12:41 +08:00
YishiMichael	67f5b10626	Attempt to refactor SVGMobject with svgelements (#1731 ) * Some small refactors * Refactor MTex * Implement TransformMatchingMTex * Some refactors * Some refactors * Some small refactors * Strip strings before matching * Implement get_submob_tex * Use RGB color mode * Some small refactors * Try refactoring SVGMobject with svglib * Refactor SVGMobject using svgelements * Refactor SVGMobject using svgelements * Use functions instead of func names as dict values * style: modify import order to conform to PEP8 * Set default values to None * modify import order * Remove unused import Co-authored-by: TonyCrane <tonycrane@foxmail.com>	2022-02-11 07:53:21 -08:00
YishiMichael	baba6929df	Implement ImplicitFunction (#1727 )	2022-02-07 08:24:40 -08:00
YishiMichael	d6b20a7306	Refactor MTex and implement TransformMatchingMTex (#1725 ) * Some small refactors * Refactor MTex * Implement TransformMatchingMTex * Some refactors * Some refactors * Some small refactors * Strip strings before matching * Implement get_submob_tex * Use RGB color mode * Some small refactors	2022-02-07 08:21:53 -08:00
鹤翔万里	4c3ba7f674	Clean dependencies (#1728 ) * clean dependencies * add classifiers to metadata	2022-02-05 22:13:34 +08:00
TonyCrane	3883f57bf8	release: ready to release v1.4.1	2022-02-04 11:03:37 +08:00
TonyCrane	d2e0811285	import Iterable from collections.abc instead of collections	2022-02-04 10:55:59 +08:00
Grant Sanderson	1e2a6ffb8a	Merge pull request #1724 from TurkeyBilly/patch-2 Temporarily fix boolean operation bug	2022-01-31 08:06:27 -08:00
Bill Xi	56e5696163	Update boolean_ops.py	2022-01-31 23:29:36 +08:00
TonyCrane	1ec00629a5	release: ready to release v1.4.0	2022-01-30 13:06:22 +08:00
TonyCrane	aa6335cd90	docs: update changelog for #1719 #1720 #1721 and #1723	2022-01-30 13:00:57 +08:00
YishiMichael	7093f7d02d	Some small refactors to MTex (#1723 )	2022-01-30 12:42:35 +08:00
Grant Sanderson	fad9ed2df7	Merge pull request #1720 from YishiMichael/master Handle explicit color-related commands	2022-01-29 08:01:48 -08:00
YishiMichael	725155409b	Some small refactors	2022-01-29 21:06:54 +08:00
YishiMichael	a6675eb043	Some small refactors	2022-01-29 14:35:27 +08:00
YishiMichael	5d2dcec307	Fix color-related bugs	2022-01-29 14:05:52 +08:00
Grant Sanderson	f60dc7cd07	Merge pull request #1719 from 3b1b/parse-style Parse style from <style> tag and Add support to <line> tag	2022-01-27 13:33:14 -08:00
YishiMichael	6c39cac62b	Remove redundant attribute	2022-01-28 01:19:02 +08:00
鹤翔万里	2bd25a55fa	add back override parameter to init_colors	2022-01-28 00:20:13 +08:00
鹤翔万里	0e4edfdd79	improve config helper (#1721 )	2022-01-28 00:16:19 +08:00
YishiMichael	277256a407	Merge branch '3b1b:master' into master	2022-01-27 23:11:19 +08:00
YishiMichael	831b7d455c	Handle explicit color-related commands	2022-01-27 23:09:05 +08:00
TonyCrane	1d14a23af9	docs: update changelog for #1712 #1717 and #1716	2022-01-27 22:21:40 +08:00
TonyCrane	dffa70ea15	docs: update changelog for #1704 and #1709	2022-01-27 22:09:57 +08:00
TonyCrane	31976063df	add dependency cssselect2	2022-01-27 17:31:14 +08:00
TonyCrane	aa135280ac	support <line> tag in SVG	2022-01-27 17:23:58 +08:00
TonyCrane	f0160822ba	fix bug of ref map	2022-01-27 17:17:19 +08:00
TonyCrane	48e07d1817	parse style attribute using tinycss	2022-01-27 17:16:52 +08:00
TonyCrane	3ef5899a24	some cleanups	2022-01-27 16:43:45 +08:00
TonyCrane	f895455264	add parser for <style> tag of SVG	2022-01-27 16:37:51 +08:00
Grant Sanderson	3baa14103e	Merge pull request #1716 from YishiMichael/master Refactor MTex and some clean-ups	2022-01-26 08:56:44 -08:00
Grant Sanderson	c315300ff1	Merge branch 'master' into master	2022-01-26 08:54:18 -08:00
Grant Sanderson	3b17d6d0eb	Merge pull request #1718 from 3b1b/text-fix Text fix	2022-01-26 08:21:36 -08:00
Grant Sanderson	8a29de5ef0	Override style for Text	2022-01-26 08:21:00 -08:00
Grant Sanderson	ecb729850a	Small style fixes	2022-01-26 08:20:45 -08:00
Grant Sanderson	a770291053	Include style in MTex.get_mobjects_from	2022-01-26 08:20:38 -08:00
Grant Sanderson	27c666fab5	Merge pull request #1717 from 3b1b/svg-style Parse and generate style for SVG	2022-01-26 07:56:03 -08:00
YishiMichael	942a7e71b8	Update MTex	2022-01-26 23:46:13 +08:00
TonyCrane	ebb75d1235	cached SVGMobject in SingleStringTex with default color	2022-01-26 20:37:44 +08:00
TonyCrane	9af23415a2	synchronize SingleStringTex's color to SVGMobject	2022-01-26 20:20:48 +08:00
TonyCrane	19778e405a	some cleanups	2022-01-26 19:55:47 +08:00
TonyCrane	833e40c2d4	fix default style	2022-01-26 19:50:27 +08:00
TonyCrane	9df53b8a18	fix the bug of M command with more than 2 args	2022-01-26 14:05:01 +08:00
TonyCrane	ff86b0e378	fix the bug of outdated relative_point after command Z	2022-01-26 13:56:42 +08:00
TonyCrane	92adcd75d4	add style support to svg	2022-01-26 13:53:53 +08:00
YishiMichael	240f5020b4	Add back default_config.yml	2022-01-26 13:21:27 +08:00
YishiMichael	e8205a5049	Some refactors for MTex	2022-01-26 13:03:14 +08:00
TonyCrane	6c8dd14adc	some clean	2022-01-26 11:00:57 +08:00
Grant Sanderson	07f84e2676	Merge pull request #1712 from 3b1b/fix-svg Improve handling of SVG transform and Some refactors	2022-01-25 13:26:40 -08:00
TonyCrane	8db1164ece	some refactors	2022-01-25 21:48:04 +08:00
TonyCrane	790bf0a104	fix typo	2022-01-25 20:25:30 +08:00
TonyCrane	8205edcc4c	fix a small bug	2022-01-25 20:13:20 +08:00
TonyCrane	05b3c9852e	fix add_smooth_cubic_curve_to when have only one point	2022-01-25 20:06:00 +08:00
TonyCrane	925f2e123f	add comments	2022-01-25 19:54:19 +08:00
TonyCrane	565763a2ff	reconstruct path parser	2022-01-25 19:44:42 +08:00
TonyCrane	6a74c241b8	fix bug of node which is not an element	2022-01-25 16:28:23 +08:00
TonyCrane	416cc8e6d5	add warning for unsupported element type	2022-01-25 14:41:11 +08:00
TonyCrane	d694aed452	add support for skewX and skewY transform	2022-01-25 14:40:02 +08:00
TonyCrane	11379283aa	add support for rotate transform	2022-01-25 14:29:47 +08:00
TonyCrane	dd13559b11	replace warnings.warn with log.warning	2022-01-25 14:09:05 +08:00
TonyCrane	1658438fef	allow Mobject.scale receive iterable scale_factor	2022-01-25 14:05:32 +08:00
TonyCrane	f4eb2724c5	refactor SVGMobject.handle_transforms	2022-01-25 14:04:35 +08:00
TonyCrane	33f720c73a	fix typo	2022-01-25 13:15:53 +08:00
TonyCrane	bbb4fa155c	fix the depth of svg tag	2022-01-25 13:14:19 +08:00
Grant Sanderson	2318c9e716	Merge pull request #1709 from TurkeyBilly/patch-4 Fix "Code is unreachable Pylance" warning for NumberPlane	2022-01-17 08:56:08 -08:00
Bill Xi	e80dd243f1	Added abstract method decorator and override	2022-01-17 20:27:34 +08:00
Grant Sanderson	3ffe300f96	Merge pull request #1704 from TurkeyBilly/patch-2 Adding "label_buff" config parameter for Brace	2022-01-03 08:53:34 -08:00
Bill Xi	24e3caa072	fix no "import copy" bug added import copy	2022-01-03 16:49:00 +08:00
Bill Xi	9efd02c500	Remove spelling mistake I misspelled "label"	2022-01-03 16:37:26 +08:00
Bill Xi	0a318486c5	Adding "lable_buff" config parameter for Brace	2022-01-03 14:57:16 +08:00
鹤翔万里	919133c6bf	Merge pull request #1702 from Suji04/patch-2 removed extra 'all' from comments	2021-12-31 18:18:50 +08:00
Sujan Dutta	066a2ed5dc	removed extra 'all' from comments	2021-12-31 00:10:57 -05:00
TonyCrane	09ced7ce9a	docs: update changelog for #1694 and #1697	2021-12-23 10:34:15 +08:00
Grant Sanderson	505b229117	Merge pull request #1697 from 3b1b/video-work Video work	2021-12-21 10:59:50 -08:00
Grant Sanderson	5aa8d15d85	Use FFMPEG_BIN instead of "ffmpeg" for sound incorporation	2021-12-21 10:58:58 -08:00
Grant Sanderson	7aa05572ab	Remove unnecessary import	2021-12-21 10:58:41 -08:00
Grant Sanderson	f1996f8479	Small hack for the lightbulb, needs to be fixed properly later	2021-12-21 10:58:33 -08:00
Grant Sanderson	37b63ca956	Merge pull request #1694 from DangGiaChi/BarChart_modified Add option to add ticks on x-axis in BarChart()	2021-12-17 09:30:53 -08:00
DangGiaChi	84fd657d9b	Change variables names: x_tick, x_ticks, y_tick, y_ticks	2021-12-17 15:02:10 +07:00
DangGiaChi	b489490f41	Fixed things as suggestions	2021-12-17 07:14:37 +07:00
DangGiaChi	bbf45f95c6	Add option to add ticks on x-axis in BarChart()	2021-12-16 22:03:29 +07:00