`OpenGLSurface` rendered on top of `ThreeDAxis`

[alembcke]

Description of bug / unexpected behavior

When creating ThreeDAxes and adding a surface using the OpenGL renderer, the surface is rendered on top of the axes. This does not happen when using the Cairo renderer.

Expected behavior

Surface objects should not be rendered over the axes when plotting

How to reproduce the issue

Code for reproducing the problem

from manim import *
import numpy as np


class Test(ThreeDScene):
    def construct(self):
        self.set_camera_orientation(phi=75 * DEGREES, theta=-20 * DEGREES)

        axes = ThreeDAxes(                                                
                x_range=[0, 3, 1],
                y_range=[0, 3, 1],
                z_range=[-1, 1, 1] 
            )                  

        def func(x, y):
            return np.cos(x) * np.sin(y)

        surface = axes.plot_surface(    
            function=func,          
            u_range = (0, 3),       
            v_range = (0, 3),                                
            colorscale = ['#482173', '#2e6f8e', '#29af7f', '#bddf26']
        )                                                            

        self.add(axes, surface)

Additional media files

OpenGL Output:

Cairo Output:

It might be difficult to see due to the light reflecting off the surface, but the ThreeDAxes is in front of the surface for the Cairo output, but is half-covered for the OpenGL output even though that is the z-axis at the origin and the function doesn't cross the origin.

Logs

Terminal output

PASTE HERE OR PROVIDE LINK TO https://pastebin.com/ OR SIMILAR

System specifications

System Details

• OS (with version, e.g., Windows 10 v2004 or macOS 10.15 (Catalina)):
• RAM:
• Python version (python/py/python3 --version):
• Installed modules (provide output from pip list):

PASTE HERE

LaTeX details

• LaTeX distribution (e.g. TeX Live 2020):
• Installed LaTeX packages:

FFMPEG

Output of ffmpeg -version:

PASTE HERE

Additional comments

[rgreen32]

This appears to be in issue of depth_test being set to False on the opengl context. Specifically, the ShaderWrappers for OpenGLVMobject are not being set properly.

When I manually set the depth_test values, I get the expected visual.

   # For shaders
    def init_shader_data(self):
        self.fill_data = np.zeros(0, dtype=self.fill_dtype)
        self.stroke_data = np.zeros(0, dtype=self.stroke_dtype)
        self.fill_shader_wrapper = ShaderWrapper(
            vert_data=self.fill_data,
            depth_test=True,
            vert_indices=np.zeros(0, dtype="i4"),
            shader_folder=self.fill_shader_folder,
            render_primitive=self.render_primitive,
        )
        self.stroke_shader_wrapper = ShaderWrapper(
            vert_data=self.stroke_data,
            depth_test=True,
            shader_folder=self.stroke_shader_folder,
            render_primitive=self.render_primitive,
        )

depth_test = False	depth_test = True

[alembcke]

I see the difference when calling with depth_test = True, but OpenGLSurface is an OpenGLMobject, not an OpenGLVMobject. Also, OpenGLSurface calls the parent class __init__() with depth_test = True, so that should be flowing from OpenGLSurface to OpenGLMobject to the shader. So I don't see how OpenGLSurface could be getting called with anything other than depth_test = True, do you?

[rgreen32]

@alembcke Yes, OpenGLSurface is an OpenGLMobject but ThreeDAxes is an OpenGLVMobject.

[alembcke]

@rgreen32 ah, I see! And OpenGLVMobject doesn't set depth_test at all by default. So to fix this there should be some logic within OpenGLVMobject to set depth_test - perhaps something that checks if the scene is 3D or 2D and set as appropriate. Or is there a better solution?

[behackl]

Completed via #3106.