void Simulator::reconfigure()

in src/esp/sim/Simulator.cpp [108:208]
74 lines of code
23 McCabe index (conditional complexity)

void Simulator::reconfigure(const SimulatorConfiguration& cfg) {
  // set metadata mediator's cfg  upon creation or reconfigure
  if (!metadataMediator_) {
    metadataMediator_ = metadata::MetadataMediator::create(cfg);
  } else {
    metadataMediator_->setSimulatorConfiguration(cfg);
  }

  // assign MM to RM on create or reconfigure
  if (!resourceManager_) {
    assets::ResourceManager::Flags flags{};
    if (cfg.pbrImageBasedLighting) {
      flags |= assets::ResourceManager::Flag::PbrImageBasedLighting;
    }
    resourceManager_ =
        std::make_unique<assets::ResourceManager>(metadataMediator_, flags);
    // needs to be called after ResourceManager exists but before any assets
    // have been loaded
    reconfigureReplayManager(cfg.enableGfxReplaySave);
  } else {
    resourceManager_->setMetadataMediator(metadataMediator_);
  }

  if (!sceneManager_) {
    sceneManager_ = scene::SceneManager::create_unique();
  }

  // if configuration is unchanged, just reset and return
  if (cfg == config_) {
    // This is a check to make sure that pathfinder_ is not null after
    // a reconfigure. We check to see if it's null so that an existing
    // one isn't overwritten.
    if (!pathfinder_) {
      pathfinder_ = nav::PathFinder::create();
    }
    reset();
    return;
  }
  // otherwise set current configuration and initialize
  // TODO can optimize to do partial re-initialization instead of from-scratch
  config_ = cfg;

  if (!config_.createRenderer) {
    config_.requiresTextures = false;
  }

  if (requiresTextures_ == Cr::Containers::NullOpt) {
    requiresTextures_ = config_.requiresTextures;
    resourceManager_->setRequiresTextures(config_.requiresTextures);
  } else if (!(*requiresTextures_) && config_.requiresTextures) {
    throw std::runtime_error(
        "requiresTextures was changed to True from False.  Must call close() "
        "before changing this value.");
  } else if ((*requiresTextures_) && !config_.requiresTextures) {
    ESP_WARNING() << "Not changing requiresTextures as the simulator was "
                     "initialized with True.  Call close() to change this.";
  }

  if (config_.createRenderer) {
    /* When creating a viewer based app, there is no need to create a
    WindowlessContext since a (windowed) context already exists. */
    if (!context_ && !Magnum::GL::Context::hasCurrent()) {
      context_ = gfx::WindowlessContext::create_unique(config_.gpuDeviceId);
    }

    // reinitialize members
    if (!renderer_) {
      gfx::Renderer::Flags flags;
      if (!(*requiresTextures_))
        flags |= gfx::Renderer::Flag::NoTextures;

#ifdef ESP_BUILD_WITH_BACKGROUND_RENDERER
      if (context_)
        flags |= gfx::Renderer::Flag::BackgroundRenderer;

      if (context_ && config_.leaveContextWithBackgroundRenderer)
        flags |= gfx::Renderer::Flag::LeaveContextWithBackgroundRenderer;
#endif

      renderer_ = gfx::Renderer::create(context_.get(), flags);
    }
#ifndef CORRADE_TARGET_EMSCRIPTEN
    flextGLInit(Magnum::GL::Context::current());
#endif
    renderer_->acquireGlContext();
  } else {
    CORRADE_ASSERT(
        !Magnum::GL::Context::hasCurrent(),
        "Simulator::reconfigure() : Unexpected existing context when "
        "createRenderer==false", );
  }

  // (re) create scene instance
  bool success = createSceneInstance(config_.activeSceneName);

  ESP_DEBUG() << "CreateSceneInstance success =="
              << (success ? "true" : "false")
              << "for active scene name :" << config_.activeSceneName
              << (config_.createRenderer ? " with" : " without") << "renderer.";

}  // Simulator::reconfigure