Add flag for window rectangles to GrRenderTarget

include/gpu/GrRenderTarget.h

 /*
  * 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 GrRenderTarget_DEFINED
 #define GrRenderTarget_DEFINED
 
@@ skipping 12 matching lines @@
  * Additionally, GrContext provides methods for creating GrRenderTargets
  * that wrap externally created render targets.
  */
 class GrRenderTarget : virtual public GrSurface {
 public:
     // GrSurface overrides
     GrRenderTarget* asRenderTarget() override { return this; }
     const GrRenderTarget* asRenderTarget() const  override { return this; }
 
     // GrRenderTarget
-    /**
-     * On some hardware it is possible for a render target to have multisampling
-     * only in certain buffers.
-     * Enforce only two legal sample configs.
-     * kUnified_SampleConfig signifies multisampling in both color and stencil
-     * buffers and is available across all hardware.
-     * kStencil_SampleConfig means multisampling is present in stencil buffer
-     * only; this config requires hardware support of
-     * NV_framebuffer_mixed_samples.
-    */
-    enum SampleConfig {
-        kUnified_SampleConfig = 0,
-        kStencil_SampleConfig = 1
-    };
+    bool isOffscreen() const { return fFlags & Flags::kOffscreen; }
+
+    bool isStencilBufferMultisampled() const { return fDesc.fSampleCnt > 0; }
 
     /**
-     * @return true if the surface is multisampled in all buffers,
-     *         false otherwise
+     * For our purposes, "Mixed Sampled" means the stencil buffer is multisampled but the color
+     * buffer is not.
      */
-    bool isUnifiedMultisampled() const {
-        if (fSampleConfig != kUnified_SampleConfig) {
-            return false;
-        }
-        return 0 != fDesc.fSampleCnt;
-    }
+    bool isMixedSampled() const { return fFlags & Flags::kMixedSampled; }
 
     /**
-     * @return true if the surface is multisampled in the stencil buffer,
-     *         false otherwise
+     * "Unified Sampled" means the stencil and color buffers are both multisampled.
      */
-    bool isStencilBufferMultisampled() const {
-        return 0 != fDesc.fSampleCnt;
-    }
+    bool isUnifiedMultisampled() const { return fDesc.fSampleCnt > 0 && !this->isMixedSampled(); }
 
     /**
-     * @return the number of color samples-per-pixel, or zero if non-MSAA or
-     *         multisampled in the stencil buffer only.
+     * Returns the number of samples/pixel in the stencil buffer (Zero if non-MSAA).
      */
-    int numColorSamples() const {
-        if (fSampleConfig == kUnified_SampleConfig) {
-            return fDesc.fSampleCnt;
-        }
-        return 0;
-    }
+    int numStencilSamples() const { return fDesc.fSampleCnt; }
 
     /**
-     * @return the number of stencil samples-per-pixel, or zero if non-MSAA.
+     * Returns the number of samples/pixel in the color buffer (Zero if non-MSAA or mixed sampled).
      */
-    int numStencilSamples() const {
-        return fDesc.fSampleCnt;
-    }
-
-    /**
-     * @return true if the surface is mixed sampled, false otherwise.
-     */
-    bool hasMixedSamples() const {
-        SkASSERT(kStencil_SampleConfig != fSampleConfig ||
-                 this->isStencilBufferMultisampled());
-        return kStencil_SampleConfig == fSampleConfig;
-    }
+    int numColorSamples() const { return this->isMixedSampled() ? 0 : fDesc.fSampleCnt; }
 
     /**
      * Call to indicate the multisample contents were modified such that the
      * render target needs to be resolved before it can be used as texture. Gr
      * tracks this for its own drawing and thus this only needs to be called
      * when the render target has been modified outside of Gr. This has no
      * effect on wrapped backend render targets.
      *
      * @param rect  a rect bounding the area needing resolve. NULL indicates
      *              the whole RT needs resolving.
@@ skipping 46 matching lines @@
     // Checked when this object is asked to attach a stencil buffer.
     virtual bool canAttemptStencilAttachment() const = 0;
 
     // Provides access to functions that aren't part of the public API.
     GrRenderTargetPriv renderTargetPriv();
     const GrRenderTargetPriv renderTargetPriv() const;
 
     void setLastDrawTarget(GrDrawTarget* dt);
     GrDrawTarget* getLastDrawTarget() { return fLastDrawTarget; }
 
-    static SampleConfig ComputeSampleConfig(const GrCaps& caps, int sampleCnt);
+protected:
+    enum class Flags {
+        kNone          = 0,
+        kOffscreen     = 1 << 0,
+        kMixedSampled  = 1 << 1
+    };
 
-protected:
-    GrRenderTarget(GrGpu* gpu, const GrSurfaceDesc& desc,
-                   SampleConfig sampleConfig, GrStencilAttachment* stencil = nullptr)
+    GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(Flags);
+
+    GrRenderTarget(GrGpu* gpu, const GrSurfaceDesc& desc, Flags flags,
+                   GrStencilAttachment* stencil = nullptr)
         : INHERITED(gpu, desc)
         , fStencilAttachment(stencil)
         , fMultisampleSpecsID(0)
-        , fSampleConfig(sampleConfig)
+        , fFlags(flags)
         , fLastDrawTarget(nullptr) {
+        SkASSERT(!(fFlags & Flags::kMixedSampled) || fDesc.fSampleCnt > 0);
         fResolveRect.setLargestInverted();
     }
 
     ~GrRenderTarget() override;
 
     // override of GrResource
     void onAbandon() override;
     void onRelease() override;
 
 private:
     // Allows the backends to perform any additional work that is required for attaching a
     // GrStencilAttachment. When this is called, the GrStencilAttachment has already been put onto
     // the GrRenderTarget. This function must return false if any failures occur when completing the
     // stencil attachment.
     virtual bool completeStencilAttachment() = 0;
 
     friend class GrRenderTargetPriv;
 
     GrStencilAttachment*  fStencilAttachment;
     uint8_t               fMultisampleSpecsID;
-    SampleConfig          fSampleConfig;
+    Flags                 fFlags;
 
     SkIRect               fResolveRect;
 
     // The last drawTarget that wrote to or is currently going to write to this renderTarget
     // The drawTarget can be closed (e.g., no draw context is currently bound
     // to this renderTarget).
     // This back-pointer is required so that we can add a dependancy between
     // the drawTarget used to create the current contents of this renderTarget
     // and the drawTarget of a destination renderTarget to which this one is being drawn.
     GrDrawTarget* fLastDrawTarget;
 
     typedef GrSurface INHERITED;
 };
 
+GR_MAKE_BITFIELD_CLASS_OPS(GrRenderTarget::Flags);
 
 #endif