Download models in the background

include/gz/sim/ServerConfig.hh

@@ -445,6 +445,18 @@ namespace gz
       public: const std::chrono::time_point<std::chrono::system_clock> &
               Timestamp() const;
 
+      /// \brief Set whether asset download should block simulation start.
+      /// The default value is true.
+      /// \param[in] _set True to wait while assets download. False will
+      /// download assets in a background thread.
+      public: void SetWaitForAssets(bool _set);
+
+      /// \brief Get whether asset download should block simulation start.
+      /// The default value is true.
+      /// \return True if simulation should wait while assets download. False
+      /// indicates assets should be downloaded in a separate thread.
+      public: bool WaitForAssets() const;
+
       /// \brief Get the type of source
       /// \return The source type.
       public: SourceType Source() const;

src/Conversions.cc

@@ -257,7 +257,7 @@ msgs::Geometry gz::sim::convert(const sdf::Geometry &_in)
       }
     }
   }
-  else
+  else if (_in.Type() != sdf::GeometryType::EMPTY)
   {
     gzerr << "Geometry type [" << static_cast<int>(_in.Type())
            << "] not supported" << std::endl;

src/Server.cc

@@ -45,6 +45,9 @@ Server::Server(const ServerConfig &_config)
     config.SetCacheLocation(_config.ResourceCache());
   this->dataPtr->fuelClient = std::make_unique<fuel_tools::FuelClient>(config);
 
+  // Turn on/off downloads.
+  this->dataPtr->enableDownload = _config.WaitForAssets();
+
   // Configure SDF to fetch assets from Gazebo Fuel.
   sdf::setFindCallback(std::bind(&ServerPrivate::FetchResource,
         this->dataPtr.get(), std::placeholders::_1));
@@ -57,16 +60,18 @@ Server::Server(const ServerConfig &_config)
 
   // Ignore the sdf::Errors returned by this function. The errors will be
   // displayed later in the downloadThread.
-  this->dataPtr->LoadSdfRootHelper(_config, this->dataPtr->sdfRoot, outputMsgs);
+  sdf::Errors errors = this->dataPtr->LoadSdfRootHelper(_config,
+      this->dataPtr->sdfRoot, outputMsgs);
   gzmsg << outputMsgs;
 
-  // Remove all the models from the primary sdfRoot object so that they can
-  // be downloaded and added to simulation in the background.
-  for (uint64_t i = 0; i < this->dataPtr->sdfRoot.WorldCount(); ++i)
+  if (_config.WaitForAssets())
   {
-    this->dataPtr->sdfRoot.WorldByIndex(i)->ClearModels();
-    this->dataPtr->sdfRoot.WorldByIndex(i)->ClearActors();
-    this->dataPtr->sdfRoot.WorldByIndex(i)->ClearLights();
+    if (!errors.empty())
+    {
+      for (auto &err : errors)
+        gzerr << err << "\n";
+      return;
+    }
   }
 
   // Add record plugin
@@ -77,6 +82,72 @@ Server::Server(const ServerConfig &_config)
 
   this->dataPtr->CreateEntities();
 
+  if (!_config.WaitForAssets())
+  {
+    // Remove all the models from the primary sdfRoot object so that they can
+    // be downloaded and added to simulation in the background.
+    for (uint64_t i = 0; i < this->dataPtr->sdfRoot.WorldCount(); ++i)
+    {
+      this->dataPtr->sdfRoot.WorldByIndex(i)->ClearModels();
+      this->dataPtr->sdfRoot.WorldByIndex(i)->ClearActors();
+      this->dataPtr->sdfRoot.WorldByIndex(i)->ClearLights();
+    }
+
+    // Turn on downloads.
+    this->dataPtr->enableDownload = true;
+
+    // Force each simulation runner to remain paused until the downloads are
+    // complete.
+    for (auto &runner : this->dataPtr->simRunners)
+    {
+      runner->SetForcedPause(true);
+    }
+
+    // Download models in a separate thread.
+    this->dataPtr->downloadThread = std::thread([&]()
+    {
+      // Reload the SDF root, which will cause the models to download.
+      sdf::Root localRoot;
+      std::string ignoreMessages;
+      sdf::Errors localErrors = this->dataPtr->LoadSdfRootHelper(_config,
+          localRoot, ignoreMessages);
+
+      // Output any errors.
+      if (!localErrors.empty())
+      {
+        for (auto &err : localErrors)
+          gzerr << err << "\n";
+      }
+      else
+      {
+        // Add the models back into the worlds.
+        for (auto &runner : this->dataPtr->simRunners)
+        {
+          std::string worldName = runner->WorldSdf().Name();
+          const sdf::World *world = localRoot.WorldByName(worldName);
+          if (world)
+          {
+            for (uint64_t i = 0; i < world->ActorCount(); ++i)
+              runner->CreateEntity(*world->ActorByIndex(i));
+            for (uint64_t i = 0; i < world->LightCount(); ++i)
+              runner->CreateEntity(*world->LightByIndex(i));
+            for (uint64_t i = 0; i < world->ModelCount(); ++i)
+              runner->CreateEntity(*world->ModelByIndex(i));
+          }
+          else
+          {
+            gzerr << "Unable to find world with name[" << worldName << "]. "
+              << "Downloaded models may not appear.\n";
+          }
+
+          // Allow the runner to resume normal operations.
+          runner->SetForcedPause(false);
+        }
+      }
+    });
+  }
+
+
   // Set the desired update period, this will override the desired RTF given in
   // the world file which was parsed by CreateEntities.
   if (_config.UpdatePeriod())
@@ -87,58 +158,7 @@ Server::Server(const ServerConfig &_config)
   // Establish publishers and subscribers.
   this->dataPtr->SetupTransport();
 
-  // Turn on downloads.
-  this->dataPtr->enableDownload = true;
-
-  // Force each simulation runner to remain paused until the downloads are
-  // complete.
-  for (auto &runner : this->dataPtr->simRunners)
-  {
-    runner->SetForcedPause(true);
-  }
-
-  // Download models in a separate thread.
-  this->dataPtr->downloadThread = std::thread([&]()
-  {
-    // Reload the SDF root, which will cause the models to download.
-    sdf::Root localRoot;
-    std::string ignoreMessages;
-    sdf::Errors errors = this->dataPtr->LoadSdfRootHelper(_config,
-        localRoot, ignoreMessages);
-
-    // Output any errors.
-    if (!errors.empty())
-    {
-      for (auto &err : errors)
-        gzerr << err << "\n";
-    }
-    else
-    {
-      // Add the models back into the worlds.
-      for (auto &runner : this->dataPtr->simRunners)
-      {
-        std::string worldName = runner->WorldSdf().Name();
-        const sdf::World *world = localRoot.WorldByName(worldName);
-        if (world)
-        {
-          for (uint64_t i = 0; i < world->ActorCount(); ++i)
-            runner->CreateEntity(*world->ActorByIndex(i));
-          for (uint64_t i = 0; i < world->LightCount(); ++i)
-            runner->CreateEntity(*world->LightByIndex(i));
-          for (uint64_t i = 0; i < world->ModelCount(); ++i)
-            runner->CreateEntity(*world->ModelByIndex(i));
-        }
-        else
-        {
-          gzerr << "Unable to find world with name[" << worldName << "]. "
-            << "Downloaded models may not appear.\n";
-        }
 
-        // Allow the runner to resume normal operations.
-        runner->SetForcedPause(false);
-      }
-    }
-  });
 }
 
 /////////////////////////////////////////////////

