Add "sample locations" feature to GrProcessor

src/gpu/GrGpu.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 GrGpu_DEFINED
 #define GrGpu_DEFINED
 
 #include "GrPipelineBuilder.h"
 #include "GrProgramDesc.h"
+#include "GrRenderTargetPriv.h"
 #include "GrStencil.h"
 #include "GrSwizzle.h"
 #include "GrTextureParamsAdjuster.h"
 #include "GrXferProcessor.h"
 #include "SkPath.h"
+#include <map>
 
 class GrBatchTracker;
 class GrContext;
 class GrGLContext;
 class GrIndexBuffer;
 class GrNonInstancedVertices;
 class GrPath;
 class GrPathRange;
 class GrPathRenderer;
 class GrPathRendererChain;
@@ skipping 298 matching lines @@
 
     // Called to perform a surface to surface copy. Fallbacks to issuing a draw from the src to dst
     // take place at the GrDrawTarget level and this function implement faster copy paths. The rect
     // and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the
     // src/dst bounds and non-empty.
     bool copySurface(GrSurface* dst,
                      GrSurface* src,
                      const SkIRect& srcRect,
                      const SkIPoint& dstPoint);
 
+    typedef GrRenderTargetPriv::MultisampleSpecs MultisampleSpecs;
+
+    const MultisampleSpecs& getMultisampleSpecs(GrRenderTarget*, const GrStencilSettings&);
+
     struct DrawArgs {
         DrawArgs(const GrPrimitiveProcessor* primProc,
                  const GrPipeline* pipeline,
                  const GrProgramDesc* desc)
             : fPrimitiveProcessor(primProc)
             , fPipeline(pipeline)
             , fDesc(desc) {
             SkASSERT(primProc && pipeline && desc);
         }
         const GrPrimitiveProcessor* fPrimitiveProcessor;
@@ skipping 134 matching lines @@
                          GrGpu::kGpuPrefersDraw_DrawPreference);
         *preference = SkTMax(*preference, elevation);
     }
 
     void handleDirtyContext() {
         if (fResetBits) {
             this->resetContext();
         }
     }
 
+    class SamplePattern : public SkTArray<SkPoint, true> {

[bsalomon, 2016/02/22 20:28:25]

It seems a little odd to me for this to be a point array instead of just contain
one. Does the public array interface really make sense for this?

[Chris Dalton, 2016/02/22 21:19:11]

Yeah, that felt a little weird. The only reason this class even exists is to
overload the < operator. Maybe the better option would be to give std::map a
custom comparator. It would also eliminate the confusion around what the
SamplePattern < operator was for.

[Chris Dalton, 2016/02/22 22:17:55]

Done.

+    public:
+        bool operator <(const SamplePattern&) const;
+    };
+
     Stats                                   fStats;
     SkAutoTDelete<GrPathRendering>          fPathRendering;
     // Subclass must initialize this in its constructor.
     SkAutoTUnref<const GrCaps>    fCaps;
 
 private:
     // called when the 3D context state is unknown. Subclass should emit any
     // assumed 3D context state and dirty any state cache.
     virtual void onResetContext(uint32_t resetBits) = 0;
 
@@ skipping 59 matching lines @@
 
     // overridden by backend-specific derived class to perform the resolve
     virtual void onResolveRenderTarget(GrRenderTarget* target) = 0;
 
     // overridden by backend specific derived class to perform the copy surface
     virtual bool onCopySurface(GrSurface* dst,
                                GrSurface* src,
                                const SkIRect& srcRect,
                                const SkIPoint& dstPoint) = 0;
 
+    // overridden by backend specific derived class to perform the multisample queries
+    virtual void onGetMultisampleSpecs(GrRenderTarget*,
+                                       const GrStencilSettings&,
+                                       int* effectiveSampleCnt,
+                                       SamplePattern*) = 0;
+
     void resetContext() {
         this->onResetContext(fResetBits);
         fResetBits = 0;
         ++fResetTimestamp;
     }
 
     ResetTimestamp                                                      fResetTimestamp;
     uint32_t                                                            fResetBits;
+    SkTArray<skstd::unique_ptr<MultisampleSpecs> >                      fRasterMultisampleSpecs;
+    std::map<SamplePattern, uint16_t>                                   fKnownSamplePatterns;
+    uint16_t                                                            fNextSamplePatternID;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
     GrContext*                                                          fContext;
 
     friend class GrPathRendering;
     typedef SkRefCnt INHERITED;
 };
 
 #endif