Enabling Global Illumination (GI VCT) for sensors in SDF

src/systems/sensors/Sensors.cc

@@ -64,11 +64,71 @@
 
 #include "gz/sim/rendering/Events.hh"
 #include "gz/sim/rendering/RenderUtil.hh"
+#include "gz/rendering/GlobalIlluminationVct.hh"
 
 using namespace gz;
 using namespace sim;
 using namespace systems;
 
+/// \brief GI parameters holding default data
+struct GiDefaultData
+{
+  /// \brief See rendering::GlobalIlluminationVct::SetResolution
+  math::Vector3d resolution{16, 16, 16};
+
+  /// \brief See rendering::GlobalIlluminationVct::SetOctantCount
+  math::Vector3d octantCount{1, 1, 1};
+
+  /// \brief See rendering::GlobalIlluminationVct::SetBounceCount
+  uint32_t bounceCount = 6;
+
+  /// \brief See rendering::GlobalIlluminationVct::SetHighQuality
+  bool highQuality = true;
+
+  /// \brief See rendering::GlobalIlluminationVct::SetAnisotropic
+  bool anisotropic = true;
+
+  /// \brief See rendering::GlobalIlluminationVct::SetThinWallCounter
+  float thinWallCounter = 1.0f;
+
+  /// \brief See rendering::GlobalIlluminationVct::SetConserveMemory
+  bool conserveMemory = false;
+
+  /// \brief See rendering::GlobalIlluminationVct::DebugVisualizationMode
+  uint32_t debugVisMode = rendering::GlobalIlluminationVct::DVM_None;
+};
+
+/// \brief GI VCT flag and parameters
+struct GiVctParameters
+{
+  /// \brief VCT enabled flag
+  bool enabled = false;
+
+  /// \brief See rendering::GlobalIlluminationVct::SetResolution
+  uint32_t resolution[3];
+
+  /// \brief See rendering::GlobalIlluminationVct::SetOctantCount
+  uint32_t octantCount[3];
+
+  /// \brief See rendering::GlobalIlluminationVct::SetBounceCount
+  uint32_t bounceCount;
+
+  /// \brief See rendering::GlobalIlluminationVct::SetHighQuality
+  bool highQuality;
+
+  /// \brief See rendering::GlobalIlluminationVct::SetAnisotropic
+  bool anisotropic;
+
+  /// \brief See rendering::GlobalIlluminationVct::SetThinWallCounter
+  float thinWallCounter;
+
+  /// \brief See rendering::GlobalIlluminationVct::SetConserveMemory
+  bool conserveMemory;
+
+  /// \brief See rendering::GlobalIlluminationVct::DebugVisualizationMode
+  uint32_t debugVisMode;
+};
+
 // Private data class.
 class gz::sim::systems::SensorsPrivate
 {
@@ -89,6 +149,18 @@ class gz::sim::systems::SensorsPrivate
   /// generate sensor data
   public: rendering::ScenePtr scene;
 
+  /// \brief Pointer to GlobalIlluminationVct
+  public: rendering::GlobalIlluminationVctPtr giVct;
+
+  /// \brief GI VCT parameters passed to giVct
+  public: GiVctParameters giVctParameters;
+
+  /// \brief Default GI data
+  public: GiDefaultData giDefaultData;
+
+  /// \brief GI built flag
+  public: bool giBuilt = false;
+
   /// \brief Temperature used by thermal camera. Defaults to temperature at
   /// sea level
   public: double ambientTemperature = 288.15;
@@ -288,6 +360,28 @@ void SensorsPrivate::WaitForInit()
 #endif
       this->scene = this->renderUtil.Scene();
       this->scene->SetCameraPassCountPerGpuFlush(6u);
+
+      if (this->giVctParameters.enabled)
+      {
+        this->giVct = this->scene->CreateGlobalIlluminationVct();
+        this->giVct->SetParticipatingVisuals(
+            rendering::GlobalIlluminationBase::DYNAMIC_VISUALS |
+            rendering::GlobalIlluminationBase::STATIC_VISUALS);
+
+        this->giVct->SetResolution(this->giVctParameters.resolution);
+        this->giVct->SetOctantCount(this->giVctParameters.octantCount);
+        this->giVct->SetBounceCount(this->giVctParameters.bounceCount);
+        this->giVct->SetAnisotropic(this->giVctParameters.anisotropic);
+        this->giVct->SetHighQuality(this->giVctParameters.highQuality);
+        this->giVct->SetConserveMemory(this->giVctParameters.conserveMemory);
+        this->giVct->SetThinWallCounter(this->giVctParameters.thinWallCounter);
+
+        this->giVct->SetDebugVisualization(
+          rendering::GlobalIlluminationVct::DVM_None);
+
+        this->scene->SetActiveGlobalIllumination(this->giVct);
+      }
+
       this->initialized = true;
     }
 
@@ -359,6 +453,19 @@ void SensorsPrivate::RunOnce()
       // We only need to do this once per frame It is important to call
       // sensors::RenderingSensor::SetManualSceneUpdate and set it to true
       // so we don't waste cycles doing one scene graph update per sensor
+
+      if (!this->giBuilt)
+      {
+        if (this->giVctParameters.enabled)
+        {
+          this->giVct->Build();
+          this->giVct->SetDebugVisualization(
+            static_cast<rendering::GlobalIlluminationVct::DebugVisualizationMode>
+            (this->giVctParameters.debugVisMode));
+          this->giBuilt = true;
+        }
+      }
+
       this->scene->PreRender();
     }
 
