1 /* libs/android_runtime/android/graphics/Path.cpp 2 ** 3 ** Copyright 2006, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 // This file was generated from the C++ include file: SkPath.h 19 // Any changes made to this file will be discarded by the build. 20 // To change this file, either edit the include, or device/tools/gluemaker/main.cpp, 21 // or one of the auxilary file specifications in device/tools/gluemaker. 22 23 #include "jni.h" 24 #include "GraphicsJNI.h" 25 #include "core_jni_helpers.h" 26 27 #include "SkPath.h" 28 #include "SkPathOps.h" 29 #include "SkGeometry.h" // WARNING: Internal Skia Header 30 31 #include <Caches.h> 32 #include <vector> 33 #include <map> 34 35 namespace android { 36 37 class SkPathGlue { 38 public: 39 40 static void finalizer(SkPath* obj) { 41 // Purge entries from the HWUI path cache if this path's data is unique 42 if (obj->unique() && android::uirenderer::Caches::hasInstance()) { 43 android::uirenderer::Caches::getInstance().pathCache.removeDeferred(obj); 44 } 45 delete obj; 46 } 47 48 // ---------------- Regular JNI ----------------------------- 49 50 static jlong init(JNIEnv* env, jclass clazz) { 51 return reinterpret_cast<jlong>(new SkPath()); 52 } 53 54 static jlong init_Path(JNIEnv* env, jclass clazz, jlong valHandle) { 55 SkPath* val = reinterpret_cast<SkPath*>(valHandle); 56 return reinterpret_cast<jlong>(new SkPath(*val)); 57 } 58 59 static jlong getFinalizer(JNIEnv* env, jclass clazz) { 60 return static_cast<jlong>(reinterpret_cast<uintptr_t>(&finalizer)); 61 } 62 63 static void set(JNIEnv* env, jclass clazz, jlong dstHandle, jlong srcHandle) { 64 SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); 65 const SkPath* src = reinterpret_cast<SkPath*>(srcHandle); 66 *dst = *src; 67 } 68 69 static void computeBounds(JNIEnv* env, jclass clazz, jlong objHandle, jobject jbounds) { 70 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 71 const SkRect& bounds = obj->getBounds(); 72 GraphicsJNI::rect_to_jrectf(bounds, env, jbounds); 73 } 74 75 static void incReserve(JNIEnv* env, jclass clazz, jlong objHandle, jint extraPtCount) { 76 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 77 obj->incReserve(extraPtCount); 78 } 79 80 static void moveTo__FF(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x, jfloat y) { 81 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 82 obj->moveTo(x, y); 83 } 84 85 static void rMoveTo(JNIEnv* env, jclass clazz, jlong objHandle, jfloat dx, jfloat dy) { 86 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 87 obj->rMoveTo(dx, dy); 88 } 89 90 static void lineTo__FF(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x, jfloat y) { 91 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 92 obj->lineTo(x, y); 93 } 94 95 static void rLineTo(JNIEnv* env, jclass clazz, jlong objHandle, jfloat dx, jfloat dy) { 96 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 97 obj->rLineTo(dx, dy); 98 } 99 100 static void quadTo__FFFF(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x1, jfloat y1, 101 jfloat x2, jfloat y2) { 102 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 103 obj->quadTo(x1, y1, x2, y2); 104 } 105 106 static void rQuadTo(JNIEnv* env, jclass clazz, jlong objHandle, jfloat dx1, jfloat dy1, 107 jfloat dx2, jfloat dy2) { 108 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 109 obj->rQuadTo(dx1, dy1, dx2, dy2); 110 } 111 112 static void cubicTo__FFFFFF(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x1, jfloat y1, 113 jfloat x2, jfloat y2, jfloat x3, jfloat y3) { 114 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 115 obj->cubicTo(x1, y1, x2, y2, x3, y3); 116 } 117 118 static void rCubicTo(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x1, jfloat y1, 119 jfloat x2, jfloat y2, jfloat x3, jfloat y3) { 120 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 121 obj->rCubicTo(x1, y1, x2, y2, x3, y3); 122 } 123 124 static void arcTo(JNIEnv* env, jclass clazz, jlong objHandle, jfloat left, jfloat top, 125 jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle, 126 jboolean forceMoveTo) { 127 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 128 SkRect oval = SkRect::MakeLTRB(left, top, right, bottom); 129 obj->arcTo(oval, startAngle, sweepAngle, forceMoveTo); 130 } 131 132 static void close(JNIEnv* env, jclass clazz, jlong objHandle) { 133 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 134 obj->close(); 135 } 136 137 static void addRect(JNIEnv* env, jclass clazz, jlong objHandle, 138 jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) { 139 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 140 SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); 141 obj->addRect(left, top, right, bottom, dir); 142 } 143 144 static void addOval(JNIEnv* env, jclass clazz, jlong objHandle, 145 jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) { 146 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 147 SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); 148 SkRect oval = SkRect::MakeLTRB(left, top, right, bottom); 149 obj->addOval(oval, dir); 150 } 151 152 static void addCircle(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x, jfloat y, 153 jfloat radius, jint dirHandle) { 154 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 155 SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); 156 obj->addCircle(x, y, radius, dir); 157 } 158 159 static void addArc(JNIEnv* env, jclass clazz, jlong objHandle, jfloat left, jfloat top, 160 jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle) { 161 SkRect oval = SkRect::MakeLTRB(left, top, right, bottom); 162 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 163 obj->addArc(oval, startAngle, sweepAngle); 164 } 165 166 static void addRoundRectXY(JNIEnv* env, jclass clazz, jlong objHandle, jfloat left, jfloat top, 167 jfloat right, jfloat bottom, jfloat rx, jfloat ry, jint dirHandle) { 168 SkRect rect = SkRect::MakeLTRB(left, top, right, bottom); 169 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 170 SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); 171 obj->addRoundRect(rect, rx, ry, dir); 172 } 173 174 static void addRoundRect8(JNIEnv* env, jclass clazz, jlong objHandle, jfloat left, jfloat top, 175 jfloat right, jfloat bottom, jfloatArray array, jint dirHandle) { 176 SkRect rect = SkRect::MakeLTRB(left, top, right, bottom); 177 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 178 SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); 179 AutoJavaFloatArray afa(env, array, 8); 180 #ifdef SK_SCALAR_IS_FLOAT 181 const float* src = afa.ptr(); 182 #else 183 #error Need to convert float array to SkScalar array before calling the following function. 184 #endif 185 obj->addRoundRect(rect, src, dir); 186 } 187 188 static void addPath__PathFF(JNIEnv* env, jclass clazz, jlong objHandle, jlong srcHandle, 189 jfloat dx, jfloat dy) { 190 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 191 SkPath* src = reinterpret_cast<SkPath*>(srcHandle); 192 obj->addPath(*src, dx, dy); 193 } 194 195 static void addPath__Path(JNIEnv* env, jclass clazz, jlong objHandle, jlong srcHandle) { 196 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 197 SkPath* src = reinterpret_cast<SkPath*>(srcHandle); 198 obj->addPath(*src); 199 } 200 201 static void addPath__PathMatrix(JNIEnv* env, jclass clazz, jlong objHandle, jlong srcHandle, 202 jlong matrixHandle) { 203 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 204 SkPath* src = reinterpret_cast<SkPath*>(srcHandle); 205 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 206 obj->addPath(*src, *matrix); 207 } 208 209 static void offset__FF(JNIEnv* env, jclass clazz, jlong objHandle, jfloat dx, jfloat dy) { 210 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 211 obj->offset(dx, dy); 212 } 213 214 static void setLastPoint(JNIEnv* env, jclass clazz, jlong objHandle, jfloat dx, jfloat dy) { 215 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 216 obj->setLastPt(dx, dy); 217 } 218 219 static void transform__MatrixPath(JNIEnv* env, jclass clazz, jlong objHandle, jlong matrixHandle, 220 jlong dstHandle) { 221 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 222 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 223 SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); 224 obj->transform(*matrix, dst); 225 } 226 227 static void transform__Matrix(JNIEnv* env, jclass clazz, jlong objHandle, jlong matrixHandle) { 228 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 229 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 230 obj->transform(*matrix); 231 } 232 233 static jboolean op(JNIEnv* env, jclass clazz, jlong p1Handle, jlong p2Handle, jint opHandle, 234 jlong rHandle) { 235 SkPath* p1 = reinterpret_cast<SkPath*>(p1Handle); 236 SkPath* p2 = reinterpret_cast<SkPath*>(p2Handle); 237 SkPathOp op = static_cast<SkPathOp>(opHandle); 238 SkPath* r = reinterpret_cast<SkPath*>(rHandle); 239 return Op(*p1, *p2, op, r); 240 } 241 242 typedef SkPoint (*bezierCalculation)(float t, const SkPoint* points); 243 244 static void addMove(std::vector<SkPoint>& segmentPoints, std::vector<float>& lengths, 245 const SkPoint& point) { 246 float length = 0; 247 if (!lengths.empty()) { 248 length = lengths.back(); 249 } 250 segmentPoints.push_back(point); 251 lengths.push_back(length); 252 } 253 254 static void addLine(std::vector<SkPoint>& segmentPoints, std::vector<float>& lengths, 255 const SkPoint& toPoint) { 256 if (segmentPoints.empty()) { 257 segmentPoints.push_back(SkPoint::Make(0, 0)); 258 lengths.push_back(0); 259 } else if (segmentPoints.back() == toPoint) { 260 return; // Empty line 261 } 262 float length = lengths.back() + SkPoint::Distance(segmentPoints.back(), toPoint); 263 segmentPoints.push_back(toPoint); 264 lengths.push_back(length); 265 } 266 267 static float cubicCoordinateCalculation(float t, float p0, float p1, float p2, float p3) { 268 float oneMinusT = 1 - t; 269 float oneMinusTSquared = oneMinusT * oneMinusT; 270 float oneMinusTCubed = oneMinusTSquared * oneMinusT; 271 float tSquared = t * t; 272 float tCubed = tSquared * t; 273 return (oneMinusTCubed * p0) + (3 * oneMinusTSquared * t * p1) 274 + (3 * oneMinusT * tSquared * p2) + (tCubed * p3); 275 } 276 277 static SkPoint cubicBezierCalculation(float t, const SkPoint* points) { 278 float x = cubicCoordinateCalculation(t, points[0].x(), points[1].x(), 279 points[2].x(), points[3].x()); 280 float y = cubicCoordinateCalculation(t, points[0].y(), points[1].y(), 281 points[2].y(), points[3].y()); 282 return SkPoint::Make(x, y); 283 } 284 285 static float quadraticCoordinateCalculation(float t, float p0, float p1, float p2) { 286 float oneMinusT = 1 - t; 287 return oneMinusT * ((oneMinusT * p0) + (t * p1)) + t * ((oneMinusT * p1) + (t * p2)); 288 } 289 290 static SkPoint quadraticBezierCalculation(float t, const SkPoint* points) { 291 float x = quadraticCoordinateCalculation(t, points[0].x(), points[1].x(), points[2].x()); 292 float y = quadraticCoordinateCalculation(t, points[0].y(), points[1].y(), points[2].y()); 293 return SkPoint::Make(x, y); 294 } 295 296 // Subdivide a section of the Bezier curve, set the mid-point and the mid-t value. 297 // Returns true if further subdivision is necessary as defined by errorSquared. 298 static bool subdividePoints(const SkPoint* points, bezierCalculation bezierFunction, 299 float t0, const SkPoint &p0, float t1, const SkPoint &p1, 300 float& midT, SkPoint &midPoint, float errorSquared) { 301 midT = (t1 + t0) / 2; 302 float midX = (p1.x() + p0.x()) / 2; 303 float midY = (p1.y() + p0.y()) / 2; 304 305 midPoint = (*bezierFunction)(midT, points); 306 float xError = midPoint.x() - midX; 307 float yError = midPoint.y() - midY; 308 float midErrorSquared = (xError * xError) + (yError * yError); 309 return midErrorSquared > errorSquared; 310 } 311 312 // Divides Bezier curves until linear interpolation is very close to accurate, using 313 // errorSquared as a metric. Cubic Bezier curves can have an inflection point that improperly 314 // short-circuit subdivision. If you imagine an S shape, the top and bottom points being the 315 // starting and end points, linear interpolation would mark the center where the curve places 316 // the point. It is clearly not the case that we can linearly interpolate at that point. 317 // doubleCheckDivision forces a second examination between subdivisions to ensure that linear 318 // interpolation works. 319 static void addBezier(const SkPoint* points, 320 bezierCalculation bezierFunction, std::vector<SkPoint>& segmentPoints, 321 std::vector<float>& lengths, float errorSquared, bool doubleCheckDivision) { 322 typedef std::map<float, SkPoint> PointMap; 323 PointMap tToPoint; 324 325 tToPoint[0] = (*bezierFunction)(0, points); 326 tToPoint[1] = (*bezierFunction)(1, points); 327 328 PointMap::iterator iter = tToPoint.begin(); 329 PointMap::iterator next = iter; 330 ++next; 331 while (next != tToPoint.end()) { 332 bool needsSubdivision = true; 333 SkPoint midPoint; 334 do { 335 float midT; 336 needsSubdivision = subdividePoints(points, bezierFunction, iter->first, 337 iter->second, next->first, next->second, midT, midPoint, errorSquared); 338 if (!needsSubdivision && doubleCheckDivision) { 339 SkPoint quarterPoint; 340 float quarterT; 341 needsSubdivision = subdividePoints(points, bezierFunction, iter->first, 342 iter->second, midT, midPoint, quarterT, quarterPoint, errorSquared); 343 if (needsSubdivision) { 344 // Found an inflection point. No need to double-check. 345 doubleCheckDivision = false; 346 } 347 } 348 if (needsSubdivision) { 349 next = tToPoint.insert(iter, PointMap::value_type(midT, midPoint)); 350 } 351 } while (needsSubdivision); 352 iter = next; 353 next++; 354 } 355 356 // Now that each division can use linear interpolation with less than the allowed error 357 for (iter = tToPoint.begin(); iter != tToPoint.end(); ++iter) { 358 addLine(segmentPoints, lengths, iter->second); 359 } 360 } 361 362 static void createVerbSegments(const SkPath::Iter& pathIter, SkPath::Verb verb, 363 const SkPoint* points, std::vector<SkPoint>& segmentPoints, 364 std::vector<float>& lengths, float errorSquared, float errorConic) { 365 switch (verb) { 366 case SkPath::kMove_Verb: 367 addMove(segmentPoints, lengths, points[0]); 368 break; 369 case SkPath::kClose_Verb: 370 addLine(segmentPoints, lengths, points[0]); 371 break; 372 case SkPath::kLine_Verb: 373 addLine(segmentPoints, lengths, points[1]); 374 break; 375 case SkPath::kQuad_Verb: 376 addBezier(points, quadraticBezierCalculation, segmentPoints, lengths, 377 errorSquared, false); 378 break; 379 case SkPath::kCubic_Verb: 380 addBezier(points, cubicBezierCalculation, segmentPoints, lengths, 381 errorSquared, true); 382 break; 383 case SkPath::kConic_Verb: { 384 SkAutoConicToQuads converter; 385 const SkPoint* quads = converter.computeQuads( 386 points, pathIter.conicWeight(), errorConic); 387 for (int i = 0; i < converter.countQuads(); i++) { 388 // Note: offset each subsequent quad by 2, since end points are shared 389 const SkPoint* quad = quads + i * 2; 390 addBezier(quad, quadraticBezierCalculation, segmentPoints, lengths, 391 errorConic, false); 392 } 393 break; 394 } 395 default: 396 static_assert(SkPath::kMove_Verb == 0 397 && SkPath::kLine_Verb == 1 398 && SkPath::kQuad_Verb == 2 399 && SkPath::kConic_Verb == 3 400 && SkPath::kCubic_Verb == 4 401 && SkPath::kClose_Verb == 5 402 && SkPath::kDone_Verb == 6, 403 "Path enum changed, new types may have been added."); 404 break; 405 } 406 } 407 408 // Returns a float[] with each point along the path represented by 3 floats 409 // * fractional length along the path that the point resides 410 // * x coordinate 411 // * y coordinate 412 // Note that more than one point may have the same length along the path in 413 // the case of a move. 414 // NULL can be returned if the Path is empty. 415 static jfloatArray approximate(JNIEnv* env, jclass clazz, jlong pathHandle, 416 float acceptableError) { 417 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 418 SkASSERT(path); 419 SkPath::Iter pathIter(*path, false); 420 SkPath::Verb verb; 421 SkPoint points[4]; 422 std::vector<SkPoint> segmentPoints; 423 std::vector<float> lengths; 424 float errorSquared = acceptableError * acceptableError; 425 float errorConic = acceptableError / 2; // somewhat arbitrary 426 427 while ((verb = pathIter.next(points, false)) != SkPath::kDone_Verb) { 428 createVerbSegments(pathIter, verb, points, segmentPoints, lengths, 429 errorSquared, errorConic); 430 } 431 432 if (segmentPoints.empty()) { 433 int numVerbs = path->countVerbs(); 434 if (numVerbs == 1) { 435 addMove(segmentPoints, lengths, path->getPoint(0)); 436 } else { 437 // Invalid or empty path. Fall back to point(0,0) 438 addMove(segmentPoints, lengths, SkPoint()); 439 } 440 } 441 442 float totalLength = lengths.back(); 443 if (totalLength == 0) { 444 // Lone Move instructions should still be able to animate at the same value. 445 segmentPoints.push_back(segmentPoints.back()); 446 lengths.push_back(1); 447 totalLength = 1; 448 } 449 450 size_t numPoints = segmentPoints.size(); 451 size_t approximationArraySize = numPoints * 3; 452 453 float* approximation = new float[approximationArraySize]; 454 455 int approximationIndex = 0; 456 for (size_t i = 0; i < numPoints; i++) { 457 const SkPoint& point = segmentPoints[i]; 458 approximation[approximationIndex++] = lengths[i] / totalLength; 459 approximation[approximationIndex++] = point.x(); 460 approximation[approximationIndex++] = point.y(); 461 } 462 463 jfloatArray result = env->NewFloatArray(approximationArraySize); 464 env->SetFloatArrayRegion(result, 0, approximationArraySize, approximation); 465 delete[] approximation; 466 return result; 467 } 468 469 // ---------------- @FastNative ----------------------------- 470 471 static jboolean isRect(JNIEnv* env, jclass clazz, jlong objHandle, jobject jrect) { 472 SkRect rect; 473 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 474 jboolean result = obj->isRect(&rect); 475 if (jrect) { 476 GraphicsJNI::rect_to_jrectf(rect, env, jrect); 477 } 478 return result; 479 } 480 481 // ---------------- @CriticalNative ------------------------- 482 483 static void reset(jlong objHandle) { 484 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 485 obj->reset(); 486 } 487 488 static void rewind(jlong objHandle) { 489 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 490 obj->rewind(); 491 } 492 493 static jboolean isEmpty(jlong objHandle) { 494 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 495 return obj->isEmpty(); 496 } 497 498 static jboolean isConvex(jlong objHandle) { 499 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 500 return obj->isConvex(); 501 } 502 503 static jint getFillType(jlong objHandle) { 504 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 505 return obj->getFillType(); 506 } 507 508 static void setFillType(jlong pathHandle, jint ftHandle) {; 509 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 510 SkPath::FillType ft = static_cast<SkPath::FillType>(ftHandle); 511 path->setFillType(ft); 512 } 513 }; 514 515 static const JNINativeMethod methods[] = { 516 {"nInit","()J", (void*) SkPathGlue::init}, 517 {"nInit","(J)J", (void*) SkPathGlue::init_Path}, 518 {"nGetFinalizer", "()J", (void*) SkPathGlue::getFinalizer}, 519 {"nSet","(JJ)V", (void*) SkPathGlue::set}, 520 {"nComputeBounds","(JLandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds}, 521 {"nIncReserve","(JI)V", (void*) SkPathGlue::incReserve}, 522 {"nMoveTo","(JFF)V", (void*) SkPathGlue::moveTo__FF}, 523 {"nRMoveTo","(JFF)V", (void*) SkPathGlue::rMoveTo}, 524 {"nLineTo","(JFF)V", (void*) SkPathGlue::lineTo__FF}, 525 {"nRLineTo","(JFF)V", (void*) SkPathGlue::rLineTo}, 526 {"nQuadTo","(JFFFF)V", (void*) SkPathGlue::quadTo__FFFF}, 527 {"nRQuadTo","(JFFFF)V", (void*) SkPathGlue::rQuadTo}, 528 {"nCubicTo","(JFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF}, 529 {"nRCubicTo","(JFFFFFF)V", (void*) SkPathGlue::rCubicTo}, 530 {"nArcTo","(JFFFFFFZ)V", (void*) SkPathGlue::arcTo}, 531 {"nClose","(J)V", (void*) SkPathGlue::close}, 532 {"nAddRect","(JFFFFI)V", (void*) SkPathGlue::addRect}, 533 {"nAddOval","(JFFFFI)V", (void*) SkPathGlue::addOval}, 534 {"nAddCircle","(JFFFI)V", (void*) SkPathGlue::addCircle}, 535 {"nAddArc","(JFFFFFF)V", (void*) SkPathGlue::addArc}, 536 {"nAddRoundRect","(JFFFFFFI)V", (void*) SkPathGlue::addRoundRectXY}, 537 {"nAddRoundRect","(JFFFF[FI)V", (void*) SkPathGlue::addRoundRect8}, 538 {"nAddPath","(JJFF)V", (void*) SkPathGlue::addPath__PathFF}, 539 {"nAddPath","(JJ)V", (void*) SkPathGlue::addPath__Path}, 540 {"nAddPath","(JJJ)V", (void*) SkPathGlue::addPath__PathMatrix}, 541 {"nOffset","(JFF)V", (void*) SkPathGlue::offset__FF}, 542 {"nSetLastPoint","(JFF)V", (void*) SkPathGlue::setLastPoint}, 543 {"nTransform","(JJJ)V", (void*) SkPathGlue::transform__MatrixPath}, 544 {"nTransform","(JJ)V", (void*) SkPathGlue::transform__Matrix}, 545 {"nOp","(JJIJ)Z", (void*) SkPathGlue::op}, 546 {"nApproximate", "(JF)[F", (void*) SkPathGlue::approximate}, 547 548 // ------- @FastNative below here ---------------------- 549 {"nIsRect","(JLandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect}, 550 551 // ------- @CriticalNative below here ------------------ 552 {"nReset","(J)V", (void*) SkPathGlue::reset}, 553 {"nRewind","(J)V", (void*) SkPathGlue::rewind}, 554 {"nIsEmpty","(J)Z", (void*) SkPathGlue::isEmpty}, 555 {"nIsConvex","(J)Z", (void*) SkPathGlue::isConvex}, 556 {"nGetFillType","(J)I", (void*) SkPathGlue::getFillType}, 557 {"nSetFillType","(JI)V", (void*) SkPathGlue::setFillType}, 558 }; 559 560 int register_android_graphics_Path(JNIEnv* env) { 561 return RegisterMethodsOrDie(env, "android/graphics/Path", methods, NELEM(methods)); 562 563 static_assert(0 == SkPath::kCW_Direction, "direction_mismatch"); 564 static_assert(1 == SkPath::kCCW_Direction, "direction_mismatch"); 565 } 566 567 } 568
