A community-maintained Python framework for creating mathematical animations.
Shader mobject (#1462)
Devin Neal684065fa9006
diff --git a/example_scenes/opengl.py b/example_scenes/opengl.pyindex 01689f3b1..1ca334bef 100644--- a/example_scenes/opengl.py+++ b/example_scenes/opengl.py@@ -1,6 +1,8 @@import osfrom pathlib import Path+import manim.utils.opengl as opengl+import manim.utils.space_ops as space_opsfrom manim import *from manim.opengl import *@@ -8,6 +10,324 @@ from manim.opengl import *# Lines that do not yet work with the Community Version are commented.+def get_plane_mesh(context):+ shader = Shader(context, name="vertex_colors")+ attributes = np.zeros(+ 18,+ dtype=[+ ("in_vert", np.float32, (4,)),+ ("in_color", np.float32, (4,)),+ ],+ )+ attributes["in_vert"] = np.array(+ [+ # xy plane+ [-1, -1, 0, 1],+ [-1, 1, 0, 1],+ [1, 1, 0, 1],+ [-1, -1, 0, 1],+ [1, -1, 0, 1],+ [1, 1, 0, 1],+ # yz plane+ [0, -1, -1, 1],+ [0, -1, 1, 1],+ [0, 1, 1, 1],+ [0, -1, -1, 1],+ [0, 1, -1, 1],+ [0, 1, 1, 1],+ # xz plane+ [-1, 0, -1, 1],+ [-1, 0, 1, 1],+ [1, 0, 1, 1],+ [-1, 0, -1, 1],+ [1, 0, -1, 1],+ [1, 0, 1, 1],+ ]+ )+ attributes["in_color"] = np.array(+ [+ # xy plane+ [1, 0, 0, 1],+ [1, 0, 0, 1],+ [1, 0, 0, 1],+ [1, 0, 0, 1],+ [1, 0, 0, 1],+ [1, 0, 0, 1],+ # yz plane+ [0, 1, 0, 1],+ [0, 1, 0, 1],+ [0, 1, 0, 1],+ [0, 1, 0, 1],+ [0, 1, 0, 1],+ [0, 1, 0, 1],+ # xz plane+ [0, 0, 1, 1],+ [0, 0, 1, 1],+ [0, 0, 1, 1],+ [0, 0, 1, 1],+ [0, 0, 1, 1],+ [0, 0, 1, 1],+ ]+ )+ return Mesh(shader, attributes)+++class ThreeDMobjectTest(Scene):+ def construct(self):+ # config["background_color"] = "#333333"++ s = OpenGLSquare(fill_opacity=0.5).shift(2 * RIGHT)+ self.add(s)++ sp = OpenGLSphere().shift(2 * LEFT)+ self.add(sp)++ mesh = get_plane_mesh(self.renderer.context)+ self.add(mesh)++ def update_mesh(mesh, dt):+ mesh.model_matrix = np.matmul(+ opengl.rotation_matrix(z=dt), mesh.model_matrix+ )++ mesh.add_updater(update_mesh)++ self.interactive_embed()+++class NamedFullScreenQuad(Scene):+ def construct(self):+ surface = FullScreenQuad(self.renderer.context, fragment_shader_name="design_3")+ surface.shader.set_uniform("u_resolution", (854.0, 480.0, 0.0))+ surface.shader.set_uniform("u_time", 0)+ self.add(surface)++ t = 0++ def update_surface(surface, dt):+ nonlocal t+ t += dt+ surface.shader.set_uniform("u_time", t / 4)++ surface.add_updater(update_surface)++ # self.wait()+ self.interactive_embed()+++class InlineFullScreenQuad(Scene):+ def construct(self):+ surface = FullScreenQuad(+ self.renderer.context,+ """+ #version 330+++ #define TWO_PI 6.28318530718++ uniform vec2 u_resolution;+ uniform float u_time;++ // Function from Iñigo Quiles+ // https://www.shadertoy.com/view/MsS3Wc+ vec3 hsb2rgb( in vec3 c ){+ vec3 rgb = clamp(abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),+ 6.0)-3.0)-1.0,+ 0.0,+ 1.0 );+ rgb = rgb*rgb*(3.0-2.0*rgb);+ return c.z * mix( vec3(1.0), rgb, c.y);+ }++ void main(){+ vec2 st = gl_FragCoord.xy/u_resolution;+ vec3 color = vec3(0.0);++ // Use polar coordinates instead of cartesian+ vec2 toCenter = vec2(0.5)-st;+ float angle = atan(toCenter.y,toCenter.x);+ angle += u_time;+ float radius = length(toCenter)*2.0;++ // Map the angle (-PI to PI) to the Hue (from 0 to 1)+ // and the Saturation to the radius+ color = hsb2rgb(vec3((angle/TWO_PI)+0.5,radius,1.0));++ gl_FragColor = vec4(color,1.0);+ }+ """,+ output_color_variable="gl_FragColor",+ )+ surface.shader.set_uniform("u_resolution", (854.0, 480.0))+ shader_time = 0++ def update_surface(surface):+ nonlocal shader_time+ surface.shader.set_uniform("u_time", shader_time)+ shader_time += 1 / 60.0++ surface.add_updater(update_surface)+ self.add(surface)+ # self.wait(5)+ self.interactive_embed()+++class SimpleInlineFullScreenQuad(Scene):+ def construct(self):+ surface = FullScreenQuad(+ self.renderer.context,+ """+ #version 330++ uniform float v_red;+ uniform float v_green;+ uniform float v_blue;++ void main() {+ frag_color = vec4(v_red, v_green, v_blue, 1);+ }+ """,+ )+ surface.shader.set_uniform("v_red", 0)+ surface.shader.set_uniform("v_green", 0)+ surface.shader.set_uniform("v_blue", 0)++ increase = True+ val = 0.5+ surface.shader.set_uniform("v_red", val)+ surface.shader.set_uniform("v_green", val)+ surface.shader.set_uniform("v_blue", val)++ def update_surface(mesh, dt):+ nonlocal increase+ nonlocal val+ if increase:+ val += dt+ else:+ val -= dt+ if val >= 1:+ increase = False+ elif val <= 0:+ increase = True+ surface.shader.set_uniform("v_red", val)+ surface.shader.set_uniform("v_green", val)+ surface.shader.set_uniform("v_blue", val)++ surface.add_updater(update_surface)++ self.add(surface)+ self.wait(5)+++class InlineShaderExample(Scene):+ def construct(self):+ config["background_color"] = "#333333"++ c = OpenGLCircle(fill_opacity=0.7).shift(UL)+ self.add(c)++ shader = Shader(+ self.renderer.context,+ source=dict(+ vertex_shader="""+ #version 330++ in vec4 in_vert;+ in vec4 in_color;+ out vec4 v_color;+ uniform mat4 u_model_view_matrix;+ uniform mat4 u_projection_matrix;++ void main() {+ v_color = in_color;+ vec4 camera_space_vertex = u_model_view_matrix * in_vert;+ vec4 clip_space_vertex = u_projection_matrix * camera_space_vertex;+ gl_Position = clip_space_vertex;+ }+ """,+ fragment_shader="""+ #version 330++ in vec4 v_color;+ out vec4 frag_color;++ void main() {+ frag_color = v_color;+ }+ """,+ ),+ )+ shader.set_uniform("u_model_view_matrix", opengl.view_matrix())+ shader.set_uniform(+ "u_projection_matrix", opengl.orthographic_projection_matrix()+ )++ attributes = np.zeros(+ 6,+ dtype=[+ ("in_vert", np.float32, (4,)),+ ("in_color", np.float32, (4,)),+ ],+ )+ attributes["in_vert"] = np.array(+ [+ [-1, -1, 0, 1],+ [-1, 1, 0, 1],+ [1, 1, 0, 1],+ [-1, -1, 0, 1],+ [1, -1, 0, 1],+ [1, 1, 0, 1],+ ]+ )+ attributes["in_color"] = np.array(+ [+ [0, 0, 1, 1],+ [0, 0, 1, 1],+ [0, 0, 1, 1],+ [0, 0, 1, 1],+ [0, 0, 1, 1],+ [0, 0, 1, 1],+ ]+ )+ mesh = Mesh(shader, attributes)+ self.add(mesh)++ self.wait(5)+ # self.embed_2()+++class NamedShaderExample(Scene):+ def construct(self):+ shader = Shader(self.renderer.context, "manim_coords")+ shader.set_uniform("u_color", (0.0, 1.0, 0.0, 1.0))++ view_matrix = self.camera.get_view_matrix()+ shader.set_uniform("u_model_view_matrix", view_matrix)+ shader.set_uniform(+ "u_projection_matrix", opengl.perspective_projection_matrix()+ )+ attributes = np.zeros(+ 6,+ dtype=[+ ("in_vert", np.float32, (4,)),+ ],+ )+ attributes["in_vert"] = np.array(+ [+ [-1, -1, 0, 1],+ [-1, 1, 0, 1],+ [1, 1, 0, 1],+ [-1, -1, 0, 1],+ [1, -1, 0, 1],+ [1, 1, 0, 1],+ ]+ )+ mesh = Mesh(shader, attributes)+ self.add(mesh)++ self.wait(5)++class InteractiveDevelopment(Scene):def construct(self):circle = OpenGLCircle()diff --git a/manim/cli/render/commands.py b/manim/cli/render/commands.pyindex 7ef24943d..97de34353 100644--- a/manim/cli/render/commands.py+++ b/manim/cli/render/commands.py@@ -16,7 +16,6 @@ import requestsfrom ... import __version__, config, console, loggerfrom ...constants import CONTEXT_SETTINGS, EPILOG-from ...utils.exceptions import RerunSceneExceptionfrom ...utils.module_ops import scene_classes_from_filefrom .ease_of_access_options import ease_of_access_optionsfrom .global_options import global_optionsdiff --git a/manim/opengl/__init__.py b/manim/opengl/__init__.pyindex 6dbdf520f..5f9f7b250 100644--- a/manim/opengl/__init__.py+++ b/manim/opengl/__init__.py@@ -6,3 +6,4 @@ from ..mobject.svg.opengl_tex_mobject import *from ..mobject.svg.opengl_text_mobject import *from ..mobject.types.opengl_surface import *from ..mobject.types.opengl_vectorized_mobject import *+from ..renderer.shader import *diff --git a/manim/renderer/opengl_renderer.py b/manim/renderer/opengl_renderer.pyindex d2e542b46..d752463a1 100644--- a/manim/renderer/opengl_renderer.py+++ b/manim/renderer/opengl_renderer.py@@ -11,10 +11,10 @@ from manim.utils.caching import handle_caching_playfrom manim.utils.color import color_to_rgbafrom manim.utils.exceptions import EndSceneEarlyException-from .. import loggerfrom ..constants import *from ..mobject.opengl_mobject import OpenGLMobject, OpenGLPointfrom ..scene.scene_file_writer import SceneFileWriter+from ..utils import openglfrom ..utils.simple_functions import clipfrom ..utils.space_ops import (angle_of_vector,@@ -24,6 +24,7 @@ from ..utils.space_ops import (rotation_matrix_transpose_from_quaternion,)from .opengl_renderer_window import Window+from .shader import Mesh, Shaderclass OpenGLCamera(OpenGLMobject):@@ -63,8 +64,19 @@ class OpenGLCamera(OpenGLMobject):self.light_source_position = light_source_positionself.light_source = OpenGLPoint(self.light_source_position)+ self.model_matrix = opengl.translation_matrix(0, 0, 11)+super().__init__(**kwargs)+ def get_position(self):+ return self.model_matrix[:, 3][:3]++ def get_view_matrix(self, format=True):+ if format:+ return opengl.matrix_to_shader_input(np.linalg.inv(self.model_matrix))+ else:+ return np.linalg.inv(self.model_matrix)+def init_data(self):super().init_data()self.data["euler_angles"] = np.array(self.euler_angles, dtype=float)@@ -81,6 +93,7 @@ class OpenGLCamera(OpenGLMobject):self.set_height(config["frame_height"])self.set_width(config["frame_width"])self.set_euler_angles(0, 0, 0)+ self.model_matrix = opengl.translation_matrix(0, 0, 11)return selfdef refresh_rotation_matrix(self):@@ -134,7 +147,7 @@ class OpenGLCamera(OpenGLMobject):def increment_phi(self, dphi):phi = self.data["euler_angles"][1]- new_phi = clip(phi + dphi, 0, PI)+ new_phi = clip(phi + dphi, -PI / 2, PI / 2)self.data["euler_angles"][1] = new_phiself.refresh_rotation_matrix()return self@@ -189,9 +202,6 @@ class OpenGLRenderer:self.camera = OpenGLCamera()self.pressed_keys = set()- # Initialize shader map.- self.id_to_shader_program = {}-# Initialize texture map.self.path_to_texture_id = {}@@ -220,12 +230,6 @@ class OpenGLRenderer:moderngl.ONE,)- 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 get_pixel_shape(self):return self.frame_buffer_object.viewport[2:4]@@ -249,73 +253,48 @@ class OpenGLRenderer:"focal_distance": camera.get_focal_distance(),}- def render_mobjects(self, mobs):- for mob in mobs:- shader_wrapper_list = mob.get_shader_wrapper_list()- render_group_list = map(- lambda shader_wrapper: self.get_render_group(- self.context, shader_wrapper- ),- shader_wrapper_list,- )- for render_group in render_group_list:- self.render_render_group(render_group)-- def render_render_group(self, render_group):- shader_wrapper = render_group["shader_wrapper"]- self.set_shader_uniforms(render_group["prog"], render_group["shader_wrapper"])- self.update_depth_test(self.context, shader_wrapper)- render_group["vao"].render(int(shader_wrapper.render_primitive))-- if render_group["single_use"]:- for key in ["vbo", "ibo", "vao"]:- if render_group[key] is not None:- render_group[key].release()-- def get_render_group(self, context, shader_wrapper, single_use=True):- # Data buffers- vertex_buffer_object = self.context.buffer(shader_wrapper.vert_data.tobytes())- if shader_wrapper.vert_indices is None:- index_buffer_object = None- else:- vert_index_data = shader_wrapper.vert_indices.astype("i4").tobytes()- if vert_index_data:- index_buffer_object = self.context.buffer(vert_index_data)- else:- index_buffer_object = None-- # Program and vertex array- shader_program, vert_format = self.get_shader_program(- self.context, shader_wrapper- )- vertex_array_object = self.context.vertex_array(- program=shader_program,- content=[- (vertex_buffer_object, vert_format, *shader_wrapper.vert_attributes)- ],- index_buffer=index_buffer_object,- )- return {- "vbo": vertex_buffer_object,- "ibo": index_buffer_object,- "vao": vertex_array_object,- "prog": shader_program,- "shader_wrapper": shader_wrapper,- "single_use": single_use,- }+ def render_mobject(self, mobject):+ shader_wrapper_list = mobject.get_shader_wrapper_list()++ # Convert ShaderWrappers to Meshes.+ for shader_wrapper in shader_wrapper_list:+ shader = Shader(self.context, shader_wrapper.shader_folder)++ # Set textures.+ for name, path in shader_wrapper.texture_paths.items():+ tid = self.get_texture_id(path)+ shader.shader_program[name].value = tid++ # Set uniforms.+ for name, value in it.chain(+ shader_wrapper.uniforms.items(), self.perspective_uniforms.items()+ ):+ try:+ shader.set_uniform(name, value)+ except KeyError:+ pass+ try:+ shader.set_uniform("u_view_matrix", self.scene.camera.get_view_matrix())+ shader.set_uniform(+ "u_projection_matrix", opengl.orthographic_projection_matrix()+ )+ except KeyError:+ pass- def get_shader_program(self, context, shader_wrapper):- sid = shader_wrapper.get_program_id()- if sid not in self.id_to_shader_program:- # Create shader program for the first time, then cache- # in self.id_to_shader_program.- program_code = shader_wrapper.get_program_code()- program = self.context.program(**program_code)- vert_format = moderngl.detect_format(- program, shader_wrapper.vert_attributes+ # Set depth test.+ if shader_wrapper.depth_test:+ self.context.enable(moderngl.DEPTH_TEST)+ else:+ self.context.disable(moderngl.DEPTH_TEST)++ # Render.+ mesh = Mesh(+ shader,+ shader_wrapper.vert_data,+ indices=shader_wrapper.vert_indices,+ use_depth_test=shader_wrapper.depth_test,)- self.id_to_shader_program[sid] = (program, vert_format)- return self.id_to_shader_program[sid]+ mesh.render()def get_texture_id(self, path):if path not in self.path_to_texture_id:@@ -331,27 +310,6 @@ class OpenGLRenderer:self.path_to_texture_id[path] = tidreturn 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- for name, value in it.chain(- shader_wrapper.uniforms.items(), self.perspective_uniforms.items()- ):- try:- shader[name].value = value- except KeyError:- pass-def update_skipping_status(self):"""This method is used internally to check if the current@@ -385,7 +343,21 @@ class OpenGLRenderer:def update_frame():self.frame_buffer_object.clear(*window_background_color)self.refresh_perspective_uniforms(scene.camera)- self.render_mobjects(scene.mobjects)++ for mobject in scene.mobjects:+ self.render_mobject(mobject)++ view_matrix = scene.camera.get_view_matrix()+ for mesh in scene.meshes:+ try:+ mesh.shader.set_uniform("u_view_matrix", view_matrix)+ mesh.shader.set_uniform(+ "u_projection_matrix", opengl.perspective_projection_matrix()+ )+ except KeyError:+ pass+ mesh.render()+self.animation_elapsed_time = time.time() - self.animation_start_timewindow_background_color = color_to_rgba(config["background_color"])diff --git a/manim/renderer/shader.py b/manim/renderer/shader.pynew file mode 100644index 000000000..c7b6c422c--- /dev/null+++ b/manim/renderer/shader.py@@ -0,0 +1,265 @@+import os+import re+import textwrap+from pathlib import Path++import moderngl+import numpy as np++from .. import config+from ..utils import opengl+from ..utils.simple_functions import get_parameters++SHADER_FOLDER = Path(__file__).parent / "shaders"+shader_program_cache = {}+file_path_to_code_map = {}+++def get_shader_code_from_file(file_path):+ if file_path in file_path_to_code_map:+ return file_path_to_code_map[file_path]+ with open(file_path, "r") as f:+ source = f.read()+ include_lines = re.finditer(+ r"^#include (?P<include_path>.*\.glsl)$", source, flags=re.MULTILINE+ )+ for match in include_lines:+ include_path = match.group("include_path")+ included_code = get_shader_code_from_file(+ os.path.join(file_path.parent / include_path)+ )+ source = source.replace(match.group(0), included_code)+ file_path_to_code_map[file_path] = source+ return source+++class Mesh:+ def __init__(self, shader, attributes, indices=None, use_depth_test=True):+ self.shader = shader+ self.attributes = attributes+ self.indices = indices+ self.use_depth_test = use_depth_test+ self.init_updaters()++ self.translation = np.zeros(3)+ self.rotation = np.zeros(3)+ self.scale = np.zeros(3)+ self.model_matrix = np.eye(4)+ self.model_matrix_needs_update = False++ def render(self):+ # Set matrix uniforms.+ if self.model_matrix_needs_update:+ pass+ try:+ self.shader.set_uniform(+ "u_model_matrix", opengl.matrix_to_shader_input(self.model_matrix)+ )+ except KeyError:+ pass++ if self.use_depth_test:+ self.shader.context.enable(moderngl.DEPTH_TEST)++ vertex_buffer_object = self.shader.context.buffer(self.attributes.tobytes())+ if self.indices is None:+ index_buffer_object = None+ else:+ vert_index_data = self.indices.astype("i4").tobytes()+ if vert_index_data:+ index_buffer_object = self.shader.context.buffer(vert_index_data)+ else:+ index_buffer_object = None+ vertex_array_object = self.shader.context.simple_vertex_array(+ self.shader.shader_program,+ vertex_buffer_object,+ *self.attributes.dtype.names,+ index_buffer=index_buffer_object,+ )+ vertex_array_object.render(moderngl.TRIANGLES)+ vertex_buffer_object.release()+ vertex_array_object.release()+ if index_buffer_object is not None:+ index_buffer_object.release()++ 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):+ 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)+ 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 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):+ self.time_based_updaters = []+ self.non_time_updaters = []+ self.refresh_has_updater_status()+ 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):+ self.updating_suspended = True+ return self++ def resume_updating(self, call_updater=True):+ self.updating_suspended = False+ if call_updater:+ self.update(dt=0)+ return self++ def refresh_has_updater_status(self):+ self.has_updaters = len(self.get_updaters()) > 0+ return self+++class Shader:+ def __init__(+ self,+ context,+ name=None,+ source=None,+ ):+ self.context = context+ self.name = name++ # See if the program is cached.+ if self.name in shader_program_cache:+ self.shader_program = shader_program_cache[self.name]++ # Generate the shader from inline code if it was passed.+ if source is not None:+ self.shader_program = context.program(**source)+ else:+ # Search for a file containing the shader.+ source_dict = {}+ source_dict_key = {+ "vert": "vertex_shader",+ "frag": "fragment_shader",+ "geom": "geometry_shader",+ }+ shader_folder = SHADER_FOLDER / name+ for shader_file in shader_folder.iterdir():+ shader_file_path = shader_folder / shader_file+ shader_source = get_shader_code_from_file(shader_file_path)+ source_dict[source_dict_key[shader_file_path.stem]] = shader_source+ self.shader_program = context.program(**source_dict)++ # Cache the shader.+ if name is not None:+ shader_program_cache[self.name] = self.shader_program++ def set_uniform(self, name, value):+ self.shader_program[name] = value+++class FullScreenQuad(Mesh):+ def __init__(+ self,+ context,+ fragment_shader_source=None,+ fragment_shader_name=None,+ output_color_variable="frag_color",+ ):+ if fragment_shader_source is None and fragment_shader_name is None:+ raise Exception("Must either pass shader name or shader source.")++ if fragment_shader_name is not None:+ # Use the name.+ shader_file_path = SHADER_FOLDER / f"{fragment_shader_name}.frag"+ fragment_shader_source = get_shader_code_from_file(shader_file_path)+ elif fragment_shader_source is not None:+ fragment_shader_source = textwrap.dedent(fragment_shader_source.lstrip())+ fragment_shader_lines = fragment_shader_source.split("\n")++ # If the first line is a version string, insert after it.+ insertion_index = 0+ if fragment_shader_lines[0].startswith("#version"):+ insertion_index += 1+ fragment_shader_lines.insert(+ insertion_index,+ f"out vec4 {output_color_variable};",+ )+ fragment_shader_source = "\n".join(fragment_shader_lines)++ shader = Shader(+ context,+ source=dict(+ vertex_shader="""+ #version 330++ in vec4 in_vert;+ uniform mat4 u_model_view_matrix;+ uniform mat4 u_projection_matrix;++ void main() {{+ vec4 camera_space_vertex = u_model_view_matrix * in_vert;+ vec4 clip_space_vertex = u_projection_matrix * camera_space_vertex;+ gl_Position = clip_space_vertex;+ }}+ """,+ fragment_shader=fragment_shader_source,+ ),+ )+ shader.set_uniform("u_model_view_matrix", opengl.view_matrix())+ shader.set_uniform(+ "u_projection_matrix", opengl.orthographic_projection_matrix()+ )+ super().__init__(shader, None)++ def render(self):+ self.attributes = np.zeros(6, dtype=[("in_vert", np.float32, (4,))])+ self.attributes["in_vert"] = np.array(+ [+ [-config["frame_x_radius"], -config["frame_y_radius"], 0, 1],+ [-config["frame_x_radius"], config["frame_y_radius"], 0, 1],+ [config["frame_x_radius"], config["frame_y_radius"], 0, 1],+ [-config["frame_x_radius"], -config["frame_y_radius"], 0, 1],+ [config["frame_x_radius"], -config["frame_y_radius"], 0, 1],+ [config["frame_x_radius"], config["frame_y_radius"], 0, 1],+ ],+ )+ super().render()diff --git a/manim/renderer/shader_wrapper.py b/manim/renderer/shader_wrapper.pyindex 208bcd97e..30ccf17c1 100644--- a/manim/renderer/shader_wrapper.py+++ b/manim/renderer/shader_wrapper.py@@ -181,10 +181,12 @@ def get_shader_code_from_file(filename):# from other files an inserted into the relevant strings before# passing to ctx.program for compiling# Replace "#INSERT " lines with relevant code- insertions = re.findall(r"^#INSERT .*\.glsl$", result, flags=re.MULTILINE)+ insertions = re.findall(+ r"^#include ../include/.*\.glsl$", result, flags=re.MULTILINE+ )for line in insertions:inserted_code = get_shader_code_from_file(- os.path.join("inserts", line.replace("#INSERT ", ""))+ os.path.join("inserts", line.replace("#include ../include/", "")))result = result.replace(line, inserted_code)filename_to_code_map[filename] = resultdiff --git a/manim/renderer/shaders/default/frag.glsl b/manim/renderer/shaders/default/frag.glslnew file mode 100644index 000000000..2a721a51e--- /dev/null+++ b/manim/renderer/shaders/default/frag.glsl@@ -0,0 +1,8 @@+#version 330++uniform vec4 u_color;+out vec4 frag_color;++void main() {+ frag_color = u_color;+}diff --git a/manim/renderer/shaders/default/vert.glsl b/manim/renderer/shaders/default/vert.glslnew file mode 100644index 000000000..b261193e4--- /dev/null+++ b/manim/renderer/shaders/default/vert.glsl@@ -0,0 +1,10 @@+#version 330++in vec4 in_vert;+uniform mat4 u_model_matrix;+uniform mat4 u_view_matrix;+uniform mat4 u_projection_matrix;++void main() {+ gl_Position = u_projection_matrix * u_view_matrix * u_model_matrix * in_vert;+}diff --git a/manim/renderer/shaders/design.frag b/manim/renderer/shaders/design.fragnew file mode 100644index 000000000..e84e3984a--- /dev/null+++ b/manim/renderer/shaders/design.frag@@ -0,0 +1,15 @@+#version 330++out vec4 frag_color;++void main() {+ vec2 st = gl_FragCoord.xy / vec2(854, 360);+ vec3 color = vec3(0.0);++ st *= 3.0;+ st = fract(st);++ color = vec3(st, 0.0);++ frag_color = vec4(color, 1.0);+}diff --git a/manim/renderer/shaders/design_2.frag b/manim/renderer/shaders/design_2.fragnew file mode 100644index 000000000..02c91490d--- /dev/null+++ b/manim/renderer/shaders/design_2.frag@@ -0,0 +1,45 @@+#version 330++uniform vec2 u_resolution;+out vec4 frag_color;+++#define PI 3.14159265358979323846++vec2 rotate2D(vec2 _st, float _angle){+ _st -= 0.5;+ _st = mat2(cos(_angle),-sin(_angle),+ sin(_angle),cos(_angle)) * _st;+ _st += 0.5;+ return _st;+}++vec2 tile(vec2 _st, float _zoom){+ _st *= _zoom;+ return fract(_st);+}++float box(vec2 _st, vec2 _size, float _smoothEdges){+ _size = vec2(0.5)-_size*0.5;+ vec2 aa = vec2(_smoothEdges*0.5);+ vec2 uv = smoothstep(_size,_size+aa,_st);+ uv *= smoothstep(_size,_size+aa,vec2(1.0)-_st);+ return uv.x*uv.y;+}++void main(void){+ vec2 st = gl_FragCoord.xy/u_resolution.xy;+ vec3 color = vec3(0.0);++ // Divide the space in 4+ st = tile(st,4.);++ // Use a matrix to rotate the space 45 degrees+ st = rotate2D(st,PI*0.25);++ // Draw a square+ color = vec3(box(st,vec2(0.7),0.01));+ // color = vec3(st,0.0);++ frag_color = vec4(color,1.0);+}diff --git a/manim/renderer/shaders/design_3.frag b/manim/renderer/shaders/design_3.fragnew file mode 100644index 000000000..6a0e601c7--- /dev/null+++ b/manim/renderer/shaders/design_3.frag@@ -0,0 +1,59 @@+#version 330++uniform vec3 u_resolution;+uniform float u_time;+out vec4 frag_color;++vec3 palette(float d){+ return mix(vec3(0.2,0.7,0.9),vec3(1.,0.,1.),d);+}++vec2 rotate(vec2 p,float a){+ float c = cos(a);+ float s = sin(a);+ return p*mat2(c,s,-s,c);+}++float map(vec3 p){+ for( int i = 0; i<8; ++i){+ float t = u_time*0.1;+ p.xz =rotate(p.xz,t);+ p.xy =rotate(p.xy,t*1.89);+ p.xz = abs(p.xz);+ p.xz-=.5;+ }+ return dot(sign(p),p)/5.;+}++vec4 rm (vec3 ro, vec3 rd){+ float t = 0.;+ vec3 col = vec3(0.);+ float d;+ for(float i =0.; i<64.; i++){+ vec3 p = ro + rd*t;+ d = map(p)*.5;+ if(d<0.02){+ break;+ }+ if(d>100.){+ break;+ }+ //col+=vec3(0.6,0.8,0.8)/(400.*(d));+ col+=palette(length(p)*.1)/(400.*(d));+ t+=d;+ }+ return vec4(col,1./(d*100.));+}++void main(void){+ vec2 uv = (gl_FragCoord.xy-(u_resolution.xy/2.))/u_resolution.x;+ vec3 ro = vec3(0.,0.,-50.);+ ro.xz = rotate(ro.xz,u_time);+ vec3 cf = normalize(-ro);+ vec3 cs = normalize(cross(cf,vec3(0.,1.,0.)));+ vec3 cu = normalize(cross(cf,cs));+ vec3 uuv = ro+cf*3. + uv.x*cs + uv.y*cu;+ vec3 rd = normalize(uuv-ro);+ vec4 col = rm(ro,rd);+ frag_color = vec4(col.xyz, 1);+}diff --git a/manim/renderer/shaders/image/vert.glsl b/manim/renderer/shaders/image/vert.glslindex f27efe300..aaaae6bff 100644--- a/manim/renderer/shaders/image/vert.glsl+++ b/manim/renderer/shaders/image/vert.glsl@@ -1,6 +1,6 @@#version 330-#INSERT camera_uniform_declarations.glsl+#include ../include/camera_uniform_declarations.glsluniform sampler2D Texture;@@ -12,8 +12,8 @@ out vec2 v_im_coords;out float v_opacity;// Analog of import for manim only-#INSERT get_gl_Position.glsl-#INSERT position_point_into_frame.glsl+#include ../include/get_gl_Position.glsl+#include ../include/position_point_into_frame.glslvoid main(){v_im_coords = im_coords;diff --git a/manim/renderer/shaders/include/NOTE.md b/manim/renderer/shaders/include/NOTE.mdnew file mode 100644index 000000000..45f0c1388--- /dev/null+++ b/manim/renderer/shaders/include/NOTE.md@@ -0,0 +1,7 @@+There seems to be no analog to #include in C++ for OpenGL shaders. While there are other options for sharing code between shaders, a lot of them aren't great, especially if the goal is to have all the logic for which specific bits of code to share handled in the shader file itself. So the way manim currently works is to replace any line which looks like++#INSERT <file_name>++with the code from one of the files in this folder.++The functions in this file often include reference to uniforms which are assumed to be part of the surrounding context into which they are inserted.diff --git a/manim/renderer/shaders/include/add_light.glsl b/manim/renderer/shaders/include/add_light.glslnew file mode 100644index 000000000..f0f32c8d9--- /dev/null+++ b/manim/renderer/shaders/include/add_light.glsl@@ -0,0 +1,43 @@+///// INSERT COLOR_MAP FUNCTION HERE /////++vec4 add_light(vec4 color,+ vec3 point,+ vec3 unit_normal,+ vec3 light_coords,+ float gloss,+ float shadow){+ ///// INSERT COLOR FUNCTION HERE /////+ // The line above may be replaced by arbitrary code snippets, as per+ // the method Mobject.set_color_by_code+ if(gloss == 0.0 && shadow == 0.0) return color;++ // TODO, do we actually want this? It effectively treats surfaces as two-sided+ if(unit_normal.z < 0){+ unit_normal *= -1;+ }++ // TODO, read this in as a uniform?+ float camera_distance = 6;+ // Assume everything has already been rotated such that camera is in the z-direction+ vec3 to_camera = vec3(0, 0, camera_distance) - point;+ vec3 to_light = light_coords - point;+ vec3 light_reflection = -to_light + 2 * unit_normal * dot(to_light, unit_normal);+ float dot_prod = dot(normalize(light_reflection), normalize(to_camera));+ float shine = gloss * exp(-3 * pow(1 - dot_prod, 2));+ float dp2 = dot(normalize(to_light), unit_normal);+ float darkening = mix(1, max(dp2, 0), shadow);+ return vec4(+ darkening * mix(color.rgb, vec3(1.0), shine),+ color.a+ );+}++vec4 finalize_color(vec4 color,+ vec3 point,+ vec3 unit_normal,+ vec3 light_coords,+ float gloss,+ float shadow){+ // Put insertion here instead+ return add_light(color, point, unit_normal, light_coords, gloss, shadow);+}diff --git a/manim/renderer/shaders/include/camera_uniform_declarations.glsl b/manim/renderer/shaders/include/camera_uniform_declarations.glslnew file mode 100644index 000000000..fdeacab85--- /dev/null+++ b/manim/renderer/shaders/include/camera_uniform_declarations.glsl@@ -0,0 +1,6 @@+uniform vec2 frame_shape;+uniform float anti_alias_width;+uniform vec3 camera_center;+uniform mat3 camera_rotation;+uniform float is_fixed_in_frame;+uniform float focal_distance;diff --git a/manim/renderer/shaders/include/finalize_color.glsl b/manim/renderer/shaders/include/finalize_color.glslnew file mode 100644index 000000000..7324fc155--- /dev/null+++ b/manim/renderer/shaders/include/finalize_color.glsl@@ -0,0 +1,51 @@+vec3 float_to_color(float value, float min_val, float max_val, vec3[9] colormap_data){+ float alpha = clamp((value - min_val) / (max_val - min_val), 0.0, 1.0);+ int disc_alpha = min(int(alpha * 8), 7);+ return mix(+ colormap_data[disc_alpha],+ colormap_data[disc_alpha + 1],+ 8.0 * alpha - disc_alpha+ );+}+++vec4 add_light(vec4 color,+ vec3 point,+ vec3 unit_normal,+ vec3 light_coords,+ float gloss,+ float shadow){+ if(gloss == 0.0 && shadow == 0.0) return color;++ // TODO, do we actually want this? It effectively treats surfaces as two-sided+ if(unit_normal.z < 0){+ unit_normal *= -1;+ }++ // TODO, read this in as a uniform?+ float camera_distance = 6;+ // Assume everything has already been rotated such that camera is in the z-direction+ vec3 to_camera = vec3(0, 0, camera_distance) - point;+ vec3 to_light = light_coords - point;+ vec3 light_reflection = -to_light + 2 * unit_normal * dot(to_light, unit_normal);+ float dot_prod = dot(normalize(light_reflection), normalize(to_camera));+ float shine = gloss * exp(-3 * pow(1 - dot_prod, 2));+ float dp2 = dot(normalize(to_light), unit_normal);+ float darkening = mix(1, max(dp2, 0), shadow);+ return vec4(+ darkening * mix(color.rgb, vec3(1.0), shine),+ color.a+ );+}++vec4 finalize_color(vec4 color,+ vec3 point,+ vec3 unit_normal,+ vec3 light_coords,+ float gloss,+ float shadow){+ ///// INSERT COLOR FUNCTION HERE /////+ // The line above may be replaced by arbitrary code snippets, as per+ // the method Mobject.set_color_by_code+ return add_light(color, point, unit_normal, light_coords, gloss, shadow);+}diff --git a/manim/renderer/shaders/include/get_gl_Position.glsl b/manim/renderer/shaders/include/get_gl_Position.glslnew file mode 100644index 000000000..95d3f054b--- /dev/null+++ b/manim/renderer/shaders/include/get_gl_Position.glsl@@ -0,0 +1,31 @@+// Assumes the following uniforms exist in the surrounding context:+// uniform vec2 frame_shape;+// uniform float focal_distance;+// uniform float is_fixed_in_frame;++const vec2 DEFAULT_FRAME_SHAPE = vec2(8.0 * 16.0 / 9.0, 8.0);++float perspective_scale_factor(float z, float focal_distance){+ return max(0.0, focal_distance / (focal_distance - z));+}+++vec4 get_gl_Position(vec3 point){+ vec4 result = vec4(point, 1.0);+ if(!bool(is_fixed_in_frame)){+ result.x *= 2.0 / frame_shape.x;+ result.y *= 2.0 / frame_shape.y;+ float psf = perspective_scale_factor(result.z, focal_distance);+ if (psf > 0){+ result.xy *= psf;+ // TODO, what's the better way to do this?+ // This is to keep vertices too far out of frame from getting cut.+ result.z *= 0.01;+ }+ } else{+ result.x *= 2.0 / DEFAULT_FRAME_SHAPE.x;+ result.y *= 2.0 / DEFAULT_FRAME_SHAPE.y;+ }+ result.z *= -1;+ return result;+}diff --git a/manim/renderer/shaders/include/get_rotated_surface_unit_normal_vector.glsl b/manim/renderer/shaders/include/get_rotated_surface_unit_normal_vector.glslnew file mode 100644index 000000000..8c6350d7a--- /dev/null+++ b/manim/renderer/shaders/include/get_rotated_surface_unit_normal_vector.glsl@@ -0,0 +1,16 @@+// Assumes the following uniforms exist in the surrounding context:+// uniform vec3 camera_center;+// uniform mat3 camera_rotation;++vec3 get_rotated_surface_unit_normal_vector(vec3 point, vec3 du_point, vec3 dv_point){+ vec3 cp = cross(+ (du_point - point),+ (dv_point - point)+ );+ if(length(cp) == 0){+ // Instead choose a normal to just dv_point - point in the direction of point+ vec3 v2 = dv_point - point;+ cp = cross(cross(v2, point), v2);+ }+ return normalize(rotate_point_into_frame(cp));+}diff --git a/manim/renderer/shaders/include/get_unit_normal.glsl b/manim/renderer/shaders/include/get_unit_normal.glslnew file mode 100644index 000000000..65bb9c71e--- /dev/null+++ b/manim/renderer/shaders/include/get_unit_normal.glsl@@ -0,0 +1,22 @@+vec3 get_unit_normal(in vec3[3] points){+ float tol = 1e-6;+ vec3 v1 = normalize(points[1] - points[0]);+ vec3 v2 = normalize(points[2] - points[0]);+ vec3 cp = cross(v1, v2);+ float cp_norm = length(cp);+ if(cp_norm < tol){+ // Three points form a line, so find a normal vector+ // to that line in the plane shared with the z-axis+ vec3 k_hat = vec3(0.0, 0.0, 1.0);+ vec3 new_cp = cross(cross(v2, k_hat), v2);+ float new_cp_norm = length(new_cp);+ if(new_cp_norm < tol){+ // We only come here if all three points line up+ // on the z-axis.+ return vec3(0.0, -1.0, 0.0);+ // return k_hat;+ }+ return new_cp / new_cp_norm;+ }+ return cp / cp_norm;+}diff --git a/manim/renderer/shaders/include/position_point_into_frame.glsl b/manim/renderer/shaders/include/position_point_into_frame.glslnew file mode 100644index 000000000..4cef7e38f--- /dev/null+++ b/manim/renderer/shaders/include/position_point_into_frame.glsl@@ -0,0 +1,19 @@+// Assumes the following uniforms exist in the surrounding context:+// uniform float is_fixed_in_frame;+// uniform vec3 camera_center;+// uniform mat3 camera_rotation;++vec3 rotate_point_into_frame(vec3 point){+ if(bool(is_fixed_in_frame)){+ return point;+ }+ return camera_rotation * point;+}+++vec3 position_point_into_frame(vec3 point){+ if(bool(is_fixed_in_frame)){+ return point;+ }+ return rotate_point_into_frame(point - camera_center);+}diff --git a/manim/renderer/shaders/include/quadratic_bezier_distance.glsl b/manim/renderer/shaders/include/quadratic_bezier_distance.glslnew file mode 100644index 000000000..7f2c5d5dd--- /dev/null+++ b/manim/renderer/shaders/include/quadratic_bezier_distance.glsl@@ -0,0 +1,107 @@+// Must be inserted in a context with a definition for modify_distance_for_endpoints++// All of this is with respect to a curve that's been rotated/scaled+// so that b0 = (0, 0) and b1 = (1, 0). That is, b2 entirely+// determines the shape of the curve++vec2 bezier(float t, vec2 b2){+ // Quick returns for the 0 and 1 cases+ if (t == 0) return vec2(0, 0);+ else if (t == 1) return b2;+ // Everything else+ return vec2(+ 2 * t * (1 - t) + b2.x * t*t,+ b2.y * t * t+ );+}+++float cube_root(float x){+ return sign(x) * pow(abs(x), 1.0 / 3.0);+}+++int cubic_solve(float a, float b, float c, float d, out float roots[3]){+ // Normalize so a = 1+ b = b / a;+ c = c / a;+ d = d / a;++ float p = c - b*b / 3.0;+ float q = b * (2.0*b*b - 9.0*c) / 27.0 + d;+ float p3 = p*p*p;+ float disc = q*q + 4.0*p3 / 27.0;+ float offset = -b / 3.0;+ if(disc >= 0.0){+ float z = sqrt(disc);+ float u = (-q + z) / 2.0;+ float v = (-q - z) / 2.0;+ u = cube_root(u);+ v = cube_root(v);+ roots[0] = offset + u + v;+ return 1;+ }+ float u = sqrt(-p / 3.0);+ float v = acos(-sqrt( -27.0 / p3) * q / 2.0) / 3.0;+ float m = cos(v);+ float n = sin(v) * 1.732050808;++ float all_roots[3] = float[3](+ offset + u * (n - m),+ offset - u * (n + m),+ offset + u * (m + m)+ );++ // Only accept roots with a positive derivative+ int n_valid_roots = 0;+ for(int i = 0; i < 3; i++){+ float r = all_roots[i];+ if(3*r*r + 2*b*r + c > 0){+ roots[n_valid_roots] = r;+ n_valid_roots++;+ }+ }+ return n_valid_roots;+}++float dist_to_line(vec2 p, vec2 b2){+ float t = clamp(p.x / b2.x, 0, 1);+ float dist;+ if(t == 0) dist = length(p);+ else if(t == 1) dist = distance(p, b2);+ else dist = abs(p.y);++ return modify_distance_for_endpoints(p, dist, t);+}+++float dist_to_point_on_curve(vec2 p, float t, vec2 b2){+ t = clamp(t, 0, 1);+ return modify_distance_for_endpoints(+ p, length(p - bezier(t, b2)), t+ );+}+++float min_dist_to_curve(vec2 p, vec2 b2, float degree){+ // Check if curve is really a a line+ if(degree == 1) return dist_to_line(p, b2);++ // Try finding the exact sdf by solving the equation+ // (d/dt) dist^2(t) = 0, which amount to the following+ // cubic.+ float xm2 = uv_b2.x - 2.0;+ float y = uv_b2.y;+ float a = xm2*xm2 + y*y;+ float b = 3 * xm2;+ float c = -(p.x*xm2 + p.y*y) + 2;+ float d = -p.x;++ float roots[3];+ int n = cubic_solve(a, b, c, d, roots);+ // At most 2 roots will have been populated.+ float d0 = dist_to_point_on_curve(p, roots[0], b2);+ if(n == 1) return d0;+ float d1 = dist_to_point_on_curve(p, roots[1], b2);+ return min(d0, d1);+}diff --git a/manim/renderer/shaders/include/quadratic_bezier_geometry_functions.glsl b/manim/renderer/shaders/include/quadratic_bezier_geometry_functions.glslnew file mode 100644index 000000000..d2e3e0fb7--- /dev/null+++ b/manim/renderer/shaders/include/quadratic_bezier_geometry_functions.glsl@@ -0,0 +1,92 @@+float cross2d(vec2 v, vec2 w){+ return v.x * w.y - w.x * v.y;+}+++mat3 get_xy_to_uv(vec2 b0, vec2 b1){+ mat3 shift = mat3(+ 1.0, 0.0, 0.0,+ 0.0, 1.0, 0.0,+ -b0.x, -b0.y, 1.0+ );++ float sf = length(b1 - b0);+ vec2 I = (b1 - b0) / sf;+ vec2 J = vec2(-I.y, I.x);+ mat3 rotate = mat3(+ I.x, J.x, 0.0,+ I.y, J.y, 0.0,+ 0.0, 0.0, 1.0+ );+ return (1 / sf) * rotate * shift;+}+++// Orthogonal matrix to convert to a uv space defined so that+// b0 goes to [0, 0] and b1 goes to [1, 0]+mat4 get_xyz_to_uv(vec3 b0, vec3 b1, vec3 unit_normal){+ mat4 shift = mat4(+ 1, 0, 0, 0,+ 0, 1, 0, 0,+ 0, 0, 1, 0,+ -b0.x, -b0.y, -b0.z, 1+ );++ float scale_factor = length(b1 - b0);+ vec3 I = (b1 - b0) / scale_factor;+ vec3 K = unit_normal;+ vec3 J = cross(K, I);+ // Transpose (hence inverse) of matrix taking+ // i-hat to I, k-hat to unit_normal, and j-hat to their cross+ mat4 rotate = mat4(+ I.x, J.x, K.x, 0.0,+ I.y, J.y, K.y, 0.0,+ I.z, J.z, K.z, 0.0,+ 0.0, 0.0, 0.0, 1.0+ );+ return (1 / scale_factor) * rotate * shift;+}+++// Returns 0 for null curve, 1 for linear, 2 for quadratic.+// Populates new_points with bezier control points for the curve,+// which for quadratics will be the same, but for linear and null+// might change. The idea is to inform the caller of the degree,+// while also passing tangency information in the linear case.+// float get_reduced_control_points(vec3 b0, vec3 b1, vec3 b2, out vec3 new_points[3]){+float get_reduced_control_points(in vec3 points[3], out vec3 new_points[3]){+ float length_threshold = 1e-6;+ float angle_threshold = 5e-2;++ vec3 p0 = points[0];+ vec3 p1 = points[1];+ vec3 p2 = points[2];+ vec3 v01 = (p1 - p0);+ vec3 v12 = (p2 - p1);++ float dot_prod = clamp(dot(normalize(v01), normalize(v12)), -1, 1);+ bool aligned = acos(dot_prod) < angle_threshold;+ bool distinct_01 = length(v01) > length_threshold; // v01 is considered nonzero+ bool distinct_12 = length(v12) > length_threshold; // v12 is considered nonzero+ int n_uniques = int(distinct_01) + int(distinct_12);++ bool quadratic = (n_uniques == 2) && !aligned;+ bool linear = (n_uniques == 1) || ((n_uniques == 2) && aligned);+ bool constant = (n_uniques == 0);+ if(quadratic){+ new_points[0] = p0;+ new_points[1] = p1;+ new_points[2] = p2;+ return 2.0;+ }else if(linear){+ new_points[0] = p0;+ new_points[1] = (p0 + p2) / 2.0;+ new_points[2] = p2;+ return 1.0;+ }else{+ new_points[0] = p0;+ new_points[1] = p0;+ new_points[2] = p0;+ return 0.0;+ }+}diff --git a/manim/renderer/shaders/manim_coords/frag.glsl b/manim/renderer/shaders/manim_coords/frag.glslnew file mode 100644index 000000000..2a721a51e--- /dev/null+++ b/manim/renderer/shaders/manim_coords/frag.glsl@@ -0,0 +1,8 @@+#version 330++uniform vec4 u_color;+out vec4 frag_color;++void main() {+ frag_color = u_color;+}diff --git a/manim/renderer/shaders/manim_coords/vert.glsl b/manim/renderer/shaders/manim_coords/vert.glslnew file mode 100644index 000000000..e12bd25a3--- /dev/null+++ b/manim/renderer/shaders/manim_coords/vert.glsl@@ -0,0 +1,11 @@+#version 330++in vec4 in_vert;+uniform mat4 u_model_view_matrix;+uniform mat4 u_projection_matrix;++void main() {+ vec4 camera_space_vertex = u_model_view_matrix * in_vert;+ vec4 clip_space_vertex = u_projection_matrix * camera_space_vertex;+ gl_Position = clip_space_vertex;+}diff --git a/manim/renderer/shaders/quadratic_bezier_fill/frag.glsl b/manim/renderer/shaders/quadratic_bezier_fill/frag.glslindex b2a1c82aa..28a187979 100644--- a/manim/renderer/shaders/quadratic_bezier_fill/frag.glsl+++ b/manim/renderer/shaders/quadratic_bezier_fill/frag.glsl@@ -1,6 +1,6 @@#version 330-#INSERT camera_uniform_declarations.glsl+#include ../include/camera_uniform_declarations.glslin vec4 color;in float fill_all; // Either 0 or 1e@@ -19,7 +19,7 @@ float modify_distance_for_endpoints(vec2 p, float dist, float t){return dist;}-#INSERT quadratic_bezier_distance.glsl+#include ../include/quadratic_bezier_distance.glslfloat sdf(){diff --git a/manim/renderer/shaders/quadratic_bezier_fill/geom.glsl b/manim/renderer/shaders/quadratic_bezier_fill/geom.glslindex 4fd9245f5..dcb4ab364 100644--- a/manim/renderer/shaders/quadratic_bezier_fill/geom.glsl+++ b/manim/renderer/shaders/quadratic_bezier_fill/geom.glsl@@ -32,10 +32,10 @@ out float bezier_degree;// Analog of import for manim only-#INSERT quadratic_bezier_geometry_functions.glsl-#INSERT get_gl_Position.glsl-#INSERT get_unit_normal.glsl-#INSERT finalize_color.glsl+#include ../include/quadratic_bezier_geometry_functions.glsl+#include ../include/get_gl_Position.glsl+#include ../include/get_unit_normal.glsl+#include ../include/finalize_color.glslvoid emit_vertex_wrapper(vec3 point, int index){diff --git a/manim/renderer/shaders/quadratic_bezier_fill/vert.glsl b/manim/renderer/shaders/quadratic_bezier_fill/vert.glslindex ae26c0c8a..e89133988 100644--- a/manim/renderer/shaders/quadratic_bezier_fill/vert.glsl+++ b/manim/renderer/shaders/quadratic_bezier_fill/vert.glsl@@ -1,6 +1,6 @@#version 330-#INSERT camera_uniform_declarations.glsl+#include ../include/camera_uniform_declarations.glslin vec3 point;in vec3 unit_normal;@@ -13,11 +13,11 @@ out vec4 v_color;out float v_vert_index;// Analog of import for manim only-#INSERT position_point_into_frame.glsl+#include ../include/position_point_into_frame.glslvoid main(){- bp = position_point_into_frame(point);- v_global_unit_normal = rotate_point_into_frame(unit_normal);+ bp = position_point_into_frame(point.xyz);+ v_global_unit_normal = rotate_point_into_frame(unit_normal.xyz);v_color = color;v_vert_index = vert_index;}diff --git a/manim/renderer/shaders/quadratic_bezier_stroke/frag.glsl b/manim/renderer/shaders/quadratic_bezier_stroke/frag.glslindex 430ff2bef..8cf383a05 100644--- a/manim/renderer/shaders/quadratic_bezier_stroke/frag.glsl+++ b/manim/renderer/shaders/quadratic_bezier_stroke/frag.glsl@@ -1,6 +1,6 @@#version 330-#INSERT camera_uniform_declarations.glsl+#include ../include/camera_uniform_declarations.glslin vec2 uv_coords;in vec2 uv_b2;@@ -79,7 +79,7 @@ float modify_distance_for_endpoints(vec2 p, float dist, float t){}-#INSERT quadratic_bezier_distance.glsl+#include ../include/quadratic_bezier_distance.glslvoid main() {diff --git a/manim/renderer/shaders/quadratic_bezier_stroke/geom.glsl b/manim/renderer/shaders/quadratic_bezier_stroke/geom.glslindex f9cfe303b..9eda1a6e5 100644--- a/manim/renderer/shaders/quadratic_bezier_stroke/geom.glsl+++ b/manim/renderer/shaders/quadratic_bezier_stroke/geom.glsl@@ -49,10 +49,10 @@ const float MITER_JOINT = 3;const float PI = 3.141592653;-#INSERT quadratic_bezier_geometry_functions.glsl-#INSERT get_gl_Position.glsl-#INSERT get_unit_normal.glsl-#INSERT finalize_color.glsl+#include ../include/quadratic_bezier_geometry_functions.glsl+#include ../include/get_gl_Position.glsl+#include ../include/get_unit_normal.glsl+#include ../include/finalize_color.glslvoid flatten_points(in vec3[3] points, out vec2[3] flat_points){diff --git a/manim/renderer/shaders/quadratic_bezier_stroke/vert.glsl b/manim/renderer/shaders/quadratic_bezier_stroke/vert.glslindex fa5e1ea18..4ed9d0a7e 100644--- a/manim/renderer/shaders/quadratic_bezier_stroke/vert.glsl+++ b/manim/renderer/shaders/quadratic_bezier_stroke/vert.glsl@@ -1,6 +1,6 @@#version 330-#INSERT camera_uniform_declarations.glsl+#include ../include/camera_uniform_declarations.glslin vec3 point;in vec3 prev_point;@@ -21,7 +21,7 @@ out vec4 v_color;const float STROKE_WIDTH_CONVERSION = 0.01;-#INSERT position_point_into_frame.glsl+#include ../include/position_point_into_frame.glslvoid main(){bp = position_point_into_frame(point);diff --git a/manim/renderer/shaders/simple_vert.glsl b/manim/renderer/shaders/simple_vert.glslindex acdabc2d9..f3f8162ee 100644--- a/manim/renderer/shaders/simple_vert.glsl+++ b/manim/renderer/shaders/simple_vert.glsl@@ -1,12 +1,12 @@#version 330-#INSERT camera_uniform_declarations.glsl+#include ../include/camera_uniform_declarations.glslin vec3 point;// Analog of import for manim only-#INSERT get_gl_Position.glsl-#INSERT position_point_into_frame.glsl+#include ../include/get_gl_Position.glsl+#include ../include/position_point_into_frame.glslvoid main(){gl_Position = get_gl_Position(position_point_into_frame(point));diff --git a/manim/renderer/shaders/surface/frag.glsl b/manim/renderer/shaders/surface/frag.glslindex 28f3b40d0..fb7cee13d 100644--- a/manim/renderer/shaders/surface/frag.glsl+++ b/manim/renderer/shaders/surface/frag.glsl@@ -10,7 +10,7 @@ in vec4 v_color;out vec4 frag_color;-#INSERT finalize_color.glsl+#include ../include/finalize_color.glslvoid main() {frag_color = finalize_color(diff --git a/manim/renderer/shaders/surface/vert.glsl b/manim/renderer/shaders/surface/vert.glslindex d95c6a528..9f9293e79 100644--- a/manim/renderer/shaders/surface/vert.glsl+++ b/manim/renderer/shaders/surface/vert.glsl@@ -1,6 +1,6 @@#version 330-#INSERT camera_uniform_declarations.glsl+#include ../include/camera_uniform_declarations.glslin vec3 point;in vec3 du_point;@@ -11,9 +11,9 @@ out vec3 xyz_coords;out vec3 v_normal;out vec4 v_color;-#INSERT position_point_into_frame.glsl-#INSERT get_gl_Position.glsl-#INSERT get_rotated_surface_unit_normal_vector.glsl+#include ../include/position_point_into_frame.glsl+#include ../include/get_gl_Position.glsl+#include ../include/get_rotated_surface_unit_normal_vector.glslvoid main(){xyz_coords = position_point_into_frame(point);diff --git a/manim/renderer/shaders/textured_surface/frag.glsl b/manim/renderer/shaders/textured_surface/frag.glslindex 22ec2e1de..ff162ffa7 100644--- a/manim/renderer/shaders/textured_surface/frag.glsl+++ b/manim/renderer/shaders/textured_surface/frag.glsl@@ -14,7 +14,7 @@ in float v_opacity;out vec4 frag_color;-#INSERT finalize_color.glsl+#include ../include/finalize_color.glslconst float dark_shift = 0.2;diff --git a/manim/renderer/shaders/textured_surface/vert.glsl b/manim/renderer/shaders/textured_surface/vert.glslindex 8b54798a2..f0573ea39 100644--- a/manim/renderer/shaders/textured_surface/vert.glsl+++ b/manim/renderer/shaders/textured_surface/vert.glsl@@ -1,6 +1,6 @@#version 330-#INSERT camera_uniform_declarations.glsl+#include ../include/camera_uniform_declarations.glslin vec3 point;in vec3 du_point;@@ -13,9 +13,9 @@ out vec3 v_normal;out vec2 v_im_coords;out float v_opacity;-#INSERT position_point_into_frame.glsl-#INSERT get_gl_Position.glsl-#INSERT get_rotated_surface_unit_normal_vector.glsl+#include ../include/position_point_into_frame.glsl+#include ../include/get_gl_Position.glsl+#include ../include/get_rotated_surface_unit_normal_vector.glslvoid main(){xyz_coords = position_point_into_frame(point);diff --git a/manim/renderer/shaders/true_dot/frag.glsl b/manim/renderer/shaders/true_dot/frag.glslindex 78fe74c2d..965c0eac4 100644--- a/manim/renderer/shaders/true_dot/frag.glsl+++ b/manim/renderer/shaders/true_dot/frag.glsl@@ -12,7 +12,7 @@ in vec2 point;out vec4 frag_color;-#INSERT finalize_color.glsl+#include ../include/finalize_color.glslvoid main() {vec2 diff = point - center;diff --git a/manim/renderer/shaders/true_dot/geom.glsl b/manim/renderer/shaders/true_dot/geom.glslindex 221634167..31ec676c1 100644--- a/manim/renderer/shaders/true_dot/geom.glsl+++ b/manim/renderer/shaders/true_dot/geom.glsl@@ -18,7 +18,7 @@ out float radius;out vec2 center;out vec2 point;-#INSERT get_gl_Position.glsl+#include ../include/get_gl_Position.glslvoid main() {color = v_color[0];diff --git a/manim/renderer/shaders/true_dot/vert.glsl b/manim/renderer/shaders/true_dot/vert.glslindex 0daf70502..1458a340e 100644--- a/manim/renderer/shaders/true_dot/vert.glsl+++ b/manim/renderer/shaders/true_dot/vert.glsl@@ -1,6 +1,6 @@#version 330-#INSERT camera_uniform_declarations.glsl+#include ../include/camera_uniform_declarations.glslin vec3 point;in float radius;@@ -10,7 +10,7 @@ out vec3 v_point;out float v_radius;out vec4 v_color;-#INSERT position_point_into_frame.glsl+#include ../include/position_point_into_frame.glslvoid main(){v_point = position_point_into_frame(point);diff --git a/manim/renderer/shaders/vertex_colors/frag.glsl b/manim/renderer/shaders/vertex_colors/frag.glslnew file mode 100644index 000000000..dc5d0d766--- /dev/null+++ b/manim/renderer/shaders/vertex_colors/frag.glsl@@ -0,0 +1,8 @@+#version 330++in vec4 v_color;+out vec4 frag_color;++void main() {+ frag_color = v_color;+}diff --git a/manim/renderer/shaders/vertex_colors/vert.glsl b/manim/renderer/shaders/vertex_colors/vert.glslnew file mode 100644index 000000000..405b778c1--- /dev/null+++ b/manim/renderer/shaders/vertex_colors/vert.glsl@@ -0,0 +1,13 @@+#version 330++in vec4 in_vert;+in vec4 in_color;+out vec4 v_color;+uniform mat4 u_model_matrix;+uniform mat4 u_view_matrix;+uniform mat4 u_projection_matrix;++void main() {+ v_color = in_color;+ gl_Position = u_projection_matrix * u_view_matrix * u_model_matrix * in_vert;+}diff --git a/manim/scene/scene.py b/manim/scene/scene.pyindex cd1f2b792..995837675 100644--- a/manim/scene/scene.py+++ b/manim/scene/scene.py@@ -9,6 +9,7 @@ import inspectimport platformimport randomimport string+import sysimport threadingimport typesimport warnings@@ -27,6 +28,8 @@ from ..container import Containerfrom ..mobject.mobject import Mobject, _AnimationBuilderfrom ..mobject.opengl_mobject import OpenGLMobject, OpenGLPointfrom ..renderer.cairo_renderer import CairoRenderer+from ..renderer.shader import Mesh+from ..utils import opengl, space_opsfrom ..utils.exceptions import EndSceneEarlyException, RerunSceneExceptionfrom ..utils.family import extract_mobject_family_membersfrom ..utils.family_ops import restructure_list_to_exclude_certain_family_members@@ -99,6 +102,8 @@ class Scene(Container):self.last_t = Noneself.queue = Queue()self.skip_animation_preview = False+ self.meshes = []+ self.camera_target = ORIGINif config.renderer == "opengl":# Items associated with interaction@@ -305,6 +310,10 @@ class Scene(Container):for mobject in self.mobjects:mobject.update(dt)+ def update_meshes(self, dt):+ for mesh in self.meshes:+ mesh.update(dt)+def should_update_mobjects(self):"""Returns True if any mobject in Scene is being updated@@ -376,9 +385,17 @@ class Scene(Container):"""if config.renderer == "opengl":- new_mobjects = mobjects+ new_mobjects = []+ new_meshes = []+ for mobject_or_mesh in mobjects:+ if isinstance(mobject_or_mesh, Mesh):+ new_meshes.append(mobject_or_mesh)+ else:+ new_mobjects.append(mobject_or_mesh)self.remove(*new_mobjects)self.mobjects += new_mobjects+ self.remove(*new_meshes)+ self.meshes += new_mesheselse:mobjects = [*mobjects, *self.foreground_mobjects]self.restructure_mobjects(to_remove=mobjects)@@ -413,10 +430,19 @@ class Scene(Container):The mobjects to remove."""if config.renderer == "opengl":- mobjects_to_remove = mobjects+ mobjects_to_remove = []+ meshes_to_remove = set()+ for mobject_or_mesh in mobjects:+ if isinstance(mobject_or_mesh, Mesh):+ meshes_to_remove.add(mobject_or_mesh)+ else:+ mobjects_to_remove.append(mobject_or_mesh)self.mobjects = restructure_list_to_exclude_certain_family_members(self.mobjects, mobjects_to_remove)+ self.meshes = list(+ filter(lambda mesh: mesh not in set(meshes_to_remove), self.meshes)+ )return selfelse:for list_name in "mobjects", "foreground_mobjects":@@ -967,7 +993,7 @@ class Scene(Container):namespace["rerun"] = embedded_rerunshell(local_ns=namespace)- self.queue.put(("exit", [], {}))+ self.queue.put(("exit_keyboard", [], {}))def get_embedded_method(method_name):return lambda *args, **kwargs: self.queue.put((method_name, args, kwargs))@@ -1036,6 +1062,7 @@ class Scene(Container):dt = 1 / config["frame_rate"]self.renderer.render(self, dt, self.moving_mobjects)self.update_mobjects(dt)+ self.update_meshes(dt)# Join the keyboard thread if necessary.if shell is not None and keyboard_thread_needs_join:@@ -1095,6 +1122,7 @@ class Scene(Container):alpha = t / animation.run_timeanimation.interpolate(alpha)self.update_mobjects(dt)+ self.update_meshes(dt)def add_sound(self, sound_file, time_offset=0, gain=None, **kwargs):"""@@ -1147,16 +1175,9 @@ class Scene(Container):self.camera.shift(shift)def on_mouse_scroll(self, point, offset):- if CTRL_VALUE in self.renderer.pressed_keys:- factor = 1 + np.arctan(-20 * offset[1])- self.camera.scale(factor, about_point=point)-- transform = self.camera.inverse_rotation_matrix- shift = np.dot(np.transpose(transform), offset)- if SHIFT_VALUE in self.renderer.pressed_keys:- self.camera.shift(20.0 * np.array(rotate_vector(shift, PI / 2)))- else:- self.camera.shift(20.0 * shift)+ factor = 1 + np.arctan(-2.1 * offset[1])+ self.camera.scale(factor, about_point=self.camera_target)+ self.mouse_scroll_orbit_controls(point, offset)def on_key_press(self, symbol, modifiers):try:@@ -1167,6 +1188,7 @@ class Scene(Container):if char == "r":self.camera.to_default_state()+ self.camera_target = np.array([0, 0, 0], dtype=np.float32)elif char == "q":self.quit_interaction = True@@ -1175,5 +1197,90 @@ class Scene(Container):def on_mouse_drag(self, point, d_point, buttons, modifiers):self.mouse_drag_point.move_to(point)- self.camera.increment_theta(-d_point[0])- self.camera.increment_phi(d_point[1])+ if buttons == 1:+ self.camera.increment_theta(-d_point[0])+ self.camera.increment_phi(d_point[1])+ elif buttons == 4:+ camera_x_axis = self.camera.model_matrix[:3, 0]+ horizontal_shift_vector = -d_point[0] * camera_x_axis+ vertical_shift_vector = -d_point[1] * np.cross(OUT, camera_x_axis)+ total_shift_vector = horizontal_shift_vector + vertical_shift_vector+ self.camera.shift(1.1 * total_shift_vector)++ self.mouse_drag_orbit_controls(point, d_point, buttons, modifiers)++ def mouse_scroll_orbit_controls(self, point, offset):+ camera_to_target = self.camera_target - self.camera.get_position()+ camera_to_target *= np.sign(offset[1])+ shift_vector = 0.01 * camera_to_target+ self.camera.model_matrix = (+ opengl.translation_matrix(*shift_vector) @ self.camera.model_matrix+ )++ def mouse_drag_orbit_controls(self, point, d_point, buttons, modifiers):+ # Left click drag.+ if buttons == 1:+ # Translate to target the origin and rotate around the z axis.+ self.camera.model_matrix = (+ opengl.rotation_matrix(z=-d_point[0])+ @ opengl.translation_matrix(*-self.camera_target)+ @ self.camera.model_matrix+ )++ # Rotation off of the z axis.+ camera_position = self.camera.get_position()+ camera_y_axis = self.camera.model_matrix[:3, 1]+ axis_of_rotation = space_ops.normalize(+ np.cross(camera_y_axis, camera_position)+ )+ rotation_matrix = space_ops.rotation_matrix(+ d_point[1], axis_of_rotation, homogeneous=True+ )++ maximum_polar_angle = PI / 2+ minimum_polar_angle = -PI / 2++ potential_camera_model_matrix = rotation_matrix @ self.camera.model_matrix+ potential_camera_location = potential_camera_model_matrix[:3, 3]+ potential_camera_y_axis = potential_camera_model_matrix[:3, 1]+ sign = (+ np.sign(potential_camera_y_axis[2])+ if potential_camera_y_axis[2] != 0+ else 1+ )+ potential_polar_angle = sign * np.arccos(+ potential_camera_location[2] / np.linalg.norm(potential_camera_location)+ )+ if minimum_polar_angle <= potential_polar_angle <= maximum_polar_angle:+ self.camera.model_matrix = potential_camera_model_matrix+ else:+ sign = np.sign(camera_y_axis[2]) if camera_y_axis[2] != 0 else 1+ current_polar_angle = sign * np.arccos(+ camera_position[2] / np.linalg.norm(camera_position)+ )+ if potential_polar_angle > maximum_polar_angle:+ polar_angle_delta = maximum_polar_angle - current_polar_angle+ else:+ polar_angle_delta = minimum_polar_angle - current_polar_angle+ rotation_matrix = space_ops.rotation_matrix(+ polar_angle_delta, axis_of_rotation, homogeneous=True+ )+ self.camera.model_matrix = rotation_matrix @ self.camera.model_matrix++ # Translate to target the original target.+ self.camera.model_matrix = (+ opengl.translation_matrix(*self.camera_target)+ @ self.camera.model_matrix+ )+ # Right click drag.+ elif buttons == 4:+ camera_x_axis = self.camera.model_matrix[:3, 0]+ horizontal_shift_vector = -d_point[0] * camera_x_axis+ vertical_shift_vector = -d_point[1] * np.cross(OUT, camera_x_axis)+ total_shift_vector = horizontal_shift_vector + vertical_shift_vector++ self.camera.model_matrix = (+ opengl.translation_matrix(*total_shift_vector)+ @ self.camera.model_matrix+ )+ self.camera_target += total_shift_vectordiff --git a/manim/utils/opengl.py b/manim/utils/opengl.pynew file mode 100644index 000000000..9999d14fd--- /dev/null+++ b/manim/utils/opengl.py@@ -0,0 +1,140 @@+import numpy as np+import numpy.linalg as linalg++from .. import config++depth = 20+++def matrix_to_shader_input(matrix):+ return tuple(matrix.T.ravel())+++def orthographic_projection_matrix(+ width=None, height=None, near=1, far=depth + 1, format=True+):+ if width is None:+ width = config["frame_width"]+ if height is None:+ height = config["frame_height"]+ projection_matrix = np.array(+ [+ [2 / width, 0, 0, 0],+ [0, 2 / height, 0, 0],+ [0, 0, -2 / (far - near), -(far + near) / (far - near)],+ [0, 0, 0, 1],+ ]+ )+ if format:+ return matrix_to_shader_input(projection_matrix)+ else:+ return projection_matrix+++def perspective_projection_matrix(width=None, height=None, near=4, far=18, format=True):+ if width is None:+ width = config["frame_width"] / 3+ if height is None:+ height = config["frame_height"] / 3+ projection_matrix = np.array(+ [+ [2 * near / width, 0, 0, 0],+ [0, 2 * near / height, 0, 0],+ [0, 0, (far + near) / (near - far), (2 * far * near) / (near - far)],+ [0, 0, -1, 0],+ ]+ )+ if format:+ return matrix_to_shader_input(projection_matrix)+ else:+ return projection_matrix+++def translation_matrix(x=0, y=0, z=0):+ return np.array(+ [+ [1, 0, 0, x],+ [0, 1, 0, y],+ [0, 0, 1, z],+ [0, 0, 0, 1],+ ]+ )+++def x_rotation_matrix(x=0):+ return np.array(+ [+ [1, 0, 0, 0],+ [0, np.cos(x), -np.sin(x), 0],+ [0, np.sin(x), np.cos(x), 0],+ [0, 0, 0, 1],+ ]+ )+++def y_rotation_matrix(y=0):+ return np.array(+ [+ [np.cos(y), 0, np.sin(y), 0],+ [0, 1, 0, 0],+ [-np.sin(y), 0, np.cos(y), 0],+ [0, 0, 0, 1],+ ]+ )+++def z_rotation_matrix(z=0):+ return np.array(+ [+ [np.cos(z), -np.sin(z), 0, 0],+ [np.sin(z), np.cos(z), 0, 0],+ [0, 0, 1, 0],+ [0, 0, 0, 1],+ ]+ )+++# TODO: When rotating around the x axis, rotation eventually stops.+def rotate_in_place_matrix(initial_position, x=0, y=0, z=0):+ return np.matmul(+ translation_matrix(*-initial_position),+ np.matmul(+ rotation_matrix(x, y, z),+ translation_matrix(*initial_position),+ ),+ )+++def rotation_matrix(x=0, y=0, z=0):+ return np.matmul(+ np.matmul(x_rotation_matrix(x), y_rotation_matrix(y)), z_rotation_matrix(z)+ )+++def scale_matrix(scale_factor=None):+ return np.array(+ [+ [1, 0, 0, 0],+ [0, 1, 0, 0],+ [0, 0, 1, 0],+ [0, 0, 0, 1],+ ]+ )+++def view_matrix(+ translation=None,+ x_rotation=0,+ y_rotation=0,+ z_rotation=0,+):+ if translation is None:+ translation = np.array([0, 0, depth / 2 + 1])+ model_matrix = np.matmul(+ np.matmul(+ translation_matrix(*translation),+ rotation_matrix(x=x_rotation, y=y_rotation, z=z_rotation),+ ),+ scale_matrix(),+ )+ return tuple(linalg.inv(model_matrix).T.ravel())diff --git a/manim/utils/space_ops.py b/manim/utils/space_ops.pyindex a91361569..e2f077c28 100644--- a/manim/utils/space_ops.py+++ b/manim/utils/space_ops.py@@ -168,14 +168,20 @@ def rotation_matrix_transpose(angle, axis):return rotation_matrix_transpose_from_quaternion(quat)-def rotation_matrix(angle, axis):+def rotation_matrix(angle, axis, homogeneous=False):"""Rotation in R^3 about a specified axis of rotation."""about_z = rotation_about_z(angle)z_to_axis = z_to_vector(axis)axis_to_z = np.linalg.inv(z_to_axis)- return reduce(np.dot, [z_to_axis, about_z, axis_to_z])+ inhomogeneous_rotation_matrix = reduce(np.dot, [z_to_axis, about_z, axis_to_z])+ if not homogeneous:+ return inhomogeneous_rotation_matrix+ else:+ rotation_matrix = np.eye(4)+ rotation_matrix[:3, :3] = inhomogeneous_rotation_matrix+ return rotation_matrixdef rotation_about_z(angle):