Vulkan: Store ImageHelper as a pointer in TextureVk and RenderbufferVk

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -16,11 +16,8 @@
 
 namespace rx
 {
-RenderTargetVk::RenderTargetVk(vk::ImageHelper *image,
-                               vk::ImageView *imageView,
-                               size_t layerIndex,
-                               TextureVk *owner)
-    : mImage(image), mImageView(imageView), mLayerIndex(layerIndex), mOwner(owner)
+RenderTargetVk::RenderTargetVk()
+    : mImage(nullptr), mImageView(nullptr), mLayerIndex(0), mOwner(nullptr)
 {}
 
 RenderTargetVk::~RenderTargetVk() {}
@@ -32,6 +29,25 @@ RenderTargetVk::RenderTargetVk(RenderTargetVk &&other)
       mOwner(other.mOwner)
 {}
 
+void RenderTargetVk::init(vk::ImageHelper *image,
+                          vk::ImageView *imageView,
+                          size_t layerIndex,
+                          TextureVk *owner)
+{
+    mImage      = image;
+    mImageView  = imageView;
+    mLayerIndex = layerIndex;
+    mOwner      = owner;
+}
+
+void RenderTargetVk::reset()
+{
+    mImage      = nullptr;
+    mImageView  = nullptr;
+    mLayerIndex = 0;
+    mOwner      = nullptr;
+}
+
 void RenderTargetVk::onColorDraw(vk::FramebufferHelper *framebufferVk,
                                  vk::CommandBuffer *commandBuffer,
                                  vk::RenderPassDesc *renderPassDesc)

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -37,15 +37,18 @@ class TextureVk;
 class RenderTargetVk final : public FramebufferAttachmentRenderTarget
 {
   public:
-    RenderTargetVk(vk::ImageHelper *image,
-                   vk::ImageView *imageView,
-                   size_t layerIndex,
-                   TextureVk *ownwer);
+    RenderTargetVk();
     ~RenderTargetVk() override;
 
     // Used in std::vector initialization.
     RenderTargetVk(RenderTargetVk &&other);
 
+    void init(vk::ImageHelper *image,
+              vk::ImageView *imageView,
+              size_t layerIndex,
+              TextureVk *owner);
+    void reset();
+
     // Note: RenderTargets should be called in order, with the depth/stencil onRender last.
     void onColorDraw(vk::FramebufferHelper *framebufferVk,
                      vk::CommandBuffer *commandBuffer,

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -24,7 +24,7 @@ constexpr VkClearColorValue kBlackClearColorValue                 = {{0}};
 }  // anonymous namespace
 
 RenderbufferVk::RenderbufferVk(const gl::RenderbufferState &state)
-    : RenderbufferImpl(state), mRenderTarget(&mImage, &mImageView, 0, nullptr)
+    : RenderbufferImpl(state), mImage(nullptr)
 {}
 
 RenderbufferVk::~RenderbufferVk() {}
@@ -34,8 +34,12 @@ void RenderbufferVk::onDestroy(const gl::Context *context)
     ContextVk *contextVk = vk::GetImpl(context);
     RendererVk *renderer = contextVk->getRenderer();
 
-    mImage.releaseImage(renderer);
-    mImage.releaseStagingBuffer(renderer);
+    if (mImage)
+    {
+        mImage->releaseImage(renderer);
+        mImage->releaseStagingBuffer(renderer);
+        SafeDelete(mImage);
+    }
 
     renderer->releaseObject(renderer->getCurrentQueueSerial(), &mImageView);
 }
@@ -49,20 +53,25 @@ angle::Result RenderbufferVk::setStorage(const gl::Context *context,
     RendererVk *renderer       = contextVk->getRenderer();
     const vk::Format &vkFormat = renderer->getFormat(internalformat);
 
-    if (mImage.valid())
+    if (mImage != nullptr && mImage->valid())
     {
         // Check against the state if we need to recreate the storage.
         if (internalformat != mState.getFormat().info->internalFormat ||
             static_cast<GLsizei>(width) != mState.getWidth() ||
             static_cast<GLsizei>(height) != mState.getHeight())
         {
-            mImage.releaseImage(renderer);
+            mImage->releaseImage(renderer);
             renderer->releaseObject(renderer->getCurrentQueueSerial(), &mImageView);
         }
     }
 
-    if (!mImage.valid() && (width != 0 && height != 0))
+    if ((mImage == nullptr || !mImage->valid()) && (width != 0 && height != 0))
     {
+        if (mImage == nullptr)
+        {
+            mImage = new vk::ImageHelper();
+        }
+
         const angle::Format &textureFormat = vkFormat.textureFormat();
         bool isDepthOrStencilFormat = textureFormat.depthBits > 0 || textureFormat.stencilBits > 0;
         const VkImageUsageFlags usage =
@@ -72,30 +81,33 @@ angle::Result RenderbufferVk::setStorage(const gl::Context *context,
             (isDepthOrStencilFormat ? VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT : 0);
 
         gl::Extents extents(static_cast<int>(width), static_cast<int>(height), 1);
-        ANGLE_TRY(mImage.init(contextVk, gl::TextureType::_2D, extents, vkFormat, 1, usage, 1, 1));
+        ANGLE_TRY(mImage->init(contextVk, gl::TextureType::_2D, extents, vkFormat, 1, usage, 1, 1));
 
         VkMemoryPropertyFlags flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
-        ANGLE_TRY(mImage.initMemory(contextVk, renderer->getMemoryProperties(), flags));
+        ANGLE_TRY(mImage->initMemory(contextVk, renderer->getMemoryProperties(), flags));
 
         VkImageAspectFlags aspect = vk::GetFormatAspectFlags(textureFormat);
 
         // Note that LUMA textures are not color-renderable, so a read-view with swizzle is not
         // needed.
-        ANGLE_TRY(mImage.initImageView(contextVk, gl::TextureType::_2D, aspect, gl::SwizzleState(),
-                                       &mImageView, 1));
+        ANGLE_TRY(mImage->initImageView(contextVk, gl::TextureType::_2D, aspect, gl::SwizzleState(),
+                                        &mImageView, 1));
 
         // TODO(jmadill): Fold this into the RenderPass load/store ops. http://anglebug.com/2361
         vk::CommandBuffer *commandBuffer = nullptr;
-        ANGLE_TRY(mImage.recordCommands(contextVk, &commandBuffer));
+        ANGLE_TRY(mImage->recordCommands(contextVk, &commandBuffer));
 
         if (isDepthOrStencilFormat)
         {
-            mImage.clearDepthStencil(aspect, aspect, kDefaultClearDepthStencilValue, commandBuffer);
+            mImage->clearDepthStencil(aspect, aspect, kDefaultClearDepthStencilValue,
+                                      commandBuffer);
         }
         else
         {
-            mImage.clearColor(kBlackClearColorValue, 0, 1, commandBuffer);
+            mImage->clearColor(kBlackClearColorValue, 0, 1, commandBuffer);
         }
+
+        mRenderTarget.init(mImage, &mImageView, 0, nullptr);
     }
 
     return angle::Result::Continue;
@@ -123,7 +135,7 @@ angle::Result RenderbufferVk::getAttachmentRenderTarget(const gl::Context *conte
                                                         const gl::ImageIndex &imageIndex,
                                                         FramebufferAttachmentRenderTarget **rtOut)
 {
-    ASSERT(mImage.valid());
+    ASSERT(mImage && mImage->valid());
     *rtOut = &mRenderTarget;
     return angle::Result::Continue;
 }

src/libANGLE/renderer/vulkan/RenderbufferVk.h

@@ -45,7 +45,7 @@ class RenderbufferVk : public RenderbufferImpl
                                      const gl::ImageIndex &imageIndex) override;
 
   private:
-    vk::ImageHelper mImage;
+    vk::ImageHelper *mImage;
     vk::ImageView mImageView;
     RenderTargetVk mRenderTarget;
 };

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -75,8 +75,9 @@ constexpr VkImageUsageFlags kSurfaceVKDepthStencilImageUsageFlags =
 }  // namespace
 
 OffscreenSurfaceVk::AttachmentImage::AttachmentImage()
