--Implementation of Nvidia's HBAO effect (soft shadows in corners and crevices) via Magnum

examples/viewer.py

@@ -1123,6 +1123,11 @@ def next_frame() -> None:
         action="store_true",
         help="Override configured lighting to use default lighting for the stage.",
     )
+    parser.add_argument(
+        "--hbao",
+        action="store_true",
+        help="Enable horizon-based ambient occlusion, which provides soft shadows in corners and crevices.",
+    )
     parser.add_argument(
         "--enable-batch-renderer",
         action="store_true",
@@ -1174,6 +1179,7 @@ def next_frame() -> None:
     sim_settings["window_width"] = args.width
     sim_settings["window_height"] = args.height
     sim_settings["default_agent_navmesh"] = False
+    sim_settings["enable_hbao"] = args.hbao
 
     # start the application
     HabitatSimInteractiveViewer(sim_settings).exec()

src/esp/bindings/SimBindings.cpp

@@ -99,6 +99,9 @@ void initSimBindings(py::module& m) {
       .def_readwrite(
           "navmesh_settings", &SimulatorConfiguration::navMeshSettings,
           R"(Optionally provide a pre-configured NavMeshSettings. If provided, the NavMesh will be recomputed with the provided settings if: A. no NavMesh was loaded, or B. the loaded NavMesh's settings differ from the configured settings. If not provided, no NavMesh recompute will be done automatically.)")
+      .def_readwrite(
+          "enable_hbao", &SimulatorConfiguration::enableHBAO,
+          R"(Whether or not to enable horizon-based ambient occlusion, which provides soft shadows in corners and crevices.)")
       .def(py::self == py::self)
       .def(py::self != py::self);
 

src/esp/gfx/BackgroundRenderer.cpp

@@ -147,9 +147,14 @@ int BackgroundRenderer::threadRender() {
       sensor.renderTarget().renderEnter();
 
     auto* camera = sensor.getRenderCamera();
+
     for (auto& transforms : jobTransforms[i]) {
       camera->draw(transforms, flags);
     }
+    auto sensorType = sensor.specification()->sensorType;
+    if (sensorType == sensor::SensorType::Color) {
+      sensor.renderTarget().tryDrawHbao();
+    }
 
     if (!(flags & RenderCamera::Flag::ObjectsOnly))
       sensor.renderTarget().renderExit();

src/esp/gfx/RenderTarget.cpp

@@ -23,6 +23,7 @@
 #include "esp/sensor/VisualSensor.h"
 
 #include "esp/gfx_batch/DepthUnprojection.h"
+#include "esp/gfx_batch/Hbao.h"
 
 #ifdef ESP_BUILD_WITH_CUDA
 #include <cuda_gl_interop.h>
@@ -117,6 +118,24 @@ struct RenderTarget::Impl {
     CORRADE_INTERNAL_ASSERT(
         framebuffer_.checkStatus(Mn::GL::FramebufferTarget::Draw) ==
         Mn::GL::Framebuffer::Status::Complete);
+
+    if (flags_ & Flag::HorizonBasedAmbientOcclusion) {
+#ifndef MAGNUM_TARGET_WEBGL
+      // depth texture is required for HBAO
+      CORRADE_INTERNAL_ASSERT(flags_ & Flag::DepthTextureAttachment);
+      // TODO Drive construction based on premade configurations
+      hbao_ = gfx_batch::Hbao{
+          gfx_batch::HbaoConfiguration{}
+              .setSize(size)
+              .setUseSpecialBlur(true)
+              .setUseLayeredGeometryShader(true)
+          // TODO other options here?
+      };
+#else
+      ESP_ERROR()
+          << "HBAO functionality requested but not supported for WebGL builds";
+#endif
+    }
   }
 
   void initDepthUnprojector() {
@@ -181,6 +200,18 @@ struct RenderTarget::Impl {
 
   void renderExit() {}
 
+  void tryDrawHbao() {
+    if (!hbao_) {
+      return;
+    }
+    // TODO:Support a toggle between cache-aware and classic algorithm. For now
+    // we just use cache aware
+    bool useCacheAware = true;
+
+    hbao_->drawEffect(visualSensor_->getProjectionMatrix(), useCacheAware,
+                      depthRenderTexture_, framebuffer_);
+  }
+
   void blitRgbaTo(Mn::GL::AbstractFramebuffer& target,
                   const Mn::Range2Di& targetRectangle) {
     CORRADE_ASSERT(
@@ -367,6 +398,8 @@ struct RenderTarget::Impl {
   cudaGraphicsResource_t objecIdBufferCugl_ = nullptr;
   cudaGraphicsResource_t depthBufferCugl_ = nullptr;
 #endif
+
+  Cr::Containers::Optional<gfx_batch::Hbao> hbao_{};
 };  // namespace gfx
 
 RenderTarget::RenderTarget(const Mn::Vector2i& size,
@@ -426,6 +459,10 @@ Mn::GL::Texture2D& RenderTarget::getObjectIdTexture() {
   return pimpl_->getObjectIdTexture();
 }
 
+void RenderTarget::tryDrawHbao() {
+  return pimpl_->tryDrawHbao();
+}
+
 #ifdef ESP_BUILD_WITH_CUDA
 void RenderTarget::readFrameRgbaGPU(uint8_t* devPtr) {
   pimpl_->readFrameRgbaGPU(devPtr);

src/esp/gfx/RenderTarget.h

@@ -52,6 +52,11 @@ class RenderTarget {
      * rendering slower (default depth buffer will be used in this case.)
      */
     DepthTextureAttachment = 1 << 2,
+
+    /**
+     * Enable HBAO visual effect that adds soft shadows to corners and crevices.
+     */
+    HorizonBasedAmbientOcclusion = 1 << 3,
   };
 
   typedef Corrade::Containers::EnumSet<Flag> Flags;
@@ -170,6 +175,11 @@ class RenderTarget {
    */
   Magnum::GL::Texture2D& getObjectIdTexture();
 
+  /**
+   * @brief draw HBAO effect if enabled for this render target
+   */
+  void tryDrawHbao();
+
   // @brief Delete copy Constructor
   RenderTarget(const RenderTarget&) = delete;
   // @brief Delete copy operator

src/esp/gfx/Renderer.cpp

@@ -340,6 +340,14 @@ struct Renderer::Impl {
             "render buffer while the simulator was initialized with "
             "requiresTextures = false", );
         renderTargetFlags |= RenderTarget::Flag::RgbaAttachment;
+        // TODO complete support for other camera types (fisheye,
+        // equirectanguular) to use hbao.
+        if ((sensor.canUseHBAO()) &&
+            (flags_ & Renderer::Flag::HorizonBasedAmbientOcclusion)) {
+          // force depth texture for Color sensor, needed for HBAO
+          renderTargetFlags |= RenderTarget::Flag::DepthTextureAttachment;
+          renderTargetFlags |= RenderTarget::Flag::HorizonBasedAmbientOcclusion;
+        }
         break;
 
       case sensor::SensorType::Depth:

src/esp/gfx/Renderer.h

@@ -52,6 +52,11 @@ class Renderer {
      */
     LeaveContextWithBackgroundRenderer = 1 << 3,
 
+    /**
+     * Enable HBAO visual effect that adds soft shadows to corners and crevices.
+     */
+    HorizonBasedAmbientOcclusion = 1 << 4,
+
   };
 
   typedef Corrade::Containers::EnumSet<Flag> Flags;

src/esp/gfx_batch/CMakeLists.txt

@@ -20,6 +20,8 @@ set(
   Renderer.h
   RendererStandalone.cpp
   RendererStandalone.h
+  Hbao.cpp
+  Hbao.h
 )
 
 set_directory_properties(PROPERTIES CORRADE_USE_PEDANTIC_FLAGS ON)