kc3-lang/angle/src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

• Show log

  Commit

• Hash : 34ca1ac7
  Author :
  Date : 2020-06-16T12:05:12
  

  Vulkan: Fix FramebufferVk cache
  
  Migrate Serial from Image to ImageView.
  Imageviews are what are utimately used in FramebufferVk, so move
  the Serials into the ImageViewHelper class. Since that class also
  knows the level/layer of the imageView, we can revert to using a
  single Serial per ImageView instead of the AttachmentSerial that
  included the layer and level.
  ImageViewHelper caches Serials per layer/level combo.
  
  Bug: angleproject:4651
  Change-Id: I3741d7d03523eada84295cb712c1cc1e6e3c3867
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2248203
  Commit-Queue: Tobin Ehlis <tobine@google.com>
  Reviewed-by: Mohan Maiya <m.maiya@samsung.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

• //
  // Copyright 2016 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // RenderTargetVk:
  //   Wrapper around a Vulkan renderable resource, using an ImageView.
  //
  
  #include "libANGLE/renderer/vulkan/RenderTargetVk.h"
  
  #include "libANGLE/renderer/vulkan/ContextVk.h"
  #include "libANGLE/renderer/vulkan/ResourceVk.h"
  #include "libANGLE/renderer/vulkan/TextureVk.h"
  #include "libANGLE/renderer/vulkan/vk_format_utils.h"
  #include "libANGLE/renderer/vulkan/vk_helpers.h"
  
  namespace rx
  {
  
  RenderTargetVk::RenderTargetVk()
  {
      reset();
  }
  
  RenderTargetVk::~RenderTargetVk() {}
  
  RenderTargetVk::RenderTargetVk(RenderTargetVk &&other)
      : mImage(other.mImage),
        mImageViews(other.mImageViews),
        mLevelIndex(other.mLevelIndex),
        mLayerIndex(other.mLayerIndex),
        mContentDefined(other.mContentDefined)
  {
      other.reset();
  }
  
  void RenderTargetVk::init(vk::ImageHelper *image,
                            vk::ImageViewHelper *imageViews,
                            uint32_t levelIndex,
                            uint32_t layerIndex)
  {
      mImage      = image;
      mImageViews = imageViews;
      mLevelIndex = levelIndex;
      mLayerIndex = layerIndex;
      // We are being conservative here since our targeted optimization is to skip surfaceVK's depth
      // buffer load after swap call.
      mContentDefined = true;
  }
  
  void RenderTargetVk::reset()
  {
      mImage          = nullptr;
      mImageViews     = nullptr;
      mLevelIndex     = 0;
      mLayerIndex     = 0;
      mContentDefined = false;
  }
  
  Serial RenderTargetVk::getAssignImageViewSerial(ContextVk *contextVk)
  {
      ASSERT(mImageViews);
      ASSERT(mLayerIndex < std::numeric_limits<uint16_t>::max());
      ASSERT(mLevelIndex < std::numeric_limits<uint16_t>::max());
  
      Serial imageViewSerial = mImageViews->getAssignSerial(contextVk, mLevelIndex, mLayerIndex);
      ASSERT(imageViewSerial.getValue() < std::numeric_limits<uint32_t>::max());
      return imageViewSerial;
  }
  
  angle::Result RenderTargetVk::onColorDraw(ContextVk *contextVk)
  {
      ASSERT(!mImage->getFormat().actualImageFormat().hasDepthOrStencilBits());
  
      contextVk->onRenderPassImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::ColorAttachment,
                                        mImage);
      mContentDefined = true;
      retainImageViews(contextVk);
  
      return angle::Result::Continue;
  }
  
  angle::Result RenderTargetVk::onDepthStencilDraw(ContextVk *contextVk)
  {
      ASSERT(mImage->getFormat().actualImageFormat().hasDepthOrStencilBits());
  
      const angle::Format &format    = mImage->getFormat().actualImageFormat();
      VkImageAspectFlags aspectFlags = vk::GetDepthStencilAspectFlags(format);
  
      contextVk->onRenderPassImageWrite(aspectFlags, vk::ImageLayout::DepthStencilAttachment, mImage);
      mContentDefined = true;
      retainImageViews(contextVk);
  
      return angle::Result::Continue;
  }
  
  vk::ImageHelper &RenderTargetVk::getImage()
  {
      ASSERT(mImage && mImage->valid());
      return *mImage;
  }
  
  const vk::ImageHelper &RenderTargetVk::getImage() const
  {
      ASSERT(mImage && mImage->valid());
      return *mImage;
  }
  
  angle::Result RenderTargetVk::getImageView(ContextVk *contextVk,
                                             const vk::ImageView **imageViewOut) const
  {
      ASSERT(mImage && mImage->valid() && mImageViews);
      return mImageViews->getLevelLayerDrawImageView(contextVk, *mImage, mLevelIndex, mLayerIndex,
                                                     imageViewOut);
  }
  
  angle::Result RenderTargetVk::getAndRetainCopyImageView(ContextVk *contextVk,
                                                          const vk::ImageView **imageViewOut) const
  {
      retainImageViews(contextVk);
  
      const vk::ImageViewHelper *imageViews = mImageViews;
      const vk::ImageView &copyView         = imageViews->getCopyImageView();
  
      // If the source of render target is the texture, this will always be valid.  This is also where
      // 3D or 2DArray images could be the source of the render target.
      if (copyView.valid())
      {
          *imageViewOut = &copyView;
          return angle::Result::Continue;
      }
  
      // Otherwise, this must come from the surface, in which case the image is 2D, so the image view
      // used to draw is just as good for fetching.
      return getImageView(contextVk, imageViewOut);
  }
  
  const vk::Format &RenderTargetVk::getImageFormat() const
  {
      ASSERT(mImage && mImage->valid());
      return mImage->getFormat();
  }
  
  gl::Extents RenderTargetVk::getExtents() const
  {
      ASSERT(mImage && mImage->valid());
      return mImage->getLevelExtents2D(static_cast<uint32_t>(mLevelIndex));
  }
  
  void RenderTargetVk::updateSwapchainImage(vk::ImageHelper *image, vk::ImageViewHelper *imageViews)
  {
      ASSERT(image && image->valid() && imageViews);
      mImage      = image;
      mImageViews = imageViews;
  }
  
  vk::ImageHelper *RenderTargetVk::getImageForWrite(ContextVk *contextVk) const
  {
      ASSERT(mImage && mImage->valid());
      retainImageViews(contextVk);
      return mImage;
  }
  
  angle::Result RenderTargetVk::flushStagedUpdates(ContextVk *contextVk,
                                                   vk::ClearValuesArray *deferredClears,
                                                   uint32_t deferredClearIndex) const
  {
      // Note that the layer index for 3D textures is always zero according to Vulkan.
      uint32_t layerIndex = mLayerIndex;
      if (mImage->getType() == VK_IMAGE_TYPE_3D)
      {
          layerIndex = 0;
      }
  
      ASSERT(mImage->valid());
      if (!mImage->isUpdateStaged(mLevelIndex, layerIndex))
          return angle::Result::Continue;
  
      vk::CommandBuffer *commandBuffer;
      ANGLE_TRY(contextVk->endRenderPassAndGetCommandBuffer(&commandBuffer));
      return mImage->flushSingleSubresourceStagedUpdates(
          contextVk, mLevelIndex, layerIndex, commandBuffer, deferredClears, deferredClearIndex);
  }
  
  void RenderTargetVk::retainImageViews(ContextVk *contextVk) const
  {
      mImageViews->retain(&contextVk->getResourceUseList());
  }
  
  gl::ImageIndex RenderTargetVk::getImageIndex() const
  {
      // Determine the GL type from the Vk Image properties.
      if (mImage->getType() == VK_IMAGE_TYPE_3D)
      {
          return gl::ImageIndex::Make3D(mLevelIndex, mLayerIndex);
      }
  
      // We don't need to distinguish 2D array and cube.
      if (mImage->getLayerCount() > 1)
      {
          return gl::ImageIndex::Make2DArray(mLevelIndex, mLayerIndex);
      }
  
      ASSERT(mLayerIndex == 0);
      return gl::ImageIndex::Make2D(mLevelIndex);
  }
  }  // namespace rx
  

Download