kc3-lang/angle/src/libANGLE/renderer/FramebufferImpl.h

• Show log

  Commit

• Hash : 6722009e
  Author :
  Date : 2019-05-20T11:12:53
  

  Vulkan: Handle dirty RTs with state messages.
  
  Prior to this CL we were handling dirty state change notifications by
  flushing the RT Images just prior to use or just after they were
  changed. This could lead to a few redundant checks in several places.
  It also meant we needed an owner pointer from the RT to the parent
  Image. This pointer would be null for Surfaces and Renderbuffers.
  
  This cleans up the image flushing logic to be handled by dirty bit
  notifications. When an app updates an attached Texture with TexSubImage
  or related calls it will send a notification to the Framebuffer. The
  Framebuffer then sets a dirty contents bit that is handled in the
  implementation. In Vulkan this means flushing the dirty bits.
  
  Requires adding a flag to the FramebufferImpl class to determine if we
  need to syncState before we checkStatus. Adding the option allows us to
  only call syncState for the GL back-end. Not calling syncState allows
  the robust resource init operation to happen *before* we syncState.
  Which in turn allows FramebuffeVk to initialize the VkImages in one go.
  
  Added new regression tests for Texture updates. This might not cover
  all cases. I found it was very hard to trigger some of the resource
  update staging in TextureVk.
  
  Bug: angleproject:3427
  Change-Id: Idfa177436ba7fcb9d398f2b67922e085f778f82a
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1601552
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/FramebufferImpl.h

• //
  // Copyright 2014 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.
  //
  
  // FramebufferImpl.h: Defines the abstract rx::FramebufferImpl class.
  
  #ifndef LIBANGLE_RENDERER_FRAMEBUFFERIMPL_H_
  #define LIBANGLE_RENDERER_FRAMEBUFFERIMPL_H_
  
  #include "angle_gl.h"
  #include "common/angleutils.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/Framebuffer.h"
  
  namespace gl
  {
  class State;
  class Framebuffer;
  class FramebufferAttachment;
  struct Rectangle;
  }  // namespace gl
  
  namespace rx
  {
  class DisplayImpl;
  
  class FramebufferImpl : angle::NonCopyable
  {
    public:
      explicit FramebufferImpl(const gl::FramebufferState &state) : mState(state) {}
      virtual ~FramebufferImpl() {}
      virtual void destroy(const gl::Context *context) {}
  
      virtual angle::Result discard(const gl::Context *context,
                                    size_t count,
                                    const GLenum *attachments)       = 0;
      virtual angle::Result invalidate(const gl::Context *context,
                                       size_t count,
                                       const GLenum *attachments)    = 0;
      virtual angle::Result invalidateSub(const gl::Context *context,
                                          size_t count,
                                          const GLenum *attachments,
                                          const gl::Rectangle &area) = 0;
  
      virtual angle::Result clear(const gl::Context *context, GLbitfield mask) = 0;
      virtual angle::Result clearBufferfv(const gl::Context *context,
                                          GLenum buffer,
                                          GLint drawbuffer,
                                          const GLfloat *values)               = 0;
      virtual angle::Result clearBufferuiv(const gl::Context *context,
                                           GLenum buffer,
                                           GLint drawbuffer,
                                           const GLuint *values)               = 0;
      virtual angle::Result clearBufferiv(const gl::Context *context,
                                          GLenum buffer,
                                          GLint drawbuffer,
                                          const GLint *values)                 = 0;
      virtual angle::Result clearBufferfi(const gl::Context *context,
                                          GLenum buffer,
                                          GLint drawbuffer,
                                          GLfloat depth,
                                          GLint stencil)                       = 0;
  
      virtual GLenum getImplementationColorReadFormat(const gl::Context *context) const = 0;
      virtual GLenum getImplementationColorReadType(const gl::Context *context) const   = 0;
      virtual angle::Result readPixels(const gl::Context *context,
                                       const gl::Rectangle &area,
                                       GLenum format,
                                       GLenum type,
                                       void *pixels)                                    = 0;
  
      virtual angle::Result blit(const gl::Context *context,
                                 const gl::Rectangle &sourceArea,
                                 const gl::Rectangle &destArea,
                                 GLbitfield mask,
                                 GLenum filter) = 0;
  
      virtual bool checkStatus(const gl::Context *context) const = 0;
  
      virtual angle::Result syncState(const gl::Context *context,
                                      const gl::Framebuffer::DirtyBits &dirtyBits) = 0;
  
      virtual angle::Result getSamplePosition(const gl::Context *context,
                                              size_t index,
                                              GLfloat *xy) const = 0;
  
      // Special configuration option for checkStatus(). Some back-ends don't require a syncState
      // before calling checkStatus. In practice the GL back-end is the only config that needs
      // syncState because it depends on the behaviour of the driver. Allowing the Vulkan and
      // D3D back-ends to skip syncState lets us do more work in the syncState call.
      virtual bool shouldSyncStateBeforeCheckStatus() const;
  
      const gl::FramebufferState &getState() const { return mState; }
  
    protected:
      const gl::FramebufferState &mState;
  };
  
  inline bool FramebufferImpl::shouldSyncStateBeforeCheckStatus() const
  {
      return false;
  }
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_FRAMEBUFFERIMPL_H_
  

Download