SkRemote: shaders

src/core/SkRemote.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRemote_DEFINED
 #define SkRemote_DEFINED
 
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkRemote_protocol.h"
+#include "SkShader.h"
 #include "SkTHash.h"
 #include "SkTypes.h"
 
 // TODO: document
 
 namespace SkRemote {
     // TODO: document
     struct Misc {
         SkColor         fColor;
         SkFilterQuality fFilterQuality;
@@ skipping 14 matching lines @@
     };
 
     // TODO: document
     struct Encoder {
         virtual ~Encoder() {}
 
         virtual void define(ID, const SkMatrix&) = 0;
         virtual void define(ID, const Misc&)     = 0;
         virtual void define(ID, const SkPath&)   = 0;
         virtual void define(ID, const Stroke&)   = 0;
+        virtual void define(ID, SkShader*)       = 0;
         virtual void define(ID, SkXfermode*)     = 0;
 
         virtual void undefine(ID) = 0;
 
         virtual void    save() = 0;
         virtual void restore() = 0;
 
         virtual void setMatrix(ID matrix) = 0;
 
-        // TODO: struct CommonIDs { ID misc; ID xfermode; ... }
+        // TODO: struct CommonIDs { ID misc, shader, xfermode; ... }
         // for IDs that affect both fill + stroke?
 
-        virtual void   clipPath(ID path, SkRegion::Op, bool aa)           = 0;
-        virtual void   fillPath(ID path, ID misc, ID xfermode)            = 0;
-        virtual void strokePath(ID path, ID misc, ID xfermode, ID stroke) = 0;
+        virtual void   clipPath(ID path, SkRegion::Op, bool aa)                      = 0;
+        virtual void   fillPath(ID path, ID misc, ID shader, ID xfermode)            = 0;
+        virtual void strokePath(ID path, ID misc, ID shader, ID xfermode, ID stroke) = 0;
     };
 
     class LookupScope;
 
     // The Cache interface encapsulates the caching logic of the Client.
     //
     // Each lookup() method must always fill ID* with a valid value,
     // but ID may be cached.  If so, the lookup() method returns true;
     // if not the lookup() method returns false and the Client must
     // then define() this ID -> Thing mapping before using the ID.
     //
     // The Caches may also add IDs to the LookupScope's list of IDs to
     // undefine() on destruction.  This lets the Cache purge IDs.
     struct Cache {
         virtual ~Cache() {}
 
         static Cache* CreateNeverCache();   // Never caches anything.
         static Cache* CreateAlwaysCache();  // Caches by value (not deep pointer equality).
         // TODO: static Cache* CreateDeepCache();  // Caches by deep value.
 
         virtual bool lookup(const SkMatrix&,   ID*, LookupScope*) = 0;
         virtual bool lookup(const Misc&,       ID*, LookupScope*) = 0;
         virtual bool lookup(const SkPath&,     ID*, LookupScope*) = 0;
         virtual bool lookup(const Stroke&,     ID*, LookupScope*) = 0;
+        virtual bool lookup(const SkShader*,   ID*, LookupScope*) = 0;
         virtual bool lookup(const SkXfermode*, ID*, LookupScope*) = 0;
 
         virtual void cleanup(Encoder*) = 0;
     };
 
     // TODO: document
     class Client final : public SkCanvas {
     public:
         Client(Cache*, Encoder*);
         ~Client();
@@ skipping 30 matching lines @@
     // TODO: document
     class Server final : public Encoder {
     public:
         explicit Server(SkCanvas*);
 
     private:
         void define(ID, const SkMatrix&) override;
         void define(ID, const Misc&)     override;
         void define(ID, const SkPath&)   override;
         void define(ID, const Stroke&)   override;
+        void define(ID, SkShader*)       override;
         void define(ID, SkXfermode*)     override;
 
         void undefine(ID) override;
 
         void    save() override;
         void restore() override;
 
         void setMatrix(ID matrix) override;
 
-        void   clipPath(ID path, SkRegion::Op, bool aa)           override;
-        void   fillPath(ID path, ID misc, ID xfermode)            override;
-        void strokePath(ID path, ID misc, ID xfermode, ID stroke) override;
+        void   clipPath(ID path, SkRegion::Op, bool aa)                      override;
+        void   fillPath(ID path, ID misc, ID shader, ID xfermode)            override;
+        void strokePath(ID path, ID misc, ID shader, ID xfermode, ID stroke) override;
 
         // Maps ID -> T.
         template <typename T, Type kType>
         class IDMap {
         public:
             ~IDMap() {
                 // A well-behaved client always cleans up its definitions.
                 SkASSERT(fMap.count() == 0);
             }
 
@@ skipping 52 matching lines @@
             }
 
         private:
             SkTHashMap<ID, T*> fMap;
         };
 
         IDMap<SkMatrix, Type::kMatrix>           fMatrix;
         IDMap<Misc    , Type::kMisc  >           fMisc;
         IDMap<SkPath  , Type::kPath  >           fPath;
         IDMap<Stroke  , Type::kStroke>           fStroke;
+        ReffedIDMap<SkShader,   Type::kShader>   fShader;
         ReffedIDMap<SkXfermode, Type::kXfermode> fXfermode;
 
         SkCanvas* fCanvas;
     };
 
 }  // namespace SkRemote
 
 #endif//SkRemote_DEFINED