SkiaCanvas.cpp revision 60126efd7d905ca24822765c6dafac17fef278ab
1/* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "Canvas.h" 18 19#include <SkCanvas.h> 20#include <SkClipStack.h> 21#include <SkDevice.h> 22#include <SkDeque.h> 23#include <SkDrawFilter.h> 24#include <SkGraphics.h> 25#include <SkShader.h> 26#include <SkTArray.h> 27#include <SkTemplates.h> 28 29#include <memory> 30 31namespace android { 32 33// Holds an SkCanvas reference plus additional native data. 34class SkiaCanvas : public Canvas { 35public: 36 explicit SkiaCanvas(const SkBitmap& bitmap); 37 38 /** 39 * Create a new SkiaCanvas. 40 * 41 * @param canvas SkCanvas to handle calls made to this SkiaCanvas. Must 42 * not be NULL. This constructor will ref() the SkCanvas, and unref() 43 * it in its destructor. 44 */ 45 explicit SkiaCanvas(SkCanvas* canvas) : mCanvas(canvas) { 46 SkASSERT(canvas); 47 canvas->ref(); 48 } 49 50 virtual SkCanvas* asSkCanvas() override { 51 return mCanvas.get(); 52 } 53 54 virtual void setBitmap(const SkBitmap& bitmap) override; 55 56 virtual bool isOpaque() override; 57 virtual int width() override; 58 virtual int height() override; 59 60 virtual void setHighContrastText(bool highContrastText) override { 61 mHighContrastText = highContrastText; 62 } 63 virtual bool isHighContrastText() override { return mHighContrastText; } 64 65 virtual int getSaveCount() const override; 66 virtual int save(SkCanvas::SaveFlags flags) override; 67 virtual void restore() override; 68 virtual void restoreToCount(int saveCount) override; 69 70 virtual int saveLayer(float left, float top, float right, float bottom, 71 const SkPaint* paint, SkCanvas::SaveFlags flags) override; 72 virtual int saveLayerAlpha(float left, float top, float right, float bottom, 73 int alpha, SkCanvas::SaveFlags flags) override; 74 75 virtual void getMatrix(SkMatrix* outMatrix) const override; 76 virtual void setMatrix(const SkMatrix& matrix) override; 77 virtual void setLocalMatrix(const SkMatrix& matrix) override { this->setMatrix(matrix); } 78 virtual void concat(const SkMatrix& matrix) override; 79 virtual void rotate(float degrees) override; 80 virtual void scale(float sx, float sy) override; 81 virtual void skew(float sx, float sy) override; 82 virtual void translate(float dx, float dy) override; 83 84 virtual bool getClipBounds(SkRect* outRect) const override; 85 virtual bool quickRejectRect(float left, float top, float right, float bottom) const override; 86 virtual bool quickRejectPath(const SkPath& path) const override; 87 virtual bool clipRect(float left, float top, float right, float bottom, 88 SkRegion::Op op) override; 89 virtual bool clipPath(const SkPath* path, SkRegion::Op op) override; 90 virtual bool clipRegion(const SkRegion* region, SkRegion::Op op) override; 91 92 virtual SkDrawFilter* getDrawFilter() override; 93 virtual void setDrawFilter(SkDrawFilter* drawFilter) override; 94 95 virtual void drawColor(int color, SkXfermode::Mode mode) override; 96 virtual void drawPaint(const SkPaint& paint) override; 97 98 virtual void drawPoint(float x, float y, const SkPaint& paint) override; 99 virtual void drawPoints(const float* points, int count, const SkPaint& paint) override; 100 virtual void drawLine(float startX, float startY, float stopX, float stopY, 101 const SkPaint& paint) override; 102 virtual void drawLines(const float* points, int count, const SkPaint& paint) override; 103 virtual void drawRect(float left, float top, float right, float bottom, 104 const SkPaint& paint) override; 105 virtual void drawRegion(const SkRegion& region, const SkPaint& paint) override; 106 virtual void drawRoundRect(float left, float top, float right, float bottom, 107 float rx, float ry, const SkPaint& paint) override; 108 virtual void drawCircle(float x, float y, float radius, const SkPaint& paint) override; 109 virtual void drawOval(float left, float top, float right, float bottom, 110 const SkPaint& paint) override; 111 virtual void drawArc(float left, float top, float right, float bottom, 112 float startAngle, float sweepAngle, bool useCenter, const SkPaint& paint) override; 113 virtual void drawPath(const SkPath& path, const SkPaint& paint) override; 114 virtual void drawVertices(SkCanvas::VertexMode vertexMode, int vertexCount, 115 const float* verts, const float* tex, const int* colors, 116 const uint16_t* indices, int indexCount, const SkPaint& paint) override; 117 118 virtual void drawBitmap(const SkBitmap& bitmap, float left, float top, 119 const SkPaint* paint) override; 120 virtual void drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix, 121 const SkPaint* paint) override; 122 virtual void drawBitmap(const SkBitmap& bitmap, float srcLeft, float srcTop, 123 float srcRight, float srcBottom, float dstLeft, float dstTop, 124 float dstRight, float dstBottom, const SkPaint* paint) override; 125 virtual void drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, int meshHeight, 126 const float* vertices, const int* colors, const SkPaint* paint) override; 127 128 virtual void drawText(const uint16_t* text, const float* positions, int count, 129 const SkPaint& paint, float x, float y, 130 float boundsLeft, float boundsTop, float boundsRight, float boundsBottom, 131 float totalAdvance) override; 132 virtual void drawPosText(const uint16_t* text, const float* positions, int count, 133 int posCount, const SkPaint& paint) override; 134 virtual void drawTextOnPath(const uint16_t* glyphs, int count, const SkPath& path, 135 float hOffset, float vOffset, const SkPaint& paint) override; 136 137 virtual bool drawTextAbsolutePos() const override { return true; } 138 139private: 140 struct SaveRec { 141 int saveCount; 142 SkCanvas::SaveFlags saveFlags; 143 }; 144 145 bool mHighContrastText = false; 146 147 void recordPartialSave(SkCanvas::SaveFlags flags); 148 void saveClipsForFrame(SkTArray<SkClipStack::Element>& clips, int frameSaveCount); 149 void applyClips(const SkTArray<SkClipStack::Element>& clips); 150 151 void drawPoints(const float* points, int count, const SkPaint& paint, 152 SkCanvas::PointMode mode); 153 void drawTextDecorations(float x, float y, float length, const SkPaint& paint); 154 155 SkAutoTUnref<SkCanvas> mCanvas; 156 std::unique_ptr<SkDeque> mSaveStack; // lazily allocated, tracks partial saves. 157}; 158 159Canvas* Canvas::create_canvas(const SkBitmap& bitmap) { 160 return new SkiaCanvas(bitmap); 161} 162 163Canvas* Canvas::create_canvas(SkCanvas* skiaCanvas) { 164 return new SkiaCanvas(skiaCanvas); 165} 166 167SkiaCanvas::SkiaCanvas(const SkBitmap& bitmap) { 168 mCanvas.reset(new SkCanvas(bitmap)); 169} 170 171// ---------------------------------------------------------------------------- 172// Canvas state operations: Replace Bitmap 173// ---------------------------------------------------------------------------- 174 175class ClipCopier : public SkCanvas::ClipVisitor { 176public: 177 ClipCopier(SkCanvas* dstCanvas) : m_dstCanvas(dstCanvas) {} 178 179 virtual void clipRect(const SkRect& rect, SkRegion::Op op, bool antialias) { 180 m_dstCanvas->clipRect(rect, op, antialias); 181 } 182 virtual void clipRRect(const SkRRect& rrect, SkRegion::Op op, bool antialias) { 183 m_dstCanvas->clipRRect(rrect, op, antialias); 184 } 185 virtual void clipPath(const SkPath& path, SkRegion::Op op, bool antialias) { 186 m_dstCanvas->clipPath(path, op, antialias); 187 } 188 189private: 190 SkCanvas* m_dstCanvas; 191}; 192 193void SkiaCanvas::setBitmap(const SkBitmap& bitmap) { 194 SkCanvas* newCanvas = new SkCanvas(bitmap); 195 SkASSERT(newCanvas); 196 197 if (!bitmap.isNull()) { 198 // Copy the canvas matrix & clip state. 199 newCanvas->setMatrix(mCanvas->getTotalMatrix()); 200 if (NULL != mCanvas->getDevice() && NULL != newCanvas->getDevice()) { 201 ClipCopier copier(newCanvas); 202 mCanvas->replayClips(&copier); 203 } 204 } 205 206 // unrefs the existing canvas 207 mCanvas.reset(newCanvas); 208 209 // clean up the old save stack 210 mSaveStack.reset(NULL); 211} 212 213// ---------------------------------------------------------------------------- 214// Canvas state operations 215// ---------------------------------------------------------------------------- 216 217bool SkiaCanvas::isOpaque() { 218 return mCanvas->getDevice()->accessBitmap(false).isOpaque(); 219} 220 221int SkiaCanvas::width() { 222 return mCanvas->getBaseLayerSize().width(); 223} 224 225int SkiaCanvas::height() { 226 return mCanvas->getBaseLayerSize().height(); 227} 228 229// ---------------------------------------------------------------------------- 230// Canvas state operations: Save (layer) 231// ---------------------------------------------------------------------------- 232 233int SkiaCanvas::getSaveCount() const { 234 return mCanvas->getSaveCount(); 235} 236 237int SkiaCanvas::save(SkCanvas::SaveFlags flags) { 238 int count = mCanvas->save(); 239 recordPartialSave(flags); 240 return count; 241} 242 243void SkiaCanvas::restore() { 244 const SaveRec* rec = (NULL == mSaveStack.get()) 245 ? NULL 246 : static_cast<SaveRec*>(mSaveStack->back()); 247 int currentSaveCount = mCanvas->getSaveCount() - 1; 248 SkASSERT(NULL == rec || currentSaveCount >= rec->saveCount); 249 250 if (NULL == rec || rec->saveCount != currentSaveCount) { 251 // Fast path - no record for this frame. 252 mCanvas->restore(); 253 return; 254 } 255 256 bool preserveMatrix = !(rec->saveFlags & SkCanvas::kMatrix_SaveFlag); 257 bool preserveClip = !(rec->saveFlags & SkCanvas::kClip_SaveFlag); 258 259 SkMatrix savedMatrix; 260 if (preserveMatrix) { 261 savedMatrix = mCanvas->getTotalMatrix(); 262 } 263 264 SkTArray<SkClipStack::Element> savedClips; 265 if (preserveClip) { 266 saveClipsForFrame(savedClips, currentSaveCount); 267 } 268 269 mCanvas->restore(); 270 271 if (preserveMatrix) { 272 mCanvas->setMatrix(savedMatrix); 273 } 274 275 if (preserveClip && !savedClips.empty()) { 276 applyClips(savedClips); 277 } 278 279 mSaveStack->pop_back(); 280} 281 282void SkiaCanvas::restoreToCount(int restoreCount) { 283 while (mCanvas->getSaveCount() > restoreCount) { 284 this->restore(); 285 } 286} 287 288int SkiaCanvas::saveLayer(float left, float top, float right, float bottom, 289 const SkPaint* paint, SkCanvas::SaveFlags flags) { 290 SkRect bounds = SkRect::MakeLTRB(left, top, right, bottom); 291 int count = mCanvas->saveLayer(&bounds, paint, flags | SkCanvas::kMatrixClip_SaveFlag); 292 recordPartialSave(flags); 293 return count; 294} 295 296int SkiaCanvas::saveLayerAlpha(float left, float top, float right, float bottom, 297 int alpha, SkCanvas::SaveFlags flags) { 298 SkRect bounds = SkRect::MakeLTRB(left, top, right, bottom); 299 int count = mCanvas->saveLayerAlpha(&bounds, alpha, flags | SkCanvas::kMatrixClip_SaveFlag); 300 recordPartialSave(flags); 301 return count; 302} 303 304// ---------------------------------------------------------------------------- 305// functions to emulate legacy SaveFlags (i.e. independent matrix/clip flags) 306// ---------------------------------------------------------------------------- 307 308void SkiaCanvas::recordPartialSave(SkCanvas::SaveFlags flags) { 309 // A partial save is a save operation which doesn't capture the full canvas state. 310 // (either kMatrix_SaveFlags or kClip_SaveFlag is missing). 311 312 // Mask-out non canvas state bits. 313 flags = static_cast<SkCanvas::SaveFlags>(flags & SkCanvas::kMatrixClip_SaveFlag); 314 315 if (SkCanvas::kMatrixClip_SaveFlag == flags) { 316 // not a partial save. 317 return; 318 } 319 320 if (NULL == mSaveStack.get()) { 321 mSaveStack.reset(SkNEW_ARGS(SkDeque, (sizeof(struct SaveRec), 8))); 322 } 323 324 SaveRec* rec = static_cast<SaveRec*>(mSaveStack->push_back()); 325 // Store the save counter in the SkClipStack domain. 326 // (0-based, equal to the number of save ops on the stack). 327 rec->saveCount = mCanvas->getSaveCount() - 1; 328 rec->saveFlags = flags; 329} 330 331void SkiaCanvas::saveClipsForFrame(SkTArray<SkClipStack::Element>& clips, int frameSaveCount) { 332 SkClipStack::Iter clipIterator(*mCanvas->getClipStack(), 333 SkClipStack::Iter::kTop_IterStart); 334 while (const SkClipStack::Element* elem = clipIterator.next()) { 335 if (elem->getSaveCount() < frameSaveCount) { 336 // done with the current frame. 337 break; 338 } 339 SkASSERT(elem->getSaveCount() == frameSaveCount); 340 clips.push_back(*elem); 341 } 342} 343 344void SkiaCanvas::applyClips(const SkTArray<SkClipStack::Element>& clips) { 345 ClipCopier clipCopier(mCanvas); 346 347 // The clip stack stores clips in device space. 348 SkMatrix origMatrix = mCanvas->getTotalMatrix(); 349 mCanvas->resetMatrix(); 350 351 // We pushed the clips in reverse order. 352 for (int i = clips.count() - 1; i >= 0; --i) { 353 clips[i].replay(&clipCopier); 354 } 355 356 mCanvas->setMatrix(origMatrix); 357} 358 359// ---------------------------------------------------------------------------- 360// Canvas state operations: Matrix 361// ---------------------------------------------------------------------------- 362 363void SkiaCanvas::getMatrix(SkMatrix* outMatrix) const { 364 *outMatrix = mCanvas->getTotalMatrix(); 365} 366 367void SkiaCanvas::setMatrix(const SkMatrix& matrix) { 368 mCanvas->setMatrix(matrix); 369} 370 371void SkiaCanvas::concat(const SkMatrix& matrix) { 372 mCanvas->concat(matrix); 373} 374 375void SkiaCanvas::rotate(float degrees) { 376 mCanvas->rotate(degrees); 377} 378 379void SkiaCanvas::scale(float sx, float sy) { 380 mCanvas->scale(sx, sy); 381} 382 383void SkiaCanvas::skew(float sx, float sy) { 384 mCanvas->skew(sx, sy); 385} 386 387void SkiaCanvas::translate(float dx, float dy) { 388 mCanvas->translate(dx, dy); 389} 390 391// ---------------------------------------------------------------------------- 392// Canvas state operations: Clips 393// ---------------------------------------------------------------------------- 394 395// This function is a mirror of SkCanvas::getClipBounds except that it does 396// not outset the edge of the clip to account for anti-aliasing. There is 397// a skia bug to investigate pushing this logic into back into skia. 398// (see https://code.google.com/p/skia/issues/detail?id=1303) 399bool SkiaCanvas::getClipBounds(SkRect* outRect) const { 400 SkIRect ibounds; 401 if (!mCanvas->getClipDeviceBounds(&ibounds)) { 402 return false; 403 } 404 405 SkMatrix inverse; 406 // if we can't invert the CTM, we can't return local clip bounds 407 if (!mCanvas->getTotalMatrix().invert(&inverse)) { 408 if (outRect) { 409 outRect->setEmpty(); 410 } 411 return false; 412 } 413 414 if (NULL != outRect) { 415 SkRect r = SkRect::Make(ibounds); 416 inverse.mapRect(outRect, r); 417 } 418 return true; 419} 420 421bool SkiaCanvas::quickRejectRect(float left, float top, float right, float bottom) const { 422 SkRect bounds = SkRect::MakeLTRB(left, top, right, bottom); 423 return mCanvas->quickReject(bounds); 424} 425 426bool SkiaCanvas::quickRejectPath(const SkPath& path) const { 427 return mCanvas->quickReject(path); 428} 429 430bool SkiaCanvas::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) { 431 SkRect rect = SkRect::MakeLTRB(left, top, right, bottom); 432 mCanvas->clipRect(rect, op); 433 return !mCanvas->isClipEmpty(); 434} 435 436bool SkiaCanvas::clipPath(const SkPath* path, SkRegion::Op op) { 437 mCanvas->clipPath(*path, op); 438 return !mCanvas->isClipEmpty(); 439} 440 441bool SkiaCanvas::clipRegion(const SkRegion* region, SkRegion::Op op) { 442 SkPath rgnPath; 443 if (region->getBoundaryPath(&rgnPath)) { 444 // The region is specified in device space. 445 SkMatrix savedMatrix = mCanvas->getTotalMatrix(); 446 mCanvas->resetMatrix(); 447 mCanvas->clipPath(rgnPath, op); 448 mCanvas->setMatrix(savedMatrix); 449 } else { 450 mCanvas->clipRect(SkRect::MakeEmpty(), op); 451 } 452 return !mCanvas->isClipEmpty(); 453} 454 455// ---------------------------------------------------------------------------- 456// Canvas state operations: Filters 457// ---------------------------------------------------------------------------- 458 459SkDrawFilter* SkiaCanvas::getDrawFilter() { 460 return mCanvas->getDrawFilter(); 461} 462 463void SkiaCanvas::setDrawFilter(SkDrawFilter* drawFilter) { 464 mCanvas->setDrawFilter(drawFilter); 465} 466 467// ---------------------------------------------------------------------------- 468// Canvas draw operations 469// ---------------------------------------------------------------------------- 470 471void SkiaCanvas::drawColor(int color, SkXfermode::Mode mode) { 472 mCanvas->drawColor(color, mode); 473} 474 475void SkiaCanvas::drawPaint(const SkPaint& paint) { 476 mCanvas->drawPaint(paint); 477} 478 479// ---------------------------------------------------------------------------- 480// Canvas draw operations: Geometry 481// ---------------------------------------------------------------------------- 482 483void SkiaCanvas::drawPoints(const float* points, int count, const SkPaint& paint, 484 SkCanvas::PointMode mode) { 485 // convert the floats into SkPoints 486 count >>= 1; // now it is the number of points 487 SkAutoSTMalloc<32, SkPoint> storage(count); 488 SkPoint* pts = storage.get(); 489 for (int i = 0; i < count; i++) { 490 pts[i].set(points[0], points[1]); 491 points += 2; 492 } 493 mCanvas->drawPoints(mode, count, pts, paint); 494} 495 496 497void SkiaCanvas::drawPoint(float x, float y, const SkPaint& paint) { 498 mCanvas->drawPoint(x, y, paint); 499} 500 501void SkiaCanvas::drawPoints(const float* points, int count, const SkPaint& paint) { 502 this->drawPoints(points, count, paint, SkCanvas::kPoints_PointMode); 503} 504 505void SkiaCanvas::drawLine(float startX, float startY, float stopX, float stopY, 506 const SkPaint& paint) { 507 mCanvas->drawLine(startX, startY, stopX, stopY, paint); 508} 509 510void SkiaCanvas::drawLines(const float* points, int count, const SkPaint& paint) { 511 this->drawPoints(points, count, paint, SkCanvas::kLines_PointMode); 512} 513 514void SkiaCanvas::drawRect(float left, float top, float right, float bottom, 515 const SkPaint& paint) { 516 mCanvas->drawRectCoords(left, top, right, bottom, paint); 517 518} 519 520void SkiaCanvas::drawRegion(const SkRegion& region, const SkPaint& paint) { 521 SkRegion::Iterator it(region); 522 while (!it.done()) { 523 mCanvas->drawRect(SkRect::Make(it.rect()), paint); 524 it.next(); 525 } 526} 527 528void SkiaCanvas::drawRoundRect(float left, float top, float right, float bottom, 529 float rx, float ry, const SkPaint& paint) { 530 SkRect rect = SkRect::MakeLTRB(left, top, right, bottom); 531 mCanvas->drawRoundRect(rect, rx, ry, paint); 532} 533 534void SkiaCanvas::drawCircle(float x, float y, float radius, const SkPaint& paint) { 535 mCanvas->drawCircle(x, y, radius, paint); 536} 537 538void SkiaCanvas::drawOval(float left, float top, float right, float bottom, const SkPaint& paint) { 539 SkRect oval = SkRect::MakeLTRB(left, top, right, bottom); 540 mCanvas->drawOval(oval, paint); 541} 542 543void SkiaCanvas::drawArc(float left, float top, float right, float bottom, 544 float startAngle, float sweepAngle, bool useCenter, const SkPaint& paint) { 545 SkRect arc = SkRect::MakeLTRB(left, top, right, bottom); 546 mCanvas->drawArc(arc, startAngle, sweepAngle, useCenter, paint); 547} 548 549void SkiaCanvas::drawPath(const SkPath& path, const SkPaint& paint) { 550 mCanvas->drawPath(path, paint); 551} 552 553void SkiaCanvas::drawVertices(SkCanvas::VertexMode vertexMode, int vertexCount, 554 const float* verts, const float* texs, const int* colors, 555 const uint16_t* indices, int indexCount, const SkPaint& paint) { 556#ifndef SK_SCALAR_IS_FLOAT 557 SkDEBUGFAIL("SkScalar must be a float for these conversions to be valid"); 558#endif 559 const int ptCount = vertexCount >> 1; 560 mCanvas->drawVertices(vertexMode, ptCount, (SkPoint*)verts, (SkPoint*)texs, 561 (SkColor*)colors, NULL, indices, indexCount, paint); 562} 563 564// ---------------------------------------------------------------------------- 565// Canvas draw operations: Bitmaps 566// ---------------------------------------------------------------------------- 567 568void SkiaCanvas::drawBitmap(const SkBitmap& bitmap, float left, float top, const SkPaint* paint) { 569 mCanvas->drawBitmap(bitmap, left, top, paint); 570} 571 572void SkiaCanvas::drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix, const SkPaint* paint) { 573 SkAutoCanvasRestore acr(mCanvas, true); 574 mCanvas->concat(matrix); 575 mCanvas->drawBitmap(bitmap, 0, 0, paint); 576} 577 578void SkiaCanvas::drawBitmap(const SkBitmap& bitmap, float srcLeft, float srcTop, 579 float srcRight, float srcBottom, float dstLeft, float dstTop, 580 float dstRight, float dstBottom, const SkPaint* paint) { 581 SkRect srcRect = SkRect::MakeLTRB(srcLeft, srcTop, srcRight, srcBottom); 582 SkRect dstRect = SkRect::MakeLTRB(dstLeft, dstTop, dstRight, dstBottom); 583 mCanvas->drawBitmapRectToRect(bitmap, &srcRect, dstRect, paint); 584} 585 586void SkiaCanvas::drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, int meshHeight, 587 const float* vertices, const int* colors, const SkPaint* paint) { 588 589 const int ptCount = (meshWidth + 1) * (meshHeight + 1); 590 const int indexCount = meshWidth * meshHeight * 6; 591 592 /* Our temp storage holds 2 or 3 arrays. 593 texture points [ptCount * sizeof(SkPoint)] 594 optionally vertex points [ptCount * sizeof(SkPoint)] if we need a 595 copy to convert from float to fixed 596 indices [ptCount * sizeof(uint16_t)] 597 */ 598 ssize_t storageSize = ptCount * sizeof(SkPoint); // texs[] 599 storageSize += indexCount * sizeof(uint16_t); // indices[] 600 601 602#ifndef SK_SCALAR_IS_FLOAT 603 SkDEBUGFAIL("SkScalar must be a float for these conversions to be valid"); 604#endif 605 SkAutoMalloc storage(storageSize); 606 SkPoint* texs = (SkPoint*)storage.get(); 607 uint16_t* indices = (uint16_t*)(texs + ptCount); 608 609 // cons up texture coordinates and indices 610 { 611 const SkScalar w = SkIntToScalar(bitmap.width()); 612 const SkScalar h = SkIntToScalar(bitmap.height()); 613 const SkScalar dx = w / meshWidth; 614 const SkScalar dy = h / meshHeight; 615 616 SkPoint* texsPtr = texs; 617 SkScalar y = 0; 618 for (int i = 0; i <= meshHeight; i++) { 619 if (i == meshHeight) { 620 y = h; // to ensure numerically we hit h exactly 621 } 622 SkScalar x = 0; 623 for (int j = 0; j < meshWidth; j++) { 624 texsPtr->set(x, y); 625 texsPtr += 1; 626 x += dx; 627 } 628 texsPtr->set(w, y); 629 texsPtr += 1; 630 y += dy; 631 } 632 SkASSERT(texsPtr - texs == ptCount); 633 } 634 635 // cons up indices 636 { 637 uint16_t* indexPtr = indices; 638 int index = 0; 639 for (int i = 0; i < meshHeight; i++) { 640 for (int j = 0; j < meshWidth; j++) { 641 // lower-left triangle 642 *indexPtr++ = index; 643 *indexPtr++ = index + meshWidth + 1; 644 *indexPtr++ = index + meshWidth + 2; 645 // upper-right triangle 646 *indexPtr++ = index; 647 *indexPtr++ = index + meshWidth + 2; 648 *indexPtr++ = index + 1; 649 // bump to the next cell 650 index += 1; 651 } 652 // bump to the next row 653 index += 1; 654 } 655 SkASSERT(indexPtr - indices == indexCount); 656 SkASSERT((char*)indexPtr - (char*)storage.get() == storageSize); 657 } 658 659 // double-check that we have legal indices 660#ifdef SK_DEBUG 661 { 662 for (int i = 0; i < indexCount; i++) { 663 SkASSERT((unsigned)indices[i] < (unsigned)ptCount); 664 } 665 } 666#endif 667 668 // cons-up a shader for the bitmap 669 SkPaint tmpPaint; 670 if (paint) { 671 tmpPaint = *paint; 672 } 673 SkShader* shader = SkShader::CreateBitmapShader(bitmap, 674 SkShader::kClamp_TileMode, 675 SkShader::kClamp_TileMode); 676 SkSafeUnref(tmpPaint.setShader(shader)); 677 678 mCanvas->drawVertices(SkCanvas::kTriangles_VertexMode, ptCount, (SkPoint*)vertices, 679 texs, (const SkColor*)colors, NULL, indices, 680 indexCount, tmpPaint); 681} 682 683// ---------------------------------------------------------------------------- 684// Canvas draw operations: Text 685// ---------------------------------------------------------------------------- 686 687void SkiaCanvas::drawText(const uint16_t* text, const float* positions, int count, 688 const SkPaint& paint, float x, float y, 689 float boundsLeft, float boundsTop, float boundsRight, float boundsBottom, 690 float totalAdvance) { 691 // Set align to left for drawing, as we don't want individual 692 // glyphs centered or right-aligned; the offset above takes 693 // care of all alignment. 694 SkPaint paintCopy(paint); 695 paintCopy.setTextAlign(SkPaint::kLeft_Align); 696 697 SK_COMPILE_ASSERT(sizeof(SkPoint) == sizeof(float)*2, SkPoint_is_no_longer_2_floats); 698 mCanvas->drawPosText(text, count << 1, reinterpret_cast<const SkPoint*>(positions), paintCopy); 699} 700 701void SkiaCanvas::drawPosText(const uint16_t* text, const float* positions, int count, int posCount, 702 const SkPaint& paint) { 703 SkPoint* posPtr = posCount > 0 ? new SkPoint[posCount] : NULL; 704 int indx; 705 for (indx = 0; indx < posCount; indx++) { 706 posPtr[indx].fX = positions[indx << 1]; 707 posPtr[indx].fY = positions[(indx << 1) + 1]; 708 } 709 710 SkPaint paintCopy(paint); 711 paintCopy.setTextEncoding(SkPaint::kUTF16_TextEncoding); 712 mCanvas->drawPosText(text, count, posPtr, paintCopy); 713 714 delete[] posPtr; 715} 716 717void SkiaCanvas::drawTextOnPath(const uint16_t* glyphs, int count, const SkPath& path, 718 float hOffset, float vOffset, const SkPaint& paint) { 719 mCanvas->drawTextOnPathHV(glyphs, count << 1, path, hOffset, vOffset, paint); 720} 721 722} // namespace android 723