made point light shadows

src/utils/SkShadowPaintFilterCanvas.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPathEffect.h"
 #include "SkShadowPaintFilterCanvas.h"
 
@@ skipping 33 matching lines @@
 
         *paint->writable() = newPaint;
     }
 
     return true;
 }
 
 SkISize SkShadowPaintFilterCanvas::ComputeDepthMapSize(const SkLights::Light& light, int maxDepth,
                                                        int width, int height) {
     if (light.type() != SkLights::Light::kDirectional_LightType) {
-        return SkISize::Make(width *2 , height * 2);
+        return SkISize::Make(width * 2, height * 2);
     }
 
     int dMapWidth = SkMin32(maxDepth * fabs(light.dir().fX) + width,
                             width * 2);
     int dMapHeight = SkMin32(maxDepth * fabs(light.dir().fY) + height,
                              height * 2);
     return SkISize::Make(dMapWidth, dMapHeight);
 }
 
 void SkShadowPaintFilterCanvas::setShadowParams(const SkShadowParams &params) {
     fShadowParams = params;
 }
 
 void SkShadowPaintFilterCanvas::onDrawPicture(const SkPicture *picture, const SkMatrix *matrix,
                                               const SkPaint *paint) {
     SkTCopyOnFirstWrite<SkPaint> filteredPaint(paint);
     if (this->onFilter(&filteredPaint, kPicture_Type)) {
         SkCanvas::onDrawPicture(picture, matrix, filteredPaint);
     }
 }
 

[robertphillips, 2016/08/31 22:18:19]

const SkRect&

[vjiaoblack, 2016/09/01 19:22:47]

Done.

