A community-maintained Python framework for creating mathematical animations.
Beginning to port shaders example
Devin Neal08607e2c6f13
diff --git a/manim/mobject/opengl_mobject.py b/manim/mobject/opengl_mobject.pyindex f48bb5deb..848f31a93 100644--- a/manim/mobject/opengl_mobject.py+++ b/manim/mobject/opengl_mobject.py@@ -38,6 +38,10 @@ class OpenGLMobject:"""Mathematical Object"""+ shader_dtype=[+ ("point", np.float32, (3,)),+ ]+ shader_folder = ""def __init__(self,@@ -50,16 +54,12 @@ class OpenGLMobject:# Positive shadow up to 1 makes a side opposite the light darkershadow=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 positionis_fixed_in_frame=False,# Must match in attributes of vert shader- shader_dtype=[- ("point", np.float32, (3,)),- ],# Event listenerlisten_to_events=False,**kwargs@@ -74,14 +74,12 @@ class OpenGLMobject:# Positive shadow up to 1 makes a side opposite the light darkerself.shadow = shadow# For shaders- self.shader_folder = shader_folderself.render_primitive = render_primitiveself.texture_paths = texture_pathsself.depth_test = depth_test# If true, the mobject will not get rotated according to camera positionself.is_fixed_in_frame = is_fixed_in_frame# Must match in attributes of vert shader- self.shader_dtype = shader_dtype# Event listenerself.listen_to_events = listen_to_events@@ -817,7 +815,7 @@ class OpenGLMobject:def move_to(self, point_or_mobject, aligned_edge=ORIGIN, coor_mask=np.array([1, 1, 1])):- if isinstance(point_or_mobject, Mobject):+ if isinstance(point_or_mobject, OpenGLMobject):target = point_or_mobject.get_bounding_box_point(aligned_edge)else:target = point_or_mobject@@ -1384,11 +1382,11 @@ class OpenGLMobject: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_data = np.zeros(len(self.get_points()), dtype=self.__class__.shader_dtype)self.shader_indices = Noneself.shader_wrapper = ShaderWrapper(vert_data=self.shader_data,- shader_folder=self.shader_folder,+ shader_folder=self.__class__.shader_folder,texture_paths=self.texture_paths,depth_test=self.depth_test,render_primitive=self.render_primitive,@@ -1404,8 +1402,9 @@ class OpenGLMobject:vert_indices=self.get_shader_vert_indices(),uniforms = self.get_shader_uniforms(),depth_test = self.depth_test,+ texture_paths=self.texture_paths,render_primitive=self.render_primitive,- shader_folder=self.shader_folder,+ shader_folder=self.__class__.shader_folder,)return self.shader_wrapperdiff --git a/manim/mobject/types/opengl_surface.py b/manim/mobject/types/opengl_surface.pyindex e77c3e957..fe9508457 100644--- a/manim/mobject/types/opengl_surface.py+++ b/manim/mobject/types/opengl_surface.py@@ -184,7 +184,7 @@ class OpenGLSurface(OpenGLMobject):# For shadersdef get_shader_data(self):s_points, du_points, dv_points = self.get_surface_points_and_nudged_points()- shader_data = np.zeros(len(s_points), dtype=OpenGLSurface.shader_dtype)+ shader_data = np.zeros(len(s_points), dtype=self.__class__.shader_dtype)if "points" not in self.locked_data_keys:shader_data["point"] = s_pointsshader_data["du_point"] = du_points@@ -218,22 +218,20 @@ class OpenGLTexturedSurface(OpenGLSurface):("im_coords", np.float32, (2,)),("opacity", np.float32, (1,)),]+ shader_folder = "textured_surface"def __init__(self, uv_surface, image_file, dark_image_file=None, shader_folder=None, **kwargs):if not isinstance(uv_surface, OpenGLSurface):raise Exception("uv_surface must be of type OpenGLSurface")- shader_folder = (- shader_folder if shader_folder is not None else "textured_surface"- )# Set texture informationif dark_image_file is None:dark_image_file = image_fileself.num_textures = 1else:self.num_textures = 2- self.texture_paths = {+ texture_paths = {"LightTexture": get_full_raster_image_path(image_file),"DarkTexture": get_full_raster_image_path(dark_image_file),}@@ -244,7 +242,7 @@ class OpenGLTexturedSurface(OpenGLSurface):self.v_range = uv_surface.v_rangeself.resolution = uv_surface.resolutionself.gloss = self.uv_surface.gloss- super().__init__(**kwargs)+ super().__init__(texture_paths=texture_paths, **kwargs)def init_data(self):super().init_data()diff --git a/manim/renderer/opengl_renderer.py b/manim/renderer/opengl_renderer.pyindex 321a67502..7413466e2 100644--- a/manim/renderer/opengl_renderer.py+++ b/manim/renderer/opengl_renderer.py@@ -7,16 +7,164 @@ import itertools as itimport timefrom .. import loggerfrom ..constants import *-from ..utils.space_ops import cross2d-from ..utils.space_ops import earclip_triangulation-from ..utils.space_ops import z_to_vector+from ..utils.space_ops import (+ cross2d,+ earclip_triangulation,+ z_to_vector,+ quaternion_mult,+ quaternion_from_angle_axis,+ rotation_matrix_transpose_from_quaternion,+ rotation_matrix_transpose,+ angle_of_vector,+)from ..mobject import opengl_geometry+from ..mobject.opengl_mobject import OpenGLMobject, OpenGLPoint+from PIL import Image+from manim import config+++class OpenGLCamera(OpenGLMobject):+ def __init__(+ self,+ frame_shape=None,+ center_point=None,+ # Theta, phi, gamma+ euler_angles=[0, 0, 0],+ focal_distance=2,+ light_source_position=[-10, 10, 10],+ **kwargs+ ):+ self.use_z_index = True+ self.frame_rate = 60++ if frame_shape is None:+ self.frame_shape = (config["frame_width"], config["frame_height"])+ else:+ self.frame_shape = frame_shape++ if center_point is None:+ self.center_point = ORIGIN+ else:+ self.center_point = center_point++ if euler_angles is None:+ self.euler_angles = [0, 0, 0]+ else:+ self.euler_angles = euler_angles++ self.focal_distance = focal_distance++ if light_source_position is None:+ self.light_source_position = [-10, 10, 10]+ else:+ self.light_source_position = light_source_position+ self.light_source = OpenGLPoint(self.light_source_position)++ super().__init__(**kwargs)++ def init_data(self):+ super().init_data()+ self.data["euler_angles"] = np.array(self.euler_angles, dtype=float)+ self.refresh_rotation_matrix()++ def init_points(self):+ self.set_points([ORIGIN, LEFT, RIGHT, DOWN, UP])+ self.set_width(self.frame_shape[0], stretch=True)+ self.set_height(self.frame_shape[1], stretch=True)+ self.move_to(self.center_point)++ def to_default_state(self):+ self.center()+ self.set_height(config["frame_height"])+ self.set_width(config["frame_width"])+ self.set_euler_angles(0, 0, 0)+ return self++ def refresh_rotation_matrix(self):+ # Rotate based on camera orientation+ theta, phi, gamma = self.data["euler_angles"]+ quat = quaternion_mult(+ quaternion_from_angle_axis(theta, OUT, axis_normalized=True),+ quaternion_from_angle_axis(phi, RIGHT, axis_normalized=True),+ quaternion_from_angle_axis(gamma, OUT, axis_normalized=True),+ )+ self.inverse_camera_rotation_matrix = rotation_matrix_transpose_from_quaternion(+ quat+ )++ def rotate(self, angle, axis=OUT, **kwargs):+ curr_rot_T = self.inverse_camera_rotation_matrix+ added_rot_T = rotation_matrix_transpose(angle, axis)+ new_rot_T = np.dot(curr_rot_T, added_rot_T)+ Fz = new_rot_T[2]+ phi = np.arccos(Fz[2])+ theta = angle_of_vector(Fz[:2]) + PI / 2+ partial_rot_T = np.dot(+ rotation_matrix_transpose(phi, RIGHT),+ rotation_matrix_transpose(theta, OUT),+ )+ gamma = angle_of_vector(np.dot(partial_rot_T, new_rot_T.T)[:, 0])+ self.set_euler_angles(theta, phi, gamma)+ return self++ def set_euler_angles(self, theta=None, phi=None, gamma=None):+ if theta is not None:+ self.data["euler_angles"][0] = theta+ if phi is not None:+ self.data["euler_angles"][1] = phi+ if gamma is not None:+ self.data["euler_angles"][2] = gamma+ self.refresh_rotation_matrix()+ return self+ def set_theta(self, theta):+ return self.set_euler_angles(theta=theta)-class OpenGLCamera:- use_z_index = True- frame_rate = 60+ def set_phi(self, phi):+ return self.set_euler_angles(phi=phi)++ def set_gamma(self, gamma):+ return self.set_euler_angles(gamma=gamma)++ def increment_theta(self, dtheta):+ self.data["euler_angles"][0] += dtheta+ self.refresh_rotation_matrix()+ return self++ def increment_phi(self, dphi):+ phi = self.data["euler_angles"][1]+ new_phi = clip(phi + dphi, 0, PI)+ self.data["euler_angles"][1] = new_phi+ self.refresh_rotation_matrix()+ return self++ def increment_gamma(self, dgamma):+ self.data["euler_angles"][2] += dgamma+ self.refresh_rotation_matrix()+ return self++ def get_shape(self):+ return (self.get_width(), self.get_height())++ def get_center(self):+ # Assumes first point is at the center+ return self.get_points()[0]++ def get_width(self):+ points = self.get_points()+ return points[2, 0] - points[1, 0]++ def get_height(self):+ points = self.get_points()+ return points[4, 1] - points[3, 1]++ def get_focal_distance(self):+ return self.focal_distance * self.get_height()++ def interpolate(self, *args, **kwargs):+ super().interpolate(*args, **kwargs)+ self.refresh_rotation_matrix()points_per_curve = 3@@ -30,6 +178,9 @@ JOINT_TYPE_MAP = {class OpenGLRenderer:def __init__(self):+ # Measured in pixel widths, used for vector graphics+ self.anti_alias_width = 1.5+self.num_plays = 0self.skip_animations = False@@ -37,6 +188,7 @@ class OpenGLRenderer:self.camera = OpenGLCamera()+ # Initialize context.self.context = self.window.ctxself.context.enable(moderngl.BLEND)self.context.blend_func = (@@ -46,16 +198,44 @@ class OpenGLRenderer:moderngl.ONE,)self.frame_buffer_object = self.context.detect_framebuffer()++ # Initialize shader map.self.id_to_shader_program = {}+ # Initialize texture map.+ self.path_to_texture_id = {}+def update_depth_test(self, context, shader_wrapper):if shader_wrapper.depth_test:self.context.enable(moderngl.DEPTH_TEST)else:self.context.disable(moderngl.DEPTH_TEST)- def render_mobject(self, mobs):- # shader_wrapper_list = self.get_shader_wrapper_list(mob)+ def get_pixel_shape(self):+ return self.frame_buffer_object.viewport[2:4]+ # return (self.pixel_width, self.pixel_height)++ def refresh_perspective_uniforms(self, camera_frame):+ pw, ph = self.get_pixel_shape()+ fw, fh = camera_frame.get_shape()+ # TODO, this should probably be a mobject uniform, with+ # the camera taking care of the conversion factor+ anti_alias_width = self.anti_alias_width / (ph / fh)+ # Orient light+ rotation = camera_frame.inverse_camera_rotation_matrix+ light_pos = camera_frame.light_source.get_location()+ light_pos = np.dot(rotation, light_pos)++ self.perspective_uniforms = {+ "frame_shape": camera_frame.get_shape(),+ "anti_alias_width": anti_alias_width,+ "camera_center": tuple(camera_frame.get_center()),+ "camera_rotation": tuple(np.array(rotation).T.flatten()),+ "light_source_position": tuple(light_pos),+ "focal_distance": camera_frame.get_focal_distance(),+ }++ def render_mobjects(self, mobs):for mob in mobs:shader_wrapper_list = mob.get_shader_wrapper_list()render_group_list = map(@@ -76,91 +256,6 @@ class OpenGLRenderer:if render_group[key] is not None:render_group[key].release()- def read_data_to_shader(self, mob, shader_data, shader_data_key, data_key):- # Check data alignment.- d_len = len(mob.data[data_key])- if d_len != 1 and d_len != len(shader_data):- mob.data[data_key] = resize_with_interpolation(- mob.data[data_key], len(shader_data)- )-- shader_data[shader_data_key] = mob.data[data_key]-- def get_stroke_shader_data(self, mob):- points = mob.data["points"]- stroke_data = np.zeros(len(points), dtype=VMobject.stroke_dtype)-- stroke_data["point"] = points- stroke_data["prev_point"][:points_per_curve] = points[-points_per_curve:]- stroke_data["prev_point"][points_per_curve:] = points[:-points_per_curve]- stroke_data["next_point"][:-points_per_curve] = points[points_per_curve:]- stroke_data["next_point"][-points_per_curve:] = points[:points_per_curve]-- self.read_data_to_shader(mob, stroke_data, "color", "stroke_rgba")- self.read_data_to_shader(mob, stroke_data, "stroke_width", "stroke_width")- self.read_data_to_shader(mob, stroke_data, "unit_normal", "unit_normal")-- return stroke_data-- def get_fill_shader_data(self, mob):- points = mob.data["points"]- fill_data = np.zeros(len(points), dtype=VMobject.fill_dtype)- fill_data["vert_index"][:, 0] = range(len(points))-- self.read_data_to_shader(mob, fill_data, "point", "points")- self.read_data_to_shader(mob, fill_data, "color", "fill_rgba")- self.read_data_to_shader(mob, fill_data, "unit_normal", "unit_normal")-- return fill_data-- def get_stroke_shader_wrapper(self, mob):- return ShaderWrapper(- vert_data=self.get_stroke_shader_data(mob),- shader_folder="quadratic_bezier_stroke",- render_primitive=moderngl.TRIANGLES,- uniforms=self.get_stroke_uniforms(mob),- depth_test=mob.depth_test,- )-- def get_fill_shader_wrapper(self, mob):- return ShaderWrapper(- vert_data=self.get_fill_shader_data(mob),- vert_indices=self.get_triangulation(mob),- shader_folder="quadratic_bezier_fill",- render_primitive=moderngl.TRIANGLES,- uniforms=self.get_fill_uniforms(mob),- depth_test=mob.depth_test,- )-- def get_shader_wrapper_list(self, mob):- fill_shader_wrappers = []- stroke_shader_wrappers = []- back_stroke_shader_wrappers = []- if any(mob.data["fill_rgba"][:, 3]):- fill_shader_wrappers.append(self.get_fill_shader_wrapper(mob))- if any(mob.data["stroke_rgba"][:, 3]) and mob.data["stroke_width"][0]:- stroke_shader_wrapper = self.get_stroke_shader_wrapper(mob)- # TODO: Handle background_stroke- # if mob.draw_stroke_behind_fill:- # back_stroke_shader_wrappers.append(ssw)- # else:- stroke_shader_wrappers.append(stroke_shader_wrapper)-- # Combine data lists- wrapper_lists = [- back_stroke_shader_wrappers,- fill_shader_wrappers,- stroke_shader_wrappers,- ]-- result = []- for wrapper_list in wrapper_lists:- if wrapper_list:- wrapper = wrapper_list[0]- wrapper.combine_with(*wrapper_list[1:])- result.append(wrapper)- return result-def get_render_group(self, context, shader_wrapper, single_use=True):# Data buffersvertex_buffer_object = self.context.buffer(shader_wrapper.vert_data.tobytes())@@ -206,95 +301,35 @@ class OpenGLRenderer:self.id_to_shader_program[sid] = (program, vert_format)return self.id_to_shader_program[sid]- def get_triangulation(self, mob, 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 = mob.get_unit_normal()-- if not mob.needs_new_triangulation:- return mob.triangulation-- points = mob.data["points"]-- if len(points) <= 1:- mob.triangulation = np.zeros(0, dtype="i4")- mob.needs_new_triangulation = False- return mob.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 = mob.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])- mob.triangulation = tri_indices- mob.needs_new_triangulation = False- return tri_indices-- def get_stroke_uniforms(self, mob):- return dict(- **self.get_fill_uniforms(mob),- joint_type=JOINT_TYPE_MAP[mob.joint_type],- flat_stroke=float(mob.flat_stroke),- )-- def get_fill_uniforms(self, mob):- return dict(- is_fixed_in_frame=float(mob.is_fixed_in_frame),- gloss=mob.gloss,- shadow=mob.shadow,- )+ def get_texture_id(self, path):+ if path not in self.path_to_texture_id:+ # A way to increase tid's sequentially+ tid = len(self.path_to_texture_id)+ im = Image.open(path)+ texture = self.context.texture(+ size=im.size,+ components=len(im.getbands()),+ data=im.tobytes(),+ )+ texture.use(location=tid)+ self.path_to_texture_id[path] = tid+ return self.path_to_texture_id[path]def set_shader_uniforms(self, shader, shader_wrapper):- perspective_uniforms = {- "frame_shape": (14.222222222222221, 8.0),- "anti_alias_width": 0.016666666666666666,- "camera_center": (0.0, 0.0, 0.0),- "camera_rotation": (1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0),- "light_source_position": (-10.0, 10.0, 10.0),- "focal_distance": 16.0,- }-- # for name, path in shader_wrapper.texture_paths.items():- # tid = self.get_texture_id(path)- # shader[name].value = tid+ # perspective_uniforms = {+ # "frame_shape": (14.222222222222221, 8.0),+ # "anti_alias_width": 0.016666666666666666,+ # "camera_center": (0.0, 0.0, 0.0),+ # "camera_rotation": (1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0),+ # "light_source_position": (-10.0, 10.0, 10.0),+ # "focal_distance": 16.0,+ # }++ for name, path in shader_wrapper.texture_paths.items():+ tid = self.get_texture_id(path)+ shader[name].value = tidfor name, value in it.chain(- shader_wrapper.uniforms.items(), perspective_uniforms.items()+ shader_wrapper.uniforms.items(), self.perspective_uniforms.items()):try:shader[name].value = value@@ -319,7 +354,8 @@ class OpenGLRenderer:def render(self, scene, frame_offset, moving_mobjects):def update_frame():self.frame_buffer_object.clear(*window_background_color)- self.render_mobject(scene.mobjects)+ self.refresh_perspective_uniforms(scene.camera)+ self.render_mobjects(scene.mobjects)self.window.swap_buffers()self.animation_elapsed_time = time.time() - self.animation_start_timediff --git a/manim/utils/space_ops.py b/manim/utils/space_ops.pyindex 1d5e7e344..ecdcdf03c 100644--- a/manim/utils/space_ops.py+++ b/manim/utils/space_ops.py@@ -92,8 +92,13 @@ def quaternion_mult(*quats):)-def quaternion_from_angle_axis(angle, axis):- return np.append(np.cos(angle / 2), np.sin(angle / 2) * normalize(axis))+def quaternion_from_angle_axis(angle, axis, axis_normalized=False):+ if config["use_opengl_renderer"]:+ if not axis_normalized:+ axis = normalize(axis)+ return [math.cos(angle / 2), *(math.sin(angle / 2) * axis)]+ else:+ return np.append(np.cos(angle / 2), np.sin(angle / 2) * normalize(axis))def angle_axis_from_quaternion(quaternion):@@ -213,10 +218,13 @@ def angle_of_vector(vector):"""Returns polar coordinate theta when vector is project on xy plane"""- z = complex(*vector[:2])- if z == 0:- return 0- return np.angle(complex(*vector[:2]))+ if config["use_opengl_renderer"]:+ return np.angle(complex(*vector[:2]))+ else:+ z = complex(*vector[:2])+ if z == 0:+ return 0+ return np.angle(complex(*vector[:2]))def angle_between_vectors(v1, v2):