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

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2017-09-14 22:20:29
  Hash : 71c88b31
  Message : Enable [[nodiscard]] for gl::Error. This forces all return values to be checked for gl::Error. Requires quite a bit of minor refactoring. I also added a macro to swallow an error without returning from a function. We could look at storing the errors in the Context at some point, since almost always when we're generating errors that we need to discard we have access to the Context as a parameter. BUG=angleproject:2150 Change-Id: I457e48a30c002eda0993acbcd3180ba87bf169fb Reviewed-on: https://chromium-review.googlesource.com/665173 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: Yuly Novikov <ynovikov@chromium.org>

• src/libANGLE/Image.h

• //
  // Copyright (c) 2015 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.
  //
  
  // Image.h: Defines the egl::Image class representing the EGLimage object.
  
  #ifndef LIBANGLE_IMAGE_H_
  #define LIBANGLE_IMAGE_H_
  
  #include "common/angleutils.h"
  #include "libANGLE/AttributeMap.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/FramebufferAttachment.h"
  #include "libANGLE/RefCountObject.h"
  #include "libANGLE/formatutils.h"
  
  #include <set>
  
  namespace rx
  {
  class EGLImplFactory;
  class ImageImpl;
  }
  
  namespace egl
  {
  class Image;
  
  // Only currently Renderbuffers and Textures can be bound with images. This makes the relationship
  // explicit, and also ensures that an image sibling can determine if it's been initialized or not,
  // which is important for the robust resource init extension with Textures and EGLImages.
  class ImageSibling : public gl::RefCountObject, public gl::FramebufferAttachmentObject
  {
    public:
      ImageSibling(GLuint id);
      virtual ~ImageSibling();
  
    protected:
      // Set the image target of this sibling
      void setTargetImage(const gl::Context *context, egl::Image *imageTarget);
  
      // Orphan all EGL image sources and targets
      gl::Error orphanImages(const gl::Context *context);
  
    private:
      friend class Image;
  
      // Called from Image only to add a new source image
      void addImageSource(egl::Image *imageSource);
  
      // Called from Image only to remove a source image when the Image is being deleted
      void removeImageSource(egl::Image *imageSource);
  
      std::set<Image *> mSourcesOf;
      gl::BindingPointer<Image> mTargetOf;
  };
  
  struct ImageState : private angle::NonCopyable
  {
      ImageState(EGLenum target, ImageSibling *buffer, const AttributeMap &attribs);
  
      gl::ImageIndex imageIndex;
      gl::BindingPointer<ImageSibling> source;
      std::set<ImageSibling *> targets;
  };
  
  class Image final : public gl::RefCountObject
  {
    public:
      Image(rx::EGLImplFactory *factory,
            EGLenum target,
            ImageSibling *buffer,
            const AttributeMap &attribs);
  
      gl::Error onDestroy(const gl::Context *context) override;
      ~Image();
  
      const gl::Format &getFormat() const;
      size_t getWidth() const;
      size_t getHeight() const;
      size_t getSamples() const;
  
      Error initialize();
  
      rx::ImageImpl *getImplementation() const;
  
    private:
      friend class ImageSibling;
  
      // Called from ImageSibling only notify the image that a new target sibling exists for state
      // tracking.
      void addTargetSibling(ImageSibling *sibling);
  
      // Called from ImageSibling only to notify the image that a sibling (source or target) has
      // been respecified and state tracking should be updated.
      gl::Error orphanSibling(const gl::Context *context, ImageSibling *sibling);
  
      ImageState mState;
      rx::ImageImpl *mImplementation;
  };
  }  // namespace egl
  
  #endif  // LIBANGLE_IMAGE_H_