A community-maintained Python framework for creating mathematical animations.
Add OpenGL support for :class:`~.PMobject` (#1882)
Ryan McCauleyab28d5b1717c
diff --git a/manim/__init__.py b/manim/__init__.pyindex 516c80c93..1389e7b2d 100644--- a/manim/__init__.py+++ b/manim/__init__.py@@ -74,7 +74,9 @@ from .mobject.svg.text_mobject import *from .mobject.table import *from .mobject.three_d_utils import *from .mobject.three_dimensions import *+from .mobject.types.dot_cloud import *from .mobject.types.image_mobject import *+from .mobject.types.opengl_point_cloud_mobject import *from .mobject.types.point_cloud_mobject import *from .mobject.types.vectorized_mobject import *from .mobject.value_tracker import *diff --git a/manim/mobject/opengl_compatibility.py b/manim/mobject/opengl_compatibility.pyindex 1557ef9c6..96ffc071d 100644--- a/manim/mobject/opengl_compatibility.py+++ b/manim/mobject/opengl_compatibility.py@@ -3,6 +3,7 @@ from abc import ABCMetafrom .. import configfrom .opengl_mobject import OpenGLMobjectfrom .opengl_three_dimensions import OpenGLSurface+from .types.opengl_point_cloud_mobject import OpenGLPMobjectfrom .types.opengl_vectorized_mobject import OpenGLVMobject@@ -25,6 +26,9 @@ class ConvertToOpenGL(ABCMeta):base_names_to_opengl = {"Mobject": OpenGLMobject,"VMobject": OpenGLVMobject,+ "PMobject": OpenGLPMobject,+ "Mobject1D": OpenGLPMobject,+ "Mobject2D": OpenGLPMobject,"Surface": OpenGLSurface,}diff --git a/manim/mobject/opengl_mobject.py b/manim/mobject/opengl_mobject.pyindex 0c7ddb406..2faf1979f 100644--- a/manim/mobject/opengl_mobject.py+++ b/manim/mobject/opengl_mobject.py@@ -65,7 +65,7 @@ class OpenGLMobject:# Positive shadow up to 1 makes a side opposite the light darkershadow=0.0,# For shaders- render_primitive=moderngl.TRIANGLE_STRIP,+ render_primitive=moderngl.TRIANGLES,texture_paths=None,depth_test=False,# If true, the mobject will not get rotated according to camera position@@ -134,7 +134,7 @@ class OpenGLMobject:self.set_color(self.color, self.opacity)def init_points(self):- # Typically implemented in subclass, unlpess purposefully left blank+ # Typically implemented in subclass, unless purposefully left blankpassdef set_data(self, data):@@ -264,6 +264,11 @@ class OpenGLMobject:self.refresh_bounding_box()return self+ def apply_over_attr_arrays(self, func):+ for attr in self.get_array_attrs():+ setattr(self, attr, func(getattr(self, attr)))+ return self+def append_points(self, new_points):self.points = np.vstack([self.points, new_points])self.refresh_bounding_box()@@ -1267,6 +1272,23 @@ class OpenGLMobject:mob.data[name] = rgbas.copy()return self+ def set_rgba_array_direct(self, rgbas: np.ndarray, name="rgbas", recurse=True):+ """Directly set rgba data from `rgbas` and optionally do the same recursively+ with submobjects. This can be used if the `rgbas` have already been generated+ with the correct shape and simply need to be set.++ Parameters+ ----------+ rgbas+ the rgba to be set as data+ name+ the name of the data attribute to be set+ recurse+ set to true to recursively apply this method to submobjects+ """+ for mob in self.get_family(recurse):+ mob.data[name] = rgbas.copy()+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_arraydiff --git a/manim/mobject/types/dot_cloud.py b/manim/mobject/types/dot_cloud.pynew file mode 100644index 000000000..bbdee7d06--- /dev/null+++ b/manim/mobject/types/dot_cloud.py@@ -0,0 +1,43 @@+__all__ = ["TrueDot", "DotCloud"]++import numpy as np++from ...constants import ORIGIN, RIGHT, UP+from ...utils.color import YELLOW+from .opengl_point_cloud_mobject import OpenGLPMobject+++class DotCloud(OpenGLPMobject):+ def __init__(+ self, color=YELLOW, stroke_width=2.0, radius=2.0, density=10, **kwargs+ ):+ self.radius = radius+ self.epsilon = 1.0 / density+ super().__init__(+ stroke_width=stroke_width, density=density, color=color, **kwargs+ )++ def init_points(self):+ self.points = np.array(+ [+ r * (np.cos(theta) * RIGHT + np.sin(theta) * UP)+ for r in np.arange(self.epsilon, self.radius, self.epsilon)+ # Num is equal to int(stop - start)/ (step + 1) reformulated.+ for theta in np.linspace(+ 0, 2 * np.pi, num=int(2 * np.pi * (r + self.epsilon) / self.epsilon)+ )+ ],+ dtype=np.float32,+ )++ def make_3d(self, gloss=0.5, shadow=0.2):+ self.set_gloss(gloss)+ self.set_shadow(shadow)+ self.apply_depth_test()+ return self+++class TrueDot(DotCloud):+ def __init__(self, center=ORIGIN, stroke_width=2.0, **kwargs):+ self.radius = stroke_width+ super().__init__(points=[center], stroke_width=stroke_width, **kwargs)diff --git a/manim/mobject/types/opengl_point_cloud_mobject.py b/manim/mobject/types/opengl_point_cloud_mobject.pynew file mode 100644index 000000000..6a568405e--- /dev/null+++ b/manim/mobject/types/opengl_point_cloud_mobject.py@@ -0,0 +1,168 @@+__all__ = ["OpenGLPMobject", "OpenGLPGroup", "OpenGLPMPoint"]++import moderngl+import numpy as np++from ...constants import *+from ...mobject.opengl_mobject import OpenGLMobject+from ...utils.bezier import interpolate+from ...utils.color import BLACK, WHITE, YELLOW, color_gradient, color_to_rgba+from ...utils.config_ops import _Uniforms+from ...utils.iterables import resize_with_interpolation+++class OpenGLPMobject(OpenGLMobject):+ shader_folder = "true_dot"+ # Scale for consistency with cairo units+ OPENGL_POINT_RADIUS_SCALE_FACTOR = 0.01+ shader_dtype = [+ ("point", np.float32, (3,)),+ ("color", np.float32, (4,)),+ ]++ point_radius = _Uniforms()++ def __init__(+ self, stroke_width=2.0, color=YELLOW, render_primitive=moderngl.POINTS, **kwargs+ ):+ self.stroke_width = stroke_width+ super().__init__(color=color, render_primitive=render_primitive, **kwargs)+ self.point_radius = (+ self.stroke_width * OpenGLPMobject.OPENGL_POINT_RADIUS_SCALE_FACTOR+ )++ def reset_points(self):+ self.rgbas = np.zeros((1, 4))+ self.points = np.zeros((0, 3))+ return self++ def get_array_attrs(self):+ return ["points", "rgbas"]++ def add_points(self, points, rgbas=None, color=None, opacity=None):+ """+ points must be a Nx3 numpy array, as must rgbas if it is not None+ """+ if rgbas is None and color is None:+ color = YELLOW+ self.append_points(points)+ # rgbas array will have been resized with points+ if color is not None:+ if opacity is None:+ opacity = self.rgbas[-1, 3]+ new_rgbas = np.repeat([color_to_rgba(color, opacity)], len(points), axis=0)+ elif rgbas is not None:+ new_rgbas = rgbas+ elif len(rgbas) != len(points):+ raise ValueError("points and rgbas must have same shape")+ self.rgbas = np.append(self.rgbas, new_rgbas, axis=0)+ return self++ def thin_out(self, factor=5):+ """+ Removes all but every nth point for n = factor+ """+ for mob in self.family_members_with_points():+ num_points = mob.get_num_points()++ def thin_func():+ return np.arange(0, num_points, factor)++ if len(mob.points) == len(mob.rgbas):+ mob.set_rgba_array_direct(mob.rgbas[thin_func()])+ mob.set_points(mob.points[thin_func()])++ return self++ def set_color_by_gradient(self, *colors):+ self.rgbas = np.array(+ list(map(color_to_rgba, color_gradient(*colors, self.get_num_points())))+ )+ return self++ def set_colors_by_radial_gradient(+ self, center=None, radius=1, inner_color=WHITE, outer_color=BLACK+ ):+ start_rgba, end_rgba = list(map(color_to_rgba, [inner_color, outer_color]))+ if center is None:+ center = self.get_center()+ for mob in self.family_members_with_points():+ distances = np.abs(self.points - center)+ alphas = np.linalg.norm(distances, axis=1) / radius++ mob.rgbas = np.array(+ np.array([interpolate(start_rgba, end_rgba, alpha) for alpha in alphas])+ )+ return self++ def match_colors(self, pmobject):+ self.rgbas[:] = resize_with_interpolation(pmobject.rgbas, self.get_num_points())+ return self++ def fade_to(self, color, alpha, family=True):+ rgbas = interpolate(self.rgbas, color_to_rgba(color), alpha)+ for mob in self.submobjects:+ mob.fade_to(color, alpha, family)+ self.set_rgba_array_direct(rgbas)+ return self++ def filter_out(self, condition):+ for mob in self.family_members_with_points():+ to_keep = ~np.apply_along_axis(condition, 1, mob.get_points())+ for key in mob.data:+ mob.data[key] = mob.data[key][to_keep]+ return self++ def sort_points(self, function=lambda p: p[0]):+ """+ function is any map from R^3 to R+ """+ for mob in self.family_members_with_points():+ indices = np.argsort(np.apply_along_axis(function, 1, mob.get_points()))+ for key in mob.data:+ mob.data[key] = mob.data[key][indices]+ return self++ def ingest_submobjects(self):+ for key in self.data:+ self.data[key] = np.vstack([sm.data[key] for sm in self.get_family()])+ return self++ def point_from_proportion(self, alpha):+ index = alpha * (self.get_num_points() - 1)+ return self.get_points()[int(index)]++ def pointwise_become_partial(self, pmobject, a, b):+ lower_index = int(a * pmobject.get_num_points())+ upper_index = int(b * pmobject.get_num_points())+ for key in self.data:+ self.data[key] = pmobject.data[key][lower_index:upper_index]+ return self++ def get_shader_data(self):+ shader_data = np.zeros(len(self.get_points()), dtype=self.shader_dtype)+ self.read_data_to_shader(shader_data, "point", "points")+ self.read_data_to_shader(shader_data, "color", "rgbas")+ return shader_data+++class OpenGLPGroup(OpenGLPMobject):+ def __init__(self, *pmobs, **kwargs):+ if not all([isinstance(m, OpenGLPMobject) for m in pmobs]):+ raise Exception("All submobjects must be of type OpenglPMObject")+ super().__init__(**kwargs)+ self.add(*pmobs)++ def fade_to(self, color, alpha, family=True):+ if family:+ for mob in self.submobjects:+ mob.fade_to(color, alpha, family)+++class OpenGLPMPoint(OpenGLPMobject):+ def __init__(self, location=ORIGIN, stroke_width=4.0, color=BLACK, **kwargs):+ self.location = location+ super().__init__(stroke_width=stroke_width, **kwargs)++ def init_points(self):+ self.points = np.array([self.location], dtype=np.float32)diff --git a/manim/mobject/types/point_cloud_mobject.py b/manim/mobject/types/point_cloud_mobject.pyindex 05e92a5c4..b291fbef0 100644--- a/manim/mobject/types/point_cloud_mobject.py+++ b/manim/mobject/types/point_cloud_mobject.py@@ -2,8 +2,8 @@__all__ = ["PMobject", "Mobject1D", "Mobject2D", "PGroup", "PointCloudDot", "Point"]-import numpy as np+from colour import Colorfrom ...constants import *from ...mobject.mobject import Mobject@@ -12,15 +12,16 @@ from ...utils.color import (BLACK,WHITE,YELLOW,- YELLOW_C,color_gradient,color_to_rgba,rgba_to_color,)from ...utils.iterables import stretch_array_to_length+from ..opengl_compatibility import ConvertToOpenGL+from ..types.opengl_point_cloud_mobject import OpenGLPMobject-class PMobject(Mobject):+class PMobject(Mobject, metaclass=ConvertToOpenGL):"""A disc made of a cloud of DotsExamples@@ -77,7 +78,7 @@ class PMobject(Mobject):self.rgbas = np.append(self.rgbas, rgbas, axis=0)return self- def set_color(self, color=YELLOW_C, family=True):+ def set_color(self, color=YELLOW, family=True):rgba = color_to_rgba(color)mobs = self.family_members_with_points() if family else [self]for mob in mobs:@@ -94,24 +95,25 @@ class PMobject(Mobject):mob.stroke_width = widthreturn self- # def set_color_by_gradient(self, start_color, end_color):def set_color_by_gradient(self, *colors):self.rgbas = np.array(- list(map(color_to_rgba, color_gradient(colors, len(self.points))))+ list(map(color_to_rgba, color_gradient(*colors, len(self.points)))))return selfdef set_colors_by_radial_gradient(self, center=None, radius=1, inner_color=WHITE, outer_color=BLACK):- start_rgba, end_rgba = list(map(color_to_rgba, [start_color, end_color]))+ start_rgba, end_rgba = list(map(color_to_rgba, [inner_color, outer_color]))if center is None:center = self.get_center()for mob in self.family_members_with_points():- num_points = mob.get_num_points()- t = min(1, np.abs(mob.get_center() - center) / radius)+ distances = np.abs(self.points - center)+ alphas = np.linalg.norm(distances, axis=1) / radius- mob.rgbas = np.array([interpolate(start_rgba, end_rgba, t)] * num_points)+ mob.rgbas = np.array(+ np.array([interpolate(start_rgba, end_rgba, alpha) for alpha in alphas])+ )return selfdef match_colors(self, mobject):@@ -146,10 +148,10 @@ class PMobject(Mobject):mob.apply_over_attr_arrays(lambda arr: arr[indices])return self- def fade_to(self, color, alpha):+ def fade_to(self, color, alpha, family=True):self.rgbas = interpolate(self.rgbas, color_to_rgba(color), alpha)for mob in self.submobjects:- mob.fade_to(color, alpha)+ mob.fade_to(color, alpha, family)return selfdef get_all_rgbas(self):@@ -202,7 +204,7 @@ class PMobject(Mobject):# TODO, Make the two implementations below non-redundant-class Mobject1D(PMobject):+class Mobject1D(PMobject, metaclass=ConvertToOpenGL):def __init__(self, density=DEFAULT_POINT_DENSITY_1D, **kwargs):self.density = densityself.epsilon = 1.0 / self.density@@ -219,7 +221,7 @@ class Mobject1D(PMobject):self.add_points(points, color=color)-class Mobject2D(PMobject):+class Mobject2D(PMobject, metaclass=ConvertToOpenGL):def __init__(self, density=DEFAULT_POINT_DENSITY_2D, **kwargs):self.density = densityself.epsilon = 1.0 / self.density@@ -249,11 +251,21 @@ class PGroup(PMobject):"""def __init__(self, *pmobs, **kwargs):- if not all([isinstance(m, PMobject) for m in pmobs]):- raise ValueError("All submobjects must be of type PMobject")+ if not all(+ [isinstance(m, PMobject) or isinstance(m, OpenGLPMobject) for m in pmobs]+ ):+ raise ValueError(+ "All submobjects must be of type PMobject or OpenGLPMObject"+ " if using the opengl renderer"+ )super().__init__(**kwargs)self.add(*pmobs)+ def fade_to(self, color, alpha, family=True):+ if family:+ for mob in self.submobjects:+ mob.fade_to(color, alpha, family)+class PointCloudDot(Mobject1D):"""A disc made of a cloud of Dots@@ -296,11 +308,16 @@ class PointCloudDot(Mobject1D):**kwargs):self.radius = radius- Mobject1D.__init__(- self, stroke_width=stroke_width, density=density, color=color, **kwargs+ self.epsilon = 1.0 / density+ super().__init__(+ stroke_width=stroke_width, density=density, color=color, **kwargs)self.shift(center)+ def init_points(self):+ self.reset_points()+ self.generate_points()+def generate_points(self):self.add_points([@@ -336,5 +353,13 @@ class Point(PMobject):"""def __init__(self, location=ORIGIN, color=BLACK, **kwargs):- PMobject.__init__(self, color=color, **kwargs)- self.add_points([location])+ self.location = location+ super().__init__(color=color, **kwargs)++ def init_points(self):+ self.reset_points()+ self.generate_points()+ self.set_points([self.location])++ def generate_points(self):+ self.add_points([self.location])diff --git a/manim/renderer/opengl_renderer.py b/manim/renderer/opengl_renderer.pyindex 4560675a3..f47418992 100644--- a/manim/renderer/opengl_renderer.py+++ b/manim/renderer/opengl_renderer.py@@ -339,6 +339,7 @@ class OpenGLRenderer:shader_wrapper.vert_data,indices=shader_wrapper.vert_indices,use_depth_test=shader_wrapper.depth_test,+ primitive=mobject.render_primitive,)mesh.set_uniforms(self)mesh.render()diff --git a/manim/renderer/shaders/true_dot/frag.glsl b/manim/renderer/shaders/true_dot/frag.glslindex 965c0eac4..e5838ef7c 100644--- a/manim/renderer/shaders/true_dot/frag.glsl+++ b/manim/renderer/shaders/true_dot/frag.glsl@@ -6,7 +6,7 @@ uniform float shadow;uniform float anti_alias_width;in vec4 color;-in float radius;+in float point_radius;in vec2 center;in vec2 point;@@ -17,11 +17,11 @@ out vec4 frag_color;void main() {vec2 diff = point - center;float dist = length(diff);- float signed_dist = dist - radius;+ float signed_dist = dist - point_radius;if (signed_dist > 0.5 * anti_alias_width){discard;}- vec3 normal = vec3(diff / radius, sqrt(1 - (dist * dist) / (radius * radius)));+ vec3 normal = vec3(diff / point_radius, sqrt(1 - (dist * dist) / (point_radius * point_radius)));frag_color = finalize_color(color,vec3(point.xy, 0.0),diff --git a/manim/renderer/shaders/true_dot/geom.glsl b/manim/renderer/shaders/true_dot/geom.glslindex 31ec676c1..ba407e124 100644--- a/manim/renderer/shaders/true_dot/geom.glsl+++ b/manim/renderer/shaders/true_dot/geom.glsl@@ -10,11 +10,11 @@ uniform float is_fixed_in_frame;uniform float anti_alias_width;in vec3 v_point[1];-in float v_radius[1];+in float v_point_radius[1];in vec4 v_color[1];out vec4 color;-out float radius;+out float point_radius;out vec2 center;out vec2 point;@@ -22,11 +22,11 @@ out vec2 point;void main() {color = v_color[0];- radius = v_radius[0];+ point_radius = v_point_radius[0];center = v_point[0].xy;- radius = v_radius[0] / max(1.0 - v_point[0].z / focal_distance / frame_shape.y, 0.0);- float rpa = radius + anti_alias_width;+ point_radius = v_point_radius[0] / max(1.0 - v_point[0].z / focal_distance / frame_shape.y, 0.0);+ float rpa = point_radius + anti_alias_width;for(int i = 0; i < 4; i++){// To account for perspectivediff --git a/manim/renderer/shaders/true_dot/vert.glsl b/manim/renderer/shaders/true_dot/vert.glslindex 1458a340e..4f071018e 100644--- a/manim/renderer/shaders/true_dot/vert.glsl+++ b/manim/renderer/shaders/true_dot/vert.glsl@@ -3,17 +3,18 @@#include ../include/camera_uniform_declarations.glslin vec3 point;-in float radius;in vec4 color;+uniform float point_radius;+out vec3 v_point;-out float v_radius;+out float v_point_radius;out vec4 v_color;#include ../include/position_point_into_frame.glslvoid main(){v_point = position_point_into_frame(point);- v_radius = radius;+ v_point_radius = point_radius;v_color = color;}diff --git a/manim/utils/color.py b/manim/utils/color.pyindex 4c787656a..b11c1f959 100644--- a/manim/utils/color.py+++ b/manim/utils/color.py@@ -369,7 +369,7 @@ def color_to_rgb(color: Union[Color, str]) -> np.ndarray:elif isinstance(color, Color):return np.array(color.get_rgb())else:- raise ValueError("Invalid color type")+ raise ValueError("Invalid color type: " + str(color))def color_to_rgba(color: Union[Color, str], alpha: float = 1) -> np.ndarray: