1 #ifndef SkPictureFlat_DEFINED 2 #define SkPictureFlat_DEFINED 3 4 #include "SkChunkAlloc.h" 5 #include "SkBitmap.h" 6 #include "SkPicture.h" 7 #include "SkMatrix.h" 8 #include "SkPaint.h" 9 #include "SkPath.h" 10 #include "SkRegion.h" 11 12 enum DrawType { 13 UNUSED, 14 CLIP_PATH, 15 CLIP_REGION, 16 CLIP_RECT, 17 CONCAT, 18 DRAW_BITMAP, 19 DRAW_BITMAP_MATRIX, 20 DRAW_BITMAP_RECT, 21 DRAW_CLEAR, 22 DRAW_DATA, 23 DRAW_PAINT, 24 DRAW_PATH, 25 DRAW_PICTURE, 26 DRAW_POINTS, 27 DRAW_POS_TEXT, 28 DRAW_POS_TEXT_TOP_BOTTOM, // fast variant of DRAW_POS_TEXT 29 DRAW_POS_TEXT_H, 30 DRAW_POS_TEXT_H_TOP_BOTTOM, // fast variant of DRAW_POS_TEXT_H 31 DRAW_RECT, 32 DRAW_SHAPE, 33 DRAW_SPRITE, 34 DRAW_TEXT, 35 DRAW_TEXT_ON_PATH, 36 DRAW_TEXT_TOP_BOTTOM, // fast variant of DRAW_TEXT 37 DRAW_VERTICES, 38 RESTORE, 39 ROTATE, 40 SAVE, 41 SAVE_LAYER, 42 SCALE, 43 SET_MATRIX, 44 SKEW, 45 TRANSLATE 46 }; 47 48 enum DrawVertexFlags { 49 DRAW_VERTICES_HAS_TEXS = 0x01, 50 DRAW_VERTICES_HAS_COLORS = 0x02, 51 DRAW_VERTICES_HAS_INDICES = 0x04 52 }; 53 54 class SkRefCntPlayback { 55 public: 56 SkRefCntPlayback(); 57 virtual ~SkRefCntPlayback(); 58 59 int count() const { return fCount; } 60 61 void reset(const SkRefCntSet*); 62 63 void setCount(int count); 64 SkRefCnt* set(int index, SkRefCnt*); 65 66 virtual void setupBuffer(SkFlattenableReadBuffer& buffer) const { 67 buffer.setRefCntArray(fArray, fCount); 68 } 69 70 protected: 71 int fCount; 72 SkRefCnt** fArray; 73 }; 74 75 class SkTypefacePlayback : public SkRefCntPlayback { 76 public: 77 virtual void setupBuffer(SkFlattenableReadBuffer& buffer) const { 78 buffer.setTypefaceArray((SkTypeface**)fArray, fCount); 79 } 80 }; 81 82 class SkFactoryPlayback { 83 public: 84 SkFactoryPlayback(int count) : fCount(count) { 85 fArray = SkNEW_ARRAY(SkFlattenable::Factory, count); 86 } 87 88 ~SkFactoryPlayback() { 89 SkDELETE_ARRAY(fArray); 90 } 91 92 SkFlattenable::Factory* base() const { return fArray; } 93 94 void setupBuffer(SkFlattenableReadBuffer& buffer) const { 95 buffer.setFactoryPlayback(fArray, fCount); 96 } 97 98 private: 99 int fCount; 100 SkFlattenable::Factory* fArray; 101 }; 102 103 class SkFlatData { 104 public: 105 static int Compare(const SkFlatData* a, const SkFlatData* b) { 106 return memcmp(&a->fAllocSize, &b->fAllocSize, a->fAllocSize); 107 } 108 109 int index() const { return fIndex; } 110 111 #ifdef SK_DEBUG_SIZE 112 size_t size() const { return sizeof(fIndex) + fAllocSize; } 113 #endif 114 115 protected: 116 static SkFlatData* Alloc(SkChunkAlloc* heap, int32_t size, int index); 117 118 int fIndex; 119 int32_t fAllocSize; 120 }; 121 122 class SkFlatBitmap : public SkFlatData { 123 public: 124 static SkFlatBitmap* Flatten(SkChunkAlloc*, const SkBitmap&, int index, 125 SkRefCntSet*); 126 127 void unflatten(SkBitmap* bitmap, SkRefCntPlayback* rcp) const { 128 SkFlattenableReadBuffer buffer(fBitmapData); 129 if (rcp) { 130 rcp->setupBuffer(buffer); 131 } 132 bitmap->unflatten(buffer); 133 } 134 135 #ifdef SK_DEBUG_VALIDATE 136 void validate() const { 137 // to be written 138 } 139 #endif 140 141 private: 142 char fBitmapData[1]; 143 typedef SkFlatData INHERITED; 144 }; 145 146 class SkFlatMatrix : public SkFlatData { 147 public: 148 static SkFlatMatrix* Flatten(SkChunkAlloc* heap, const SkMatrix& matrix, int index); 149 150 void unflatten(SkMatrix* result) const { 151 result->unflatten(fMatrixData); 152 } 153 154 #ifdef SK_DEBUG_DUMP 155 void dump() const; 156 #endif 157 158 #ifdef SK_DEBUG_VALIDATE 159 void validate() const { 160 // to be written 161 } 162 #endif 163 164 private: 165 char fMatrixData[1]; 166 typedef SkFlatData INHERITED; 167 }; 168 169 class SkFlatPaint : public SkFlatData { 170 public: 171 static SkFlatPaint* Flatten(SkChunkAlloc* heap, const SkPaint& paint, 172 int index, SkRefCntSet*, 173 SkRefCntSet* faceRecorder); 174 175 void unflatten(SkPaint* result, SkRefCntPlayback* rcp, 176 SkTypefacePlayback* facePlayback) const { 177 Read(fPaintData, result, rcp, facePlayback); 178 } 179 180 static void Read(const void* storage, SkPaint* paint, SkRefCntPlayback*, 181 SkTypefacePlayback* facePlayback); 182 183 #ifdef SK_DEBUG_DUMP 184 void dump() const; 185 #endif 186 187 private: 188 char fPaintData[1]; 189 typedef SkFlatData INHERITED; 190 }; 191 192 class SkFlatRegion : public SkFlatData { 193 public: 194 static SkFlatRegion* Flatten(SkChunkAlloc* heap, const SkRegion& region, int index); 195 196 void unflatten(SkRegion* result) const { 197 result->unflatten(fRegionData); 198 } 199 200 #ifdef SK_DEBUG_VALIDATE 201 void validate() const { 202 // to be written 203 } 204 #endif 205 206 private: 207 char fRegionData[1]; 208 typedef SkFlatData INHERITED; 209 }; 210 211 #endif 212