working on updating segmentation camera to ogre2.2

Signed-off-by: Ashton Larkin <[email protected]>

Author: adlarkin

ogre2/src/Ogre2SegmentationCamera.cc

@@ -42,26 +42,22 @@ namespace rendering
 {
 inline namespace IGNITION_RENDERING_VERSION_NAMESPACE {
 /// \brief Helper class to assign unique colors to renderables
-class Ogre2SegmentationMaterialSwitcher : public Ogre::RenderTargetListener
+class Ogre2SegmentationMaterialSwitcher : public Ogre::Camera::Listener
 {
   /// \brief Constructor
   /// \param[in] _scene Ogre scene to be rendered
   public: explicit Ogre2SegmentationMaterialSwitcher(Ogre2ScenePtr _scene);
 
   /// \brief Destructor
-  public: ~Ogre2SegmentationMaterialSwitcher() = default;
+  public: virtual ~Ogre2SegmentationMaterialSwitcher() = default;
 
-  /// \brief Ogre's pre render update callback
-  /// \param[in] _evt Ogre render target event containing information about
-  /// the source render target.
-  public: virtual void preRenderTargetUpdate(
-              const Ogre::RenderTargetEvent &_evt) override;
+  /// \brief Callback when a camera is about to be rendered
+  /// \param[in] _cam Ogre render camara which is about to render.
+  public: virtual void cameraPreRenderScene(Ogre::Camera *_cam) override;
 
-  /// \brief Ogre's post render update callback
-  /// \param[in] _evt Ogre render target event containing information about
-  /// the source render target.
-  public: virtual void postRenderTargetUpdate(
-              const Ogre::RenderTargetEvent &_evt) override;
+  /// \brief Callback when a camera is finished being rendered
+  /// \param[in] _cam Ogre camera that was rendered
+  public: virtual void cameraPostRenderScene(Ogre::Camera *_cam) override;
 
   /// \brief Convert label of semantic map to a unique color for colored map and
   /// add the color of the label to the taken colors if it doesn't exist
@@ -156,13 +152,7 @@ class ignition::rendering::Ogre2SegmentationCameraPrivate
   public: std::string workspaceDefinition;
 
   /// \brief Render Texture to store the final segmentation data
-  public: Ogre::RenderTexture *ogreRenderTexture {nullptr};
-
-  /// \brief Texture to create the render texture from.
-  public: Ogre::TexturePtr ogreTexture;
-
-  /// \brief Pixel Box to copy render texture data to a buffer
-  public: Ogre::PixelBox *pixelBox {nullptr};
+  public: Ogre::TextureGpu *ogreRenderTexture {nullptr};
 
   /// \brief buffer to store render texture data & to be sent to listeners
   public: uint8_t *buffer = nullptr;
@@ -181,7 +171,7 @@ class ignition::rendering::Ogre2SegmentationCameraPrivate
     const std::string &_format)> newSegmentationFrame;
 
   /// \brief Image / Render Texture Format
-  public: const Ogre::PixelFormat format = Ogre::PF_R8G8B8;
+  public: const Ogre::PixelFormatGpu format = Ogre::PFG_RGB8_UNORM;
 };
 
 using namespace ignition;
@@ -293,8 +283,8 @@ VisualPtr Ogre2SegmentationMaterialSwitcher::TopLevelModelVisual(
 }
 
 ////////////////////////////////////////////////
-void Ogre2SegmentationMaterialSwitcher::preRenderTargetUpdate(
-    const Ogre::RenderTargetEvent &/*_evt*/)
+void Ogre2SegmentationMaterialSwitcher::cameraPreRenderScene(
+    Ogre::Camera *)
 {
   this->colorToLabel.clear();
   this->datablockMap.clear();
@@ -458,8 +448,8 @@ void Ogre2SegmentationMaterialSwitcher::preRenderTargetUpdate(
 }
 
 /////////////////////////////////////////////////
-void Ogre2SegmentationMaterialSwitcher::postRenderTargetUpdate(
-    const Ogre::RenderTargetEvent &/*_evt*/)
+void Ogre2SegmentationMaterialSwitcher::cameraPostRenderScene(
+    Ogre::Camera *)
 {
   // restore item to use pbs hlms material
   for (const auto &[subItem, dataBlock] : this->datablockMap)
@@ -540,8 +530,9 @@ void Ogre2SegmentationCamera::Destroy()
   // remove thermal texture, material, compositor
   if (this->dataPtr->ogreRenderTexture)
   {
-    Ogre::TextureManager::getSingleton().remove(
-        this->dataPtr->ogreRenderTexture->getName());
+    ogreRoot->getRenderSystem()->getTextureGpuManager()->destroyTexture(
+        this->dataPtr->ogreRenderTexture);
+    this->dataPtr->ogreRenderTexture = nullptr;
   }
   if (this->dataPtr->ogreCompositorWorkspace)
   {
@@ -570,10 +561,6 @@ void Ogre2SegmentationCamera::Destroy()
     }
   }
 
-  if (this->dataPtr->pixelBox)
-    delete this->dataPtr->pixelBox;
-  this->dataPtr->pixelBox = nullptr;
-
   if (this->dataPtr->materialSwitcher)
     delete this->dataPtr->materialSwitcher;
   this->dataPtr->materialSwitcher = nullptr;
@@ -600,27 +587,28 @@ void Ogre2SegmentationCamera::CreateSegmentationTexture()
   auto width = this->ImageWidth();
   auto height = this->ImageHeight();
 
-  // texture
-  this->dataPtr->ogreTexture =
-    Ogre::TextureManager::getSingleton().createManual(
-    "SegmentationCameraTexture",
-    Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
-    Ogre::TEX_TYPE_2D, width, height, 0, this->dataPtr->format,
-    Ogre::TU_RENDERTARGET
-  );
+  auto engine = Ogre2RenderEngine::Instance();
+  auto ogreRoot = engine->OgreRoot();
+  Ogre::TextureGpuManager *textureMgr =
+    ogreRoot->getRenderSystem()->getTextureGpuManager();
 
   // render texture
-  auto hardwareBuffer = this->dataPtr->ogreTexture->getBuffer();
-  this->dataPtr->ogreRenderTexture = hardwareBuffer->getRenderTarget();
+  this->dataPtr->ogreRenderTexture = textureMgr->createOrRetrieveTexture(
+      "SegmentationCameraTexture",
+      Ogre::GpuPageOutStrategy::SaveToSystemRam,
+      Ogre::TextureFlags::RenderToTexture,
+      Ogre::TextureTypes::Type2D);
+  this->dataPtr->ogreRenderTexture->setResolution(width, height);
+  this->dataPtr->ogreRenderTexture->setNumMipmaps(1u);
+  this->dataPtr->ogreRenderTexture->setPixelFormat(this->dataPtr->format);
+  this->dataPtr->ogreRenderTexture->scheduleTransitionTo(
+      Ogre::GpuResidency::Resident);
 
   // switch the material to a unique color for each object
   // in the pre render & get the original material again in the post render
-  this->dataPtr->ogreRenderTexture->addListener(
-    this->dataPtr->materialSwitcher);
+  this->ogreCamera->addListener(this->dataPtr->materialSwitcher);
 
   // workspace
-  auto engine = Ogre2RenderEngine::Instance();
-  auto ogreRoot = engine->OgreRoot();
   this->dataPtr->ogreCompositorManager = ogreRoot->getCompositorManager2();
 
   this->dataPtr->workspaceDefinition = "SegmentationCameraWorkspace_" +
@@ -652,15 +640,9 @@ void Ogre2SegmentationCamera::CreateSegmentationTexture()
     renderScenePass)->setVisibilityMask(IGN_VISIBILITY_ALL);
 
   // buffer to store render texture data
-  auto bufferSize = Ogre::PixelUtil::getMemorySize(
-    width, height, 1, this->dataPtr->format);
   if (this->dataPtr->buffer)
     delete [] this->dataPtr->buffer;
-  this->dataPtr->buffer = new uint8_t[bufferSize];
-  if (this->dataPtr->pixelBox)
-    delete this->dataPtr->pixelBox;
-  this->dataPtr->pixelBox = new Ogre::PixelBox(width, height, 1,
-    this->dataPtr->format, this->dataPtr->buffer);
+  this->dataPtr->buffer = new uint8_t[width * height * 3 * sizeof(uint8_t)];
 }
 
 /////////////////////////////////////////////////
