| /* |
| * 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" |
| |
| #ifdef SK_EXPERIMENTAL_SHADOWING |
| |
| SkShadowPaintFilterCanvas::SkShadowPaintFilterCanvas(SkCanvas *canvas) |
| : SkPaintFilterCanvas(canvas) { |
| fShadowParams.fShadowRadius = 0.0f; |
| fShadowParams.fType = SkShadowParams::kNoBlur_ShadowType; |
| fShadowParams.fBiasingConstant = 0.0f; |
| fShadowParams.fMinVariance = 0.0f; |
| } |
| |
| // TODO use a shader instead |
| bool SkShadowPaintFilterCanvas::onFilter(SkTCopyOnFirstWrite<SkPaint>* paint, Type type) const { |
| if (*paint) { |
| int z = this->getZ(); |
| SkASSERT(z <= 0xFF && z >= 0x00); |
| |
| SkPaint newPaint; |
| newPaint.setPathEffect(sk_ref_sp<SkPathEffect>((*paint)->getPathEffect())); |
| |
| SkColor color = 0xFF000000; // init color to opaque black |
| color |= z; // Put the index into the blue component |
| |
| if (fShadowParams.fType == SkShadowParams::kVariance_ShadowType) { |
| int z2 = z * z; |
| if (z2 > 255 * 256) { |
| color |= 0xff00; |
| } else { |
| // Let's only store the more significant bits of z2 to save space. |
| // In practice, this should barely impact shadow blur quality. |
| color |= z2 & 0x0000ff00; |
| } |
| } |
| newPaint.setColor(color); |
| |
| *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) { |
| // Calculating the right depth map size for point lights is complex, |
| // as it depends on the max depth, the max depth delta, the location |
| // of the point light and the shapes, etc... If we take upper bounds |
| // on those metrics, the shadow map will be pretty big in any case. |
| // Thus, just using 4x the width and height seems to work for most scenes. |
| return SkISize::Make(width * 4, height * 4); |
| } |
| |
| 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 ¶ms) { |
| 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); |
| } |
| } |
| |
| void SkShadowPaintFilterCanvas::updateMatrix() { |
| // 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) { |
| SkISize size = this->getBaseLayerSize(); |
| |
| SkPoint3 lightPos = this->fLights->light(0).pos(); |
| |
| // shadow maps for point lights are 4x the size of the diffuse map, by experimentation |
| // (see SPFCanvas::ComputeDepthMapSize()) |
| SkScalar diffuseHeight = size.fHeight / 4.0f; |
| |
| // move point light with canvas's CTM |
| SkPoint lightPoint = SkPoint::Make(lightPos.fX, diffuseHeight - lightPos.fY); |
| SkMatrix mat = this->getTotalMatrix(); |
| if (mat.invert(&mat)) { |
| mat.mapPoints(&lightPoint, 1); |
| } |
| lightPoint.set(lightPoint.fX, diffuseHeight - lightPoint.fY); |
| |
| // center the shadow map |
| // note: the 3/8 constant is specific to the 4.0 depth map size multiplier |
| mat = this->getTotalMatrix(); |
| mat.postTranslate(size.width() * 0.375f, size.height() * 0.375f); |
| this->setMatrix(mat); |
| |
| // project shapes onto canvas as shadows |
| SkScalar scale = (lightPos.fZ) / (lightPos.fZ - this->getZ()); |
| this->scale(scale, scale); |
| |
| this->translate(-lightPoint.fX * this->getZ() / |
| ((lightPos.fZ - this->getZ()) * scale), |
| -(diffuseHeight - lightPoint.fY) * this->getZ() / |
| ((lightPos.fZ - this->getZ()) * scale)); |
| } |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawPaint(const SkPaint &paint) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawPaint(paint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawPoints(PointMode mode, size_t count, const SkPoint pts[], |
| const SkPaint &paint) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawPoints(mode, count, pts, paint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawRect(const SkRect &rect, const SkPaint &paint) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawRect(rect, paint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawRRect(const SkRRect &rrect, const SkPaint &paint) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawRRect(rrect, paint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawDRRect(const SkRRect &outer, const SkRRect &inner, |
| const SkPaint &paint) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawDRRect(outer, inner, paint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawOval(const SkRect &rect, const SkPaint &paint) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawOval(rect, paint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawArc(const SkRect &rect, SkScalar startAngle, |
| SkScalar sweepAngle, bool useCenter, |
| const SkPaint &paint) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawArc(rect, startAngle, sweepAngle, useCenter, paint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawPath(const SkPath &path, const SkPaint &paint) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawPath(path, paint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawBitmap(const SkBitmap &bm, SkScalar left, SkScalar top, |
| const SkPaint *paint) { |
| this->save(); |
| this->updateMatrix(); |
| 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->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawBitmapRect(bm, src, dst, paint, constraint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawBitmapNine(const SkBitmap &bm, const SkIRect ¢er, |
| const SkRect &dst, const SkPaint *paint) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawBitmapNine(bm, center, dst, paint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawImage(const SkImage *image, SkScalar left, |
| SkScalar top, const SkPaint *paint) { |
| this->save(); |
| this->updateMatrix(); |
| 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->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawImageRect(image, src, dst, paint, constraint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawImageNine(const SkImage *image, const SkIRect ¢er, |
| const SkRect &dst, const SkPaint *paint) { |
| this->save(); |
| this->updateMatrix(); |
| 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->save(); |
| this->updateMatrix(); |
| 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->save(); |
| this->updateMatrix(); |
| 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->save(); |
| this->updateMatrix(); |
| 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->save(); |
| this->updateMatrix(); |
| 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->save(); |
| this->updateMatrix(); |
| 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->save(); |
| this->updateMatrix(); |
| 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) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawTextRSXform(text, byteLength, xform, cull, paint); |
| this->restore(); |
| } |
| |
| void SkShadowPaintFilterCanvas::onDrawTextBlob(const SkTextBlob *blob, SkScalar x, SkScalar y, |
| const SkPaint &paint) { |
| this->save(); |
| this->updateMatrix(); |
| this->INHERITED::onDrawTextBlob(blob, x, y, paint); |
| this->restore(); |
| } |
| |
| #endif |