Support multiple scales for dfpaths.

src/gpu/GrAADistanceFieldPathRenderer.h

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAADistanceFieldPathRenderer_DEFINED
 #define GrAADistanceFieldPathRenderer_DEFINED
@@ skipping 23 matching lines @@
                                                const SkStrokeRec&,
                                                const GrDrawTarget*) const SK_OVERRIDE;
     
     virtual bool onDrawPath(const SkPath& path,
                             const SkStrokeRec& stroke,
                             GrDrawTarget* target,
                             bool antiAlias) SK_OVERRIDE;
 
 private:
     struct PathData {
-        uint32_t   fGenID;
+        struct Key {
+            uint32_t   fGenID;

[robertphillips, 2014/10/29 19:55:02]

// fMipLevel is the scaling applied to this path when it was generated. This
determines the range for which it can be used to draw.

?

[jvanverth1, 2014/10/30 12:48:28]

Done.

+            uint32_t   fMipLevel;
+            bool operator==(const Key& other) const {
+                return other.fGenID == fGenID && other.fMipLevel == fMipLevel;
+            }
+        };
+        Key        fKey;
+        SkScalar   fScale;
         GrPlot*    fPlot;
         SkRect     fBounds;
         SkIPoint16 fAtlasLocation;
         SK_DECLARE_INTERNAL_LLIST_INTERFACE(PathData);
         
-        static inline const uint32_t& GetKey(const PathData& data) {
-            return data.fGenID;
+        static inline const Key& GetKey(const PathData& data) {
+            return data.fKey;
         }
         
-        static inline uint32_t Hash(uint32_t key) {
-            return SkChecksum::Murmur3(&key, sizeof(key));
+        static inline uint32_t Hash(Key key) {
+            return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(&key), sizeof(key));
         }
     };
     typedef SkTInternalLList<PathData> PathDataList;
     
     GrContext*                         fContext;
     GrAtlas*                           fAtlas;
     SkAutoTUnref<GrGeometryProcessor>  fCachedGeometryProcessor;
     // current set of flags used to create the cached geometry processor
     uint32_t                           fEffectFlags;
     GrAtlas::ClientPlotUsage           fPlotUsage;
-    SkTDynamicHash<PathData, uint32_t> fPathCache;
+    SkTDynamicHash<PathData, PathData::Key> fPathCache;
     PathDataList                       fPathList;
     
     bool internalDrawPath(const SkPath& path, const PathData* pathData, GrDrawTarget* target);
-    PathData* addPathToAtlas(const SkPath& path, const SkStrokeRec& stroke, bool antiAlias);
+    PathData* addPathToAtlas(const SkPath& path, const SkStrokeRec& stroke, bool antiAlias,
+                             uint32_t mipLevel, SkScalar scale);
     bool freeUnusedPlot();
     
     typedef GrPathRenderer INHERITED;
 };
 
 #endif