@@ -676,24 +658,34 @@ void Ogre2SegmentationCamera::Render()
 /////////////////////////////////////////////////
 void Ogre2SegmentationCamera::PostRender()
 {
-  // copy render texture data to the pixel box & its buffer
-  this->dataPtr->ogreRenderTexture->copyContentsToMemory(
-    *this->dataPtr->pixelBox,
-    Ogre::RenderTarget::FB_FRONT
-  );
-
   // return if no one is listening to the new frame
   if (this->dataPtr->newSegmentationFrame.ConnectionCount() == 0)
     return;
 
-  uint width = this->ImageWidth();
-  uint height = this->ImageHeight();
-  uint channelCount = 3;
+  unsigned int width = this->ImageWidth();
+  unsigned int height = this->ImageHeight();
+  unsigned int channelCount = 3;
+  unsigned int bytesPerChannel = PixelUtil::BytesPerChannel(PF_R8G8B8);
+
+  Ogre::Image2 image;
+  image.convertFromTexture(this->dataPtr->ogreRenderTexture, 0u, 0u);
+  Ogre::TextureBox box = image.getData(0u);
+
+  // copy data row by row. The texture box may not be a contiguous region of
+  // a texture
+  uint8_t *segmentationBuffer = static_cast<uint8_t *>(box.data);
+  for (unsigned int i = 0; i < height; ++i)
+  {
+    unsigned int rawDataRowIdx = i * box.bytesPerRow / bytesPerChannel;
+    unsigned int rowIdx = i * width * channelCount;
+    memcpy(&this->dataPtr->buffer[rowIdx], &segmentationBuffer[rawDataRowIdx],
+        width * channelCount * bytesPerChannel);
+  }
 
   this->dataPtr->newSegmentationFrame(
     this->dataPtr->buffer,
     width, height, channelCount,
-    Ogre::PixelUtil::getFormatName(this->dataPtr->format)
+    PixelUtil::Name(PF_R8G8B8)
   );
 }
 
