DisplayListRenderer.cpp revision d63cbd10765e8f48e39b07b15f0a4b70bf853ec8
1/* 2 * Copyright (C) 2010 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#define LOG_TAG "OpenGLRenderer" 18 19#include "DisplayListRenderer.h" 20 21namespace android { 22namespace uirenderer { 23 24/////////////////////////////////////////////////////////////////////////////// 25// Display list 26/////////////////////////////////////////////////////////////////////////////// 27 28const char* DisplayList::OP_NAMES[] = { 29 "Save", 30 "Restore", 31 "RestoreToCount", 32 "SaveLayer", 33 "SaveLayerAlpha", 34 "Translate", 35 "Rotate", 36 "Scale", 37 "Skew", 38 "SetMatrix", 39 "ConcatMatrix", 40 "ClipRect", 41 "DrawDisplayList", 42 "DrawLayer", 43 "DrawBitmap", 44 "DrawBitmapMatrix", 45 "DrawBitmapRect", 46 "DrawBitmapMesh", 47 "DrawPatch", 48 "DrawColor", 49 "DrawRect", 50 "DrawRoundRect", 51 "DrawCircle", 52 "DrawOval", 53 "DrawArc", 54 "DrawPath", 55 "DrawLines", 56 "DrawText", 57 "ResetShader", 58 "SetupShader", 59 "ResetColorFilter", 60 "SetupColorFilter", 61 "ResetShadow", 62 "SetupShadow", 63 "DrawGLFunction" 64}; 65 66DisplayList::DisplayList(const DisplayListRenderer& recorder) { 67 initFromDisplayListRenderer(recorder); 68} 69 70DisplayList::~DisplayList() { 71 clearResources(); 72} 73 74void DisplayList::clearResources() { 75 sk_free((void*) mReader.base()); 76 77 Caches& caches = Caches::getInstance(); 78 79 for (size_t i = 0; i < mBitmapResources.size(); i++) { 80 caches.resourceCache.decrementRefcount(mBitmapResources.itemAt(i)); 81 } 82 mBitmapResources.clear(); 83 84 for (size_t i = 0; i < mShaders.size(); i++) { 85 caches.resourceCache.decrementRefcount(mShaders.itemAt(i)); 86 } 87 mShaders.clear(); 88 89 for (size_t i = 0; i < mPaints.size(); i++) { 90 delete mPaints.itemAt(i); 91 } 92 mPaints.clear(); 93 94 for (size_t i = 0; i < mPaths.size(); i++) { 95 delete mPaths.itemAt(i); 96 } 97 mPaths.clear(); 98 99 for (size_t i = 0; i < mMatrices.size(); i++) { 100 delete mMatrices.itemAt(i); 101 } 102 mMatrices.clear(); 103} 104 105void DisplayList::initFromDisplayListRenderer(const DisplayListRenderer& recorder, bool reusing) { 106 const SkWriter32& writer = recorder.writeStream(); 107 init(); 108 109 if (writer.size() == 0) { 110 return; 111 } 112 113 if (reusing) { 114 // re-using display list - clear out previous allocations 115 clearResources(); 116 } 117 118 size_t size = writer.size(); 119 void* buffer = sk_malloc_throw(size); 120 writer.flatten(buffer); 121 mReader.setMemory(buffer, size); 122 123 Caches& caches = Caches::getInstance(); 124 125 const Vector<SkBitmap*> &bitmapResources = recorder.getBitmapResources(); 126 for (size_t i = 0; i < bitmapResources.size(); i++) { 127 SkBitmap* resource = bitmapResources.itemAt(i); 128 mBitmapResources.add(resource); 129 caches.resourceCache.incrementRefcount(resource); 130 } 131 132 const Vector<SkiaShader*> &shaders = recorder.getShaders(); 133 for (size_t i = 0; i < shaders.size(); i++) { 134 SkiaShader* shader = shaders.itemAt(i); 135 mShaders.add(shader); 136 caches.resourceCache.incrementRefcount(shader); 137 } 138 139 const Vector<SkPaint*> &paints = recorder.getPaints(); 140 for (size_t i = 0; i < paints.size(); i++) { 141 mPaints.add(paints.itemAt(i)); 142 } 143 144 const Vector<SkPath*> &paths = recorder.getPaths(); 145 for (size_t i = 0; i < paths.size(); i++) { 146 mPaths.add(paths.itemAt(i)); 147 } 148 149 const Vector<SkMatrix*> &matrices = recorder.getMatrices(); 150 for (size_t i = 0; i < matrices.size(); i++) { 151 mMatrices.add(matrices.itemAt(i)); 152 } 153} 154 155void DisplayList::init() { 156} 157 158bool DisplayList::replay(OpenGLRenderer& renderer, uint32_t level) { 159 bool needsInvalidate = false; 160 TextContainer text; 161 mReader.rewind(); 162 163#if DEBUG_DISPLAY_LIST 164 uint32_t count = (level + 1) * 2; 165 char indent[count + 1]; 166 for (uint32_t i = 0; i < count; i++) { 167 indent[i] = ' '; 168 } 169 indent[count] = '\0'; 170 DISPLAY_LIST_LOGD("%sStart display list (%p)", (char*) indent + 2, this); 171#endif 172 173 int saveCount = renderer.getSaveCount() - 1; 174 while (!mReader.eof()) { 175 int op = mReader.readInt(); 176 177 switch (op) { 178 case DrawGLFunction: { 179 Functor *functor = (Functor *) getInt(); 180 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], functor); 181 needsInvalidate |= renderer.callDrawGLFunction(functor); 182 } 183 break; 184 case Save: { 185 int rendererNum = getInt(); 186 DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, OP_NAMES[op], rendererNum); 187 renderer.save(rendererNum); 188 } 189 break; 190 case Restore: { 191 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 192 renderer.restore(); 193 } 194 break; 195 case RestoreToCount: { 196 int restoreCount = saveCount + getInt(); 197 DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, OP_NAMES[op], restoreCount); 198 renderer.restoreToCount(restoreCount); 199 } 200 break; 201 case SaveLayer: { 202 float f1 = getFloat(); 203 float f2 = getFloat(); 204 float f3 = getFloat(); 205 float f4 = getFloat(); 206 SkPaint* paint = getPaint(); 207 int flags = getInt(); 208 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p, 0x%x", (char*) indent, 209 OP_NAMES[op], f1, f2, f3, f4, paint, flags); 210 renderer.saveLayer(f1, f2, f3, f4, paint, flags); 211 } 212 break; 213 case SaveLayerAlpha: { 214 float f1 = getFloat(); 215 float f2 = getFloat(); 216 float f3 = getFloat(); 217 float f4 = getFloat(); 218 int alpha = getInt(); 219 int flags = getInt(); 220 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", (char*) indent, 221 OP_NAMES[op], f1, f2, f3, f4, alpha, flags); 222 renderer.saveLayerAlpha(f1, f2, f3, f4, alpha, flags); 223 } 224 break; 225 case Translate: { 226 float f1 = getFloat(); 227 float f2 = getFloat(); 228 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], f1, f2); 229 renderer.translate(f1, f2); 230 } 231 break; 232 case Rotate: { 233 float rotation = getFloat(); 234 DISPLAY_LIST_LOGD("%s%s %.2f", (char*) indent, OP_NAMES[op], rotation); 235 renderer.rotate(rotation); 236 } 237 break; 238 case Scale: { 239 float sx = getFloat(); 240 float sy = getFloat(); 241 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy); 242 renderer.scale(sx, sy); 243 } 244 break; 245 case Skew: { 246 float sx = getFloat(); 247 float sy = getFloat(); 248 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy); 249 renderer.skew(sx, sy); 250 } 251 break; 252 case SetMatrix: { 253 SkMatrix* matrix = getMatrix(); 254 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], matrix); 255 renderer.setMatrix(matrix); 256 } 257 break; 258 case ConcatMatrix: { 259 SkMatrix* matrix = getMatrix(); 260 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], matrix); 261 renderer.concatMatrix(matrix); 262 } 263 break; 264 case ClipRect: { 265 float f1 = getFloat(); 266 float f2 = getFloat(); 267 float f3 = getFloat(); 268 float f4 = getFloat(); 269 int regionOp = getInt(); 270 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d", (char*) indent, OP_NAMES[op], 271 f1, f2, f3, f4, regionOp); 272 renderer.clipRect(f1, f2, f3, f4, (SkRegion::Op) regionOp); 273 } 274 break; 275 case DrawDisplayList: { 276 DisplayList* displayList = getDisplayList(); 277 DISPLAY_LIST_LOGD("%s%s %p, %d", (char*) indent, OP_NAMES[op], 278 displayList, level + 1); 279 needsInvalidate |= renderer.drawDisplayList(displayList, level + 1); 280 } 281 break; 282 case DrawLayer: { 283 Layer* layer = (Layer*) getInt(); 284 float x = getFloat(); 285 float y = getFloat(); 286 SkPaint* paint = getPaint(); 287 DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 288 layer, x, y, paint); 289 renderer.drawLayer(layer, x, y, paint); 290 } 291 break; 292 case DrawBitmap: { 293 SkBitmap* bitmap = getBitmap(); 294 float x = getFloat(); 295 float y = getFloat(); 296 SkPaint* paint = getPaint(); 297 DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 298 bitmap, x, y, paint); 299 renderer.drawBitmap(bitmap, x, y, paint); 300 } 301 break; 302 case DrawBitmapMatrix: { 303 SkBitmap* bitmap = getBitmap(); 304 SkMatrix* matrix = getMatrix(); 305 SkPaint* paint = getPaint(); 306 DISPLAY_LIST_LOGD("%s%s %p, %p, %p", (char*) indent, OP_NAMES[op], 307 bitmap, matrix, paint); 308 renderer.drawBitmap(bitmap, matrix, paint); 309 } 310 break; 311 case DrawBitmapRect: { 312 SkBitmap* bitmap = getBitmap(); 313 float f1 = getFloat(); 314 float f2 = getFloat(); 315 float f3 = getFloat(); 316 float f4 = getFloat(); 317 float f5 = getFloat(); 318 float f6 = getFloat(); 319 float f7 = getFloat(); 320 float f8 = getFloat(); 321 SkPaint* paint = getPaint(); 322 DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p", 323 (char*) indent, OP_NAMES[op], bitmap, f1, f2, f3, f4, f5, f6, f7, f8, paint); 324 renderer.drawBitmap(bitmap, f1, f2, f3, f4, f5, f6, f7, f8, paint); 325 } 326 break; 327 case DrawBitmapMesh: { 328 int verticesCount = 0; 329 uint32_t colorsCount = 0; 330 331 SkBitmap* bitmap = getBitmap(); 332 uint32_t meshWidth = getInt(); 333 uint32_t meshHeight = getInt(); 334 float* vertices = getFloats(verticesCount); 335 bool hasColors = getInt(); 336 int* colors = hasColors ? getInts(colorsCount) : NULL; 337 338 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 339 renderer.drawBitmapMesh(bitmap, meshWidth, meshHeight, vertices, colors, getPaint()); 340 } 341 break; 342 case DrawPatch: { 343 int32_t* xDivs = NULL; 344 int32_t* yDivs = NULL; 345 uint32_t* colors = NULL; 346 uint32_t xDivsCount = 0; 347 uint32_t yDivsCount = 0; 348 int8_t numColors = 0; 349 350 SkBitmap* bitmap = getBitmap(); 351 352 xDivs = getInts(xDivsCount); 353 yDivs = getInts(yDivsCount); 354 colors = getUInts(numColors); 355 356 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 357 renderer.drawPatch(bitmap, xDivs, yDivs, colors, xDivsCount, yDivsCount, 358 numColors, getFloat(), getFloat(), getFloat(), getFloat(), getPaint()); 359 } 360 break; 361 case DrawColor: { 362 int color = getInt(); 363 int xferMode = getInt(); 364 DISPLAY_LIST_LOGD("%s%s 0x%x %d", (char*) indent, OP_NAMES[op], color, xferMode); 365 renderer.drawColor(color, (SkXfermode::Mode) xferMode); 366 } 367 break; 368 case DrawRect: { 369 float f1 = getFloat(); 370 float f2 = getFloat(); 371 float f3 = getFloat(); 372 float f4 = getFloat(); 373 SkPaint* paint = getPaint(); 374 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 375 f1, f2, f3, f4, paint); 376 renderer.drawRect(f1, f2, f3, f4, paint); 377 } 378 break; 379 case DrawRoundRect: { 380 float f1 = getFloat(); 381 float f2 = getFloat(); 382 float f3 = getFloat(); 383 float f4 = getFloat(); 384 float f5 = getFloat(); 385 float f6 = getFloat(); 386 SkPaint* paint = getPaint(); 387 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p", 388 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, paint); 389 renderer.drawRoundRect(f1, f2, f3, f4, f5, f6, paint); 390 } 391 break; 392 case DrawCircle: { 393 float f1 = getFloat(); 394 float f2 = getFloat(); 395 float f3 = getFloat(); 396 SkPaint* paint = getPaint(); 397 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %p", 398 (char*) indent, OP_NAMES[op], f1, f2, f3, paint); 399 renderer.drawCircle(f1, f2, f3, paint); 400 } 401 break; 402 case DrawOval: { 403 float f1 = getFloat(); 404 float f2 = getFloat(); 405 float f3 = getFloat(); 406 float f4 = getFloat(); 407 SkPaint* paint = getPaint(); 408 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", 409 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, paint); 410 renderer.drawOval(f1, f2, f3, f4, paint); 411 } 412 break; 413 case DrawArc: { 414 float f1 = getFloat(); 415 float f2 = getFloat(); 416 float f3 = getFloat(); 417 float f4 = getFloat(); 418 float f5 = getFloat(); 419 float f6 = getFloat(); 420 int i1 = getInt(); 421 SkPaint* paint = getPaint(); 422 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p", 423 (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, i1, paint); 424 renderer.drawArc(f1, f2, f3, f4, f5, f6, i1 == 1, paint); 425 } 426 break; 427 case DrawPath: { 428 SkPath* path = getPath(); 429 SkPaint* paint = getPaint(); 430 DISPLAY_LIST_LOGD("%s%s %p, %p", (char*) indent, OP_NAMES[op], path, paint); 431 renderer.drawPath(path, paint); 432 } 433 break; 434 case DrawLines: { 435 int count = 0; 436 float* points = getFloats(count); 437 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 438 renderer.drawLines(points, count, getPaint()); 439 } 440 break; 441 case DrawText: { 442 getText(&text); 443 int count = getInt(); 444 float x = getFloat(); 445 float y = getFloat(); 446 SkPaint* paint = getPaint(); 447 DISPLAY_LIST_LOGD("%s%s %s, %d, %d, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], 448 text.text(), text.length(), count, x, y, paint); 449 renderer.drawText(text.text(), text.length(), count, x, y, paint); 450 } 451 break; 452 case ResetShader: { 453 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 454 renderer.resetShader(); 455 } 456 break; 457 case SetupShader: { 458 SkiaShader* shader = getShader(); 459 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], shader); 460 renderer.setupShader(shader); 461 } 462 break; 463 case ResetColorFilter: { 464 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 465 renderer.resetColorFilter(); 466 } 467 break; 468 case SetupColorFilter: { 469 SkiaColorFilter *colorFilter = getColorFilter(); 470 DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], colorFilter); 471 renderer.setupColorFilter(colorFilter); 472 } 473 break; 474 case ResetShadow: { 475 DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]); 476 renderer.resetShadow(); 477 } 478 break; 479 case SetupShadow: { 480 float radius = getFloat(); 481 float dx = getFloat(); 482 float dy = getFloat(); 483 int color = getInt(); 484 DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, 0x%x", (char*) indent, OP_NAMES[op], 485 radius, dx, dy, color); 486 renderer.setupShadow(radius, dx, dy, color); 487 } 488 break; 489 default: 490 DISPLAY_LIST_LOGD("Display List error: op not handled: %s%s", 491 (char*) indent, OP_NAMES[op]); 492 break; 493 } 494 } 495 496 DISPLAY_LIST_LOGD("%sDone, returning %d", (char*) indent + 2, needsInvalidate); 497 return needsInvalidate; 498} 499 500/////////////////////////////////////////////////////////////////////////////// 501// Base structure 502/////////////////////////////////////////////////////////////////////////////// 503 504DisplayListRenderer::DisplayListRenderer(): mWriter(MIN_WRITER_SIZE) { 505 mDisplayList = NULL; 506} 507 508DisplayListRenderer::~DisplayListRenderer() { 509 reset(); 510} 511 512void DisplayListRenderer::reset() { 513 mWriter.reset(); 514 515 Caches& caches = Caches::getInstance(); 516 for (size_t i = 0; i < mBitmapResources.size(); i++) { 517 SkBitmap* resource = mBitmapResources.itemAt(i); 518 caches.resourceCache.decrementRefcount(resource); 519 } 520 mBitmapResources.clear(); 521 522 for (size_t i = 0; i < mShaders.size(); i++) { 523 caches.resourceCache.decrementRefcount(mShaders.itemAt(i)); 524 } 525 mShaders.clear(); 526 mShaderMap.clear(); 527 528 mPaints.clear(); 529 mPaintMap.clear(); 530 mPaths.clear(); 531 mPathMap.clear(); 532 mMatrices.clear(); 533} 534 535/////////////////////////////////////////////////////////////////////////////// 536// Operations 537/////////////////////////////////////////////////////////////////////////////// 538 539DisplayList* DisplayListRenderer::getDisplayList() { 540 if (mDisplayList == NULL) { 541 mDisplayList = new DisplayList(*this); 542 } else { 543 mDisplayList->initFromDisplayListRenderer(*this, true); 544 } 545 return mDisplayList; 546} 547 548void DisplayListRenderer::setViewport(int width, int height) { 549 mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1); 550 551 mWidth = width; 552 mHeight = height; 553} 554 555void DisplayListRenderer::prepareDirty(float left, float top, 556 float right, float bottom, bool opaque) { 557 mSnapshot = new Snapshot(mFirstSnapshot, 558 SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); 559 mSaveCount = 1; 560 mSnapshot->setClip(0.0f, 0.0f, mWidth, mHeight); 561 mRestoreSaveCount = -1; 562} 563 564void DisplayListRenderer::finish() { 565 insertRestoreToCount(); 566 OpenGLRenderer::finish(); 567} 568 569void DisplayListRenderer::interrupt() { 570} 571 572void DisplayListRenderer::resume() { 573} 574 575bool DisplayListRenderer::callDrawGLFunction(Functor *functor) { 576 addOp(DisplayList::DrawGLFunction); 577 addInt((int) functor); 578 return false; // No invalidate needed at record-time 579} 580 581int DisplayListRenderer::save(int flags) { 582 addOp(DisplayList::Save); 583 addInt(flags); 584 return OpenGLRenderer::save(flags); 585} 586 587void DisplayListRenderer::restore() { 588 addOp(DisplayList::Restore); 589 OpenGLRenderer::restore(); 590} 591 592void DisplayListRenderer::restoreToCount(int saveCount) { 593 mRestoreSaveCount = saveCount; 594 OpenGLRenderer::restoreToCount(saveCount); 595} 596 597int DisplayListRenderer::saveLayer(float left, float top, float right, float bottom, 598 SkPaint* p, int flags) { 599 addOp(DisplayList::SaveLayer); 600 addBounds(left, top, right, bottom); 601 addPaint(p); 602 addInt(flags); 603 return OpenGLRenderer::save(flags); 604} 605 606int DisplayListRenderer::saveLayerAlpha(float left, float top, float right, float bottom, 607 int alpha, int flags) { 608 addOp(DisplayList::SaveLayerAlpha); 609 addBounds(left, top, right, bottom); 610 addInt(alpha); 611 addInt(flags); 612 return OpenGLRenderer::save(flags); 613} 614 615void DisplayListRenderer::translate(float dx, float dy) { 616 addOp(DisplayList::Translate); 617 addPoint(dx, dy); 618 OpenGLRenderer::translate(dx, dy); 619} 620 621void DisplayListRenderer::rotate(float degrees) { 622 addOp(DisplayList::Rotate); 623 addFloat(degrees); 624 OpenGLRenderer::rotate(degrees); 625} 626 627void DisplayListRenderer::scale(float sx, float sy) { 628 addOp(DisplayList::Scale); 629 addPoint(sx, sy); 630 OpenGLRenderer::scale(sx, sy); 631} 632 633void DisplayListRenderer::skew(float sx, float sy) { 634 addOp(DisplayList::Skew); 635 addPoint(sx, sy); 636 OpenGLRenderer::skew(sx, sy); 637} 638 639void DisplayListRenderer::setMatrix(SkMatrix* matrix) { 640 addOp(DisplayList::SetMatrix); 641 addMatrix(matrix); 642 OpenGLRenderer::setMatrix(matrix); 643} 644 645void DisplayListRenderer::concatMatrix(SkMatrix* matrix) { 646 addOp(DisplayList::ConcatMatrix); 647 addMatrix(matrix); 648 OpenGLRenderer::concatMatrix(matrix); 649} 650 651bool DisplayListRenderer::clipRect(float left, float top, float right, float bottom, 652 SkRegion::Op op) { 653 addOp(DisplayList::ClipRect); 654 addBounds(left, top, right, bottom); 655 addInt(op); 656 return OpenGLRenderer::clipRect(left, top, right, bottom, op); 657} 658 659bool DisplayListRenderer::drawDisplayList(DisplayList* displayList, uint32_t level) { 660 addOp(DisplayList::DrawDisplayList); 661 addDisplayList(displayList); 662 return false; 663} 664 665void DisplayListRenderer::drawLayer(Layer* layer, float x, float y, SkPaint* paint) { 666 addOp(DisplayList::DrawLayer); 667 addInt((int) layer); 668 addPoint(x, y); 669 addPaint(paint); 670} 671 672void DisplayListRenderer::drawBitmap(SkBitmap* bitmap, float left, float top, 673 SkPaint* paint) { 674 addOp(DisplayList::DrawBitmap); 675 addBitmap(bitmap); 676 addPoint(left, top); 677 addPaint(paint); 678} 679 680void DisplayListRenderer::drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, 681 SkPaint* paint) { 682 addOp(DisplayList::DrawBitmapMatrix); 683 addBitmap(bitmap); 684 addMatrix(matrix); 685 addPaint(paint); 686} 687 688void DisplayListRenderer::drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop, 689 float srcRight, float srcBottom, float dstLeft, float dstTop, 690 float dstRight, float dstBottom, SkPaint* paint) { 691 addOp(DisplayList::DrawBitmapRect); 692 addBitmap(bitmap); 693 addBounds(srcLeft, srcTop, srcRight, srcBottom); 694 addBounds(dstLeft, dstTop, dstRight, dstBottom); 695 addPaint(paint); 696} 697 698void DisplayListRenderer::drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight, 699 float* vertices, int* colors, SkPaint* paint) { 700 addOp(DisplayList::DrawBitmapMesh); 701 addBitmap(bitmap); 702 addInt(meshWidth); 703 addInt(meshHeight); 704 addFloats(vertices, (meshWidth + 1) * (meshHeight + 1) * 2); 705 if (colors) { 706 addInt(1); 707 addInts(colors, (meshWidth + 1) * (meshHeight + 1)); 708 } else { 709 addInt(0); 710 } 711 addPaint(paint); 712} 713 714void DisplayListRenderer::drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs, 715 const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors, 716 float left, float top, float right, float bottom, SkPaint* paint) { 717 addOp(DisplayList::DrawPatch); 718 addBitmap(bitmap); 719 addInts(xDivs, width); 720 addInts(yDivs, height); 721 addUInts(colors, numColors); 722 addBounds(left, top, right, bottom); 723 addPaint(paint); 724} 725 726void DisplayListRenderer::drawColor(int color, SkXfermode::Mode mode) { 727 addOp(DisplayList::DrawColor); 728 addInt(color); 729 addInt(mode); 730} 731 732void DisplayListRenderer::drawRect(float left, float top, float right, float bottom, 733 SkPaint* paint) { 734 addOp(DisplayList::DrawRect); 735 addBounds(left, top, right, bottom); 736 addPaint(paint); 737} 738 739void DisplayListRenderer::drawRoundRect(float left, float top, float right, float bottom, 740 float rx, float ry, SkPaint* paint) { 741 addOp(DisplayList::DrawRoundRect); 742 addBounds(left, top, right, bottom); 743 addPoint(rx, ry); 744 addPaint(paint); 745} 746 747void DisplayListRenderer::drawCircle(float x, float y, float radius, SkPaint* paint) { 748 addOp(DisplayList::DrawCircle); 749 addPoint(x, y); 750 addFloat(radius); 751 addPaint(paint); 752} 753 754void DisplayListRenderer::drawOval(float left, float top, float right, float bottom, 755 SkPaint* paint) { 756 addOp(DisplayList::DrawOval); 757 addBounds(left, top, right, bottom); 758 addPaint(paint); 759} 760 761void DisplayListRenderer::drawArc(float left, float top, float right, float bottom, 762 float startAngle, float sweepAngle, bool useCenter, SkPaint* paint) { 763 addOp(DisplayList::DrawArc); 764 addBounds(left, top, right, bottom); 765 addPoint(startAngle, sweepAngle); 766 addInt(useCenter ? 1 : 0); 767 addPaint(paint); 768} 769 770void DisplayListRenderer::drawPath(SkPath* path, SkPaint* paint) { 771 addOp(DisplayList::DrawPath); 772 addPath(path); 773 addPaint(paint); 774} 775 776void DisplayListRenderer::drawLines(float* points, int count, SkPaint* paint) { 777 addOp(DisplayList::DrawLines); 778 addFloats(points, count); 779 addPaint(paint); 780} 781 782void DisplayListRenderer::drawText(const char* text, int bytesCount, int count, 783 float x, float y, SkPaint* paint) { 784 addOp(DisplayList::DrawText); 785 addText(text, bytesCount); 786 addInt(count); 787 addPoint(x, y); 788 addPaint(paint); 789} 790 791void DisplayListRenderer::resetShader() { 792 addOp(DisplayList::ResetShader); 793} 794 795void DisplayListRenderer::setupShader(SkiaShader* shader) { 796 addOp(DisplayList::SetupShader); 797 addShader(shader); 798} 799 800void DisplayListRenderer::resetColorFilter() { 801 addOp(DisplayList::ResetColorFilter); 802} 803 804void DisplayListRenderer::setupColorFilter(SkiaColorFilter* filter) { 805 addOp(DisplayList::SetupColorFilter); 806 addColorFilter(filter); 807} 808 809void DisplayListRenderer::resetShadow() { 810 addOp(DisplayList::ResetShadow); 811} 812 813void DisplayListRenderer::setupShadow(float radius, float dx, float dy, int color) { 814 addOp(DisplayList::SetupShadow); 815 addFloat(radius); 816 addPoint(dx, dy); 817 addInt(color); 818} 819 820}; // namespace uirenderer 821}; // namespace android 822