Enable loading a render engine plugin from the static plugin registry (#1152)

* Enable loading a render engine plugin from the static plugin registry

Signed-off-by: Shameek Ganguly <shameek@intrinsic.ai>

Author: shameekganguly

ogre/src/OgreRenderEngine.cc

@@ -878,3 +878,5 @@ OgreRenderEngine *OgreRenderEngine::Instance()
 // Register this plugin
 GZ_ADD_PLUGIN(rendering::OgreRenderEnginePlugin,
               rendering::RenderEnginePlugin)
+GZ_ADD_PLUGIN_ALIAS(rendering::OgreRenderEnginePlugin,
+                    "gz::rendering::ogre::Plugin")

ogre2/src/Ogre2RenderEngine.cc

@@ -1453,3 +1453,5 @@ Ogre2RenderEngine *Ogre2RenderEngine::Instance()
 // Register this plugin
 GZ_ADD_PLUGIN(rendering::Ogre2RenderEnginePlugin,
               rendering::RenderEnginePlugin)
+GZ_ADD_PLUGIN_ALIAS(rendering::Ogre2RenderEnginePlugin,
+                    "gz::rendering::ogre2::Plugin")

optix/src/OptixRenderEngine.cc

@@ -143,3 +143,5 @@ OptixRenderEngine *OptixRenderEngine::Instance()
 // Register this plugin
 GZ_ADD_PLUGIN(OptixRenderEnginePlugin,
               rendering::RenderEnginePlugin)
+GZ_ADD_PLUGIN_ALIAS(OptixRenderEnginePlugin,
+                    "gz::rendering::optix::Plugin")

src/RenderEngineManager.cc

@@ -15,8 +15,10 @@
  *
  */
 
+#include <cstddef>
 #include <map>
 #include <mutex>
+#include <string>
 
 #include <gz/common/Console.hh>
 #include <gz/common/SystemPaths.hh>
@@ -48,6 +50,11 @@ class gz::rendering::RenderEngineManagerPrivate
   /// \brief EngineMap iterator.
   typedef EngineMap::iterator EngineIter;
 
+  /// \brief Expected filename prefix for plugin to be loaded from the static
+  /// registry.
+  public: static constexpr std::string_view kStaticPluginFilenamePrefix =
+      "static://";
+
   /// \brief Get a pointer to the render engine from an EngineMap iterator.
   /// \param[in] _iter EngineMap iterator
   /// \param[in] _path Another search path for rendering engine plugin.
@@ -78,6 +85,11 @@ class gz::rendering::RenderEngineManagerPrivate
   public: bool LoadEnginePlugin(const std::string &_filename,
               const std::string &_path);
 
+  /// \brief Load a render engine plugin from the static plugin registry.
+  /// \param[in] _filename Filename of plugin
+  /// \return True if the plugin is loaded successfully
+  public: bool LoadStaticEnginePlugin(const std::string &_filename);
+
   /// \brief Unload a render engine plugin.
   /// \param[in] _engineName Name of engine associated with this plugin
   /// \return True if the plugin is unloaded successfully
@@ -431,32 +443,67 @@ bool RenderEngineManagerPrivate::UnloadEngine(EngineIter _iter)
 //////////////////////////////////////////////////
 void RenderEngineManagerPrivate::RegisterDefaultEngines()
 {
-  // TODO(anyone): Find a cleaner way to get the default engine library name
 
-  // cppcheck-suppress unreadVariable
-  std::string libName = "gz-rendering-";
+  auto registerStaticOrSolibPlugin = [this](const std::string& _engineName,
+      const std::string& _staticFilename, const std::string& _solibFilename)
+  {
+    std::lock_guard<std::recursive_mutex> lock(this->enginesMutex);
+    // Check static plugin registry if the plugin was statically linked in.
+    constexpr size_t prefixLen = kStaticPluginFilenamePrefix.size();
+    const std::string staticPluginAlias = _staticFilename.substr(prefixLen);
+    if (!this->pluginLoader.PluginsWithAlias(staticPluginAlias).empty())
+    {
+      this->defaultEngines[_engineName] = _staticFilename;
+      if (this->engines.find(_staticFilename) == this->engines.end())
+        this->engines[_staticFilename] = nullptr;
+      return;
+    }
+    // Else if a .so lib plugin file is expected, register that as the default.
+    if (!_solibFilename.empty())
+    {
+      this->defaultEngines[_engineName] = _solibFilename;
+      if (this->engines.find(_solibFilename) == this->engines.end())
+        this->engines[_solibFilename] = nullptr;
+    }
+  };
 
-  // cppcheck-suppress unusedVariable
-  std::string engineName;
+  // TODO(anyone): Find a cleaner way to get the default engine .so library name
+  // cppcheck-suppress unreadVariable
+  const std::string libNamePrefix = "gz-rendering-";
 
-  std::lock_guard<std::recursive_mutex> lock(this->enginesMutex);
+  // Register Ogre
+  const std::string ogreEngineName = "ogre";
+  const std::string ogreStaticFilename = "static://gz::rendering::ogre::Plugin";
 #if GZ_RENDERING_HAVE_OGRE
-  engineName = "ogre";
-  this->defaultEngines[engineName] = libName + engineName;
-  if (this->engines.find(libName + engineName) == this->engines.end())
-    this->engines[libName + engineName] = nullptr;
+  registerStaticOrSolibPlugin(ogreEngineName, ogreStaticFilename,
+      libNamePrefix + ogreEngineName);
+#else
+  registerStaticOrSolibPlugin(ogreEngineName, ogreStaticFilename,
+      /*_solibFilename=*/"");
 #endif
+
+  // Register Ogre2
+  const std::string ogre2EngineName = "ogre2";
+  const std::string ogre2StaticFilename =
+      "static://gz::rendering::ogre2::Plugin";
 #if GZ_RENDERING_HAVE_OGRE2
-  engineName = "ogre2";
-  this->defaultEngines[engineName] = libName + engineName;
-  if (this->engines.find(libName + engineName) == this->engines.end())
-    this->engines[libName + engineName] = nullptr;
+  registerStaticOrSolibPlugin(ogre2EngineName, ogre2StaticFilename,
+      libNamePrefix + ogre2EngineName);
+#else
+  registerStaticOrSolibPlugin(ogre2EngineName, ogre2StaticFilename,
+      /*_solibFilename=*/"");
 #endif
+
+  // Register Optix
+  const std::string optixEngineName = "optix";
+  const std::string optixStaticFilename =
+      "static://gz::rendering::optix::Plugin";
 #if GZ_RENDERING_HAVE_OPTIX
-  engineName = "optix";
-  this->defaultEngines[engineName] = libName + engineName;
-  if (this->engines.find(libName + engineName) == this->engines.end())
-    this->engines[libName + engineName] = nullptr;
+  registerStaticOrSolibPlugin(optixEngineName, optixStaticFilename,
+      libNamePrefix + optixEngineName);
+#else
+  registerStaticOrSolibPlugin(optixEngineName, optixStaticFilename,
+      /*_solibFilename=*/"");
 #endif
 }
 
@@ -466,6 +513,12 @@ bool RenderEngineManagerPrivate::LoadEnginePlugin(
 {
   gzmsg << "Loading plugin [" << _filename << "]" << std::endl;
 
+  constexpr size_t prefixLen = kStaticPluginFilenamePrefix.size();
+  if (_filename.substr(0, prefixLen) == kStaticPluginFilenamePrefix)
+  {
+    return this->LoadStaticEnginePlugin(_filename);
+  }
+
   gz::common::SystemPaths systemPaths;
   systemPaths.SetPluginPathEnv(this->pluginPathEnv);
 
@@ -560,10 +613,52 @@ bool RenderEngineManagerPrivate::LoadEnginePlugin(
   return true;
 }
 
+//////////////////////////////////////////////////
+bool RenderEngineManagerPrivate::LoadStaticEnginePlugin(
+    const std::string &_filename)
+{
+  constexpr size_t prefixLen = kStaticPluginFilenamePrefix.size();
+  const std::string filenameWoPrefix = _filename.substr(prefixLen);
+
+  gzmsg << "Loading plugin [" << filenameWoPrefix << "] from static registry"
+        << std::endl;
+
+  auto plugin = this->pluginLoader.Instantiate(filenameWoPrefix);
+  if (!plugin)
+  {
+    gzerr << "Failed to load static render engine plugin [" << filenameWoPrefix
+          << "]. Static plugin registry does not contain this plugin."
+          << std::endl;
+    return false;
+  }
+
+  auto renderPlugin = plugin->QueryInterface<rendering::RenderEnginePlugin>();
+  if (!renderPlugin)
+  {
+    gzerr << "Failed to find RenderEnginePlugin interface in static render "
+          << "engine plugin [" << _filename << "]" << std::endl;
+    return false;
+  }
+
+  // Instantiate the engine
+  {
+    std::lock_guard<std::recursive_mutex> lock(this->enginesMutex);
+    this->engines[_filename] = renderPlugin->Engine();
+  }
+
+  return true;
+}
+
 //////////////////////////////////////////////////
 bool RenderEngineManagerPrivate::UnloadEnginePlugin(
     const std::string &_engineName)
 {
+  const size_t prefix_len = kStaticPluginFilenamePrefix.length();
+  if (_engineName.substr(0, prefix_len) == kStaticPluginFilenamePrefix)
+  {
+    return true;
+  }
+
   auto it = this->enginePlugins.find(_engineName);
   if (it == this->enginePlugins.end())
   {

test/BUILD.bazel

@@ -0,0 +1,21 @@
+package(
+    default_applicable_licenses = ["//:license"],
+    features = [
+        "layering_check",
+        "parse_headers",
+    ],
+)
+
+cc_test(
+    name = "INTEGRATION_load_static_render_engine_plugin",
+    srcs = ["integration/load_static_render_engine_plugin.cc"],
+    env = {"GZ_BAZEL": "1"},
+    deps = [
+        "//:gz-rendering",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+        "@gz-common",
+        "@gz-plugin//:loader",
+        "@gz-plugin//:register",
+    ],
+)

test/integration/load_static_render_engine_plugin.cc

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2025 Open Source Robotics Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <memory>
+#include <string>
+
+#include <gtest/gtest.h>
+
+#include <gz/common/Console.hh>
+
+#include <gz/plugin/Loader.hh>
+#include <gz/plugin/RegisterStatic.hh>
+
+#include <gz/rendering/base/BaseRenderEngine.hh>
+#include <gz/rendering/base/BaseScene.hh>
+#include <gz/rendering/base/BaseStorage.hh>
+#include <gz/rendering/RenderingIface.hh>
+#include <gz/rendering/RenderEnginePlugin.hh>
+
+using namespace gz;
+using namespace rendering;
+
+namespace {
+// Dummy scene class used in the render engine below.
+class DummyScene final: public BaseScene
+{};
+
+// Dummy singleton render engine used in the render engine plugin below.
+class DummyRenderEngine final: public BaseRenderEngine
+{
+public: typedef BaseSceneStore<DummyScene> DummySceneStore;
+public: typedef std::shared_ptr<DummySceneStore> DummySceneStorePtr;
+
+public: static DummyRenderEngine* Instance();
+
+private: DummyRenderEngine();
+
+public: std::string Name() const override {return "test_engine";}
+
+protected: bool LoadImpl(const std::map<std::string,
+    std::string> &_params) override {return true;}
+
+protected: bool InitImpl() override {return true;}
+
+protected: ScenePtr CreateSceneImpl(unsigned int _id,
+        const std::string &_name) override {return nullptr;}
+
+protected: SceneStorePtr Scenes() const override {return this->sceneStore; }
+
+private: DummySceneStorePtr sceneStore;
+};
+
+DummyRenderEngine* DummyRenderEngine::Instance()
+{
+  static DummyRenderEngine engine;
+  return &engine;
+}
+
+DummyRenderEngine::DummyRenderEngine()
+: sceneStore(std::make_shared<DummySceneStore>())
+{}
+
+// Dummy render engine plugin used in the test below. Note that the plugin is
+// registered with the static plugin registry at the bottom of this file.
+class DummyRenderEnginePlugin final : public RenderEnginePlugin
+{
+public: DummyRenderEnginePlugin();
+
+public: std::string Name() const override {return engine->Name();}
+
+public: RenderEngine *Engine() const override {return engine;}
+
+private: DummyRenderEngine* engine;
+};
+
+DummyRenderEnginePlugin::DummyRenderEnginePlugin()
+: engine(DummyRenderEngine::Instance())
+{}
+
+// Test that the dummy render engine plugin can be loaded from the static plugin
+// registry.
+TEST(LoadStaticRenderEnginePlugin, LoadUnloadWorks)
+{
+  plugin::Loader pluginLoader;
+  const std::string pluginName =
+      pluginLoader.LookupPlugin("DummyRenderEnginePlugin");
+  EXPECT_FALSE(pluginName.empty());
+
+  const std::string engineFilename = "static://DummyRenderEnginePlugin";
+  RenderEngine *engine = rendering::engine(engineFilename);
+  EXPECT_NE(nullptr, engine);
+
+  EXPECT_EQ(DummyRenderEngine::Instance(), engine);
+
+  EXPECT_TRUE(rendering::unloadEngine(engineFilename));
+}
+
+// Register the plugin with the static registry
+GZ_ADD_STATIC_PLUGIN(DummyRenderEnginePlugin, RenderEnginePlugin)
+GZ_ADD_STATIC_PLUGIN_ALIAS(DummyRenderEnginePlugin, "DummyRenderEnginePlugin")
+
+}  // namespace