text: /*
   * Copyright 2011 Google Inc.
   *
   * Use of this source code is governed by a BSD-style license that can be
   * found in the LICENSE file.
   */
  
  #ifndef GrAttachment_DEFINED
  #define GrAttachment_DEFINED
  
  #include "src/core/SkClipStack.h"
  #include "src/gpu/GrSurface.h"
  
  class GrRenderTarget;
  class GrResourceKey;
  
  /**
   * This is a generic attachment class for out GrSurfaces. It always represents a single gpu
   * allocation. It contains usage flags so that we know what the attachment can be used for.
   *
   * TODO: Once we can pull out GrRenderTarget to be more of a framebuffer and break apart our
   * texture render target diamond, we will merge this class with GrSurface. Until then this will
   * act as the staging class for the new surface and framebuffer world.
   */
  class GrAttachment : public GrSurface {
  public:
      enum class UsageFlags : uint8_t {
          kStencilAttachment = 0x1,
          kColorAttachment   = 0x2,
          kTexture           = 0x4,
      };
      GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(UsageFlags);
  
      ~GrAttachment() override {}
  
      UsageFlags supportedUsages() const { return fSupportedUsages; }
  
      int numSamples() const { return fSampleCnt; }
  
      GrMipmapped mipmapped() const { return fMipmapped; }
  
      bool hasPerformedInitialClear() const { return fHasPerformedInitialClear; }
      void markHasPerformedInitialClear() { fHasPerformedInitialClear = true; }
  
      // This unique key is used for attachments of the same dimensions, usage, and sample cnt which
      // are shared between multiple render targets at the same time. Only one usage flag may be
      // passed in.
      // TODO: Once attachments start having multiple usages, we'll need to figure out how to search
      // the cache for an attachment that simply contains the requested usage instead of equaling it.
      static void ComputeSharedAttachmentUniqueKey(const GrCaps& caps,
                                                   const GrBackendFormat& format,
                                                   SkISize dimensions,
                                                   UsageFlags requiredUsage,
                                                   int sampleCnt,
                                                   GrMipmapped mipmapped,
                                                   GrProtected isProtected,
                                                   GrUniqueKey* key);
  
      // TODO: Once attachments start having multiple usages, we'll need to figure out how to search
      // the cache for an attachment that simply contains the requested usage instead of equaling it.
      static void ComputeScratchKey(const GrCaps& caps,
                                    const GrBackendFormat& format,
                                    SkISize dimensions,
                                    UsageFlags requiredUsage,
                                    int sampleCnt,
                                    GrMipmapped mipmapped,
                                    GrProtected,
                                    GrScratchKey* key);
  
  protected:
      GrAttachment(GrGpu* gpu, SkISize dimensions, UsageFlags supportedUsages, int sampleCnt,
                   GrMipmapped mipmapped, GrProtected isProtected)
              : INHERITED(gpu, dimensions, isProtected)
              , fSupportedUsages(supportedUsages)
              , fSampleCnt(sampleCnt)
              , fMipmapped(mipmapped) {}
  
  private:
      size_t onGpuMemorySize() const final;
  
      void computeScratchKey(GrScratchKey*) const final;
  
      const char* getResourceType() const override {
          if (fSupportedUsages == UsageFlags::kStencilAttachment) {
              return "StencilAttachment";
          }
  
          // This is a general grouping of all textures and color attachments.
          return "Surface";
      }
  
      UsageFlags fSupportedUsages;
      int fSampleCnt;
      GrMipmapped fMipmapped;
      bool fHasPerformedInitialClear = false;
  
      using INHERITED = GrSurface;
  };
  
  GR_MAKE_BITFIELD_CLASS_OPS(GrAttachment::UsageFlags);
  
  #endif
  