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

• Show log

  Commit

• Hash : 9aef3670
  Author :
  Date : 2018-04-27T11:45:06
  

  Vulkan: Implement masked color clears.
  
  This implements masked color clear using clear shaders. The shaders
  themselves were introduced in a prior patch. In order to get the
  right setup for the draw call to trigger the shaders, we create
  an internal pipeline from the pipeline cache. We also use a special
  pipeline layout with only uniform buffers. The masked out color
  channels are disabled via settings on the pipeline.
  
  This fixes the dEQP masked color clear tests. It doesn't handle
  masked color clears combined with the depth clear bit. It's likely
  we don't have test coverage for this case.
  
  Bug: angleproject:2455
  Change-Id: I513248cc0f7e58f490fc16ac9afb40119d730ccc
  Reviewed-on: https://chromium-review.googlesource.com/1031373
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/FramebufferVk.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.
  //
  // FramebufferVk.h:
  //    Defines the class interface for FramebufferVk, implementing FramebufferImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_FRAMEBUFFERVK_H_
  #define LIBANGLE_RENDERER_VULKAN_FRAMEBUFFERVK_H_
  
  #include "libANGLE/renderer/FramebufferImpl.h"
  #include "libANGLE/renderer/RenderTargetCache.h"
  #include "libANGLE/renderer/vulkan/CommandGraph.h"
  #include "libANGLE/renderer/vulkan/vk_cache_utils.h"
  
  namespace rx
  {
  class RendererVk;
  class RenderTargetVk;
  class WindowSurfaceVk;
  
  class FramebufferVk : public FramebufferImpl, public vk::CommandGraphResource
  {
    public:
      // Factory methods so we don't have to use constructors with overloads.
      static FramebufferVk *CreateUserFBO(const gl::FramebufferState &state);
  
      // The passed-in SurfaceVK must be destroyed after this FBO is destroyed. Our Surface code is
      // ref-counted on the number of 'current' contexts, so we shouldn't get any dangling surface
      // references. See Surface::setIsCurrent(bool).
      static FramebufferVk *CreateDefaultFBO(const gl::FramebufferState &state,
                                             WindowSurfaceVk *backbuffer);
  
      ~FramebufferVk() override;
      void destroy(const gl::Context *context) override;
      void destroyDefault(const egl::Display *display) override;
  
      gl::Error discard(const gl::Context *context, size_t count, const GLenum *attachments) override;
      gl::Error invalidate(const gl::Context *context,
                           size_t count,
                           const GLenum *attachments) override;
      gl::Error invalidateSub(const gl::Context *context,
                              size_t count,
                              const GLenum *attachments,
                              const gl::Rectangle &area) override;
  
      gl::Error clear(const gl::Context *context, GLbitfield mask) override;
      gl::Error clearBufferfv(const gl::Context *context,
                              GLenum buffer,
                              GLint drawbuffer,
                              const GLfloat *values) override;
      gl::Error clearBufferuiv(const gl::Context *context,
                               GLenum buffer,
                               GLint drawbuffer,
                               const GLuint *values) override;
      gl::Error clearBufferiv(const gl::Context *context,
                              GLenum buffer,
                              GLint drawbuffer,
                              const GLint *values) override;
      gl::Error clearBufferfi(const gl::Context *context,
                              GLenum buffer,
                              GLint drawbuffer,
                              GLfloat depth,
                              GLint stencil) override;
  
      GLenum getImplementationColorReadFormat(const gl::Context *context) const override;
      GLenum getImplementationColorReadType(const gl::Context *context) const override;
      gl::Error readPixels(const gl::Context *context,
                           const gl::Rectangle &area,
                           GLenum format,
                           GLenum type,
                           void *pixels) override;
  
      gl::Error blit(const gl::Context *context,
                     const gl::Rectangle &sourceArea,
                     const gl::Rectangle &destArea,
                     GLbitfield mask,
                     GLenum filter) override;
  
      bool checkStatus(const gl::Context *context) const override;
  
      gl::Error syncState(const gl::Context *context,
                          const gl::Framebuffer::DirtyBits &dirtyBits) override;
  
      gl::Error getSamplePosition(size_t index, GLfloat *xy) const override;
  
      const vk::RenderPassDesc &getRenderPassDesc();
      gl::Error getCommandGraphNodeForDraw(ContextVk *contextVk, vk::CommandGraphNode **nodeOut);
  
    private:
      FramebufferVk(const gl::FramebufferState &state);
      FramebufferVk(const gl::FramebufferState &state, WindowSurfaceVk *backbuffer);
  
      gl::ErrorOrResult<vk::Framebuffer *> getFramebuffer(RendererVk *rendererVk);
  
      gl::Error clearWithClearAttachments(ContextVk *contextVk,
                                          bool clearColor,
                                          bool clearDepth,
                                          bool clearStencil);
      gl::Error clearWithDraw(ContextVk *contextVk, VkColorComponentFlags colorMaskFlags);
      void updateActiveColorMasks(size_t colorIndex, bool r, bool g, bool b, bool a);
  
      WindowSurfaceVk *mBackbuffer;
  
      Optional<vk::RenderPassDesc> mRenderPassDesc;
      vk::Framebuffer mFramebuffer;
      RenderTargetCache<RenderTargetVk> mRenderTargetCache;
  
      // These two variables are used to quickly compute if we need to do a masked clear. If a color
      // channel is masked out, we check against the Framebuffer Attachments (RenderTargets) to see
      // if the masked out channel is present in any of the attachments.
      VkColorComponentFlags mActiveColorComponents;
      gl::DrawBufferMask mActiveColorComponentMasks[4];
  
      // For use in masked clear.
      vk::BufferAndMemory mMaskedClearUniformBuffer;
      VkDescriptorSet mMaskedClearDescriptorSet;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_FRAMEBUFFERVK_H_
  

Download