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

• Show log

  Commit

• Hash : d657e1d7
  Author :
  Date : 2020-04-24T13:13:18
  

  Vulkan: Defer framebuffer clears.
  
  This works by storing the deferred clears in the ImageHelper's staging
  buffers. We apply the deferred clears onto the RenderPass right before
  we begin to draw. Storing the clears in the ImageHelper solves problems
  where we clear GL Textures in a Framebuffer and then unbind the
  Textures and sample from them. Or do other commands like CopyTexImage.
  
  Note that because the staging buffer clears only handle full-image
  clears we need to immediately apply some scissored clears where before
  we would use the RP. This should be a pretty rare occurrence and it is
  possible to optimize that in the future.
  
  Reduces the RenderPass count in the Manhattan "frame 10" trace from max
  22 to max 20. May improve perf slightly on Android or may have effects
  too small to measure. Should not regress performance.
  
  Bug: angleproject:4517
  Change-Id: I02150d531022afb903f1058f070937ec6337bd88
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2142711
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Reviewed-by: Charlie Lao <cclao@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

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

• //
  // 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.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_RENDERTARGETVK_H_
  #define LIBANGLE_RENDERER_VULKAN_RENDERTARGETVK_H_
  
  #include "libANGLE/FramebufferAttachment.h"
  #include "libANGLE/renderer/renderer_utils.h"
  #include "libANGLE/renderer/vulkan/vk_headers.h"
  #include "libANGLE/renderer/vulkan/vk_helpers.h"
  
  namespace rx
  {
  namespace vk
  {
  struct Format;
  class FramebufferHelper;
  class ImageHelper;
  class ImageView;
  class Resource;
  class RenderPassDesc;
  }  // namespace vk
  
  class ContextVk;
  class TextureVk;
  
  // This is a very light-weight class that does not own to the resources it points to.
  // It's meant only to copy across some information from a FramebufferAttachment to the
  // business rendering logic. It stores Images and ImageViews by pointer for performance.
  class RenderTargetVk final : public FramebufferAttachmentRenderTarget
  {
    public:
      RenderTargetVk();
      ~RenderTargetVk() override;
  
      // Used in std::vector initialization.
      RenderTargetVk(RenderTargetVk &&other);
  
      void init(vk::ImageHelper *image,
                vk::ImageViewHelper *imageViews,
                uint32_t levelIndex,
                uint32_t layerIndex);
      void reset();
      // This returns the serial from underlying ImageHelper, first assigning one if required
      vk::AttachmentSerial getAssignSerial(ContextVk *contextVk);
  
      // Note: RenderTargets should be called in order, with the depth/stencil onRender last.
      angle::Result onColorDraw(ContextVk *contextVk);
      angle::Result onDepthStencilDraw(ContextVk *contextVk);
  
      vk::ImageHelper &getImage();
      const vk::ImageHelper &getImage() const;
  
      // getImageForRead will also transition the resource to the given layout.
      vk::ImageHelper *getImageForWrite(ContextVk *contextVk) const;
  
      // For cube maps we use single-level single-layer 2D array views.
      angle::Result getImageView(ContextVk *contextVk, const vk::ImageView **imageViewOut) const;
  
      const vk::Format &getImageFormat() const;
      gl::Extents getExtents() const;
      uint32_t getLevelIndex() const { return mLevelIndex; }
      uint32_t getLayerIndex() const { return mLayerIndex; }
  
      gl::ImageIndex getImageIndex() const;
  
      // Special mutator for Surface RenderTargets. Allows the Framebuffer to keep a single
      // RenderTargetVk pointer.
      void updateSwapchainImage(vk::ImageHelper *image, vk::ImageViewHelper *imageViews);
  
      angle::Result flushStagedUpdates(ContextVk *contextVk,
                                       vk::ClearValuesArray *deferredClears,
                                       uint32_t deferredClearIndex) const;
  
      void retainImageViews(ContextVk *contextVk) const;
  
      bool hasDefinedContent() const { return mContentDefined; }
      // mark content as undefined so that certain optimizations are possible
      void invalidateContent() { mContentDefined = false; }
  
    private:
      vk::ImageHelper *mImage;
      vk::ImageViewHelper *mImageViews;
      uint32_t mLevelIndex;
      uint32_t mLayerIndex;
      // Right now we are only tracking depth/stencil buffer. We could expand it to cover color
      // buffers if needed in future.
      bool mContentDefined;
  };
  
  // A vector of rendertargets
  using RenderTargetVector = std::vector<RenderTargetVk>;
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_RENDERTARGETVK_H_
  

Download