SkRemote: shaders

src/core/SkRemote.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 "SkPath.h"
 #include "SkRect.h"
 #include "SkRemote.h"
@@ skipping 83 matching lines @@
     };
 
 
     Cache* Cache::CreateNeverCache() {
         struct NeverCache final : public Cache {
             NeverCache()
                 : fNextMatrix  (Type::kMatrix)
                 , fNextMisc    (Type::kMisc)
                 , fNextPath    (Type::kPath)
                 , fNextStroke  (Type::kStroke)
+                , fNextShader  (Type::kShader)
                 , fNextXfermode(Type::kXfermode)
             {}
             void cleanup(Encoder*) override {}
 
             static bool Helper(ID* next, ID* id, LookupScope* ls) {
                 *id = ++(*next);
                 ls->undefineWhenDone(*id);
                 return false;
             }
 
             bool lookup(const SkMatrix&, ID* id, LookupScope* ls) override {
                 return Helper(&fNextMatrix, id, ls);
             }
             bool lookup(const Misc&, ID* id, LookupScope* ls) override {
                 return Helper(&fNextMisc, id, ls);
             }
             bool lookup(const SkPath&, ID* id, LookupScope* ls) override {
                 return Helper(&fNextPath, id, ls);
             }
             bool lookup(const Stroke&, ID* id, LookupScope* ls) override {
                 return Helper(&fNextStroke, id, ls);
             }
+            bool lookup(const SkShader* shader, ID* id, LookupScope* ls) override {
+                if (!shader) {
+                    *id = ID(Type::kShader);
+                    return true;  // Null IDs are always defined.
+                }
+                return Helper(&fNextShader, id, ls);
+            }
             bool lookup(const SkXfermode* xfermode, ID* id, LookupScope* ls) override {
                 if (!xfermode) {
                     *id = ID(Type::kXfermode);
                     return true;  // Null IDs are always defined.
                 }
                 return Helper(&fNextXfermode, id, ls);
             }
 
             ID fNextMatrix,
                fNextMisc,
                fNextPath,
                fNextStroke,
+               fNextShader,
                fNextXfermode;
         };
         return new NeverCache;
     }
 
     // These can't be declared locally inside AlwaysCache because of the templating.  :(
     namespace {
         template <typename T, typename Map>
         static bool always_cache_lookup(const T& val, Map* map, ID* next, ID* id) {
             if (const ID* found = map->find(val)) {
@@ skipping 42 matching lines @@
         };
     } // namespace
 
     Cache* Cache::CreateAlwaysCache() {
         struct AlwaysCache final : public Cache {
             AlwaysCache()
                 : fNextMatrix  (Type::kMatrix)
                 , fNextMisc    (Type::kMisc)
                 , fNextPath    (Type::kPath)
                 , fNextStroke  (Type::kStroke)
+                , fNextShader  (Type::kShader)
                 , fNextXfermode(Type::kXfermode)
             {}
 
             void cleanup(Encoder* encoder) override {
                 Undefiner undef{encoder};
                 fMatrix  .foreach(undef);
                 fMisc    .foreach(undef);
                 fPath    .foreach(undef);
                 fStroke  .foreach(undef);
+                fShader  .foreach(undef);
                 fXfermode.foreach(undef);
             }
 
 
             bool lookup(const SkMatrix& matrix, ID* id, LookupScope*) override {
                 return always_cache_lookup(matrix, &fMatrix, &fNextMatrix, id);
             }
             bool lookup(const Misc& misc, ID* id, LookupScope*) override {
                 return always_cache_lookup(misc, &fMisc, &fNextMisc, id);
             }
             bool lookup(const SkPath& path, ID* id, LookupScope*) override {
                 return always_cache_lookup(path, &fPath, &fNextPath, id);
             }
             bool lookup(const Stroke& stroke, ID* id, LookupScope*) override {
                 return always_cache_lookup(stroke, &fStroke, &fNextStroke, id);
             }
+            bool lookup(const SkShader* shader, ID* id, LookupScope*) override {
+                return always_cache_lookup(shader, &fShader, &fNextShader, id);
+            }
             bool lookup(const SkXfermode* xfermode, ID* id, LookupScope*) override {
                 return always_cache_lookup(xfermode, &fXfermode, &fNextXfermode, id);
             }
 
             SkTHashMap<SkMatrix, ID>               fMatrix;
             SkTHashMap<Misc,     ID, MiscHash>     fMisc;
             SkTHashMap<SkPath,   ID>               fPath;
             SkTHashMap<Stroke,   ID>               fStroke;
+            RefKeyMap<SkShader,   Type::kShader>   fShader;
             RefKeyMap<SkXfermode, Type::kXfermode> fXfermode;
 
             ID fNextMatrix,
                fNextMisc,
                fNextPath,
                fNextStroke,
+               fNextShader,
                fNextXfermode;
         };
         return new AlwaysCache;
     }
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
 
     Client::Client(Cache* cache, Encoder* encoder)
         : SkCanvas(1,1)
         , fCache(cache)
@@ skipping 37 matching lines @@
         SkPath path;
         path.addRRect(outside);
         path.addRRect(inside, SkPath::kCCW_Direction);
         this->onDrawPath(path, paint);
     }
 
     void Client::onDrawPath(const SkPath& path, const SkPaint& paint) {
         LookupScope ls(fCache, fEncoder);
         ID p = ls.lookup(path),
            m = ls.lookup(Misc::CreateFrom(paint)),
+           s = ls.lookup(paint.getShader()),
            x = ls.lookup(paint.getXfermode());
 
         if (paint.getStyle() == SkPaint::kFill_Style) {
-            fEncoder->fillPath(p, m, x);
+            fEncoder->fillPath(p, m, s, x);
         } else {
             // TODO: handle kStrokeAndFill_Style
-            fEncoder->strokePath(p, m, x, ls.lookup(Stroke::CreateFrom(paint)));
+            fEncoder->strokePath(p, m, s, x, ls.lookup(Stroke::CreateFrom(paint)));
         }
     }
 
     void Client::onDrawPaint(const SkPaint& paint) {
         SkPath path;
         path.setFillType(SkPath::kInverseWinding_FillType);  // Either inverse FillType works fine.
         this->onDrawPath(path, paint);
     }
 
     void Client::onDrawText(const void* text, size_t byteLength, SkScalar x,
@@ skipping 43 matching lines @@
     }
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
 
     Server::Server(SkCanvas* canvas) : fCanvas(canvas) {}
 
     void Server::define(ID id, const SkMatrix& v) { fMatrix  .set(id, v); }
     void Server::define(ID id, const Misc&     v) { fMisc    .set(id, v); }
     void Server::define(ID id, const SkPath&   v) { fPath    .set(id, v); }
     void Server::define(ID id, const Stroke&   v) { fStroke  .set(id, v); }
