Creating framework for drawShadowedPicture

tools/debugger/SkDrawCommand.cpp

 /*
  * 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 "SkBlurMaskFilter.h"
@@ skipping 162 matching lines @@
     , fVisible(true) {
 }
 
 SkDrawCommand::~SkDrawCommand() {
     fInfo.deleteAll();
 }
 
 const char* SkDrawCommand::GetCommandString(OpType type) {
     switch (type) {
         case kBeginDrawPicture_OpType: return "BeginDrawPicture";
+        case kBeginDrawShadowedPicture_OpType: return "BeginDrawShadowedPicture";
         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 kDrawBitmapNine_OpType: return "DrawBitmapNine";
         case kDrawBitmapRect_OpType: return "DrawBitmapRect";
         case kDrawClear_OpType: return "DrawClear";
         case kDrawDRRect_OpType: return "DrawDRRect";
         case kDrawImage_OpType: return "DrawImage";
         case kDrawImageRect_OpType: return "DrawImageRect";
         case kDrawOval_OpType: return "DrawOval";
         case kDrawPaint_OpType: return "DrawPaint";
         case kDrawPatch_OpType: return "DrawPatch";
         case kDrawPath_OpType: return "DrawPath";
         case kDrawPoints_OpType: return "DrawPoints";
         case kDrawPosText_OpType: return "DrawPosText";
         case kDrawPosTextH_OpType: return "DrawPosTextH";
         case kDrawRect_OpType: return "DrawRect";
         case kDrawRRect_OpType: return "DrawRRect";
         case kDrawText_OpType: return "DrawText";
         case kDrawTextBlob_OpType: return "DrawTextBlob";
         case kDrawTextOnPath_OpType: return "DrawTextOnPath";
         case kDrawTextRSXform_OpType: return "DrawTextRSXform";
         case kDrawVertices_OpType: return "DrawVertices";
         case kEndDrawPicture_OpType: return "EndDrawPicture";
+        case kEndDrawShadowedPicture_OpType: return "EndDrawShadowedPicture";
         case kRestore_OpType: return "Restore";
         case kSave_OpType: return "Save";
         case kSaveLayer_OpType: return "SaveLayer";
         case kSetMatrix_OpType: return "SetMatrix";
         case kTranslateZ_OpType: return "TranslateZ";
         default:
             SkDebugf("OpType error 0x%08x\n", type);
             SkASSERT(0);
             break;
     }
@@ skipping 42 matching lines @@
         INSTALL_FACTORY(DrawTextRSXform);
         INSTALL_FACTORY(DrawTextBlob);
 
         INSTALL_FACTORY(DrawRect);
         INSTALL_FACTORY(DrawRRect);
         INSTALL_FACTORY(DrawDRRect);
         INSTALL_FACTORY(DrawPatch);
         INSTALL_FACTORY(Save);
         INSTALL_FACTORY(SaveLayer);
         INSTALL_FACTORY(SetMatrix);
-
+#ifdef SK_USE_SHADOWS
         INSTALL_FACTORY(TranslateZ);
+#endif
     }
     SkString name = SkString(command[SKDEBUGCANVAS_ATTRIBUTE_COMMAND].asCString());
     FROM_JSON* factory = factories.find(name);
     if (factory == nullptr) {
         SkDebugf("no JSON factory for '%s'\n", name.c_str());
         return nullptr;
     }
     return (*factory)(command, urlDataManager);
 }
 
@@ skipping 1199 matching lines @@
 
 static void extract_json_matrix(Json::Value& matrix, SkMatrix* result) {
     SkScalar values[] = {
         matrix[0][0].asFloat(), matrix[0][1].asFloat(), matrix[0][2].asFloat(),
         matrix[1][0].asFloat(), matrix[1][1].asFloat(), matrix[1][2].asFloat(),
         matrix[2][0].asFloat(), matrix[2][1].asFloat(), matrix[2][2].asFloat()
     };
     result->set9(values);
 }
 
+#ifdef SK_USE_SHADOWS
+// somehow this is only used in shadows...
 static void extract_json_scalar(Json::Value& scalar, SkScalar* result) {
     SkScalar value = scalar.asFloat();
     *result = value;
 }
+#endif
 
 static void extract_json_path(Json::Value& path, SkPath* result) {
     const char* fillType = path[SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE].asCString();
     if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_WINDING)) {
         result->setFillType(SkPath::kWinding_FillType);
     }
     else if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_EVENODD)) {
         result->setFillType(SkPath::kEvenOdd_FillType);
     }
     else if (!strcmp(fillType, SKDEBUGCANVAS_FILLTYPE_INVERSEWINDING)) {
@@ skipping 866 matching lines @@
 
 SkEndDrawPictureCommand::SkEndDrawPictureCommand(bool restore)
     : INHERITED(kEndDrawPicture_OpType) , fRestore(restore) { }
 
 void SkEndDrawPictureCommand::execute(SkCanvas* canvas) const {
     if (fRestore) {
         canvas->restore();
     }
 }
 
+SkBeginDrawShadowedPictureCommand::SkBeginDrawShadowedPictureCommand(const SkPicture* picture,
+                                                                     const SkMatrix* matrix,
+                                                                     const SkPaint* paint)
+        : INHERITED(kBeginDrawShadowedPicture_OpType)
+        , fPicture(SkRef(picture)) {
+
+    SkString* str = new SkString;
+    str->appendf("SkPicture: L: %f T: %f R: %f B: %f",
+                 picture->cullRect().fLeft, picture->cullRect().fTop,
+                 picture->cullRect().fRight, picture->cullRect().fBottom);
+    fInfo.push(str);
+
+    if (matrix) {
+        fMatrix.set(*matrix);
+        fInfo.push(SkObjectParser::MatrixToString(*matrix));
+    }
+
+    if (paint) {
+        fPaint.set(*paint);
+        fInfo.push(SkObjectParser::PaintToString(*paint));
+    }
+}
+
+void SkBeginDrawShadowedPictureCommand::execute(SkCanvas* canvas) const {
+    if (fPaint.isValid()) {
+        SkRect bounds = fPicture->cullRect();
+        if (fMatrix.isValid()) {
+            fMatrix.get()->mapRect(&bounds);
+        }
+        canvas->saveLayer(&bounds, fPaint.get());
+    }
+
+    if (fMatrix.isValid()) {
+        if (!fPaint.isValid()) {
+            canvas->save();
+        }
+        canvas->concat(*fMatrix.get());
+    }
+}
+
+bool SkBeginDrawShadowedPictureCommand::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;
+}
+
+SkEndDrawShadowedPictureCommand::SkEndDrawShadowedPictureCommand(bool restore)
+        : INHERITED(kEndDrawShadowedPicture_OpType) , fRestore(restore) { }
+
+void SkEndDrawShadowedPictureCommand::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;
     fCount = count;
     fPts = new SkPoint[count];
     memcpy(fPts, pts, count * sizeof(SkPoint));
     fPaint = paint;
 
     fInfo.push(SkObjectParser::PointsToString(pts, count));
@@ skipping 916 matching lines @@
     return new SkSetMatrixCommand(matrix);
 }
 
 SkTranslateZCommand::SkTranslateZCommand(SkScalar z)
     : INHERITED(kTranslateZ_OpType) {
     fZTranslate = z;
     fInfo.push(SkObjectParser::ScalarToString(fZTranslate, "drawDepthTranslation"));
 }
 
 void SkTranslateZCommand::execute(SkCanvas* canvas) const {
+#ifdef SK_USE_SHADOWS
     canvas->translateZ(fZTranslate);
+#endif
 }
 
 Json::Value SkTranslateZCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_DRAWDEPTHTRANS] = MakeJsonScalar(fZTranslate);
     return result;
 }
 
 SkTranslateZCommand* SkTranslateZCommand::fromJSON(Json::Value& command,
                                        UrlDataManager& urlDataManager) {
     SkScalar z;
+#ifdef SK_USE_SHADOWS
     extract_json_scalar(command[SKDEBUGCANVAS_ATTRIBUTE_DRAWDEPTHTRANS], &z);
+#else
+    z = 0;
+#endif
     return new SkTranslateZCommand(z);
 }