Add "sample locations" feature to GrProcessor

include/gpu/GrCaps.h

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef GrCaps_DEFINED
 #define GrCaps_DEFINED
 
 #include "GrTypes.h"
 #include "GrTypesPriv.h"
 #include "GrBlend.h"
 #include "GrShaderVar.h"
 #include "SkRefCnt.h"
 #include "SkString.h"
+#include "../../src/gpu/GrAllocator.h"
+#include <functional>
 
 struct GrContextOptions;
 
 class GrShaderCaps : public SkRefCnt {
 public:
     /** Info about shader variable precision within a given shader stage. That is, this info
         is relevant to a float (or vecNf) variable declared with a GrSLPrecision
         in a given GrShaderType. The info here is hoisted from the OpenGL spec. */
     struct PrecisionInfo {
         PrecisionInfo() {
@@ skipping 224 matching lines @@
     bool supportsInstancedDraws() const {
         return fSupportsInstancedDraws;
     }
 
     bool fullClearIsFree() const { return fFullClearIsFree; }
 
     /** True in environments that will issue errors if memory uploaded to buffers 
         is not initialized (even if not read by draw calls). */
     bool mustClearUploadedBufferData() const { return fMustClearUploadedBufferData; }
 
+    /** Info struct that contains hardware-specific multisample info. */
+    struct MultisampleSpecs {
+        /** Nonzero ID that uniquely identifies these multisample specs. */
+        uint8_t                            fUniqueID;
+        /** The actual number of samples the GPU will run. NOTE: this value can be greater than the
+            the render target's sample count. */
+        int                                fEffectiveSampleCnt;
+        /** If sample locations are supported, contains the subpixel locations at which the GPU will
+            sample. Pixel center is at (.5, .5) and (0, 0) indicates the top left corner. */
+        SkAutoTDeleteArray<const SkPoint>  fSampleLocations;
+    };
+
+    typedef std::function<void(int* effectiveSampleCnt, SkAutoTDeleteArray<SkPoint>* locations)>
+        QueryMultisampleFunctor;
+
+    /** Finds a surface descriptor's multisample specs. */
+    const MultisampleSpecs& getMultisampleSpecs(const GrSurfaceDesc&,

[bsalomon, 2016/03/07 19:10:06]

I'm curious why this has to be on GrCaps (as opposed to just GrGLCaps)? It seems
like putting  
It seems like you could have:

  GrRT::getSpecs(stencil)
     calls virtual GrGpu::getSpecs(this, stencil)

  GrGLGpu::getSpecs() override {
     auto rtBinder = [<capture the rt>] { bind the rt };
     // Make a call on GrGLCaps() that binds the RT if necessary and implements
caching
  }

I was hoping that in other APIs there would be less stateful way of making this
query that didn't need to necessitate a functor for tracking what state changes
occurred in order to get the sample locations.

[Chris Dalton, 2016/03/07 19:36:44]

There's nothing platform specific about caching sample patterns based on sample
count + origin, and for that reason I felt that the caching logic belongs in
GrCaps. (The same logic would apply to any backend.)

As far as the functor is concerned, it seems like if the caps class is what
initiates the query, it will need a functor no matter what. Unless, were you
thinking GrGLCaps should make the direct calls to glGetMultisamplefv?

+                                                const QueryMultisampleFunctor&) const;
+
+    /** Retrieves existing multisample specs. The provided uniqueID must have come from a valid
+        MultisampleSpecs instance that was returned previously by this class. */
+    const MultisampleSpecs& getMultisampleSpecs(const uint8_t uniqueID) const;
+
 protected:
     /** Subclasses must call this at the end of their constructors in order to apply caps
         overrides requested by the client. Note that overrides will only reduce the caps never
         expand them. */
     void applyOptionsOverrides(const GrContextOptions& options);
 
     SkAutoTUnref<GrShaderCaps>    fShaderCaps;
 
     bool fNPOTTextureTileSupport                     : 1;
     bool fMipMapSupport                              : 1;
@@ skipping 34 matching lines @@
     int fMaxStencilSampleCount;
     int fMaxRasterSamples;
 
 private:
     virtual void onApplyOptionsOverrides(const GrContextOptions&) {};
 
     bool fSuppressPrints : 1;
     bool fImmediateFlush: 1;
     bool fDrawPathMasksToCompressedTextureSupport : 1;
 
+    mutable SkTArray<const MultisampleSpecs*, true>  fMultisampleSpecsMap;
+    mutable GrTAllocator<MultisampleSpecs>           fMultisampleSpecsAllocator;
+
     typedef SkRefCnt INHERITED;
 };
 
 #endif