Implement support for mixed sampled render targets

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 11 matching lines @@
  * that wrap externally created render targets.
  */
 class GrRenderTarget : virtual public GrSurface {
 public:
     SK_DECLARE_INST_COUNT(GrRenderTarget)
 
     // GrSurface overrides
     GrRenderTarget* asRenderTarget() SK_OVERRIDE { return this; }
     const GrRenderTarget* asRenderTarget() const  SK_OVERRIDE { return this; }
 
     // GrRenderTarget

[Chris Dalton, 2015/03/17 00:39:35]

I've thought about it more, and I recommend creating this new enum:

 enum PipelineStage {
     kColorBuffer_PipelineStage,
     kStencilBuffer_PipelineStage,
     kEverywhere_PipelineStage = kColorBuffer_PipelineStage,
     kAnywhere_PipelineStage = kStencil_PipelineStage,
     kRaster_PipelineStage = kStencil_PipelineStage
 };

Then, isMultisampled and numSamples accept a PipelineStage enum instead.

     /**
-     * @return true if the surface is multisampled, false otherwise
+     * @param requestedConfig
+     * @return true if the surface is multisampled in all of the buffers
+     *         specified by the sample config, false if any are non-MSAA
      */
-    bool isMultisampled() const { return 0 != fDesc.fSampleCnt; }
+    bool isMultisampled(GrSampleConfig requestedConfig = kUnified_GrSampleConfig) const {
+        return 0 != numSamples(requestedConfig);
+    }
 
     /**
-     * @return the number of samples-per-pixel or zero if non-MSAA.
+     * @return the number of samples-per-pixel or zero if any of the specified
+     *         buffers is non-MSAA.
      */
-    int numSamples() const { return fDesc.fSampleCnt; }
+    int numSamples(GrSampleConfig requestedConfig = kUnified_GrSampleConfig) const {
+        if (kStencil_GrSampleConfig == fSampleConfig &&
+            kUnified_GrSampleConfig == requestedConfig) {
+            return 0;
+        }
+        return fDesc.fSampleCnt;
+    }
+
+    /**
+     * @return sample config.
+     */
+    GrSampleConfig sampleConfig() {
+        return fSampleConfig;
+    }
 
     /**
      * 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 35 matching lines @@
         kAutoResolves_ResolveType,
         kCantResolve_ResolveType,
     };
     virtual ResolveType getResolveType() const = 0;
 
     // Provides access to functions that aren't part of the public API.
     GrRenderTargetPriv renderTargetPriv();
     const GrRenderTargetPriv renderTargetPriv() const;
 
 protected:
-    GrRenderTarget(GrGpu* gpu, LifeCycle lifeCycle, const GrSurfaceDesc& desc)
+    GrRenderTarget(GrGpu* gpu, LifeCycle lifeCycle, const GrSurfaceDesc& desc,
+                   GrSampleConfig sampleConfig)
         : INHERITED(gpu, lifeCycle, desc)
+        , fSampleConfig(sampleConfig)
         , fStencilBuffer(NULL) {
         fResolveRect.setLargestInverted();
     }
 
     // override of GrResource
     void onAbandon() SK_OVERRIDE;
     void onRelease() SK_OVERRIDE;
 
 private:
     // Checked when this object is asked to attach a stencil buffer.
     virtual bool canAttemptStencilAttachment() const = 0;
 
     friend class GrRenderTargetPriv;
 
+    GrSampleConfig    fSampleConfig;
+
     GrStencilBuffer*  fStencilBuffer;
 
     SkIRect           fResolveRect;
 
     typedef GrSurface INHERITED;
 };
 
 #endif