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 8#include "SkDashPathEffect.h" 9#include "SkDashImpl.h" 10#include "SkDashPathPriv.h" 11#include "SkReadBuffer.h" 12#include "SkWriteBuffer.h" 13#include "SkStrokeRec.h" 14 15SkDashImpl::SkDashImpl(const SkScalar intervals[], int count, SkScalar phase) 16 : fPhase(0) 17 , fInitialDashLength(-1) 18 , fInitialDashIndex(0) 19 , fIntervalLength(0) { 20 SkASSERT(intervals); 21 SkASSERT(count > 1 && SkIsAlign2(count)); 22 23 fIntervals = (SkScalar*)sk_malloc_throw(sizeof(SkScalar) * count); 24 fCount = count; 25 for (int i = 0; i < count; i++) { 26 fIntervals[i] = intervals[i]; 27 } 28 29 // set the internal data members 30 SkDashPath::CalcDashParameters(phase, fIntervals, fCount, 31 &fInitialDashLength, &fInitialDashIndex, &fIntervalLength, &fPhase); 32} 33 34SkDashImpl::~SkDashImpl() { 35 sk_free(fIntervals); 36} 37 38bool SkDashImpl::filterPath(SkPath* dst, const SkPath& src, SkStrokeRec* rec, 39 const SkRect* cullRect) const { 40 return SkDashPath::InternalFilter(dst, src, rec, cullRect, fIntervals, fCount, 41 fInitialDashLength, fInitialDashIndex, fIntervalLength); 42} 43 44static void outset_for_stroke(SkRect* rect, const SkStrokeRec& rec) { 45 SkScalar radius = SkScalarHalf(rec.getWidth()); 46 if (0 == radius) { 47 radius = SK_Scalar1; // hairlines 48 } 49 if (SkPaint::kMiter_Join == rec.getJoin()) { 50 radius *= rec.getMiter(); 51 } 52 rect->outset(radius, radius); 53} 54 55// Attempt to trim the line to minimally cover the cull rect (currently 56// only works for horizontal and vertical lines). 57// Return true if processing should continue; false otherwise. 58static bool cull_line(SkPoint* pts, const SkStrokeRec& rec, 59 const SkMatrix& ctm, const SkRect* cullRect, 60 const SkScalar intervalLength) { 61 if (nullptr == cullRect) { 62 SkASSERT(false); // Shouldn't ever occur in practice 63 return false; 64 } 65 66 SkScalar dx = pts[1].x() - pts[0].x(); 67 SkScalar dy = pts[1].y() - pts[0].y(); 68 69 if ((dx && dy) || (!dx && !dy)) { 70 return false; 71 } 72 73 SkRect bounds = *cullRect; 74 outset_for_stroke(&bounds, rec); 75 76 // cullRect is in device space while pts are in the local coordinate system 77 // defined by the ctm. We want our answer in the local coordinate system. 78 79 SkASSERT(ctm.rectStaysRect()); 80 SkMatrix inv; 81 if (!ctm.invert(&inv)) { 82 return false; 83 } 84 85 inv.mapRect(&bounds); 86 87 if (dx) { 88 SkASSERT(dx && !dy); 89 SkScalar minX = pts[0].fX; 90 SkScalar maxX = pts[1].fX; 91 92 if (dx < 0) { 93 SkTSwap(minX, maxX); 94 } 95 96 SkASSERT(minX < maxX); 97 if (maxX <= bounds.fLeft || minX >= bounds.fRight) { 98 return false; 99 } 100 101 // Now we actually perform the chop, removing the excess to the left and 102 // right of the bounds (keeping our new line "in phase" with the dash, 103 // hence the (mod intervalLength). 104 105 if (minX < bounds.fLeft) { 106 minX = bounds.fLeft - SkScalarMod(bounds.fLeft - minX, intervalLength); 107 } 108 if (maxX > bounds.fRight) { 109 maxX = bounds.fRight + SkScalarMod(maxX - bounds.fRight, intervalLength); 110 } 111 112 SkASSERT(maxX > minX); 113 if (dx < 0) { 114 SkTSwap(minX, maxX); 115 } 116 pts[0].fX = minX; 117 pts[1].fX = maxX; 118 } else { 119 SkASSERT(dy && !dx); 120 SkScalar minY = pts[0].fY; 121 SkScalar maxY = pts[1].fY; 122 123 if (dy < 0) { 124 SkTSwap(minY, maxY); 125 } 126 127 SkASSERT(minY < maxY); 128 if (maxY <= bounds.fTop || minY >= bounds.fBottom) { 129 return false; 130 } 131 132 // Now we actually perform the chop, removing the excess to the top and 133 // bottom of the bounds (keeping our new line "in phase" with the dash, 134 // hence the (mod intervalLength). 135 136 if (minY < bounds.fTop) { 137 minY = bounds.fTop - SkScalarMod(bounds.fTop - minY, intervalLength); 138 } 139 if (maxY > bounds.fBottom) { 140 maxY = bounds.fBottom + SkScalarMod(maxY - bounds.fBottom, intervalLength); 141 } 142 143 SkASSERT(maxY > minY); 144 if (dy < 0) { 145 SkTSwap(minY, maxY); 146 } 147 pts[0].fY = minY; 148 pts[1].fY = maxY; 149 } 150 151 return true; 152} 153 154// Currently asPoints is more restrictive then it needs to be. In the future 155// we need to: 156// allow kRound_Cap capping (could allow rotations in the matrix with this) 157// allow paths to be returned 158bool SkDashImpl::asPoints(PointData* results, const SkPath& src, const SkStrokeRec& rec, 159 const SkMatrix& matrix, const SkRect* cullRect) const { 160 // width < 0 -> fill && width == 0 -> hairline so requiring width > 0 rules both out 161 if (0 >= rec.getWidth()) { 162 return false; 163 } 164 165 // TODO: this next test could be eased up. We could allow any number of 166 // intervals as long as all the ons match and all the offs match. 167 // Additionally, they do not necessarily need to be integers. 168 // We cannot allow arbitrary intervals since we want the returned points 169 // to be uniformly sized. 170 if (fCount != 2 || 171 !SkScalarNearlyEqual(fIntervals[0], fIntervals[1]) || 172 !SkScalarIsInt(fIntervals[0]) || 173 !SkScalarIsInt(fIntervals[1])) { 174 return false; 175 } 176 177 SkPoint pts[2]; 178 179 if (!src.isLine(pts)) { 180 return false; 181 } 182 183 // TODO: this test could be eased up to allow circles 184 if (SkPaint::kButt_Cap != rec.getCap()) { 185 return false; 186 } 187 188 // TODO: this test could be eased up for circles. Rotations could be allowed. 189 if (!matrix.rectStaysRect()) { 190 return false; 191 } 192 193 // See if the line can be limited to something plausible. 194 if (!cull_line(pts, rec, matrix, cullRect, fIntervalLength)) { 195 return false; 196 } 197 198 SkScalar length = SkPoint::Distance(pts[1], pts[0]); 199 200 SkVector tangent = pts[1] - pts[0]; 201 if (tangent.isZero()) { 202 return false; 203 } 204 205 tangent.scale(SkScalarInvert(length)); 206 207 // TODO: make this test for horizontal & vertical lines more robust 208 bool isXAxis = true; 209 if (SkScalarNearlyEqual(SK_Scalar1, tangent.fX) || 210 SkScalarNearlyEqual(-SK_Scalar1, tangent.fX)) { 211 results->fSize.set(SkScalarHalf(fIntervals[0]), SkScalarHalf(rec.getWidth())); 212 } else if (SkScalarNearlyEqual(SK_Scalar1, tangent.fY) || 213 SkScalarNearlyEqual(-SK_Scalar1, tangent.fY)) { 214 results->fSize.set(SkScalarHalf(rec.getWidth()), SkScalarHalf(fIntervals[0])); 215 isXAxis = false; 216 } else if (SkPaint::kRound_Cap != rec.getCap()) { 217 // Angled lines don't have axis-aligned boxes. 218 return false; 219 } 220 221 if (results) { 222 results->fFlags = 0; 223 SkScalar clampedInitialDashLength = SkMinScalar(length, fInitialDashLength); 224 225 if (SkPaint::kRound_Cap == rec.getCap()) { 226 results->fFlags |= PointData::kCircles_PointFlag; 227 } 228 229 results->fNumPoints = 0; 230 SkScalar len2 = length; 231 if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) { 232 SkASSERT(len2 >= clampedInitialDashLength); 233 if (0 == fInitialDashIndex) { 234 if (clampedInitialDashLength > 0) { 235 if (clampedInitialDashLength >= fIntervals[0]) { 236 ++results->fNumPoints; // partial first dash 237 } 238 len2 -= clampedInitialDashLength; 239 } 240 len2 -= fIntervals[1]; // also skip first space 241 if (len2 < 0) { 242 len2 = 0; 243 } 244 } else { 245 len2 -= clampedInitialDashLength; // skip initial partial empty 246 } 247 } 248 // Too many midpoints can cause results->fNumPoints to overflow or 249 // otherwise cause the results->fPoints allocation below to OOM. 250 // Cap it to a sane value. 251 SkScalar numIntervals = len2 / fIntervalLength; 252 if (!SkScalarIsFinite(numIntervals) || numIntervals > SkDashPath::kMaxDashCount) { 253 return false; 254 } 255 int numMidPoints = SkScalarFloorToInt(numIntervals); 256 results->fNumPoints += numMidPoints; 257 len2 -= numMidPoints * fIntervalLength; 258 bool partialLast = false; 259 if (len2 > 0) { 260 if (len2 < fIntervals[0]) { 261 partialLast = true; 262 } else { 263 ++numMidPoints; 264 ++results->fNumPoints; 265 } 266 } 267 268 results->fPoints = new SkPoint[results->fNumPoints]; 269 270 SkScalar distance = 0; 271 int curPt = 0; 272 273 if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) { 274 SkASSERT(clampedInitialDashLength <= length); 275 276 if (0 == fInitialDashIndex) { 277 if (clampedInitialDashLength > 0) { 278 // partial first block 279 SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles 280 SkScalar x = pts[0].fX + tangent.fX * SkScalarHalf(clampedInitialDashLength); 281 SkScalar y = pts[0].fY + tangent.fY * SkScalarHalf(clampedInitialDashLength); 282 SkScalar halfWidth, halfHeight; 283 if (isXAxis) { 284 halfWidth = SkScalarHalf(clampedInitialDashLength); 285 halfHeight = SkScalarHalf(rec.getWidth()); 286 } else { 287 halfWidth = SkScalarHalf(rec.getWidth()); 288 halfHeight = SkScalarHalf(clampedInitialDashLength); 289 } 290 if (clampedInitialDashLength < fIntervals[0]) { 291 // This one will not be like the others 292 results->fFirst.addRect(x - halfWidth, y - halfHeight, 293 x + halfWidth, y + halfHeight); 294 } else { 295 SkASSERT(curPt < results->fNumPoints); 296 results->fPoints[curPt].set(x, y); 297 ++curPt; 298 } 299 300 distance += clampedInitialDashLength; 301 } 302 303 distance += fIntervals[1]; // skip over the next blank block too 304 } else { 305 distance += clampedInitialDashLength; 306 } 307 } 308 309 if (0 != numMidPoints) { 310 distance += SkScalarHalf(fIntervals[0]); 311 312 for (int i = 0; i < numMidPoints; ++i) { 313 SkScalar x = pts[0].fX + tangent.fX * distance; 314 SkScalar y = pts[0].fY + tangent.fY * distance; 315 316 SkASSERT(curPt < results->fNumPoints); 317 results->fPoints[curPt].set(x, y); 318 ++curPt; 319 320 distance += fIntervalLength; 321 } 322 323 distance -= SkScalarHalf(fIntervals[0]); 324 } 325 326 if (partialLast) { 327 // partial final block 328 SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles 329 SkScalar temp = length - distance; 330 SkASSERT(temp < fIntervals[0]); 331 SkScalar x = pts[0].fX + tangent.fX * (distance + SkScalarHalf(temp)); 332 SkScalar y = pts[0].fY + tangent.fY * (distance + SkScalarHalf(temp)); 333 SkScalar halfWidth, halfHeight; 334 if (isXAxis) { 335 halfWidth = SkScalarHalf(temp); 336 halfHeight = SkScalarHalf(rec.getWidth()); 337 } else { 338 halfWidth = SkScalarHalf(rec.getWidth()); 339 halfHeight = SkScalarHalf(temp); 340 } 341 results->fLast.addRect(x - halfWidth, y - halfHeight, 342 x + halfWidth, y + halfHeight); 343 } 344 345 SkASSERT(curPt == results->fNumPoints); 346 } 347 348 return true; 349} 350 351SkPathEffect::DashType SkDashImpl::asADash(DashInfo* info) const { 352 if (info) { 353 if (info->fCount >= fCount && info->fIntervals) { 354 memcpy(info->fIntervals, fIntervals, fCount * sizeof(SkScalar)); 355 } 356 info->fCount = fCount; 357 info->fPhase = fPhase; 358 } 359 return kDash_DashType; 360} 361 362void SkDashImpl::flatten(SkWriteBuffer& buffer) const { 363 buffer.writeScalar(fPhase); 364 buffer.writeScalarArray(fIntervals, fCount); 365} 366 367sk_sp<SkFlattenable> SkDashImpl::CreateProc(SkReadBuffer& buffer) { 368 const SkScalar phase = buffer.readScalar(); 369 uint32_t count = buffer.getArrayCount(); 370 SkAutoSTArray<32, SkScalar> intervals(count); 371 if (buffer.readScalarArray(intervals.get(), count)) { 372 return SkDashPathEffect::Make(intervals.get(), SkToInt(count), phase); 373 } 374 return nullptr; 375} 376 377#ifndef SK_IGNORE_TO_STRING 378void SkDashImpl::toString(SkString* str) const { 379 str->appendf("SkDashPathEffect: ("); 380 str->appendf("count: %d phase %.2f intervals: (", fCount, fPhase); 381 for (int i = 0; i < fCount; ++i) { 382 str->appendf("%.2f", fIntervals[i]); 383 if (i < fCount-1) { 384 str->appendf(", "); 385 } 386 } 387 str->appendf("))"); 388} 389#endif 390 391////////////////////////////////////////////////////////////////////////////////////////////////// 392 393sk_sp<SkPathEffect> SkDashPathEffect::Make(const SkScalar intervals[], int count, SkScalar phase) { 394 if (!SkDashPath::ValidDashPath(phase, intervals, count)) { 395 return nullptr; 396 } 397 return sk_sp<SkPathEffect>(new SkDashImpl(intervals, count, phase)); 398} 399