Add necessary headers for Vulkan QML GUI backend

include/gz/rendering/Camera.hh

@@ -79,7 +79,9 @@ namespace gz
 
       /// \brief Set the image pixel format
       /// \param[in] _format New image pixel format
-      public: virtual void SetImageFormat(PixelFormat _format) = 0;
+      /// \param[in] _reinterpretable See RenderTarget::SetFormat
+      public: virtual void SetImageFormat(PixelFormat _format,
+                                          bool _reinterpretable = false) = 0;
 
       /// \brief Get the total image memory size in bytes
       /// \return The image memory size in bytes
@@ -332,6 +334,12 @@ namespace gz
       /// \param[out] _textureIdPtr the address of a void* pointer.
       public: virtual void RenderTextureMetalId(void *_textureIdPtr) const = 0;
 
+      /// \brief Right now this is Vulkan-only. This function needs to be
+      /// called after rendering, and before handling the texture pointer
+      /// (i.e. by calling RenderTextureMetalId()) so that external APIs
+      /// (e.g. Qt) can sample the texture.
+      public: virtual void PrepareForExternalSampling() = 0;
+
       /// \brief Add a render pass to the camera
       /// \param[in] _pass New render pass to add
       public: virtual void AddRenderPass(const RenderPassPtr &_pass) = 0;

include/gz/rendering/RenderEngineVulkanExternalDeviceStructs.hh

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2022 Open Source Robotics Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+#ifndef GZ_RENDERING_RENDERENGINE_VULKANEXTERNALDEVICESTRUCTS_HH_
+#define GZ_RENDERING_RENDERENGINE_VULKANEXTERNALDEVICESTRUCTS_HH_
+
+#ifndef __APPLE__
+
+#  include <vector>
+#  include "gz/rendering/Export.hh"
+#  include "gz/rendering/config.hh"
+
+#  include "vulkan/vulkan_core.h"
+
+namespace gz
+{
+  namespace rendering
+  {
+    inline namespace GZ_RENDERING_VERSION_NAMESPACE {
+    /// \brief Structure to encapsulate data needed by OgreNext to init Vulkan
+    /// from Qt.
+    /// Mirrors Ogre::VulkanExternalInstance without depending on OgreNext
+    /// directly.
+    struct GZ_RENDERING_VISIBLE GzVulkanExternalInstance
+    {
+      VkInstance instance;
+      std::vector<VkLayerProperties> instanceLayers;
+      std::vector<VkExtensionProperties> instanceExtensions;
+    };
+
+    /// \brief Structure to encapsulate data needed by OgreNext to init Vulkan
+    /// from Qt.
+    /// Mirrors Ogre::VulkanExternalDevice without depending on OgreNext
+    /// directly.
+    struct GZ_RENDERING_VISIBLE GzVulkanExternalDevice
+    {
+      VkPhysicalDevice physicalDevice;
+      VkDevice device;
+      std::vector<VkExtensionProperties> deviceExtensions;
+      VkQueue graphicsQueue;
+      VkQueue presentQueue;
+    };
+  }
+  }
+}
+
+#endif
+#endif

include/gz/rendering/RenderTarget.hh

@@ -62,7 +62,15 @@ namespace gz
 
       /// \brief Set the render target image format
       /// \param[in] _format New target format
-      public: virtual void SetFormat(PixelFormat _format) = 0;
+      /// \param[in] _reinterpretable whether the RenderTarget will be
+      /// reinterpreted to another format (e.g.
+      /// from RGBA8_UNORM to/from RGBA8_UNORM_SRGB)
+      public: virtual void SetFormat(PixelFormat _format,
+                                     bool _reinterpretable = false) = 0;
+
+      /// \brief See SetFormat()
+      /// \return True if format is reinterpretable
+      public: virtual bool Reinterpretable() const = 0;
 
       /// \brief Write rendered image to given Image. The RenderTarget will
       /// convert the underlying image to the specified format listed in the

include/gz/rendering/base/BaseCamera.hh

@@ -61,7 +61,9 @@ namespace gz
 
       public: virtual unsigned int ImageMemorySize() const override;
 
-      public: virtual void SetImageFormat(PixelFormat _format) override;
+      public: virtual void SetImageFormat(PixelFormat _format,
+                                          bool _reinterpretable = false)
+          override;
 
       public: virtual math::Angle HFOV() const override;
 
