Refugee from Dead Machine 11: Add SkCanvas::drawLitAtlas call

include/private/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 "SkLight.h"
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkPicture.h"
+#include "SkPoint3.h"
 #include "SkRect.h"
 #include "SkRRect.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.
 //
@@ skipping 32 matching lines @@
     M(DrawPoints)                                                   \
     M(DrawPosText)                                                  \
     M(DrawPosTextH)                                                 \
     M(DrawText)                                                     \
     M(DrawTextOnPath)                                               \
     M(DrawRRect)                                                    \
     M(DrawRect)                                                     \
     M(DrawSprite)                                                   \
     M(DrawTextBlob)                                                 \
     M(DrawAtlas)                                                    \
+    M(DrawLitAtlas)                                                 \
     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 55 matching lines @@
     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(const Z& a, const Y& b, const X& c, const W& d,              \
       const V& e, const U& f, const S& g, const 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 RECORDB(T, A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, I, i, J, j, K, k) \
+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,      \
+              typename Q, typename P, typename O>                  \
+    T(const Z& a, const Y& b, const X& c, const W& d,              \
+      const V& e, const U& f, const S& g, const R& h,              \
+      const Q& i, const P& j, const O& k)                          \
+        : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h), i(i), j(j), k(k) {}  \
+    A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; K k;         \
+};
+
 #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 180 matching lines @@
 
 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);
 
+RECORDB(DrawLitAtlas,  Optional<SkPaint>, paint,
+                       RefBox<const SkImage>, atlas,
+                       PODArray<SkRSXform>, xforms,
+                       PODArray<SkRect>, diffTexs,
+                       PODArray<SkRect>, normTexs,
+                       PODArray<SkColor>, colors,
+                       int, count,
+                       SkXfermode::Mode, mode,
+                       Optional<SkRect>, cull,
+                       PODArray<SkLight>, lights,
+                       int, numLights);
+
 // 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 25 matching lines @@
 #undef RECORD1
 #undef RECORD2
 #undef RECORD3
 #undef RECORD4
 #undef RECORD5
 #undef RECORD8
 
 }  // namespace SkRecords
 
 #endif//SkRecords_DEFINED