SkPaint.cpp 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600
  1. /*
  2. * Copyright 2006 The Android Open Source Project
  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. #include "include/core/SkPaint.h"
  8. #include "include/core/SkColorFilter.h"
  9. #include "include/core/SkData.h"
  10. #include "include/core/SkGraphics.h"
  11. #include "include/core/SkImageFilter.h"
  12. #include "include/core/SkMaskFilter.h"
  13. #include "include/core/SkPathEffect.h"
  14. #include "include/core/SkScalar.h"
  15. #include "include/core/SkShader.h"
  16. #include "include/core/SkStrokeRec.h"
  17. #include "include/core/SkTypeface.h"
  18. #include "include/private/SkMutex.h"
  19. #include "include/private/SkTo.h"
  20. #include "src/core/SkColorSpacePriv.h"
  21. #include "src/core/SkColorSpaceXformSteps.h"
  22. #include "src/core/SkDraw.h"
  23. #include "src/core/SkMaskGamma.h"
  24. #include "src/core/SkOpts.h"
  25. #include "src/core/SkPaintDefaults.h"
  26. #include "src/core/SkPaintPriv.h"
  27. #include "src/core/SkReadBuffer.h"
  28. #include "src/core/SkSafeRange.h"
  29. #include "src/core/SkStringUtils.h"
  30. #include "src/core/SkStroke.h"
  31. #include "src/core/SkSurfacePriv.h"
  32. #include "src/core/SkTLazy.h"
  33. #include "src/core/SkWriteBuffer.h"
  34. #include "src/shaders/SkShaderBase.h"
  35. // define this to get a printf for out-of-range parameter in setters
  36. // e.g. setTextSize(-1)
  37. //#define SK_REPORT_API_RANGE_CHECK
  38. SkPaint::SkPaint()
  39. : fColor4f{0, 0, 0, 1} // opaque black
  40. , fWidth{0}
  41. , fMiterLimit{SkPaintDefaults_MiterLimit}
  42. , fBitfields{(unsigned)false, // fAntiAlias
  43. (unsigned)false, // fDither
  44. (unsigned)SkPaint::kDefault_Cap, // fCapType
  45. (unsigned)SkPaint::kDefault_Join, // fJoinType
  46. (unsigned)SkPaint::kFill_Style, // fStyle
  47. (unsigned)kNone_SkFilterQuality, // fFilterQuality
  48. (unsigned)SkBlendMode::kSrcOver, // fBlendMode
  49. 0} // fPadding
  50. {
  51. static_assert(sizeof(fBitfields) == sizeof(fBitfieldsUInt), "");
  52. }
  53. SkPaint::SkPaint(const SkColor4f& color, SkColorSpace* colorSpace) : SkPaint() {
  54. this->setColor(color, colorSpace);
  55. }
  56. SkPaint::SkPaint(const SkPaint& src) = default;
  57. SkPaint::SkPaint(SkPaint&& src) = default;
  58. SkPaint::~SkPaint() = default;
  59. SkPaint& SkPaint::operator=(const SkPaint& src) = default;
  60. SkPaint& SkPaint::operator=(SkPaint&& src) = default;
  61. bool operator==(const SkPaint& a, const SkPaint& b) {
  62. #define EQUAL(field) (a.field == b.field)
  63. return EQUAL(fPathEffect)
  64. && EQUAL(fShader)
  65. && EQUAL(fMaskFilter)
  66. && EQUAL(fColorFilter)
  67. && EQUAL(fDrawLooper)
  68. && EQUAL(fImageFilter)
  69. && EQUAL(fColor4f)
  70. && EQUAL(fWidth)
  71. && EQUAL(fMiterLimit)
  72. && EQUAL(fBitfieldsUInt)
  73. ;
  74. #undef EQUAL
  75. }
  76. #define DEFINE_REF_FOO(type) sk_sp<Sk##type> SkPaint::ref##type() const { return f##type; }
  77. DEFINE_REF_FOO(ColorFilter)
  78. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  79. DEFINE_REF_FOO(DrawLooper)
  80. #endif
  81. DEFINE_REF_FOO(ImageFilter)
  82. DEFINE_REF_FOO(MaskFilter)
  83. DEFINE_REF_FOO(PathEffect)
  84. DEFINE_REF_FOO(Shader)
  85. #undef DEFINE_REF_FOO
  86. void SkPaint::reset() { *this = SkPaint(); }
  87. void SkPaint::setFilterQuality(SkFilterQuality quality) {
  88. fBitfields.fFilterQuality = quality;
  89. }
  90. void SkPaint::setStyle(Style style) {
  91. if ((unsigned)style < kStyleCount) {
  92. fBitfields.fStyle = style;
  93. } else {
  94. #ifdef SK_REPORT_API_RANGE_CHECK
  95. SkDebugf("SkPaint::setStyle(%d) out of range\n", style);
  96. #endif
  97. }
  98. }
  99. void SkPaint::setColor(SkColor color) {
  100. fColor4f = SkColor4f::FromColor(color);
  101. }
  102. void SkPaint::setColor(const SkColor4f& color, SkColorSpace* colorSpace) {
  103. SkASSERT(fColor4f.fA >= 0 && fColor4f.fA <= 1.0f);
  104. SkColorSpaceXformSteps steps{colorSpace, kUnpremul_SkAlphaType,
  105. sk_srgb_singleton(), kUnpremul_SkAlphaType};
  106. fColor4f = color;
  107. steps.apply(fColor4f.vec());
  108. }
  109. void SkPaint::setAlphaf(float a) {
  110. SkASSERT(a >= 0 && a <= 1.0f);
  111. fColor4f.fA = a;
  112. }
  113. void SkPaint::setARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
  114. this->setColor(SkColorSetARGB(a, r, g, b));
  115. }
  116. void SkPaint::setStrokeWidth(SkScalar width) {
  117. if (width >= 0) {
  118. fWidth = width;
  119. } else {
  120. #ifdef SK_REPORT_API_RANGE_CHECK
  121. SkDebugf("SkPaint::setStrokeWidth() called with negative value\n");
  122. #endif
  123. }
  124. }
  125. void SkPaint::setStrokeMiter(SkScalar limit) {
  126. if (limit >= 0) {
  127. fMiterLimit = limit;
  128. } else {
  129. #ifdef SK_REPORT_API_RANGE_CHECK
  130. SkDebugf("SkPaint::setStrokeMiter() called with negative value\n");
  131. #endif
  132. }
  133. }
  134. void SkPaint::setStrokeCap(Cap ct) {
  135. if ((unsigned)ct < kCapCount) {
  136. fBitfields.fCapType = SkToU8(ct);
  137. } else {
  138. #ifdef SK_REPORT_API_RANGE_CHECK
  139. SkDebugf("SkPaint::setStrokeCap(%d) out of range\n", ct);
  140. #endif
  141. }
  142. }
  143. void SkPaint::setStrokeJoin(Join jt) {
  144. if ((unsigned)jt < kJoinCount) {
  145. fBitfields.fJoinType = SkToU8(jt);
  146. } else {
  147. #ifdef SK_REPORT_API_RANGE_CHECK
  148. SkDebugf("SkPaint::setStrokeJoin(%d) out of range\n", jt);
  149. #endif
  150. }
  151. }
  152. ///////////////////////////////////////////////////////////////////////////////
  153. #define MOVE_FIELD(Field) void SkPaint::set##Field(sk_sp<Sk##Field> f) { f##Field = std::move(f); }
  154. MOVE_FIELD(ImageFilter)
  155. MOVE_FIELD(Shader)
  156. MOVE_FIELD(ColorFilter)
  157. MOVE_FIELD(PathEffect)
  158. MOVE_FIELD(MaskFilter)
  159. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  160. MOVE_FIELD(DrawLooper)
  161. #endif
  162. #undef MOVE_FIELD
  163. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  164. void SkPaint::setLooper(sk_sp<SkDrawLooper> looper) { fDrawLooper = std::move(looper); }
  165. #endif
  166. ///////////////////////////////////////////////////////////////////////////////
  167. #include "include/core/SkStream.h"
  168. #ifdef SK_DEBUG
  169. static void ASSERT_FITS_IN(uint32_t value, int bitCount) {
  170. SkASSERT(bitCount > 0 && bitCount <= 32);
  171. uint32_t mask = ~0U;
  172. mask >>= (32 - bitCount);
  173. SkASSERT(0 == (value & ~mask));
  174. }
  175. #else
  176. #define ASSERT_FITS_IN(value, bitcount)
  177. #endif
  178. enum FlatFlags {
  179. kHasTypeface_FlatFlag = 0x1,
  180. kHasEffects_FlatFlag = 0x2,
  181. kFlatFlagMask = 0x3,
  182. };
  183. enum BitsPerField {
  184. kFlags_BPF = 16,
  185. kHint_BPF = 2,
  186. kFilter_BPF = 2,
  187. kFlatFlags_BPF = 3,
  188. };
  189. static inline int BPF_Mask(int bits) {
  190. return (1 << bits) - 1;
  191. }
  192. // SkPaint originally defined flags, some of which now apply to SkFont. These are renames
  193. // of those flags, split into categories depending on which objects they (now) apply to.
  194. enum PaintFlagsForPaint {
  195. kAA_PaintFlagForPaint = 0x01,
  196. kDither_PaintFlagForPaint = 0x04,
  197. };
  198. enum PaintFlagsForFont {
  199. kFakeBold_PaintFlagForFont = 0x20,
  200. kLinear_PaintFlagForFont = 0x40,
  201. kSubpixel_PaintFlagForFont = 0x80,
  202. kLCD_PaintFlagForFont = 0x200,
  203. kEmbeddedBitmap_PaintFlagForFont = 0x400,
  204. kAutoHinting_PaintFlagForFont = 0x800,
  205. };
  206. static FlatFlags unpack_paint_flags(SkPaint* paint, uint32_t packed, SkFont* font) {
  207. uint32_t f = packed >> 16;
  208. paint->setAntiAlias((f & kAA_PaintFlagForPaint) != 0);
  209. paint->setDither((f & kDither_PaintFlagForPaint) != 0);
  210. if (font) {
  211. font->setEmbolden((f & kFakeBold_PaintFlagForFont) != 0);
  212. font->setLinearMetrics((f & kLinear_PaintFlagForFont) != 0);
  213. font->setSubpixel((f & kSubpixel_PaintFlagForFont) != 0);
  214. font->setEmbeddedBitmaps((f & kEmbeddedBitmap_PaintFlagForFont) != 0);
  215. font->setForceAutoHinting((f & kAutoHinting_PaintFlagForFont) != 0);
  216. font->setHinting((SkFontHinting)((packed >> 14) & BPF_Mask(kHint_BPF)));
  217. if (f & kAA_PaintFlagForPaint) {
  218. if (f & kLCD_PaintFlagForFont) {
  219. font->setEdging(SkFont::Edging::kSubpixelAntiAlias);
  220. } else {
  221. font->setEdging(SkFont::Edging::kAntiAlias);
  222. }
  223. } else {
  224. font->setEdging(SkFont::Edging::kAlias);
  225. }
  226. }
  227. paint->setFilterQuality((SkFilterQuality)((packed >> 10) & BPF_Mask(kFilter_BPF)));
  228. return (FlatFlags)(packed & kFlatFlagMask);
  229. }
  230. template <typename T> uint32_t shift_bits(T value, unsigned shift, unsigned bits) {
  231. SkASSERT(shift + bits <= 32);
  232. uint32_t v = static_cast<uint32_t>(value);
  233. ASSERT_FITS_IN(v, bits);
  234. return v << shift;
  235. }
  236. /* Packing the paint
  237. flags : 8 // 2...
  238. blend : 8 // 30+
  239. cap : 2 // 3
  240. join : 2 // 3
  241. style : 2 // 3
  242. filter: 2 // 4
  243. flat : 8 // 1...
  244. total : 32
  245. */
  246. static uint32_t pack_v68(const SkPaint& paint, unsigned flatFlags) {
  247. uint32_t packed = 0;
  248. packed |= shift_bits(((unsigned)paint.isDither() << 1) |
  249. (unsigned)paint.isAntiAlias(), 0, 8);
  250. packed |= shift_bits(paint.getBlendMode(), 8, 8);
  251. packed |= shift_bits(paint.getStrokeCap(), 16, 2);
  252. packed |= shift_bits(paint.getStrokeJoin(), 18, 2);
  253. packed |= shift_bits(paint.getStyle(), 20, 2);
  254. packed |= shift_bits(paint.getFilterQuality(), 22, 2);
  255. packed |= shift_bits(flatFlags, 24, 8);
  256. return packed;
  257. }
  258. static uint32_t unpack_v68(SkPaint* paint, uint32_t packed, SkSafeRange& safe) {
  259. paint->setAntiAlias((packed & 1) != 0);
  260. paint->setDither((packed & 2) != 0);
  261. packed >>= 8;
  262. paint->setBlendMode(safe.checkLE(packed & 0xFF, SkBlendMode::kLastMode));
  263. packed >>= 8;
  264. paint->setStrokeCap(safe.checkLE(packed & 0x3, SkPaint::kLast_Cap));
  265. packed >>= 2;
  266. paint->setStrokeJoin(safe.checkLE(packed & 0x3, SkPaint::kLast_Join));
  267. packed >>= 2;
  268. paint->setStyle(safe.checkLE(packed & 0x3, SkPaint::kStrokeAndFill_Style));
  269. packed >>= 2;
  270. paint->setFilterQuality(safe.checkLE(packed & 0x3, kLast_SkFilterQuality));
  271. packed >>= 2;
  272. return packed;
  273. }
  274. /* To save space/time, we analyze the paint, and write a truncated version of
  275. it if there are not tricky elements like shaders, etc.
  276. */
  277. void SkPaintPriv::Flatten(const SkPaint& paint, SkWriteBuffer& buffer) {
  278. uint8_t flatFlags = 0;
  279. if (paint.getPathEffect() ||
  280. paint.getShader() ||
  281. paint.getMaskFilter() ||
  282. paint.getColorFilter() ||
  283. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  284. paint.getLooper() ||
  285. #endif
  286. paint.getImageFilter()) {
  287. flatFlags |= kHasEffects_FlatFlag;
  288. }
  289. buffer.writeScalar(paint.getStrokeWidth());
  290. buffer.writeScalar(paint.getStrokeMiter());
  291. buffer.writeColor4f(paint.getColor4f());
  292. buffer.write32(pack_v68(paint, flatFlags));
  293. if (flatFlags & kHasEffects_FlatFlag) {
  294. buffer.writeFlattenable(paint.getPathEffect());
  295. buffer.writeFlattenable(paint.getShader());
  296. buffer.writeFlattenable(paint.getMaskFilter());
  297. buffer.writeFlattenable(paint.getColorFilter());
  298. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  299. buffer.writeFlattenable(paint.getLooper());
  300. #else
  301. buffer.write32(0);
  302. #endif
  303. buffer.writeFlattenable(paint.getImageFilter());
  304. }
  305. }
  306. SkReadPaintResult SkPaintPriv::Unflatten_PreV68(SkPaint* paint, SkReadBuffer& buffer, SkFont* font) {
  307. SkSafeRange safe;
  308. {
  309. SkScalar sz = buffer.readScalar();
  310. SkScalar sx = buffer.readScalar();
  311. SkScalar kx = buffer.readScalar();
  312. if (font) {
  313. font->setSize(sz);
  314. font->setScaleX(sx);
  315. font->setSkewX(kx);
  316. }
  317. }
  318. paint->setStrokeWidth(buffer.readScalar());
  319. paint->setStrokeMiter(buffer.readScalar());
  320. if (buffer.isVersionLT(SkReadBuffer::kFloat4PaintColor_Version)) {
  321. paint->setColor(buffer.readColor());
  322. } else {
  323. SkColor4f color;
  324. buffer.readColor4f(&color);
  325. paint->setColor(color, sk_srgb_singleton());
  326. }
  327. unsigned flatFlags = unpack_paint_flags(paint, buffer.readUInt(), font);
  328. uint32_t tmp = buffer.readUInt();
  329. paint->setStrokeCap(safe.checkLE((tmp >> 24) & 0xFF, SkPaint::kLast_Cap));
  330. paint->setStrokeJoin(safe.checkLE((tmp >> 16) & 0xFF, SkPaint::kLast_Join));
  331. paint->setStyle(safe.checkLE((tmp >> 12) & 0xF, SkPaint::kStrokeAndFill_Style));
  332. paint->setBlendMode(safe.checkLE(tmp & 0xFF, SkBlendMode::kLastMode));
  333. sk_sp<SkTypeface> tf;
  334. if (flatFlags & kHasTypeface_FlatFlag) {
  335. tf = buffer.readTypeface();
  336. }
  337. if (font) {
  338. font->setTypeface(tf);
  339. }
  340. if (flatFlags & kHasEffects_FlatFlag) {
  341. paint->setPathEffect(buffer.readPathEffect());
  342. paint->setShader(buffer.readShader());
  343. paint->setMaskFilter(buffer.readMaskFilter());
  344. paint->setColorFilter(buffer.readColorFilter());
  345. (void)buffer.read32(); // use to be SkRasterizer
  346. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  347. paint->setLooper(buffer.readDrawLooper());
  348. #else
  349. (void)buffer.read32(); // used to be drawlooper
  350. #endif
  351. paint->setImageFilter(buffer.readImageFilter());
  352. } else {
  353. paint->setPathEffect(nullptr);
  354. paint->setShader(nullptr);
  355. paint->setMaskFilter(nullptr);
  356. paint->setColorFilter(nullptr);
  357. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  358. paint->setLooper(nullptr);
  359. #endif
  360. paint->setImageFilter(nullptr);
  361. }
  362. if (!buffer.validate(safe)) {
  363. paint->reset();
  364. return kFailed_ReadPaint;
  365. }
  366. return kSuccess_PaintAndFont;
  367. }
  368. SkReadPaintResult SkPaintPriv::Unflatten(SkPaint* paint, SkReadBuffer& buffer, SkFont* font) {
  369. if (buffer.isVersionLT(SkReadBuffer::kPaintDoesntSerializeFonts_Version)) {
  370. return Unflatten_PreV68(paint, buffer, font);
  371. }
  372. SkSafeRange safe;
  373. paint->setStrokeWidth(buffer.readScalar());
  374. paint->setStrokeMiter(buffer.readScalar());
  375. {
  376. SkColor4f color;
  377. buffer.readColor4f(&color);
  378. paint->setColor(color, sk_srgb_singleton());
  379. }
  380. unsigned flatFlags = unpack_v68(paint, buffer.readUInt(), safe);
  381. if (flatFlags & kHasEffects_FlatFlag) {
  382. paint->setPathEffect(buffer.readPathEffect());
  383. paint->setShader(buffer.readShader());
  384. paint->setMaskFilter(buffer.readMaskFilter());
  385. paint->setColorFilter(buffer.readColorFilter());
  386. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  387. paint->setLooper(buffer.readDrawLooper());
  388. #else
  389. (void)buffer.readDrawLooper();
  390. #endif
  391. paint->setImageFilter(buffer.readImageFilter());
  392. } else {
  393. paint->setPathEffect(nullptr);
  394. paint->setShader(nullptr);
  395. paint->setMaskFilter(nullptr);
  396. paint->setColorFilter(nullptr);
  397. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  398. paint->setLooper(nullptr);
  399. #endif
  400. paint->setImageFilter(nullptr);
  401. }
  402. if (!buffer.validate(safe)) {
  403. paint->reset();
  404. return kFailed_ReadPaint;
  405. }
  406. return kSuccess_JustPaint;
  407. }
  408. ///////////////////////////////////////////////////////////////////////////////
  409. bool SkPaint::getFillPath(const SkPath& src, SkPath* dst, const SkRect* cullRect,
  410. SkScalar resScale) const {
  411. if (!src.isFinite()) {
  412. dst->reset();
  413. return false;
  414. }
  415. SkStrokeRec rec(*this, resScale);
  416. const SkPath* srcPtr = &src;
  417. SkPath tmpPath;
  418. if (fPathEffect && fPathEffect->filterPath(&tmpPath, src, &rec, cullRect)) {
  419. srcPtr = &tmpPath;
  420. }
  421. if (!rec.applyToPath(dst, *srcPtr)) {
  422. if (srcPtr == &tmpPath) {
  423. // If path's were copy-on-write, this trick would not be needed.
  424. // As it is, we want to save making a deep-copy from tmpPath -> dst
  425. // since we know we're just going to delete tmpPath when we return,
  426. // so the swap saves that copy.
  427. dst->swap(tmpPath);
  428. } else {
  429. *dst = *srcPtr;
  430. }
  431. }
  432. if (!dst->isFinite()) {
  433. dst->reset();
  434. return false;
  435. }
  436. return !rec.isHairlineStyle();
  437. }
  438. bool SkPaint::canComputeFastBounds() const {
  439. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  440. if (this->getLooper()) {
  441. return this->getLooper()->canComputeFastBounds(*this);
  442. }
  443. #endif
  444. if (this->getImageFilter() && !this->getImageFilter()->canComputeFastBounds()) {
  445. return false;
  446. }
  447. return true;
  448. }
  449. const SkRect& SkPaint::doComputeFastBounds(const SkRect& origSrc,
  450. SkRect* storage,
  451. Style style) const {
  452. SkASSERT(storage);
  453. const SkRect* src = &origSrc;
  454. #ifdef SK_SUPPORT_LEGACY_DRAWLOOPER
  455. if (this->getLooper()) {
  456. SkASSERT(this->getLooper()->canComputeFastBounds(*this));
  457. this->getLooper()->computeFastBounds(*this, *src, storage);
  458. return *storage;
  459. }
  460. #endif
  461. SkRect tmpSrc;
  462. if (this->getPathEffect()) {
  463. this->getPathEffect()->computeFastBounds(&tmpSrc, origSrc);
  464. src = &tmpSrc;
  465. }
  466. SkScalar radius = SkStrokeRec::GetInflationRadius(*this, style);
  467. *storage = src->makeOutset(radius, radius);
  468. if (this->getMaskFilter()) {
  469. as_MFB(this->getMaskFilter())->computeFastBounds(*storage, storage);
  470. }
  471. if (this->getImageFilter()) {
  472. *storage = this->getImageFilter()->computeFastBounds(*storage);
  473. }
  474. return *storage;
  475. }
  476. ///////////////////////////////////////////////////////////////////////////////
  477. // return true if the filter exists, and may affect alpha
  478. static bool affects_alpha(const SkColorFilter* cf) {
  479. return cf && !(cf->getFlags() & SkColorFilter::kAlphaUnchanged_Flag);
  480. }
  481. // return true if the filter exists, and may affect alpha
  482. static bool affects_alpha(const SkImageFilter* imf) {
  483. // TODO: check if we should allow imagefilters to broadcast that they don't affect alpha
  484. // ala colorfilters
  485. return imf != nullptr;
  486. }
  487. bool SkPaint::nothingToDraw() const {
  488. if (fDrawLooper) {
  489. return false;
  490. }
  491. switch (this->getBlendMode()) {
  492. case SkBlendMode::kSrcOver:
  493. case SkBlendMode::kSrcATop:
  494. case SkBlendMode::kDstOut:
  495. case SkBlendMode::kDstOver:
  496. case SkBlendMode::kPlus:
  497. if (0 == this->getAlpha()) {
  498. return !affects_alpha(fColorFilter.get()) && !affects_alpha(fImageFilter.get());
  499. }
  500. break;
  501. case SkBlendMode::kDst:
  502. return true;
  503. default:
  504. break;
  505. }
  506. return false;
  507. }
  508. uint32_t SkPaint::getHash() const {
  509. // We're going to hash 6 pointers and 6 floats, finishing up with fBitfields,
  510. // so fBitfields should be 6 pointers and 6 floats from the start.
  511. static_assert(offsetof(SkPaint, fBitfieldsUInt) == 6 * sizeof(void*) + 6 * sizeof(float),
  512. "SkPaint_notPackedTightly");
  513. return SkOpts::hash(reinterpret_cast<const uint32_t*>(this),
  514. offsetof(SkPaint, fBitfieldsUInt) + sizeof(fBitfieldsUInt));
  515. }