Improve support of concurrent OpenGL contexts for Rasterizer.

Author: duburcqa

.github/workflows/generic.yml

@@ -162,7 +162,7 @@ jobs:
 
       - name: Run unit tests
         run: |
-          pytest -v --logical --dev --backend ${{ matrix.GS_BACKEND }} -m 'required and not slow' --forked ./tests
+          pytest -v -ra --logical --dev --backend ${{ matrix.GS_BACKEND }} -m 'required and not slow' --forked ./tests
 
       - name: Save Updated Taichi Kernel Cache
         if: >-

genesis/engine/simulator.py

@@ -1,4 +1,5 @@
 from typing import TYPE_CHECKING
+
 import numpy as np
 import gstaichi as ti
 

genesis/ext/pyrender/offscreen.py

@@ -75,8 +75,7 @@ def make_current(self):
 
         self._platform.make_current()
 
-        # If platform does not support dynamically-resizing framebuffers,
-        # destroy it and restart it
+        # If platform does not support dynamically-resizing framebuffers, destroy it and restart it
         if (
             self._platform.viewport_height != self.viewport_height
             or self._platform.viewport_width != self.viewport_width
@@ -261,8 +260,8 @@ def _create(self, platform):
         else:
             raise ValueError("Unsupported PyOpenGL platform: {}".format(platform))
         self._platform.init_context()
-        self._platform.make_current()
 
+        self._platform.make_current()
         try:
             from OpenGL.GL import glGetString, GL_RENDERER
 
@@ -276,6 +275,7 @@ def _create(self, platform):
                 "Software rendering context detected. Shadows and plane reflection not supported. Beware rendering "
                 "will be extremely slow."
             )
+        self._platform.make_uncurrent()
 
     def __del__(self):
         try:

genesis/ext/pyrender/viewer.py

@@ -385,7 +385,7 @@ def __init__(
             if not self._is_active:
                 if self._exception:
                     raise RuntimeError("Unable to initialize an OpenGL 3+ context.") from self._exception
-                raise OpenGL.error.Error("Invalid OpenGL context.")
+                raise OpenGL.error.Error("Invalid OpenGL context (unknown exception).")
         else:
             if self.auto_start:
                 self.start()
@@ -1116,38 +1116,76 @@ def start(self, auto_refresh=True):
                 confs[1],
             ]
         while confs:
-            # Keep the window invisible for now. It will be displayed only if everything is working fine.
-            # This approach avoids "flickering" when creating and closing an invalid context. Besides, it avoids
-            # "frozen" graphical window during compilation that would be interpreted as as bug by the end-user.
             conf = confs.pop(0)
+
+            # Close any existing context and window
             try:
-                super().__init__(
-                    config=conf,
-                    visible=False,
-                    resizable=True,
-                    width=self._viewport_size[0],
-                    height=self._viewport_size[1],
-                )
+                OpenGL.contextdata.cleanupContext()
+                self.set_visible(False)
+            except Exception:
+                pass
+            try:
+                super().close()
+            except Exception:
+                pass
+
+            try:
+                # Keep the window invisible for now. It will be displayed only if everything is working fine.
+                # This approach avoids "flickering" when creating and closing an invalid context. Besides, it avoids
+                # "frozen" graphical window during compilation that would be interpreted as as bug by the end-user.
+                try:
+                    super().__init__(
+                        config=conf,
+                        visible=False,
+                        resizable=True,
+                        width=self._viewport_size[0],
+                        height=self._viewport_size[1],
+                    )
+                except xlib_exceptions as e:
+                    # Trying again without UTF8 support as a fallback.
+                    # See: https://github.com/pyglet/pyglet/issues/1024
+                    if pyglet.window.xlib._have_utf8:
+                        pyglet.window.xlib._have_utf8 = False
+                        confs.insert(0, conf)
+                    raise
+
+                # Refresh first without window, to make sure all the necessary kernels are compiled
+                self.refresh()
+
+                # At this point, we are all set to display the graphical window if requested
+                if not pyglet.options["headless"]:
+                    self.set_visible(True)
+
+                # Run the entire rendering pipeline once, to make sure that everything is fine
+                self.refresh()
+
                 break
-            except xlib_exceptions as e:
-                # Trying again without UTF8 support as a fallback.
-                # See: https://github.com/pyglet/pyglet/issues/1024
-                if not pyglet.window.xlib._have_utf8:
-                    if self._run_in_thread:
-                        self.on_close()
-                        self._exception = e
-                        return
-                    else:
-                        raise RuntimeError("Unable to initialize an OpenGL 3+ context.") from e
-                pyglet.window.xlib._have_utf8 = False
-                confs.insert(0, conf)
-            except (pyglet.window.NoSuchConfigException, pyglet.gl.ContextException) as e:
+            except (
+                pyglet.window.NoSuchConfigException,
+                pyglet.gl.ContextException,
+                pyglet.gl.GLException,
+                OpenGL.error.Error,
+                AttributeError,
+                ArgumentError,
+                RuntimeError,
+            ) as e:
                 if not confs:
