epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2011 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 | */ |
robertphillips@google.com | 53238bc | 2013-08-30 13:12:10 +0000 | [diff] [blame] | 7 | |
Mike Reed | 986480a | 2017-01-13 22:43:16 +0000 | [diff] [blame] | 8 | #include "SkDevice.h" |
Brian Salomon | 199fb87 | 2017-02-06 09:41:10 -0500 | [diff] [blame] | 9 | #include "SkColorFilter.h" |
dandov | ecfff21 | 2014-08-04 10:02:00 -0700 | [diff] [blame] | 10 | #include "SkDraw.h" |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 11 | #include "SkDrawFilter.h" |
Florin Malita | ca79535 | 2016-11-16 14:45:34 -0500 | [diff] [blame] | 12 | #include "SkImageCacherator.h" |
senorblanco | 900c367 | 2016-04-27 11:31:23 -0700 | [diff] [blame] | 13 | #include "SkImageFilter.h" |
| 14 | #include "SkImageFilterCache.h" |
msarett | 1688206 | 2016-08-16 09:31:08 -0700 | [diff] [blame] | 15 | #include "SkImagePriv.h" |
Brian Salomon | 199fb87 | 2017-02-06 09:41:10 -0500 | [diff] [blame] | 16 | #include "SkImage_Base.h" |
msarett | c573a40 | 2016-08-02 08:05:56 -0700 | [diff] [blame] | 17 | #include "SkLatticeIter.h" |
dandov | ecfff21 | 2014-08-04 10:02:00 -0700 | [diff] [blame] | 18 | #include "SkPatchUtils.h" |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 19 | #include "SkPathMeasure.h" |
Brian Salomon | 199fb87 | 2017-02-06 09:41:10 -0500 | [diff] [blame] | 20 | #include "SkPathPriv.h" |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 21 | #include "SkRSXform.h" |
Brian Salomon | 199fb87 | 2017-02-06 09:41:10 -0500 | [diff] [blame] | 22 | #include "SkRasterClip.h" |
fmalita | 8483326 | 2014-09-19 11:40:51 -0700 | [diff] [blame] | 23 | #include "SkShader.h" |
robertphillips | 4418dba | 2016-03-07 12:45:14 -0800 | [diff] [blame] | 24 | #include "SkSpecialImage.h" |
Brian Salomon | 199fb87 | 2017-02-06 09:41:10 -0500 | [diff] [blame] | 25 | #include "SkTLazy.h" |
halcanary | 3377975 | 2015-10-27 14:01:05 -0700 | [diff] [blame] | 26 | #include "SkTextBlobRunIterator.h" |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 27 | #include "SkTextToPathIter.h" |
Brian Salomon | 199fb87 | 2017-02-06 09:41:10 -0500 | [diff] [blame] | 28 | #include "SkVertices.h" |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 29 | |
reed | 589a39e | 2016-08-20 07:59:19 -0700 | [diff] [blame] | 30 | SkBaseDevice::SkBaseDevice(const SkImageInfo& info, const SkSurfaceProps& surfaceProps) |
| 31 | : fInfo(info) |
| 32 | , fSurfaceProps(surfaceProps) |
| 33 | { |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 34 | fOrigin.setZero(); |
Mike Reed | c42a1cd | 2017-02-14 14:25:14 -0500 | [diff] [blame] | 35 | fCTM.reset(); |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 36 | } |
| 37 | |
Mike Reed | c42a1cd | 2017-02-14 14:25:14 -0500 | [diff] [blame] | 38 | void SkBaseDevice::setOrigin(const SkMatrix& globalCTM, int x, int y) { |
| 39 | fOrigin.set(x, y); |
| 40 | fCTM = globalCTM; |
| 41 | fCTM.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y)); |
| 42 | } |
| 43 | |
| 44 | void SkBaseDevice::setGlobalCTM(const SkMatrix& ctm) { |
| 45 | fCTM = ctm; |
| 46 | if (fOrigin.fX | fOrigin.fY) { |
| 47 | fCTM.postTranslate(-SkIntToScalar(fOrigin.fX), -SkIntToScalar(fOrigin.fY)); |
| 48 | } |
| 49 | } |
| 50 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 51 | bool SkBaseDevice::clipIsWideOpen() const { |
| 52 | if (kRect_ClipType == this->onGetClipType()) { |
| 53 | SkRegion rgn; |
| 54 | this->onAsRgnClip(&rgn); |
| 55 | SkASSERT(rgn.isRect()); |
| 56 | return rgn.getBounds() == SkIRect::MakeWH(this->width(), this->height()); |
| 57 | } else { |
| 58 | return false; |
| 59 | } |
| 60 | } |
| 61 | |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 62 | SkPixelGeometry SkBaseDevice::CreateInfo::AdjustGeometry(const SkImageInfo& info, |
reed | 76033be | 2015-03-14 10:54:31 -0700 | [diff] [blame] | 63 | TileUsage tileUsage, |
reed | 70ee31b | 2015-12-10 13:44:45 -0800 | [diff] [blame] | 64 | SkPixelGeometry geo, |
| 65 | bool preserveLCDText) { |
reed | 76033be | 2015-03-14 10:54:31 -0700 | [diff] [blame] | 66 | switch (tileUsage) { |
| 67 | case kPossible_TileUsage: |
reed | 8dc0ccb | 2015-03-20 06:32:52 -0700 | [diff] [blame] | 68 | // (we think) for compatibility with old clients, we assume this layer can support LCD |
| 69 | // even though they may not have marked it as opaque... seems like we should update |
| 70 | // our callers (reed/robertphilips). |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 71 | break; |
reed | 76033be | 2015-03-14 10:54:31 -0700 | [diff] [blame] | 72 | case kNever_TileUsage: |
reed | 70ee31b | 2015-12-10 13:44:45 -0800 | [diff] [blame] | 73 | if (!preserveLCDText) { |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 74 | geo = kUnknown_SkPixelGeometry; |
| 75 | } |
| 76 | break; |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 77 | } |
| 78 | return geo; |
| 79 | } |
| 80 | |
msarett | 44df651 | 2016-08-25 13:54:30 -0700 | [diff] [blame] | 81 | static inline bool is_int(float x) { |
| 82 | return x == (float) sk_float_round2int(x); |
| 83 | } |
| 84 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 85 | void SkBaseDevice::drawRegion(const SkRegion& region, const SkPaint& paint) { |
| 86 | const SkMatrix& ctm = this->ctm(); |
| 87 | bool isNonTranslate = ctm.getType() & ~(SkMatrix::kTranslate_Mask); |
msarett | 44df651 | 2016-08-25 13:54:30 -0700 | [diff] [blame] | 88 | bool complexPaint = paint.getStyle() != SkPaint::kFill_Style || paint.getMaskFilter() || |
| 89 | paint.getPathEffect(); |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 90 | bool antiAlias = paint.isAntiAlias() && (!is_int(ctm.getTranslateX()) || |
| 91 | !is_int(ctm.getTranslateY())); |
msarett | 44df651 | 2016-08-25 13:54:30 -0700 | [diff] [blame] | 92 | if (isNonTranslate || complexPaint || antiAlias) { |
| 93 | SkPath path; |
| 94 | region.getBoundaryPath(&path); |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 95 | return this->drawPath(path, paint, nullptr, false); |
msarett | 44df651 | 2016-08-25 13:54:30 -0700 | [diff] [blame] | 96 | } |
| 97 | |
| 98 | SkRegion::Iterator it(region); |
| 99 | while (!it.done()) { |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 100 | this->drawRect(SkRect::Make(it.rect()), paint); |
msarett | 44df651 | 2016-08-25 13:54:30 -0700 | [diff] [blame] | 101 | it.next(); |
| 102 | } |
| 103 | } |
| 104 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 105 | void SkBaseDevice::drawArc(const SkRect& oval, SkScalar startAngle, |
bsalomon | ac3aa24 | 2016-08-19 11:25:19 -0700 | [diff] [blame] | 106 | SkScalar sweepAngle, bool useCenter, const SkPaint& paint) { |
bsalomon | 6bf2331 | 2016-08-22 11:46:35 -0700 | [diff] [blame] | 107 | SkPath path; |
bsalomon | 21af9ca | 2016-08-25 12:29:23 -0700 | [diff] [blame] | 108 | bool isFillNoPathEffect = SkPaint::kFill_Style == paint.getStyle() && !paint.getPathEffect(); |
| 109 | SkPathPriv::CreateDrawArcPath(&path, oval, startAngle, sweepAngle, useCenter, |
| 110 | isFillNoPathEffect); |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 111 | this->drawPath(path, paint); |
bsalomon | ac3aa24 | 2016-08-19 11:25:19 -0700 | [diff] [blame] | 112 | } |
| 113 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 114 | void SkBaseDevice::drawDRRect(const SkRRect& outer, |
commit-bot@chromium.org | ed9806f | 2014-02-21 02:32:36 +0000 | [diff] [blame] | 115 | const SkRRect& inner, const SkPaint& paint) { |
| 116 | SkPath path; |
| 117 | path.addRRect(outer); |
| 118 | path.addRRect(inner); |
| 119 | path.setFillType(SkPath::kEvenOdd_FillType); |
bsalomon | 6bf2331 | 2016-08-22 11:46:35 -0700 | [diff] [blame] | 120 | path.setIsVolatile(true); |
commit-bot@chromium.org | ed9806f | 2014-02-21 02:32:36 +0000 | [diff] [blame] | 121 | |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 122 | const SkMatrix* preMatrix = nullptr; |
commit-bot@chromium.org | ed9806f | 2014-02-21 02:32:36 +0000 | [diff] [blame] | 123 | const bool pathIsMutable = true; |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 124 | this->drawPath(path, paint, preMatrix, pathIsMutable); |
commit-bot@chromium.org | ed9806f | 2014-02-21 02:32:36 +0000 | [diff] [blame] | 125 | } |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 126 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 127 | void SkBaseDevice::drawPatch(const SkPoint cubics[12], const SkColor colors[4], |
Mike Reed | faba371 | 2016-11-03 14:45:31 -0400 | [diff] [blame] | 128 | const SkPoint texCoords[4], SkBlendMode bmode, const SkPaint& paint) { |
dandov | b3c9d1c | 2014-08-12 08:34:29 -0700 | [diff] [blame] | 129 | SkPatchUtils::VertexData data; |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 130 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 131 | SkISize lod = SkPatchUtils::GetLevelOfDetail(cubics, &this->ctm()); |
Mike Reed | 795c5ea | 2017-03-17 14:29:05 -0400 | [diff] [blame] | 132 | auto vertices = SkPatchUtils::MakeVertices(cubics, colors, texCoords, lod.width(), lod.height()); |
| 133 | if (vertices) { |
Mike Reed | 2f6b5a4 | 2017-03-19 15:04:17 -0400 | [diff] [blame] | 134 | this->drawVertices(vertices.get(), bmode, paint); |
dandov | 45f7842 | 2014-08-15 06:06:47 -0700 | [diff] [blame] | 135 | } |
dandov | ecfff21 | 2014-08-04 10:02:00 -0700 | [diff] [blame] | 136 | } |
| 137 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 138 | void SkBaseDevice::drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 139 | const SkPaint &paint, SkDrawFilter* drawFilter) { |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 140 | |
fmalita | 8483326 | 2014-09-19 11:40:51 -0700 | [diff] [blame] | 141 | SkPaint runPaint = paint; |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 142 | |
halcanary | 3377975 | 2015-10-27 14:01:05 -0700 | [diff] [blame] | 143 | SkTextBlobRunIterator it(blob); |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 144 | for (;!it.done(); it.next()) { |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 145 | size_t textLen = it.glyphCount() * sizeof(uint16_t); |
| 146 | const SkPoint& offset = it.offset(); |
| 147 | // applyFontToPaint() always overwrites the exact same attributes, |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 148 | // so it is safe to not re-seed the paint for this reason. |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 149 | it.applyFontToPaint(&runPaint); |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 150 | |
| 151 | if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) { |
| 152 | // A false return from filter() means we should abort the current draw. |
| 153 | runPaint = paint; |
| 154 | continue; |
| 155 | } |
| 156 | |
fmalita | 112e7e2 | 2014-11-13 14:05:58 -0800 | [diff] [blame] | 157 | runPaint.setFlags(this->filterTextFlags(runPaint)); |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 158 | |
| 159 | switch (it.positioning()) { |
| 160 | case SkTextBlob::kDefault_Positioning: |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 161 | this->drawText(it.glyphs(), textLen, x + offset.x(), y + offset.y(), runPaint); |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 162 | break; |
| 163 | case SkTextBlob::kHorizontal_Positioning: |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 164 | this->drawPosText(it.glyphs(), textLen, it.pos(), 1, |
fmalita | 05c4a43 | 2014-09-29 06:29:53 -0700 | [diff] [blame] | 165 | SkPoint::Make(x, y + offset.y()), runPaint); |
| 166 | break; |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 167 | case SkTextBlob::kFull_Positioning: |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 168 | this->drawPosText(it.glyphs(), textLen, it.pos(), 2, |
fmalita | 05c4a43 | 2014-09-29 06:29:53 -0700 | [diff] [blame] | 169 | SkPoint::Make(x, y), runPaint); |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 170 | break; |
| 171 | default: |
| 172 | SkFAIL("unhandled positioning mode"); |
| 173 | } |
| 174 | |
fmalita | 024f996 | 2015-03-03 19:08:17 -0800 | [diff] [blame] | 175 | if (drawFilter) { |
| 176 | // A draw filter may change the paint arbitrarily, so we must re-seed in this case. |
| 177 | runPaint = paint; |
| 178 | } |
fmalita | aa1b912 | 2014-08-28 14:32:24 -0700 | [diff] [blame] | 179 | } |
| 180 | } |
| 181 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 182 | void SkBaseDevice::drawImage(const SkImage* image, SkScalar x, SkScalar y, |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 183 | const SkPaint& paint) { |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 184 | SkBitmap bm; |
Brian Osman | 61624f0 | 2016-12-09 14:51:59 -0500 | [diff] [blame] | 185 | if (as_IB(image)->getROPixels(&bm, this->imageInfo().colorSpace())) { |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 186 | this->drawBitmap(bm, SkMatrix::MakeTrans(x, y), paint); |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 187 | } |
| 188 | } |
| 189 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 190 | void SkBaseDevice::drawImageRect(const SkImage* image, const SkRect* src, |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 191 | const SkRect& dst, const SkPaint& paint, |
| 192 | SkCanvas::SrcRectConstraint constraint) { |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 193 | SkBitmap bm; |
Brian Osman | 61624f0 | 2016-12-09 14:51:59 -0500 | [diff] [blame] | 194 | if (as_IB(image)->getROPixels(&bm, this->imageInfo().colorSpace())) { |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 195 | this->drawBitmapRect(bm, src, dst, paint, constraint); |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 196 | } |
| 197 | } |
| 198 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 199 | void SkBaseDevice::drawImageNine(const SkImage* image, const SkIRect& center, |
reed | 4c21dc5 | 2015-06-25 12:32:03 -0700 | [diff] [blame] | 200 | const SkRect& dst, const SkPaint& paint) { |
msarett | c573a40 | 2016-08-02 08:05:56 -0700 | [diff] [blame] | 201 | SkLatticeIter iter(image->width(), image->height(), center, dst); |
reed | 4c21dc5 | 2015-06-25 12:32:03 -0700 | [diff] [blame] | 202 | |
| 203 | SkRect srcR, dstR; |
| 204 | while (iter.next(&srcR, &dstR)) { |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 205 | this->drawImageRect(image, &srcR, dstR, paint, SkCanvas::kStrict_SrcRectConstraint); |
reed | 4c21dc5 | 2015-06-25 12:32:03 -0700 | [diff] [blame] | 206 | } |
| 207 | } |
| 208 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 209 | void SkBaseDevice::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, |
reed | 4c21dc5 | 2015-06-25 12:32:03 -0700 | [diff] [blame] | 210 | const SkRect& dst, const SkPaint& paint) { |
msarett | c573a40 | 2016-08-02 08:05:56 -0700 | [diff] [blame] | 211 | SkLatticeIter iter(bitmap.width(), bitmap.height(), center, dst); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 212 | |
reed | 4c21dc5 | 2015-06-25 12:32:03 -0700 | [diff] [blame] | 213 | SkRect srcR, dstR; |
| 214 | while (iter.next(&srcR, &dstR)) { |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 215 | this->drawBitmapRect(bitmap, &srcR, dstR, paint, SkCanvas::kStrict_SrcRectConstraint); |
reed | 4c21dc5 | 2015-06-25 12:32:03 -0700 | [diff] [blame] | 216 | } |
| 217 | } |
| 218 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 219 | void SkBaseDevice::drawImageLattice(const SkImage* image, |
msarett | 1688206 | 2016-08-16 09:31:08 -0700 | [diff] [blame] | 220 | const SkCanvas::Lattice& lattice, const SkRect& dst, |
| 221 | const SkPaint& paint) { |
msarett | 71df2d7 | 2016-09-30 12:41:42 -0700 | [diff] [blame] | 222 | SkLatticeIter iter(lattice, dst); |
msarett | 1688206 | 2016-08-16 09:31:08 -0700 | [diff] [blame] | 223 | |
| 224 | SkRect srcR, dstR; |
| 225 | while (iter.next(&srcR, &dstR)) { |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 226 | this->drawImageRect(image, &srcR, dstR, paint, SkCanvas::kStrict_SrcRectConstraint); |
msarett | 1688206 | 2016-08-16 09:31:08 -0700 | [diff] [blame] | 227 | } |
| 228 | } |
| 229 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 230 | void SkBaseDevice::drawBitmapLattice(const SkBitmap& bitmap, |
msarett | 1688206 | 2016-08-16 09:31:08 -0700 | [diff] [blame] | 231 | const SkCanvas::Lattice& lattice, const SkRect& dst, |
| 232 | const SkPaint& paint) { |
msarett | 71df2d7 | 2016-09-30 12:41:42 -0700 | [diff] [blame] | 233 | SkLatticeIter iter(lattice, dst); |
msarett | 1688206 | 2016-08-16 09:31:08 -0700 | [diff] [blame] | 234 | |
| 235 | SkRect srcR, dstR; |
| 236 | while (iter.next(&srcR, &dstR)) { |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 237 | this->drawBitmapRect(bitmap, &srcR, dstR, paint, SkCanvas::kStrict_SrcRectConstraint); |
msarett | 1688206 | 2016-08-16 09:31:08 -0700 | [diff] [blame] | 238 | } |
| 239 | } |
| 240 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 241 | void SkBaseDevice::drawAtlas(const SkImage* atlas, const SkRSXform xform[], |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 242 | const SkRect tex[], const SkColor colors[], int count, |
Mike Reed | faba371 | 2016-11-03 14:45:31 -0400 | [diff] [blame] | 243 | SkBlendMode mode, const SkPaint& paint) { |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 244 | SkPath path; |
| 245 | path.setIsVolatile(true); |
| 246 | |
| 247 | for (int i = 0; i < count; ++i) { |
| 248 | SkPoint quad[4]; |
| 249 | xform[i].toQuad(tex[i].width(), tex[i].height(), quad); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 250 | |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 251 | SkMatrix localM; |
| 252 | localM.setRSXform(xform[i]); |
| 253 | localM.preTranslate(-tex[i].left(), -tex[i].top()); |
| 254 | |
| 255 | SkPaint pnt(paint); |
reed | 5671c5b | 2016-03-09 14:47:34 -0800 | [diff] [blame] | 256 | sk_sp<SkShader> shader = atlas->makeShader(SkShader::kClamp_TileMode, |
| 257 | SkShader::kClamp_TileMode, |
| 258 | &localM); |
reed | 4f0e047 | 2015-08-18 12:50:24 -0700 | [diff] [blame] | 259 | if (!shader) { |
| 260 | break; |
| 261 | } |
reed | 5671c5b | 2016-03-09 14:47:34 -0800 | [diff] [blame] | 262 | pnt.setShader(std::move(shader)); |
reed | 4f0e047 | 2015-08-18 12:50:24 -0700 | [diff] [blame] | 263 | |
bsalomon | f1b7a1d | 2015-09-28 06:26:28 -0700 | [diff] [blame] | 264 | if (colors) { |
Mike Reed | 7d954ad | 2016-10-28 15:42:34 -0400 | [diff] [blame] | 265 | pnt.setColorFilter(SkColorFilter::MakeModeFilter(colors[i], (SkBlendMode)mode)); |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 266 | } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 267 | |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 268 | path.rewind(); |
| 269 | path.addPoly(quad, 4, true); |
| 270 | path.setConvexity(SkPath::kConvex_Convexity); |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 271 | this->drawPath(path, pnt, nullptr, true); |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 272 | } |
| 273 | } |
| 274 | |
| 275 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 276 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 277 | void SkBaseDevice::drawSpecial(SkSpecialImage*, int x, int y, const SkPaint&) {} |
reed | e51c356 | 2016-07-19 14:33:20 -0700 | [diff] [blame] | 278 | sk_sp<SkSpecialImage> SkBaseDevice::makeSpecial(const SkBitmap&) { return nullptr; } |
| 279 | sk_sp<SkSpecialImage> SkBaseDevice::makeSpecial(const SkImage*) { return nullptr; } |
| 280 | sk_sp<SkSpecialImage> SkBaseDevice::snapSpecial() { return nullptr; } |
| 281 | |
| 282 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 283 | |
commit-bot@chromium.org | a713f9c | 2014-03-17 21:31:26 +0000 | [diff] [blame] | 284 | bool SkBaseDevice::readPixels(const SkImageInfo& info, void* dstP, size_t rowBytes, int x, int y) { |
commit-bot@chromium.org | a713f9c | 2014-03-17 21:31:26 +0000 | [diff] [blame] | 285 | return this->onReadPixels(info, dstP, rowBytes, x, y); |
| 286 | } |
| 287 | |
commit-bot@chromium.org | 4ef54f8 | 2014-03-17 17:03:18 +0000 | [diff] [blame] | 288 | bool SkBaseDevice::writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, |
| 289 | int x, int y) { |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 290 | return this->onWritePixels(info, pixels, rowBytes, x, y); |
| 291 | } |
| 292 | |
| 293 | bool SkBaseDevice::onWritePixels(const SkImageInfo&, const void*, size_t, int, int) { |
| 294 | return false; |
| 295 | } |
| 296 | |
commit-bot@chromium.org | a713f9c | 2014-03-17 21:31:26 +0000 | [diff] [blame] | 297 | bool SkBaseDevice::onReadPixels(const SkImageInfo&, void*, size_t, int x, int y) { |
commit-bot@chromium.org | 2cccf83 | 2014-03-12 03:04:08 +0000 | [diff] [blame] | 298 | return false; |
| 299 | } |
| 300 | |
reed | 884e97c | 2015-05-26 11:31:54 -0700 | [diff] [blame] | 301 | bool SkBaseDevice::accessPixels(SkPixmap* pmap) { |
| 302 | SkPixmap tempStorage; |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 303 | if (nullptr == pmap) { |
reed | 884e97c | 2015-05-26 11:31:54 -0700 | [diff] [blame] | 304 | pmap = &tempStorage; |
| 305 | } |
| 306 | return this->onAccessPixels(pmap); |
| 307 | } |
| 308 | |
| 309 | bool SkBaseDevice::peekPixels(SkPixmap* pmap) { |
| 310 | SkPixmap tempStorage; |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 311 | if (nullptr == pmap) { |
reed | 884e97c | 2015-05-26 11:31:54 -0700 | [diff] [blame] | 312 | pmap = &tempStorage; |
| 313 | } |
| 314 | return this->onPeekPixels(pmap); |
| 315 | } |
| 316 | |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 317 | ////////////////////////////////////////////////////////////////////////////////////////// |
| 318 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 319 | static void morphpoints(SkPoint dst[], const SkPoint src[], int count, |
| 320 | SkPathMeasure& meas, const SkMatrix& matrix) { |
| 321 | SkMatrix::MapXYProc proc = matrix.getMapXYProc(); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 322 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 323 | for (int i = 0; i < count; i++) { |
| 324 | SkPoint pos; |
| 325 | SkVector tangent; |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 326 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 327 | proc(matrix, src[i].fX, src[i].fY, &pos); |
| 328 | SkScalar sx = pos.fX; |
| 329 | SkScalar sy = pos.fY; |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 330 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 331 | if (!meas.getPosTan(sx, &pos, &tangent)) { |
| 332 | // set to 0 if the measure failed, so that we just set dst == pos |
| 333 | tangent.set(0, 0); |
| 334 | } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 335 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 336 | /* This is the old way (that explains our approach but is way too slow |
| 337 | SkMatrix matrix; |
| 338 | SkPoint pt; |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 339 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 340 | pt.set(sx, sy); |
| 341 | matrix.setSinCos(tangent.fY, tangent.fX); |
| 342 | matrix.preTranslate(-sx, 0); |
| 343 | matrix.postTranslate(pos.fX, pos.fY); |
| 344 | matrix.mapPoints(&dst[i], &pt, 1); |
| 345 | */ |
Mike Reed | a99b6ce | 2017-02-04 11:04:26 -0500 | [diff] [blame] | 346 | dst[i].set(pos.fX - tangent.fY * sy, pos.fY + tangent.fX * sy); |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 347 | } |
| 348 | } |
| 349 | |
| 350 | /* TODO |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 351 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 352 | Need differentially more subdivisions when the follow-path is curvy. Not sure how to |
| 353 | determine that, but we need it. I guess a cheap answer is let the caller tell us, |
| 354 | but that seems like a cop-out. Another answer is to get Rob Johnson to figure it out. |
| 355 | */ |
| 356 | static void morphpath(SkPath* dst, const SkPath& src, SkPathMeasure& meas, |
| 357 | const SkMatrix& matrix) { |
| 358 | SkPath::Iter iter(src, false); |
| 359 | SkPoint srcP[4], dstP[3]; |
| 360 | SkPath::Verb verb; |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 361 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 362 | while ((verb = iter.next(srcP)) != SkPath::kDone_Verb) { |
| 363 | switch (verb) { |
| 364 | case SkPath::kMove_Verb: |
| 365 | morphpoints(dstP, srcP, 1, meas, matrix); |
| 366 | dst->moveTo(dstP[0]); |
| 367 | break; |
| 368 | case SkPath::kLine_Verb: |
| 369 | // turn lines into quads to look bendy |
| 370 | srcP[0].fX = SkScalarAve(srcP[0].fX, srcP[1].fX); |
| 371 | srcP[0].fY = SkScalarAve(srcP[0].fY, srcP[1].fY); |
| 372 | morphpoints(dstP, srcP, 2, meas, matrix); |
| 373 | dst->quadTo(dstP[0], dstP[1]); |
| 374 | break; |
| 375 | case SkPath::kQuad_Verb: |
| 376 | morphpoints(dstP, &srcP[1], 2, meas, matrix); |
| 377 | dst->quadTo(dstP[0], dstP[1]); |
| 378 | break; |
| 379 | case SkPath::kCubic_Verb: |
| 380 | morphpoints(dstP, &srcP[1], 3, meas, matrix); |
| 381 | dst->cubicTo(dstP[0], dstP[1], dstP[2]); |
| 382 | break; |
| 383 | case SkPath::kClose_Verb: |
| 384 | dst->close(); |
| 385 | break; |
| 386 | default: |
| 387 | SkDEBUGFAIL("unknown verb"); |
| 388 | break; |
| 389 | } |
| 390 | } |
| 391 | } |
| 392 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 393 | void SkBaseDevice::drawTextOnPath(const void* text, size_t byteLength, |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 394 | const SkPath& follow, const SkMatrix* matrix, |
| 395 | const SkPaint& paint) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 396 | SkASSERT(byteLength == 0 || text != nullptr); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 397 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 398 | // nothing to draw |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 399 | if (text == nullptr || byteLength == 0) { |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 400 | return; |
| 401 | } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 402 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 403 | SkTextToPathIter iter((const char*)text, byteLength, paint, true); |
| 404 | SkPathMeasure meas(follow, false); |
| 405 | SkScalar hOffset = 0; |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 406 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 407 | // need to measure first |
| 408 | if (paint.getTextAlign() != SkPaint::kLeft_Align) { |
| 409 | SkScalar pathLen = meas.getLength(); |
| 410 | if (paint.getTextAlign() == SkPaint::kCenter_Align) { |
| 411 | pathLen = SkScalarHalf(pathLen); |
| 412 | } |
| 413 | hOffset += pathLen; |
| 414 | } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 415 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 416 | const SkPath* iterPath; |
| 417 | SkScalar xpos; |
| 418 | SkMatrix scaledMatrix; |
| 419 | SkScalar scale = iter.getPathScale(); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 420 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 421 | scaledMatrix.setScale(scale, scale); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 422 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 423 | while (iter.next(&iterPath, &xpos)) { |
| 424 | if (iterPath) { |
| 425 | SkPath tmp; |
| 426 | SkMatrix m(scaledMatrix); |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 427 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 428 | tmp.setIsVolatile(true); |
| 429 | m.postTranslate(xpos + hOffset, 0); |
| 430 | if (matrix) { |
| 431 | m.postConcat(*matrix); |
| 432 | } |
| 433 | morphpath(&tmp, *iterPath, meas, m); |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 434 | this->drawPath(tmp, iter.getPaint(), nullptr, true); |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 435 | } |
| 436 | } |
| 437 | } |
| 438 | |
reed | 45561a0 | 2016-07-07 12:47:17 -0700 | [diff] [blame] | 439 | #include "SkUtils.h" |
| 440 | typedef int (*CountTextProc)(const char* text); |
| 441 | static int count_utf16(const char* text) { |
| 442 | const uint16_t* prev = (uint16_t*)text; |
| 443 | (void)SkUTF16_NextUnichar(&prev); |
| 444 | return SkToInt((const char*)prev - text); |
| 445 | } |
| 446 | static int return_4(const char* text) { return 4; } |
| 447 | static int return_2(const char* text) { return 2; } |
| 448 | |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 449 | void SkBaseDevice::drawTextRSXform(const void* text, size_t len, |
reed | 45561a0 | 2016-07-07 12:47:17 -0700 | [diff] [blame] | 450 | const SkRSXform xform[], const SkPaint& paint) { |
| 451 | CountTextProc proc = nullptr; |
| 452 | switch (paint.getTextEncoding()) { |
| 453 | case SkPaint::kUTF8_TextEncoding: |
| 454 | proc = SkUTF8_CountUTF8Bytes; |
| 455 | break; |
| 456 | case SkPaint::kUTF16_TextEncoding: |
| 457 | proc = count_utf16; |
| 458 | break; |
| 459 | case SkPaint::kUTF32_TextEncoding: |
| 460 | proc = return_4; |
| 461 | break; |
| 462 | case SkPaint::kGlyphID_TextEncoding: |
| 463 | proc = return_2; |
| 464 | break; |
| 465 | } |
| 466 | |
reed | 45561a0 | 2016-07-07 12:47:17 -0700 | [diff] [blame] | 467 | SkMatrix localM, currM; |
| 468 | const void* stopText = (const char*)text + len; |
| 469 | while ((const char*)text < (const char*)stopText) { |
| 470 | localM.setRSXform(*xform++); |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 471 | currM.setConcat(this->ctm(), localM); |
Mike Reed | c42a1cd | 2017-02-14 14:25:14 -0500 | [diff] [blame] | 472 | SkAutoDeviceCTMRestore adc(this, currM); |
Mike Reed | c42a1cd | 2017-02-14 14:25:14 -0500 | [diff] [blame] | 473 | |
reed | 45561a0 | 2016-07-07 12:47:17 -0700 | [diff] [blame] | 474 | int subLen = proc((const char*)text); |
Mike Reed | a136136 | 2017-03-07 09:37:29 -0500 | [diff] [blame] | 475 | this->drawText(text, subLen, 0, 0, paint); |
reed | 45561a0 | 2016-07-07 12:47:17 -0700 | [diff] [blame] | 476 | text = (const char*)text + subLen; |
| 477 | } |
| 478 | } |
| 479 | |
reed | f87fe78 | 2015-02-17 10:33:54 -0800 | [diff] [blame] | 480 | ////////////////////////////////////////////////////////////////////////////////////////// |
| 481 | |
fmalita | 112e7e2 | 2014-11-13 14:05:58 -0800 | [diff] [blame] | 482 | uint32_t SkBaseDevice::filterTextFlags(const SkPaint& paint) const { |
| 483 | uint32_t flags = paint.getFlags(); |
| 484 | |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 485 | if (!paint.isLCDRenderText() || !paint.isAntiAlias()) { |
fmalita | 112e7e2 | 2014-11-13 14:05:58 -0800 | [diff] [blame] | 486 | return flags; |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 487 | } |
| 488 | |
robertphillips | 7b05ff1 | 2015-06-19 14:14:54 -0700 | [diff] [blame] | 489 | if (kUnknown_SkPixelGeometry == fSurfaceProps.pixelGeometry() |
fmalita | 112e7e2 | 2014-11-13 14:05:58 -0800 | [diff] [blame] | 490 | || this->onShouldDisableLCD(paint)) { |
| 491 | |
| 492 | flags &= ~SkPaint::kLCDRenderText_Flag; |
| 493 | flags |= SkPaint::kGenA8FromLCD_Flag; |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 494 | } |
| 495 | |
fmalita | 112e7e2 | 2014-11-13 14:05:58 -0800 | [diff] [blame] | 496 | return flags; |
reed | b2db898 | 2014-11-13 12:41:02 -0800 | [diff] [blame] | 497 | } |
| 498 | |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 499 | sk_sp<SkSurface> SkBaseDevice::makeSurface(SkImageInfo const&, SkSurfaceProps const&) { |
| 500 | return nullptr; |
| 501 | } |
ericrk | 983294f | 2016-04-18 09:14:00 -0700 | [diff] [blame] | 502 | |
| 503 | ////////////////////////////////////////////////////////////////////////////////////////// |
| 504 | |
| 505 | void SkBaseDevice::LogDrawScaleFactor(const SkMatrix& matrix, SkFilterQuality filterQuality) { |
| 506 | #if SK_HISTOGRAMS_ENABLED |
| 507 | enum ScaleFactor { |
| 508 | kUpscale_ScaleFactor, |
| 509 | kNoScale_ScaleFactor, |
| 510 | kDownscale_ScaleFactor, |
| 511 | kLargeDownscale_ScaleFactor, |
| 512 | |
| 513 | kLast_ScaleFactor = kLargeDownscale_ScaleFactor |
| 514 | }; |
| 515 | |
| 516 | float rawScaleFactor = matrix.getMinScale(); |
| 517 | |
| 518 | ScaleFactor scaleFactor; |
| 519 | if (rawScaleFactor < 0.5f) { |
| 520 | scaleFactor = kLargeDownscale_ScaleFactor; |
| 521 | } else if (rawScaleFactor < 1.0f) { |
| 522 | scaleFactor = kDownscale_ScaleFactor; |
| 523 | } else if (rawScaleFactor > 1.0f) { |
| 524 | scaleFactor = kUpscale_ScaleFactor; |
| 525 | } else { |
| 526 | scaleFactor = kNoScale_ScaleFactor; |
| 527 | } |
| 528 | |
| 529 | switch (filterQuality) { |
| 530 | case kNone_SkFilterQuality: |
| 531 | SK_HISTOGRAM_ENUMERATION("DrawScaleFactor.NoneFilterQuality", scaleFactor, |
| 532 | kLast_ScaleFactor + 1); |
| 533 | break; |
| 534 | case kLow_SkFilterQuality: |
| 535 | SK_HISTOGRAM_ENUMERATION("DrawScaleFactor.LowFilterQuality", scaleFactor, |
| 536 | kLast_ScaleFactor + 1); |
| 537 | break; |
| 538 | case kMedium_SkFilterQuality: |
| 539 | SK_HISTOGRAM_ENUMERATION("DrawScaleFactor.MediumFilterQuality", scaleFactor, |
| 540 | kLast_ScaleFactor + 1); |
| 541 | break; |
| 542 | case kHigh_SkFilterQuality: |
| 543 | SK_HISTOGRAM_ENUMERATION("DrawScaleFactor.HighFilterQuality", scaleFactor, |
| 544 | kLast_ScaleFactor + 1); |
| 545 | break; |
| 546 | } |
| 547 | |
| 548 | // Also log filter quality independent scale factor. |
| 549 | SK_HISTOGRAM_ENUMERATION("DrawScaleFactor.AnyFilterQuality", scaleFactor, |
| 550 | kLast_ScaleFactor + 1); |
| 551 | |
| 552 | // Also log an overall histogram of filter quality. |
| 553 | SK_HISTOGRAM_ENUMERATION("FilterQuality", filterQuality, kLast_SkFilterQuality + 1); |
| 554 | #endif |
| 555 | } |
| 556 | |