-void SkShadowPaintFilterCanvas::updateMatrix() {
+void SkShadowPaintFilterCanvas::updateMatrix(const SkRect boundRect) {
     this->save();
 
     //  It is up to the user to set the 0th light in fLights to
     //  the light the want to render the depth map with.
     if (this->fLights->light(0).type() == SkLights::Light::kDirectional_LightType) {
         const SkVector3& lightDir = this->fLights->light(0).dir();
         SkScalar x = lightDir.fX * this->getZ();
         SkScalar y = lightDir.fY * this->getZ();
 
         this->translate(x, y);
+    } else if (this->fLights->light(0).type() == SkLights::Light::kPoint_LightType) {

[robertphillips, 2016/08/31 22:18:19]

How does all this interact with the CTM and saveLayers.

I.e.,

What if we add a translate on the canvas of 500, 500 to draw a 10x10 rect vs.
drawing the 500,500,510,510 rect directly?

Similarly, if we have a large canvas but create a small layer at 500,500 to draw
several rects that are dropped down onto the main canvas together.

[vjiaoblack, 2016/09/01 19:22:47]

I'll test it.

+        const SkPoint3& lightPos = this->fLights->light(0).pos();
+
+        SkScalar scale = (lightPos.fZ) / (lightPos.fZ - this->getZ());
+
+        this->translate(-boundRect.centerX() * scale, -boundRect.centerY() * scale);
+        this->scale(scale, scale);
+        this->translate(boundRect.centerX() / scale, boundRect.centerY() / scale);
+

[robertphillips, 2016/08/31 22:18:19]

Why 400?

[vjiaoblack, 2016/09/01 19:22:48]

because it's the current height of the diffuse map. I'll have to pass it in
later

+        // pass in 400 as height
+        this->translate((boundRect.centerX() - lightPos.fX) *
+                        (this->getZ() / (lightPos.fZ - this->getZ())) / scale,
+                        - ((400 - boundRect.centerY()) - lightPos.fY) *
+                        (this->getZ() / (lightPos.fZ - this->getZ())) / scale);
     }
 }
 
 void SkShadowPaintFilterCanvas::onDrawPaint(const SkPaint &paint) {
-    this->updateMatrix();
+    SkISize size = this->getBaseLayerSize();
+    this->updateMatrix(SkRect::MakeIWH(size.fWidth, size.fHeight));
     this->INHERITED::onDrawPaint(paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawPoints(PointMode mode, size_t count, const SkPoint pts[],
                                              const SkPaint &paint) {
-    this->updateMatrix();
+    SkISize size = this->getBaseLayerSize();
+    this->updateMatrix(SkRect::MakeIWH(size.fWidth, size.fHeight));
     this->INHERITED::onDrawPoints(mode, count, pts, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawRect(const SkRect &rect, const SkPaint &paint) {
-    this->updateMatrix();
+    this->updateMatrix(rect);
     this->INHERITED::onDrawRect(rect, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawRRect(const SkRRect &rrect, const SkPaint &paint) {
-    this->updateMatrix();
+    this->updateMatrix(rrect.getBounds());
     this->INHERITED::onDrawRRect(rrect, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawDRRect(const SkRRect &outer, const SkRRect &inner,
                   const SkPaint &paint) {
-    this->updateMatrix();
+    this->updateMatrix(outer.getBounds());
     this->INHERITED::onDrawDRRect(outer, inner, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawOval(const SkRect &rect, const SkPaint &paint) {
-    this->updateMatrix();
+    this->updateMatrix(rect);
     this->INHERITED::onDrawOval(rect, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawArc(const SkRect &rect, SkScalar startAngle,
                                           SkScalar sweepAngle, bool useCenter,
                                           const SkPaint &paint) {
-    this->updateMatrix();
+    this->updateMatrix(rect);
     this->INHERITED::onDrawArc(rect, startAngle, sweepAngle, useCenter, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawPath(const SkPath &path, const SkPaint &paint) {
-    this->updateMatrix();
+    this->updateMatrix(path.getBounds());
     this->INHERITED::onDrawPath(path, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawBitmap(const SkBitmap &bm, SkScalar left, SkScalar top,
                                              const SkPaint *paint) {
-    this->updateMatrix();
+    this->updateMatrix(SkRect::MakeXYWH(left, top, bm.width(), bm.height()));
     this->INHERITED::onDrawBitmap(bm, left, top, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawBitmapRect(const SkBitmap &bm, const SkRect *src,
                                                  const SkRect &dst, const SkPaint *paint,
                                                  SrcRectConstraint constraint) {
-    this->updateMatrix();
+    this->updateMatrix(dst);
     this->INHERITED::onDrawBitmapRect(bm, src, dst, paint, constraint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawBitmapNine(const SkBitmap &bm, const SkIRect &center,
                                                  const SkRect &dst, const SkPaint *paint) {
-    this->updateMatrix();
+    this->updateMatrix(dst);
     this->INHERITED::onDrawBitmapNine(bm, center, dst, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawImage(const SkImage *image, SkScalar left,
                                             SkScalar top, const SkPaint *paint) {
-    this->updateMatrix();
+    this->updateMatrix(SkRect::MakeXYWH(left, top, image->width(), image->height()));
     this->INHERITED::onDrawImage(image, left, top, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawImageRect(const SkImage *image, const SkRect *src,
                                                 const SkRect &dst, const SkPaint *paint,
                                                 SrcRectConstraint constraint) {
-    this->updateMatrix();
+    this->updateMatrix(dst);
     this->INHERITED::onDrawImageRect(image, src, dst, paint, constraint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawImageNine(const SkImage *image, const SkIRect &center,
                                                 const SkRect &dst, const SkPaint *paint) {
-    this->updateMatrix();
+    this->updateMatrix(dst);
     this->INHERITED::onDrawImageNine(image, center, dst, paint);
     this->restore();
 }
 
 
 void SkShadowPaintFilterCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
                                                const SkPoint vertices[], const SkPoint texs[],
                                                const SkColor colors[], SkXfermode *xmode,
                                                const uint16_t indices[], int indexCount,
                                                const SkPaint &paint) {
-    this->updateMatrix();
+    SkISize size = this->getBaseLayerSize();
+    this->updateMatrix(SkRect::MakeIWH(size.fWidth, size.fHeight));
     this->INHERITED::onDrawVertices(vmode, vertexCount, vertices, texs, colors,
                                     xmode, indices, indexCount, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawPatch(const SkPoint cubics[], const SkColor colors[],
                                             const SkPoint texCoords[], SkXfermode *xmode,
                                             const SkPaint &paint) {
-    this->updateMatrix();
+    SkISize size = this->getBaseLayerSize();
+    this->updateMatrix(SkRect::MakeIWH(size.fWidth, size.fHeight));
     this->INHERITED::onDrawPatch(cubics, colors, texCoords, xmode, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawText(const void *text, size_t byteLength, SkScalar x,
                                            SkScalar y, const SkPaint &paint) {
-    this->updateMatrix();
+    this->updateMatrix(paint.getFontBounds().makeOffset(x, y));
     this->INHERITED::onDrawText(text, byteLength, x, y, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawPosText(const void *text, size_t byteLength,
                                               const SkPoint pos[], const SkPaint &paint) {
-    this->updateMatrix();
+    SkISize size = this->getBaseLayerSize();
+    this->updateMatrix(SkRect::MakeIWH(size.fWidth, size.fHeight));
     this->INHERITED::onDrawPosText(text, byteLength, pos, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawPosTextH(const void *text, size_t byteLength,
                                                const SkScalar xpos[],
                                                SkScalar constY, const SkPaint &paint) {
-    this->updateMatrix();
+    SkISize size = this->getBaseLayerSize();
+    this->updateMatrix(SkRect::MakeIWH(size.fWidth, size.fHeight));
     this->INHERITED::onDrawPosTextH(text, byteLength, xpos, constY, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawTextOnPath(const void *text, size_t byteLength,
                                                  const SkPath &path, const SkMatrix *matrix,
                                                  const SkPaint &paint) {
-    this->updateMatrix();
+    this->updateMatrix(path.getBounds());
     this->INHERITED::onDrawTextOnPath(text, byteLength, path, matrix, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawTextRSXform(const void *text, size_t byteLength,
                                                   const SkRSXform xform[], const SkRect *cull,
                                                   const SkPaint &paint) {

[robertphillips, 2016/08/31 22:18:19]

Isn't the cull parameter optional?

[vjiaoblack, 2016/09/01 19:22:47]

Done.

-    this->updateMatrix();
+    this->updateMatrix(*cull);
     this->INHERITED::onDrawTextRSXform(text, byteLength, xform, cull, paint);
     this->restore();
 }
 
 void SkShadowPaintFilterCanvas::onDrawTextBlob(const SkTextBlob *blob, SkScalar x, SkScalar y,
                                                const SkPaint &paint) {
-    this->updateMatrix();
+    SkISize size = this->getBaseLayerSize();
+    this->updateMatrix(SkRect::MakeIWH(size.fWidth, size.fHeight));
     this->INHERITED::onDrawTextBlob(blob, x, y, paint);
     this->restore();
 }
 
 #endif