+                    # It is essential to set the exception before closing the viewer, otherwise the main thread preempt
+                    # execution of this thread and wrongly report unknown exception.
                     if self._run_in_thread:
-                        self.on_close()
                         self._exception = e
+
+                    # Now the viewer can be safely cause to avoid leaving any global OpenGL context or window dangling
+                    try:
+                        self.on_close()
+                    except Exception:
+                        pass
+
+                    if self._run_in_thread:
+                        # Reporting the exception for the main thread to raise it
                         return
                     else:
+                        # Raise the exception right away
                         raise RuntimeError("Unable to initialize an OpenGL 3+ context.") from e
 
         if self._run_in_thread:
@@ -1157,27 +1195,7 @@ def start(self, auto_refresh=True):
             pyglet.clock.schedule(Viewer._time_event, self)
 
         # Update window title
-        self.switch_to()
         self.set_caption(self.viewer_flags["window_title"])
-
-        # Run the entire rendering pipeline once, to make sure that everything is fine
-        try:
-            self.refresh()
-        except (OpenGL.error.Error, RuntimeError) as e:
-            # Invalid OpenGL context and crossing threading boundaries. Closing before anything else
-            self.on_close()
-
-            if self._run_in_thread:
-                # Reporting the exception for the main thread to raise it
-                self._exception = e
-                return
-            else:
-                # Raise the exception right away
-                raise
-
-        # At this point, we are all set to display the graphical window if requested, finally!
-        if not pyglet.options["headless"]:
-            self.set_visible(True)
         self.activate()
 
         # The viewer can be considered as fully initialized at this point
@@ -1220,6 +1238,7 @@ def refresh(self):
                 self._event_loop_step_offscreen()
                 self._offscreen_event.clear()
 
+        self.switch_to()
         pyglet.clock.tick()
 
         if gs.platform != "Windows":
@@ -1229,7 +1248,6 @@ def refresh(self):
             # this is a workaround on Windows. not sure if it's correct
             time.sleep(0.001)
 
-        self.switch_to()
         self.dispatch_pending_events()
         if self._is_active:
             self.dispatch_events()

genesis/utils/mjcf.py

@@ -4,13 +4,15 @@
 from itertools import chain
 from bisect import bisect_right
 
+# Note the importing mujoco with env var `MUJOCO_GL=EGL` forcibly defines `PYOPENGL_PLATFORM=egl`
+import mujoco
+
 import numpy as np
 import trimesh
+import z3
 from trimesh.visual.texture import TextureVisuals
 from PIL import Image
 
-import z3
-import mujoco
 import genesis as gs
 from genesis.ext import urdfpy
 

genesis/vis/viewer.py

@@ -1,6 +1,7 @@
 import importlib
 import os
 import threading
+from traceback import TracebackException
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -114,9 +115,10 @@ def build(self, scene):
                         self._pyrender_viewer.start(auto_refresh=False)
                     self._pyrender_viewer.wait_until_initialized()
                 break
-            except (OpenGL.error.Error, RuntimeError):
+            except (OpenGL.error.Error, RuntimeError) as e:
                 # Invalid OpenGL context. Trying another platform if any...
-                gs.logger.debug("Invalid OpenGL context.")
+                traceback = TracebackException.from_exception(e)
+                gs.logger.debug("".join(traceback.format()))
 
                 # Clear broken OpenGL context if it went this far
                 if self._pyrender_viewer is not None:
@@ -126,6 +128,7 @@ def build(self, scene):
                 if i == len(all_opengl_platforms) - 1:
                     raise
             finally:
+                # Restore original platform systematically
                 del os.environ["PYOPENGL_PLATFORM"]
                 if opengl_platform_orig is not None:
                     os.environ["PYOPENGL_PLATFORM"] = opengl_platform_orig

tests/conftest.py

@@ -19,34 +19,49 @@
 from PIL import Image
 from syrupy.extensions.image import PNGImageSnapshotExtension
 
-has_display = True
+# Mock tkinter module for backward compatibility because it is a hard dependency for old Genesis versions
+has_tkinter = False
 try:
-    from tkinter import Tk
+    import tkinter
 
-    root = Tk()
-    root.withdraw()
-    root.destroy()
-except Exception:  # ImportError, TclError
-    # Mock tkinter module for backward compatibility because it is a hard dependency for old Genesis versions
+    has_tkinter = True
+except ImportError:
     tkinter = type(sys)("tkinter")
     tkinter.Tk = type(sys)("Tk")
     tkinter.filedialog = type(sys)("filedialog")
     sys.modules["tkinter"] = tkinter
     sys.modules["tkinter.Tk"] = tkinter.Tk
     sys.modules["tkinter.filedialog"] = tkinter.filedialog
 
