Significant performance issues compared to manimgl with the opengl renderer.

[hydrobeam]

Description of bug / unexpected behavior

Running the SinCurveUnitCircle example with manimce using the following input:

 manim mkt.py --renderer=opengl SineCurveUnitCircle --write_to_movie --disable_caching

Results in the video taking an extremely long time to render, at around 36 seconds total. Interestingly enough, a 1 second self.wait() call took 4 seconds to render. This is even slower than cairo, which clocks in at ~24 seconds. See below for the videos I recorded of the rendering process.

manimgl speeds

Comparing these speeds to manimgl, it becomes a little more apparent how slow our opengl rendering is. Writing to file takes ~8 seconds on manimgl, meaning that our opengl rendering is ~5x slower than manimgl in this particular case on my machine.

While these specific times may vary due to background tasks etc... , manimgl universally performs much better than manimce by a very large margin.

Expected behavior

Comparable speeds between manimgl and manimce's opengl rendering. At the very least faster than cairo.

How to reproduce the issue

Here's the manimgl compatible code if you're interested in running the scene in manimgl.

Code for reproducing the problem

class SineCurveUnitCircle(Scene):
    # contributed by heejin_park, https://infograph.tistory.com/230
    def construct(self):
        self.show_axis()
        self.show_circle()
        self.move_dot_and_draw_curve()
        self.wait()

    def show_axis(self):
        x_start = np.array([-6,0,0])
        x_end = np.array([6,0,0])

        y_start = np.array([-4,-2,0])
        y_end = np.array([-4,2,0])

        x_axis = Line(x_start, x_end)
        y_axis = Line(y_start, y_end)

        self.add(x_axis, y_axis)
        self.add_x_labels()

        self.origin_point = np.array([-4,0,0])
        self.curve_start = np.array([-3,0,0])

    def add_x_labels(self):
        x_labels = [
            Tex("\pi"), Tex("2 \pi"),
            Tex("3 \pi"), Tex("4 \pi"),
        ]

        for i in range(len(x_labels)):
            x_labels[i].next_to(np.array([-1 + 2*i, 0, 0]), DOWN)
            self.add(x_labels[i])

    def show_circle(self):
        circle = Circle(radius=1)
        circle.move_to(self.origin_point)
        self.add(circle)
        self.circle = circle

    def move_dot_and_draw_curve(self):
        orbit = self.circle
        origin_point = self.origin_point

        dot = Dot(radius=0.08, color=YELLOW)
        dot.move_to(orbit.point_from_proportion(0))
        self.t_offset = 0
        rate = 0.25

        def go_around_circle(mob, dt):
            self.t_offset += (dt * rate)
            # print(self.t_offset)
            mob.move_to(orbit.point_from_proportion(self.t_offset % 1))

        def get_line_to_circle():
            return Line(origin_point, dot.get_center(), color=BLUE)

        def get_line_to_curve():
            x = self.curve_start[0] + self.t_offset * 4
            y = dot.get_center()[1]
            return Line(dot.get_center(), np.array([x,y,0]), color=YELLOW_A, stroke_width=2 )


        self.curve = VGroup()
        self.curve.add(Line(self.curve_start,self.curve_start))
        def get_curve():
            last_line = self.curve[-1]
            x = self.curve_start[0] + self.t_offset * 4
            y = dot.get_center()[1]
            new_line = Line(last_line.get_end(),np.array([x,y,0])).set_color(YELLOW_D)
            self.curve.add(new_line)

            return self.curve

        dot.add_updater(go_around_circle)

        origin_to_circle_line = always_redraw(get_line_to_circle)
        dot_to_curve_line = always_redraw(get_line_to_curve)
        sine_curve_line = always_redraw(get_curve)

        self.add(dot)
        self.add(orbit, origin_to_circle_line, dot_to_curve_line, sine_curve_line)
        self.wait(8.5)

        dot.remove_updater(go_around_circle)
        

Additional media files

ManimCE + ManimGL rendering videos below:

Images/GIFs

testing.py.-.manimgl.-.Visual.Studio.Code.2021-08-24.07-31-49.mp4

opengl_renderer.py.-.hydro_manim.-.Visual.Studio.Code.2021-08-24.07-30-36.mp4

System specifications

• OS: Windows 11
• Python version: 3.9

[Darylgolden]

Can confirm that OpenGL rendering often runs slower than Cairo on my system too, which I find very strange.

[hydrobeam]

I realized that manimgl has a default setting of 30fps, as opposed to manimce's 60 fps. This means that manimgl running at 60fps actually needs ~14s to render the scene. Manimce requires ~8 seconds to render at 30fps. So, manimce actually performs much worse as the frame rate increases.

The difference between manimgl/ce isn't as bad as I thought, but this doesn't change the fact that our opengl is still slower than cairo 🤷

[Darylgolden]

(Which means the speed at 30 fps is comparable).

On the Discord server, we've already found the root cause, and it shouldn't be too hard to fix.

[hydrobeam]

What's the root cause? Could you describe it?

[k4pran]

There seems to be a lot happening for each frame, and even small operations can add up to performance issues if it is happening often. Some things I have noticed that might help below, but I think in general we should do as much setup as possible before rendering happens and try to make logic inside the render method as simple as possible.

• Is the initial call to update_frame necessary ?

  manim/manim/renderer/opengl_renderer.py

  Line 389 in f88b372

  self.update_frame(scene)

• Is there not a way we can directly use data dict to pass to shaders, currently we are creating multiple numpy array every frame for every mobject here

  manim/manim/mobject/types/opengl_vectorized_mobject.py

  Line 1154 in f88b372

  stroke_data = np.zeros(len(points), dtype=OpenGLVMobject.stroke_dtype)

  and here

  manim/manim/mobject/types/opengl_vectorized_mobject.py

  Line 1171 in f88b372

  fill_data = np.zeros(len(points), dtype=OpenGLVMobject.fill_dtype)

  .
• We also create multiple shader wrappers for each frame instead of updating them here

  manim/manim/mobject/types/opengl_vectorized_mobject.py

  Line 1097 in f88b372

  def get_stroke_shader_wrapper(self):

  and here

  manim/manim/mobject/types/opengl_vectorized_mobject.py

  Line 1085 in f88b372

  def get_fill_shader_wrapper(self):

• The view matrix is calculated by inverting the camera's model matrix, this happens multiple times per frame here

  manim/manim/renderer/opengl_renderer.py

  Line 108 in 89bcec8

  return opengl.matrix_to_shader_input(np.linalg.inv(self.model_matrix))

  and it is slow. It also runs even when the view matrix isn't used in the shader. Maybe we can store the model view matrix and update it on the fly when the camera's model matrix is updated