commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #ifndef sk_tool_utils_DEFINED |
| 9 | #define sk_tool_utils_DEFINED |
| 10 | |
halcanary | b0cce2c | 2015-01-26 12:49:00 -0800 | [diff] [blame] | 11 | #include "SkColor.h" |
Ben Wagner | 97182cc | 2018-02-15 10:20:04 -0500 | [diff] [blame] | 12 | #include "SkData.h" |
| 13 | #include "SkEncodedImageFormat.h" |
Mike Reed | 12a6d45 | 2018-12-21 22:22:31 -0500 | [diff] [blame] | 14 | #include "SkFont.h" |
Ben Wagner | 97182cc | 2018-02-15 10:20:04 -0500 | [diff] [blame] | 15 | #include "SkFontStyle.h" |
Mike Reed | 38810f3 | 2018-12-21 10:58:25 -0500 | [diff] [blame] | 16 | #include "SkFontTypes.h" |
robertphillips | 3e5c2b1 | 2015-03-23 05:46:51 -0700 | [diff] [blame] | 17 | #include "SkImageEncoder.h" |
tfarina | 2010891 | 2014-06-21 10:54:17 -0700 | [diff] [blame] | 18 | #include "SkImageInfo.h" |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 19 | #include "SkRandom.h" |
Ben Wagner | 97182cc | 2018-02-15 10:20:04 -0500 | [diff] [blame] | 20 | #include "SkRect.h" |
Robert Phillips | 4150eea | 2018-02-07 17:08:21 -0500 | [diff] [blame] | 21 | #include "SkRefCnt.h" |
Ben Wagner | 97182cc | 2018-02-15 10:20:04 -0500 | [diff] [blame] | 22 | #include "SkScalar.h" |
Hal Canary | 1fcc404 | 2016-11-30 17:07:59 -0500 | [diff] [blame] | 23 | #include "SkStream.h" |
Ben Wagner | 97182cc | 2018-02-15 10:20:04 -0500 | [diff] [blame] | 24 | #include "SkTArray.h" |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 25 | #include "SkTDArray.h" |
Mike Reed | 3185f90 | 2018-10-26 16:33:00 -0400 | [diff] [blame] | 26 | #include "SkTypeface.h" |
Ben Wagner | 97182cc | 2018-02-15 10:20:04 -0500 | [diff] [blame] | 27 | #include "SkTypes.h" |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 28 | |
Cary Clark | 992c7b0 | 2014-07-31 08:58:44 -0400 | [diff] [blame] | 29 | class SkBitmap; |
| 30 | class SkCanvas; |
Ben Wagner | 97182cc | 2018-02-15 10:20:04 -0500 | [diff] [blame] | 31 | class SkFontStyle; |
Mike Reed | 2484660 | 2017-12-04 16:06:03 -0500 | [diff] [blame] | 32 | class SkImage; |
Cary Clark | 992c7b0 | 2014-07-31 08:58:44 -0400 | [diff] [blame] | 33 | class SkPaint; |
joshualitt | 98d2e2f | 2015-10-05 07:23:30 -0700 | [diff] [blame] | 34 | class SkPath; |
Ben Wagner | 97182cc | 2018-02-15 10:20:04 -0500 | [diff] [blame] | 35 | class SkPixmap; |
robertphillips | 276d328 | 2016-08-04 09:03:19 -0700 | [diff] [blame] | 36 | class SkRRect; |
halcanary | b0cce2c | 2015-01-26 12:49:00 -0800 | [diff] [blame] | 37 | class SkShader; |
Mike Reed | 46596ae | 2018-01-02 15:40:29 -0500 | [diff] [blame] | 38 | class SkSurface; |
| 39 | class SkSurfaceProps; |
joshualitt | 9e36c1a | 2015-04-14 12:17:27 -0700 | [diff] [blame] | 40 | class SkTextBlobBuilder; |
Ben Wagner | 97182cc | 2018-02-15 10:20:04 -0500 | [diff] [blame] | 41 | class SkTypeface; |
skia.committer@gmail.com | db0c875 | 2014-03-18 03:02:11 +0000 | [diff] [blame] | 42 | |
Cary Clark | 992c7b0 | 2014-07-31 08:58:44 -0400 | [diff] [blame] | 43 | namespace sk_tool_utils { |
caryclark | 5fb6bd4 | 2014-06-23 11:25:00 -0700 | [diff] [blame] | 44 | |
Mike Reed | d474698 | 2018-02-07 16:05:29 -0500 | [diff] [blame] | 45 | const char* alphatype_name(SkAlphaType); |
commit-bot@chromium.org | a713f9c | 2014-03-17 21:31:26 +0000 | [diff] [blame] | 46 | const char* colortype_name(SkColorType); |
caryclark | 3721355 | 2015-07-24 11:08:01 -0700 | [diff] [blame] | 47 | |
| 48 | /** |
| 49 | * Map opaque colors from 8888 to 565. |
| 50 | */ |
caryclark | 65cdba6 | 2015-06-15 06:51:08 -0700 | [diff] [blame] | 51 | SkColor color_to_565(SkColor color); |
caryclark | 3721355 | 2015-07-24 11:08:01 -0700 | [diff] [blame] | 52 | |
| 53 | /** |
| 54 | * Return a color emoji typeface if available. |
| 55 | */ |
bungeman | 13b9c95 | 2016-05-12 10:09:30 -0700 | [diff] [blame] | 56 | sk_sp<SkTypeface> emoji_typeface(); |
caryclark | 3721355 | 2015-07-24 11:08:01 -0700 | [diff] [blame] | 57 | |
| 58 | /** |
| 59 | * If the platform supports color emoji, return sample text the emoji can render. |
| 60 | */ |
caryclark | c3dcb67 | 2015-07-21 12:27:36 -0700 | [diff] [blame] | 61 | const char* emoji_sample_text(); |
caryclark | 3721355 | 2015-07-24 11:08:01 -0700 | [diff] [blame] | 62 | |
| 63 | /** |
Mike Klein | b251b72 | 2017-11-13 11:03:16 -0500 | [diff] [blame] | 64 | * Returns a string describing the platform font manager, if we're using one, otherwise "". |
caryclark | 3721355 | 2015-07-24 11:08:01 -0700 | [diff] [blame] | 65 | */ |
Mike Klein | b251b72 | 2017-11-13 11:03:16 -0500 | [diff] [blame] | 66 | const char* platform_font_manager(); |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 67 | |
| 68 | /** |
caryclark | 1818acb | 2015-07-24 12:09:25 -0700 | [diff] [blame] | 69 | * Sets the paint to use a platform-independent text renderer |
caryclark | 5fb6bd4 | 2014-06-23 11:25:00 -0700 | [diff] [blame] | 70 | */ |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 71 | void set_portable_typeface(SkPaint* paint, const char* name = nullptr, |
mboc | ee6a991 | 2016-05-31 11:42:36 -0700 | [diff] [blame] | 72 | SkFontStyle style = SkFontStyle()); |
caryclark | 3721355 | 2015-07-24 11:08:01 -0700 | [diff] [blame] | 73 | |
| 74 | /** |
caryclark | 3721355 | 2015-07-24 11:08:01 -0700 | [diff] [blame] | 75 | * Returns a platform-independent text renderer. |
| 76 | */ |
mboc | ee6a991 | 2016-05-31 11:42:36 -0700 | [diff] [blame] | 77 | sk_sp<SkTypeface> create_portable_typeface(const char* name, SkFontStyle style); |
caryclark | 3721355 | 2015-07-24 11:08:01 -0700 | [diff] [blame] | 78 | |
Mike Reed | 3185f90 | 2018-10-26 16:33:00 -0400 | [diff] [blame] | 79 | static inline sk_sp<SkTypeface> create_portable_typeface() { |
| 80 | return create_portable_typeface(nullptr, SkFontStyle()); |
| 81 | } |
| 82 | |
Mike Reed | 38810f3 | 2018-12-21 10:58:25 -0500 | [diff] [blame] | 83 | void get_text_path(const SkFont&, const void* text, size_t length, SkTextEncoding, SkPath*, |
| 84 | const SkPoint* positions = nullptr); |
| 85 | |
caryclark | 5fb6bd4 | 2014-06-23 11:25:00 -0700 | [diff] [blame] | 86 | /** |
Mike Reed | 4c790bd | 2018-02-08 14:10:40 -0500 | [diff] [blame] | 87 | * Call writePixels() by using the pixels from bitmap, but with an info that claims |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 88 | * the pixels are colorType + alphaType |
| 89 | */ |
| 90 | void write_pixels(SkCanvas*, const SkBitmap&, int x, int y, SkColorType, SkAlphaType); |
Mike Reed | 4c790bd | 2018-02-08 14:10:40 -0500 | [diff] [blame] | 91 | void write_pixels(SkSurface*, const SkBitmap&, int x, int y, SkColorType, SkAlphaType); |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 92 | |
Mike Reed | 5a625e0 | 2017-08-08 15:48:54 -0400 | [diff] [blame] | 93 | /** |
Brian Osman | 1b15198 | 2018-09-20 12:47:39 -0400 | [diff] [blame] | 94 | * Returns true iff all of the pixels between the two images are identical. |
Mike Reed | 5a625e0 | 2017-08-08 15:48:54 -0400 | [diff] [blame] | 95 | * |
| 96 | * If the configs differ, return false. |
Mike Reed | 5a625e0 | 2017-08-08 15:48:54 -0400 | [diff] [blame] | 97 | */ |
Brian Osman | 1b15198 | 2018-09-20 12:47:39 -0400 | [diff] [blame] | 98 | bool equal_pixels(const SkPixmap&, const SkPixmap&); |
| 99 | bool equal_pixels(const SkBitmap&, const SkBitmap&); |
| 100 | bool equal_pixels(const SkImage* a, const SkImage* b); |
Mike Reed | 5a625e0 | 2017-08-08 15:48:54 -0400 | [diff] [blame] | 101 | |
halcanary | b0cce2c | 2015-01-26 12:49:00 -0800 | [diff] [blame] | 102 | /** Returns a newly created CheckerboardShader. */ |
reed | 8a21c9f | 2016-03-08 18:50:00 -0800 | [diff] [blame] | 103 | sk_sp<SkShader> create_checkerboard_shader(SkColor c1, SkColor c2, int size); |
halcanary | b0cce2c | 2015-01-26 12:49:00 -0800 | [diff] [blame] | 104 | |
| 105 | /** Draw a checkerboard pattern in the current canvas, restricted to |
halcanary | f77365f | 2015-01-27 08:38:35 -0800 | [diff] [blame] | 106 | the current clip, using SkXfermode::kSrc_Mode. */ |
halcanary | b0cce2c | 2015-01-26 12:49:00 -0800 | [diff] [blame] | 107 | void draw_checkerboard(SkCanvas* canvas, |
| 108 | SkColor color1, |
| 109 | SkColor color2, |
robertphillips | 943a462 | 2015-09-03 13:32:33 -0700 | [diff] [blame] | 110 | int checkSize); |
| 111 | |
| 112 | /** Make it easier to create a bitmap-based checkerboard */ |
| 113 | SkBitmap create_checkerboard_bitmap(int w, int h, |
| 114 | SkColor c1, SkColor c2, |
| 115 | int checkSize); |
halcanary | b0cce2c | 2015-01-26 12:49:00 -0800 | [diff] [blame] | 116 | |
| 117 | /** A default checkerboard. */ |
| 118 | inline void draw_checkerboard(SkCanvas* canvas) { |
| 119 | sk_tool_utils::draw_checkerboard(canvas, 0xFF999999, 0xFF666666, 8); |
| 120 | } |
| 121 | |
robertphillips | 943a462 | 2015-09-03 13:32:33 -0700 | [diff] [blame] | 122 | SkBitmap create_string_bitmap(int w, int h, SkColor c, int x, int y, |
| 123 | int textSize, const char* str); |
| 124 | |
Cary Clark | a24712e | 2018-09-05 18:41:40 +0000 | [diff] [blame] | 125 | // If the canvas does't make a surface (e.g. recording), make a raster surface |
| 126 | sk_sp<SkSurface> makeSurface(SkCanvas*, const SkImageInfo&, const SkSurfaceProps* = nullptr); |
| 127 | |
joshualitt | 9e36c1a | 2015-04-14 12:17:27 -0700 | [diff] [blame] | 128 | // A helper for inserting a drawtext call into a SkTextBlobBuilder |
Mike Reed | 12a6d45 | 2018-12-21 22:22:31 -0500 | [diff] [blame] | 129 | void add_to_text_blob_w_len(SkTextBlobBuilder*, const char* text, size_t len, SkTextEncoding, |
| 130 | const SkFont&, SkScalar x, SkScalar y); |
Robert Phillips | 4c72b26 | 2017-08-15 13:28:42 -0400 | [diff] [blame] | 131 | |
Mike Reed | 12a6d45 | 2018-12-21 22:22:31 -0500 | [diff] [blame] | 132 | void add_to_text_blob(SkTextBlobBuilder*, const char* text, const SkFont&, |
| 133 | SkScalar x, SkScalar y); |
| 134 | |
Chris Dalton | 7c02cc7 | 2017-11-06 14:10:54 -0700 | [diff] [blame] | 135 | // Constructs a star by walking a 'numPts'-sided regular polygon with even/odd fill: |
| 136 | // |
| 137 | // moveTo(pts[0]); |
| 138 | // lineTo(pts[step % numPts]); |
| 139 | // ... |
| 140 | // lineTo(pts[(step * (N - 1)) % numPts]); |
| 141 | // |
| 142 | // numPts=5, step=2 will produce a classic five-point star. |
| 143 | // |
| 144 | // numPts and step must be co-prime. |
| 145 | SkPath make_star(const SkRect& bounds, int numPts = 5, int step = 2); |
| 146 | |
Robert Phillips | a8cdbd7 | 2018-07-17 12:30:40 -0400 | [diff] [blame] | 147 | void create_hemi_normal_map(SkBitmap* bm, const SkIRect& dst); |
| 148 | |
| 149 | void create_frustum_normal_map(SkBitmap* bm, const SkIRect& dst); |
| 150 | |
| 151 | void create_tetra_normal_map(SkBitmap* bm, const SkIRect& dst); |
| 152 | |
joshualitt | 98d2e2f | 2015-10-05 07:23:30 -0700 | [diff] [blame] | 153 | void make_big_path(SkPath& path); |
robertphillips | 9c4909b | 2015-10-19 06:39:17 -0700 | [diff] [blame] | 154 | |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 155 | // A helper object to test the topological sorting code (TopoSortBench.cpp & TopoSortTest.cpp) |
Robert Phillips | 4150eea | 2018-02-07 17:08:21 -0500 | [diff] [blame] | 156 | class TopoTestNode : public SkRefCnt { |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 157 | public: |
| 158 | TopoTestNode(int id) : fID(id), fOutputPos(-1), fTempMark(false) { } |
| 159 | |
| 160 | void dependsOn(TopoTestNode* src) { |
| 161 | *fDependencies.append() = src; |
| 162 | } |
| 163 | |
| 164 | int id() const { return fID; } |
| 165 | void reset() { fOutputPos = -1; } |
| 166 | |
| 167 | int outputPos() const { return fOutputPos; } |
| 168 | |
| 169 | // check that the topological sort is valid for this node |
| 170 | bool check() { |
| 171 | if (-1 == fOutputPos) { |
| 172 | return false; |
| 173 | } |
| 174 | |
| 175 | for (int i = 0; i < fDependencies.count(); ++i) { |
| 176 | if (-1 == fDependencies[i]->outputPos()) { |
| 177 | return false; |
| 178 | } |
| 179 | // This node should've been output after all the nodes on which it depends |
| 180 | if (fOutputPos < fDependencies[i]->outputPos()) { |
| 181 | return false; |
| 182 | } |
| 183 | } |
| 184 | |
| 185 | return true; |
| 186 | } |
| 187 | |
| 188 | // The following 7 methods are needed by the topological sort |
| 189 | static void SetTempMark(TopoTestNode* node) { node->fTempMark = true; } |
| 190 | static void ResetTempMark(TopoTestNode* node) { node->fTempMark = false; } |
| 191 | static bool IsTempMarked(TopoTestNode* node) { return node->fTempMark; } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 192 | static void Output(TopoTestNode* node, int outputPos) { |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 193 | SkASSERT(-1 != outputPos); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 194 | node->fOutputPos = outputPos; |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 195 | } |
| 196 | static bool WasOutput(TopoTestNode* node) { return (-1 != node->fOutputPos); } |
| 197 | static int NumDependencies(TopoTestNode* node) { return node->fDependencies.count(); } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 198 | static TopoTestNode* Dependency(TopoTestNode* node, int index) { |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 199 | return node->fDependencies[index]; |
| 200 | } |
| 201 | |
| 202 | // Helper functions for TopoSortBench & TopoSortTest |
Robert Phillips | 4150eea | 2018-02-07 17:08:21 -0500 | [diff] [blame] | 203 | static void AllocNodes(SkTArray<sk_sp<sk_tool_utils::TopoTestNode>>* graph, int num) { |
| 204 | graph->reserve(num); |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 205 | |
| 206 | for (int i = 0; i < num; ++i) { |
Robert Phillips | 4150eea | 2018-02-07 17:08:21 -0500 | [diff] [blame] | 207 | graph->push_back(sk_sp<TopoTestNode>(new TopoTestNode(i))); |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 208 | } |
| 209 | } |
| 210 | |
Robert Phillips | 4150eea | 2018-02-07 17:08:21 -0500 | [diff] [blame] | 211 | #ifdef SK_DEBUG |
| 212 | static void Print(const SkTArray<TopoTestNode*>& graph) { |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 213 | for (int i = 0; i < graph.count(); ++i) { |
| 214 | SkDebugf("%d, ", graph[i]->id()); |
| 215 | } |
| 216 | SkDebugf("\n"); |
| 217 | } |
Robert Phillips | 4150eea | 2018-02-07 17:08:21 -0500 | [diff] [blame] | 218 | #endif |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 219 | |
| 220 | // randomize the array |
Robert Phillips | 4150eea | 2018-02-07 17:08:21 -0500 | [diff] [blame] | 221 | static void Shuffle(SkTArray<sk_sp<TopoTestNode>>* graph, SkRandom* rand) { |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 222 | for (int i = graph->count()-1; i > 0; --i) { |
| 223 | int swap = rand->nextU() % (i+1); |
| 224 | |
Robert Phillips | 4150eea | 2018-02-07 17:08:21 -0500 | [diff] [blame] | 225 | (*graph)[i].swap((*graph)[swap]); |
robertphillips | 423f646 | 2015-10-19 12:15:55 -0700 | [diff] [blame] | 226 | } |
| 227 | } |
| 228 | |
| 229 | private: |
| 230 | int fID; |
| 231 | int fOutputPos; |
| 232 | bool fTempMark; |
| 233 | |
| 234 | SkTDArray<TopoTestNode*> fDependencies; |
| 235 | }; |
| 236 | |
Hal Canary | db68301 | 2016-11-23 08:55:18 -0700 | [diff] [blame] | 237 | template <typename T> |
| 238 | inline bool EncodeImageToFile(const char* path, const T& src, SkEncodedImageFormat f, int q) { |
| 239 | SkFILEWStream file(path); |
| 240 | return file.isValid() && SkEncodeImage(&file, src, f, q); |
| 241 | } |
| 242 | |
Matt Sarett | 68b8e3d | 2017-04-28 11:15:22 -0400 | [diff] [blame] | 243 | bool copy_to(SkBitmap* dst, SkColorType dstCT, const SkBitmap& src); |
Matt Sarett | 4897fb8 | 2017-01-18 11:49:33 -0500 | [diff] [blame] | 244 | void copy_to_g8(SkBitmap* dst, const SkBitmap& src); |
tfarina | 2010891 | 2014-06-21 10:54:17 -0700 | [diff] [blame] | 245 | } // namespace sk_tool_utils |
| 246 | |
| 247 | #endif // sk_tool_utils_DEFINED |