-    # Assuming headless server if tkinder is not installed
-    has_display = False
+# Determine whether a screen is available
+if has_tkinter:
+    has_display = True
+    try:
+        root = tkinter.Tk()
+        root.withdraw()
+        root.destroy()
+    except tkinter.TclError:
+        has_display = False
+else:
+    # Assuming headless server if tkinter is not installed unless DISPLAY env var is available on Linux
+    if sys.platform.startswith("linux"):
+        has_display = bool(os.environ.get("DISPLAY"))
+    else:
+        has_display = False
 
+# Determine whether EGL driver is available
 has_egl = True
 try:
     pyglet.lib.load_library("EGL")
 except ImportError:
     has_egl = False
 
+# Forcibly disable Mujoco OpenGL to avoid conflicts with Genesis
+os.environ["MUJOCO_GL"] = "0"
+
+# pyglet must be configured in headless mode before importing Genesis if necessary.
+# Note that environment variables are used instead of global options to ease option propagation to subprocesses.
 if not has_display and has_egl:
-    # It is necessary to configure pyglet in headless mode if necessary before importing Genesis.
-    # Note that environment variables are used instead of global options to ease option propagation to subprocesses.
     pyglet.options["headless"] = True
     os.environ["PYGLET_HEADLESS"] = "1"
 
@@ -115,7 +130,7 @@ def pytest_cmdline_main(config: pytest.Config) -> None:
         config.option.forked = False
 
     # Force disabling distributed framework if interactive viewer is enabled
-    show_viewer = config.getoption("--vis")
+    show_viewer = config.getoption("--vis", IS_INTERACTIVE_VIEWER_AVAILABLE)
     if show_viewer:
         config.option.numprocesses = 0
 
@@ -383,7 +398,8 @@ def pytest_addoption(parser):
     parser.addoption(
         "--logical", action="store_true", default=False, help="Consider logical cores in default number of workers."
     )
-    parser.addoption("--vis", action="store_true", default=False, help="Enable interactive viewer.")
+    if IS_INTERACTIVE_VIEWER_AVAILABLE:
+        parser.addoption("--vis", action="store_true", default=False, help="Enable interactive viewer.")
     parser.addoption("--dev", action="store_true", default=False, help="Enable genesis debug mode.")
     supported, _reason = is_mem_monitoring_supported()
     help_text = (
@@ -396,7 +412,7 @@ def pytest_addoption(parser):
 
 @pytest.fixture(scope="session")
 def show_viewer(pytestconfig):
-    return pytestconfig.getoption("--vis") and IS_INTERACTIVE_VIEWER_AVAILABLE
+    return pytestconfig.getoption("--vis", IS_INTERACTIVE_VIEWER_AVAILABLE)
 
 
 @pytest.fixture(scope="session")

tests/test_render.py

@@ -1621,19 +1621,41 @@ def test_rasterizer_camera_sensor_with_viewer(renderer):
     This verifies that the sensor properly shares the viewer's OpenGL context instead of
     creating a conflicting separate context.
     """
+    CAM_RES = (128, 64)
+
     scene = gs.Scene(
-        viewer_options=gs.options.ViewerOptions(run_in_thread=False),
+        viewer_options=gs.options.ViewerOptions(
+            res=CAM_RES,
+            run_in_thread=False,
+        ),
         renderer=renderer,
         show_viewer=True,
     )
     # At least one entity is needed to ensure the rendered image is not entirely blank,
     # otherwise it is not possible to verify that something was actually rendered.
     scene.add_entity(morph=gs.morphs.Plane())
-    camera_sensor = scene.add_sensor(RasterizerCameraOptions(res=(256, 256)))
+    camera_sensor = scene.add_sensor(
+        RasterizerCameraOptions(
+            res=CAM_RES,
+        )
+    )
     scene.build()
 
-    assert scene.visualizer.viewer._pyrender_viewer.is_active
+    pyrender_viewer = scene.visualizer.viewer._pyrender_viewer
+    assert pyrender_viewer.is_active
 
     scene.step()
+
+    if sys.platform == "linux":
+        glinfo = pyrender_viewer.context.get_info()
+        renderer = glinfo.get_renderer()
+        if "llvmpipe" in renderer:
+            llvm_version = re.search(r"LLVM\s+([\d.]+)", renderer).group(1)
+            if llvm_version < "20":
+                pytest.skip(
+                    "OpenGL function 'glBlitFramebuffer' involved in offscreen rendering with the interactive viewer "
+                    "takes ages on old CPU-based Mesa rendering driver. Skipping..."
+                )
+
     data = camera_sensor.read()
     assert data.rgb.float().std() > 1.0, "RGB std too low, image may be blank"