add SkCanvas::drawAtlas

src/core/SkRecords.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 SkRecords_DEFINED
 #define SkRecords_DEFINED
 
 #include "SkCanvas.h"
 #include "SkDrawable.h"
 #include "SkPathPriv.h"
 #include "SkPicture.h"
+#include "SkRSXform.h"
 #include "SkTextBlob.h"
 
 namespace SkRecords {
 
 // A list of all the types of canvas calls we can record.
 // Each of these is reified into a struct below.
 //
 // (We're using the macro-of-macro trick here to do several different things with the same list.)
 //
 // We leave this SK_RECORD_TYPES macro defined for use by code that wants to operate on SkRecords
@@ skipping 26 matching lines @@
     M(DrawPicture)                                                  \
     M(DrawPoints)                                                   \
     M(DrawPosText)                                                  \
     M(DrawPosTextH)                                                 \
     M(DrawText)                                                     \
     M(DrawTextOnPath)                                               \
     M(DrawRRect)                                                    \
     M(DrawRect)                                                     \
     M(DrawSprite)                                                   \
     M(DrawTextBlob)                                                 \
+    M(DrawAtlas)                                                    \
     M(DrawVertices)
 
 // Defines SkRecords::Type, an enum of all record types.
 #define ENUM(T) T##_Type,
 enum Type { SK_RECORD_TYPES(ENUM) };
 #undef ENUM
 
 // Macros to make it easier to define a record for a draw call with 0 args, 1 args, 2 args, etc.
 // These should be clearer when you look at their use below.
 #define RECORD0(T)                      \
@@ skipping 43 matching lines @@
 
 #define RECORD5(T, A, a, B, b, C, c, D, d, E, e)                          \
 struct T {                                                                \
     static const Type kType = T##_Type;                                   \
     T() {}                                                                \
     template <typename Z, typename Y, typename X, typename W, typename V> \
     T(Z a, Y b, X c, W d, V e) : a(a), b(b), c(c), d(d), e(e) {}          \
     A a; B b; C c; D d; E e;                                              \
 };
 
+#define RECORD8(T, A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h)        \
+struct T {                                                                \
+    static const Type kType = T##_Type;                                   \
+    T() {}                                                                \
+    template <typename Z, typename Y, typename X, typename W, typename V, typename U, typename S, typename R> \
+    T(Z a, Y b, X c, W d, V e, U f, S g, R h) : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {} \
+    A a; B b; C c; D d; E e; F f; G g; H h;                               \
+};
+    
 #define ACT_AS_PTR(ptr)                 \
     operator T*() const { return ptr; } \
     T* operator->() const { return ptr; }
 
 template <typename T>
 class RefBox : SkNoncopyable {
 public:
     RefBox() {}
     RefBox(T* obj) : fObj(SkSafeRef(obj)) {}
     ~RefBox() { SkSafeUnref(fObj); }
@@ skipping 176 matching lines @@
                         size_t, byteLength,
                         PreCachedPath, path,
                         TypedMatrix, matrix);
 
 RECORD5(DrawPatch, SkPaint, paint,
                    PODArray<SkPoint>, cubics,
                    PODArray<SkColor>, colors,
                    PODArray<SkPoint>, texCoords,
                    RefBox<SkXfermode>, xmode);
 
+RECORD8(DrawAtlas,  Optional<SkPaint>, paint,
+                    RefBox<const SkImage>, atlas,
+                    PODArray<SkRSXform>, xforms,
+                    PODArray<SkRect>, texs,
+                    PODArray<SkColor>, colors,
+                    int, count,
+                    SkXfermode::Mode, mode,
+                    Optional<SkRect>, cull);
+
 // This guy is so ugly we just write it manually.
 struct DrawVertices {
     static const Type kType = DrawVertices_Type;
 
     DrawVertices(const SkPaint& paint,
                  SkCanvas::VertexMode vmode,
                  int vertexCount,
                  SkPoint* vertices,
                  SkPoint* texs,
                  SkColor* colors,
@@ skipping 20 matching lines @@
     PODArray<uint16_t> indices;
     int indexCount;
 };
 
 #undef RECORD0
 #undef RECORD1
 #undef RECORD2
 #undef RECORD3
 #undef RECORD4
 #undef RECORD5
+#undef RECORD8
 
 }  // namespace SkRecords
 
 #endif//SkRecords_DEFINED