+    void Server::define(ID id, SkShader*       v) { fShader  .set(id, v); }
     void Server::define(ID id, SkXfermode*     v) { fXfermode.set(id, v); }
 
     void Server::undefine(ID id) {
         switch(id.type()) {
             case Type::kMatrix:   return fMatrix  .remove(id);
             case Type::kMisc:     return fMisc    .remove(id);
             case Type::kPath:     return fPath    .remove(id);
             case Type::kStroke:   return fStroke  .remove(id);
+            case Type::kShader:   return fShader  .remove(id);
             case Type::kXfermode: return fXfermode.remove(id);
 
             case Type::kNone: SkASSERT(false);
         };
     }
 
     void Server::   save() { fCanvas->save(); }
     void Server::restore() { fCanvas->restore(); }
 
     void Server::setMatrix(ID matrix) { fCanvas->setMatrix(fMatrix.find(matrix)); }
 
     void Server::clipPath(ID path, SkRegion::Op op, bool aa) {
         fCanvas->clipPath(fPath.find(path), op, aa);
     }
-    void Server::fillPath(ID path, ID misc, ID xfermode) {
+    void Server::fillPath(ID path, ID misc, ID shader, ID xfermode) {
         SkPaint paint;
         paint.setStyle(SkPaint::kFill_Style);
         fMisc.find(misc).applyTo(&paint);
+        paint.setShader  (fShader  .find(shader));
         paint.setXfermode(fXfermode.find(xfermode));
         fCanvas->drawPath(fPath.find(path), paint);
     }
-    void Server::strokePath(ID path, ID misc, ID xfermode, ID stroke) {
+    void Server::strokePath(ID path, ID misc, ID shader, ID xfermode, ID stroke) {
         SkPaint paint;
         paint.setStyle(SkPaint::kStroke_Style);
         fMisc  .find(misc  ).applyTo(&paint);
         fStroke.find(stroke).applyTo(&paint);
+        paint.setShader  (fShader  .find(shader));
         paint.setXfermode(fXfermode.find(xfermode));
         fCanvas->drawPath(fPath.find(path), paint);
     }
 
 } // namespace SkRemote