@@ -521,6 +628,52 @@ Sensors::~Sensors()
   this->dataPtr->Stop();
 }
 
+//TODO: why does math::Vector3d work but not math::Vector3i?
+static void ConvertDoubleToUInt32x3(sdf::ElementConstPtr _parentElem,
+    const char* _childName, uint32_t _valueToSet[3], math::Vector3d _defaultValue)
+{
+  math::Vector3d parsedValues = (_parentElem == nullptr) ? 
+      _defaultValue : _parentElem->Get<math::Vector3d>(_childName, _defaultValue).first;
+
+  _valueToSet[0] = static_cast<uint32_t>(parsedValues[0]);
+  _valueToSet[1] = static_cast<uint32_t>(parsedValues[1]);
+  _valueToSet[2] = static_cast<uint32_t>(parsedValues[2]);
+}
+
+static void ConvertDoubleToUInt32x3(uint32_t _valueToSet[3], math::Vector3d _defaultValue)
+{
+  ConvertDoubleToUInt32x3(nullptr, "", _valueToSet, _defaultValue);
+}
+
+static void SetDebugVisMode(const std::string &_text,
+    uint32_t &_modeToSet, uint32_t _defaultMode)
+{
+  if (_text == "albedo")
+  {
+    _modeToSet = rendering::GlobalIlluminationVct::DVM_Albedo;
+  }
+  else if (_text == "normal")
+  {
+    _modeToSet = rendering::GlobalIlluminationVct::DVM_Normal;
+  }
+  else if (_text == "emissive")
+  {
+    _modeToSet = rendering::GlobalIlluminationVct::DVM_Emissive;
+  }
+  else if (_text == "lighting")
+  {
+    _modeToSet = rendering::GlobalIlluminationVct::DVM_Lighting;
+  } 
+  else if (_text == "none")
+  {
+    _modeToSet = rendering::GlobalIlluminationVct::DVM_None;
+  } 
+  else
+  {
+    _modeToSet = _defaultMode;
+  }
+}
+
 //////////////////////////////////////////////////
 void Sensors::Configure(const Entity &/*_id*/,
     const std::shared_ptr<const sdf::Element> &_sdf,
@@ -549,6 +702,54 @@ void Sensors::Configure(const Entity &/*_id*/,
   if (_sdf->HasElement("ambient_light"))
     this->dataPtr->ambientLight = _sdf->Get<math::Color>("ambient_light");
 
+  // Get the global illumination technique and its parameters, if specified
+  if (_sdf->HasElement("global_illumination"))
+  {
+    if (engineName != "ogre2")
+    {
+      gzerr << "Global illumination is only supported by the ogre2 render engine" << std::endl;
+    }
+    else
+    {
+      auto giElem = _sdf->FindElement("global_illumination");
+      std::string giType = giElem->GetAttribute("type")->GetAsString();
+      if (giType == "vct")
+      {
+        this->dataPtr->giVctParameters.enabled = giElem->Get<bool>("enabled", this->dataPtr->giVctParameters.enabled).first;
+
+        if (giElem->HasElement("resolution"))
+          ConvertDoubleToUInt32x3(giElem, "resolution", this->dataPtr->giVctParameters.resolution, this->dataPtr->giDefaultData.resolution);
+        else 
+          ConvertDoubleToUInt32x3(this->dataPtr->giVctParameters.resolution, this->dataPtr->giDefaultData.resolution);
+
+        if (giElem->HasElement("octant_count"))
+          ConvertDoubleToUInt32x3(giElem, "octant_count", this->dataPtr->giVctParameters.octantCount, this->dataPtr->giDefaultData.octantCount);
+        else
+          ConvertDoubleToUInt32x3(this->dataPtr->giVctParameters.octantCount, this->dataPtr->giDefaultData.octantCount);
+
+        this->dataPtr->giVctParameters.bounceCount = giElem->Get<uint32_t>("bounce_count", this->dataPtr->giVctParameters.bounceCount).first;
+        this->dataPtr->giVctParameters.highQuality = giElem->Get<bool>("high_quality", this->dataPtr->giVctParameters.highQuality).first;
+        this->dataPtr->giVctParameters.anisotropic = giElem->Get<bool>("anisotropic", this->dataPtr->giVctParameters.anisotropic).first;
+        this->dataPtr->giVctParameters.thinWallCounter = giElem->Get<float>("thin_wall_counter", this->dataPtr->giVctParameters.thinWallCounter).first;
+        this->dataPtr->giVctParameters.conserveMemory = giElem->Get<bool>("conserve_memory", this->dataPtr->giVctParameters.conserveMemory).first;
+
+        if (giElem->HasElement("debug_vis_mode"))
+        {
+          const std::string text = giElem->Get<std::string>("debug_vis_mode", "none").first;
+          SetDebugVisMode(text, this->dataPtr->giVctParameters.debugVisMode, this->dataPtr->giDefaultData.debugVisMode);
+        }
+      }      
+      else if (giType == "civct")
+      {
+        //todo: add CIVCT here. should also check if apiBackend is vulkan
+        gzerr << "GI CI VCT is not supported" << std::endl;
+      } else
+      {
+        gzerr << "GI method type [" << giType << "] is not supported." << std::endl;
+      }
+    }
+  }
+
   this->dataPtr->renderUtil.SetEngineName(engineName);
 #ifdef __APPLE__
   if (apiBackend.empty())