src/ServerConfig.cc

@@ -333,6 +333,9 @@ class gz::sim::ServerConfigPrivate
 
   /// \brief Type of source used.
   public: ServerConfig::SourceType source{ServerConfig::SourceType::kNone};
+
+  /// \brief True to block while simulation assets download.
+  public: bool waitForAssets = true;
 };
 
 //////////////////////////////////////////////////
@@ -719,6 +722,18 @@ ServerConfig::Timestamp() const
   return this->dataPtr->timestamp;
 }
 
+/////////////////////////////////////////////////
+void ServerConfig::SetWaitForAssets(bool _set)
+{
+  this->dataPtr->waitForAssets = _set;
+}
+
+/////////////////////////////////////////////////
+bool ServerConfig::WaitForAssets() const
+{
+  return this->dataPtr->waitForAssets;
+}
+
 /////////////////////////////////////////////////
 void ServerConfig::AddLogRecordTopic(const std::string &_topic)
 {

src/SimulationRunner.hh

@@ -568,14 +568,15 @@ namespace gz
       /// background. The simulation runner must remain paused while this
       /// takes place. This flag can be used to make sure simulation stays
       /// paused.
-      private: bool forcedPause{true};
+      private: bool forcedPause{false};
 
       /// \brief During a forced pause, the user may request that simulation
       /// should run. This flag will capture that request, and then be used
       /// when the forced pause ends.
       private: bool requestedPause{true};
 
       private: bool resetInitiated{false};
+
       friend class LevelManager;
     };
     }

