SkDrawCommand.h revision c54d8db4d169ea5f2af2a9a2349df007bd428475
1 2/* 3 * Copyright 2012 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9#ifndef SKDRAWCOMMAND_H_ 10#define SKDRAWCOMMAND_H_ 11 12#include "SkPictureFlat.h" 13#include "SkCanvas.h" 14#include "SkString.h" 15 16class SK_API SkDrawCommand { 17public: 18 SkDrawCommand(DrawType drawType); 19 20 virtual ~SkDrawCommand(); 21 22 virtual SkString toString() const; 23 24 void setOffset(size_t offset) { fOffset = offset; } 25 size_t offset() const { return fOffset; } 26 27 virtual const char* toCString() const { 28 return GetCommandString(fDrawType); 29 } 30 31 bool isVisible() const { 32 return fVisible; 33 } 34 35 void setVisible(bool toggle) { 36 fVisible = toggle; 37 } 38 39 const SkTDArray<SkString*>* Info() const { return &fInfo; } 40 virtual void execute(SkCanvas*) const = 0; 41 virtual void vizExecute(SkCanvas*) const {} 42 43 virtual void setUserMatrix(const SkMatrix&) {} 44 45 /** Does nothing by default, but used by save() and restore()-type 46 subclasses to track unresolved save() calls. */ 47 virtual void trackSaveState(int* state) {} 48 49 // The next "active" system is only used by save, saveLayer, restore, 50 // pushCull and popCull. It is used in two ways: 51 // To determine which saveLayers are currently active (at a 52 // given point in the rendering). 53 // saves just return a kPushLayer action but don't track active state 54 // restores just return a kPopLayer action 55 // saveLayers return kPushLayer but also track the active state 56 // To determine which culls are currently active (at a given point) 57 // in the rendering). 58 // pushCulls return a kPushCull action 59 // popCulls return a kPopCull action 60 enum Action { 61 kNone_Action, 62 kPopLayer_Action, 63 kPushLayer_Action, 64 kPopCull_Action, 65 kPushCull_Action 66 }; 67 virtual Action action() const { return kNone_Action; } 68 virtual void setActive(bool active) {} 69 virtual bool active() const { return false; } 70 71 DrawType getType() const { return fDrawType; } 72 73 virtual bool render(SkCanvas* canvas) const { return false; } 74 75 static const char* GetCommandString(DrawType type); 76 77protected: 78 SkTDArray<SkString*> fInfo; 79 80private: 81 DrawType fDrawType; 82 size_t fOffset; 83 bool fVisible; 84}; 85 86class SkRestoreCommand : public SkDrawCommand { 87public: 88 SkRestoreCommand(); 89 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 90 virtual void trackSaveState(int* state) SK_OVERRIDE; 91 virtual Action action() const SK_OVERRIDE { return kPopLayer_Action; } 92 93private: 94 typedef SkDrawCommand INHERITED; 95}; 96 97class SkClearCommand : public SkDrawCommand { 98public: 99 SkClearCommand(SkColor color); 100 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 101private: 102 SkColor fColor; 103 104 typedef SkDrawCommand INHERITED; 105}; 106 107class SkClipPathCommand : public SkDrawCommand { 108public: 109 SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA); 110 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 111 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 112private: 113 SkPath fPath; 114 SkRegion::Op fOp; 115 bool fDoAA; 116 117 typedef SkDrawCommand INHERITED; 118}; 119 120class SkClipRegionCommand : public SkDrawCommand { 121public: 122 SkClipRegionCommand(const SkRegion& region, SkRegion::Op op); 123 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 124private: 125 SkRegion fRegion; 126 SkRegion::Op fOp; 127 128 typedef SkDrawCommand INHERITED; 129}; 130 131class SkClipRectCommand : public SkDrawCommand { 132public: 133 SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA); 134 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 135 136 const SkRect& rect() const { return fRect; } 137 SkRegion::Op op() const { return fOp; } 138 bool doAA() const { return fDoAA; } 139 140private: 141 SkRect fRect; 142 SkRegion::Op fOp; 143 bool fDoAA; 144 145 typedef SkDrawCommand INHERITED; 146}; 147 148class SkClipRRectCommand : public SkDrawCommand { 149public: 150 SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA); 151 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 152 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 153 154 const SkRRect& rrect() const { return fRRect; } 155 SkRegion::Op op() const { return fOp; } 156 bool doAA() const { return fDoAA; } 157 158private: 159 SkRRect fRRect; 160 SkRegion::Op fOp; 161 bool fDoAA; 162 163 typedef SkDrawCommand INHERITED; 164}; 165 166class SkConcatCommand : public SkDrawCommand { 167public: 168 SkConcatCommand(const SkMatrix& matrix); 169 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 170private: 171 SkMatrix fMatrix; 172 173 typedef SkDrawCommand INHERITED; 174}; 175 176class SkDrawBitmapCommand : public SkDrawCommand { 177public: 178 SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top, 179 const SkPaint* paint); 180 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 181 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 182private: 183 SkBitmap fBitmap; 184 SkScalar fLeft; 185 SkScalar fTop; 186 SkPaint fPaint; 187 SkPaint* fPaintPtr; 188 189 typedef SkDrawCommand INHERITED; 190}; 191 192class SkDrawBitmapNineCommand : public SkDrawCommand { 193public: 194 SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center, 195 const SkRect& dst, const SkPaint* paint); 196 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 197 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 198private: 199 SkBitmap fBitmap; 200 SkIRect fCenter; 201 SkRect fDst; 202 SkPaint fPaint; 203 SkPaint* fPaintPtr; 204 205 typedef SkDrawCommand INHERITED; 206}; 207 208class SkDrawBitmapRectCommand : public SkDrawCommand { 209public: 210 SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src, 211 const SkRect& dst, const SkPaint* paint, 212 SkCanvas::DrawBitmapRectFlags flags); 213 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 214 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 215 216 const SkBitmap& bitmap() const { return fBitmap; } 217 218 // The non-const 'paint' method allows modification of this object's 219 // SkPaint. For this reason the ctor and setPaint method make a local copy. 220 // The 'fPaintPtr' member acts a signal that the local SkPaint is valid 221 // (since only an SkPaint* is passed into the ctor). 222 const SkPaint* paint() const { return fPaintPtr; } 223 SkPaint* paint() { return fPaintPtr; } 224 225 void setPaint(const SkPaint& paint) { fPaint = paint; fPaintPtr = &fPaint; } 226 227 const SkRect* srcRect() const { return fSrc.isEmpty() ? NULL : &fSrc; } 228 void setSrcRect(const SkRect& src) { fSrc = src; } 229 230 const SkRect& dstRect() const { return fDst; } 231 void setDstRect(const SkRect& dst) { fDst = dst; } 232 233 SkCanvas::DrawBitmapRectFlags flags() const { return fFlags; } 234 void setFlags(SkCanvas::DrawBitmapRectFlags flags) { fFlags = flags; } 235 236private: 237 SkBitmap fBitmap; 238 SkRect fSrc; 239 SkRect fDst; 240 SkPaint fPaint; 241 SkPaint* fPaintPtr; 242 SkCanvas::DrawBitmapRectFlags fFlags; 243 244 typedef SkDrawCommand INHERITED; 245}; 246 247class SkDrawDataCommand : public SkDrawCommand { 248public: 249 SkDrawDataCommand(const void* data, size_t length); 250 virtual ~SkDrawDataCommand() { delete [] fData; } 251 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 252private: 253 char* fData; 254 size_t fLength; 255 256 typedef SkDrawCommand INHERITED; 257}; 258 259class SkBeginCommentGroupCommand : public SkDrawCommand { 260public: 261 SkBeginCommentGroupCommand(const char* description); 262 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE { 263 canvas->beginCommentGroup(fDescription.c_str()); 264 }; 265private: 266 SkString fDescription; 267 268 typedef SkDrawCommand INHERITED; 269}; 270 271class SkCommentCommand : public SkDrawCommand { 272public: 273 SkCommentCommand(const char* kywd, const char* value); 274 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE { 275 canvas->addComment(fKywd.c_str(), fValue.c_str()); 276 }; 277private: 278 SkString fKywd; 279 SkString fValue; 280 281 typedef SkDrawCommand INHERITED; 282}; 283 284class SkEndCommentGroupCommand : public SkDrawCommand { 285public: 286 SkEndCommentGroupCommand(); 287 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE { 288 canvas->endCommentGroup(); 289 }; 290private: 291 typedef SkDrawCommand INHERITED; 292}; 293 294class SkDrawOvalCommand : public SkDrawCommand { 295public: 296 SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint); 297 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 298 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 299private: 300 SkRect fOval; 301 SkPaint fPaint; 302 303 typedef SkDrawCommand INHERITED; 304}; 305 306class SkDrawPaintCommand : public SkDrawCommand { 307public: 308 SkDrawPaintCommand(const SkPaint& paint); 309 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 310 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 311private: 312 SkPaint fPaint; 313 314 typedef SkDrawCommand INHERITED; 315}; 316 317class SkDrawPathCommand : public SkDrawCommand { 318public: 319 SkDrawPathCommand(const SkPath& path, const SkPaint& paint); 320 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 321 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 322 323private: 324 SkPath fPath; 325 SkPaint fPaint; 326 327 typedef SkDrawCommand INHERITED; 328}; 329 330class SkDrawPictureCommand : public SkDrawCommand { 331public: 332 SkDrawPictureCommand(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint); 333 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 334 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 335 336private: 337 SkAutoTUnref<const SkPicture> fPicture; 338 SkMatrix fMatrix; 339 SkMatrix* fMatrixPtr; 340 SkPaint fPaint; 341 SkPaint* fPaintPtr; 342 343 typedef SkDrawCommand INHERITED; 344}; 345 346class SkDrawPointsCommand : public SkDrawCommand { 347public: 348 SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pts[], 349 const SkPaint& paint); 350 virtual ~SkDrawPointsCommand() { delete [] fPts; } 351 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 352 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 353private: 354 SkCanvas::PointMode fMode; 355 size_t fCount; 356 SkPoint* fPts; 357 SkPaint fPaint; 358 359 typedef SkDrawCommand INHERITED; 360}; 361 362class SkDrawTextCommand : public SkDrawCommand { 363public: 364 SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y, 365 const SkPaint& paint); 366 virtual ~SkDrawTextCommand() { delete [] fText; } 367 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 368private: 369 char* fText; 370 size_t fByteLength; 371 SkScalar fX; 372 SkScalar fY; 373 SkPaint fPaint; 374 375 typedef SkDrawCommand INHERITED; 376}; 377 378class SkDrawPosTextCommand : public SkDrawCommand { 379public: 380 SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[], 381 const SkPaint& paint); 382 virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; } 383 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 384private: 385 char* fText; 386 size_t fByteLength; 387 SkPoint* fPos; 388 SkPaint fPaint; 389 390 typedef SkDrawCommand INHERITED; 391}; 392 393class SkDrawTextOnPathCommand : public SkDrawCommand { 394public: 395 SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& path, 396 const SkMatrix* matrix, const SkPaint& paint); 397 virtual ~SkDrawTextOnPathCommand() { delete [] fText; } 398 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 399private: 400 char* fText; 401 size_t fByteLength; 402 SkPath fPath; 403 SkMatrix fMatrix; 404 SkPaint fPaint; 405 406 typedef SkDrawCommand INHERITED; 407}; 408 409class SkDrawPosTextHCommand : public SkDrawCommand { 410public: 411 SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xpos[], 412 SkScalar constY, const SkPaint& paint); 413 virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; } 414 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 415private: 416 SkScalar* fXpos; 417 char* fText; 418 size_t fByteLength; 419 SkScalar fConstY; 420 SkPaint fPaint; 421 422 typedef SkDrawCommand INHERITED; 423}; 424 425class SkDrawTextBlobCommand : public SkDrawCommand { 426public: 427 SkDrawTextBlobCommand(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint); 428 429 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 430 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 431 432private: 433 SkAutoTUnref<const SkTextBlob> fBlob; 434 SkScalar fXPos; 435 SkScalar fYPos; 436 SkPaint fPaint; 437 438 typedef SkDrawCommand INHERITED; 439}; 440 441class SkDrawRectCommand : public SkDrawCommand { 442public: 443 SkDrawRectCommand(const SkRect& rect, const SkPaint& paint); 444 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 445 446 const SkRect& rect() const { return fRect; } 447 const SkPaint& paint() const { return fPaint; } 448private: 449 SkRect fRect; 450 SkPaint fPaint; 451 452 typedef SkDrawCommand INHERITED; 453}; 454 455class SkDrawRRectCommand : public SkDrawCommand { 456public: 457 SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint); 458 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 459 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 460private: 461 SkRRect fRRect; 462 SkPaint fPaint; 463 464 typedef SkDrawCommand INHERITED; 465}; 466 467class SkDrawDRRectCommand : public SkDrawCommand { 468public: 469 SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner, 470 const SkPaint& paint); 471 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 472 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 473private: 474 SkRRect fOuter; 475 SkRRect fInner; 476 SkPaint fPaint; 477 478 typedef SkDrawCommand INHERITED; 479}; 480 481class SkDrawSpriteCommand : public SkDrawCommand { 482public: 483 SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint* paint); 484 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 485 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; 486private: 487 SkBitmap fBitmap; 488 int fLeft; 489 int fTop; 490 SkPaint fPaint; 491 SkPaint* fPaintPtr; 492 493 typedef SkDrawCommand INHERITED; 494}; 495 496class SkDrawVerticesCommand : public SkDrawCommand { 497public: 498 SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount, 499 const SkPoint vertices[], const SkPoint texs[], 500 const SkColor colors[], SkXfermode* xfermode, 501 const uint16_t indices[], int indexCount, 502 const SkPaint& paint); 503 virtual ~SkDrawVerticesCommand(); 504 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 505private: 506 SkCanvas::VertexMode fVmode; 507 int fVertexCount; 508 SkPoint* fVertices; 509 SkPoint* fTexs; 510 SkColor* fColors; 511 SkXfermode* fXfermode; 512 uint16_t* fIndices; 513 int fIndexCount; 514 SkPaint fPaint; 515 516 typedef SkDrawCommand INHERITED; 517}; 518 519class SkRotateCommand : public SkDrawCommand { 520public: 521 SkRotateCommand(SkScalar degrees); 522 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 523private: 524 SkScalar fDegrees; 525 526 typedef SkDrawCommand INHERITED; 527}; 528 529class SkSaveCommand : public SkDrawCommand { 530public: 531 SkSaveCommand(); 532 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 533 virtual void trackSaveState(int* state) SK_OVERRIDE; 534 virtual Action action() const SK_OVERRIDE { return kPushLayer_Action; } 535private: 536 typedef SkDrawCommand INHERITED; 537}; 538 539class SkSaveLayerCommand : public SkDrawCommand { 540public: 541 SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint, 542 SkCanvas::SaveFlags flags); 543 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 544 virtual void vizExecute(SkCanvas* canvas) const SK_OVERRIDE; 545 virtual void trackSaveState(int* state) SK_OVERRIDE; 546 virtual Action action() const SK_OVERRIDE{ return kPushLayer_Action; } 547 virtual void setActive(bool active) SK_OVERRIDE { fActive = active; } 548 virtual bool active() const SK_OVERRIDE { return fActive; } 549 550 const SkPaint* paint() const { return fPaintPtr; } 551 552private: 553 SkRect fBounds; 554 SkPaint fPaint; 555 SkPaint* fPaintPtr; 556 SkCanvas::SaveFlags fFlags; 557 558 bool fActive; 559 560 typedef SkDrawCommand INHERITED; 561}; 562 563class SkScaleCommand : public SkDrawCommand { 564public: 565 SkScaleCommand(SkScalar sx, SkScalar sy); 566 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 567 568 SkScalar x() const { return fSx; } 569 SkScalar y() const { return fSy; } 570 571private: 572 SkScalar fSx; 573 SkScalar fSy; 574 575 typedef SkDrawCommand INHERITED; 576}; 577 578class SkSetMatrixCommand : public SkDrawCommand { 579public: 580 SkSetMatrixCommand(const SkMatrix& matrix); 581 virtual void setUserMatrix(const SkMatrix&) SK_OVERRIDE; 582 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 583private: 584 SkMatrix fUserMatrix; 585 SkMatrix fMatrix; 586 587 typedef SkDrawCommand INHERITED; 588}; 589 590class SkSkewCommand : public SkDrawCommand { 591public: 592 SkSkewCommand(SkScalar sx, SkScalar sy); 593 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 594private: 595 SkScalar fSx; 596 SkScalar fSy; 597 598 typedef SkDrawCommand INHERITED; 599}; 600 601class SkTranslateCommand : public SkDrawCommand { 602public: 603 SkTranslateCommand(SkScalar dx, SkScalar dy); 604 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 605 606 SkScalar x() const { return fDx; } 607 SkScalar y() const { return fDy; } 608 609private: 610 SkScalar fDx; 611 SkScalar fDy; 612 613 typedef SkDrawCommand INHERITED; 614}; 615 616class SkPushCullCommand : public SkDrawCommand { 617public: 618 SkPushCullCommand(const SkRect&); 619 virtual void execute(SkCanvas*) const SK_OVERRIDE; 620 virtual void vizExecute(SkCanvas* canvas) const SK_OVERRIDE; 621 virtual Action action() const { return kPushCull_Action; } 622 virtual void setActive(bool active) { fActive = active; } 623 virtual bool active() const { return fActive; } 624private: 625 SkRect fCullRect; 626 bool fActive; 627 628 typedef SkDrawCommand INHERITED; 629}; 630 631class SkPopCullCommand : public SkDrawCommand { 632public: 633 SkPopCullCommand(); 634 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; 635 virtual Action action() const { return kPopCull_Action; } 636private: 637 typedef SkDrawCommand INHERITED; 638}; 639 640#endif 641