A community-maintained Python framework for creating mathematical animations.
Ported OpenGLMobject and OpenGLVMobject
Devin Neal5ccf1d97ef78
diff --git a/manim/mobject/opengl_geometry.py b/manim/mobject/opengl_geometry.pyindex 103f89583..078a403d7 100644--- a/manim/mobject/opengl_geometry.py+++ b/manim/mobject/opengl_geometry.py@@ -104,51 +104,3 @@ class OpenGLArcBetweenPoints(OpenGLArc):if angle == 0:self.set_points_as_corners([LEFT, RIGHT])self.put_start_and_end_on(start, end)---class OpenGLPolygon(VMobject):- def __init__(self, *vertices, **kwargs):- self.vertices = vertices- super().__init__(**kwargs)-- def init_points(self):- verts = self.vertices- self.set_points_as_corners([*verts, verts[0]])-- def get_vertices(self):- return self.get_start_anchors()-- def round_corners(self, radius=0.5):- vertices = self.get_vertices()- arcs = []- for v1, v2, v3 in adjacent_n_tuples(vertices, 3):- vect1 = v2 - v1- vect2 = v3 - v2- unit_vect1 = normalize(vect1)- unit_vect2 = normalize(vect2)- angle = angle_between_vectors(vect1, vect2)- # Negative radius gives concave curves- angle *= np.sign(radius)- # Distance between vertex and start of the arc- cut_off_length = radius * np.tan(angle / 2)- # Determines counterclockwise vs. clockwise- sign = np.sign(np.cross(vect1, vect2)[2])- arc = ArcBetweenPoints(- v2 - unit_vect1 * cut_off_length,- v2 + unit_vect2 * cut_off_length,- angle=sign * angle,- n_components=2,- )- arcs.append(arc)-- self.clear_points()- # To ensure that we loop through starting with last- arcs = [arcs[-1], *arcs[:-1]]- for arc1, arc2 in adjacent_pairs(arcs):- self.append_points(arc1.get_points())- line = Line(arc1.get_end(), arc2.get_start())- # Make sure anchors are evenly distributed- len_ratio = line.get_length() / arc1.get_arc_length()- line.insert_n_curves(int(arc1.get_num_curves() * len_ratio))- self.append_points(line.get_points())- return selfdiff --git a/manim/mobject/opengl_mobject.py b/manim/mobject/opengl_mobject.pynew file mode 100644index 000000000..159138ce6--- /dev/null+++ b/manim/mobject/opengl_mobject.py@@ -0,0 +1,1633 @@+import copy+import itertools as it+import random+import sys+import moderngl+from functools import wraps+from ..utils.color import *+from ..utils.iterables import listify++import numpy as np++from ..constants import *++from ..utils.color import color_gradient++# from ..utils.color import get_colormap_list+from ..utils.color import rgb_to_hex+from ..utils.color import color_to_rgb++# from ..utils.iterables import batch_by_property+from ..utils.iterables import list_update+from ..utils.iterables import resize_array+from ..utils.iterables import resize_preserving_order+from ..utils.iterables import resize_with_interpolation+from ..utils.iterables import make_even+from ..utils.iterables import listify+from ..utils.bezier import interpolate+from ..utils.paths import straight_path+from ..utils.simple_functions import get_parameters+from ..utils.space_ops import angle_of_vector+from ..utils.space_ops import get_norm+from ..utils.space_ops import rotation_matrix_transpose+++class OpenGLMobject:+ """+ Mathematical Object+ """++ def __init__(+ self,+ color=WHITE,+ opacity=1,+ dim=3, # TODO, get rid of this+ # Lighting parameters+ # Positive gloss up to 1 makes it reflect the light.+ gloss=0.0,+ # Positive shadow up to 1 makes a side opposite the light darker+ shadow=0.0,+ # For shaders+ shader_folder="",+ render_primitive=moderngl.TRIANGLE_STRIP,+ texture_paths=None,+ depth_test=False,+ # If true, the mobject will not get rotated according to camera position+ is_fixed_in_frame=False,+ # Must match in attributes of vert shader+ shader_dtype=[+ ("point", np.float32, (3,)),+ ],+ # Event listener+ listen_to_events=False,+ **kwargs+ ):++ self.color = color+ self.opacity = opacity+ self.dim = dim # TODO, get rid of this+ # Lighting parameters+ # Positive gloss up to 1 makes it reflect the light.+ self.gloss = gloss+ # Positive shadow up to 1 makes a side opposite the light darker+ self.shadow = shadow+ # For shaders+ self.shader_folder = shader_folder+ self.render_primitive = render_primitive+ self.texture_paths = texture_paths+ self.depth_test = depth_test+ # If true, the mobject will not get rotated according to camera position+ self.is_fixed_in_frame = is_fixed_in_frame+ # Must match in attributes of vert shader+ self.shader_dtype = shader_dtype+ # Event listener+ self.listen_to_events = listen_to_events++ self.submobjects = []+ self.parents = []+ self.family = [self]+ self.locked_data_keys = set()+ self.needs_new_bounding_box = True++ self.init_data()+ self.init_uniforms()+ self.init_updaters()+ # self.init_event_listners()+ self.init_points()+ self.init_colors()+ # self.init_shader_data()++ # if self.depth_test:+ # self.apply_depth_test()++ def __str__(self):+ return self.__class__.__name__++ def init_data(self):+ self.data = {+ "points": np.zeros((0, 3)),+ "bounding_box": np.zeros((3, 3)),+ "rgbas": np.zeros((1, 4)),+ }++ def init_uniforms(self):+ self.uniforms = {+ "is_fixed_in_frame": float(self.is_fixed_in_frame),+ "gloss": self.gloss,+ "shadow": self.shadow,+ }++ def init_colors(self):+ self.set_color(self.color, self.opacity)++ def init_points(self):+ # Typically implemented in subclass, unlpess purposefully left blank+ pass++ def set_data(self, data):+ for key in data:+ self.data[key] = data[key].copy()+ return self++ def set_uniforms(self, uniforms):+ for key in uniforms:+ self.uniforms[key] = uniforms[key] # Copy?+ return self++ @property+ def animate(self):+ # Borrowed from https://github.com/ManimCommunity/manim/+ return _AnimationBuilder(self)++ # Only these methods should directly affect points++ def resize_points(self, new_length, resize_func=resize_array):+ if new_length != len(self.data["points"]):+ self.data["points"] = resize_func(self.data["points"], new_length)+ self.refresh_bounding_box()+ return self++ def set_points(self, points):+ if len(points) == len(self.data["points"]):+ self.data["points"][:] = points+ elif isinstance(points, np.ndarray):+ self.data["points"] = points.copy()+ else:+ self.data["points"] = np.array(points)+ self.refresh_bounding_box()+ return self++ def append_points(self, new_points):+ self.data["points"] = np.vstack([self.data["points"], new_points])+ self.refresh_bounding_box()+ return self++ def reverse_points(self):+ for mob in self.get_family():+ for key in mob.data:+ mob.data[key] = mob.data[key][::-1]+ return self++ def apply_points_function(+ self, func, about_point=None, about_edge=ORIGIN, works_on_bounding_box=False+ ):+ if about_point is None and about_edge is not None:+ about_point = self.get_bounding_box_point(about_edge)++ for mob in self.get_family():+ arrs = []+ if mob.has_points():+ arrs.append(mob.get_points())+ if works_on_bounding_box:+ arrs.append(mob.get_bounding_box())++ for arr in arrs:+ if about_point is None:+ arr[:] = func(arr)+ else:+ arr[:] = func(arr - about_point) + about_point++ if not works_on_bounding_box:+ self.refresh_bounding_box(recurse_down=True)+ else:+ for parent in self.parents:+ parent.refresh_bounding_box()+ return self++ # Others related to points++ def match_points(self, mobject):+ self.set_points(mobject.get_points())++ def get_points(self):+ return self.data["points"]++ def clear_points(self):+ self.resize_points(0)++ def get_num_points(self):+ return len(self.data["points"])++ def get_all_points(self):+ if self.submobjects:+ return np.vstack([sm.get_points() for sm in self.get_family()])+ else:+ return self.get_points()++ def has_points(self):+ return self.get_num_points() > 0++ def get_bounding_box(self):+ if self.needs_new_bounding_box:+ self.data["bounding_box"] = self.compute_bounding_box()+ self.needs_new_bounding_box = False+ return self.data["bounding_box"]++ def compute_bounding_box(self):+ all_points = np.vstack(+ [+ self.get_points(),+ *(+ mob.get_bounding_box()+ for mob in self.get_family()[1:]+ if mob.has_points()+ ),+ ]+ )+ if len(all_points) == 0:+ return np.zeros((3, self.dim))+ else:+ # Lower left and upper right corners+ mins = all_points.min(0)+ maxs = all_points.max(0)+ mids = (mins + maxs) / 2+ return np.array([mins, mids, maxs])++ def refresh_bounding_box(self, recurse_down=False, recurse_up=True):+ for mob in self.get_family(recurse_down):+ mob.needs_new_bounding_box = True+ if recurse_up:+ for parent in self.parents:+ parent.refresh_bounding_box()+ return self++ def is_point_touching(self, point, buff=MED_SMALL_BUFF):+ bb = self.get_bounding_box()+ mins = bb[0] - buff+ maxs = bb[2] + buff+ return (point >= mins).all() and (point <= maxs).all()++ # Family matters++ def __getitem__(self, value):+ if isinstance(value, slice):+ GroupClass = self.get_group_class()+ return GroupClass(*self.split().__getitem__(value))+ return self.split().__getitem__(value)++ def __iter__(self):+ return iter(self.split())++ def __len__(self):+ return len(self.split())++ def split(self):+ return self.submobjects++ def assemble_family(self):+ sub_families = (sm.get_family() for sm in self.submobjects)+ self.family = [self, *it.chain(*sub_families)]+ self.refresh_has_updater_status()+ self.refresh_bounding_box()+ for parent in self.parents:+ parent.assemble_family()+ return self++ def get_family(self, recurse=True):+ if recurse:+ return self.family+ else:+ return [self]++ def family_members_with_points(self):+ return [m for m in self.get_family() if m.has_points()]++ def add(self, *mobjects):+ if self in mobjects:+ raise Exception("Mobject cannot contain self")+ for mobject in mobjects:+ if mobject not in self.submobjects:+ self.submobjects.append(mobject)+ if self not in mobject.parents:+ mobject.parents.append(self)+ self.assemble_family()+ return self++ def remove(self, *mobjects):+ for mobject in mobjects:+ if mobject in self.submobjects:+ self.submobjects.remove(mobject)+ if self in mobject.parents:+ mobject.parents.remove(self)+ self.assemble_family()+ return self++ def add_to_back(self, *mobjects):+ self.set_submobjects(list_update(mobjects, self.submobjects))+ return self++ def replace_submobject(self, index, new_submob):+ old_submob = self.submobjects[index]+ if self in old_submob.parents:+ old_submob.parents.remove(self)+ self.submobjects[index] = new_submob+ self.assemble_family()+ return self++ def set_submobjects(self, submobject_list):+ self.remove(*self.submobjects)+ self.add(*submobject_list)+ return self++ def digest_mobject_attrs(self):+ """+ Ensures all attributes which are mobjects are included+ in the submobjects list.+ """+ mobject_attrs = [+ x for x in list(self.__dict__.values()) if isinstance(x, Mobject)+ ]+ self.set_submobjects(list_update(self.submobjects, mobject_attrs))+ return self++ # Submobject organization++ def arrange(self, direction=RIGHT, center=True, **kwargs):+ for m1, m2 in zip(self.submobjects, self.submobjects[1:]):+ m2.next_to(m1, direction, **kwargs)+ if center:+ self.center()+ return self++ def arrange_in_grid(+ self,+ n_rows=None,+ n_cols=None,+ buff=None,+ h_buff=None,+ v_buff=None,+ buff_ratio=None,+ h_buff_ratio=0.5,+ v_buff_ratio=0.5,+ aligned_edge=ORIGIN,+ fill_rows_first=True,+ ):+ submobs = self.submobjects+ if n_rows is None and n_cols is None:+ n_rows = int(np.sqrt(len(submobs)))+ if n_rows is None:+ n_rows = len(submobs) // n_cols+ if n_cols is None:+ n_cols = len(submobs) // n_rows++ if buff is not None:+ h_buff = buff+ v_buff = buff+ else:+ if buff_ratio is not None:+ v_buff_ratio = buff_ratio+ h_buff_ratio = buff_ratio+ if h_buff is None:+ h_buff = h_buff_ratio * self[0].get_width()+ if v_buff is None:+ v_buff = v_buff_ratio * self[0].get_height()++ x_unit = h_buff + max([sm.get_width() for sm in submobs])+ y_unit = v_buff + max([sm.get_height() for sm in submobs])++ for index, sm in enumerate(submobs):+ if fill_rows_first:+ x, y = index % n_cols, index // n_cols+ else:+ x, y = index // n_rows, index % n_rows+ sm.move_to(ORIGIN, aligned_edge)+ sm.shift(x * x_unit * RIGHT + y * y_unit * DOWN)+ self.center()+ return self++ def get_grid(self, n_rows, n_cols, height=None, **kwargs):+ """+ Returns a new mobject containing multiple copies of this one+ arranged in a grid+ """+ grid = self.get_group_class()(*(self.copy() for n in range(n_rows * n_cols)))+ grid.arrange_in_grid(n_rows, n_cols, **kwargs)+ if height is not None:+ grid.set_height(height)+ return grid++ def sort(self, point_to_num_func=lambda p: p[0], submob_func=None):+ if submob_func is not None:+ self.submobjects.sort(key=submob_func)+ else:+ self.submobjects.sort(key=lambda m: point_to_num_func(m.get_center()))+ return self++ def shuffle(self, recurse=False):+ if recurse:+ for submob in self.submobjects:+ submob.shuffle(recurse=True)+ random.shuffle(self.submobjects)+ return self++ # Copying++ def copy(self):+ # TODO, either justify reason for shallow copy, or+ # remove this redundancy everywhere+ # return self.deepcopy()++ parents = self.parents+ self.parents = []+ copy_mobject = copy.copy(self)+ self.parents = parents++ copy_mobject.data = dict(self.data)+ for key in self.data:+ copy_mobject.data[key] = self.data[key].copy()++ # TODO, are uniforms ever numpy arrays?+ copy_mobject.uniforms = dict(self.uniforms)++ copy_mobject.submobjects = []+ copy_mobject.add(*[sm.copy() for sm in self.submobjects])+ copy_mobject.match_updaters(self)++ copy_mobject.needs_new_bounding_box = self.needs_new_bounding_box++ # Make sure any mobject or numpy array attributes are copied+ family = self.get_family()+ for attr, value in list(self.__dict__.items()):+ if isinstance(value, Mobject) and value in family and value is not self:+ setattr(copy_mobject, attr, value.copy())+ if isinstance(value, np.ndarray):+ setattr(copy_mobject, attr, value.copy())+ if isinstance(value, ShaderWrapper):+ setattr(copy_mobject, attr, value.copy())+ return copy_mobject++ def deepcopy(self):+ parents = self.parents+ self.parents = []+ result = copy.deepcopy(self)+ self.parents = parents+ return result++ def generate_target(self, use_deepcopy=False):+ self.target = None # Prevent exponential explosion+ if use_deepcopy:+ self.target = self.deepcopy()+ else:+ self.target = self.copy()+ return self.target++ def save_state(self, use_deepcopy=False):+ if hasattr(self, "saved_state"):+ # Prevent exponential growth of data+ self.saved_state = None+ if use_deepcopy:+ self.saved_state = self.deepcopy()+ else:+ self.saved_state = self.copy()+ return self++ def restore(self):+ if not hasattr(self, "saved_state") or self.save_state is None:+ raise Exception("Trying to restore without having saved")+ self.become(self.saved_state)+ return self++ # Updating++ def init_updaters(self):+ self.time_based_updaters = []+ self.non_time_updaters = []+ self.has_updaters = False+ self.updating_suspended = False++ def update(self, dt=0, recurse=True):+ if not self.has_updaters or self.updating_suspended:+ return self+ for updater in self.time_based_updaters:+ updater(self, dt)+ for updater in self.non_time_updaters:+ updater(self)+ if recurse:+ for submob in self.submobjects:+ submob.update(dt, recurse)+ return self++ def get_time_based_updaters(self):+ return self.time_based_updaters++ def has_time_based_updater(self):+ return len(self.time_based_updaters) > 0++ def get_updaters(self):+ return self.time_based_updaters + self.non_time_updaters++ def get_family_updaters(self):+ return list(it.chain(*[sm.get_updaters() for sm in self.get_family()]))++ def add_updater(self, update_function, index=None, call_updater=True):+ if "dt" in get_parameters(update_function):+ updater_list = self.time_based_updaters+ else:+ updater_list = self.non_time_updaters++ if index is None:+ updater_list.append(update_function)+ else:+ updater_list.insert(index, update_function)++ self.refresh_has_updater_status()+ if call_updater:+ self.update()+ return self++ def remove_updater(self, update_function):+ for updater_list in [self.time_based_updaters, self.non_time_updaters]:+ while update_function in updater_list:+ updater_list.remove(update_function)+ self.refresh_has_updater_status()+ return self++ def clear_updaters(self, recurse=True):+ self.time_based_updaters = []+ self.non_time_updaters = []+ self.refresh_has_updater_status()+ if recurse:+ for submob in self.submobjects:+ submob.clear_updaters()+ return self++ def match_updaters(self, mobject):+ self.clear_updaters()+ for updater in mobject.get_updaters():+ self.add_updater(updater)+ return self++ def suspend_updating(self, recurse=True):+ self.updating_suspended = True+ if recurse:+ for submob in self.submobjects:+ submob.suspend_updating(recurse)+ return self++ def resume_updating(self, recurse=True, call_updater=True):+ self.updating_suspended = False+ if recurse:+ for submob in self.submobjects:+ submob.resume_updating(recurse)+ for parent in self.parents:+ parent.resume_updating(recurse=False, call_updater=False)+ if call_updater:+ self.update(dt=0, recurse=recurse)+ return self++ def refresh_has_updater_status(self):+ self.has_updaters = any(mob.get_updaters() for mob in self.get_family())+ return self++ # Transforming operations++ def shift(self, vector):+ self.apply_points_function(+ lambda points: points + vector,+ about_edge=None,+ works_on_bounding_box=True,+ )+ return self++ def scale(self, scale_factor, **kwargs):+ """+ Default behavior is to scale about the center of the mobject.+ The argument about_edge can be a vector, indicating which side of+ the mobject to scale about, e.g., mob.scale(about_edge = RIGHT)+ scales about mob.get_right().++ Otherwise, if about_point is given a value, scaling is done with+ respect to that point.+ """+ self.apply_points_function(+ lambda points: scale_factor * points, works_on_bounding_box=True, **kwargs+ )+ return self++ def stretch(self, factor, dim, **kwargs):+ def func(points):+ points[:, dim] *= factor+ return points++ self.apply_points_function(func, works_on_bounding_box=True, **kwargs)+ return self++ def rotate_about_origin(self, angle, axis=OUT):+ return self.rotate(angle, axis, about_point=ORIGIN)++ def rotate(self, angle, axis=OUT, **kwargs):+ rot_matrix_T = rotation_matrix_transpose(angle, axis)+ self.apply_points_function(+ lambda points: np.dot(points, rot_matrix_T), **kwargs+ )+ return self++ def flip(self, axis=UP, **kwargs):+ return self.rotate(TAU / 2, axis, **kwargs)++ def apply_function(self, function, **kwargs):+ # Default to applying matrix about the origin, not mobjects center+ if len(kwargs) == 0:+ kwargs["about_point"] = ORIGIN+ self.apply_points_function(+ lambda points: np.array([function(p) for p in points]), **kwargs+ )+ return self++ def apply_function_to_position(self, function):+ self.move_to(function(self.get_center()))+ return self++ def apply_function_to_submobject_positions(self, function):+ for submob in self.submobjects:+ submob.apply_function_to_position(function)+ return self++ def apply_matrix(self, matrix, **kwargs):+ # Default to applying matrix about the origin, not mobjects center+ if ("about_point" not in kwargs) and ("about_edge" not in kwargs):+ kwargs["about_point"] = ORIGIN+ full_matrix = np.identity(self.dim)+ matrix = np.array(matrix)+ full_matrix[: matrix.shape[0], : matrix.shape[1]] = matrix+ self.apply_points_function(+ lambda points: np.dot(points, full_matrix.T), **kwargs+ )+ return self++ def apply_complex_function(self, function, **kwargs):+ def R3_func(point):+ x, y, z = point+ xy_complex = function(complex(x, y))+ return [xy_complex.real, xy_complex.imag, z]++ return self.apply_function(R3_func)++ def wag(self, direction=RIGHT, axis=DOWN, wag_factor=1.0):+ for mob in self.family_members_with_points():+ alphas = np.dot(mob.get_points(), np.transpose(axis))+ alphas -= min(alphas)+ alphas /= max(alphas)+ alphas = alphas ** wag_factor+ mob.set_points(+ mob.get_points()+ + np.dot(+ alphas.reshape((len(alphas), 1)),+ np.array(direction).reshape((1, mob.dim)),+ )+ )+ return self++ # Positioning methods++ def center(self):+ self.shift(-self.get_center())+ return self++ def align_on_border(self, direction, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):+ """+ Direction just needs to be a vector pointing towards side or+ corner in the 2d plane.+ """+ target_point = np.sign(direction) * (FRAME_X_RADIUS, FRAME_Y_RADIUS, 0)+ point_to_align = self.get_bounding_box_point(direction)+ shift_val = target_point - point_to_align - buff * np.array(direction)+ shift_val = shift_val * abs(np.sign(direction))+ self.shift(shift_val)+ return self++ def to_corner(self, corner=LEFT + DOWN, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):+ return self.align_on_border(corner, buff)++ def to_edge(self, edge=LEFT, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):+ return self.align_on_border(edge, buff)++ def next_to(+ self,+ mobject_or_point,+ direction=RIGHT,+ buff=DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,+ aligned_edge=ORIGIN,+ submobject_to_align=None,+ index_of_submobject_to_align=None,+ coor_mask=np.array([1, 1, 1]),+ ):+ if isinstance(mobject_or_point, Mobject):+ mob = mobject_or_point+ if index_of_submobject_to_align is not None:+ target_aligner = mob[index_of_submobject_to_align]+ else:+ target_aligner = mob+ target_point = target_aligner.get_bounding_box_point(+ aligned_edge + direction+ )+ else:+ target_point = mobject_or_point+ if submobject_to_align is not None:+ aligner = submobject_to_align+ elif index_of_submobject_to_align is not None:+ aligner = self[index_of_submobject_to_align]+ else:+ aligner = self+ point_to_align = aligner.get_bounding_box_point(aligned_edge - direction)+ self.shift((target_point - point_to_align + buff * direction) * coor_mask)+ return self++ def shift_onto_screen(self, **kwargs):+ space_lengths = [FRAME_X_RADIUS, FRAME_Y_RADIUS]+ for vect in UP, DOWN, LEFT, RIGHT:+ dim = np.argmax(np.abs(vect))+ buff = kwargs.get("buff", DEFAULT_MOBJECT_TO_EDGE_BUFFER)+ max_val = space_lengths[dim] - buff+ edge_center = self.get_edge_center(vect)+ if np.dot(edge_center, vect) > max_val:+ self.to_edge(vect, **kwargs)+ return self++ def is_off_screen(self):+ if self.get_left()[0] > FRAME_X_RADIUS:+ return True+ if self.get_right()[0] < -FRAME_X_RADIUS:+ return True+ if self.get_bottom()[1] > FRAME_Y_RADIUS:+ return True+ if self.get_top()[1] < -FRAME_Y_RADIUS:+ return True+ return False++ def stretch_about_point(self, factor, dim, point):+ return self.stretch(factor, dim, about_point=point)++ def stretch_in_place(self, factor, dim):+ # Now redundant with stretch+ return self.stretch(factor, dim)++ def rescale_to_fit(self, length, dim, stretch=False, **kwargs):+ old_length = self.length_over_dim(dim)+ if old_length == 0:+ return self+ if stretch:+ self.stretch(length / old_length, dim, **kwargs)+ else:+ self.scale(length / old_length, **kwargs)+ return self++ def stretch_to_fit_width(self, width, **kwargs):+ return self.rescale_to_fit(width, 0, stretch=True, **kwargs)++ def stretch_to_fit_height(self, height, **kwargs):+ return self.rescale_to_fit(height, 1, stretch=True, **kwargs)++ def stretch_to_fit_depth(self, depth, **kwargs):+ return self.rescale_to_fit(depth, 1, stretch=True, **kwargs)++ def set_width(self, width, stretch=False, **kwargs):+ return self.rescale_to_fit(width, 0, stretch=stretch, **kwargs)++ def set_height(self, height, stretch=False, **kwargs):+ return self.rescale_to_fit(height, 1, stretch=stretch, **kwargs)++ def set_depth(self, depth, stretch=False, **kwargs):+ return self.rescale_to_fit(depth, 2, stretch=stretch, **kwargs)++ def set_coord(self, value, dim, direction=ORIGIN):+ curr = self.get_coord(dim, direction)+ shift_vect = np.zeros(self.dim)+ shift_vect[dim] = value - curr+ self.shift(shift_vect)+ return self++ def set_x(self, x, direction=ORIGIN):+ return self.set_coord(x, 0, direction)++ def set_y(self, y, direction=ORIGIN):+ return self.set_coord(y, 1, direction)++ def set_z(self, z, direction=ORIGIN):+ return self.set_coord(z, 2, direction)++ def space_out_submobjects(self, factor=1.5, **kwargs):+ self.scale(factor, **kwargs)+ for submob in self.submobjects:+ submob.scale(1.0 / factor)+ return self++ def move_to(+ self, point_or_mobject, aligned_edge=ORIGIN, coor_mask=np.array([1, 1, 1])+ ):+ if isinstance(point_or_mobject, Mobject):+ target = point_or_mobject.get_bounding_box_point(aligned_edge)+ else:+ target = point_or_mobject+ point_to_align = self.get_bounding_box_point(aligned_edge)+ self.shift((target - point_to_align) * coor_mask)+ return self++ def replace(self, mobject, dim_to_match=0, stretch=False):+ if not mobject.get_num_points() and not mobject.submobjects:+ self.scale(0)+ return self+ if stretch:+ for i in range(self.dim):+ self.rescale_to_fit(mobject.length_over_dim(i), i, stretch=True)+ else:+ self.rescale_to_fit(+ mobject.length_over_dim(dim_to_match), dim_to_match, stretch=False+ )+ self.shift(mobject.get_center() - self.get_center())+ return self++ def surround(self, mobject, dim_to_match=0, stretch=False, buff=MED_SMALL_BUFF):+ self.replace(mobject, dim_to_match, stretch)+ length = mobject.length_over_dim(dim_to_match)+ self.scale((length + buff) / length)+ return self++ def put_start_and_end_on(self, start, end):+ # TODO, this doesn't currently work in 3d+ curr_start, curr_end = self.get_start_and_end()+ curr_vect = curr_end - curr_start+ if np.all(curr_vect == 0):+ raise Exception("Cannot position endpoints of closed loop")+ target_vect = end - start+ self.scale(+ get_norm(target_vect) / get_norm(curr_vect),+ about_point=curr_start,+ )+ self.rotate(+ angle_of_vector(target_vect) - angle_of_vector(curr_vect),+ about_point=curr_start,+ )+ self.shift(start - curr_start)+ return self++ # Color functions++ def set_rgba_array(self, color=None, opacity=None, name="rgbas", recurse=True):+ if color is not None:+ rgbs = np.array([color_to_rgb(c) for c in listify(color)])+ if opacity is not None:+ opacities = listify(opacity)++ # Color only+ if color is not None and opacity is None:+ for mob in self.get_family(recurse):+ mob.data[name] = resize_array(mob.data[name], len(rgbs))+ mob.data[name][:, :3] = rgbs++ # Opacity only+ if color is None and opacity is not None:+ for mob in self.get_family(recurse):+ mob.data[name] = resize_array(mob.data[name], len(opacities))+ mob.data[name][:, 3] = opacities++ # Color and opacity+ if color is not None and opacity is not None:+ rgbas = np.array([[*rgb, o] for rgb, o in zip(*make_even(rgbs, opacities))])+ for mob in self.get_family(recurse):+ mob.data[name] = rgbas.copy()+ return self++ def set_color(self, color, opacity=None, recurse=True):+ self.set_rgba_array(color, opacity, recurse=False)+ # Recurse to submobjects differently from how set_rgba_array+ # in case they implement set_color differently+ if recurse:+ for submob in self.submobjects:+ submob.set_color(color, recurse=True)+ return self++ def set_opacity(self, opacity, recurse=True):+ self.set_rgba_array(color=None, opacity=opacity, recurse=False)+ if recurse:+ for submob in self.submobjects:+ submob.set_opacity(opacity, recurse=True)+ return self++ def get_color(self):+ return rgb_to_hex(self.data["rgbas"][0, :3])++ def get_opacity(self):+ return self.data["rgbas"][0, 3]++ def set_color_by_gradient(self, *colors):+ self.set_submobject_colors_by_gradient(*colors)+ return self++ def set_submobject_colors_by_gradient(self, *colors):+ if len(colors) == 0:+ raise Exception("Need at least one color")+ elif len(colors) == 1:+ return self.set_color(*colors)++ # mobs = self.family_members_with_points()+ mobs = self.submobjects+ new_colors = color_gradient(colors, len(mobs))++ for mob, color in zip(mobs, new_colors):+ mob.set_color(color)+ return self++ def fade(self, darkness=0.5, recurse=True):+ self.set_opacity(1.0 - darkness, recurse=recurse)++ def get_gloss(self):+ return self.uniforms["gloss"]++ def set_gloss(self, gloss, recurse=True):+ for mob in self.get_family(recurse):+ mob.uniforms["gloss"] = gloss+ return self++ def get_shadow(self):+ return self.uniforms["shadow"]++ def set_shadow(self, shadow, recurse=True):+ for mob in self.get_family(recurse):+ mob.uniforms["shadow"] = shadow+ return self++ # Background rectangle++ def add_background_rectangle(self, color=None, opacity=0.75, **kwargs):+ # TODO, this does not behave well when the mobject has points,+ # since it gets displayed on top+ from manimlib.mobject.shape_matchers import BackgroundRectangle++ self.background_rectangle = BackgroundRectangle(+ self, color=color, fill_opacity=opacity, **kwargs+ )+ self.add_to_back(self.background_rectangle)+ return self++ def add_background_rectangle_to_submobjects(self, **kwargs):+ for submobject in self.submobjects:+ submobject.add_background_rectangle(**kwargs)+ return self++ def add_background_rectangle_to_family_members_with_points(self, **kwargs):+ for mob in self.family_members_with_points():+ mob.add_background_rectangle(**kwargs)+ return self++ # Getters++ def get_bounding_box_point(self, direction):+ bb = self.get_bounding_box()+ indices = (np.sign(direction) + 1).astype(int)+ return np.array([bb[indices[i]][i] for i in range(3)])++ def get_edge_center(self, direction):+ return self.get_bounding_box_point(direction)++ def get_corner(self, direction):+ return self.get_bounding_box_point(direction)++ def get_center(self):+ return self.get_bounding_box()[1]++ def get_center_of_mass(self):+ return self.get_all_points().mean(0)++ def get_boundary_point(self, direction):+ all_points = self.get_all_points()+ boundary_directions = all_points - self.get_center()+ norms = np.linalg.norm(boundary_directions, axis=1)+ boundary_directions /= np.repeat(norms, 3).reshape((len(norms), 3))+ index = np.argmax(np.dot(boundary_directions, np.array(direction).T))+ return all_points[index]++ def get_continuous_bounding_box_point(self, direction):+ dl, center, ur = self.get_bounding_box()+ corner_vect = ur - center+ return center + direction / np.max(+ np.abs(+ np.true_divide(+ direction,+ corner_vect,+ out=np.zeros(len(direction)),+ where=((corner_vect) != 0),+ )+ )+ )++ def get_top(self):+ return self.get_edge_center(UP)++ def get_bottom(self):+ return self.get_edge_center(DOWN)++ def get_right(self):+ return self.get_edge_center(RIGHT)++ def get_left(self):+ return self.get_edge_center(LEFT)++ def get_zenith(self):+ return self.get_edge_center(OUT)++ def get_nadir(self):+ return self.get_edge_center(IN)++ def length_over_dim(self, dim):+ bb = self.get_bounding_box()+ return abs((bb[2] - bb[0])[dim])++ def get_width(self):+ return self.length_over_dim(0)++ def get_height(self):+ return self.length_over_dim(1)++ def get_depth(self):+ return self.length_over_dim(2)++ def get_coord(self, dim, direction=ORIGIN):+ """+ Meant to generalize get_x, get_y, get_z+ """+ return self.get_bounding_box_point(direction)[dim]++ def get_x(self, direction=ORIGIN):+ return self.get_coord(0, direction)++ def get_y(self, direction=ORIGIN):+ return self.get_coord(1, direction)++ def get_z(self, direction=ORIGIN):+ return self.get_coord(2, direction)++ def get_start(self):+ self.throw_error_if_no_points()+ return np.array(self.get_points()[0])++ def get_end(self):+ self.throw_error_if_no_points()+ return np.array(self.get_points()[-1])++ def get_start_and_end(self):+ return self.get_start(), self.get_end()++ def point_from_proportion(self, alpha):+ points = self.get_points()+ i, subalpha = integer_interpolate(0, len(points) - 1, alpha)+ return interpolate(points[i], points[i + 1], subalpha)++ def pfp(self, alpha):+ """Abbreviation fo point_from_proportion"""+ return self.point_from_proportion(alpha)++ def get_pieces(self, n_pieces):+ template = self.copy()+ template.set_submobjects([])+ alphas = np.linspace(0, 1, n_pieces + 1)+ return Group(+ *[+ template.copy().pointwise_become_partial(self, a1, a2)+ for a1, a2 in zip(alphas[:-1], alphas[1:])+ ]+ )++ def get_z_index_reference_point(self):+ # TODO, better place to define default z_index_group?+ z_index_group = getattr(self, "z_index_group", self)+ return z_index_group.get_center()++ # Match other mobject properties++ def match_color(self, mobject):+ return self.set_color(mobject.get_color())++ def match_dim_size(self, mobject, dim, **kwargs):+ return self.rescale_to_fit(mobject.length_over_dim(dim), dim, **kwargs)++ def match_width(self, mobject, **kwargs):+ return self.match_dim_size(mobject, 0, **kwargs)++ def match_height(self, mobject, **kwargs):+ return self.match_dim_size(mobject, 1, **kwargs)++ 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_x(self, mobject, direction=ORIGIN):+ return self.match_coord(mobject, 0, direction)++ def match_y(self, mobject, direction=ORIGIN):+ return self.match_coord(mobject, 1, direction)++ def match_z(self, mobject, direction=ORIGIN):+ return self.match_coord(mobject, 2, direction)++ def align_to(self, mobject_or_point, direction=ORIGIN):+ """+ Examples:+ mob1.align_to(mob2, UP) moves mob1 vertically so that its+ top edge lines ups with mob2's top edge.++ mob1.align_to(mob2, alignment_vect = RIGHT) moves mob1+ horizontally so that it's center is directly above/below+ the center of mob2+ """+ if isinstance(mobject_or_point, Mobject):+ point = mobject_or_point.get_bounding_box_point(direction)+ else:+ point = mobject_or_point++ for dim in range(self.dim):+ if direction[dim] != 0:+ self.set_coord(point[dim], dim, direction)+ return self++ def get_group_class(self):+ return Group++ # Alignment++ def align_data_and_family(self, mobject):+ self.align_family(mobject)+ self.align_data(mobject)++ def align_data(self, mobject):+ # In case any data arrays get resized when aligned to shader data+ self.refresh_shader_data()+ for mob1, mob2 in zip(self.get_family(), mobject.get_family()):+ # Separate out how points are treated so that subclasses+ # can handle that case differently if they choose+ mob1.align_points(mob2)+ for key in mob1.data.keys() & mob2.data.keys():+ if key == "points":+ continue+ arr1 = mob1.data[key]+ arr2 = mob2.data[key]+ if len(arr2) > len(arr1):+ mob1.data[key] = resize_preserving_order(arr1, len(arr2))+ elif len(arr1) > len(arr2):+ mob2.data[key] = resize_preserving_order(arr2, len(arr1))++ def align_points(self, mobject):+ max_len = max(self.get_num_points(), mobject.get_num_points())+ for mob in (self, mobject):+ mob.resize_points(max_len, resize_func=resize_preserving_order)+ return self++ def align_family(self, mobject):+ mob1 = self+ mob2 = mobject+ n1 = len(mob1)+ n2 = len(mob2)+ if n1 != n2:+ mob1.add_n_more_submobjects(max(0, n2 - n1))+ mob2.add_n_more_submobjects(max(0, n1 - n2))+ # Recurse+ for sm1, sm2 in zip(mob1.submobjects, mob2.submobjects):+ sm1.align_family(sm2)+ return self++ def push_self_into_submobjects(self):+ copy = self.deepcopy()+ copy.set_submobjects([])+ self.resize_points(0)+ self.add(copy)+ return self++ def add_n_more_submobjects(self, n):+ if n == 0:+ return self++ curr = len(self.submobjects)+ if curr == 0:+ # If empty, simply add n point mobjects+ null_mob = self.copy()+ null_mob.set_points([self.get_center()])+ self.set_submobjects([null_mob.copy() for k in range(n)])+ return self+ target = curr + n+ repeat_indices = (np.arange(target) * curr) // target+ split_factors = [(repeat_indices == i).sum() for i in range(curr)]+ new_submobs = []+ for submob, sf in zip(self.submobjects, split_factors):+ new_submobs.append(submob)+ for k in range(1, sf):+ new_submob = submob.copy()+ # If the submobject is at all transparent, then+ # make the copy completely transparent+ if submob.get_opacity() < 1:+ new_submob.set_opacity(0)+ new_submobs.append(new_submob)+ self.set_submobjects(new_submobs)+ return self++ # Interpolate++ def interpolate(self, mobject1, mobject2, alpha, path_func=straight_path):+ for key in self.data:+ if key in self.locked_data_keys:+ continue+ if len(self.data[key]) == 0:+ continue+ if key not in mobject1.data or key not in mobject2.data:+ continue++ if key in ("points", "bounding_box"):+ func = path_func+ else:+ func = interpolate++ self.data[key][:] = func(mobject1.data[key], mobject2.data[key], alpha)+ for key in self.uniforms:+ self.uniforms[key] = interpolate(+ mobject1.uniforms[key], mobject2.uniforms[key], alpha+ )+ return self++ def pointwise_become_partial(self, mobject, a, b):+ """+ Set points in such a way as to become only+ part of mobject.+ Inputs 0 <= a < b <= 1 determine what portion+ of mobject to become.+ """+ pass # To implement in subclass++ def become(self, mobject):+ """+ Edit all data and submobjects to be idential+ to another mobject+ """+ self.align_family(mobject)+ for sm1, sm2 in zip(self.get_family(), mobject.get_family()):+ sm1.set_data(sm2.data)+ sm1.set_uniforms(sm2.uniforms)+ self.refresh_bounding_box(recurse_down=True)+ return self++ # Locking data++ def lock_data(self, keys):+ """+ To speed up some animations, particularly transformations,+ it can be handy to acknowledge which pieces of data+ won't change during the animation so that calls to+ interpolate can skip this, and so that it's not+ read into the shader_wrapper objects needlessly+ """+ if self.has_updaters:+ return+ # Be sure shader data has most up to date information+ self.refresh_shader_data()+ self.locked_data_keys = set(keys)++ def lock_matching_data(self, mobject1, mobject2):+ for sm, sm1, sm2 in zip(+ self.get_family(), mobject1.get_family(), mobject2.get_family()+ ):+ keys = sm.data.keys() & sm1.data.keys() & sm2.data.keys()+ sm.lock_data(+ list(+ filter(+ lambda key: np.all(sm1.data[key] == sm2.data[key]),+ keys,+ )+ )+ )+ return self++ def unlock_data(self):+ for mob in self.get_family():+ mob.locked_data_keys = set()++ # Operations touching shader uniforms++ def affects_shader_info_id(func):+ @wraps(func)+ def wrapper(self):+ for mob in self.get_family():+ func(mob)+ mob.refresh_shader_wrapper_id()+ return self++ return wrapper++ @affects_shader_info_id+ def fix_in_frame(self):+ self.uniforms["is_fixed_in_frame"] = 1.0+ return self++ @affects_shader_info_id+ def unfix_from_frame(self):+ self.uniforms["is_fixed_in_frame"] = 0.0+ return self++ @affects_shader_info_id+ def apply_depth_test(self):+ self.depth_test = True+ return self++ @affects_shader_info_id+ def deactivate_depth_test(self):+ self.depth_test = False+ return self++ # Shader code manipulation++ def replace_shader_code(self, old, new):+ # TODO, will this work with VMobject structure, given+ # that it does not simpler return shader_wrappers of+ # family?+ for wrapper in self.get_shader_wrapper_list():+ wrapper.replace_code(old, new)+ return self++ def set_color_by_code(self, glsl_code):+ """+ Takes a snippet of code and inserts it into a+ context which has the following variables:+ vec4 color, vec3 point, vec3 unit_normal.+ The code should change the color variable+ """+ self.replace_shader_code("///// INSERT COLOR FUNCTION HERE /////", glsl_code)+ return self++ def set_color_by_xyz_func(+ self, glsl_snippet, min_value=-5.0, max_value=5.0, colormap="viridis"+ ):+ """+ Pass in a glsl expression in terms of x, y and z which returns+ a float.+ """+ # TODO, add a version of this which changes the point data instead+ # of the shader code+ for char in "xyz":+ glsl_snippet = glsl_snippet.replace(char, "point." + char)+ rgb_list = get_colormap_list(colormap)+ self.set_color_by_code(+ "color.rgb = float_to_color({}, {}, {}, {});".format(+ glsl_snippet,+ float(min_value),+ float(max_value),+ get_colormap_code(rgb_list),+ )+ )+ return self++ # For shader data++ def init_shader_data(self):+ # TODO, only call this when needed?+ self.shader_data = np.zeros(len(self.get_points()), dtype=self.shader_dtype)+ self.shader_indices = None+ self.shader_wrapper = ShaderWrapper(+ vert_data=self.shader_data,+ shader_folder=self.shader_folder,+ texture_paths=self.texture_paths,+ depth_test=self.depth_test,+ render_primitive=self.render_primitive,+ )++ def refresh_shader_wrapper_id(self):+ self.shader_wrapper.refresh_id()+ return self++ def get_shader_wrapper(self):+ self.shader_wrapper.vert_data = self.get_shader_data()+ self.shader_wrapper.vert_indices = self.get_shader_vert_indices()+ self.shader_wrapper.uniforms = self.get_shader_uniforms()+ self.shader_wrapper.depth_test = self.depth_test+ return self.shader_wrapper++ def get_shader_wrapper_list(self):+ shader_wrappers = it.chain(+ [self.get_shader_wrapper()],+ *[sm.get_shader_wrapper_list() for sm in self.submobjects]+ )+ batches = batch_by_property(shader_wrappers, lambda sw: sw.get_id())++ result = []+ for wrapper_group, sid in batches:+ shader_wrapper = wrapper_group[0]+ if not shader_wrapper.is_valid():+ continue+ shader_wrapper.combine_with(*wrapper_group[1:])+ if len(shader_wrapper.vert_data) > 0:+ result.append(shader_wrapper)+ return result++ def check_data_alignment(self, array, data_key):+ # Makes sure that self.data[key] can be brodcast into+ # the given array, meaning its length has to be either 1+ # or the length of the array+ d_len = len(self.data[data_key])+ if d_len != 1 and d_len != len(array):+ self.data[data_key] = resize_with_interpolation(+ self.data[data_key], len(array)+ )+ return self++ def get_resized_shader_data_array(self, length):+ # If possible, try to populate an existing array, rather+ # than recreating it each frame+ if len(self.shader_data) != length:+ self.shader_data = resize_array(self.shader_data, length)+ return self.shader_data++ def read_data_to_shader(self, shader_data, shader_data_key, data_key):+ if data_key in self.locked_data_keys:+ return+ self.check_data_alignment(shader_data, data_key)+ shader_data[shader_data_key] = self.data[data_key]++ def get_shader_data(self):+ shader_data = self.get_resized_shader_data_array(self.get_num_points())+ self.read_data_to_shader(shader_data, "point", "points")+ return shader_data++ def refresh_shader_data(self):+ self.get_shader_data()++ def get_shader_uniforms(self):+ return self.uniforms++ def get_shader_vert_indices(self):+ return self.shader_indices++ # Event Handlers+ """+ Event handling follows the Event Bubbling model of DOM in javascript.+ Return false to stop the event bubbling.+ To learn more visit https://www.quirksmode.org/js/events_order.html++ Event Callback Argument is a callable function taking two arguments:+ 1. Mobject+ 2. EventData+ """++ def init_event_listners(self):+ self.event_listners = []++ def add_event_listner(self, event_type, event_callback):+ event_listner = EventListner(self, event_type, event_callback)+ self.event_listners.append(event_listner)+ EVENT_DISPATCHER.add_listner(event_listner)+ return self++ def remove_event_listner(self, event_type, event_callback):+ event_listner = EventListner(self, event_type, event_callback)+ while event_listner in self.event_listners:+ self.event_listners.remove(event_listner)+ EVENT_DISPATCHER.remove_listner(event_listner)+ return self++ def clear_event_listners(self, recurse=True):+ self.event_listners = []+ if recurse:+ for submob in self.submobjects:+ submob.clear_event_listners(recurse=recurse)+ return self++ def get_event_listners(self):+ return self.event_listners++ def get_family_event_listners(self):+ return list(it.chain(*[sm.get_event_listners() for sm in self.get_family()]))++ def get_has_event_listner(self):+ return any(mob.get_event_listners() for mob in self.get_family())++ def add_mouse_motion_listner(self, callback):+ self.add_event_listner(EventType.MouseMotionEvent, callback)++ def remove_mouse_motion_listner(self, callback):+ self.remove_event_listner(EventType.MouseMotionEvent, callback)++ def add_mouse_press_listner(self, callback):+ self.add_event_listner(EventType.MousePressEvent, callback)++ def remove_mouse_press_listner(self, callback):+ self.remove_event_listner(EventType.MousePressEvent, callback)++ def add_mouse_release_listner(self, callback):+ self.add_event_listner(EventType.MouseReleaseEvent, callback)++ def remove_mouse_release_listner(self, callback):+ self.remove_event_listner(EventType.MouseReleaseEvent, callback)++ def add_mouse_drag_listner(self, callback):+ self.add_event_listner(EventType.MouseDragEvent, callback)++ def remove_mouse_drag_listner(self, callback):+ self.remove_event_listner(EventType.MouseDragEvent, callback)++ def add_mouse_scroll_listner(self, callback):+ self.add_event_listner(EventType.MouseScrollEvent, callback)++ def remove_mouse_scroll_listner(self, callback):+ self.remove_event_listner(EventType.MouseScrollEvent, callback)++ def add_key_press_listner(self, callback):+ self.add_event_listner(EventType.KeyPressEvent, callback)++ def remove_key_press_listner(self, callback):+ self.remove_event_listner(EventType.KeyPressEvent, callback)++ def add_key_release_listner(self, callback):+ self.add_event_listner(EventType.KeyReleaseEvent, callback)++ def remove_key_release_listner(self, callback):+ self.remove_event_listner(EventType.KeyReleaseEvent, callback)++ # Errors++ def throw_error_if_no_points(self):+ if not self.has_points():+ message = "Cannot call Mobject.{} " + "for a Mobject with no points"+ caller_name = sys._getframe(1).f_code.co_name+ raise Exception(message.format(caller_name))+++class OpenGLGroup(OpenGLMobject):+ def __init__(self, *mobjects, **kwargs):+ if not all([isinstance(m, OpenGLMobject) for m in mobjects]):+ raise Exception("All submobjects must be of type Mobject")+ OpenGLMobject.__init__(self, **kwargs)+ self.add(*mobjects)+++class OpenGLPoint(OpenGLMobject):+ def __init__(+ self, location=ORIGIN, artificial_width=1e-6, artificial_height=1e-6, **kwargs+ ):+ self.artificial_width = artificial_width+ self.artificial_height = artificial_height+ OpenGLMobject.__init__(self, **kwargs)+ self.set_location(location)++ def get_width(self):+ return self.artificial_width++ def get_height(self):+ return self.artificial_height++ def get_location(self):+ return self.get_points()[0].copy()++ def get_bounding_box_point(self, *args, **kwargs):+ return self.get_location()++ def set_location(self, new_loc):+ self.set_points(np.array(new_loc, ndmin=2, dtype=float))+++class _AnimationBuilder:+ def __init__(self, mobject):+ self.mobject = mobject+ self.overridden_animation = None+ self.mobject.generate_target()+ self.is_chaining = False+ self.methods = []++ def __getattr__(self, method_name):+ method = getattr(self.mobject.target, method_name)+ self.methods.append(method)+ has_overridden_animation = hasattr(method, "_override_animate")++ if (self.is_chaining and has_overridden_animation) or self.overridden_animation:+ raise NotImplementedError(+ "Method chaining is currently not supported for "+ "overridden animations"+ )++ def update_target(*method_args, **method_kwargs):+ if has_overridden_animation:+ self.overridden_animation = method._override_animate(+ self.mobject, *method_args, **method_kwargs+ )+ else:+ method(*method_args, **method_kwargs)+ return self++ self.is_chaining = True+ return update_target++ def build(self):+ from manimlib.animation.transform import _MethodAnimation++ if self.overridden_animation:+ return self.overridden_animation++ return _MethodAnimation(self.mobject, self.methods)+++def override_animate(method):+ def decorator(animation_method):+ method._override_animate = animation_method+ return animation_method++ return decoratordiff --git a/manim/mobject/types/opengl_vectorized_mobject.py b/manim/mobject/types/opengl_vectorized_mobject.pynew file mode 100644index 000000000..e65c5b974--- /dev/null+++ b/manim/mobject/types/opengl_vectorized_mobject.py@@ -0,0 +1,1074 @@+import itertools as it+import operator as op+import moderngl+import numpy as np++from functools import reduce, wraps+from ...mobject.opengl_mobject import OpenGLMobject, OpenGLPoint+from ...constants import *+from ...utils.color import *++# from manimlib.constants import *+# from manimlib.mobject.mobject import Mobject+# from manimlib.mobject.mobject import Point+# from manimlib.utils.bezier import bezier+# from manimlib.utils.bezier import get_smooth_quadratic_bezier_handle_points+# from manimlib.utils.bezier import get_smooth_cubic_bezier_handle_points+# from manimlib.utils.bezier import get_quadratic_approximation_of_cubic+# from manimlib.utils.bezier import interpolate+# from manimlib.utils.bezier import integer_interpolate+# from manimlib.utils.bezier import partial_quadratic_bezier_points+# from manimlib.utils.color import rgb_to_hex+from ...utils.iterables import make_even++# from manimlib.utils.iterables import resize_array+from ...utils.iterables import resize_with_interpolation+from ...utils.iterables import listify++# from manimlib.utils.space_ops import angle_between_vectors+# from manimlib.utils.space_ops import cross2d+# from manimlib.utils.space_ops import earclip_triangulation+# from manimlib.utils.space_ops import get_norm+from ...utils.space_ops import get_unit_normal++# from manimlib.utils.space_ops import z_to_vector+# from manimlib.shader_wrapper import ShaderWrapper+++class OpenGLVMobject(OpenGLMobject):+ def __init__(+ self,+ fill_color=None,+ fill_opacity=0.0,+ stroke_color=None,+ stroke_opacity=1.0,+ stroke_width=DEFAULT_STROKE_WIDTH,+ draw_stroke_behind_fill=False,+ # Indicates that it will not be displayed, but+ # that it should count in parent mobject's path+ pre_function_handle_to_anchor_scale_factor=0.01,+ make_smooth_after_applying_functions=False,+ background_image_file=None,+ # This is within a pixel+ # TODO, do we care about accounting for+ # varying zoom levels?+ tolerance_for_point_equality=1e-8,+ n_points_per_curve=3,+ long_lines=False,+ # For shaders+ stroke_shader_folder="quadratic_bezier_stroke",+ fill_shader_folder="quadratic_bezier_fill",+ # Could also be "bevel", "miter", "round"+ joint_type="auto",+ flat_stroke=True,+ render_primitive=moderngl.TRIANGLES,+ triangulation_locked=False,+ **kwargs+ ):+ self.fill_color = fill_color+ self.fill_opacity = fill_opacity+ self.stroke_color = stroke_color+ self.stroke_opacity = stroke_opacity+ self.stroke_width = stroke_width+ self.draw_stroke_behind_fill = draw_stroke_behind_fill+ # Indicates that it will not be displayed, but+ # that it should count in parent mobject's path+ self.pre_function_handle_to_anchor_scale_factor = (+ pre_function_handle_to_anchor_scale_factor+ )+ self.make_smooth_after_applying_functions = make_smooth_after_applying_functions+ self.background_image_file = background_image_file+ # This is within a pixel+ # TODO, do we care about accounting for+ # varying zoom levels?+ self.tolerance_for_point_equality = tolerance_for_point_equality+ self.n_points_per_curve = n_points_per_curve+ self.long_lines = long_lines+ # For shaders+ self.stroke_shader_folder = stroke_shader_folder+ self.fill_shader_folder = fill_shader_folder+ # Could also be "bevel", "miter", "round"+ self.joint_type = joint_type+ self.flat_stroke = flat_stroke+ self.render_primitive = render_primitive+ self.triangulation_locked = triangulation_locked++ self.needs_new_triangulation = True+ self.triangulation = np.zeros(0, dtype="i4")+ super().__init__(**kwargs)+ self.refresh_unit_normal()++ #+ # def get_group_class(self):+ # return VGroup+ #++ def init_data(self):+ super().init_data()+ self.data.pop("rgbas")+ self.data.update(+ {+ "fill_rgba": np.zeros((1, 4)),+ "stroke_rgba": np.zeros((1, 4)),+ "stroke_width": np.zeros((1, 1)),+ "unit_normal": np.zeros((1, 3)),+ }+ )++ # Colors+ def init_colors(self):+ self.set_fill(+ color=self.fill_color or self.color,+ opacity=self.fill_opacity,+ )+ self.set_stroke(+ color=self.stroke_color or self.color,+ width=self.stroke_width,+ opacity=self.stroke_opacity,+ background=self.draw_stroke_behind_fill,+ )+ self.set_gloss(self.gloss)+ self.set_flat_stroke(self.flat_stroke)+ return self++ def set_fill(self, color=None, opacity=None, recurse=True):+ self.set_rgba_array(color, opacity, "fill_rgba", recurse)+ return self++ def set_stroke(+ self, color=None, width=None, opacity=None, background=None, recurse=True+ ):+ self.set_rgba_array(color, opacity, "stroke_rgba", recurse)++ if width is not None:+ for mob in self.get_family(recurse):+ mob.data["stroke_width"] = np.array(+ [[width] for width in listify(width)]+ )++ if background is not None:+ for mob in self.get_family(recurse):+ mob.draw_stroke_behind_fill = background+ return self++ def set_style(+ self,+ fill_color=None,+ fill_opacity=None,+ fill_rgba=None,+ stroke_color=None,+ stroke_opacity=None,+ stroke_rgba=None,+ stroke_width=None,+ gloss=None,+ shadow=None,+ recurse=True,+ ):+ if fill_rgba is not None:+ self.data["fill_rgba"] = resize_with_interpolation(+ fill_rgba, len(fill_rgba)+ )+ else:+ self.set_fill(color=fill_color, opacity=fill_opacity, recurse=recurse)++ if stroke_rgba is not None:+ self.data["stroke_rgba"] = resize_with_interpolation(+ stroke_rgba, len(fill_rgba)+ )+ self.set_stroke(width=stroke_width)+ else:+ self.set_stroke(+ color=stroke_color,+ width=stroke_width,+ opacity=stroke_opacity,+ recurse=recurse,+ )++ if gloss is not None:+ self.set_gloss(gloss, recurse=recurse)+ if shadow is not None:+ self.set_shadow(shadow, recurse=recurse)+ return self++ def get_style(self):+ return {+ "fill_rgba": self.data["fill_rgba"],+ "stroke_rgba": self.data["stroke_rgba"],+ "stroke_width": self.data["stroke_width"],+ "gloss": self.get_gloss(),+ "shadow": self.get_shadow(),+ }++ def match_style(self, vmobject, recurse=True):+ self.set_style(**vmobject.get_style(), recurse=False)+ if recurse:+ # Does its best to match up submobject lists, and+ # match styles accordingly+ submobs1, submobs2 = self.submobjects, vmobject.submobjects+ if len(submobs1) == 0:+ return self+ elif len(submobs2) == 0:+ submobs2 = [vmobject]+ for sm1, sm2 in zip(*make_even(submobs1, submobs2)):+ sm1.match_style(sm2)+ return self++ def set_color(self, color, recurse=True):+ self.set_fill(color, recurse=recurse)+ self.set_stroke(color, recurse=recurse)+ return self++ def set_opacity(self, opacity, recurse=True):+ self.set_fill(opacity=opacity, recurse=recurse)+ self.set_stroke(opacity=opacity, recurse=recurse)+ return self++ def fade(self, darkness=0.5, recurse=True):+ factor = 1.0 - darkness+ self.set_fill(+ opacity=factor * self.get_fill_opacity(),+ recurse=False,+ )+ self.set_stroke(+ opacity=factor * self.get_stroke_opacity(),+ recurse=False,+ )+ super().fade(darkness, recurse)+ return self++ def get_fill_colors(self):+ return [rgb_to_hex(rgba[:3]) for rgba in self.data["fill_rgba"]]++ def get_fill_opacities(self):+ return self.data["fill_rgba"][:, 3]++ def get_stroke_colors(self):+ return [rgb_to_hex(rgba[:3]) for rgba in self.data["stroke_rgba"]]++ def get_stroke_opacities(self):+ return self.data["stroke_rgba"][:, 3]++ def get_stroke_widths(self):+ return self.data["stroke_width"]++ # TODO, it's weird for these to return the first of various lists+ # rather than the full information+ def get_fill_color(self):+ """+ If there are multiple colors (for gradient)+ this returns the first one+ """+ return self.get_fill_colors()[0]++ def get_fill_opacity(self):+ """+ If there are multiple opacities, this returns the+ first+ """+ return self.get_fill_opacities()[0]++ def get_stroke_color(self):+ return self.get_stroke_colors()[0]++ def get_stroke_width(self):+ return self.get_stroke_widths()[0]++ def get_stroke_opacity(self):+ return self.get_stroke_opacities()[0]++ def get_color(self):+ if self.has_stroke():+ return self.get_stroke_color()+ return self.get_fill_color()++ def has_stroke(self):+ return any(self.get_stroke_widths()) and any(self.get_stroke_opacities())++ def has_fill(self):+ return any(self.get_fill_opacities())++ def get_opacity(self):+ if self.has_fill():+ return self.get_fill_opacity()+ return self.get_stroke_opacity()++ def set_flat_stroke(self, flat_stroke=True, recurse=True):+ for mob in self.get_family(recurse):+ mob.flat_stroke = flat_stroke+ return self++ def get_flat_stroke(self):+ return self.flat_stroke++ # Points+ def set_anchors_and_handles(self, anchors1, handles, anchors2):+ assert len(anchors1) == len(handles) == len(anchors2)+ nppc = self.n_points_per_curve+ new_points = np.zeros((nppc * len(anchors1), self.dim))+ arrays = [anchors1, handles, anchors2]+ for index, array in enumerate(arrays):+ new_points[index::nppc] = array+ self.set_points(new_points)+ return self++ def start_new_path(self, point):+ assert self.get_num_points() % self.n_points_per_curve == 0+ self.append_points([point])+ return self++ def add_cubic_bezier_curve(self, anchor1, handle1, handle2, anchor2):+ new_points = get_quadratic_approximation_of_cubic(+ anchor1, handle1, handle2, anchor2+ )+ self.append_points(new_points)++ def add_cubic_bezier_curve_to(self, handle1, handle2, anchor):+ """+ Add cubic bezier curve to the path.+ """+ self.throw_error_if_no_points()+ quadratic_approx = get_quadratic_approximation_of_cubic(+ self.get_last_point(), handle1, handle2, anchor+ )+ if self.has_new_path_started():+ self.append_points(quadratic_approx[1:])+ else:+ self.append_points(quadratic_approx)++ def add_quadratic_bezier_curve_to(self, handle, anchor):+ self.throw_error_if_no_points()+ if self.has_new_path_started():+ self.append_points([handle, anchor])+ else:+ self.append_points([self.get_last_point(), handle, anchor])++ def add_line_to(self, point):+ end = self.get_points()[-1]+ alphas = np.linspace(0, 1, self.n_points_per_curve)+ if self.long_lines:+ halfway = interpolate(end, point, 0.5)+ points = [interpolate(end, halfway, a) for a in alphas] + [+ interpolate(halfway, point, a) for a in alphas+ ]+ else:+ points = [interpolate(end, point, a) for a in alphas]+ if self.has_new_path_started():+ points = points[1:]+ self.append_points(points)+ return self++ def add_smooth_curve_to(self, point):+ if self.has_new_path_started():+ self.add_line_to(point)+ else:+ self.throw_error_if_no_points()+ new_handle = self.get_reflection_of_last_handle()+ self.add_quadratic_bezier_curve_to(new_handle, point)+ return self++ def add_smooth_cubic_curve_to(self, handle, point):+ self.throw_error_if_no_points()+ new_handle = self.get_reflection_of_last_handle()+ self.add_cubic_bezier_curve_to(new_handle, handle, point)++ def has_new_path_started(self):+ return self.get_num_points() % self.n_points_per_curve == 1++ def get_last_point(self):+ return self.get_points()[-1]++ def get_reflection_of_last_handle(self):+ points = self.get_points()+ return 2 * points[-1] - points[-2]++ def close_path(self):+ if not self.is_closed():+ self.add_line_to(self.get_subpaths()[-1][0])++ def is_closed(self):+ return self.consider_points_equals(self.get_points()[0], self.get_points()[-1])++ def subdivide_sharp_curves(self, angle_threshold=30 * DEGREES, recurse=True):+ vmobs = [vm for vm in self.get_family(recurse) if vm.has_points()]+ for vmob in vmobs:+ new_points = []+ for tup in vmob.get_bezier_tuples():+ angle = angle_between_vectors(tup[1] - tup[0], tup[2] - tup[1])+ if angle > angle_threshold:+ n = int(np.ceil(angle / angle_threshold))+ alphas = np.linspace(0, 1, n + 1)+ new_points.extend(+ [+ partial_quadratic_bezier_points(tup, a1, a2)+ for a1, a2 in zip(alphas, alphas[1:])+ ]+ )+ else:+ new_points.append(tup)+ vmob.set_points(np.vstack(new_points))+ return self++ def add_points_as_corners(self, points):+ for point in points:+ self.add_line_to(point)+ return points++ def set_points_as_corners(self, points):+ nppc = self.n_points_per_curve+ points = np.array(points)+ self.set_anchors_and_handles(+ *[interpolate(points[:-1], points[1:], a) for a in np.linspace(0, 1, nppc)]+ )+ return self++ def set_points_smoothly(self, points, true_smooth=False):+ self.set_points_as_corners(points)+ self.make_smooth()+ return self++ def change_anchor_mode(self, mode):+ assert mode in ("jagged", "approx_smooth", "true_smooth")+ nppc = self.n_points_per_curve+ for submob in self.family_members_with_points():+ subpaths = submob.get_subpaths()+ submob.clear_points()+ for subpath in subpaths:+ anchors = np.vstack([subpath[::nppc], subpath[-1:]])+ new_subpath = np.array(subpath)+ if mode == "approx_smooth":+ new_subpath[1::nppc] = get_smooth_quadratic_bezier_handle_points(+ anchors+ )+ elif mode == "true_smooth":+ h1, h2 = get_smooth_cubic_bezier_handle_points(anchors)+ new_subpath = get_quadratic_approximation_of_cubic(+ anchors[:-1], h1, h2, anchors[1:]+ )+ elif mode == "jagged":+ new_subpath[1::nppc] = 0.5 * (anchors[:-1] + anchors[1:])+ submob.append_points(new_subpath)+ submob.refresh_triangulation()+ return self++ def make_smooth(self):+ """+ This will double the number of points in the mobject,+ so should not be called repeatedly. It also means+ transforming between states before and after calling+ this might have strange artifacts+ """+ self.change_anchor_mode("true_smooth")+ return self++ def make_approximately_smooth(self):+ """+ Unlike make_smooth, this will not change the number of+ points, but it also does not result in a perfectly smooth+ curve. It's most useful when the points have been+ sampled at a not-too-low rate from a continuous function,+ as in the case of ParametricCurve+ """+ self.change_anchor_mode("approx_smooth")+ return self++ def make_jagged(self):+ self.change_anchor_mode("jagged")+ return self++ def add_subpath(self, points):+ assert len(points) % self.n_points_per_curve == 0+ self.append_points(points)+ return self++ def append_vectorized_mobject(self, vectorized_mobject):+ new_points = list(vectorized_mobject.get_points())++ if self.has_new_path_started():+ # Remove last point, which is starting+ # a new path+ self.resize_data(len(self.get_points() - 1))+ self.append_points(new_points)+ return self++ #+ def consider_points_equals(self, p0, p1):+ return get_norm(p1 - p0) < self.tolerance_for_point_equality++ # Information about the curve+ def get_bezier_tuples_from_points(self, points):+ nppc = self.n_points_per_curve+ remainder = len(points) % nppc+ points = points[: len(points) - remainder]+ return [points[i : i + nppc] for i in range(0, len(points), nppc)]++ def get_bezier_tuples(self):+ return self.get_bezier_tuples_from_points(self.get_points())++ def get_subpaths_from_points(self, points):+ nppc = self.n_points_per_curve+ diffs = points[nppc - 1 : -1 : nppc] - points[nppc::nppc]+ splits = (diffs * diffs).sum(1) > self.tolerance_for_point_equality+ split_indices = np.arange(nppc, len(points), nppc, dtype=int)[splits]++ # split_indices = filter(+ # lambda n: not self.consider_points_equals(points[n - 1], points[n]),+ # range(nppc, len(points), nppc)+ # )+ split_indices = [0, *split_indices, len(points)]+ return [+ points[i1:i2]+ for i1, i2 in zip(split_indices, split_indices[1:])+ if (i2 - i1) >= nppc+ ]++ def get_subpaths(self):+ return self.get_subpaths_from_points(self.get_points())++ def get_nth_curve_points(self, n):+ assert n < self.get_num_curves()+ nppc = self.n_points_per_curve+ return self.get_points()[nppc * n : nppc * (n + 1)]++ def get_nth_curve_function(self, n):+ return bezier(self.get_nth_curve_points(n))++ def get_num_curves(self):+ return self.get_num_points() // self.n_points_per_curve++ def point_from_proportion(self, alpha):+ num_curves = self.get_num_curves()+ n, residue = integer_interpolate(0, num_curves, alpha)+ curve_func = self.get_nth_curve_function(n)+ return curve_func(residue)++ def get_anchors_and_handles(self):+ """+ returns anchors1, handles, anchors2,+ where (anchors1[i], handles[i], anchors2[i])+ will be three points defining a quadratic bezier curve+ for any i in range(0, len(anchors1))+ """+ nppc = self.n_points_per_curve+ points = self.get_points()+ return [points[i::nppc] for i in range(nppc)]++ def get_start_anchors(self):+ return self.get_points()[0 :: self.n_points_per_curve]++ def get_end_anchors(self):+ nppc = self.n_points_per_curve+ return self.get_points()[nppc - 1 :: nppc]++ def get_anchors(self):+ points = self.get_points()+ if len(points) == 1:+ return points+ return np.array(+ list(+ it.chain(+ *zip(+ self.get_start_anchors(),+ self.get_end_anchors(),+ )+ )+ )+ )++ def get_points_without_null_curves(self, atol=1e-9):+ nppc = self.n_points_per_curve+ points = self.get_points()+ distinct_curves = reduce(+ op.or_,+ [+ (abs(points[i::nppc] - points[0::nppc]) > atol).any(1)+ for i in range(1, nppc)+ ],+ )+ return points[distinct_curves.repeat(nppc)]++ def get_arc_length(self, n_sample_points=None):+ if n_sample_points is None:+ n_sample_points = 4 * self.get_num_curves() + 1+ points = np.array(+ [self.point_from_proportion(a) for a in np.linspace(0, 1, n_sample_points)]+ )+ diffs = points[1:] - points[:-1]+ norms = np.array([get_norm(d) for d in diffs])+ return norms.sum()++ def get_area_vector(self):+ # Returns a vector whose length is the area bound by+ # the polygon formed by the anchor points, pointing+ # in a direction perpendicular to the polygon according+ # to the right hand rule.+ if not self.has_points():+ return np.zeros(3)++ nppc = self.n_points_per_curve+ points = self.get_points()+ p0 = points[0::nppc]+ p1 = points[nppc - 1 :: nppc]++ # Each term goes through all edges [(x1, y1, z1), (x2, y2, z2)]+ return 0.5 * np.array(+ [+ sum(+ (p0[:, 1] + p1[:, 1]) * (p1[:, 2] - p0[:, 2])+ ), # Add up (y1 + y2)*(z2 - z1)+ sum(+ (p0[:, 2] + p1[:, 2]) * (p1[:, 0] - p0[:, 0])+ ), # Add up (z1 + z2)*(x2 - x1)+ sum(+ (p0[:, 0] + p1[:, 0]) * (p1[:, 1] - p0[:, 1])+ ), # Add up (x1 + x2)*(y2 - y1)+ ]+ )++ def get_unit_normal(self, recompute=False):+ if not recompute:+ return self.data["unit_normal"][0]++ if len(self.data["points"]) < 3:+ return OUT++ area_vect = self.get_area_vector()+ area = get_norm(area_vect)+ if area > 0:+ return area_vect / area+ else:+ points = self.get_points()+ return get_unit_normal(+ points[1] - points[0],+ points[2] - points[1],+ )++ def refresh_unit_normal(self):+ for mob in self.get_family():+ mob.data["unit_normal"][:] = mob.get_unit_normal(recompute=True)+ return self++ # Alignment+ def align_points(self, vmobject):+ if self.get_num_points() == len(vmobject.get_points()):+ return++ for mob in self, vmobject:+ # If there are no points, add one to+ # where the "center" is+ if not mob.has_points():+ mob.start_new_path(mob.get_center())+ # If there's only one point, turn it into+ # a null curve+ if mob.has_new_path_started():+ mob.add_line_to(mob.get_points()[0])++ # Figure out what the subpaths are, and align+ subpaths1 = self.get_subpaths()+ subpaths2 = vmobject.get_subpaths()+ n_subpaths = max(len(subpaths1), len(subpaths2))+ # Start building new ones+ new_subpaths1 = []+ new_subpaths2 = []++ nppc = self.n_points_per_curve++ def get_nth_subpath(path_list, n):+ if n >= len(path_list):+ # Create a null path at the very end+ return [path_list[-1][-1]] * nppc+ return path_list[n]++ for n in range(n_subpaths):+ sp1 = get_nth_subpath(subpaths1, n)+ sp2 = get_nth_subpath(subpaths2, n)+ diff1 = max(0, (len(sp2) - len(sp1)) // nppc)+ diff2 = max(0, (len(sp1) - len(sp2)) // nppc)+ sp1 = self.insert_n_curves_to_point_list(diff1, sp1)+ sp2 = self.insert_n_curves_to_point_list(diff2, sp2)+ new_subpaths1.append(sp1)+ new_subpaths2.append(sp2)+ self.set_points(np.vstack(new_subpaths1))+ vmobject.set_points(np.vstack(new_subpaths2))+ return self++ def insert_n_curves(self, n, recurse=True):+ for mob in self.get_family(recurse):+ if mob.get_num_curves() > 0:+ new_points = mob.insert_n_curves_to_point_list(n, mob.get_points())+ # TODO, this should happen in insert_n_curves_to_point_list+ if mob.has_new_path_started():+ new_points = np.vstack([new_points, mob.get_last_point()])+ mob.set_points(new_points)+ return self++ def insert_n_curves_to_point_list(self, n, points):+ nppc = self.n_points_per_curve+ if len(points) == 1:+ return np.repeat(points, nppc * n, 0)++ bezier_groups = self.get_bezier_tuples_from_points(points)+ norms = np.array([get_norm(bg[nppc - 1] - bg[0]) for bg in bezier_groups])+ total_norm = sum(norms)+ # Calculate insertions per curve (ipc)+ if total_norm < 1e-6:+ ipc = [n] + [0] * (len(bezier_groups) - 1)+ else:+ ipc = np.round(n * norms / sum(norms)).astype(int)++ diff = n - sum(ipc)+ for x in range(diff):+ ipc[np.argmin(ipc)] += 1+ for x in range(-diff):+ ipc[np.argmax(ipc)] -= 1++ new_points = []+ for group, n_inserts in zip(bezier_groups, ipc):+ # What was once a single quadratic curve defined+ # by "group" will now be broken into n_inserts + 1+ # smaller quadratic curves+ alphas = np.linspace(0, 1, n_inserts + 2)+ for a1, a2 in zip(alphas, alphas[1:]):+ new_points += partial_quadratic_bezier_points(group, a1, a2)+ return np.vstack(new_points)++ def interpolate(self, mobject1, mobject2, alpha, *args, **kwargs):+ super().interpolate(mobject1, mobject2, alpha, *args, **kwargs)+ if self.has_fill():+ tri1 = mobject1.get_triangulation()+ tri2 = mobject2.get_triangulation()+ if len(tri1) != len(tri1) or not np.all(tri1 == tri2):+ self.refresh_triangulation()+ return self++ def pointwise_become_partial(self, vmobject, a, b):+ assert isinstance(vmobject, VMobject)+ if a <= 0 and b >= 1:+ self.become(vmobject)+ return self+ num_curves = vmobject.get_num_curves()+ nppc = self.n_points_per_curve++ # Partial curve includes three portions:+ # - A middle section, which matches the curve exactly+ # - A start, which is some ending portion of an inner quadratic+ # - An end, which is the starting portion of a later inner quadratic++ lower_index, lower_residue = integer_interpolate(0, num_curves, a)+ upper_index, upper_residue = integer_interpolate(0, num_curves, b)+ i1 = nppc * lower_index+ i2 = nppc * (lower_index + 1)+ i3 = nppc * upper_index+ i4 = nppc * (upper_index + 1)++ vm_points = vmobject.get_points()+ new_points = vm_points.copy()+ if num_curves == 0:+ new_points[:] = 0+ return self+ if lower_index == upper_index:+ tup = partial_quadratic_bezier_points(+ vm_points[i1:i2], lower_residue, upper_residue+ )+ new_points[:i1] = tup[0]+ new_points[i1:i4] = tup+ new_points[i4:] = tup[2]+ new_points[nppc:] = new_points[nppc - 1]+ else:+ low_tup = partial_quadratic_bezier_points(+ vm_points[i1:i2], lower_residue, 1+ )+ high_tup = partial_quadratic_bezier_points(+ vm_points[i3:i4], 0, upper_residue+ )+ new_points[0:i1] = low_tup[0]+ new_points[i1:i2] = low_tup+ # Keep new_points i2:i3 as they are+ new_points[i3:i4] = high_tup+ new_points[i4:] = high_tup[2]+ self.set_points(new_points)+ return self++ def get_subcurve(self, a, b):+ vmob = self.copy()+ vmob.pointwise_become_partial(self, a, b)+ return vmob++ # Related to triangulation++ def refresh_triangulation(self):+ for mob in self.get_family():+ mob.needs_new_triangulation = True+ return self++ def get_triangulation(self, normal_vector=None):+ # Figure out how to triangulate the interior to know+ # how to send the points as to the vertex shader.+ # First triangles come directly from the points+ if normal_vector is None:+ normal_vector = self.get_unit_normal()++ if not self.needs_new_triangulation:+ return self.triangulation++ points = self.get_points()++ if len(points) <= 1:+ self.triangulation = np.zeros(0, dtype="i4")+ self.needs_new_triangulation = False+ return self.triangulation++ if not np.isclose(normal_vector, OUT).all():+ # Rotate points such that unit normal vector is OUT+ points = np.dot(points, z_to_vector(normal_vector))+ indices = np.arange(len(points), dtype=int)++ b0s = points[0::3]+ b1s = points[1::3]+ b2s = points[2::3]+ v01s = b1s - b0s+ v12s = b2s - b1s++ crosses = cross2d(v01s, v12s)+ convexities = np.sign(crosses)++ atol = self.tolerance_for_point_equality+ end_of_loop = np.zeros(len(b0s), dtype=bool)+ end_of_loop[:-1] = (np.abs(b2s[:-1] - b0s[1:]) > atol).any(1)+ end_of_loop[-1] = True++ concave_parts = convexities < 0++ # These are the vertices to which we'll apply a polygon triangulation+ inner_vert_indices = np.hstack(+ [+ indices[0::3],+ indices[1::3][concave_parts],+ indices[2::3][end_of_loop],+ ]+ )+ inner_vert_indices.sort()+ rings = np.arange(1, len(inner_vert_indices) + 1)[inner_vert_indices % 3 == 2]++ # Triangulate+ inner_verts = points[inner_vert_indices]+ inner_tri_indices = inner_vert_indices[+ earclip_triangulation(inner_verts, rings)+ ]++ tri_indices = np.hstack([indices, inner_tri_indices])+ self.triangulation = tri_indices+ self.needs_new_triangulation = False+ return tri_indices++ def triggers_refreshed_triangulation(func):+ @wraps(func)+ def wrapper(self, *args, **kwargs):+ old_points = self.get_points()+ func(self, *args, **kwargs)+ if not np.all(self.get_points() == old_points):+ self.refresh_triangulation()+ self.refresh_unit_normal()++ return wrapper++ @triggers_refreshed_triangulation+ def set_points(self, points):+ super().set_points(points)+ return self++ @triggers_refreshed_triangulation+ def set_data(self, data):+ super().set_data(data)+ return self++ # TODO, how to be smart about tangents here?+ @triggers_refreshed_triangulation+ def apply_function(self, function, make_smooth=False, **kwargs):+ super().apply_function(function, **kwargs)+ if self.make_smooth_after_applying_functions or make_smooth:+ self.make_approximately_smooth()+ return self++ @triggers_refreshed_triangulation+ def flip(self, *args, **kwargs):+ super().flip(*args, **kwargs)+ return self++ # For shaders+ def init_shader_data(self):+ self.fill_data = np.zeros(0, dtype=self.fill_dtype)+ self.stroke_data = np.zeros(0, dtype=self.stroke_dtype)+ self.fill_shader_wrapper = ShaderWrapper(+ vert_data=self.fill_data,+ vert_indices=np.zeros(0, dtype="i4"),+ shader_folder=self.fill_shader_folder,+ render_primitive=self.render_primitive,+ )+ self.stroke_shader_wrapper = ShaderWrapper(+ vert_data=self.stroke_data,+ shader_folder=self.stroke_shader_folder,+ render_primitive=self.render_primitive,+ )++ def refresh_shader_wrapper_id(self):+ for wrapper in [self.fill_shader_wrapper, self.stroke_shader_wrapper]:+ wrapper.refresh_id()+ return self++ def get_fill_shader_wrapper(self):+ self.fill_shader_wrapper.vert_data = self.get_fill_shader_data()+ self.fill_shader_wrapper.vert_indices = self.get_fill_shader_vert_indices()+ self.fill_shader_wrapper.uniforms = self.get_shader_uniforms()+ self.fill_shader_wrapper.depth_test = self.depth_test+ return self.fill_shader_wrapper++ def get_stroke_shader_wrapper(self):+ self.stroke_shader_wrapper.vert_data = self.get_stroke_shader_data()+ self.stroke_shader_wrapper.uniforms = self.get_stroke_uniforms()+ self.stroke_shader_wrapper.depth_test = self.depth_test+ return self.stroke_shader_wrapper++ def get_shader_wrapper_list(self):+ # Build up data lists+ fill_shader_wrappers = []+ stroke_shader_wrappers = []+ back_stroke_shader_wrappers = []+ for submob in self.family_members_with_points():+ if submob.has_fill():+ fill_shader_wrappers.append(submob.get_fill_shader_wrapper())+ if submob.has_stroke():+ ssw = submob.get_stroke_shader_wrapper()+ if submob.draw_stroke_behind_fill:+ back_stroke_shader_wrappers.append(ssw)+ else:+ stroke_shader_wrappers.append(ssw)++ # Combine data lists+ wrapper_lists = [+ back_stroke_shader_wrappers,+ fill_shader_wrappers,+ stroke_shader_wrappers,+ ]+ result = []+ for wlist in wrapper_lists:+ if wlist:+ wrapper = wlist[0]+ wrapper.combine_with(*wlist[1:])+ result.append(wrapper)+ return result++ def get_stroke_uniforms(self):+ result = dict(super().get_shader_uniforms())+ result["joint_type"] = JOINT_TYPE_MAP[self.joint_type]+ result["flat_stroke"] = float(self.flat_stroke)+ return result++ def get_stroke_shader_data(self):+ points = self.get_points()+ if len(self.stroke_data) != len(points):+ self.stroke_data = resize_array(self.stroke_data, len(points))++ if "points" not in self.locked_data_keys:+ nppc = self.n_points_per_curve+ self.stroke_data["point"] = points+ self.stroke_data["prev_point"][:nppc] = points[-nppc:]+ self.stroke_data["prev_point"][nppc:] = points[:-nppc]+ self.stroke_data["next_point"][:-nppc] = points[nppc:]+ self.stroke_data["next_point"][-nppc:] = points[:nppc]++ self.read_data_to_shader(self.stroke_data, "color", "stroke_rgba")+ self.read_data_to_shader(self.stroke_data, "stroke_width", "stroke_width")+ self.read_data_to_shader(self.stroke_data, "unit_normal", "unit_normal")++ return self.stroke_data++ def get_fill_shader_data(self):+ points = self.get_points()+ if len(self.fill_data) != len(points):+ self.fill_data = resize_array(self.fill_data, len(points))+ self.fill_data["vert_index"][:, 0] = range(len(points))++ self.read_data_to_shader(self.fill_data, "point", "points")+ self.read_data_to_shader(self.fill_data, "color", "fill_rgba")+ self.read_data_to_shader(self.fill_data, "unit_normal", "unit_normal")++ return self.fill_data++ def refresh_shader_data(self):+ self.get_fill_shader_data()+ self.get_stroke_shader_data()++ def get_fill_shader_vert_indices(self):+ return self.get_triangulation()+++class OpenGLVGroup(OpenGLVMobject):+ def __init__(self, *vmobjects, **kwargs):+ if not all([isinstance(m, OpenGLVMobject) for m in vmobjects]):+ raise Exception("All submobjects must be of type VMobject")+ super().__init__(**kwargs)+ self.add(*vmobjects)+++class OpenGLVectorizedPoint(OpenGLPoint, OpenGLVMobject):+ def __init__(+ self,+ location=ORIGIN,+ color=BLACK,+ fill_opacity=0,+ stroke_width=0,+ artificial_width=0.01,+ artificial_height=0.01,+ **kwargs+ ):+ self.color = color+ self.fill_opacity = fill_opacity+ self.stroke_width = stroke_width+ self.artificial_width = artificial_width+ self.artificial_height = artificial_height++ super().__init__(**kwargs)+ self.set_points(np.array([location]))+++class OpenGLCurvesAsSubmobjects(OpenGLVGroup):+ def __init__(self, vmobject, **kwargs):+ super().__init__(**kwargs)+ for tup in vmobject.get_bezier_tuples():+ part = OpenGLVMobject()+ part.set_points(tup)+ part.match_style(vmobject)+ self.add(part)+++class DashedVMobject(OpenGLVMobject):+ def __init__(+ self, vmobject, num_dashes=15, positive_space_ratio=0.5, color=WHITE, **kwargs+ ):+ self.num_dashes = num_dashes+ self.positive_space_ratio = positive_space_ratio+ self.color = color+ super().__init__(**kwargs)+ num_dashes = self.num_dashes+ ps_ratio = self.positive_space_ratio+ if num_dashes > 0:+ # End points of the unit interval for division+ alphas = np.linspace(0, 1, num_dashes + 1)++ # This determines the length of each "dash"+ full_d_alpha = 1.0 / num_dashes+ partial_d_alpha = full_d_alpha * ps_ratio++ # Rescale so that the last point of vmobject will+ # be the end of the last dash+ alphas /= 1 - full_d_alpha + partial_d_alpha++ self.add(+ *[+ vmobject.get_subcurve(alpha, alpha + partial_d_alpha)+ for alpha in alphas[:-1]+ ]+ )+ # Family is already taken care of by get_subcurve+ # implementation+ self.match_style(vmobject, recurse=False)diff --git a/manim/opengl/__init__.py b/manim/opengl/__init__.pyindex 459d67173..177e57ec6 100644--- a/manim/opengl/__init__.py+++ b/manim/opengl/__init__.py@@ -1,3 +1,5 @@+from ..mobject.opengl_mobject import *+from ..mobject.types.opengl_vectorized_mobject import *from ..mobject.opengl_geometry import *Arc = OpenGLArcdiff --git a/manim/utils/iterables.py b/manim/utils/iterables.pyindex a82ba60e8..137ebfd90 100644--- a/manim/utils/iterables.py+++ b/manim/utils/iterables.py@@ -13,6 +13,7 @@ __all__ = ["make_even_by_cycling","remove_nones","concatenate_lists",+ "listify",]@@ -20,6 +21,34 @@ import itertools as itimport numpy as np+def resize_array(nparray, length):+ if len(nparray) == length:+ return nparray+ return np.resize(nparray, (length, *nparray.shape[1:]))+++def resize_preserving_order(nparray, length):+ if len(nparray) == 0:+ return np.zeros((length, *nparray.shape[1:]))+ if len(nparray) == length:+ return nparray+ indices = np.arange(length) * len(nparray) // length+ return nparray[indices]+++def resize_with_interpolation(nparray, length):+ if len(nparray) == length:+ return nparray+ cont_indices = np.linspace(0, len(nparray) - 1, length)+ return np.array(+ [+ (1 - a) * nparray[lh] + a * nparray[rh]+ for ci in cont_indices+ for lh, rh, a in [(int(ci), int(np.ceil(ci)), ci % 1)]+ ]+ )++def remove_list_redundancies(l):"""Used instead of list(set(l)) to maintain order@@ -68,6 +97,15 @@ def tuplify(obj):return (obj,)+def listify(obj):+ if isinstance(obj, str):+ return [obj]+ try:+ return list(obj)+ except TypeError:+ return [obj]++def stretch_array_to_length(nparray, length):curr_len = len(nparray)if curr_len > length: