Skip to content

armgit / manim

Public Imported from GitHub
0

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__.py
index 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.py
index 1557ef9c6..96ffc071d 100644
--- a/manim/mobject/opengl_compatibility.py
+++ b/manim/mobject/opengl_compatibility.py
@@ -3,6 +3,7 @@ from abc import ABCMeta
from .. import config
from .opengl_mobject import OpenGLMobject
from .opengl_three_dimensions import OpenGLSurface
+from .types.opengl_point_cloud_mobject import OpenGLPMobject
from .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.py
index 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 darker
shadow=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 blank
pass
def 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_array
diff --git a/manim/mobject/types/dot_cloud.py b/manim/mobject/types/dot_cloud.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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 Color
from ...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 Dots
Examples
@@ -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 = width
return 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 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, [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 self
def 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 self
def 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 = density
self.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 = density
self.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.py
index 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.glsl
index 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.glsl
index 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 perspective
diff --git a/manim/renderer/shaders/true_dot/vert.glsl b/manim/renderer/shaders/true_dot/vert.glsl
index 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.glsl
in 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.glsl
void 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.py
index 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: