blob: 056d5ebe44c78f0c7e1b8fb4380e5daf4492e40f [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 "tools/debugger/DrawCommand.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkBlurTypes.h"
#include "include/core/SkClipOp.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkColorType.h"
#include "include/core/SkDrawable.h"
#include "include/core/SkFlattenable.h"
#include "include/core/SkFont.h"
#include "include/core/SkFontTypes.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkPicture.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkPoint3.h"
#include "include/core/SkRSXform.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkSize.h"
#include "include/core/SkStream.h"
#include "include/core/SkTypeface.h"
#include "include/encode/SkPngEncoder.h"
#include "include/private/SkShadowFlags.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkTo.h"
#include "include/private/gpu/ganesh/GrImageContext.h"
#include "src/core/SkAutoMalloc.h"
#include "src/core/SkCanvasPriv.h"
#include "src/core/SkMaskFilterBase.h"
#include "src/core/SkPaintDefaults.h"
#include "src/core/SkRectPriv.h"
#include "src/core/SkTextBlobPriv.h"
#include "src/core/SkWriteBuffer.h"
#include "src/image/SkImage_Base.h"
#include "src/utils/SkJSONWriter.h"
#include "tools/UrlDataManager.h"
#include "tools/debugger/DebugLayerManager.h"
#include "tools/debugger/JsonWriteBuffer.h"
#include <algorithm>
#include <cstring>
#include <utility>
class GrDirectContext;
#if SK_SUPPORT_GPU
#include "include/gpu/GrRecordingContext.h"
#endif
#define DEBUGCANVAS_ATTRIBUTE_DUMP "dump"
#define DEBUGCANVAS_ATTRIBUTE_COMMAND "command"
#define DEBUGCANVAS_ATTRIBUTE_VISIBLE "visible"
#define DEBUGCANVAS_ATTRIBUTE_MATRIX "matrix"
#define DEBUGCANVAS_ATTRIBUTE_DRAWDEPTHTRANS "drawDepthTranslation"
#define DEBUGCANVAS_ATTRIBUTE_COORDS "coords"
#define DEBUGCANVAS_ATTRIBUTE_EDGING "edging"
#define DEBUGCANVAS_ATTRIBUTE_HINTING "hinting"
#define DEBUGCANVAS_ATTRIBUTE_BOUNDS "bounds"
#define DEBUGCANVAS_ATTRIBUTE_PAINT "paint"
#define DEBUGCANVAS_ATTRIBUTE_OUTER "outer"
#define DEBUGCANVAS_ATTRIBUTE_INNER "inner"
#define DEBUGCANVAS_ATTRIBUTE_MODE "mode"
#define DEBUGCANVAS_ATTRIBUTE_POINTS "points"
#define DEBUGCANVAS_ATTRIBUTE_PATH "path"
#define DEBUGCANVAS_ATTRIBUTE_TEXT "text"
#define DEBUGCANVAS_ATTRIBUTE_COLOR "color"
#define DEBUGCANVAS_ATTRIBUTE_ALPHA "alpha"
#define DEBUGCANVAS_ATTRIBUTE_BLENDMODE "blendMode"
#define DEBUGCANVAS_ATTRIBUTE_SAMPLING "sampling"
#define DEBUGCANVAS_ATTRIBUTE_STYLE "style"
#define DEBUGCANVAS_ATTRIBUTE_STROKEWIDTH "strokeWidth"
#define DEBUGCANVAS_ATTRIBUTE_STROKEMITER "strokeMiter"
#define DEBUGCANVAS_ATTRIBUTE_STROKEJOIN "strokeJoin"
#define DEBUGCANVAS_ATTRIBUTE_CAP "cap"
#define DEBUGCANVAS_ATTRIBUTE_ANTIALIAS "antiAlias"
#define DEBUGCANVAS_ATTRIBUTE_DITHER "dither"
#define DEBUGCANVAS_ATTRIBUTE_FAKEBOLDTEXT "fakeBoldText"
#define DEBUGCANVAS_ATTRIBUTE_LINEARTEXT "linearText"
#define DEBUGCANVAS_ATTRIBUTE_SUBPIXELTEXT "subpixelText"
#define DEBUGCANVAS_ATTRIBUTE_DEVKERNTEXT "devKernText"
#define DEBUGCANVAS_ATTRIBUTE_LCDRENDERTEXT "lcdRenderText"
#define DEBUGCANVAS_ATTRIBUTE_EMBEDDEDBITMAPTEXT "embeddedBitmapText"
#define DEBUGCANVAS_ATTRIBUTE_AUTOHINTING "forceAutoHinting"
#define DEBUGCANVAS_ATTRIBUTE_REGION "region"
#define DEBUGCANVAS_ATTRIBUTE_REGIONOP "op"
#define DEBUGCANVAS_ATTRIBUTE_EDGESTYLE "edgeStyle"
#define DEBUGCANVAS_ATTRIBUTE_DEVICEREGION "deviceRegion"
#define DEBUGCANVAS_ATTRIBUTE_BLUR "blur"
#define DEBUGCANVAS_ATTRIBUTE_SIGMA "sigma"
#define DEBUGCANVAS_ATTRIBUTE_QUALITY "quality"
#define DEBUGCANVAS_ATTRIBUTE_TEXTSIZE "textSize"
#define DEBUGCANVAS_ATTRIBUTE_TEXTSCALEX "textScaleX"
#define DEBUGCANVAS_ATTRIBUTE_TEXTSKEWX "textSkewX"
#define DEBUGCANVAS_ATTRIBUTE_DASHING "dashing"
#define DEBUGCANVAS_ATTRIBUTE_INTERVALS "intervals"
#define DEBUGCANVAS_ATTRIBUTE_PHASE "phase"
#define DEBUGCANVAS_ATTRIBUTE_FILLTYPE "fillType"
#define DEBUGCANVAS_ATTRIBUTE_VERBS "verbs"
#define DEBUGCANVAS_ATTRIBUTE_NAME "name"
#define DEBUGCANVAS_ATTRIBUTE_DATA "data"
#define DEBUGCANVAS_ATTRIBUTE_VALUES "values"
#define DEBUGCANVAS_ATTRIBUTE_SHADER "shader"
#define DEBUGCANVAS_ATTRIBUTE_PATHEFFECT "pathEffect"
#define DEBUGCANVAS_ATTRIBUTE_MASKFILTER "maskFilter"
#define DEBUGCANVAS_ATTRIBUTE_XFERMODE "xfermode"
#define DEBUGCANVAS_ATTRIBUTE_BACKDROP "backdrop"
#define DEBUGCANVAS_ATTRIBUTE_COLORFILTER "colorfilter"
#define DEBUGCANVAS_ATTRIBUTE_IMAGEFILTER "imagefilter"
#define DEBUGCANVAS_ATTRIBUTE_IMAGE "image"
#define DEBUGCANVAS_ATTRIBUTE_IMAGE_INDEX "imageIndex"
#define DEBUGCANVAS_ATTRIBUTE_BITMAP "bitmap"
#define DEBUGCANVAS_ATTRIBUTE_SRC "src"
#define DEBUGCANVAS_ATTRIBUTE_DST "dst"
#define DEBUGCANVAS_ATTRIBUTE_CENTER "center"
#define DEBUGCANVAS_ATTRIBUTE_STRICT "strict"
#define DEBUGCANVAS_ATTRIBUTE_DESCRIPTION "description"
#define DEBUGCANVAS_ATTRIBUTE_X "x"
#define DEBUGCANVAS_ATTRIBUTE_Y "y"
#define DEBUGCANVAS_ATTRIBUTE_RUNS "runs"
#define DEBUGCANVAS_ATTRIBUTE_POSITIONS "positions"
#define DEBUGCANVAS_ATTRIBUTE_GLYPHS "glyphs"
#define DEBUGCANVAS_ATTRIBUTE_FONT "font"
#define DEBUGCANVAS_ATTRIBUTE_TYPEFACE "typeface"
#define DEBUGCANVAS_ATTRIBUTE_CUBICS "cubics"
#define DEBUGCANVAS_ATTRIBUTE_COLORS "colors"
#define DEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS "textureCoords"
#define DEBUGCANVAS_ATTRIBUTE_STARTANGLE "startAngle"
#define DEBUGCANVAS_ATTRIBUTE_SWEEPANGLE "sweepAngle"
#define DEBUGCANVAS_ATTRIBUTE_USECENTER "useCenter"
#define DEBUGCANVAS_ATTRIBUTE_SHORTDESC "shortDesc"
#define DEBUGCANVAS_ATTRIBUTE_UNIQUE_ID "uniqueID"
#define DEBUGCANVAS_ATTRIBUTE_WIDTH "width"
#define DEBUGCANVAS_ATTRIBUTE_HEIGHT "height"
#define DEBUGCANVAS_ATTRIBUTE_ALPHA "alpha"
#define DEBUGCANVAS_ATTRIBUTE_LATTICE "lattice"
#define DEBUGCANVAS_ATTRIBUTE_LATTICEXCOUNT "xCount"
#define DEBUGCANVAS_ATTRIBUTE_LATTICEYCOUNT "yCount"
#define DEBUGCANVAS_ATTRIBUTE_LATTICEXDIVS "xDivs"
#define DEBUGCANVAS_ATTRIBUTE_LATTICEYDIVS "yDivs"
#define DEBUGCANVAS_ATTRIBUTE_LATTICEFLAGS "flags"
#define DEBUGCANVAS_ATTRIBUTE_ZPLANE "zPlane"
#define DEBUGCANVAS_ATTRIBUTE_LIGHTPOSITION "lightPositions"
#define DEBUGCANVAS_ATTRIBUTE_AMBIENTCOLOR "ambientColor"
#define DEBUGCANVAS_ATTRIBUTE_SPOTCOLOR "spotColor"
#define DEBUGCANVAS_ATTRIBUTE_LIGHTRADIUS "lightRadius"
#define DEBUGCANVAS_ATTRIBUTE_LAYERNODEID "layerNodeId"
#define DEBUGCANVAS_VERB_MOVE "move"
#define DEBUGCANVAS_VERB_LINE "line"
#define DEBUGCANVAS_VERB_QUAD "quad"
#define DEBUGCANVAS_VERB_CUBIC "cubic"
#define DEBUGCANVAS_VERB_CONIC "conic"
#define DEBUGCANVAS_VERB_CLOSE "close"
#define DEBUGCANVAS_STYLE_FILL "fill"
#define DEBUGCANVAS_STYLE_STROKE "stroke"
#define DEBUGCANVAS_STYLE_STROKEANDFILL "strokeAndFill"
#define DEBUGCANVAS_POINTMODE_POINTS "points"
#define DEBUGCANVAS_POINTMODE_LINES "lines"
#define DEBUGCANVAS_POINTMODE_POLYGON "polygon"
#define DEBUGCANVAS_CLIPOP_DIFFERENCE "difference"
#define DEBUGCANVAS_CLIPOP_INTERSECT "intersect"
#define DEBUGCANVAS_BLURSTYLE_NORMAL "normal"
#define DEBUGCANVAS_BLURSTYLE_SOLID "solid"
#define DEBUGCANVAS_BLURSTYLE_OUTER "outer"
#define DEBUGCANVAS_BLURSTYLE_INNER "inner"
#define DEBUGCANVAS_BLURQUALITY_LOW "low"
#define DEBUGCANVAS_BLURQUALITY_HIGH "high"
#define DEBUGCANVAS_FILLTYPE_WINDING "winding"
#define DEBUGCANVAS_FILLTYPE_EVENODD "evenOdd"
#define DEBUGCANVAS_FILLTYPE_INVERSEWINDING "inverseWinding"
#define DEBUGCANVAS_FILLTYPE_INVERSEEVENODD "inverseEvenOdd"
#define DEBUGCANVAS_CAP_BUTT "butt"
#define DEBUGCANVAS_CAP_ROUND "round"
#define DEBUGCANVAS_CAP_SQUARE "square"
#define DEBUGCANVAS_MITER_JOIN "miter"
#define DEBUGCANVAS_ROUND_JOIN "round"
#define DEBUGCANVAS_BEVEL_JOIN "bevel"
#define DEBUGCANVAS_COLORTYPE_ARGB4444 "ARGB4444"
#define DEBUGCANVAS_COLORTYPE_RGBA8888 "RGBA8888"
#define DEBUGCANVAS_COLORTYPE_BGRA8888 "BGRA8888"
#define DEBUGCANVAS_COLORTYPE_565 "565"
#define DEBUGCANVAS_COLORTYPE_GRAY8 "Gray8"
#define DEBUGCANVAS_COLORTYPE_INDEX8 "Index8"
#define DEBUGCANVAS_COLORTYPE_ALPHA8 "Alpha8"
#define DEBUGCANVAS_ALPHATYPE_OPAQUE "opaque"
#define DEBUGCANVAS_ALPHATYPE_PREMUL "premul"
#define DEBUGCANVAS_ALPHATYPE_UNPREMUL "unpremul"
#define DEBUGCANVAS_ALPHATYPE_UNKNOWN "unknown"
#define DEBUGCANVAS_HINTING_NONE "none"
#define DEBUGCANVAS_HINTING_SLIGHT "slight"
#define DEBUGCANVAS_HINTING_NORMAL "normal"
#define DEBUGCANVAS_HINTING_FULL "full"
#define DEBUGCANVAS_EDGING_ALIAS "alias"
#define DEBUGCANVAS_EDGING_ANTIALIAS "antialias"
#define DEBUGCANVAS_EDGING_SUBPIXELANTIALIAS "subpixelantialias"
#define DEBUGCANVAS_SHADOWFLAG_TRANSPARENT_OCC "transparentOccluder"
#define DEBUGCANVAS_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;
}
DrawCommand::DrawCommand(OpType type) : fOpType(type), fVisible(true) {}
const char* DrawCommand::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 kResetClip_OpType: return "ResetClip";
case kConcat_OpType: return "Concat";
case kConcat44_OpType: return "Concat44";
case kDrawAnnotation_OpType: return "DrawAnnotation";
case kDrawBitmap_OpType: return "DrawBitmap";
case kDrawBitmapRect_OpType: return "DrawBitmapRect";
case kDrawDRRect_OpType: return "DrawDRRect";
case kDrawImage_OpType: return "DrawImage";
case kDrawImageLattice_OpType: return "DrawImageLattice";
case kDrawImageRect_OpType: return "DrawImageRect";
case kDrawImageRectLayer_OpType: return "DrawImageRectLayer";
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 kDrawEdgeAAQuad_OpType: return "DrawEdgeAAQuad";
case kDrawEdgeAAImageSet_OpType: return "DrawEdgeAAImageSet";
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";
case kSetM44_OpType: return "SetM44";
default:
SkDebugf("OpType error 0x%08x\n", type);
SkASSERT(0);
break;
}
SkDEBUGFAIL("DrawType UNUSED\n");
return nullptr;
}
void DrawCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
writer.appendCString(DEBUGCANVAS_ATTRIBUTE_COMMAND, this->GetCommandString(fOpType));
writer.appendBool(DEBUGCANVAS_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_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);
}
void apply_paint_blend_mode(const SkPaint& paint, SkJSONWriter& writer) {
const auto mode = paint.getBlendMode_or(SkBlendMode::kSrcOver);
if (mode != SkBlendMode::kSrcOver) {
writer.appendCString(DEBUGCANVAS_ATTRIBUTE_BLENDMODE, SkBlendMode_Name(mode));
}
}
} // namespace
void DrawCommand::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 DrawCommand::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 DrawCommand::MakeJsonPoint(SkJSONWriter& writer, const SkPoint& point) {
writer.beginArray(nullptr, false);
writer.appendFloat(point.x());
writer.appendFloat(point.y());
writer.endArray();
}
void DrawCommand::MakeJsonPoint(SkJSONWriter& writer, SkScalar x, SkScalar y) {
writer.beginArray(nullptr, false);
writer.appendFloat(x);
writer.appendFloat(y);
writer.endArray();
}
void DrawCommand::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 DrawCommand::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 DrawCommand::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);
DrawCommand::MakeJsonRect(writer, rrect.rect());
DrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kUpperLeft_Corner));
DrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kUpperRight_Corner));
DrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kLowerRight_Corner));
DrawCommand::MakeJsonPoint(writer, rrect.radii(SkRRect::kLowerLeft_Corner));
writer.endArray();
}
void DrawCommand::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 DrawCommand::MakeJsonMatrix44(SkJSONWriter& writer, const SkM44& matrix) {
writer.beginArray();
for (int r = 0; r < 4; ++r) {
writer.beginArray(nullptr, false);
for (int c = 0; c < 4; ++c) {
writer.appendFloat(matrix.rc(r, c));
}
writer.endArray();
}
writer.endArray();
}
void DrawCommand::MakeJsonPath(SkJSONWriter& writer, const SkPath& path) {
writer.beginObject();
SkDynamicMemoryWStream wstream;
path.dump(&wstream, false);
auto data = wstream.detachAsData();
writer.appendString(DEBUGCANVAS_ATTRIBUTE_DUMP,
static_cast<const char*>(data->data()), data->size());
switch (path.getFillType()) {
case SkPathFillType::kWinding:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE, DEBUGCANVAS_FILLTYPE_WINDING);
break;
case SkPathFillType::kEvenOdd:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE, DEBUGCANVAS_FILLTYPE_EVENODD);
break;
case SkPathFillType::kInverseWinding:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE,
DEBUGCANVAS_FILLTYPE_INVERSEWINDING);
break;
case SkPathFillType::kInverseEvenOdd:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE,
DEBUGCANVAS_FILLTYPE_INVERSEEVENODD);
break;
}
writer.beginArray(DEBUGCANVAS_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.appendNString(DEBUGCANVAS_VERB_CLOSE);
continue;
}
writer.beginObject(); // verb
switch (verb) {
case SkPath::kLine_Verb: {
writer.appendName(DEBUGCANVAS_VERB_LINE);
MakeJsonPoint(writer, pts[1]);
break;
}
case SkPath::kQuad_Verb: {
writer.beginArray(DEBUGCANVAS_VERB_QUAD);
MakeJsonPoint(writer, pts[1]);
MakeJsonPoint(writer, pts[2]);
writer.endArray(); // quad coords
break;
}
case SkPath::kCubic_Verb: {
writer.beginArray(DEBUGCANVAS_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(DEBUGCANVAS_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(DEBUGCANVAS_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 DrawCommand::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);
}
void DrawCommand::MakeJsonSampling(SkJSONWriter& writer, const SkSamplingOptions& sampling) {
writer.beginObject();
writer.appendS32("maxAniso", sampling.maxAniso);
writer.appendBool("useCubic", sampling.useCubic);
writer.appendS32("filter", (int)sampling.filter);
writer.appendS32("mipmap", (int)sampling.mipmap);
writer.appendFloat("cubic.B", sampling.cubic.B);
writer.appendFloat("cubic.C", sampling.cubic.C);
writer.endObject();
}
static const char* clipop_name(SkClipOp op) {
switch (op) {
case SkClipOp::kDifference: return DEBUGCANVAS_CLIPOP_DIFFERENCE;
case SkClipOp::kIntersect: return DEBUGCANVAS_CLIPOP_INTERSECT;
default: SkASSERT(false); return "<invalid region op>";
}
}
static const char* pointmode_name(SkCanvas::PointMode mode) {
switch (mode) {
case SkCanvas::kPoints_PointMode: return DEBUGCANVAS_POINTMODE_POINTS;
case SkCanvas::kLines_PointMode: return DEBUGCANVAS_POINTMODE_LINES;
case SkCanvas::kPolygon_PointMode: return DEBUGCANVAS_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 DrawCommand::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.appendCString(DEBUGCANVAS_ATTRIBUTE_NAME, flattenable->getTypeName());
writer.appendString(DEBUGCANVAS_ATTRIBUTE_DATA, url);
writer.beginObject(DEBUGCANVAS_ATTRIBUTE_VALUES);
JsonWriteBuffer jsonBuffer(&writer, &urlDataManager);
flattenable->flatten(jsonBuffer);
writer.endObject(); // values
sk_free(data);
}
void DrawCommand::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);
}
// flattens an image to a Json stream, also called from shader flatten
bool DrawCommand::flatten(const SkImage& image,
SkJSONWriter& writer,
UrlDataManager& urlDataManager) {
// For MSKP files, there is no need to encode the image,
// just report its id.
if (urlDataManager.hasImageIndex()) {
writer.appendName(DEBUGCANVAS_ATTRIBUTE_IMAGE_INDEX);
writer.appendU64(urlDataManager.lookupImage(&image));
return true;
}
writer.beginObject(DEBUGCANVAS_ATTRIBUTE_IMAGE);
size_t rowBytes = 4 * image.width();
SkAutoMalloc buffer(rowBytes * image.height());
SkImageInfo dstInfo =
SkImageInfo::Make(image.dimensions(), kN32_SkColorType, kPremul_SkAlphaType);
// "cheat" for this debug tool and use image's context
GrDirectContext* dContext = nullptr;
#if SK_SUPPORT_GPU
dContext = GrAsDirectContext(as_IB(&image)->context());
#endif
if (!image.readPixels(dContext, dstInfo, buffer.get(), rowBytes, 0, 0)) {
SkDebugf("DrawCommand::flatten SkImage: readPixels failed\n");
writer.endObject();
return false;
}
SkBitmap bm;
bm.installPixels(dstInfo, buffer.get(), rowBytes);
SkDynamicMemoryWStream out;
DrawCommand::WritePNG(bm, out);
sk_sp<SkData> encoded = out.detachAsData();
if (encoded == nullptr) {
SkDebugf("DrawCommand::flatten SkImage: could not encode image as PNG\n");
writer.endObject();
return false;
}
auto dataPtr = encoded->data();
if (!dataPtr) {
SkDebugf("DrawCommand::flatten SkImage: encoding as PNG produced zero length data\n");
writer.endObject();
return false;
}
SkString url = encode_data(encoded->data(), encoded->size(), "image/png", urlDataManager);
writer.appendString(DEBUGCANVAS_ATTRIBUTE_DATA, url);
writer.endObject();
return true;
}
static const char* color_type_name(SkColorType colorType) {
switch (colorType) {
case kARGB_4444_SkColorType: return DEBUGCANVAS_COLORTYPE_ARGB4444;
case kRGBA_8888_SkColorType: return DEBUGCANVAS_COLORTYPE_RGBA8888;
case kBGRA_8888_SkColorType: return DEBUGCANVAS_COLORTYPE_BGRA8888;
case kRGB_565_SkColorType: return DEBUGCANVAS_COLORTYPE_565;
case kGray_8_SkColorType: return DEBUGCANVAS_COLORTYPE_GRAY8;
case kAlpha_8_SkColorType: return DEBUGCANVAS_COLORTYPE_ALPHA8;
default: SkASSERT(false); return DEBUGCANVAS_COLORTYPE_RGBA8888;
}
}
static const char* alpha_type_name(SkAlphaType alphaType) {
switch (alphaType) {
case kOpaque_SkAlphaType: return DEBUGCANVAS_ALPHATYPE_OPAQUE;
case kPremul_SkAlphaType: return DEBUGCANVAS_ALPHATYPE_PREMUL;
case kUnpremul_SkAlphaType: return DEBUGCANVAS_ALPHATYPE_UNPREMUL;
default: SkASSERT(false); return DEBUGCANVAS_ALPHATYPE_OPAQUE;
}
}
bool DrawCommand::flatten(const SkBitmap& bitmap,
SkJSONWriter& writer,
UrlDataManager& urlDataManager) {
sk_sp<SkImage> image(bitmap.asImage());
writer.appendCString(DEBUGCANVAS_ATTRIBUTE_COLOR, color_type_name(bitmap.colorType()));
writer.appendCString(DEBUGCANVAS_ATTRIBUTE_ALPHA, alpha_type_name(bitmap.alphaType()));
// Image will appear to have no uses, TODO(nifong): provide the user with a useful explanation
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 SkFontHinting::kNone:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_HINTING, DEBUGCANVAS_HINTING_NONE);
break;
case SkFontHinting::kSlight:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_HINTING, DEBUGCANVAS_HINTING_SLIGHT);
break;
case SkFontHinting::kNormal:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_HINTING, DEBUGCANVAS_HINTING_NORMAL);
break;
case SkFontHinting::kFull:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_HINTING, DEBUGCANVAS_HINTING_FULL);
break;
}
}
}
static void apply_font_edging(const SkFont& font, SkJSONWriter& writer) {
switch (font.getEdging()) {
case SkFont::Edging::kAlias:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_EDGING, DEBUGCANVAS_EDGING_ALIAS);
break;
case SkFont::Edging::kAntiAlias:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_EDGING, DEBUGCANVAS_EDGING_ANTIALIAS);
break;
case SkFont::Edging::kSubpixelAntiAlias:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_EDGING,
DEBUGCANVAS_EDGING_SUBPIXELANTIALIAS);
break;
}
}
static void apply_paint_color(const SkPaint& paint, SkJSONWriter& writer) {
SkColor color = paint.getColor();
if (color != SK_ColorBLACK) {
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COLOR);
DrawCommand::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.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_STYLE_STROKE);
break;
}
case SkPaint::kStrokeAndFill_Style: {
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_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.appendNString(DEBUGCANVAS_ATTRIBUTE_CAP, DEBUGCANVAS_CAP_BUTT);
break;
case SkPaint::kRound_Cap:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_CAP, DEBUGCANVAS_CAP_ROUND);
break;
case SkPaint::kSquare_Cap:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_CAP, DEBUGCANVAS_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.appendNString(DEBUGCANVAS_ATTRIBUTE_STROKEJOIN, DEBUGCANVAS_MITER_JOIN);
break;
case SkPaint::kRound_Join:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STROKEJOIN, DEBUGCANVAS_ROUND_JOIN);
break;
case SkPaint::kBevel_Join:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STROKEJOIN, DEBUGCANVAS_BEVEL_JOIN);
break;
default: SkASSERT(false);
}
}
}
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(DEBUGCANVAS_ATTRIBUTE_BLUR);
writer.appendFloat(DEBUGCANVAS_ATTRIBUTE_SIGMA, blurRec.fSigma);
switch (blurRec.fStyle) {
case SkBlurStyle::kNormal_SkBlurStyle:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_BLURSTYLE_NORMAL);
break;
case SkBlurStyle::kSolid_SkBlurStyle:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_BLURSTYLE_SOLID);
break;
case SkBlurStyle::kOuter_SkBlurStyle:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_BLURSTYLE_OUTER);
break;
case SkBlurStyle::kInner_SkBlurStyle:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_STYLE, DEBUGCANVAS_BLURSTYLE_INNER);
break;
default: SkASSERT(false);
}
writer.endObject(); // blur
} else {
writer.beginObject(DEBUGCANVAS_ATTRIBUTE_MASKFILTER);
DrawCommand::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(DEBUGCANVAS_ATTRIBUTE_DASHING);
writer.beginArray(DEBUGCANVAS_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(DEBUGCANVAS_ATTRIBUTE_PHASE, dashInfo.fPhase);
writer.endObject(); // dashing
} else {
writer.beginObject(DEBUGCANVAS_ATTRIBUTE_PATHEFFECT);
DrawCommand::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(DEBUGCANVAS_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(DEBUGCANVAS_ATTRIBUTE_DATA, url);
sk_free(data);
writer.endObject();
}
}
static void apply_flattenable(const char* key,
SkFlattenable* flattenable,
SkJSONWriter& writer,
UrlDataManager& urlDataManager) {
if (flattenable != nullptr) {
writer.beginObject(key);
DrawCommand::flatten(flattenable, writer, urlDataManager);
writer.endObject();
}
}
void DrawCommand::MakeJsonPaint(SkJSONWriter& writer,
const SkPaint& paint,
UrlDataManager& urlDataManager) {
writer.beginObject();
store_scalar(writer, DEBUGCANVAS_ATTRIBUTE_STROKEWIDTH, paint.getStrokeWidth(), 0.0f);
store_scalar(writer,
DEBUGCANVAS_ATTRIBUTE_STROKEMITER,
paint.getStrokeMiter(),
SkPaintDefaults_MiterLimit);
store_bool(writer, DEBUGCANVAS_ATTRIBUTE_ANTIALIAS, paint.isAntiAlias(), false);
store_bool(writer, DEBUGCANVAS_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_patheffect(paint, writer, urlDataManager);
apply_paint_maskfilter(paint, writer, urlDataManager);
apply_flattenable(DEBUGCANVAS_ATTRIBUTE_SHADER, paint.getShader(), writer, urlDataManager);
apply_flattenable(
DEBUGCANVAS_ATTRIBUTE_IMAGEFILTER, paint.getImageFilter(), writer, urlDataManager);
apply_flattenable(
DEBUGCANVAS_ATTRIBUTE_COLORFILTER, paint.getColorFilter(), writer, urlDataManager);
writer.endObject(); // paint
}
static void MakeJsonFont(const SkFont& font, SkJSONWriter& writer, UrlDataManager& urlDataManager) {
writer.beginObject();
store_bool(writer, DEBUGCANVAS_ATTRIBUTE_FAKEBOLDTEXT, font.isEmbolden(), false);
store_bool(writer, DEBUGCANVAS_ATTRIBUTE_LINEARTEXT, font.isLinearMetrics(), false);
store_bool(writer, DEBUGCANVAS_ATTRIBUTE_SUBPIXELTEXT, font.isSubpixel(), false);
store_bool(writer, DEBUGCANVAS_ATTRIBUTE_EMBEDDEDBITMAPTEXT, font.isEmbeddedBitmaps(), false);
store_bool(writer, DEBUGCANVAS_ATTRIBUTE_AUTOHINTING, font.isForceAutoHinting(), false);
store_scalar(writer, DEBUGCANVAS_ATTRIBUTE_TEXTSIZE, font.getSize(), SkPaintDefaults_TextSize);
store_scalar(writer, DEBUGCANVAS_ATTRIBUTE_TEXTSCALEX, font.getScaleX(), SK_Scalar1);
store_scalar(writer, DEBUGCANVAS_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 DrawCommand::MakeJsonLattice(SkJSONWriter& writer, const SkCanvas::Lattice& lattice) {
writer.beginObject();
writer.appendS32(DEBUGCANVAS_ATTRIBUTE_LATTICEXCOUNT, lattice.fXCount);
writer.appendS32(DEBUGCANVAS_ATTRIBUTE_LATTICEYCOUNT, lattice.fYCount);
if (nullptr != lattice.fBounds) {
writer.appendName(DEBUGCANVAS_ATTRIBUTE_BOUNDS);
MakeJsonIRect(writer, *lattice.fBounds);
}
writer.beginArray(DEBUGCANVAS_ATTRIBUTE_LATTICEXDIVS);
for (int i = 0; i < lattice.fXCount; i++) {
writer.appendS32(lattice.fXDivs[i]);
}
writer.endArray(); // xdivs
writer.beginArray(DEBUGCANVAS_ATTRIBUTE_LATTICEYDIVS);
for (int i = 0; i < lattice.fYCount; i++) {
writer.appendS32(lattice.fYDivs[i]);
}
writer.endArray(); // ydivs
if (nullptr != lattice.fRectTypes) {
writer.beginArray(DEBUGCANVAS_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();
}
ClearCommand::ClearCommand(SkColor color) : INHERITED(kClear_OpType) { fColor = color; }
void ClearCommand::execute(SkCanvas* canvas) const { canvas->clear(fColor); }
void ClearCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COLOR);
MakeJsonColor(writer, fColor);
}
ClipPathCommand::ClipPathCommand(const SkPath& path, SkClipOp op, bool doAA)
: INHERITED(kClipPath_OpType) {
fPath = path;
fOp = op;
fDoAA = doAA;
}
void ClipPathCommand::execute(SkCanvas* canvas) const { canvas->clipPath(fPath, fOp, fDoAA); }
bool ClipPathCommand::render(SkCanvas* canvas) const {
render_path(canvas, fPath);
return true;
}
void ClipPathCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PATH);
MakeJsonPath(writer, fPath);
writer.appendCString(DEBUGCANVAS_ATTRIBUTE_REGIONOP, clipop_name(fOp));
writer.appendBool(DEBUGCANVAS_ATTRIBUTE_ANTIALIAS, fDoAA);
}
ClipRegionCommand::ClipRegionCommand(const SkRegion& region, SkClipOp op)
: INHERITED(kClipRegion_OpType) {
fRegion = region;
fOp = op;
}
void ClipRegionCommand::execute(SkCanvas* canvas) const { canvas->clipRegion(fRegion, fOp); }
void ClipRegionCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_REGION);
MakeJsonRegion(writer, fRegion);
writer.appendCString(DEBUGCANVAS_ATTRIBUTE_REGIONOP, clipop_name(fOp));
}
ClipRectCommand::ClipRectCommand(const SkRect& rect, SkClipOp op, bool doAA)
: INHERITED(kClipRect_OpType) {
fRect = rect;
fOp = op;
fDoAA = doAA;
}
void ClipRectCommand::execute(SkCanvas* canvas) const { canvas->clipRect(fRect, fOp, fDoAA); }
void ClipRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COORDS);
MakeJsonRect(writer, fRect);
writer.appendCString(DEBUGCANVAS_ATTRIBUTE_REGIONOP, clipop_name(fOp));
writer.appendBool(DEBUGCANVAS_ATTRIBUTE_ANTIALIAS, fDoAA);
SkString desc;
writer.appendString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, *str_append(&desc, fRect));
}
ClipRRectCommand::ClipRRectCommand(const SkRRect& rrect, SkClipOp op, bool doAA)
: INHERITED(kClipRRect_OpType) {
fRRect = rrect;
fOp = op;
fDoAA = doAA;
}
void ClipRRectCommand::execute(SkCanvas* canvas) const { canvas->clipRRect(fRRect, fOp, fDoAA); }
bool ClipRRectCommand::render(SkCanvas* canvas) const {
render_rrect(canvas, fRRect);
return true;
}
void ClipRRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COORDS);
make_json_rrect(writer, fRRect);
writer.appendCString(DEBUGCANVAS_ATTRIBUTE_REGIONOP, clipop_name(fOp));
writer.appendBool(DEBUGCANVAS_ATTRIBUTE_ANTIALIAS, fDoAA);
}
ClipShaderCommand::ClipShaderCommand(sk_sp<SkShader> cs, SkClipOp op)
: INHERITED(kClipShader_OpType) {
fShader = cs;
fOp = op;
}
void ClipShaderCommand::execute(SkCanvas* canvas) const { canvas->clipShader(fShader, fOp); }
bool ClipShaderCommand::render(SkCanvas* canvas) const {
SkPaint paint;
paint.setShader(fShader);
canvas->drawPaint(paint);
return true;
}
void ClipShaderCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
apply_flattenable(DEBUGCANVAS_ATTRIBUTE_SHADER, fShader.get(), writer, urlDataManager);
writer.appendCString(DEBUGCANVAS_ATTRIBUTE_REGIONOP, clipop_name(fOp));
}
ResetClipCommand::ResetClipCommand() : INHERITED(kResetClip_OpType) {}
void ResetClipCommand::execute(SkCanvas* canvas) const { SkCanvasPriv::ResetClip(canvas); }
ConcatCommand::ConcatCommand(const SkMatrix& matrix) : INHERITED(kConcat_OpType) {
fMatrix = matrix;
}
void ConcatCommand::execute(SkCanvas* canvas) const { canvas->concat(fMatrix); }
namespace {
void writeMatrixType(SkJSONWriter& writer, const SkMatrix& m) {
switch (m.getType()) {
case SkMatrix::kTranslate_Mask:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, " (translate)");
break;
case SkMatrix::kScale_Mask:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, " (scale)");
break;
case SkMatrix::kAffine_Mask:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, " (rotation or skew)");
break;
case SkMatrix::kPerspective_Mask:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, " (perspective)");
break;
default:
break;
}
}
}
void ConcatCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_MATRIX);
MakeJsonMatrix(writer, fMatrix);
writeMatrixType(writer, fMatrix);
}
Concat44Command::Concat44Command(const SkM44& matrix) : INHERITED(kConcat44_OpType) {
fMatrix = matrix;
}
void Concat44Command::execute(SkCanvas* canvas) const { canvas->concat(fMatrix); }
void Concat44Command::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_MATRIX);
MakeJsonMatrix44(writer, fMatrix);
}
////
DrawAnnotationCommand::DrawAnnotationCommand(const SkRect& rect,
const char key[],
sk_sp<SkData> value)
: INHERITED(kDrawAnnotation_OpType), fRect(rect), fKey(key), fValue(std::move(value)) {}
void DrawAnnotationCommand::execute(SkCanvas* canvas) const {
canvas->drawAnnotation(fRect, fKey.c_str(), fValue);
}
void DrawAnnotationCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COORDS);
MakeJsonRect(writer, fRect);
writer.appendString("key", fKey);
if (fValue) {
writer.appendString("value", static_cast<const char*>(fValue->data()), fValue->size());
}
SkString desc;
str_append(&desc, fRect)->appendf(" %s", fKey.c_str());
writer.appendString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, desc);
}
////
DrawImageCommand::DrawImageCommand(const SkImage* image,
SkScalar left,
SkScalar top,
const SkSamplingOptions& sampling,
const SkPaint* paint)
: INHERITED(kDrawImage_OpType)
, fImage(SkRef(image))
, fLeft(left)
, fTop(top)
, fSampling(sampling)
, fPaint(paint) {}
void DrawImageCommand::execute(SkCanvas* canvas) const {
canvas->drawImage(fImage.get(), fLeft, fTop, fSampling, fPaint.getMaybeNull());
}
bool DrawImageCommand::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;
}
uint64_t DrawImageCommand::imageId(UrlDataManager& udm) const {
return udm.lookupImage(fImage.get());
}
void DrawImageCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
flatten(*fImage, writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COORDS);
MakeJsonPoint(writer, fLeft, fTop);
if (fPaint.isValid()) {
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
writer.appendName(DEBUGCANVAS_ATTRIBUTE_SAMPLING);
MakeJsonSampling(writer, fSampling);
writer.appendU32(DEBUGCANVAS_ATTRIBUTE_UNIQUE_ID, fImage->uniqueID());
writer.appendS32(DEBUGCANVAS_ATTRIBUTE_WIDTH, fImage->width());
writer.appendS32(DEBUGCANVAS_ATTRIBUTE_HEIGHT, fImage->height());
switch (fImage->alphaType()) {
case kOpaque_SkAlphaType:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_ALPHA, DEBUGCANVAS_ALPHATYPE_OPAQUE);
break;
case kPremul_SkAlphaType:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_ALPHA, DEBUGCANVAS_ALPHATYPE_PREMUL);
break;
case kUnpremul_SkAlphaType:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_ALPHA, DEBUGCANVAS_ALPHATYPE_UNPREMUL);
break;
default:
writer.appendNString(DEBUGCANVAS_ATTRIBUTE_ALPHA, DEBUGCANVAS_ALPHATYPE_UNKNOWN);
break;
}
}
DrawImageLatticeCommand::DrawImageLatticeCommand(const SkImage* image,
const SkCanvas::Lattice& lattice,
const SkRect& dst,
SkFilterMode filter,
const SkPaint* paint)
: INHERITED(kDrawImageLattice_OpType)
, fImage(SkRef(image))
, fLattice(lattice)
, fDst(dst)
, fFilter(filter)
, fPaint(paint) {}
void DrawImageLatticeCommand::execute(SkCanvas* canvas) const {
canvas->drawImageLattice(fImage.get(), fLattice, fDst, fFilter, fPaint.getMaybeNull());
}
bool DrawImageLatticeCommand::render(SkCanvas* canvas) const {
SkAutoCanvasRestore acr(canvas, true);
canvas->clear(0xFFFFFFFF);
xlate_and_scale_to_bounds(canvas, fDst);
this->execute(canvas);
return true;
}
uint64_t DrawImageLatticeCommand::imageId(UrlDataManager& udm) const {
return udm.lookupImage(fImage.get());
}
void DrawImageLatticeCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
flatten(*fImage, writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_LATTICE);
MakeJsonLattice(writer, fLattice);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_DST);
MakeJsonRect(writer, fDst);
if (fPaint.isValid()) {
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
SkString desc;
writer.appendString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, *str_append(&desc, fDst));
}
DrawImageRectCommand::DrawImageRectCommand(const SkImage* image,
const SkRect& src,
const SkRect& dst,
const SkSamplingOptions& sampling,
const SkPaint* paint,
SkCanvas::SrcRectConstraint constraint)
: INHERITED(kDrawImageRect_OpType)
, fImage(SkRef(image))
, fSrc(src)
, fDst(dst)
, fSampling(sampling)
, fPaint(paint)
, fConstraint(constraint) {}
void DrawImageRectCommand::execute(SkCanvas* canvas) const {
canvas->drawImageRect(fImage.get(), fSrc, fDst, fSampling, fPaint.getMaybeNull(), fConstraint);
}
bool DrawImageRectCommand::render(SkCanvas* canvas) const {
SkAutoCanvasRestore acr(canvas, true);
canvas->clear(0xFFFFFFFF);
xlate_and_scale_to_bounds(canvas, fDst);
this->execute(canvas);
return true;
}
uint64_t DrawImageRectCommand::imageId(UrlDataManager& udm) const {
return udm.lookupImage(fImage.get());
}
void DrawImageRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
flatten(*fImage, writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_SRC);
MakeJsonRect(writer, fSrc);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_DST);
MakeJsonRect(writer, fDst);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_SAMPLING);
MakeJsonSampling(writer, fSampling);
if (fPaint.isValid()) {
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
writer.appendBool(DEBUGCANVAS_ATTRIBUTE_STRICT, true);
}
SkString desc;
writer.appendString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, *str_append(&desc, fDst));
}
DrawImageRectLayerCommand::DrawImageRectLayerCommand(DebugLayerManager* layerManager,
const int nodeId,
const int frame,
const SkRect& src,
const SkRect& dst,
const SkSamplingOptions& sampling,
const SkPaint* paint,
SkCanvas::SrcRectConstraint constraint)
: INHERITED(kDrawImageRectLayer_OpType)
, fLayerManager(layerManager)
, fNodeId(nodeId)
, fFrame(frame)
, fSrc(src)
, fDst(dst)
, fSampling(sampling)
, fPaint(paint)
, fConstraint(constraint) {}
void DrawImageRectLayerCommand::execute(SkCanvas* canvas) const {
sk_sp<SkImage> snapshot = fLayerManager->getLayerAsImage(fNodeId, fFrame);
canvas->drawImageRect(snapshot.get(), fSrc, fDst, SkSamplingOptions(), fPaint.getMaybeNull(), fConstraint);
}
bool DrawImageRectLayerCommand::render(SkCanvas* canvas) const {
SkAutoCanvasRestore acr(canvas, true);
canvas->clear(0xFFFFFFFF);
xlate_and_scale_to_bounds(canvas, fDst);
this->execute(canvas);
return true;
}
void DrawImageRectLayerCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
// Don't append an image attribute here, the image can be rendered in as many different ways
// as there are commands in the layer, at least. the urlDataManager would save each one under
// a different URL.
// Append the node id, and the layer inspector of the debugger will know what to do with it.
writer.appendS64(DEBUGCANVAS_ATTRIBUTE_LAYERNODEID, fNodeId);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_SRC);
MakeJsonRect(writer, fSrc);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_DST);
MakeJsonRect(writer, fDst);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_SAMPLING);
MakeJsonSampling(writer, fSampling);
if (fPaint.isValid()) {
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
writer.appendBool(DEBUGCANVAS_ATTRIBUTE_STRICT, true);
}
SkString desc;
writer.appendString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, *str_append(&desc, fDst));
}
DrawOvalCommand::DrawOvalCommand(const SkRect& oval, const SkPaint& paint)
: INHERITED(kDrawOval_OpType) {
fOval = oval;
fPaint = paint;
}
void DrawOvalCommand::execute(SkCanvas* canvas) const { canvas->drawOval(fOval, fPaint); }
bool DrawOvalCommand::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 DrawOvalCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COORDS);
MakeJsonRect(writer, fOval);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
}
DrawArcCommand::DrawArcCommand(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 DrawArcCommand::execute(SkCanvas* canvas) const {
canvas->drawArc(fOval, fStartAngle, fSweepAngle, fUseCenter, fPaint);
}
bool DrawArcCommand::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 DrawArcCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COORDS);
MakeJsonRect(writer, fOval);
writer.appendFloat(DEBUGCANVAS_ATTRIBUTE_STARTANGLE, fStartAngle);
writer.appendFloat(DEBUGCANVAS_ATTRIBUTE_SWEEPANGLE, fSweepAngle);
writer.appendBool(DEBUGCANVAS_ATTRIBUTE_USECENTER, fUseCenter);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
}
DrawPaintCommand::DrawPaintCommand(const SkPaint& paint) : INHERITED(kDrawPaint_OpType) {
fPaint = paint;
}
void DrawPaintCommand::execute(SkCanvas* canvas) const { canvas->drawPaint(fPaint); }
bool DrawPaintCommand::render(SkCanvas* canvas) const {
canvas->clear(0xFFFFFFFF);
canvas->drawPaint(fPaint);
return true;
}
void DrawPaintCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
}
DrawBehindCommand::DrawBehindCommand(const SkPaint& paint) : INHERITED(kDrawPaint_OpType) {
fPaint = paint;
}
void DrawBehindCommand::execute(SkCanvas* canvas) const {
SkCanvasPriv::DrawBehind(canvas, fPaint);
}
bool DrawBehindCommand::render(SkCanvas* canvas) const {
canvas->clear(0xFFFFFFFF);
SkCanvasPriv::DrawBehind(canvas, fPaint);
return true;
}
void DrawBehindCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
}
DrawPathCommand::DrawPathCommand(const SkPath& path, const SkPaint& paint)
: INHERITED(kDrawPath_OpType) {
fPath = path;
fPaint = paint;
}
void DrawPathCommand::execute(SkCanvas* canvas) const { canvas->drawPath(fPath, fPaint); }
bool DrawPathCommand::render(SkCanvas* canvas) const {
render_path(canvas, fPath);
return true;
}
void DrawPathCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PATH);
MakeJsonPath(writer, fPath);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
}
DrawRegionCommand::DrawRegionCommand(const SkRegion& region, const SkPaint& paint)
: INHERITED(kDrawRegion_OpType) {
fRegion = region;
fPaint = paint;
}
void DrawRegionCommand::execute(SkCanvas* canvas) const { canvas->drawRegion(fRegion, fPaint); }
bool DrawRegionCommand::render(SkCanvas* canvas) const {
render_region(canvas, fRegion);
return true;
}
void DrawRegionCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_REGION);
MakeJsonRegion(writer, fRegion);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
}
BeginDrawPictureCommand::BeginDrawPictureCommand(const SkPicture* picture,
const SkMatrix* matrix,
const SkPaint* paint)
: INHERITED(kBeginDrawPicture_OpType)
, fPicture(SkRef(picture))
, fMatrix(matrix)
, fPaint(paint) {}
void BeginDrawPictureCommand::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 BeginDrawPictureCommand::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;
}
EndDrawPictureCommand::EndDrawPictureCommand(bool restore)
: INHERITED(kEndDrawPicture_OpType), fRestore(restore) {}
void EndDrawPictureCommand::execute(SkCanvas* canvas) const {
if (fRestore) {
canvas->restore();
}
}
DrawPointsCommand::DrawPointsCommand(SkCanvas::PointMode mode,
size_t count,
const SkPoint pts[],
const SkPaint& paint)
: INHERITED(kDrawPoints_OpType), fMode(mode), fPts(pts, count), fPaint(paint) {}
void DrawPointsCommand::execute(SkCanvas* canvas) const {
canvas->drawPoints(fMode, fPts.size(), fPts.begin(), fPaint);
}
bool DrawPointsCommand::render(SkCanvas* canvas) const {
canvas->clear(0xFFFFFFFF);
canvas->save();
SkRect bounds;
bounds.setEmpty();
for (int i = 0; i < fPts.size(); ++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.size(), fPts.begin(), p);
canvas->restore();
return true;
}
void DrawPointsCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendCString(DEBUGCANVAS_ATTRIBUTE_MODE, pointmode_name(fMode));
writer.beginArray(DEBUGCANVAS_ATTRIBUTE_POINTS);
for (int i = 0; i < fPts.size(); i++) {
MakeJsonPoint(writer, fPts[i]);
}
writer.endArray(); // points
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
}
DrawTextBlobCommand::DrawTextBlobCommand(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 DrawTextBlobCommand::execute(SkCanvas* canvas) const {
canvas->drawTextBlob(fBlob, fXPos, fYPos, fPaint);
}
bool DrawTextBlobCommand::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 DrawTextBlobCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginArray(DEBUGCANVAS_ATTRIBUTE_RUNS);
SkTextBlobRunIterator iter(fBlob.get());
while (!iter.done()) {
writer.beginObject(); // run
writer.beginArray(DEBUGCANVAS_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(DEBUGCANVAS_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(DEBUGCANVAS_ATTRIBUTE_FONT);
MakeJsonFont(iter.font(), writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COORDS);
MakeJsonPoint(writer, iter.offset());
writer.endObject(); // run
iter.next();
}
writer.endArray(); // runs
writer.appendFloat(DEBUGCANVAS_ATTRIBUTE_X, fXPos);
writer.appendFloat(DEBUGCANVAS_ATTRIBUTE_Y, fYPos);
SkRect bounds = fBlob->bounds();
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COORDS);
MakeJsonRect(writer, bounds);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
SkString desc;
// make the bounds local by applying the x,y
bounds.offset(fXPos, fYPos);
writer.appendString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, *str_append(&desc, bounds));
}
DrawPatchCommand::DrawPatchCommand(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 DrawPatchCommand::execute(SkCanvas* canvas) const {
canvas->drawPatch(fCubics, fColorsPtr, fTexCoordsPtr, fBlendMode, fPaint);
}
void DrawPatchCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.beginArray(DEBUGCANVAS_ATTRIBUTE_CUBICS);
for (int i = 0; i < 12; i++) {
MakeJsonPoint(writer, fCubics[i]);
}
writer.endArray(); // cubics
if (fColorsPtr != nullptr) {
writer.beginArray(DEBUGCANVAS_ATTRIBUTE_COLORS);
for (int i = 0; i < 4; i++) {
MakeJsonColor(writer, fColorsPtr[i]);
}
writer.endArray(); // colors
}
if (fTexCoordsPtr != nullptr) {
writer.beginArray(DEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS);
for (int i = 0; i < 4; i++) {
MakeJsonPoint(writer, fTexCoords[i]);
}
writer.endArray(); // texCoords
}
// fBlendMode
}
DrawRectCommand::DrawRectCommand(const SkRect& rect, const SkPaint& paint)
: INHERITED(kDrawRect_OpType) {
fRect = rect;
fPaint = paint;
}
void DrawRectCommand::execute(SkCanvas* canvas) const { canvas->drawRect(fRect, fPaint); }
void DrawRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COORDS);
MakeJsonRect(writer, fRect);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
SkString desc;
writer.appendString(DEBUGCANVAS_ATTRIBUTE_SHORTDESC, *str_append(&desc, fRect));
}
DrawRRectCommand::DrawRRectCommand(const SkRRect& rrect, const SkPaint& paint)
: INHERITED(kDrawRRect_OpType) {
fRRect = rrect;
fPaint = paint;
}
void DrawRRectCommand::execute(SkCanvas* canvas) const { canvas->drawRRect(fRRect, fPaint); }
bool DrawRRectCommand::render(SkCanvas* canvas) const {
render_rrect(canvas, fRRect);
return true;
}
void DrawRRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_COORDS);
make_json_rrect(writer, fRRect);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
}
DrawDRRectCommand::DrawDRRectCommand(const SkRRect& outer,
const SkRRect& inner,
const SkPaint& paint)
: INHERITED(kDrawDRRect_OpType) {
fOuter = outer;
fInner = inner;
fPaint = paint;
}
void DrawDRRectCommand::execute(SkCanvas* canvas) const {
canvas->drawDRRect(fOuter, fInner, fPaint);
}
bool DrawDRRectCommand::render(SkCanvas* canvas) const {
render_drrect(canvas, fOuter, fInner);
return true;
}
void DrawDRRectCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_OUTER);
make_json_rrect(writer, fOuter);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_INNER);
make_json_rrect(writer, fInner);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, fPaint, urlDataManager);
}
DrawShadowCommand::DrawShadowCommand(const SkPath& path, const SkDrawShadowRec& rec)
: INHERITED(kDrawShadow_OpType) {
fPath = path;
fShadowRec = rec;
}
void DrawShadowCommand::execute(SkCanvas* canvas) const {
canvas->private_draw_shadow_rec(fPath, fShadowRec);
}
bool DrawShadowCommand::render(SkCanvas* canvas) const {
render_shadow(canvas, fPath, fShadowRec);
return true;
}
void DrawShadowCommand::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(DEBUGCANVAS_ATTRIBUTE_PATH);
MakeJsonPath(writer, fPath);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_ZPLANE);
MakeJsonPoint3(writer, fShadowRec.fZPlaneParams);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_LIGHTPOSITION);
MakeJsonPoint3(writer, fShadowRec.fLightPos);
writer.appendFloat(DEBUGCANVAS_ATTRIBUTE_LIGHTRADIUS, fShadowRec.fLightRadius);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_AMBIENTCOLOR);
MakeJsonColor(writer, fShadowRec.fAmbientColor);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_SPOTCOLOR);
MakeJsonColor(writer, fShadowRec.fSpotColor);
store_bool(writer, DEBUGCANVAS_SHADOWFLAG_TRANSPARENT_OCC, transparentOccluder, false);
store_bool(writer, DEBUGCANVAS_SHADOWFLAG_GEOMETRIC_ONLY, geometricOnly, false);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
DrawEdgeAAQuadCommand::DrawEdgeAAQuadCommand(const SkRect& rect,
const SkPoint clip[4],
SkCanvas::QuadAAFlags aa,
const SkColor4f& color,
SkBlendMode mode)
: INHERITED(kDrawEdgeAAQuad_OpType)
, fRect(rect)
, fHasClip(clip != nullptr)
, fAA(aa)
, fColor(color)
, fMode(mode) {
if (clip) {
for (int i = 0; i < 4; ++i) {
fClip[i] = clip[i];
}
}
}
void DrawEdgeAAQuadCommand::execute(SkCanvas* canvas) const {
canvas->experimental_DrawEdgeAAQuad(fRect, fHasClip ? fClip : nullptr, fAA, fColor, fMode);
}
DrawEdgeAAImageSetCommand::DrawEdgeAAImageSetCommand(const SkCanvas::ImageSetEntry set[],
int count,
const SkPoint dstClips[],
const SkMatrix preViewMatrices[],
const SkSamplingOptions& sampling,
const SkPaint* paint,
SkCanvas::SrcRectConstraint constraint)
: INHERITED(kDrawEdgeAAImageSet_OpType)
, fSet(count)
, fCount(count)
, fSampling(sampling)
, fPaint(paint)
, fConstraint(constraint) {
int totalDstClipCount, totalMatrixCount;
SkCanvasPriv::GetDstClipAndMatrixCounts(set, count, &totalDstClipCount, &totalMatrixCount);
std::copy_n(set, count, fSet.get());
fDstClips.reset(totalDstClipCount);
std::copy_n(dstClips, totalDstClipCount, fDstClips.get());
fPreViewMatrices.reset(totalMatrixCount);
std::copy_n(preViewMatrices, totalMatrixCount, fPreViewMatrices.get());
}
void DrawEdgeAAImageSetCommand::execute(SkCanvas* canvas) const {
canvas->experimental_DrawEdgeAAImageSet(fSet.get(),
fCount,
fDstClips.get(),
fPreViewMatrices.get(),
fSampling,
fPaint.getMaybeNull(),
fConstraint);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
DrawDrawableCommand::DrawDrawableCommand(SkDrawable* drawable, const SkMatrix* matrix)
: INHERITED(kDrawDrawable_OpType), fDrawable(SkRef(drawable)), fMatrix(matrix) {}
void DrawDrawableCommand::execute(SkCanvas* canvas) const {
canvas->drawDrawable(fDrawable.get(), fMatrix.getMaybeNull());
}
///////////////////////////////////////////////////////////////////////////////////////////////////
DrawVerticesCommand::DrawVerticesCommand(sk_sp<SkVertices> vertices,
SkBlendMode bmode,
const SkPaint& paint)
: INHERITED(kDrawVertices_OpType)
, fVertices(std::move(vertices))
, fBlendMode(bmode)
, fPaint(paint) {}
void DrawVerticesCommand::execute(SkCanvas* canvas) const {
canvas->drawVertices(fVertices, fBlendMode, fPaint);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
DrawAtlasCommand::DrawAtlasCommand(const SkImage* image,
const SkRSXform xform[],
const SkRect tex[],
const SkColor colors[],
int count,
SkBlendMode bmode,
const SkSamplingOptions& sampling,
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)
, fSampling(sampling)
, fCull(cull)
, fPaint(paint) {}
void DrawAtlasCommand::execute(SkCanvas* canvas) const {
canvas->drawAtlas(fImage.get(),
fXform.begin(),
fTex.begin(),
fColors.empty() ? nullptr : fColors.begin(),
fXform.size(),
fBlendMode,
fSampling,
fCull.getMaybeNull(),
fPaint.getMaybeNull());
}
///////////////////////////////////////////////////////////////////////////////////////////////////
RestoreCommand::RestoreCommand() : INHERITED(kRestore_OpType) {}
void RestoreCommand::execute(SkCanvas* canvas) const { canvas->restore(); }
SaveCommand::SaveCommand() : INHERITED(kSave_OpType) {}
void SaveCommand::execute(SkCanvas* canvas) const { canvas->save(); }
SaveLayerCommand::SaveLayerCommand(const SkCanvas::SaveLayerRec& rec)
: INHERITED(kSaveLayer_OpType)
, fBounds(rec.fBounds)
, fPaint(rec.fPaint)
, fBackdrop(SkSafeRef(rec.fBackdrop))
, fSaveLayerFlags(rec.fSaveLayerFlags)
, fBackdropScale(SkCanvasPriv::GetBackdropScaleFactor(rec)) {}
void SaveLayerCommand::execute(SkCanvas* canvas) const {
// In the common case fBackdropScale == 1.f and then this is no different than a regular Rec
canvas->saveLayer(SkCanvasPriv::ScaledBackdropLayer(fBounds.getMaybeNull(),
fPaint.getMaybeNull(),
fBackdrop.get(),
fBackdropScale,
fSaveLayerFlags));
}
void SaveLayerCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
if (fBounds.isValid()) {
writer.appendName(DEBUGCANVAS_ATTRIBUTE_BOUNDS);
MakeJsonRect(writer, *fBounds);
}
if (fPaint.isValid()) {
writer.appendName(DEBUGCANVAS_ATTRIBUTE_PAINT);
MakeJsonPaint(writer, *fPaint, urlDataManager);
}
if (fBackdrop != nullptr) {
writer.beginObject(DEBUGCANVAS_ATTRIBUTE_BACKDROP);
flatten(fBackdrop.get(), writer, urlDataManager);
writer.endObject(); // backdrop
}
if (fSaveLayerFlags != 0) {
SkDebugf("unsupported: saveLayer flags\n");
SkASSERT(false);
}
}
SetMatrixCommand::SetMatrixCommand(const SkMatrix& matrix) : INHERITED(kSetMatrix_OpType) {
fMatrix = matrix;
}
void SetMatrixCommand::execute(SkCanvas* canvas) const { canvas->setMatrix(fMatrix); }
void SetMatrixCommand::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_MATRIX);
MakeJsonMatrix(writer, fMatrix);
writeMatrixType(writer, fMatrix);
}
SetM44Command::SetM44Command(const SkM44& matrix) : INHERITED(kSetM44_OpType) {
fMatrix = matrix;
}
void SetM44Command::execute(SkCanvas* canvas) const { canvas->setMatrix(fMatrix); }
void SetM44Command::toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const {
INHERITED::toJSON(writer, urlDataManager);
writer.appendName(DEBUGCANVAS_ATTRIBUTE_MATRIX);
MakeJsonMatrix44(writer, fMatrix);
}