Add "sample locations" feature to GrProcessor

src/gpu/GrCaps.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrCaps.h"
 #include "GrContextOptions.h"
@@ skipping 62 matching lines @@
     return r;
 }
 
 void GrShaderCaps::applyOptionsOverrides(const GrContextOptions& options) {
     fDualSourceBlendingSupport = fDualSourceBlendingSupport && !options.fSuppressDualSourceBlending;
     this->onApplyOptionsOverrides(options);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrCaps::GrCaps(const GrContextOptions& options) {
+GrCaps::GrCaps(const GrContextOptions& options) : fMultisampleSpecsAllocator(1) {
     fMipMapSupport = false;
     fNPOTTextureTileSupport = false;
     fTwoSidedStencilSupport = false;
     fStencilWrapOpsSupport = false;
     fDiscardRenderTargetSupport = false;
     fReuseScratchTextures = true;
     fReuseScratchBuffers = true;
     fGpuTracingSupport = false;
     fCompressedTexSubImageSupport = false;
     fOversizedStencilSupport = false;
@@ skipping 31 matching lines @@
     fMaxTextureSize = SkTMin(fMaxTextureSize, options.fMaxTextureSizeOverride);
     // If the max tile override is zero, it means we should use the max texture size.
     if (!options.fMaxTileSizeOverride || options.fMaxTileSizeOverride > fMaxTextureSize) {
         fMaxTileSize = fMaxTextureSize;
     } else {
         fMaxTileSize = options.fMaxTileSizeOverride;
     }
     this->onApplyOptionsOverrides(options);
 }
 
+inline static uint8_t multisample_specs_id(uint8_t numSamples, GrSurfaceOrigin origin,
+                                           const GrCaps& caps) {
+    if (!caps.sampleLocationsSupport()) {
+        return numSamples;
+    }
+
+    SkASSERT(numSamples < 128);
+    SkASSERT(kTopLeft_GrSurfaceOrigin == origin || kBottomLeft_GrSurfaceOrigin == origin);
+    return (numSamples << 1) | (origin - 1);
+
+    GR_STATIC_ASSERT(1 == kTopLeft_GrSurfaceOrigin);
+    GR_STATIC_ASSERT(2 == kBottomLeft_GrSurfaceOrigin);
+}
+
+const GrCaps::MultisampleSpecs&
+GrCaps::getMultisampleSpecs(const GrSurfaceDesc& desc,
+                            const QueryMultisampleFunctor& queryMultisample) const {
+    uint8_t surfDescKey = multisample_specs_id(desc.fSampleCnt, desc.fOrigin, *this);
+    if (fMultisampleSpecsMap.count() > surfDescKey && fMultisampleSpecsMap[surfDescKey]) {
+#if !defined(SK_DEBUG)
+        // In debug mode we query the multisample info every time and verify the caching is correct.
+        return *fMultisampleSpecsMap[surfDescKey];
+#endif
+    }
+    int effectiveSampleCnt;
+    SkAutoTDeleteArray<SkPoint> locations(nullptr);
+    queryMultisample(&effectiveSampleCnt, &locations);
+    SkASSERT(effectiveSampleCnt && effectiveSampleCnt >= desc.fSampleCnt);
+    uint8_t effectiveKey = multisample_specs_id(effectiveSampleCnt, desc.fOrigin, *this);
+    if (fMultisampleSpecsMap.count() > effectiveKey && fMultisampleSpecsMap[effectiveKey]) {
+        const MultisampleSpecs& specs = *fMultisampleSpecsMap[effectiveKey];
+        SkASSERT(effectiveKey == specs.fUniqueID);
+        SkASSERT(effectiveSampleCnt == specs.fEffectiveSampleCnt);
+        SkASSERT(!this->sampleLocationsSupport() || !memcmp(locations.get(),
+                                                            specs.fSampleLocations.get(),
+                                                            effectiveSampleCnt * sizeof(SkPoint)));
+        SkASSERT(surfDescKey <= effectiveKey);
+        SkASSERT(!fMultisampleSpecsMap[surfDescKey] || fMultisampleSpecsMap[surfDescKey] == &specs);
+        fMultisampleSpecsMap[surfDescKey] = &specs;
+        return specs;
+    }
+    const MultisampleSpecs& specs = *new (&fMultisampleSpecsAllocator)
+        MultisampleSpecs{effectiveKey, effectiveSampleCnt, locations.detach()};
+    if (fMultisampleSpecsMap.count() <= effectiveKey) {
+        int n = 1 + effectiveKey - fMultisampleSpecsMap.count();
+        fMultisampleSpecsMap.push_back_n(n, (const MultisampleSpecs*) nullptr);
+    }
+    fMultisampleSpecsMap[effectiveKey] = &specs;
+    if (effectiveSampleCnt != desc.fSampleCnt) {
+        SkASSERT(surfDescKey < effectiveKey);
+        fMultisampleSpecsMap[surfDescKey] = &specs;
+    }
+    return specs;
+}
+
+const GrCaps::MultisampleSpecs& GrCaps::getMultisampleSpecs(uint8_t uniqueID) const {
+    SkASSERT(fMultisampleSpecsMap.count() > uniqueID && fMultisampleSpecsMap[uniqueID]);
+    const MultisampleSpecs& specs = *fMultisampleSpecsMap[uniqueID];
+    SkASSERT(specs.fUniqueID == uniqueID);
+    return specs;
+}
+
 static SkString map_flags_to_string(uint32_t flags) {
     SkString str;
     if (GrCaps::kNone_MapFlags == flags) {
         str = "none";
     } else {
         SkASSERT(GrCaps::kCanMap_MapFlag & flags);
         SkDEBUGCODE(flags &= ~GrCaps::kCanMap_MapFlag);
         str = "can_map";
 
         if (GrCaps::kSubset_MapFlag & flags) {
@@ skipping 105 matching lines @@
 
     for (size_t i = 1; i < SK_ARRAY_COUNT(kConfigNames); ++i)  {
         GrPixelConfig config = static_cast<GrPixelConfig>(i);
         r.appendf("%s is uploadable to a texture: %s\n",
                   kConfigNames[i],
                   gNY[this->isConfigTexturable(config)]);
     }
 
     return r;
 }