[workspace] Load X11 lazily (#23604)

X11 is not loaded until the first time its needed. Rendering via EGL
will not load it. (We still require X11 at build-time.)

Author: jwnimmer-tri

geometry/render_gl/BUILD.bazel

@@ -46,7 +46,7 @@ drake_cc_library(
     ] + select({
         "@drake//tools/skylark:linux": [
             "@vtk_internal//:vtkglad",
-            "@x11",
+            "@vtk_internal//:vtkx11",
         ],
         "//conditions:default": [],
     }),

geometry/render_gl/internal_loaders.cc

@@ -5,6 +5,7 @@
 #include <string>
 
 #if !defined(__APPLE__)
+#include <vtkX11Functions.h>
 #include <vtkglad/include/glad/egl.h>
 #include <vtkglad/include/glad/glx.h>
 #endif
@@ -56,8 +57,9 @@ void* GladLoaderLoadGlx() {
   // exits (https://linux.die.net/man/3/xclosedisplay), but it seems not so
   // evil to skip that.
   static Display* g_display = []() {
-    XInitThreads();
-    Display* display = XOpenDisplay(0);
+    vtkX11FunctionsInitialize();
+    vtkXInitThreads();
+    Display* display = vtkXOpenDisplay(0);
     if (display == nullptr) {
       const char* display_env = std::getenv("DISPLAY");
       throw std::logic_error(

geometry/render_gl/internal_opengl_context.cc

@@ -7,9 +7,10 @@
 #include <string>
 #include <utility>
 
-// Note: This is intentionally included here since it's only needed at the
+// Note: These are intentionally included here since they are only needed at the
 // implementation level, and not in a grouping of more generic headers like
 // opengl_includes.h. See opengl_context.h for where pimpl is applied.
+#include <vtkX11Functions.h>
 #include <vtkglad/include/glad/glx.h>
 
 #include "drake/common/drake_assert.h"
@@ -119,7 +120,7 @@ class OpenGlContext::Impl {
     GLXFBConfig* fb_configs =
         glXChooseFBConfig(display(), screen_id, kVisualAttribs, &fb_count);
     ScopeExit guard([fb_configs]() {
-      XFree(fb_configs);
+      vtkXFree(fb_configs);
     });
     if (fb_configs == nullptr) {
       throw std::runtime_error(
@@ -139,7 +140,7 @@ class OpenGlContext::Impl {
           "unavailable.");
     }
     ScopeExit visual_guard([visual]() {
-      XFree(visual);
+      vtkXFree(visual);
     });
     XSetWindowAttributes window_attribs;
 
@@ -149,23 +150,23 @@ class OpenGlContext::Impl {
     bool is_complete = false;
 
     // This requires a call to XFreeColormap in the destructor.
-    window_attribs.colormap = XCreateColormap(
+    window_attribs.colormap = vtkXCreateColormap(
         display(), RootWindow(display(), screen_id), visual->visual, AllocNone);
     ScopeExit colormap_guard(
         [colormap = window_attribs.colormap, &is_complete]() {
-          if (!is_complete) XFreeColormap(display(), colormap);
+          if (!is_complete) vtkXFreeColormap(display(), colormap);
         });
 
     // Enable just the Expose event so we know when the window is ready to be
     // redrawn.
     window_attribs.event_mask = ExposureMask;
     // This requires a call to XDestroyWindow in the destructor.
-    window_ = XCreateWindow(display(), RootWindow(display(), screen_id), 0, 0,
-                            window_width_, window_height_, 0, visual->depth,
-                            InputOutput, visual->visual,
-                            CWColormap | CWEventMask, &window_attribs);
+    window_ = vtkXCreateWindow(display(), RootWindow(display(), screen_id), 0,
+                               0, window_width_, window_height_, 0,
+                               visual->depth, InputOutput, visual->visual,
+                               CWColormap | CWEventMask, &window_attribs);
     ScopeExit window_guard([window = window_, &is_complete]() {
-      if (!is_complete) XDestroyWindow(display(), window);
+      if (!is_complete) vtkXDestroyWindow(display(), window);
     });
 
     // Create an OpenGL context.
@@ -185,7 +186,7 @@ class OpenGlContext::Impl {
       if (!is_complete) glXDestroyContext(display(), context);
     });
 
-    XSync(display(), False);
+    vtkXSync(display(), False);
 
     // Enable debug.
     if (debug) {
@@ -205,9 +206,9 @@ class OpenGlContext::Impl {
   ~Impl() {
     glXDestroyContext(display(), context_);
     XWindowAttributes window_attribs;
-    XGetWindowAttributes(display(), window_, &window_attribs);
-    XFreeColormap(display(), window_attribs.colormap);
-    XDestroyWindow(display(), window_);
+    vtkXGetWindowAttributes(display(), window_, &window_attribs);
+    vtkXFreeColormap(display(), window_attribs.colormap);
+    vtkXDestroyWindow(display(), window_);
   }
 
   void MakeCurrent() const {
@@ -230,14 +231,14 @@ class OpenGlContext::Impl {
 
   void DisplayWindow(const int width, const int height) {
     if (width != window_width_ || height != window_height_) {
-      XResizeWindow(display(), window_, width, height);
+      vtkXResizeWindow(display(), window_, width, height);
       // If the window isn't viewable, it won't send an expose event.
       if (IsWindowViewable()) WaitForExposeEvent();
       window_width_ = width;
       window_height_ = height;
     }
     if (!IsWindowViewable()) {
-      XMapRaised(display(), window_);
+      vtkXMapRaised(display(), window_);
       WaitForExposeEvent();
     }
     // We wait for confirmation events to make sure we don't attempt to draw
@@ -249,14 +250,14 @@ class OpenGlContext::Impl {
 
   void HideWindow() {
     if (IsWindowViewable()) {
-      XUnmapWindow(display(), window_);
+      vtkXUnmapWindow(display(), window_);
       // Unmapping a window provides no events on that window.
     }
   }
 
   bool IsWindowViewable() const {
     XWindowAttributes attr;
-    const Status status = XGetWindowAttributes(display(), window_, &attr);
+    const Status status = vtkXGetWindowAttributes(display(), window_, &attr);
 
     // In xlib, a zero status implies function failure.
     // https://tronche.com/gui/x/xlib/introduction/errors.html#Status
@@ -269,15 +270,15 @@ class OpenGlContext::Impl {
   }
 
   void UpdateWindow() {
-    XClearWindow(display(), window_);
+    vtkXClearWindow(display(), window_);
     glXSwapBuffers(display(), window_);
   }
 
   // Waits for the display() to transmit an Expose event.
   void WaitForExposeEvent() const {
     XEvent event;
     // This blocks until the window gets an "Expose" event.
-    XWindowEvent(display(), window_, ExposureMask, &event);
+    vtkXWindowEvent(display(), window_, ExposureMask, &event);
     DRAKE_DEMAND(event.type == Expose);
   }
 

geometry/render_vtk/BUILD.bazel

@@ -63,7 +63,6 @@ drake_cc_library(
         "//geometry/render_gl:internal_loaders",
         "@vtk_internal//:vtkRenderingCore",
         "@vtk_internal//:vtkRenderingOpenGL2",
-        "@vtk_internal//:vtkglad",
     ],
 )
 

geometry/render_vtk/internal_make_render_window.cc

@@ -43,10 +43,6 @@ vtkSmartPointer<vtkRenderWindow> MakeRenderWindow(
     }
     case RenderEngineVtkBackend::kGlx: {
 #if !defined(__APPLE__)
-      // Open the library at most once per process. This is important because
-      // loading the library every time leaks resources ("too many clients")
-      // that are in short supply when using a typical Xorg server.
-      vtkX11FunctionsInitialize();
       Display* display =
           static_cast<Display*>(render_gl::internal::GladLoaderLoadGlx());
       DRAKE_DEMAND(display != nullptr);

tools/install/libdrake/BUILD.bazel

@@ -330,17 +330,6 @@ cc_library(
     }),
 )
 
-# Depend on X11 iff on Ubuntu and not MacOS.
-cc_library(
-    name = "x11_deps",
-    deps = select({
-        "//conditions:default": [
-            "@x11",
-        ],
-        "//tools/cc_toolchain:apple": [],
-    }),
-)
-
 # Provide a cc_library target that provides libdrake.so, its headers, its
 # header-only dependencies, and its required *.so's.  This is aliased by
 # `//:drake_shared_library`, which is what downstream users will consume if
@@ -371,7 +360,6 @@ cc_library(
     deps = [
         ":gurobi_deps",
         ":mosek_deps",
-        ":x11_deps",
         "//common:drake_marker_shared_library",
         "//tools/workspace/fmt:shared_library_maybe",
         "//tools/workspace/lcm_internal:shared_library_maybe",

tools/workspace/vtk_internal/patches/upstream/utilities_x11_more_functions.patch

@@ -0,0 +1,79 @@
+[vtk] Add more X11 function pointers
+
+--- Utilities/X11/vtkX11Functions.cxx
++++ Utilities/X11/vtkX11Functions.cxx
+@@ -79,6 +79,11 @@ DEFINE_POINTER_TO_FUNCTION(vtkXCreateWindow);
+ DEFINE_POINTER_TO_FUNCTION(vtkXRootWindowOfScreen);
+ DEFINE_POINTER_TO_FUNCTION(vtkXRootWindow);
+ DEFINE_POINTER_TO_FUNCTION(vtkXGetVisualInfo);
++DEFINE_POINTER_TO_FUNCTION(vtkXClearWindow);
++DEFINE_POINTER_TO_FUNCTION(vtkXFreeColormap);
++DEFINE_POINTER_TO_FUNCTION(vtkXInitThreads);
++DEFINE_POINTER_TO_FUNCTION(vtkXMapRaised);
++DEFINE_POINTER_TO_FUNCTION(vtkXWindowEvent);
+ 
+ // Xcursor API
+ #if VTK_HAVE_XCURSOR
+@@ -167,6 +172,11 @@ extern "C"
+       LOAD_POINTER_TO_FUNCTION(libX11, XRootWindowOfScreen, vtkXRootWindowOfScreen);
+       LOAD_POINTER_TO_FUNCTION(libX11, XRootWindow, vtkXRootWindow);
+       LOAD_POINTER_TO_FUNCTION(libX11, XGetVisualInfo, vtkXGetVisualInfo);
++      LOAD_POINTER_TO_FUNCTION(libX11, XClearWindow, vtkXClearWindow);
++      LOAD_POINTER_TO_FUNCTION(libX11, XFreeColormap, vtkXFreeColormap);
++      LOAD_POINTER_TO_FUNCTION(libX11, XInitThreads, vtkXInitThreads);
++      LOAD_POINTER_TO_FUNCTION(libX11, XMapRaised, vtkXMapRaised);
++      LOAD_POINTER_TO_FUNCTION(libX11, XWindowEvent, vtkXWindowEvent);
+ #if VTK_HAVE_XCURSOR
+       libXcursor = dlopen("libXcursor.so", RTLD_LAZY | RTLD_GLOBAL);
+       if (libXcursor == nullptr)
+@@ -245,6 +255,11 @@ extern "C"
+       NULLIFY_POINTER_TO_FUNCTION(vtkXRootWindowOfScreen);
+       NULLIFY_POINTER_TO_FUNCTION(vtkXRootWindow);
+       NULLIFY_POINTER_TO_FUNCTION(vtkXGetVisualInfo);
++      NULLIFY_POINTER_TO_FUNCTION(vtkXClearWindow);
++      NULLIFY_POINTER_TO_FUNCTION(vtkXFreeColormap);
++      NULLIFY_POINTER_TO_FUNCTION(vtkXInitThreads);
++      NULLIFY_POINTER_TO_FUNCTION(vtkXMapRaised);
++      NULLIFY_POINTER_TO_FUNCTION(vtkXWindowEvent);
+ 
+ // Xcursor API
+ #if VTK_HAVE_XCURSOR
+
+--- Utilities/X11/vtkX11Functions.h.in
++++ Utilities/X11/vtkX11Functions.h.in
+@@ -111,6 +111,11 @@
+ #define vtkXRootWindowOfScreen VTK_ABI_NAMESPACE_MANGLE(vtkXRootWindowOfScreen)
+ #define vtkXRootWindow VTK_ABI_NAMESPACE_MANGLE(vtkXRootWindow)
+ #define vtkXGetVisualInfo VTK_ABI_NAMESPACE_MANGLE(vtkXGetVisualInfo)
++#define vtkXClearWindow VTK_ABI_NAMESPACE_MANGLE(vtkXClearWindow)
++#define vtkXFreeColormap VTK_ABI_NAMESPACE_MANGLE(vtkXFreeColormap)
++#define vtkXInitThreads VTK_ABI_NAMESPACE_MANGLE(vtkXInitThreads)
++#define vtkXMapRaised VTK_ABI_NAMESPACE_MANGLE(vtkXMapRaised)
++#define vtkXWindowEvent VTK_ABI_NAMESPACE_MANGLE(vtkXWindowEvent)
+ 
+ #if VTK_HAVE_XCURSOR
+ #define vtkXcursorFilenameLoadCursor VTK_ABI_NAMESPACE_MANGLE(vtkXcursorFilenameLoadCursor)
+@@ -198,6 +203,11 @@ extern "C"
+   typedef Window (*vtkXRootWindowOfScreenType)(Screen*);
+   typedef Window (*vtkXRootWindowType)(Display*, int);
+   typedef XVisualInfo* (*vtkXGetVisualInfoType)(Display*, long, XVisualInfo*, int*);
++  typedef int (*vtkXClearWindowType)(Display*, Window);
++  typedef Colormap (*vtkXFreeColormapType)(Display*, Window);
++  typedef Status (*vtkXInitThreadsType)();
++  typedef int (*vtkXMapRaisedType)(Display*, Window);
++  typedef int (*vtkXWindowEventType)(Display*, Window, long, XEvent*);
+   // Xcursor API
+ #if VTK_HAVE_XCURSOR
+   typedef Cursor (*vtkXcursorFilenameLoadCursorType)(Display*, const char*);
+@@ -263,6 +273,11 @@ extern "C"
+   VTKX11_EXPORT extern vtkXRootWindowOfScreenType vtkXRootWindowOfScreen;
+   VTKX11_EXPORT extern vtkXRootWindowType vtkXRootWindow;
+   VTKX11_EXPORT extern vtkXGetVisualInfoType vtkXGetVisualInfo;
++  VTKX11_EXPORT extern vtkXClearWindowType vtkXClearWindow;
++  VTKX11_EXPORT extern vtkXFreeColormapType vtkXFreeColormap;
++  VTKX11_EXPORT extern vtkXInitThreadsType vtkXInitThreads;
++  VTKX11_EXPORT extern vtkXMapRaisedType vtkXMapRaised;
++  VTKX11_EXPORT extern vtkXWindowEventType vtkXWindowEvent;
+   // Xcursor API
+ #if VTK_HAVE_XCURSOR
+   VTKX11_EXPORT extern vtkXcursorFilenameLoadCursorType vtkXcursorFilenameLoadCursor;

tools/workspace/vtk_internal/repository.bzl

@@ -198,6 +198,7 @@ def vtk_internal_repository(
             ":patches/upstream/common_core_rm_iostream.patch",
             ":patches/upstream/rendering_core_vtkcomposite_exception.patch",
             ":patches/upstream/rendering_opengl2_scaled_albedo_for_ibl.patch",
+            ":patches/upstream/utilities_x11_more_functions.patch",
             ":patches/upstream/utilities_x11_vtk_cursor_guard.patch",
             ":patches/upstream/vtkpugixml_global_ctor.patch",
             ":patches/common_core_fmt12.patch",

tools/workspace/vtk_internal/settings.bzl

@@ -80,6 +80,7 @@ MODULE_SETTINGS = {
         }),
     },
     "VTK::x11": {
+        "visibility": ["//visibility:public"],
         "cmake_defines": select({
             ":osx": [],
             "//conditions:default": [
@@ -92,6 +93,15 @@ MODULE_SETTINGS = {
             ],
             "//conditions:default": [],
         }),
+        # Propagate X11 include dirs to dependents so that they can access X11
+        # structs and definitions. This mimics `vtk_module_include(VTK::x11
+        # INTERFACE ${X11_INCLUDE_DIR})` from upstream.
+        "deps_extra": select({
+            ":osx": [],
+            "//conditions:default": [
+                "@drake//tools/workspace/x11:hdrs",
+            ],
+        }),
     },
 
     # Second, we'll configure the modules Drake needs (in alphabetical order).
@@ -558,13 +568,6 @@ MODULE_SETTINGS = {
             ],
             "//conditions:default": [],
         }),
-        "deps_extra": select({
-            ":osx": [],
-            "//conditions:default": [
-                # Mimic vtk_module_link(... X11::X11) from upstream.
-                "@x11",
-            ],
-        }),
         "module_deps_ignore": [
             "VTK::IOXML",
             "VTK::RenderingFreeType",

tools/workspace/x11/BUILD.bazel

@@ -1,5 +1,6 @@
 load("//tools/install:install.bzl", "install")
 load("//tools/lint:lint.bzl", "add_lint_tests")
+load("//tools/skylark:drake_cc.bzl", "cc_nolink_library")
 
 # ---- Logic for choosing which x11 to use. ---
 
@@ -12,6 +13,12 @@ alias(
     visibility = ["//visibility:public"],
 )
 
+cc_nolink_library(
+    name = "hdrs",
+    visibility = ["@vtk_internal//:__pkg__"],
+    deps = ["@x11"],
+)
+
 # ---- Logic for installing x11-related files. ---
 
 install(