@@ -186,6 +188,9 @@ namespace gz
       public: virtual void RenderTextureMetalId(void *_textureIdPtr)
           const override;
 
+      // Documentation inherited.
+      public: virtual void PrepareForExternalSampling() override;
+
       // Documentation inherited.
       public: virtual void AddRenderPass(const RenderPassPtr &_pass) override;
 
@@ -332,9 +337,10 @@ namespace gz
 
     //////////////////////////////////////////////////
     template <class T>
-    void BaseCamera<T>::SetImageFormat(PixelFormat _format)
+    void BaseCamera<T>::SetImageFormat(PixelFormat _format,
+                                       bool _reinterpretable)
     {
-      this->RenderTarget()->SetFormat(_format);
+      this->RenderTarget()->SetFormat(_format, _reinterpretable);
     }
 
     //////////////////////////////////////////////////
@@ -843,6 +849,14 @@ namespace gz
           << " engine" << std::endl;
     }
 
+    //////////////////////////////////////////////////
+    template <class T>
+    void BaseCamera<T>::PrepareForExternalSampling()
+    {
+      gzerr << "PrepareForExternalSampling is not supported by current render"
+          << " engine" << std::endl;
+    }
+
     //////////////////////////////////////////////////
     template <class T>
     void BaseCamera<T>::AddRenderPass(const RenderPassPtr &_pass)

include/gz/rendering/base/BaseRenderTarget.hh

@@ -56,7 +56,11 @@ namespace gz
 
       public: virtual PixelFormat Format() const override;
 
-      public: virtual void SetFormat(PixelFormat _format) override;
+      public: virtual void SetFormat(PixelFormat _format,
+                                     bool _reinterpretable = false) override;
+
+      // Documentation inherited
+      public: virtual bool Reinterpretable() const override;
 
       // Documentation inherited
       public: virtual math::Color BackgroundColor() const override;
@@ -81,6 +85,8 @@ namespace gz
 
       protected: PixelFormat format = PF_UNKNOWN;
 
+      protected: bool reinterpretable = false;
+
       protected: bool targetDirty = true;
 
       /// \brief Flag to indicate if render pass need to be rebuilt
@@ -218,12 +224,21 @@ namespace gz
 
     //////////////////////////////////////////////////
     template <class T>
-    void BaseRenderTarget<T>::SetFormat(PixelFormat _format)
+    void BaseRenderTarget<T>::SetFormat(PixelFormat _format,
+                                        bool _reinterpretable)
     {
       this->format = PixelUtil::Sanitize(_format);
+      this->reinterpretable = _reinterpretable;
       this->targetDirty = true;
     }
 
+    //////////////////////////////////////////////////
+    template <class T>
+    bool BaseRenderTarget<T>::Reinterpretable() const
+    {
+      return this->reinterpretable;
+    }
+
     //////////////////////////////////////////////////
     template <class T>
     math::Color BaseRenderTarget<T>::BackgroundColor() const

ogre2/include/gz/rendering/ogre2/Ogre2Camera.hh

@@ -126,6 +126,9 @@ namespace gz
       public: virtual void RenderTextureMetalId(void *_textureIdPtr)
           const override;
 
+      // Documentation inherited.
+      public: virtual void PrepareForExternalSampling() override;
+
       // Documentation inherited.
       public: void SetShadowsDirty() override;
 

ogre2/include/gz/rendering/ogre2/Ogre2RenderTarget.hh

@@ -139,6 +139,9 @@ namespace gz
       // Documentation inherited
       public: void MetalIdImpl(void *_textureIdPtr) const;
 
+      /// \brief See Camera::PrepareForExternalSampling
+      public: void PrepareForExternalSampling();
+
       /// \brief Destroy the render texture
       protected: void DestroyTargetImpl();
 

ogre2/src/Ogre2Camera.cc

@@ -230,6 +230,14 @@ void Ogre2Camera::RenderTextureMetalId(void *_textureIdPtr) const
   rt->MetalId(_textureIdPtr);
 }
 
+//////////////////////////////////////////////////
+void Ogre2Camera::PrepareForExternalSampling()
+{
+  if (!this->renderTexture)
+    return;
+  this->renderTexture->PrepareForExternalSampling();
+}
+
 //////////////////////////////////////////////////
 void Ogre2Camera::SetShadowsDirty()
 {