Register modular render backend, add mjpython in viewer thread.

Co-authored-by: Copilot <copilot@github.com>

Author: yblei

include/rcs/utils.h

@@ -37,6 +37,7 @@ Eigen::Matrix<double, N, M, Eigen::ColMajor> array2eigen(
 }
 void bootstrap_egl(std::uintptr_t fn_addr, std::uintptr_t display,
                    std::uintptr_t context);
+void bootstrap_gl_context();
 void ensure_current();
 
 }  // namespace common

python/rcs/_core/common.pyi

@@ -321,6 +321,7 @@ def IdentityRotMatrix() -> numpy.ndarray[tuple[typing.Literal[3], typing.Literal
 def IdentityRotQuatVec() -> numpy.ndarray[tuple[typing.Literal[4]], numpy.dtype[numpy.float64]]: ...
 def IdentityTranslation() -> numpy.ndarray[tuple[typing.Literal[3]], numpy.dtype[numpy.float64]]: ...
 def _bootstrap_egl(fn_addr: int, display: int, context: int) -> None: ...
+def _bootstrap_gl_context() -> None: ...
 
 HARDWARE: RobotPlatform  # value = <RobotPlatform.HARDWARE: 1>
 LATERAL_GRASP: GraspType  # value = <GraspType.LATERAL_GRASP: 2>

python/rcs/sim/egl_bootstrap.py

@@ -1,41 +1,60 @@
 """
-Load the EGL library, create a persistent GLContext, and register it with the C++ backend.
+Bootstrap the rendering backend used by the C++ simulation camera path.
 
-Globals prevent the library and context from being garbage-collected.
-Call `bootstrap()` to complete initialization.
+Linux uses MuJoCo's EGL backend. macOS uses a persistent MuJoCo GLContext
+that is made current on the Python thread before C++ creates rendering
+contexts.
 """
 
 import ctypes
 import ctypes.util
 import os
+import sys
 
 _egl_available = False
 _addr_make_current = None
 _egl_display = None
 _egl_context = None
+_backend = None
+_gl_context = None
 
-name = ctypes.util.find_library("EGL")
-if name is not None:
+if sys.platform == "darwin":
     try:
-        import mujoco.egl
-        from mujoco.egl import GLContext
-
-        _egl = ctypes.CDLL(name, mode=os.RTLD_LOCAL | os.RTLD_NOW)
-        _addr_make_current = ctypes.cast(_egl.eglMakeCurrent, ctypes.c_void_p).value
-        _ctx = GLContext(max_width=3840, max_height=2160)
-        _egl_display = int(mujoco.egl.EGL_DISPLAY.address)
-        _egl_context = int(_ctx._context.address)
-        _egl_available = True
+        import mujoco
+
+        _gl_context = mujoco.GLContext(3840, 2160)
+        _backend = "gl_context"
     except Exception:
         pass
+else:
+    name = ctypes.util.find_library("EGL")
+    if name is not None:
+        try:
+            import mujoco.egl
+            from mujoco.egl import GLContext
+
+            _egl = ctypes.CDLL(name, mode=os.RTLD_LOCAL | os.RTLD_NOW)
+            _addr_make_current = ctypes.cast(_egl.eglMakeCurrent, ctypes.c_void_p).value
+            _ctx = GLContext(max_width=3840, max_height=2160)
+            _egl_display = int(mujoco.egl.EGL_DISPLAY.address)
+            _egl_context = int(_ctx._context.address)
+            _egl_available = True
+            _backend = "egl"
+        except Exception:
+            pass
 
 
 def bootstrap():
-    if not _egl_available:
-        return
     import rcs._core as _cxx
 
-    assert _addr_make_current is not None
-    assert _egl_display is not None
-    assert _egl_context is not None
-    _cxx.common._bootstrap_egl(_addr_make_current, _egl_display, _egl_context)
+    if _backend == "gl_context":
+        assert _gl_context is not None
+        _gl_context.make_current()
+        _cxx.common._bootstrap_gl_context()
+        return
+
+    if _backend == "egl":
+        assert _addr_make_current is not None
+        assert _egl_display is not None
+        assert _egl_context is not None
+        _cxx.common._bootstrap_egl(_addr_make_current, _egl_display, _egl_context)

python/rcs/sim/sim.py

@@ -1,6 +1,8 @@
 import atexit
 import contextlib
 import multiprocessing as mp
+import shutil
+import sys
 import typing
 import uuid
 from logging import getLogger
@@ -25,6 +27,21 @@
 logger = getLogger(__name__)
 
 
+def _configure_spawn_executable() -> None:
+    if sys.platform != "darwin":
+        return
+
+    mjpython = shutil.which("mjpython")
+    if mjpython is None:
+        logger.warning("mjpython was not found on PATH; passive MuJoCo viewer may fail on macOS")
+        return
+
+    mp.set_executable(mjpython)
+
+
+_configure_spawn_executable()
+
+
 # Target frames per second
 FPS = 60
 RAW_STATE_ENCODING = "raw"

src/pybind/rcs.cpp

@@ -1,4 +1,3 @@
-#include <pybind11/cast.h>
 #include <pybind11/eigen.h>
 #include <pybind11/operators.h>
 #include <pybind11/pybind11.h>
@@ -253,6 +252,7 @@ PYBIND11_MODULE(_core, m) {
 
   common.def("_bootstrap_egl", &rcs::common::bootstrap_egl, py::arg("fn_addr"),
              py::arg("display"), py::arg("context"));
+  common.def("_bootstrap_gl_context", &rcs::common::bootstrap_gl_context);
   common.def("IdentityTranslation", &rcs::common::IdentityTranslation);
   common.def("IdentityRotMatrix", &rcs::common::IdentityRotMatrix);
   common.def("IdentityRotQuatVec", &rcs::common::IdentityRotQuatVec);

src/rcs/utils.cpp

@@ -6,20 +6,44 @@
 
 namespace rcs {
 namespace common {
+enum class RenderBackend {
+  none,
+  egl,
+  current_context,
+};
+
 static PFNEGLMAKECURRENTPROC g_makeCurrent = nullptr;
 static EGLDisplay g_display = EGL_NO_DISPLAY;
 static EGLSurface g_surface = EGL_NO_SURFACE;
 static EGLContext g_context = EGL_NO_CONTEXT;
+static RenderBackend g_render_backend = RenderBackend::none;
 
 void bootstrap_egl(uintptr_t fn_addr, uintptr_t dpy, uintptr_t ctx) {
   g_makeCurrent = reinterpret_cast<PFNEGLMAKECURRENTPROC>(fn_addr);
   g_display = reinterpret_cast<EGLDisplay>(dpy);
   g_context = reinterpret_cast<EGLContext>(ctx);
+  g_render_backend = RenderBackend::egl;
+}
+
+void bootstrap_gl_context() {
+  g_makeCurrent = nullptr;
+  g_display = EGL_NO_DISPLAY;
+  g_context = EGL_NO_CONTEXT;
+  g_render_backend = RenderBackend::current_context;
 }
 
 void ensure_current() {
-  if (!g_makeCurrent(g_display, g_surface, g_surface, g_context))
+  if (g_render_backend == RenderBackend::current_context) {
+    return;
+  }
+  if (g_render_backend != RenderBackend::egl || g_makeCurrent == nullptr) {
+    throw std::runtime_error(
+        "No rendering context backend initialized. "
+        "Call the Python rendering bootstrap before using simulation cameras.");
+  }
+  if (!g_makeCurrent(g_display, g_surface, g_surface, g_context)) {
     throw std::runtime_error("eglMakeCurrent failed");
+  }
 }
 }  // namespace common
 }  // namespace rcs