kc3-lang/angle/src/libANGLE/Renderbuffer.h

• Show log

  Commit

• Hash : 185d9d08
  Author :
  Date : 2020-08-14T22:48:15
  

  Re-land "Feedback Loop Redesign 2/3: Track bound FBOs in Texture."
  
  Re-land fixes the crash when drawing with no bound Program executable.
  
  Currently we track feedback loops by counting the times a Texture is
  bound as a sampler or image in a particular context. This is a bit
  tricky because Texture bindings change frequently. Relative to the
  number of times we need to check for a feedback loop this causes excess
  overhead.
  
  Usually Framebuffers have a low number of Textures bound (in many cases
  just 1). And Textures aren't usually bound to many different FBOs. So
  instead of counting the number of times a Texture is bound as a sampler
  or image we will track the Framebuffers that the Texture is bound to.
  
  This CL adds a small vector class to gl::Texture which tracks all the
  Framebufer Serials of its bound Framebuffers. We can use this set to
  quickly check if there's any potential feedback loop between the a FBO
  and this Texture.
  
  We also update the feedback loop check to use this new method. We will
  be able to remove the old counting method when we switch the Vulkan
  feedback loop handling to use the new tracking in this CL.
  
  Bug: angleproject:4500
  Bug: angleproject:4959
  Change-Id: If2bd25b08298a99f5e64b4055137f9154b0f0860
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2365595
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/Renderbuffer.h

• //
  // Copyright 2002 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.
  //
  
  // Renderbuffer.h: Defines the renderer-agnostic container class gl::Renderbuffer.
  // Implements GL renderbuffer objects and related functionality.
  // [OpenGL ES 2.0.24] section 4.4.3 page 108.
  
  #ifndef LIBANGLE_RENDERBUFFER_H_
  #define LIBANGLE_RENDERBUFFER_H_
  
  #include "angle_gl.h"
  #include "common/angleutils.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/FramebufferAttachment.h"
  #include "libANGLE/Image.h"
  #include "libANGLE/formatutils.h"
  #include "libANGLE/renderer/RenderbufferImpl.h"
  
  namespace rx
  {
  class GLImplFactory;
  }  // namespace rx
  
  namespace gl
  {
  // A GL renderbuffer object is usually used as a depth or stencil buffer attachment
  // for a framebuffer object. The renderbuffer itself is a distinct GL object, see
  // FramebufferAttachment and Framebuffer for how they are applied to an FBO via an
  // attachment point.
  
  class RenderbufferState final : angle::NonCopyable
  {
    public:
      RenderbufferState();
      ~RenderbufferState();
  
      GLsizei getWidth() const;
      GLsizei getHeight() const;
      const Format &getFormat() const;
      GLsizei getSamples() const;
      InitState getInitState() const;
  
    private:
      friend class Renderbuffer;
  
      void update(GLsizei width,
                  GLsizei height,
                  const Format &format,
                  GLsizei samples,
                  InitState initState);
  
      GLsizei mWidth;
      GLsizei mHeight;
      Format mFormat;
      GLsizei mSamples;
  
      // For robust resource init.
      InitState mInitState;
  };
  
  class Renderbuffer final : public RefCountObject<RenderbufferID>,
                             public egl::ImageSibling,
                             public LabeledObject
  {
    public:
      Renderbuffer(rx::GLImplFactory *implFactory, RenderbufferID id);
      ~Renderbuffer() override;
  
      void onDestroy(const Context *context) override;
  
      void setLabel(const Context *context, const std::string &label) override;
      const std::string &getLabel() const override;
  
      angle::Result setStorage(const Context *context,
                               GLenum internalformat,
                               size_t width,
                               size_t height);
      angle::Result setStorageMultisample(const Context *context,
                                          size_t samples,
                                          GLenum internalformat,
                                          size_t width,
                                          size_t height);
      angle::Result setStorageEGLImageTarget(const Context *context, egl::Image *imageTarget);
  
      rx::RenderbufferImpl *getImplementation() const;
  
      GLsizei getWidth() const;
      GLsizei getHeight() const;
      const Format &getFormat() const;
      GLsizei getSamples() const;
      GLuint getRedSize() const;
      GLuint getGreenSize() const;
      GLuint getBlueSize() const;
      GLuint getAlphaSize() const;
      GLuint getDepthSize() const;
      GLuint getStencilSize() const;
      const RenderbufferState &getState() const;
  
      GLint getMemorySize() const;
  
      // FramebufferAttachmentObject Impl
      Extents getAttachmentSize(const ImageIndex &imageIndex) const override;
      Format getAttachmentFormat(GLenum binding, const ImageIndex &imageIndex) const override;
      GLsizei getAttachmentSamples(const ImageIndex &imageIndex) const override;
      bool isRenderable(const Context *context,
                        GLenum binding,
                        const ImageIndex &imageIndex) const override;
  
      void onAttach(const Context *context, rx::Serial framebufferSerial) override;
      void onDetach(const Context *context, rx::Serial framebufferSerial) override;
      GLuint getId() const override;
  
      InitState initState(const ImageIndex &imageIndex) const override;
      void setInitState(const ImageIndex &imageIndex, InitState initState) override;
  
      GLenum getImplementationColorReadFormat(const Context *context) const;
      GLenum getImplementationColorReadType(const Context *context) const;
  
      // We pass the pack buffer and state explicitly so they can be overridden during capture.
      angle::Result getRenderbufferImage(const Context *context,
                                         const PixelPackState &packState,
                                         Buffer *packBuffer,
                                         GLenum format,
                                         GLenum type,
                                         void *pixels) const;
  
    private:
      // ObserverInterface implementation.
      void onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) override;
  
      rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override;
  
      RenderbufferState mState;
      std::unique_ptr<rx::RenderbufferImpl> mImplementation;
  
      std::string mLabel;
      angle::ObserverBinding mImplObserverBinding;
  };
  
  }  // namespace gl
  
  #endif  // LIBANGLE_RENDERBUFFER_H_
  

Download