blob: aed87cc22120e4e03f3e6af004ddebe8c9f638b5 [file] [log] [blame]
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkColorPriv.h"
#include "SkDebugCanvas.h"
#include "SkDrawCommand.h"
#include "SkDrawFilter.h"
#include "SkDevice.h"
#include "SkXfermode.h"
SkDebugCanvas::SkDebugCanvas(int width, int height)
: INHERITED(width, height)
, fPicture(NULL)
, fFilter(false)
, fMegaVizMode(false)
, fOverdrawViz(false)
, fOverdrawFilter(NULL)
, fOverrideTexFiltering(false)
, fTexOverrideFilter(NULL) {
fUserMatrix.reset();
// SkPicturePlayback uses the base-class' quickReject calls to cull clipped
// operations. This can lead to problems in the debugger which expects all
// the operations in the captured skp to appear in the debug canvas. To
// circumvent this we create a wide open clip here (an empty clip rect
// is not sufficient).
// Internally, the SkRect passed to clipRect is converted to an SkIRect and
// rounded out. The following code creates a nearly maximal rect that will
// not get collapsed by the coming conversions (Due to precision loss the
// inset has to be surprisingly large).
SkIRect largeIRect = SkIRect::MakeLargest();
largeIRect.inset(1024, 1024);
SkRect large = SkRect::Make(largeIRect);
#ifdef SK_DEBUG
SkASSERT(!large.roundOut().isEmpty());
#endif
// call the base class' version to avoid adding a draw command
this->INHERITED::onClipRect(large, SkRegion::kReplace_Op, kHard_ClipEdgeStyle);
}
SkDebugCanvas::~SkDebugCanvas() {
fCommandVector.deleteAll();
SkSafeUnref(fOverdrawFilter);
SkSafeUnref(fTexOverrideFilter);
}
void SkDebugCanvas::addDrawCommand(SkDrawCommand* command) {
command->setOffset(this->getOpID());
fCommandVector.push(command);
}
void SkDebugCanvas::draw(SkCanvas* canvas) {
if (!fCommandVector.isEmpty()) {
this->drawTo(canvas, fCommandVector.count() - 1);
}
}
void SkDebugCanvas::applyUserTransform(SkCanvas* canvas) {
canvas->concat(fUserMatrix);
}
int SkDebugCanvas::getCommandAtPoint(int x, int y, int index) {
SkBitmap bitmap;
bitmap.allocPixels(SkImageInfo::MakeN32Premul(1, 1));
SkCanvas canvas(bitmap);
canvas.translate(SkIntToScalar(-x), SkIntToScalar(-y));
this->applyUserTransform(&canvas);
int layer = 0;
SkColor prev = bitmap.getColor(0,0);
for (int i = 0; i < index; i++) {
if (fCommandVector[i]->isVisible()) {
fCommandVector[i]->setUserMatrix(fUserMatrix);
fCommandVector[i]->execute(&canvas);
}
if (prev != bitmap.getColor(0,0)) {
layer = i;
}
prev = bitmap.getColor(0,0);
}
return layer;
}
class OverdrawXfermode : public SkXfermode {
public:
SkPMColor xferColor(SkPMColor src, SkPMColor dst) const SK_OVERRIDE {
// This table encodes the color progression of the overdraw visualization
static const SkPMColor gTable[] = {
SkPackARGB32(0x00, 0x00, 0x00, 0x00),
SkPackARGB32(0xFF, 128, 158, 255),
SkPackARGB32(0xFF, 170, 185, 212),
SkPackARGB32(0xFF, 213, 195, 170),
SkPackARGB32(0xFF, 255, 192, 127),
SkPackARGB32(0xFF, 255, 185, 85),
SkPackARGB32(0xFF, 255, 165, 42),
SkPackARGB32(0xFF, 255, 135, 0),
SkPackARGB32(0xFF, 255, 95, 0),
SkPackARGB32(0xFF, 255, 50, 0),
SkPackARGB32(0xFF, 255, 0, 0)
};
for (size_t i = 0; i < SK_ARRAY_COUNT(gTable)-1; ++i) {
if (gTable[i] == dst) {
return gTable[i+1];
}
}
return gTable[SK_ARRAY_COUNT(gTable)-1];
}
Factory getFactory() const SK_OVERRIDE { return NULL; }
#ifndef SK_IGNORE_TO_STRING
virtual void toString(SkString* str) const SK_OVERRIDE { str->set("OverdrawXfermode"); }
#endif
};
class SkOverdrawFilter : public SkDrawFilter {
public:
SkOverdrawFilter() {
fXferMode = SkNEW(OverdrawXfermode);
}
virtual ~SkOverdrawFilter() {
delete fXferMode;
}
bool filter(SkPaint* p, Type) SK_OVERRIDE {
p->setXfermode(fXferMode);
return true;
}
protected:
SkXfermode* fXferMode;
private:
typedef SkDrawFilter INHERITED;
};
// SkTexOverrideFilter modifies every paint to use the specified
// texture filtering mode
class SkTexOverrideFilter : public SkDrawFilter {
public:
SkTexOverrideFilter() : fFilterLevel(SkPaint::kNone_FilterLevel) {
}
void setFilterLevel(SkPaint::FilterLevel filterLevel) {
fFilterLevel = filterLevel;
}
bool filter(SkPaint* p, Type) SK_OVERRIDE {
p->setFilterLevel(fFilterLevel);
return true;
}
protected:
SkPaint::FilterLevel fFilterLevel;
private:
typedef SkDrawFilter INHERITED;
};
class SkDebugClipVisitor : public SkCanvas::ClipVisitor {
public:
SkDebugClipVisitor(SkCanvas* canvas) : fCanvas(canvas) {}
void clipRect(const SkRect& r, SkRegion::Op, bool doAA) SK_OVERRIDE {
SkPaint p;
p.setColor(SK_ColorRED);
p.setStyle(SkPaint::kStroke_Style);
p.setAntiAlias(doAA);
fCanvas->drawRect(r, p);
}
void clipRRect(const SkRRect& rr, SkRegion::Op, bool doAA) SK_OVERRIDE {
SkPaint p;
p.setColor(SK_ColorGREEN);
p.setStyle(SkPaint::kStroke_Style);
p.setAntiAlias(doAA);
fCanvas->drawRRect(rr, p);
}
void clipPath(const SkPath& path, SkRegion::Op, bool doAA) SK_OVERRIDE {
SkPaint p;
p.setColor(SK_ColorBLUE);
p.setStyle(SkPaint::kStroke_Style);
p.setAntiAlias(doAA);
fCanvas->drawPath(path, p);
}
protected:
SkCanvas* fCanvas;
private:
typedef SkCanvas::ClipVisitor INHERITED;
};
// set up the saveLayer commands so that the active ones
// return true in their 'active' method
void SkDebugCanvas::markActiveCommands(int index) {
fActiveLayers.rewind();
for (int i = 0; i < fCommandVector.count(); ++i) {
fCommandVector[i]->setActive(false);
}
for (int i = 0; i < index; ++i) {
SkDrawCommand::Action result = fCommandVector[i]->action();
if (SkDrawCommand::kPushLayer_Action == result) {
fActiveLayers.push(fCommandVector[i]);
} else if (SkDrawCommand::kPopLayer_Action == result) {
fActiveLayers.pop();
}
}
for (int i = 0; i < fActiveLayers.count(); ++i) {
fActiveLayers[i]->setActive(true);
}
}
void SkDebugCanvas::drawTo(SkCanvas* canvas, int index) {
SkASSERT(!fCommandVector.isEmpty());
SkASSERT(index < fCommandVector.count());
int saveCount = canvas->save();
SkRect windowRect = SkRect::MakeWH(SkIntToScalar(canvas->getBaseLayerSize().width()),
SkIntToScalar(canvas->getBaseLayerSize().height()));
bool pathOpsMode = getAllowSimplifyClip();
canvas->setAllowSimplifyClip(pathOpsMode);
canvas->clear(SK_ColorTRANSPARENT);
canvas->resetMatrix();
if (!windowRect.isEmpty()) {
canvas->clipRect(windowRect, SkRegion::kReplace_Op);
}
this->applyUserTransform(canvas);
// The setting of the draw filter has to go here (rather than in
// SkRasterWidget) due to the canvas restores this class performs.
// Since the draw filter is stored in the layer stack if we
// call setDrawFilter on anything but the root layer odd things happen.
if (fOverdrawViz) {
if (NULL == fOverdrawFilter) {
fOverdrawFilter = new SkOverdrawFilter;
}
if (fOverdrawFilter != canvas->getDrawFilter()) {
canvas->setDrawFilter(fOverdrawFilter);
}
} else if (fOverrideTexFiltering) {
if (NULL == fTexOverrideFilter) {
fTexOverrideFilter = new SkTexOverrideFilter;
}
if (fTexOverrideFilter != canvas->getDrawFilter()) {
canvas->setDrawFilter(fTexOverrideFilter);
}
} else {
canvas->setDrawFilter(NULL);
}
if (fMegaVizMode) {
this->markActiveCommands(index);
}
for (int i = 0; i <= index; i++) {
if (i == index && fFilter) {
canvas->clear(0xAAFFFFFF);
}
if (fCommandVector[i]->isVisible()) {
if (fMegaVizMode && fCommandVector[i]->active()) {
// "active" commands execute their visualization behaviors:
// All active saveLayers get replaced with saves so all draws go to the
// visible canvas.
// All active culls draw their cull box
fCommandVector[i]->vizExecute(canvas);
} else {
fCommandVector[i]->setUserMatrix(fUserMatrix);
fCommandVector[i]->execute(canvas);
}
}
}
if (fMegaVizMode) {
canvas->save();
// nuke the CTM
canvas->resetMatrix();
// turn off clipping
if (!windowRect.isEmpty()) {
SkRect r = windowRect;
r.outset(SK_Scalar1, SK_Scalar1);
canvas->clipRect(r, SkRegion::kReplace_Op);
}
// visualize existing clips
SkDebugClipVisitor visitor(canvas);
canvas->replayClips(&visitor);
canvas->restore();
}
if (pathOpsMode) {
this->resetClipStackData();
const SkClipStack* clipStack = canvas->getClipStack();
SkClipStack::Iter iter(*clipStack, SkClipStack::Iter::kBottom_IterStart);
const SkClipStack::Element* element;
SkPath devPath;
while ((element = iter.next())) {
SkClipStack::Element::Type type = element->getType();
SkPath operand;
if (type != SkClipStack::Element::kEmpty_Type) {
element->asPath(&operand);
}
SkRegion::Op elementOp = element->getOp();
this->addClipStackData(devPath, operand, elementOp);
if (elementOp == SkRegion::kReplace_Op) {
devPath = operand;
} else {
Op(devPath, operand, (SkPathOp) elementOp, &devPath);
}
}
this->lastClipStackData(devPath);
}
fMatrix = canvas->getTotalMatrix();
if (!canvas->getClipDeviceBounds(&fClip)) {
fClip.setEmpty();
}
canvas->restoreToCount(saveCount);
}
void SkDebugCanvas::deleteDrawCommandAt(int index) {
SkASSERT(index < fCommandVector.count());
delete fCommandVector[index];
fCommandVector.remove(index);
}
SkDrawCommand* SkDebugCanvas::getDrawCommandAt(int index) {
SkASSERT(index < fCommandVector.count());
return fCommandVector[index];
}
void SkDebugCanvas::setDrawCommandAt(int index, SkDrawCommand* command) {
SkASSERT(index < fCommandVector.count());
delete fCommandVector[index];
fCommandVector[index] = command;
}
const SkTDArray<SkString*>* SkDebugCanvas::getCommandInfo(int index) const {
SkASSERT(index < fCommandVector.count());
return fCommandVector[index]->Info();
}
bool SkDebugCanvas::getDrawCommandVisibilityAt(int index) {
SkASSERT(index < fCommandVector.count());
return fCommandVector[index]->isVisible();
}
const SkTDArray <SkDrawCommand*>& SkDebugCanvas::getDrawCommands() const {
return fCommandVector;
}
SkTDArray <SkDrawCommand*>& SkDebugCanvas::getDrawCommands() {
return fCommandVector;
}
void SkDebugCanvas::overrideTexFiltering(bool overrideTexFiltering, SkPaint::FilterLevel level) {
if (NULL == fTexOverrideFilter) {
fTexOverrideFilter = new SkTexOverrideFilter;
}
fOverrideTexFiltering = overrideTexFiltering;
fTexOverrideFilter->setFilterLevel(level);
}
void SkDebugCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
this->addDrawCommand(new SkClipPathCommand(path, op, kSoft_ClipEdgeStyle == edgeStyle));
}
void SkDebugCanvas::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
this->addDrawCommand(new SkClipRectCommand(rect, op, kSoft_ClipEdgeStyle == edgeStyle));
}
void SkDebugCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
this->addDrawCommand(new SkClipRRectCommand(rrect, op, kSoft_ClipEdgeStyle == edgeStyle));
}
void SkDebugCanvas::onClipRegion(const SkRegion& region, SkRegion::Op op) {
this->addDrawCommand(new SkClipRegionCommand(region, op));
}
void SkDebugCanvas::didConcat(const SkMatrix& matrix) {
this->addDrawCommand(new SkConcatCommand(matrix));
this->INHERITED::didConcat(matrix);
}
void SkDebugCanvas::onDrawBitmap(const SkBitmap& bitmap, SkScalar left,
SkScalar top, const SkPaint* paint) {
this->addDrawCommand(new SkDrawBitmapCommand(bitmap, left, top, paint));
}
void SkDebugCanvas::onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst,
const SkPaint* paint, DrawBitmapRectFlags flags) {
this->addDrawCommand(new SkDrawBitmapRectCommand(bitmap, src, dst, paint, flags));
}
void SkDebugCanvas::onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
const SkRect& dst, const SkPaint* paint) {
this->addDrawCommand(new SkDrawBitmapNineCommand(bitmap, center, dst, paint));
}
void SkDebugCanvas::onDrawImage(const SkImage* image, SkScalar left, SkScalar top,
const SkPaint* paint) {
SkDebugf("SkDebugCanvas::onDrawImage unimplemented\n");
}
void SkDebugCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
const SkPaint* paint) {
SkDebugf("SkDebugCanvas::onDrawImageRect unimplemented\n");
}
void SkDebugCanvas::beginCommentGroup(const char* description) {
this->addDrawCommand(new SkBeginCommentGroupCommand(description));
}
void SkDebugCanvas::addComment(const char* kywd, const char* value) {
this->addDrawCommand(new SkCommentCommand(kywd, value));
}
void SkDebugCanvas::endCommentGroup() {
this->addDrawCommand(new SkEndCommentGroupCommand());
}
void SkDebugCanvas::onDrawOval(const SkRect& oval, const SkPaint& paint) {
this->addDrawCommand(new SkDrawOvalCommand(oval, paint));
}
void SkDebugCanvas::onDrawPaint(const SkPaint& paint) {
this->addDrawCommand(new SkDrawPaintCommand(paint));
}
void SkDebugCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
this->addDrawCommand(new SkDrawPathCommand(path, paint));
}
void SkDebugCanvas::onDrawPicture(const SkPicture* picture,
const SkMatrix* matrix,
const SkPaint* paint) {
this->addDrawCommand(new SkDrawPictureCommand(picture, matrix, paint));
}
void SkDebugCanvas::onDrawPoints(PointMode mode, size_t count,
const SkPoint pts[], const SkPaint& paint) {
this->addDrawCommand(new SkDrawPointsCommand(mode, count, pts, paint));
}
void SkDebugCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
const SkPaint& paint) {
this->addDrawCommand(new SkDrawPosTextCommand(text, byteLength, pos, paint));
}
void SkDebugCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
SkScalar constY, const SkPaint& paint) {
this->addDrawCommand(
new SkDrawPosTextHCommand(text, byteLength, xpos, constY, paint));
}
void SkDebugCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) {
// NOTE(chudy): Messing up when renamed to DrawRect... Why?
addDrawCommand(new SkDrawRectCommand(rect, paint));
}
void SkDebugCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
this->addDrawCommand(new SkDrawRRectCommand(rrect, paint));
}
void SkDebugCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
const SkPaint& paint) {
this->addDrawCommand(new SkDrawDRRectCommand(outer, inner, paint));
}
void SkDebugCanvas::onDrawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint) {
this->addDrawCommand(new SkDrawSpriteCommand(bitmap, left, top, paint));
}
void SkDebugCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
const SkPaint& paint) {
this->addDrawCommand(new SkDrawTextCommand(text, byteLength, x, y, paint));
}
void SkDebugCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
const SkMatrix* matrix, const SkPaint& paint) {
this->addDrawCommand(
new SkDrawTextOnPathCommand(text, byteLength, path, matrix, paint));
}
void SkDebugCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
const SkPaint& paint) {
this->addDrawCommand(new SkDrawTextBlobCommand(blob, x, y, paint));
}
void SkDebugCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode,
const SkPaint& paint) {
this->addDrawCommand(new SkDrawPatchCommand(cubics, colors, texCoords, xmode, paint));
}
void SkDebugCanvas::onDrawVertices(VertexMode vmode, int vertexCount, const SkPoint vertices[],
const SkPoint texs[], const SkColor colors[],
SkXfermode*, const uint16_t indices[], int indexCount,
const SkPaint& paint) {
this->addDrawCommand(new SkDrawVerticesCommand(vmode, vertexCount, vertices,
texs, colors, NULL, indices, indexCount, paint));
}
void SkDebugCanvas::willRestore() {
this->addDrawCommand(new SkRestoreCommand());
this->INHERITED::willRestore();
}
void SkDebugCanvas::willSave() {
this->addDrawCommand(new SkSaveCommand());
this->INHERITED::willSave();
}
SkCanvas::SaveLayerStrategy SkDebugCanvas::willSaveLayer(const SkRect* bounds, const SkPaint* paint,
SaveFlags flags) {
this->addDrawCommand(new SkSaveLayerCommand(bounds, paint, flags));
this->INHERITED::willSaveLayer(bounds, paint, flags);
// No need for a full layer.
return kNoLayer_SaveLayerStrategy;
}
void SkDebugCanvas::didSetMatrix(const SkMatrix& matrix) {
this->addDrawCommand(new SkSetMatrixCommand(matrix));
this->INHERITED::didSetMatrix(matrix);
}
void SkDebugCanvas::toggleCommand(int index, bool toggle) {
SkASSERT(index < fCommandVector.count());
fCommandVector[index]->setVisible(toggle);
}
static const char* gFillTypeStrs[] = {
"kWinding_FillType",
"kEvenOdd_FillType",
"kInverseWinding_FillType",
"kInverseEvenOdd_FillType"
};
static const char* gOpStrs[] = {
"kDifference_PathOp",
"kIntersect_PathOp",
"kUnion_PathOp",
"kXor_PathOp",
"kReverseDifference_PathOp",
};
static const char kHTML4SpaceIndent[] = "&nbsp;&nbsp;&nbsp;&nbsp;";
void SkDebugCanvas::outputScalar(SkScalar num) {
if (num == (int) num) {
fClipStackData.appendf("%d", (int) num);
} else {
SkString str;
str.printf("%1.9g", num);
int width = (int) str.size();
const char* cStr = str.c_str();
while (cStr[width - 1] == '0') {
--width;
}
str.resize(width);
fClipStackData.appendf("%sf", str.c_str());
}
}
void SkDebugCanvas::outputPointsCommon(const SkPoint* pts, int count) {
for (int index = 0; index < count; ++index) {
this->outputScalar(pts[index].fX);
fClipStackData.appendf(", ");
this->outputScalar(pts[index].fY);
if (index + 1 < count) {
fClipStackData.appendf(", ");
}
}
}
void SkDebugCanvas::outputPoints(const SkPoint* pts, int count) {
this->outputPointsCommon(pts, count);
fClipStackData.appendf(");<br>");
}
void SkDebugCanvas::outputConicPoints(const SkPoint* pts, SkScalar weight) {
this->outputPointsCommon(pts, 2);
fClipStackData.appendf(", ");
this->outputScalar(weight);
fClipStackData.appendf(");<br>");
}
void SkDebugCanvas::addPathData(const SkPath& path, const char* pathName) {
SkPath::RawIter iter(path);
SkPath::FillType fillType = path.getFillType();
fClipStackData.appendf("%sSkPath %s;<br>", kHTML4SpaceIndent, pathName);
fClipStackData.appendf("%s%s.setFillType(SkPath::%s);<br>", kHTML4SpaceIndent, pathName,
gFillTypeStrs[fillType]);
iter.setPath(path);
uint8_t verb;
SkPoint pts[4];
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
switch (verb) {
case SkPath::kMove_Verb:
fClipStackData.appendf("%s%s.moveTo(", kHTML4SpaceIndent, pathName);
this->outputPoints(&pts[0], 1);
continue;
case SkPath::kLine_Verb:
fClipStackData.appendf("%s%s.lineTo(", kHTML4SpaceIndent, pathName);
this->outputPoints(&pts[1], 1);
break;
case SkPath::kQuad_Verb:
fClipStackData.appendf("%s%s.quadTo(", kHTML4SpaceIndent, pathName);
this->outputPoints(&pts[1], 2);
break;
case SkPath::kConic_Verb:
fClipStackData.appendf("%s%s.conicTo(", kHTML4SpaceIndent, pathName);
this->outputConicPoints(&pts[1], iter.conicWeight());
break;
case SkPath::kCubic_Verb:
fClipStackData.appendf("%s%s.cubicTo(", kHTML4SpaceIndent, pathName);
this->outputPoints(&pts[1], 3);
break;
case SkPath::kClose_Verb:
fClipStackData.appendf("%s%s.close();<br>", kHTML4SpaceIndent, pathName);
break;
default:
SkDEBUGFAIL("bad verb");
return;
}
}
}
void SkDebugCanvas::addClipStackData(const SkPath& devPath, const SkPath& operand,
SkRegion::Op elementOp) {
if (elementOp == SkRegion::kReplace_Op) {
if (!lastClipStackData(devPath)) {
fSaveDevPath = operand;
}
fCalledAddStackData = false;
} else {
fClipStackData.appendf("<br>static void test(skiatest::Reporter* reporter,"
" const char* filename) {<br>");
addPathData(fCalledAddStackData ? devPath : fSaveDevPath, "path");
addPathData(operand, "pathB");
fClipStackData.appendf("%stestPathOp(reporter, path, pathB, %s, filename);<br>",
kHTML4SpaceIndent, gOpStrs[elementOp]);
fClipStackData.appendf("}<br>");
fCalledAddStackData = true;
}
}
bool SkDebugCanvas::lastClipStackData(const SkPath& devPath) {
if (fCalledAddStackData) {
fClipStackData.appendf("<br>");
addPathData(devPath, "pathOut");
return true;
}
return false;
}