-    : renderTarget(&image, &imageView, 0, nullptr)
-{}
+{
+    renderTarget.init(&image, &imageView, 0, nullptr);
+}
 
 OffscreenSurfaceVk::AttachmentImage::~AttachmentImage() = default;
 
@@ -273,11 +274,11 @@ WindowSurfaceVk::WindowSurfaceVk(const egl::SurfaceState &surfaceState,
       mInstance(VK_NULL_HANDLE),
       mSwapchain(VK_NULL_HANDLE),
       mSwapchainPresentMode(VK_PRESENT_MODE_FIFO_KHR),
-      mColorRenderTarget(nullptr, nullptr, 0, nullptr),
-      mDepthStencilRenderTarget(&mDepthStencilImage, &mDepthStencilImageView, 0, nullptr),
       mCurrentSwapchainImageIndex(0),
       mCurrentSwapSerialIndex(0)
-{}
+{
+    mDepthStencilRenderTarget.init(&mDepthStencilImage, &mDepthStencilImageView, 0, nullptr);
+}
 
 WindowSurfaceVk::~WindowSurfaceVk()
 {

src/libANGLE/renderer/vulkan/TextureVk.h

@@ -129,14 +129,14 @@ class TextureVk : public TextureImpl
 
     const vk::ImageHelper &getImage() const
     {
-        ASSERT(mImage.valid());
-        return mImage;
+        ASSERT(mImage && mImage->valid());
+        return *mImage;
     }
 
     vk::ImageHelper &getImage()
     {
-        ASSERT(mImage.valid());
-        return mImage;
+        ASSERT(mImage && mImage->valid());
+        return *mImage;
     }
 
     const vk::ImageView &getReadImageView() const;
@@ -149,6 +149,8 @@ class TextureVk : public TextureImpl
     angle::Result ensureImageInitialized(ContextVk *contextVk);
 
   private:
+    angle::Result ensureImageAllocated(RendererVk *renderer);
+
     angle::Result redefineImage(const gl::Context *context,
                                 const gl::ImageIndex &index,
                                 const gl::InternalFormat &internalFormat,
@@ -218,7 +220,7 @@ class TextureVk : public TextureImpl
                                              uint32_t levelCount,
                                              const vk::Format &format);
 
-    vk::ImageHelper mImage;
+    vk::ImageHelper *mImage;
     vk::ImageView mDrawBaseLevelImageView;
     vk::ImageView mReadBaseLevelImageView;
     vk::ImageView mReadMipmapImageView;