AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
b8a3f9d6b8
skia2/tools/debugger/SkDrawCommand.cpp
Mike Reed 8d0f82408b Some clangtidy fixes 
Bug: skia:
Change-Id: I751f93394812bdfab40cd322a23255e18fa2440a
Reviewed-on: https://skia-review.googlesource.com/c/187387
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>
Auto-Submit: Mike Reed <reed@google.com>
2019-01-28 20:45:16 +00:00

2104 lines
77 KiB
C++
Raw Blame History

/*
* 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 "SkDrawCommand.h"
#include <algorithm>
#include "SkAutoMalloc.h"
#include "SkClipOpPriv.h"
#include "SkColorFilter.h"
#include "SkDashPathEffect.h"
#include "SkDrawable.h"
#include "SkImageFilter.h"
#include "SkJsonWriteBuffer.h"
#include "SkLatticeIter.h"
#include "SkMaskFilterBase.h"
#include "SkPaintDefaults.h"
#include "SkPathEffect.h"
#include "SkPicture.h"
#include "SkPngEncoder.h"
#include "SkReadBuffer.h"
#include "SkRectPriv.h"
#include "SkShadowFlags.h"
#include "SkTHash.h"
#include "SkTextBlobPriv.h"
#include "SkTypeface.h"
#include "SkWriteBuffer.h"
#define SKDEBUGCANVAS_ATTRIBUTE_COMMAND "command"
#define SKDEBUGCANVAS_ATTRIBUTE_VISIBLE "visible"
#define SKDEBUGCANVAS_ATTRIBUTE_MATRIX "matrix"
#define SKDEBUGCANVAS_ATTRIBUTE_DRAWDEPTHTRANS "drawDepthTranslation"
#define SKDEBUGCANVAS_ATTRIBUTE_COORDS "coords"
#define SKDEBUGCANVAS_ATTRIBUTE_EDGING "edging"
#define SKDEBUGCANVAS_ATTRIBUTE_HINTING "hinting"
#define SKDEBUGCANVAS_ATTRIBUTE_BOUNDS "bounds"
#define SKDEBUGCANVAS_ATTRIBUTE_PAINT "paint"
#define SKDEBUGCANVAS_ATTRIBUTE_OUTER "outer"
#define SKDEBUGCANVAS_ATTRIBUTE_INNER "inner"
#define SKDEBUGCANVAS_ATTRIBUTE_MODE "mode"
#define SKDEBUGCANVAS_ATTRIBUTE_POINTS "points"
#define SKDEBUGCANVAS_ATTRIBUTE_PATH "path"
#define SKDEBUGCANVAS_ATTRIBUTE_TEXT "text"
#define SKDEBUGCANVAS_ATTRIBUTE_COLOR "color"
#define SKDEBUGCANVAS_ATTRIBUTE_ALPHA "alpha"
#define SKDEBUGCANVAS_ATTRIBUTE_BLENDMODE "blendMode"
#define SKDEBUGCANVAS_ATTRIBUTE_STYLE "style"
#define SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH "strokeWidth"
#define SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER "strokeMiter"
#define SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN "strokeJoin"
#define SKDEBUGCANVAS_ATTRIBUTE_CAP "cap"
#define SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS "antiAlias"
#define SKDEBUGCANVAS_ATTRIBUTE_DITHER "dither"
#define SKDEBUGCANVAS_ATTRIBUTE_FAKEBOLDTEXT "fakeBoldText"
#define SKDEBUGCANVAS_ATTRIBUTE_LINEARTEXT "linearText"
#define SKDEBUGCANVAS_ATTRIBUTE_SUBPIXELTEXT "subpixelText"
#define SKDEBUGCANVAS_ATTRIBUTE_DEVKERNTEXT "devKernText"
#define SKDEBUGCANVAS_ATTRIBUTE_LCDRENDERTEXT "lcdRenderText"
#define SKDEBUGCANVAS_ATTRIBUTE_EMBEDDEDBITMAPTEXT "embeddedBitmapText"
#define SKDEBUGCANVAS_ATTRIBUTE_AUTOHINTING "forceAutoHinting"
#define SKDEBUGCANVAS_ATTRIBUTE_REGION "region"
#define SKDEBUGCANVAS_ATTRIBUTE_REGIONOP "op"
#define SKDEBUGCANVAS_ATTRIBUTE_EDGESTYLE "edgeStyle"
#define SKDEBUGCANVAS_ATTRIBUTE_DEVICEREGION "deviceRegion"
#define SKDEBUGCANVAS_ATTRIBUTE_BLUR "blur"
#define SKDEBUGCANVAS_ATTRIBUTE_SIGMA "sigma"
#define SKDEBUGCANVAS_ATTRIBUTE_QUALITY "quality"
#define SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE "textSize"
#define SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX "textScaleX"
#define SKDEBUGCANVAS_ATTRIBUTE_TEXTSKEWX "textSkewX"
#define SKDEBUGCANVAS_ATTRIBUTE_DASHING "dashing"
#define SKDEBUGCANVAS_ATTRIBUTE_INTERVALS "intervals"
#define SKDEBUGCANVAS_ATTRIBUTE_PHASE "phase"
#define SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE "fillType"
#define SKDEBUGCANVAS_ATTRIBUTE_VERBS "verbs"
#define SKDEBUGCANVAS_ATTRIBUTE_NAME "name"
#define SKDEBUGCANVAS_ATTRIBUTE_DATA "data"
#define SKDEBUGCANVAS_ATTRIBUTE_VALUES "values"
#define SKDEBUGCANVAS_ATTRIBUTE_SHADER "shader"
#define SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT "pathEffect"
#define SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER "maskFilter"
#define SKDEBUGCANVAS_ATTRIBUTE_XFERMODE "xfermode"
#define SKDEBUGCANVAS_ATTRIBUTE_LOOPER "looper"
#define SKDEBUGCANVAS_ATTRIBUTE_BACKDROP "backdrop"
#define SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER "colorfilter"
#define SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER "imagefilter"
#define SKDEBUGCANVAS_ATTRIBUTE_IMAGE "image"
#define SKDEBUGCANVAS_ATTRIBUTE_BITMAP "bitmap"
#define SKDEBUGCANVAS_ATTRIBUTE_SRC "src"
#define SKDEBUGCANVAS_ATTRIBUTE_DST "dst"
#define SKDEBUGCANVAS_ATTRIBUTE_CENTER "center"
#define SKDEBUGCANVAS_ATTRIBUTE_STRICT "strict"
#define SKDEBUGCANVAS_ATTRIBUTE_DESCRIPTION "description"
#define SKDEBUGCANVAS_ATTRIBUTE_X "x"
#define SKDEBUGCANVAS_ATTRIBUTE_Y "y"
#define SKDEBUGCANVAS_ATTRIBUTE_RUNS "runs"
#define SKDEBUGCANVAS_ATTRIBUTE_POSITIONS "positions"
#define SKDEBUGCANVAS_ATTRIBUTE_GLYPHS "glyphs"
#define SKDEBUGCANVAS_ATTRIBUTE_FONT "font"
#define SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE "typeface"
#define SKDEBUGCANVAS_ATTRIBUTE_CUBICS "cubics"
#define SKDEBUGCANVAS_ATTRIBUTE_COLORS "colors"
#define SKDEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS "textureCoords"
#define SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY "filterQuality"
#define SKDEBUGCANVAS_ATTRIBUTE_STARTANGLE "startAngle"
#define SKDEBUGCANVAS_ATTRIBUTE_SWEEPANGLE "sweepAngle"
#define SKDEBUGCANVAS_ATTRIBUTE_USECENTER "useCenter"
#define SKDEBUGCANVAS_ATTRIBUTE_SHORTDESC "shortDesc"
#define SKDEBUGCANVAS_ATTRIBUTE_UNIQUE_ID "uniqueID"
#define SKDEBUGCANVAS_ATTRIBUTE_WIDTH "width"
#define SKDEBUGCANVAS_ATTRIBUTE_HEIGHT "height"
#define SKDEBUGCANVAS_ATTRIBUTE_ALPHA "alpha"
#define SKDEBUGCANVAS_ATTRIBUTE_LATTICE "lattice"
#define SKDEBUGCANVAS_ATTRIBUTE_LATTICEXCOUNT "xCount"
#define SKDEBUGCANVAS_ATTRIBUTE_LATTICEYCOUNT "yCount"
#define SKDEBUGCANVAS_ATTRIBUTE_LATTICEXDIVS "xDivs"
#define SKDEBUGCANVAS_ATTRIBUTE_LATTICEYDIVS "yDivs"
#define SKDEBUGCANVAS_ATTRIBUTE_LATTICEFLAGS "flags"
#define SKDEBUGCANVAS_ATTRIBUTE_ZPLANE "zPlane"
#define SKDEBUGCANVAS_ATTRIBUTE_LIGHTPOSITION "lightPositions"
#define SKDEBUGCANVAS_ATTRIBUTE_AMBIENTCOLOR "ambientColor"
#define SKDEBUGCANVAS_ATTRIBUTE_SPOTCOLOR "spotColor"
#define SKDEBUGCANVAS_ATTRIBUTE_LIGHTRADIUS "lightRadius"
#define SKDEBUGCANVAS_VERB_MOVE "move"
#define SKDEBUGCANVAS_VERB_LINE "line"
#define SKDEBUGCANVAS_VERB_QUAD "quad"
#define SKDEBUGCANVAS_VERB_CUBIC "cubic"
#define SKDEBUGCANVAS_VERB_CONIC "conic"
#define SKDEBUGCANVAS_VERB_CLOSE "close"
#define SKDEBUGCANVAS_STYLE_FILL "fill"
#define SKDEBUGCANVAS_STYLE_STROKE "stroke"
#define SKDEBUGCANVAS_STYLE_STROKEANDFILL "strokeAndFill"
#define SKDEBUGCANVAS_POINTMODE_POINTS "points"
#define SKDEBUGCANVAS_POINTMODE_LINES "lines"
#define SKDEBUGCANVAS_POINTMODE_POLYGON "polygon"
#define SKDEBUGCANVAS_REGIONOP_DIFFERENCE "difference"
#define SKDEBUGCANVAS_REGIONOP_INTERSECT "intersect"
#define SKDEBUGCANVAS_REGIONOP_UNION "union"
#define SKDEBUGCANVAS_REGIONOP_XOR "xor"
#define SKDEBUGCANVAS_REGIONOP_REVERSE_DIFFERENCE "reverseDifference"
#define SKDEBUGCANVAS_REGIONOP_REPLACE "replace"
#define SKDEBUGCANVAS_BLURSTYLE_NORMAL "normal"
#define SKDEBUGCANVAS_BLURSTYLE_SOLID "solid"
#define SKDEBUGCANVAS_BLURSTYLE_OUTER "outer"
#define SKDEBUGCANVAS_BLURSTYLE_INNER "inner"
#define SKDEBUGCANVAS_BLURQUALITY_LOW "low"
#define SKDEBUGCANVAS_BLURQUALITY_HIGH "high"
#define SKDEBUGCANVAS_FILLTYPE_WINDING "winding"
#define SKDEBUGCANVAS_FILLTYPE_EVENODD "evenOdd"
#define SKDEBUGCANVAS_FILLTYPE_INVERSEWINDING "inverseWinding"
#define SKDEBUGCANVAS_FILLTYPE_INVERSEEVENODD "inverseEvenOdd"
#define SKDEBUGCANVAS_CAP_BUTT "butt"
#define SKDEBUGCANVAS_CAP_ROUND "round"
#define SKDEBUGCANVAS_CAP_SQUARE "square"
#define SKDEBUGCANVAS_MITER_JOIN "miter"
#define SKDEBUGCANVAS_ROUND_JOIN "round"
#define SKDEBUGCANVAS_BEVEL_JOIN "bevel"
#define SKDEBUGCANVAS_COLORTYPE_ARGB4444 "ARGB4444"
#define SKDEBUGCANVAS_COLORTYPE_RGBA8888 "RGBA8888"
#define SKDEBUGCANVAS_COLORTYPE_BGRA8888 "BGRA8888"
#define SKDEBUGCANVAS_COLORTYPE_565 "565"
#define SKDEBUGCANVAS_COLORTYPE_GRAY8 "Gray8"
#define SKDEBUGCANVAS_COLORTYPE_INDEX8 "Index8"
#define SKDEBUGCANVAS_COLORTYPE_ALPHA8 "Alpha8"
#define SKDEBUGCANVAS_ALPHATYPE_OPAQUE "opaque"
#define SKDEBUGCANVAS_ALPHATYPE_PREMUL "premul"
#define SKDEBUGCANVAS_ALPHATYPE_UNPREMUL "unpremul"
#define SKDEBUGCANVAS_ALPHATYPE_UNKNOWN "unknown"
#define SKDEBUGCANVAS_FILTERQUALITY_NONE "none"
#define SKDEBUGCANVAS_FILTERQUALITY_LOW "low"
#define SKDEBUGCANVAS_FILTERQUALITY_MEDIUM "medium"
#define SKDEBUGCANVAS_FILTERQUALITY_HIGH "high"
#define SKDEBUGCANVAS_HINTING_NONE "none"
#define SKDEBUGCANVAS_HINTING_SLIGHT "slight"
#define SKDEBUGCANVAS_HINTING_NORMAL "normal"
#define SKDEBUGCANVAS_HINTING_FULL "full"
#define SKDEBUGCANVAS_EDGING_ALIAS "alias"
#define SKDEBUGCANVAS_EDGING_ANTIALIAS "antialias"
#define SKDEBUGCANVAS_EDGING_SUBPIXELANTIALIAS "subpixelantialias"
#define SKDEBUGCANVAS_SHADOWFLAG_TRANSPARENT_OCC "transparentOccluder"
#define SKDEBUGCANVAS_SHADOWFLAG_GEOMETRIC_ONLY "geometricOnly"
static SkString* str_append(SkString* str, const SkRect& r) {
str->appendf(" [%g %g %g %g]", r.left(), r.top(), r.right(), r.bottom());
return str;
}
SkDrawCommand::SkDrawCommand(OpType type)
: fOpType(type)
, fVisible(true) {
}
const char* SkDrawCommand::GetCommandString(OpType type) {
switch (type) {
case kBeginDrawPicture_OpType: return "BeginDrawPicture";
case kClear_OpType: return "DrawClear";
case kClipPath_OpType: return "ClipPath";
case kClipRegion_OpType: return "ClipRegion";
case kClipRect_OpType: return "ClipRect";
case kClipRRect_OpType: return "ClipRRect";
case kConcat_OpType: return "Concat";
case kDrawAnnotation_OpType: return "DrawAnnotation";
case kDrawBitmap_OpType: return "DrawBitmap";
case kDrawBitmapLattice_OpType: return "DrawBitmapLattice";
case kDrawBitmapNine_OpType: return "DrawBitmapNine";
case kDrawBitmapRect_OpType: return "DrawBitmapRect";
case kDrawDRRect_OpType: return "DrawDRRect";
case kDrawImage_OpType: return "DrawImage";
case kDrawImageLattice_OpType: return "DrawImageLattice";
case kDrawImageNine_OpType: return "DrawImageNine";
case kDrawImageRect_OpType: return "DrawImageRect";
case kDrawImageSet_OpType: return "DrawImageSet";
case kDrawOval_OpType: return "DrawOval";
case kDrawPaint_OpType: return "DrawPaint";
case kDrawPatch_OpType: return "DrawPatch";
case kDrawPath_OpType: return "DrawPath";
case kDrawArc_OpType: return "DrawArc";
case kDrawPoints_OpType: return "DrawPoints";
case kDrawRect_OpType: return "DrawRect";
case kDrawRRect_OpType: return "DrawRRect";
case kDrawRegion_OpType: return "DrawRegion";
case kDrawShadow_OpType: return "DrawShadow";
case kDrawTextBlob_OpType: return "DrawTextBlob";
case kDrawVertices_OpType: return "DrawVertices";
case kDrawAtlas_OpType: return "DrawAtlas";
case kDrawDrawable_OpType: return "DrawDrawable";
case kEndDrawPicture_OpType: return "EndDrawPicture";
case kRestore_OpType: return "Restore";
case kSave_OpType: return "Save";
case kSaveLayer_OpType: return "SaveLayer";
case kSetMatrix_OpType: return "SetMatrix";
default:
SkDebugf("OpType error 0x%08x\n", type);
SkASSERT(0);
break;
}
SkDEBUGFAIL("DrawType UNUSED\n");
return nullptr;
}
void SkDrawCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_COMMAND, this->GetCommandString(fOpType));
writer.appendBool(SKDEBUGCANVAS_ATTRIBUTE_VISIBLE, this->isVisible());
}
namespace {
void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) {
const SkISize& size = canvas->getBaseLayerSize();
static const SkScalar kInsetFrac = 0.9f; // Leave a border around object
canvas->translate(size.fWidth/2.0f, size.fHeight/2.0f);
if (bounds.width() > bounds.height()) {
canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.width()),
SkDoubleToScalar((kInsetFrac*size.fHeight)/bounds.width()));
} else {
canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.height()),
SkDoubleToScalar((kInsetFrac*size.fHeight)/bounds.height()));
}
canvas->translate(-bounds.centerX(), -bounds.centerY());
}
void render_path(SkCanvas* canvas, const SkPath& path) {
canvas->clear(0xFFFFFFFF);
const SkRect& bounds = path.getBounds();
if (bounds.isEmpty()) {
return;
}
SkAutoCanvasRestore acr(canvas, true);
xlate_and_scale_to_bounds(canvas, bounds);
SkPaint p;
p.setColor(SK_ColorBLACK);
p.setStyle(SkPaint::kStroke_Style);
canvas->drawPath(path, p);
}
void render_region(SkCanvas* canvas, const SkRegion& region) {
canvas->clear(0xFFFFFFFF);
const SkIRect& bounds = region.getBounds();
if (bounds.isEmpty()) {
return;
}
SkAutoCanvasRestore acr(canvas, true);
xlate_and_scale_to_bounds(canvas, SkRect::Make(bounds));
SkPaint p;
p.setColor(SK_ColorBLACK);
p.setStyle(SkPaint::kStroke_Style);
canvas->drawRegion(region, p);
}
void render_bitmap(SkCanvas* canvas, const SkBitmap& input, const SkRect* srcRect = nullptr) {
const SkISize& size = canvas->getBaseLayerSize();
SkScalar xScale = SkIntToScalar(size.fWidth-2) / input.width();
SkScalar yScale = SkIntToScalar(size.fHeight-2) / input.height();
if (input.width() > input.height()) {
yScale *= input.height() / (float) input.width();
} else {
xScale *= input.width() / (float) input.height();
}
SkRect dst = SkRect::MakeXYWH(SK_Scalar1, SK_Scalar1,
xScale * input.width(),
yScale * input.height());
static const int kNumBlocks = 8;
canvas->clear(0xFFFFFFFF);
SkISize block = {
canvas->imageInfo().width()/kNumBlocks,
canvas->imageInfo().height()/kNumBlocks
};
for (int y = 0; y < kNumBlocks; ++y) {
for (int x = 0; x < kNumBlocks; ++x) {
SkPaint paint;
paint.setColor((x+y)%2 ? SK_ColorLTGRAY : SK_ColorDKGRAY);
SkRect r = SkRect::MakeXYWH(SkIntToScalar(x*block.width()),
SkIntToScalar(y*block.height()),
SkIntToScalar(block.width()),
SkIntToScalar(block.height()));
canvas->drawRect(r, paint);
}
}
canvas->drawBitmapRect(input, dst, nullptr);
if (srcRect) {
SkRect r = SkRect::MakeLTRB(srcRect->fLeft * xScale + SK_Scalar1,
srcRect->fTop * yScale + SK_Scalar1,
srcRect->fRight * xScale + SK_Scalar1,
srcRect->fBottom * yScale + SK_Scalar1);
SkPaint p;
p.setColor(SK_ColorRED);
p.setStyle(SkPaint::kStroke_Style);
canvas->drawRect(r, p);
}
}
void render_rrect(SkCanvas* canvas, const SkRRect& rrect) {
canvas->clear(0xFFFFFFFF);
canvas->save();
const SkRect& bounds = rrect.getBounds();
xlate_and_scale_to_bounds(canvas, bounds);
SkPaint p;
p.setColor(SK_ColorBLACK);
p.setStyle(SkPaint::kStroke_Style);
canvas->drawRRect(rrect, p);
canvas->restore();
}
void render_drrect(SkCanvas* canvas, const SkRRect& outer, const SkRRect& inner) {
canvas->clear(0xFFFFFFFF);
canvas->save();
const SkRect& bounds = outer.getBounds();
xlate_and_scale_to_bounds(canvas, bounds);
SkPaint p;
p.setColor(SK_ColorBLACK);
p.setStyle(SkPaint::kStroke_Style);
canvas->drawDRRect(outer, inner, p);
canvas->restore();
}
void render_shadow(SkCanvas* canvas, const SkPath& path, SkDrawShadowRec rec) {
canvas->clear(0xFFFFFFFF);
const SkRect& bounds = path.getBounds();
if (bounds.isEmpty()) {
return;
}
SkAutoCanvasRestore acr(canvas, true);
xlate_and_scale_to_bounds(canvas, bounds);
rec.fAmbientColor = SK_ColorBLACK;
rec.fSpotColor = SK_ColorBLACK;
canvas->private_draw_shadow_rec(path, rec);
}
static const char* const gBlendModeMap[] = {
"clear",
"src",
"dst",
"srcOver",
"dstOver",
"srcIn",
"dstIn",
"srcOut",
"dstOut",
"srcATop",
"dstATop",
"xor",
"plus",
"modulate",
"screen",
"overlay",
"darken",
"lighten",
"colorDodge",
"colorBurn",
"hardLight",
"softLight",
"difference",
"exclusion",
"multiply",
"hue",
"saturation",
"color",
"luminosity",
};
static_assert(SK_ARRAY_COUNT(gBlendModeMap) == static_cast<size_t>(SkBlendMode::kLastMode) + 1,
"blendMode mismatch");
static_assert(SK_ARRAY_COUNT(gBlendModeMap) == static_cast<size_t>(SkBlendMode::kLuminosity) + 1,
"blendMode mismatch");
void apply_paint_blend_mode(const SkPaint& paint, SkJSONWriter& writer) {
const auto mode = paint.getBlendMode();
if (mode != SkBlendMode::kSrcOver) {
SkASSERT(static_cast<size_t>(mode) < SK_ARRAY_COUNT(gBlendModeMap));
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_BLENDMODE,
gBlendModeMap[static_cast<size_t>(mode)]);
}
}
};
void SkDrawCommand::MakeJsonColor(SkJSONWriter& writer, const SkColor color) {
writer.beginArray(nullptr, false);
writer.appendS32(SkColorGetA(color));
writer.appendS32(SkColorGetR(color));
writer.appendS32(SkColorGetG(color));
writer.appendS32(SkColorGetB(color));
writer.endArray();
}
void SkDrawCommand::MakeJsonColor4f(SkJSONWriter& writer, const SkColor4f& color) {
writer.beginArray(nullptr, false);
writer.appendFloat(color.fA);
writer.appendFloat(color.fR);
writer.appendFloat(color.fG);
writer.appendFloat(color.fB);
writer.endArray();
}
void SkDrawCommand::MakeJsonPoint(SkJSONWriter& writer, const SkPoint& point) {
writer.beginArray(nullptr, false);
writer.appendFloat(point.x());
writer.appendFloat(point.y());
writer.endArray();
}
void SkDrawCommand::MakeJsonPoint(SkJSONWriter& writer, SkScalar x, SkScalar y) {
writer.beginArray(nullptr, false);
writer.appendFloat(x);
writer.appendFloat(y);
writer.endArray();
}
void SkDrawCommand::MakeJsonPoint3(SkJSONWriter& writer, const SkPoint3& point) {
writer.beginArray(nullptr, false);
writer.appendFloat(point.x());
writer.appendFloat(point.y());
writer.appendFloat(point.z());
writer.endArray();
}
void SkDrawCommand::MakeJsonRect(SkJSONWriter& writer, const SkRect& rect) {
writer.beginArray(nullptr, false);
writer.appendFloat(rect.left());
writer.appendFloat(rect.top());
writer.appendFloat(rect.right());
writer.appendFloat(rect.bottom());
writer.endArray();
}
void SkDrawCommand::MakeJsonIRect(SkJSONWriter& writer, const SkIRect& rect) {
writer.beginArray(nullptr, false);
writer.appendS32(rect.left());
writer.appendS32(rect.top());
writer.appendS32(rect.right());
writer.appendS32(rect.bottom());
writer.endArray();
}
static void make_json_rrect(SkJSONWriter& writer, const SkRRect& rrect) {
writer.beginArray(nullptr, false);
SkDrawCommand::MakeJsonRect(writer, rrect.rect());
SkDrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kUpperLeft_Corner));
SkDrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kUpperRight_Corner));
SkDrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kLowerRight_Corner));
SkDrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kLowerLeft_Corner));
writer.endArray();
}
void SkDrawCommand::MakeJsonMatrix(SkJSONWriter& writer, const SkMatrix& matrix) {
writer.beginArray();
for (int r = 0; r < 3; ++r) {
writer.beginArray(nullptr, false);
for (int c = 0; c < 3; ++c) {
writer.appendFloat(matrix[r * 3 + c]);
}
writer.endArray();
}
writer.endArray();
}
void SkDrawCommand::MakeJsonPath(SkJSONWriter& writer, const SkPath& path) {
writer.beginObject();
switch (path.getFillType()) {
case SkPath::kWinding_FillType:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE, SKDEBUGCANVAS_FILLTYPE_WINDING);
break;
case SkPath::kEvenOdd_FillType:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE, SKDEBUGCANVAS_FILLTYPE_EVENODD);
break;
case SkPath::kInverseWinding_FillType:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE, SKDEBUGCANVAS_FILLTYPE_INVERSEWINDING);
break;
case SkPath::kInverseEvenOdd_FillType:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE, SKDEBUGCANVAS_FILLTYPE_INVERSEEVENODD);
break;
}
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_VERBS);
SkPath::Iter iter(path, false);
SkPoint pts[4];
SkPath::Verb verb;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
if (verb == SkPath::kClose_Verb) {
writer.appendString(SKDEBUGCANVAS_VERB_CLOSE);
continue;
}
writer.beginObject(); // verb
switch (verb) {
case SkPath::kLine_Verb: {
writer.appendName(SKDEBUGCANVAS_VERB_LINE);
MakeJsonPoint(writer, pts[1]);
break;
}
case SkPath::kQuad_Verb: {
writer.beginArray(SKDEBUGCANVAS_VERB_QUAD);
MakeJsonPoint(writer, pts[1]);
MakeJsonPoint(writer, pts[2]);
writer.endArray(); // quad coords
break;
}
case SkPath::kCubic_Verb: {
writer.beginArray(SKDEBUGCANVAS_VERB_CUBIC);
MakeJsonPoint(writer, pts[1]);
MakeJsonPoint(writer, pts[2]);
MakeJsonPoint(writer, pts[3]);
writer.endArray(); // cubic coords
break;
}
case SkPath::kConic_Verb: {
writer.beginArray(SKDEBUGCANVAS_VERB_CONIC);
MakeJsonPoint(writer, pts[1]);
MakeJsonPoint(writer, pts[2]);
writer.appendFloat(iter.conicWeight());
writer.endArray(); // conic coords
break;
}
case SkPath::kMove_Verb: {
writer.appendName(SKDEBUGCANVAS_VERB_MOVE);
MakeJsonPoint(writer, pts[0]);
break;
}
case SkPath::kClose_Verb:
case SkPath::kDone_Verb:
// Unreachable
break;
}
writer.endObject(); // verb
}
writer.endArray(); // verbs
writer.endObject(); // path
}
void SkDrawCommand::MakeJsonRegion(SkJSONWriter& writer, const SkRegion& region) {
// TODO: Actually serialize the rectangles, rather than just devolving to path
SkPath path;
region.getBoundaryPath(&path);
MakeJsonPath(writer, path);
}
static const char* regionop_name(SkClipOp op) {
switch (op) {
case kDifference_SkClipOp:
return SKDEBUGCANVAS_REGIONOP_DIFFERENCE;
case kIntersect_SkClipOp:
return SKDEBUGCANVAS_REGIONOP_INTERSECT;
case kUnion_SkClipOp:
return SKDEBUGCANVAS_REGIONOP_UNION;
case kXOR_SkClipOp:
return SKDEBUGCANVAS_REGIONOP_XOR;
case kReverseDifference_SkClipOp:
return SKDEBUGCANVAS_REGIONOP_REVERSE_DIFFERENCE;
case kReplace_SkClipOp:
return SKDEBUGCANVAS_REGIONOP_REPLACE;
default:
SkASSERT(false);
return "<invalid region op>";
}
}
static const char* pointmode_name(SkCanvas::PointMode mode) {
switch (mode) {
case SkCanvas::kPoints_PointMode:
return SKDEBUGCANVAS_POINTMODE_POINTS;
case SkCanvas::kLines_PointMode:
return SKDEBUGCANVAS_POINTMODE_LINES;
case SkCanvas::kPolygon_PointMode:
return SKDEBUGCANVAS_POINTMODE_POLYGON;
default:
SkASSERT(false);
return "<invalid point mode>";
}
}
static void store_scalar(SkJSONWriter& writer, const char* key, SkScalar value,
SkScalar defaultValue) {
if (value != defaultValue) {
writer.appendFloat(key, value);
}
}
static void store_bool(SkJSONWriter& writer,const char* key, bool value, bool defaultValue) {
if (value != defaultValue) {
writer.appendBool(key, value);
}
}
static SkString encode_data(const void* bytes, size_t count, const char* contentType,
UrlDataManager& urlDataManager) {
sk_sp<SkData> data(SkData::MakeWithCopy(bytes, count));
return urlDataManager.addData(data.get(), contentType);
}
void SkDrawCommand::flatten(const SkFlattenable* flattenable, SkJSONWriter& writer,
UrlDataManager& urlDataManager) {
SkBinaryWriteBuffer buffer;
flattenable->flatten(buffer);
void* data = sk_malloc_throw(buffer.bytesWritten());
buffer.writeToMemory(data);
SkString url = encode_data(data, buffer.bytesWritten(), "application/octet-stream",
urlDataManager);
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_NAME, flattenable->getTypeName());
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_DATA, url.c_str());
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_VALUES);
SkJsonWriteBuffer jsonBuffer(&writer, &urlDataManager);
flattenable->flatten(jsonBuffer);
writer.endObject(); // values
sk_free(data);
}
void SkDrawCommand::WritePNG(SkBitmap bitmap, SkWStream& out) {
SkPixmap pm;
SkAssertResult(bitmap.peekPixels(&pm));
SkPngEncoder::Options options;
options.fZLibLevel = 1;
options.fFilterFlags = SkPngEncoder::FilterFlag::kNone;
SkPngEncoder::Encode(&out, pm, options);
}
bool SkDrawCommand::flatten(const SkImage& image, SkJSONWriter& writer,
UrlDataManager& urlDataManager) {
size_t rowBytes = 4 * image.width();
SkAutoMalloc buffer(rowBytes * image.height());
SkImageInfo dstInfo = SkImageInfo::Make(image.width(), image.height(),
kN32_SkColorType, kPremul_SkAlphaType);
if (!image.readPixels(dstInfo, buffer.get(), rowBytes, 0, 0)) {
SkDebugf("readPixels failed\n");
return false;
}
SkBitmap bm;
bm.installPixels(dstInfo, buffer.get(), rowBytes);
SkDynamicMemoryWStream out;
SkDrawCommand::WritePNG(bm, out);
sk_sp<SkData> encoded = out.detachAsData();
SkString url = encode_data(encoded->data(), encoded->size(), "image/png", urlDataManager);
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_DATA, url.c_str());
return true;
}
static const char* color_type_name(SkColorType colorType) {
switch (colorType) {
case kARGB_4444_SkColorType:
return SKDEBUGCANVAS_COLORTYPE_ARGB4444;
case kRGBA_8888_SkColorType:
return SKDEBUGCANVAS_COLORTYPE_RGBA8888;
case kBGRA_8888_SkColorType:
return SKDEBUGCANVAS_COLORTYPE_BGRA8888;
case kRGB_565_SkColorType:
return SKDEBUGCANVAS_COLORTYPE_565;
case kGray_8_SkColorType:
return SKDEBUGCANVAS_COLORTYPE_GRAY8;
case kAlpha_8_SkColorType:
return SKDEBUGCANVAS_COLORTYPE_ALPHA8;
default:
SkASSERT(false);
return SKDEBUGCANVAS_COLORTYPE_RGBA8888;
}
}
static const char* alpha_type_name(SkAlphaType alphaType) {
switch (alphaType) {
case kOpaque_SkAlphaType:
return SKDEBUGCANVAS_ALPHATYPE_OPAQUE;
case kPremul_SkAlphaType:
return SKDEBUGCANVAS_ALPHATYPE_PREMUL;
case kUnpremul_SkAlphaType:
return SKDEBUGCANVAS_ALPHATYPE_UNPREMUL;
default:
SkASSERT(false);
return SKDEBUGCANVAS_ALPHATYPE_OPAQUE;
}
}
bool SkDrawCommand::flatten(const SkBitmap& bitmap, SkJSONWriter& writer,
UrlDataManager& urlDataManager) {
sk_sp<SkImage> image(SkImage::MakeFromBitmap(bitmap));
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_COLOR, color_type_name(bitmap.colorType()));
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_ALPHA, alpha_type_name(bitmap.alphaType()));
bool success = flatten(*image, writer, urlDataManager);
return success;
}
static void apply_font_hinting(const SkFont& font, SkJSONWriter& writer) {
SkFontHinting hinting = font.getHinting();
if (hinting != SkPaintDefaults_Hinting) {
switch (hinting) {
case kNo_SkFontHinting:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_HINTING, SKDEBUGCANVAS_HINTING_NONE);
break;
case kSlight_SkFontHinting:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_HINTING, SKDEBUGCANVAS_HINTING_SLIGHT);
break;
case kNormal_SkFontHinting:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_HINTING, SKDEBUGCANVAS_HINTING_NORMAL);
break;
case kFull_SkFontHinting:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_HINTING, SKDEBUGCANVAS_HINTING_FULL);
break;
}
}
}
static void apply_font_edging(const SkFont& font, SkJSONWriter& writer) {
switch (font.getEdging()) {
case SkFont::Edging::kAlias:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_EDGING, SKDEBUGCANVAS_EDGING_ALIAS);
break;
case SkFont::Edging::kAntiAlias:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_EDGING, SKDEBUGCANVAS_EDGING_ANTIALIAS);
break;
case SkFont::Edging::kSubpixelAntiAlias:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_EDGING, SKDEBUGCANVAS_EDGING_SUBPIXELANTIALIAS);
break;
}
}
static void apply_paint_color(const SkPaint& paint, SkJSONWriter& writer) {
SkColor color = paint.getColor();
if (color != SK_ColorBLACK) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COLOR);
SkDrawCommand::MakeJsonColor(writer, color);
}
}
static void apply_paint_style(const SkPaint& paint, SkJSONWriter& writer) {
SkPaint::Style style = paint.getStyle();
if (style != SkPaint::kFill_Style) {
switch (style) {
case SkPaint::kStroke_Style: {
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_STYLE, SKDEBUGCANVAS_STYLE_STROKE);
break;
}
case SkPaint::kStrokeAndFill_Style: {
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_STYLE, SKDEBUGCANVAS_STYLE_STROKEANDFILL);
break;
}
default: SkASSERT(false);
}
}
}
static void apply_paint_cap(const SkPaint& paint, SkJSONWriter& writer) {
SkPaint::Cap cap = paint.getStrokeCap();
if (cap != SkPaint::kDefault_Cap) {
switch (cap) {
case SkPaint::kButt_Cap:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_CAP, SKDEBUGCANVAS_CAP_BUTT);
break;
case SkPaint::kRound_Cap:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_CAP, SKDEBUGCANVAS_CAP_ROUND);
break;
case SkPaint::kSquare_Cap:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_CAP, SKDEBUGCANVAS_CAP_SQUARE);
break;
default: SkASSERT(false);
}
}
}
static void apply_paint_join(const SkPaint& paint, SkJSONWriter& writer) {
SkPaint::Join join = paint.getStrokeJoin();
if (join != SkPaint::kDefault_Join) {
switch (join) {
case SkPaint::kMiter_Join:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN, SKDEBUGCANVAS_MITER_JOIN);
break;
case SkPaint::kRound_Join:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN, SKDEBUGCANVAS_ROUND_JOIN);
break;
case SkPaint::kBevel_Join:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_STROKEJOIN, SKDEBUGCANVAS_BEVEL_JOIN);
break;
default: SkASSERT(false);
}
}
}
static void apply_paint_filterquality(const SkPaint& paint, SkJSONWriter& writer) {
SkFilterQuality quality = paint.getFilterQuality();
switch (quality) {
case kNone_SkFilterQuality:
break;
case kLow_SkFilterQuality:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY,
SKDEBUGCANVAS_FILTERQUALITY_LOW);
break;
case kMedium_SkFilterQuality:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY,
SKDEBUGCANVAS_FILTERQUALITY_MEDIUM);
break;
case kHigh_SkFilterQuality:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY,
SKDEBUGCANVAS_FILTERQUALITY_HIGH);
break;
}
}
static void apply_paint_maskfilter(const SkPaint& paint, SkJSONWriter& writer,
UrlDataManager& urlDataManager) {
SkMaskFilter* maskFilter = paint.getMaskFilter();
if (maskFilter != nullptr) {
SkMaskFilterBase::BlurRec blurRec;
if (as_MFB(maskFilter)->asABlur(&blurRec)) {
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_BLUR);
writer.appendFloat(SKDEBUGCANVAS_ATTRIBUTE_SIGMA, blurRec.fSigma);
switch (blurRec.fStyle) {
case SkBlurStyle::kNormal_SkBlurStyle:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_STYLE,
SKDEBUGCANVAS_BLURSTYLE_NORMAL);
break;
case SkBlurStyle::kSolid_SkBlurStyle:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_STYLE,
SKDEBUGCANVAS_BLURSTYLE_SOLID);
break;
case SkBlurStyle::kOuter_SkBlurStyle:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_STYLE,
SKDEBUGCANVAS_BLURSTYLE_OUTER);
break;
case SkBlurStyle::kInner_SkBlurStyle:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_STYLE,
SKDEBUGCANVAS_BLURSTYLE_INNER);
break;
default:
SkASSERT(false);
}
writer.endObject(); // blur
} else {
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER);
SkDrawCommand::flatten(maskFilter, writer, urlDataManager);
writer.endObject(); // maskFilter
}
}
}
static void apply_paint_patheffect(const SkPaint& paint, SkJSONWriter& writer,
UrlDataManager& urlDataManager) {
SkPathEffect* pathEffect = paint.getPathEffect();
if (pathEffect != nullptr) {
SkPathEffect::DashInfo dashInfo;
SkPathEffect::DashType dashType = pathEffect->asADash(&dashInfo);
if (dashType == SkPathEffect::kDash_DashType) {
dashInfo.fIntervals = (SkScalar*) sk_malloc_throw(dashInfo.fCount * sizeof(SkScalar));
pathEffect->asADash(&dashInfo);
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_DASHING);
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_INTERVALS, false);
for (int32_t i = 0; i < dashInfo.fCount; i++) {
writer.appendFloat(dashInfo.fIntervals[i]);
}
writer.endArray(); // intervals
sk_free(dashInfo.fIntervals);
writer.appendFloat(SKDEBUGCANVAS_ATTRIBUTE_PHASE, dashInfo.fPhase);
writer.endObject(); // dashing
} else {
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT);
SkDrawCommand::flatten(pathEffect, writer, urlDataManager);
writer.endObject(); // pathEffect
}
}
}
static void apply_font_typeface(const SkFont& font, SkJSONWriter& writer,
UrlDataManager& urlDataManager) {
SkTypeface* typeface = font.getTypefaceOrDefault();
if (typeface != nullptr) {
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE);
SkDynamicMemoryWStream buffer;
typeface->serialize(&buffer);
void* data = sk_malloc_throw(buffer.bytesWritten());
buffer.copyTo(data);
SkString url = encode_data(data, buffer.bytesWritten(), "application/octet-stream",
urlDataManager);
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_DATA, url.c_str());
sk_free(data);
writer.endObject();
}
}
static void apply_flattenable(const char* key, SkFlattenable* flattenable, SkJSONWriter& writer,
UrlDataManager& urlDataManager) {
if (flattenable != nullptr) {
writer.beginObject(key);
SkDrawCommand::flatten(flattenable, writer, urlDataManager);
writer.endObject();
}
}
void SkDrawCommand::MakeJsonPaint(SkJSONWriter& writer, const SkPaint& paint,
UrlDataManager& urlDataManager) {
writer.beginObject();
store_scalar(writer, SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH, paint.getStrokeWidth(), 0.0f);
store_scalar(writer, SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER, paint.getStrokeMiter(),
SkPaintDefaults_MiterLimit);
store_bool(writer, SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS, paint.isAntiAlias(), false);
store_bool(writer, SKDEBUGCANVAS_ATTRIBUTE_DITHER, paint.isDither(), false);
apply_paint_color(paint, writer);
apply_paint_style(paint, writer);
apply_paint_blend_mode(paint, writer);
apply_paint_cap(paint, writer);
apply_paint_join(paint, writer);
apply_paint_filterquality(paint, writer);
apply_paint_patheffect(paint, writer, urlDataManager);
apply_paint_maskfilter(paint, writer, urlDataManager);
apply_flattenable(SKDEBUGCANVAS_ATTRIBUTE_SHADER, paint.getShader(), writer, urlDataManager);
apply_flattenable(SKDEBUGCANVAS_ATTRIBUTE_LOOPER, paint.getLooper(), writer, urlDataManager);
apply_flattenable(SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER, paint.getImageFilter(), writer,
urlDataManager);
apply_flattenable(SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER, paint.getColorFilter(), writer,
urlDataManager);
writer.endObject(); // paint
}
static void MakeJsonFont(const SkFont& font, SkJSONWriter& writer, UrlDataManager& urlDataManager) {
writer.beginObject();
store_bool(writer, SKDEBUGCANVAS_ATTRIBUTE_FAKEBOLDTEXT, font.isEmbolden(), false);
store_bool(writer, SKDEBUGCANVAS_ATTRIBUTE_LINEARTEXT, font.isLinearMetrics(), false);
store_bool(writer, SKDEBUGCANVAS_ATTRIBUTE_SUBPIXELTEXT, font.isSubpixel(), false);
store_bool(writer, SKDEBUGCANVAS_ATTRIBUTE_EMBEDDEDBITMAPTEXT, font.isEmbeddedBitmaps(), false);
store_bool(writer, SKDEBUGCANVAS_ATTRIBUTE_AUTOHINTING, font.isForceAutoHinting(), false);
store_scalar(writer, SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE, font.getSize(),
SkPaintDefaults_TextSize);
store_scalar(writer, SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX, font.getScaleX(), SK_Scalar1);
store_scalar(writer, SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX, font.getSkewX(), 0.0f);
apply_font_edging(font, writer);
apply_font_hinting(font, writer);
apply_font_typeface(font, writer, urlDataManager);
writer.endObject(); // font
}
void SkDrawCommand::MakeJsonLattice(SkJSONWriter& writer, const SkCanvas::Lattice& lattice) {
writer.beginObject();
writer.appendS32(SKDEBUGCANVAS_ATTRIBUTE_LATTICEXCOUNT, lattice.fXCount);
writer.appendS32(SKDEBUGCANVAS_ATTRIBUTE_LATTICEYCOUNT, lattice.fYCount);
if (nullptr != lattice.fBounds) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_BOUNDS);
MakeJsonIRect(writer, *lattice.fBounds);
}
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_LATTICEXDIVS);
for (int i = 0; i < lattice.fXCount; i++) {
writer.appendS32(lattice.fXDivs[i]);
}
writer.endArray(); // xdivs
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_LATTICEYDIVS);
for (int i = 0; i < lattice.fYCount; i++) {
writer.appendS32(lattice.fYDivs[i]);
}
writer.endArray(); // ydivs
if (nullptr != lattice.fRectTypes) {
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_LATTICEFLAGS);
int flagCount = 0;
for (int row = 0; row < lattice.fYCount+1; row++) {
writer.beginArray();
for (int column = 0; column < lattice.fXCount+1; column++) {
writer.appendS32(lattice.fRectTypes[flagCount++]);
}
writer.endArray(); // row
}
writer.endArray();
}
writer.endObject();
}
SkClearCommand::SkClearCommand(SkColor color) : INHERITED(kClear_OpType) {
fColor = color;
}
void SkClearCommand::execute(SkCanvas* canvas) const {
canvas->clear(fColor);
}
void SkClearCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COLOR);
MakeJsonColor(writer, fColor);
}
SkClipPathCommand::SkClipPathCommand(const SkPath& path, SkClipOp op, bool doAA)
: INHERITED(kClipPath_OpType) {
fPath = path;
fOp = op;
fDoAA = doAA;
}
void SkClipPathCommand::execute(SkCanvas* canvas) const {
canvas->clipPath(fPath, fOp, fDoAA);
}
bool SkClipPathCommand::render(SkCanvas* canvas) const {
render_path(canvas, fPath);
return true;
}
void SkClipPathCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PATH); MakeJsonPath(writer, fPath);
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_REGIONOP, regionop_name(fOp));
writer.appendBool(SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS, fDoAA);
}
SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkClipOp op)
: INHERITED(kClipRegion_OpType) {
fRegion = region;
fOp = op;
}
void SkClipRegionCommand::execute(SkCanvas* canvas) const {
canvas->clipRegion(fRegion, fOp);
}
void SkClipRegionCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_REGION); MakeJsonRegion(writer, fRegion);
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_REGIONOP, regionop_name(fOp));
}
SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkClipOp op, bool doAA)
: INHERITED(kClipRect_OpType) {
fRect = rect;
fOp = op;
fDoAA = doAA;
}
void SkClipRectCommand::execute(SkCanvas* canvas) const {
canvas->clipRect(fRect, fOp, fDoAA);
}
void SkClipRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS); MakeJsonRect(writer, fRect);
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_REGIONOP, regionop_name(fOp));
writer.appendBool(SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS, fDoAA);
SkString desc;
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_SHORTDESC, str_append(&desc, fRect)->c_str());
}
SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkClipOp op, bool doAA)
: INHERITED(kClipRRect_OpType) {
fRRect = rrect;
fOp = op;
fDoAA = doAA;
}
void SkClipRRectCommand::execute(SkCanvas* canvas) const {
canvas->clipRRect(fRRect, fOp, fDoAA);
}
bool SkClipRRectCommand::render(SkCanvas* canvas) const {
render_rrect(canvas, fRRect);
return true;
}
void SkClipRRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS); make_json_rrect(writer, fRRect);
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_REGIONOP, regionop_name(fOp));
writer.appendBool(SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS, fDoAA);
}
SkConcatCommand::SkConcatCommand(const SkMatrix& matrix)
: INHERITED(kConcat_OpType) {
fMatrix = matrix;
}
void SkConcatCommand::execute(SkCanvas* canvas) const {
canvas->concat(fMatrix);
}
void SkConcatCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_MATRIX); MakeJsonMatrix(writer, fMatrix);
}
////
SkDrawAnnotationCommand::SkDrawAnnotationCommand(const SkRect& rect, const char key[],
sk_sp<SkData> value)
: INHERITED(kDrawAnnotation_OpType)
, fRect(rect)
, fKey(key)
, fValue(std::move(value))
{
}
void SkDrawAnnotationCommand::execute(SkCanvas* canvas) const {
canvas->drawAnnotation(fRect, fKey.c_str(), fValue);
}
void SkDrawAnnotationCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS); MakeJsonRect(writer, fRect);
writer.appendString("key", fKey.c_str());
if (fValue.get()) {
// TODO: dump out the "value"
}
SkString desc;
str_append(&desc, fRect)->appendf(" %s", fKey.c_str());
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_SHORTDESC, desc.c_str());
}
////
SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top,
const SkPaint* paint)
: INHERITED(kDrawBitmap_OpType)
, fBitmap(bitmap)
, fLeft(left)
, fTop(top)
, fPaint(paint) {}
void SkDrawBitmapCommand::execute(SkCanvas* canvas) const {
canvas->drawBitmap(fBitmap, fLeft, fTop, fPaint.getMaybeNull());
}
bool SkDrawBitmapCommand::render(SkCanvas* canvas) const {
render_bitmap(canvas, fBitmap);
return true;
}
void SkDrawBitmapCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_BITMAP);
flatten(fBitmap, writer, urlDataManager);
writer.endObject();
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS); MakeJsonPoint(writer, fLeft, fTop);
if (fPaint.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
}
SkDrawBitmapLatticeCommand::SkDrawBitmapLatticeCommand(const SkBitmap& bitmap,
const SkCanvas::Lattice& lattice,
const SkRect& dst, const SkPaint* paint)
: INHERITED(kDrawBitmapLattice_OpType)
, fBitmap(bitmap)
, fLattice(lattice)
, fDst(dst)
, fPaint(paint) {}
void SkDrawBitmapLatticeCommand::execute(SkCanvas* canvas) const {
canvas->drawBitmapLattice(fBitmap, fLattice, fDst, fPaint.getMaybeNull());
}
bool SkDrawBitmapLatticeCommand::render(SkCanvas* canvas) const {
SkAutoCanvasRestore acr(canvas, true);
canvas->clear(0xFFFFFFFF);
xlate_and_scale_to_bounds(canvas, fDst);
this->execute(canvas);
return true;
}
void SkDrawBitmapLatticeCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_BITMAP);
flatten(fBitmap, writer, urlDataManager);
writer.endObject(); // bitmap
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_LATTICE); MakeJsonLattice(writer, fLattice);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_DST); MakeJsonRect(writer, fDst);
if (fPaint.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
SkString desc;
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_SHORTDESC, str_append(&desc, fDst)->c_str());
}
SkDrawBitmapNineCommand::SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center,
const SkRect& dst, const SkPaint* paint)
: INHERITED(kDrawBitmapNine_OpType)
, fBitmap(bitmap)
, fCenter(center)
, fDst(dst)
, fPaint(paint) {}
void SkDrawBitmapNineCommand::execute(SkCanvas* canvas) const {
canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaint.getMaybeNull());
}
bool SkDrawBitmapNineCommand::render(SkCanvas* canvas) const {
SkRect tmp = SkRect::Make(fCenter);
render_bitmap(canvas, fBitmap, &tmp);
return true;
}
void SkDrawBitmapNineCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_BITMAP);
flatten(fBitmap, writer, urlDataManager);
writer.endObject(); // bitmap
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_CENTER); MakeJsonIRect(writer, fCenter);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_DST); MakeJsonRect(writer, fDst);
if (fPaint.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
}
SkDrawBitmapRectCommand::SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint,
SkCanvas::SrcRectConstraint constraint)
: INHERITED(kDrawBitmapRect_OpType)
, fBitmap(bitmap)
, fSrc(src)
, fDst(dst)
, fPaint(paint)
, fConstraint(constraint) {}
void SkDrawBitmapRectCommand::execute(SkCanvas* canvas) const {
canvas->legacy_drawBitmapRect(fBitmap, fSrc.getMaybeNull(), fDst, fPaint.getMaybeNull(),
fConstraint);
}
bool SkDrawBitmapRectCommand::render(SkCanvas* canvas) const {
render_bitmap(canvas, fBitmap, fSrc.getMaybeNull());
return true;
}
void SkDrawBitmapRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_BITMAP);
flatten(fBitmap, writer, urlDataManager);
writer.endObject(); // bitmap
if (fSrc.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_SRC); MakeJsonRect(writer, *fSrc);
}
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_DST); MakeJsonRect(writer, fDst);
if (fPaint.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
writer.appendBool(SKDEBUGCANVAS_ATTRIBUTE_STRICT, true);
}
SkString desc;
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_SHORTDESC, str_append(&desc, fDst)->c_str());
}
SkDrawImageCommand::SkDrawImageCommand(const SkImage* image, SkScalar left, SkScalar top,
const SkPaint* paint)
: INHERITED(kDrawImage_OpType)
, fImage(SkRef(image))
, fLeft(left)
, fTop(top)
, fPaint(paint) {}
void SkDrawImageCommand::execute(SkCanvas* canvas) const {
canvas->drawImage(fImage.get(), fLeft, fTop, fPaint.getMaybeNull());
}
bool SkDrawImageCommand::render(SkCanvas* canvas) const {
SkAutoCanvasRestore acr(canvas, true);
canvas->clear(0xFFFFFFFF);
xlate_and_scale_to_bounds(canvas, SkRect::MakeXYWH(fLeft, fTop,
SkIntToScalar(fImage->width()),
SkIntToScalar(fImage->height())));
this->execute(canvas);
return true;
}
void SkDrawImageCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_IMAGE);
flatten(*fImage, writer, urlDataManager);
writer.endObject(); // image
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS); MakeJsonPoint(writer, fLeft, fTop);
if (fPaint.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
writer.appendU32(SKDEBUGCANVAS_ATTRIBUTE_UNIQUE_ID, fImage->uniqueID());
writer.appendS32(SKDEBUGCANVAS_ATTRIBUTE_WIDTH, fImage->width());
writer.appendS32(SKDEBUGCANVAS_ATTRIBUTE_HEIGHT, fImage->height());
switch (fImage->alphaType()) {
case kOpaque_SkAlphaType:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_ALPHA, SKDEBUGCANVAS_ALPHATYPE_OPAQUE);
break;
case kPremul_SkAlphaType:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_ALPHA, SKDEBUGCANVAS_ALPHATYPE_PREMUL);
break;
case kUnpremul_SkAlphaType:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_ALPHA, SKDEBUGCANVAS_ALPHATYPE_UNPREMUL);
break;
default:
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_ALPHA, SKDEBUGCANVAS_ALPHATYPE_UNKNOWN);
break;
}
}
SkDrawImageLatticeCommand::SkDrawImageLatticeCommand(const SkImage* image,
const SkCanvas::Lattice& lattice,
const SkRect& dst, const SkPaint* paint)
: INHERITED(kDrawImageLattice_OpType)
, fImage(SkRef(image))
, fLattice(lattice)
, fDst(dst)
, fPaint(paint) {}
void SkDrawImageLatticeCommand::execute(SkCanvas* canvas) const {
canvas->drawImageLattice(fImage.get(), fLattice, fDst, fPaint.getMaybeNull());
}
bool SkDrawImageLatticeCommand::render(SkCanvas* canvas) const {
SkAutoCanvasRestore acr(canvas, true);
canvas->clear(0xFFFFFFFF);
xlate_and_scale_to_bounds(canvas, fDst);
this->execute(canvas);
return true;
}
void SkDrawImageLatticeCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_IMAGE);
flatten(*fImage, writer, urlDataManager);
writer.endObject(); // image
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_LATTICE); MakeJsonLattice(writer, fLattice);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_DST); MakeJsonRect(writer, fDst);
if (fPaint.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
SkString desc;
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_SHORTDESC, str_append(&desc, fDst)->c_str());
}
SkDrawImageRectCommand::SkDrawImageRectCommand(const SkImage* image, const SkRect* src,
const SkRect& dst, const SkPaint* paint,
SkCanvas::SrcRectConstraint constraint)
: INHERITED(kDrawImageRect_OpType)
, fImage(SkRef(image))
, fSrc(src)
, fDst(dst)
, fPaint(paint)
, fConstraint(constraint) {}
void SkDrawImageRectCommand::execute(SkCanvas* canvas) const {
canvas->legacy_drawImageRect(fImage.get(), fSrc.getMaybeNull(), fDst,
fPaint.getMaybeNull(), fConstraint);
}
bool SkDrawImageRectCommand::render(SkCanvas* canvas) const {
SkAutoCanvasRestore acr(canvas, true);
canvas->clear(0xFFFFFFFF);
xlate_and_scale_to_bounds(canvas, fDst);
this->execute(canvas);
return true;
}
void SkDrawImageRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_IMAGE);
flatten(*fImage, writer, urlDataManager);
writer.endObject(); // image
if (fSrc.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_SRC); MakeJsonRect(writer, *fSrc);
}
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_DST); MakeJsonRect(writer, fDst);
if (fPaint.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
writer.appendBool(SKDEBUGCANVAS_ATTRIBUTE_STRICT, true);
}
SkString desc;
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_SHORTDESC, str_append(&desc, fDst)->c_str());
}
SkDrawImageSetCommand::SkDrawImageSetCommand(const SkCanvas::ImageSetEntry set[], int count,
SkFilterQuality filterQuality, SkBlendMode mode)
: INHERITED(kDrawImageSet_OpType)
, fSet(count)
, fCount(count)
, fFilterQuality(filterQuality)
, fMode(mode) {
std::copy_n(set, count, fSet.get());
}
void SkDrawImageSetCommand::execute(SkCanvas* canvas) const {
canvas->experimental_DrawImageSetV1(fSet.get(), fCount, fFilterQuality, fMode);
}
SkDrawImageNineCommand::SkDrawImageNineCommand(const SkImage* image, const SkIRect& center,
const SkRect& dst, const SkPaint* paint)
: INHERITED(kDrawImageNine_OpType)
, fImage(SkRef(image))
, fCenter(center)
, fDst(dst)
, fPaint(paint) {}
void SkDrawImageNineCommand::execute(SkCanvas* canvas) const {
canvas->drawImageNine(fImage.get(), fCenter, fDst, fPaint.getMaybeNull());
}
bool SkDrawImageNineCommand::render(SkCanvas* canvas) const {
SkAutoCanvasRestore acr(canvas, true);
canvas->clear(0xFFFFFFFF);
xlate_and_scale_to_bounds(canvas, fDst);
this->execute(canvas);
return true;
}
void SkDrawImageNineCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_IMAGE);
flatten(*fImage, writer, urlDataManager);
writer.endObject(); // image
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_CENTER); MakeJsonIRect(writer, fCenter);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_DST); MakeJsonRect(writer, fDst);
if (fPaint.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
}
SkDrawOvalCommand::SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint)
: INHERITED(kDrawOval_OpType) {
fOval = oval;
fPaint = paint;
}
void SkDrawOvalCommand::execute(SkCanvas* canvas) const {
canvas->drawOval(fOval, fPaint);
}
bool SkDrawOvalCommand::render(SkCanvas* canvas) const {
canvas->clear(0xFFFFFFFF);
canvas->save();
xlate_and_scale_to_bounds(canvas, fOval);
SkPaint p;
p.setColor(SK_ColorBLACK);
p.setStyle(SkPaint::kStroke_Style);
canvas->drawOval(fOval, p);
canvas->restore();
return true;
}
void SkDrawOvalCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS); MakeJsonRect(writer, fOval);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT); MakeJsonPaint(writer, fPaint, urlDataManager);
}
SkDrawArcCommand::SkDrawArcCommand(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,
bool useCenter, const SkPaint& paint)
: INHERITED(kDrawArc_OpType) {
fOval = oval;
fStartAngle = startAngle;
fSweepAngle = sweepAngle;
fUseCenter = useCenter;
fPaint = paint;
}
void SkDrawArcCommand::execute(SkCanvas* canvas) const {
canvas->drawArc(fOval, fStartAngle, fSweepAngle, fUseCenter, fPaint);
}
bool SkDrawArcCommand::render(SkCanvas* canvas) const {
canvas->clear(0xFFFFFFFF);
canvas->save();
xlate_and_scale_to_bounds(canvas, fOval);
SkPaint p;
p.setColor(SK_ColorBLACK);
p.setStyle(SkPaint::kStroke_Style);
canvas->drawArc(fOval, fStartAngle, fSweepAngle, fUseCenter, p);
canvas->restore();
return true;
}
void SkDrawArcCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS); MakeJsonRect(writer, fOval);
writer.appendFloat(SKDEBUGCANVAS_ATTRIBUTE_STARTANGLE, fStartAngle);
writer.appendFloat(SKDEBUGCANVAS_ATTRIBUTE_SWEEPANGLE, fSweepAngle);
writer.appendBool(SKDEBUGCANVAS_ATTRIBUTE_USECENTER, fUseCenter);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT); MakeJsonPaint(writer, fPaint, urlDataManager);
}
SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint)
: INHERITED(kDrawPaint_OpType) {
fPaint = paint;
}
void SkDrawPaintCommand::execute(SkCanvas* canvas) const {
canvas->drawPaint(fPaint);
}
bool SkDrawPaintCommand::render(SkCanvas* canvas) const {
canvas->clear(0xFFFFFFFF);
canvas->drawPaint(fPaint);
return true;
}
void SkDrawPaintCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT); MakeJsonPaint(writer, fPaint, urlDataManager);
}
SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint)
: INHERITED(kDrawPath_OpType) {
fPath = path;
fPaint = paint;
}
void SkDrawPathCommand::execute(SkCanvas* canvas) const {
canvas->drawPath(fPath, fPaint);
}
bool SkDrawPathCommand::render(SkCanvas* canvas) const {
render_path(canvas, fPath);
return true;
}
void SkDrawPathCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PATH); MakeJsonPath(writer, fPath);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT); MakeJsonPaint(writer, fPaint, urlDataManager);
}
SkDrawRegionCommand::SkDrawRegionCommand(const SkRegion& region, const SkPaint& paint)
: INHERITED(kDrawRegion_OpType) {
fRegion = region;
fPaint = paint;
}
void SkDrawRegionCommand::execute(SkCanvas* canvas) const {
canvas->drawRegion(fRegion, fPaint);
}
bool SkDrawRegionCommand::render(SkCanvas* canvas) const {
render_region(canvas, fRegion);
return true;
}
void SkDrawRegionCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_REGION); MakeJsonRegion(writer, fRegion);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT); MakeJsonPaint(writer, fPaint, urlDataManager);
}
SkBeginDrawPictureCommand::SkBeginDrawPictureCommand(const SkPicture* picture,
const SkMatrix* matrix,
const SkPaint* paint)
: INHERITED(kBeginDrawPicture_OpType)
, fPicture(SkRef(picture))
, fMatrix(matrix)
, fPaint(paint) {}
void SkBeginDrawPictureCommand::execute(SkCanvas* canvas) const {
if (fPaint.isValid()) {
SkRect bounds = fPicture->cullRect();
if (fMatrix.isValid()) {
fMatrix->mapRect(&bounds);
}
canvas->saveLayer(&bounds, fPaint.get());
}
if (fMatrix.isValid()) {
if (!fPaint.isValid()) {
canvas->save();
}
canvas->concat(*fMatrix);
}
}
bool SkBeginDrawPictureCommand::render(SkCanvas* canvas) const {
canvas->clear(0xFFFFFFFF);
canvas->save();
xlate_and_scale_to_bounds(canvas, fPicture->cullRect());
canvas->drawPicture(fPicture.get());
canvas->restore();
return true;
}
SkEndDrawPictureCommand::SkEndDrawPictureCommand(bool restore)
: INHERITED(kEndDrawPicture_OpType) , fRestore(restore) { }
void SkEndDrawPictureCommand::execute(SkCanvas* canvas) const {
if (fRestore) {
canvas->restore();
}
}
SkDrawPointsCommand::SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count,
const SkPoint pts[], const SkPaint& paint)
: INHERITED(kDrawPoints_OpType)
, fMode(mode)
, fPts(pts, count)
, fPaint(paint) {}
void SkDrawPointsCommand::execute(SkCanvas* canvas) const {
canvas->drawPoints(fMode, fPts.count(), fPts.begin(), fPaint);
}
bool SkDrawPointsCommand::render(SkCanvas* canvas) const {
canvas->clear(0xFFFFFFFF);
canvas->save();
SkRect bounds;
bounds.setEmpty();
for (int i = 0; i < fPts.count(); ++i) {
SkRectPriv::GrowToInclude(&bounds, fPts[i]);
}
xlate_and_scale_to_bounds(canvas, bounds);
SkPaint p;
p.setColor(SK_ColorBLACK);
p.setStyle(SkPaint::kStroke_Style);
canvas->drawPoints(fMode, fPts.count(), fPts.begin(), p);
canvas->restore();
return true;
}
void SkDrawPointsCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_MODE, pointmode_name(fMode));
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_POINTS);
for (int i = 0; i < fPts.count(); i++) {
MakeJsonPoint(writer, fPts[i]);
}
writer.endArray(); // points
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT); MakeJsonPaint(writer, fPaint, urlDataManager);
}
SkDrawTextBlobCommand::SkDrawTextBlobCommand(sk_sp<SkTextBlob> blob, SkScalar x, SkScalar y,
const SkPaint& paint)
: INHERITED(kDrawTextBlob_OpType)
, fBlob(std::move(blob))
, fXPos(x)
, fYPos(y)
, fPaint(paint) {}
void SkDrawTextBlobCommand::execute(SkCanvas* canvas) const {
canvas->drawTextBlob(fBlob, fXPos, fYPos, fPaint);
}
bool SkDrawTextBlobCommand::render(SkCanvas* canvas) const {
canvas->clear(SK_ColorWHITE);
canvas->save();
SkRect bounds = fBlob->bounds().makeOffset(fXPos, fYPos);
xlate_and_scale_to_bounds(canvas, bounds);
canvas->drawTextBlob(fBlob, fXPos, fYPos, fPaint);
canvas->restore();
return true;
}
void SkDrawTextBlobCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_RUNS);
SkTextBlobRunIterator iter(fBlob.get());
while (!iter.done()) {
writer.beginObject(); // run
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_GLYPHS);
for (uint32_t i = 0; i < iter.glyphCount(); i++) {
writer.appendU32(iter.glyphs()[i]);
}
writer.endArray(); // glyphs
if (iter.positioning() != SkTextBlobRunIterator::kDefault_Positioning) {
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_POSITIONS);
const SkScalar* iterPositions = iter.pos();
for (uint32_t i = 0; i < iter.glyphCount(); i++) {
switch (iter.positioning()) {
case SkTextBlobRunIterator::kFull_Positioning:
MakeJsonPoint(writer, iterPositions[i * 2], iterPositions[i * 2 + 1]);
break;
case SkTextBlobRunIterator::kHorizontal_Positioning:
writer.appendFloat(iterPositions[i]);
break;
case SkTextBlobRunIterator::kDefault_Positioning:
break;
case SkTextBlobRunIterator::kRSXform_Positioning:
// TODO_RSXFORM_BLOB
break;
}
}
writer.endArray(); // positions
}
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_FONT);
MakeJsonFont(iter.font(), writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS);
MakeJsonPoint(writer, iter.offset());
writer.endObject(); // run
iter.next();
}
writer.endArray(); // runs
writer.appendFloat(SKDEBUGCANVAS_ATTRIBUTE_X, fXPos);
writer.appendFloat(SKDEBUGCANVAS_ATTRIBUTE_Y, fYPos);
SkRect bounds = fBlob->bounds();
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS); MakeJsonRect(writer, bounds);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT); MakeJsonPaint(writer, fPaint, urlDataManager);
SkString desc;
// make the bounds local by applying the x,y
bounds.offset(fXPos, fYPos);
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_SHORTDESC, str_append(&desc, bounds)->c_str());
}
SkDrawPatchCommand::SkDrawPatchCommand(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkBlendMode bmode,
const SkPaint& paint)
: INHERITED(kDrawPatch_OpType)
, fBlendMode(bmode)
{
memcpy(fCubics, cubics, sizeof(fCubics));
if (colors != nullptr) {
memcpy(fColors, colors, sizeof(fColors));
fColorsPtr = fColors;
} else {
fColorsPtr = nullptr;
}
if (texCoords != nullptr) {
memcpy(fTexCoords, texCoords, sizeof(fTexCoords));
fTexCoordsPtr = fTexCoords;
} else {
fTexCoordsPtr = nullptr;
}
fPaint = paint;
}
void SkDrawPatchCommand::execute(SkCanvas* canvas) const {
canvas->drawPatch(fCubics, fColorsPtr, fTexCoordsPtr, fBlendMode, fPaint);
}
void SkDrawPatchCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_CUBICS);
for (int i = 0; i < 12; i++) {
MakeJsonPoint(writer, fCubics[i]);
}
writer.endArray(); // cubics
if (fColorsPtr != nullptr) {
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_COLORS);
for (int i = 0; i < 4; i++) {
MakeJsonColor(writer, fColorsPtr[i]);
}
writer.endArray(); // colors
}
if (fTexCoordsPtr != nullptr) {
writer.beginArray(SKDEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS);
for (int i = 0; i < 4; i++) {
MakeJsonPoint(writer, fTexCoords[i]);
}
writer.endArray(); // texCoords
}
// fBlendMode
}
SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint)
: INHERITED(kDrawRect_OpType) {
fRect = rect;
fPaint = paint;
}
void SkDrawRectCommand::execute(SkCanvas* canvas) const {
canvas->drawRect(fRect, fPaint);
}
void SkDrawRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS); MakeJsonRect(writer, fRect);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT); MakeJsonPaint(writer, fPaint, urlDataManager);
SkString desc;
writer.appendString(SKDEBUGCANVAS_ATTRIBUTE_SHORTDESC, str_append(&desc, fRect)->c_str());
}
SkDrawEdgeAARectCommand::SkDrawEdgeAARectCommand(const SkRect& rect, SkCanvas::QuadAAFlags aa,
SkColor color, SkBlendMode mode)
: INHERITED(kDrawEdgeAARect_OpType) {
fRect = rect;
fAA = aa;
fColor = color;
fMode = mode;
}
void SkDrawEdgeAARectCommand::execute(SkCanvas* canvas) const {
canvas->experimental_DrawEdgeAARectV1(fRect, fAA, fColor, fMode);
}
SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint)
: INHERITED(kDrawRRect_OpType) {
fRRect = rrect;
fPaint = paint;
}
void SkDrawRRectCommand::execute(SkCanvas* canvas) const {
canvas->drawRRect(fRRect, fPaint);
}
bool SkDrawRRectCommand::render(SkCanvas* canvas) const {
render_rrect(canvas, fRRect);
return true;
}
void SkDrawRRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_COORDS); make_json_rrect(writer, fRRect);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT); MakeJsonPaint(writer, fPaint, urlDataManager);
}
SkDrawDRRectCommand::SkDrawDRRectCommand(const SkRRect& outer,
const SkRRect& inner,
const SkPaint& paint)
: INHERITED(kDrawDRRect_OpType) {
fOuter = outer;
fInner = inner;
fPaint = paint;
}
void SkDrawDRRectCommand::execute(SkCanvas* canvas) const {
canvas->drawDRRect(fOuter, fInner, fPaint);
}
bool SkDrawDRRectCommand::render(SkCanvas* canvas) const {
render_drrect(canvas, fOuter, fInner);
return true;
}
void SkDrawDRRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_OUTER); make_json_rrect(writer, fOuter);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_INNER); make_json_rrect(writer, fInner);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT); MakeJsonPaint(writer, fPaint, urlDataManager);
}
SkDrawShadowCommand::SkDrawShadowCommand(const SkPath& path, const SkDrawShadowRec& rec)
: INHERITED(kDrawShadow_OpType) {
fPath = path;
fShadowRec = rec;
}
void SkDrawShadowCommand::execute(SkCanvas* canvas) const {
canvas->private_draw_shadow_rec(fPath, fShadowRec);
}
bool SkDrawShadowCommand::render(SkCanvas* canvas) const {
render_shadow(canvas, fPath, fShadowRec);
return true;
}
void SkDrawShadowCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
bool geometricOnly = SkToBool(fShadowRec.fFlags & SkShadowFlags::kGeometricOnly_ShadowFlag);
bool transparentOccluder =
SkToBool(fShadowRec.fFlags & SkShadowFlags::kTransparentOccluder_ShadowFlag);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PATH); MakeJsonPath(writer, fPath);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_ZPLANE);
MakeJsonPoint3(writer, fShadowRec.fZPlaneParams);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_LIGHTPOSITION);
MakeJsonPoint3(writer, fShadowRec.fLightPos);
writer.appendFloat(SKDEBUGCANVAS_ATTRIBUTE_LIGHTRADIUS, fShadowRec.fLightRadius);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_AMBIENTCOLOR);
MakeJsonColor(writer, fShadowRec.fAmbientColor);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_SPOTCOLOR);
MakeJsonColor(writer, fShadowRec.fSpotColor);
store_bool(writer, SKDEBUGCANVAS_SHADOWFLAG_TRANSPARENT_OCC, transparentOccluder, false);
store_bool(writer, SKDEBUGCANVAS_SHADOWFLAG_GEOMETRIC_ONLY, geometricOnly, false);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
SkDrawDrawableCommand::SkDrawDrawableCommand(SkDrawable* drawable, const SkMatrix* matrix)
: INHERITED(kDrawDrawable_OpType)
, fDrawable(SkRef(drawable))
, fMatrix(matrix) {}
void SkDrawDrawableCommand::execute(SkCanvas* canvas) const {
canvas->drawDrawable(fDrawable.get(), fMatrix.getMaybeNull());
}
///////////////////////////////////////////////////////////////////////////////////////////////////
SkDrawVerticesCommand::SkDrawVerticesCommand(sk_sp<SkVertices> vertices, SkBlendMode bmode,
const SkPaint& paint)
: INHERITED(kDrawVertices_OpType)
, fVertices(std::move(vertices))
, fBlendMode(bmode)
, fPaint(paint) {}
void SkDrawVerticesCommand::execute(SkCanvas* canvas) const {
canvas->drawVertices(fVertices, fBlendMode, fPaint);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
SkDrawAtlasCommand::SkDrawAtlasCommand(const SkImage* image, const SkRSXform xform[],
const SkRect tex[], const SkColor colors[], int count,
SkBlendMode bmode, const SkRect* cull,
const SkPaint* paint)
: INHERITED(kDrawAtlas_OpType)
, fImage(SkRef(image))
, fXform(xform, count)
, fTex(tex, count)
, fColors(colors, colors ? count : 0)
, fBlendMode(bmode)
, fCull(cull)
, fPaint(paint) {}
void SkDrawAtlasCommand::execute(SkCanvas* canvas) const {
canvas->drawAtlas(fImage.get(), fXform.begin(), fTex.begin(),
fColors.isEmpty() ? nullptr : fColors.begin(), fXform.count(), fBlendMode,
fCull.getMaybeNull(), fPaint.getMaybeNull());
}
///////////////////////////////////////////////////////////////////////////////////////////////////
SkRestoreCommand::SkRestoreCommand()
: INHERITED(kRestore_OpType) {}
void SkRestoreCommand::execute(SkCanvas* canvas) const {
canvas->restore();
}
SkSaveCommand::SkSaveCommand()
: INHERITED(kSave_OpType) {
}
void SkSaveCommand::execute(SkCanvas* canvas) const {
canvas->save();
}
SkSaveLayerCommand::SkSaveLayerCommand(const SkCanvas::SaveLayerRec& rec)
: INHERITED(kSaveLayer_OpType)
, fBounds(rec.fBounds)
, fPaint(rec.fPaint)
, fBackdrop(SkSafeRef(rec.fBackdrop))
, fSaveLayerFlags(rec.fSaveLayerFlags) {}
void SkSaveLayerCommand::execute(SkCanvas* canvas) const {
canvas->saveLayer(SkCanvas::SaveLayerRec(fBounds.getMaybeNull(), fPaint.getMaybeNull(),
fSaveLayerFlags));
}
void SkSaveLayerCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
if (fBounds.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_BOUNDS); MakeJsonRect(writer, *fBounds);
}
if (fPaint.isValid()) {
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
if (fBackdrop != nullptr) {
writer.beginObject(SKDEBUGCANVAS_ATTRIBUTE_BACKDROP);
flatten(fBackdrop.get(), writer, urlDataManager);
writer.endObject(); // backdrop
}
if (fSaveLayerFlags != 0) {
SkDebugf("unsupported: saveLayer flags\n");
SkASSERT(false);
}
}
SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix)
: INHERITED(kSetMatrix_OpType) {
fMatrix = matrix;
}
void SkSetMatrixCommand::execute(SkCanvas* canvas) const {
canvas->setMatrix(fMatrix);
}
void SkSetMatrixCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(SKDEBUGCANVAS_ATTRIBUTE_MATRIX); MakeJsonMatrix(writer, fMatrix);
}
Reference in New Issue View Git Blame Copy Permalink