Creating framework for drawShadowedPicture

include/core/SkCanvas.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
 #include "SkTypes.h"
 #include "SkBitmap.h"
 #include "SkDeque.h"
 #include "SkImage.h"
 #include "SkPaint.h"
 #include "SkRefCnt.h"
 #include "SkRegion.h"
 #include "SkSurfaceProps.h"
 #include "SkXfermode.h"
+#include "SkLights.h"
 
 class GrContext;
 class GrDrawContext;
 class SkBaseDevice;
 class SkCanvasClipVisitor;
 class SkClipStack;
 class SkData;
 class SkDraw;
 class SkDrawable;
 class SkDrawFilter;
@@ skipping 414 matching lines @@
 
     /** Replace the current matrix with a copy of the specified matrix.
         @param matrix The matrix that will be copied into the current matrix.
     */
     void setMatrix(const SkMatrix& matrix);
 
     /** Helper for setMatrix(identity). Sets the current matrix to identity.
     */
     void resetMatrix();
 
+#ifndef SK_RELEASE
     /** Add the specified translation to the current draw depth of the canvas.
         @param z    The distance to translate in Z.
                     Negative into screen, positive out of screen.
                     Without translation, the draw depth defaults to 0.
     */
     void translateZ(SkScalar z);
 
+    /** Set the current set of lights in the canvas.
+        @param lights   The lights that we want the canvas to have.
+    */
+    void setLights(sk_sp<SkLights> lights);
+
+    /** Returns the current set of lights the canvas uses
+      */
+    sk_sp<SkLights> getLights() const;
+#endif
+
     /**
      *  Modify the current clip with the specified rectangle.
      *  @param rect The rect to combine with the current clip
      *  @param op The region op to apply to the current clip
      *  @param doAntiAlias true if the clip should be antialiased
      */
     void clipRect(const SkRect& rect,
                   SkRegion::Op op = SkRegion::kIntersect_Op,
                   bool doAntiAlias = false);
 
@@ skipping 571 matching lines @@
      *  If paint is non-null, draw the picture into a temporary buffer, and then apply the paint's
      *  alpha/colorfilter/imagefilter/xfermode to that buffer as it is drawn to the canvas.
      *  This is logically equivalent to
      *      saveLayer(paint)/drawPicture/restore
      */
     void drawPicture(const SkPicture*, const SkMatrix* matrix, const SkPaint* paint);
     void drawPicture(const sk_sp<SkPicture>& picture, const SkMatrix* matrix, const SkPaint* paint) {
         this->drawPicture(picture.get(), matrix, paint);
     }
 
+#ifndef SK_RELEASE
+    /**
+     *  Draw the picture into this canvas.
+     *
+     *  We will use the canvas's lights along with the picture information (draw depths of
+     *  objects, etc) to first create a set of shadowmaps for the light-picture pairs, and
+     *  then use that set of shadowmaps to render the scene with shadows.
+     *
+     *  If matrix is non-null, apply that matrix to the CTM when drawing this picture. This is
+     *  logically equivalent to
+     *      save/concat/drawPicture/restore
+     *
+     *  If paint is non-null, draw the picture into a temporary buffer, and then apply the paint's
+     *  alpha/colorfilter/imagefilter/xfermode to that buffer as it is drawn to the canvas.
+     *  This is logically equivalent to
+     *      saveLayer(paint)/drawPicture/restore
+     *
+     */
+    void drawShadowedPicture(const SkPicture*,
+                             const SkMatrix* matrix,
+                             const SkPaint* paint);
+    void drawShadowedPicture(const sk_sp<SkPicture>& picture,
+                             const SkMatrix* matrix,
+                             const SkPaint* paint) {
+        this->drawShadowedPicture(picture.get(), matrix, paint);
+    }
+#endif
+
     enum VertexMode {
         kTriangles_VertexMode,
         kTriangleStrip_VertexMode,
         kTriangleFan_VertexMode
     };
 
     /** Draw the array of vertices, interpreted as triangles (based on mode).
 
         If both textures and vertex-colors are NULL, it strokes hairlines with
         the paint's color. This behavior is a useful debugging mode to visualize
@@ skipping 198 matching lines @@
                                const SkPaint* paint,
                                SrcRectConstraint constraint = kStrict_SrcRectConstraint);
 
     // expose minimum amount of information necessary for transitional refactoring
     /**
      * Returns CTM and clip bounds, translated from canvas coordinates to top layer coordinates.
      */
     void temporary_internal_describeTopLayer(SkMatrix* matrix, SkIRect* clip_bounds);
 
 protected:
+#ifndef SK_RELEASE
     /** Returns the current (cumulative) draw depth of the canvas.
       */
     SkScalar getZ() const;
 
+    sk_sp<SkLights> fLights;
+#endif
+
     /** After calling saveLayer(), there can be any number of devices that make
         up the top-most drawing area. LayerIter can be used to iterate through
         those devices. Note that the iterator is only valid until the next API
         call made on the canvas. Ownership of all pointers in the iterator stays
         with the canvas, so none of them should be modified or deleted.
     */
     class LayerIter /*: SkNoncopyable*/ {
     public:
         /** Initialize iterator with canvas, and set values for 1st device */
         LayerIter(SkCanvas*, bool skipEmptyClips);
@@ skipping 45 matching lines @@
 
     virtual void willSave() {}
     // Overriders should call the corresponding INHERITED method up the inheritance chain.
     virtual SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec&) {
         return kFullLayer_SaveLayerStrategy;
     }
     virtual void willRestore() {}
     virtual void didRestore() {}
     virtual void didConcat(const SkMatrix&) {}
     virtual void didSetMatrix(const SkMatrix&) {}
+
+#ifndef SK_RELEASE
     virtual void didTranslateZ(SkScalar) {}
+#endif
 
     virtual void onDrawAnnotation(const SkRect&, const char key[], SkData* value);
     virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&);
 
     virtual void onDrawText(const void* text, size_t byteLength, SkScalar x,
                             SkScalar y, const SkPaint& paint);
 
     virtual void onDrawPosText(const void* text, size_t byteLength,
                                const SkPoint pos[], const SkPaint& paint);
 
@@ skipping 45 matching lines @@
     };
 
     virtual void onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle);
     virtual void onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle);
     virtual void onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle);
     virtual void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op);
 
     virtual void onDiscard();
 
     virtual void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*);
+    virtual void onDrawShadowedPicture(const SkPicture*,
+                                       const SkMatrix*,
+                                       const SkPaint*);
 
     // Returns the canvas to be used by DrawIter. Default implementation
     // returns this. Subclasses that encapsulate an indirect canvas may
     // need to overload this method. The impl must keep track of this, as it
     // is not released or deleted by the caller.
     virtual SkCanvas* canvasForDrawIter();
 
     // Clip rectangle bounds. Called internally by saveLayer.
     // returns false if the entire rectangle is entirely clipped out
     // If non-NULL, The imageFilter parameter will be used to expand the clip
@@ skipping 202 matching lines @@
 
 class SkCanvasClipVisitor {
 public:
     virtual ~SkCanvasClipVisitor();
     virtual void clipRect(const SkRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipRRect(const SkRRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) = 0;
 };
 
 #endif