@@ -709,13 +701,30 @@ void Ogre2SegmentationCamera::Capture(Image &_image)
     return;
   }
 
-  // image buffer
-  void *data = _image.Data();
-
-  // pixel box to copy data from the render texture to the image buffer
-  Ogre::PixelBox ogrePixelBox(width, height, 1, this->dataPtr->format, data);
-  this->dataPtr->ogreRenderTexture->copyContentsToMemory(
-    ogrePixelBox, Ogre::RenderTarget::FB_FRONT);
+  // I'm not sure what to cast _image.Data to (void * isn't going to work here),
+  // so for now, this is commented out since it doesn't compile
+/*
+ *  unsigned int bytesPerChannel = PixelUtil::BytesPerChannel(_image.Format());
+ *  unsigned int channelCount = _image.Depth();
+ *
+ *  // image buffer
+ *  void *imgData = _image.Data();
+ *
+ *  // copy data from the render texture to the image buffer
+ *  Ogre::Image2 image;
+ *  image.convertFromTexture(this->dataPtr->ogreRenderTexture, 0u, 0u);
+ *  Ogre::TextureBox box = image.getData(0);
+ *  void *bufferTmp = static_cast<void *>(box.data);
+ *  // copy data row by row. The texture box may not be a contiguous region of
+ *  // a texture
+ *  for (unsigned int i = 0; i < height; ++i)
+ *  {
+ *    unsigned int rawDataRowIdx = i * box.bytesPerRow / bytesPerChannel;
+ *    unsigned int rowIdx = i * width * channelCount;
+ *    memcpy(&imgData[rowIdx], &bufferTmp[rawDataRowIdx],
+ *        width * channelCount * bytesPerChannel);
+ *  }
+ */
 }
 
 /////////////////////////////////////////////////