ManimCompatMob

Qualified name: algan.mobs.manim\_compat.ManimCompatMob

class ManimCompatMob(*args, **kwargs)

Bases: ManimMob

Base class for Mobs whose construction/query API is supplied by Manim.

Subclasses define _manim_class. Constructor arguments use Manim’s API; add_to_scene, glow and glow_radius remain Algan-only options. Methods not implemented by Algan are delegated to the backing Manim object. Returned Mobjects are converted to Algan Mobs – newly built ones are registered with the owning Scene, so axes.plot(...).spawn() renders – while mutations of the backing object are immediately resynchronised into this Mob’s geometry.

Methods

copy
get_manim_mobject	Return the backing Manim object used for compatibility operations.
move	Move by a displacement, applying it as a Manim shift.
move_to	Move the Mob to an absolute location.
rotate	Rotate the Mob, using Algan's rotation rather than Manim's.
scale	Resize the Mob relative to its current size.
set	Set several animatable attributes at once, as one animation.
sync_from_manim	Refresh converted geometry after directly editing the backing object.

Attributes

animation_manager	This mob's scene-owned animation manager.
basis	The Mob's orientation and scale, as a flattened 3x3 matrix of shape (*, 9).
casts_shadows	Whether this Mob's geometry blocks light on its way from a light source to another surface -- whether it casts a shadow.
children	The Mobs attached below this one, in attachment order.
closed_shell	Whether this Mob's triangles form a CLOSED shell -- every camera ray that enters the geometry crosses a second time on its way out.
draws_descendants	Whether get_render_primitives returns geometry belonging to this Mob's DESCENDANTS as well as its own.
forward	Get the direction the Mob is facing.
lifespan	This mob's [spawn, despawn) interval on its Scene timeline (a Lifespan).
location	The Mob's position in world space, shape (*, 3).
normalized_basis	The Mob's orientation with scale divided out, shape (*, 9).
parents	The Mobs this one is attached to, in attachment order.
receives_shadows	Whether this Mob's surfaces are darkened by shadows cast onto them.
right	Get the Mob's own rightward direction.
scale_coefficient	The Mob's scale along its own right, up and forward axes, shape (*, 3).
stroke_color	The color of the circuit's border stroke.
two_sided	Whether this Mob's geometry should be lit from whichever side the ray arrives on.
up	Get the Mob's own upward direction.
x	The Mob's x coordinate in world units, shape (*, 1).
xy	The Mob's x and y coordinates in world units, shape (*, 2).
y	The Mob's y coordinate in world units, shape (*, 1).
z	The Mob's z coordinate in world units, shape (*, 1).
z_index	Which of two exactly coplanar circuits draws in front (higher wins).

get_manim_mobject()

Return the backing Manim object used for compatibility operations.

move(displacement, arc_angle=None, recursive=True, **kwargs)

Move by a displacement, applying it as a Manim shift.

Algan’s generic implementation moves to self.location + displacement, but a compatibility Mob’s location is the center of the backing Mobject’s own points, which is not the composite’s center whenever it also has submobjects (an Arrow’s tip, for example). Shifting the backing geometry instead keeps the travelled displacement exact for every Mob, and is what the relative-placement helpers (move_to_screen_edge(), move_next_to(), …) are built on.

move_to(point_or_mobject, aligned_edge=array([0., 0., 0.]), coor_mask=array([1, 1, 1]))

Move the Mob to an absolute location.

The path is a straight line unless arc_angle is given, in which case the Mob swings to the target along a circular arc.

Animation

Recorded as an animation: the Mob travels from where it is to location over the current context’s runtime (1 second by default). Use with Off(): mob.move_to(...) to teleport it instead. Applies to this Mob and its descendants.

Parameters:

• location – The target location, shape (*, 3).

• arc_angle – Signed sweep of the curved path, in degrees. Defaults to None, meaning travel in a straight line.

• **kwargs – Passed to set_location() (notably recursive), or to move_to_point_along_arc() when arc_angle is given (notably arc_normal).

Returns:

This Mob, so calls can be chained.

Return type:

Mob

See also

move()

Move by a relative displacement instead.

move_to_screen_position()

Place the Mob in screen space.

rotate(angle, axis=tensor([0., 0., 1.]), about=None, *, degrees=True)

Rotate the Mob, using Algan’s rotation rather than Manim’s.

rotate is one of the names this class shares with Mob, and the two libraries mean different things by it: Algan measures angle in degrees where Manim’s angle is in radians, and an explicit axis turns the opposite way in each (their default z axis are opposite vectors, which is exactly what makes the default rotation agree). A compatibility Mob is animated as an Algan Mob, so this follows rotate() exactly – degrees, Algan’s direction constants, and a real rotation of the Mob’s basis that sweeps from 0 rather than a linear morph between the two poses (which cannot express a turn of 180 degrees, let alone a full one). The backing Manim object picks the new pose up through the usual lazy synchronization.

Only the pivot is taken from Manim: it rotates about the composite’s center, whereas Algan’s generic implementation uses location, the center of the backing Mobject’s own points. The two differ for every Mob that also has submobjects – an Arrow would otherwise turn about its shaft rather than in place – so about defaults to get_center(), which agrees with Manim’s get_center for these objects.

Parameters:

• angle (float | Tensor)

• axis (Tensor)

• about (Tensor | None)

• degrees (bool)

Return type:

Mob

scale(scale_factor, **kwargs)

Resize the Mob relative to its current size.

The factor multiplies the size the Mob has now, so two calls to scale(2) leave it four times its original size. For an absolute target, use set_scale().

Animation

Recorded as an animation: the Mob grows or shrinks over the current context’s runtime (1 second by default).

Parameters:

• scale_factor – Multiplier on the current size: 2 for twice as big, 0.5 for half. A tensor of shape (*, 3) scales the Mob’s right, up and forward axes separately, which is how you stretch a shape.

• recursive – Whether descendants scale too, keeping the Mob’s proportions. Defaults to True; False scales this Mob alone, so a Group’s children keep their own sizes.

Returns:

This Mob, so calls can be chained.

Return type:

Mob

set(**kwargs)

Set several animatable attributes at once, as one animation.

The attributes change together rather than one after another, which is what you want for a single visual beat: mob.set(location=RIGHT, color=BLUE) slides and recolors in the same second, where two separate statements would take two seconds inside a Seq.

Animation

Recorded as an animation: all the writes go into one Sync spanning the current context’s runtime (1 second by default). Changes propagate to descendants; use set_non_recursive() if they should not.

Parameters:

**kwargs – Animatable attribute names and their target values, e.g. location, color, opacity, glow, scale_coefficient.

Returns:

This Mob, so calls can be chained.

Return type:

Mob

Raises:

AttributeError – If a name is not an animatable attribute of this Mob. The message lists the ones that are.

Examples

Move a square to the right and change its color to blue:

Example: Example1MobSet

from algan import *

mob = Square().spawn()
mob.set(location=ORIGIN+RIGHT, color=BLUE)

Scene.save_video()

sync_from_manim(*, before_source=None)

Refresh converted geometry after directly editing the backing object.