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