src/cmd/cmdsim.rb.in

@@ -109,6 +109,8 @@ COMMANDS = { 'sim' =>
   "\n"\
   "  --headless-rendering         Run rendering in headless mode                   \n"\
   "\n"\
+  "  --parallel-download          Download assets in a background thread.         \n"\
+  "\n"\
   "  -r                           Run simulation on start.                         \n"\
   "\n"\
   "  -s                           Run only the server (headless mode). This        \n"\
@@ -224,7 +226,8 @@ class Cmd
       'render_engine_gui' => '',
       'render_engine_server' => '',
       'wait_gui' => 1,
-      'headless-rendering' => 0
+      'headless-rendering' => 0,
+      'wait-for-assets' => 0
     }
 
     usage = COMMANDS[args[0]]
@@ -304,6 +307,9 @@ class Cmd
       opts.on('--headless-rendering') do
         options['headless-rendering'] = 1
       end
+      opts.on('--wait-for-assets') do
+        options['wait-for-assets'] = 1
+      end
       opts.on('--render-engine-gui [arg]', String) do |g|
         options['render_engine_gui'] = g
       end
@@ -455,7 +461,7 @@ Please use [GZ_SIM_RESOURCE_PATH] instead."
                                const char *, int, int, const char *,
                                int, int, int, const char *, const char *,
                                const char *, const char *, const char *,
-                               const char *, int, int)'
+                               const char *, int, int, int)'
 
       # Import the runGui function
       Importer.extern 'int runGui(const char *, const char *, int, const char *)'
@@ -490,7 +496,8 @@ See https://github.com/gazebosim/gz-sim/issues/44 for more info."
             options['render_engine_server'], options['render_engine_gui'],
             options['file'], options['record-topics'].join(':'),
             options['wait_gui'],
-            options['headless-rendering'])
+            options['headless-rendering'],
+            options['wait-for-assets'])
         end
 
         guiPid = Process.fork do
@@ -527,7 +534,8 @@ See https://github.com/gazebosim/gz-sim/issues/44 for more info."
             options['playback'], options['physics_engine'],
             options['render_engine_server'], options['render_engine_gui'],
             options['file'], options['record-topics'].join(':'),
-            options['wait_gui'], options['headless-rendering'])
+            options['wait_gui'], options['headless-rendering'],
+            options['parallel-download'])
             # Otherwise run the gui
       else options['gui']
         if plugin.end_with? ".dylib"

src/gz.cc

@@ -136,7 +136,7 @@ extern "C" int runServer(const char *_sdfString,
     const char *_playback, const char *_physicsEngine,
     const char *_renderEngineServer, const char *_renderEngineGui,
     const char *_file, const char *_recordTopics, int _waitGui,
-    int _headless)
+    int _headless, int _waitForAssets)
 {
   std::string startingWorldPath{""};
   gz::sim::ServerConfig serverConfig;
@@ -396,6 +396,8 @@ extern "C" int runServer(const char *_sdfString,
     serverConfig.SetRenderEngineGui(_renderEngineGui);
   }
 
+  serverConfig.SetWaitForAssets(!_waitForAssets);
+
   // Create the Gazebo server
   gz::sim::Server server(serverConfig);
 

src/gz.hh

@@ -57,6 +57,8 @@ extern "C" const char *worldInstallDir();
 /// it receives a world path from GUI.
 /// null to record the default topics.
 /// \param[in] _headless True if server rendering should run headless
+/// \param[in] _waitForAssets True to wait for simulation assets to download
+/// before starting simulation.
 /// \return 0 if successful, 1 if not.
 extern "C" int runServer(const char *_sdfString,
     int _iterations, int _run, float _hz, int _levels,
@@ -65,7 +67,8 @@ extern "C" int runServer(const char *_sdfString,
     int _logCompress, const char *_playback,
     const char *_physicsEngine, const char *_renderEngineServer,
     const char *_renderEngineGui, const char *_file,
-    const char *_recordTopics, int _waitGui, int _headless);
+    const char *_recordTopics, int _waitGui, int _headless,
+    int _waitForAssets);
 
 /// \brief External hook to run simulation GUI.
 /// \param[in] _guiConfig Path to Gazebo GUI configuration file.