Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2016 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "LayerDrawable.h" |
John Reck | 283bb46 | 2018-12-13 16:40:14 -0800 | [diff] [blame] | 18 | #include <utils/MathUtils.h> |
Greg Daniel | 45ec62b | 2017-01-04 14:27:00 -0500 | [diff] [blame] | 19 | |
Greg Daniel | ac2d232 | 2017-07-12 11:30:15 -0400 | [diff] [blame] | 20 | #include "GrBackendSurface.h" |
Derek Sollenberger | f87da67 | 2016-11-02 11:34:27 -0400 | [diff] [blame] | 21 | #include "SkColorFilter.h" |
Greg Daniel | 45ec62b | 2017-01-04 14:27:00 -0500 | [diff] [blame] | 22 | #include "SkSurface.h" |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 23 | #include "gl/GrGLTypes.h" |
| 24 | |
| 25 | namespace android { |
| 26 | namespace uirenderer { |
| 27 | namespace skiapipeline { |
| 28 | |
| 29 | void LayerDrawable::onDraw(SkCanvas* canvas) { |
Derek Sollenberger | f5a370e | 2017-06-15 13:50:08 -0400 | [diff] [blame] | 30 | Layer* layer = mLayerUpdater->backingLayer(); |
| 31 | if (layer) { |
Stan Iliev | 1a025a7 | 2018-09-05 16:35:11 -0400 | [diff] [blame] | 32 | DrawLayer(canvas->getGrContext(), canvas, layer, nullptr, nullptr, true); |
Derek Sollenberger | f5a370e | 2017-06-15 13:50:08 -0400 | [diff] [blame] | 33 | } |
Derek Sollenberger | c4fbada | 2016-11-07 16:05:41 -0500 | [diff] [blame] | 34 | } |
| 35 | |
Stan Iliev | 694f3e4 | 2019-07-29 17:00:49 -0400 | [diff] [blame] | 36 | static inline SkScalar isIntegerAligned(SkScalar x) { |
| 37 | return fabsf(roundf(x) - x) <= NON_ZERO_EPSILON; |
| 38 | } |
| 39 | |
Stan Iliev | 134372d | 2019-07-10 16:46:09 -0400 | [diff] [blame] | 40 | // Disable filtering when there is no scaling in screen coordinates and the corners have the same |
| 41 | // fraction (for translate) or zero fraction (for any other rect-to-rect transform). |
| 42 | static bool shouldFilterRect(const SkMatrix& matrix, const SkRect& srcRect, const SkRect& dstRect) { |
| 43 | if (!matrix.rectStaysRect()) return true; |
| 44 | SkRect dstDevRect = matrix.mapRect(dstRect); |
| 45 | float dstW, dstH; |
| 46 | bool requiresIntegerTranslate = false; |
| 47 | if (MathUtils::isZero(matrix.getScaleX()) && MathUtils::isZero(matrix.getScaleY())) { |
| 48 | // Has a 90 or 270 degree rotation, although total matrix may also have scale factors |
| 49 | // in m10 and m01. Those scalings are automatically handled by mapRect so comparing |
| 50 | // dimensions is sufficient, but swap width and height comparison. |
| 51 | dstW = dstDevRect.height(); |
| 52 | dstH = dstDevRect.width(); |
| 53 | requiresIntegerTranslate = true; |
| 54 | } else { |
| 55 | // Handle H/V flips or 180 rotation matrices. Axes may have been mirrored, but |
| 56 | // dimensions are still safe to compare directly. |
| 57 | dstW = dstDevRect.width(); |
| 58 | dstH = dstDevRect.height(); |
| 59 | requiresIntegerTranslate = |
| 60 | matrix.getScaleX() < -NON_ZERO_EPSILON || matrix.getScaleY() < -NON_ZERO_EPSILON; |
| 61 | } |
| 62 | if (!(MathUtils::areEqual(dstW, srcRect.width()) && |
| 63 | MathUtils::areEqual(dstH, srcRect.height()))) { |
| 64 | return true; |
| 65 | } |
| 66 | if (requiresIntegerTranslate) { |
| 67 | // Device rect and source rect should be integer aligned to ensure there's no difference |
| 68 | // in how nearest-neighbor sampling is resolved. |
Stan Iliev | 694f3e4 | 2019-07-29 17:00:49 -0400 | [diff] [blame] | 69 | return !(isIntegerAligned(srcRect.x()) && |
| 70 | isIntegerAligned(srcRect.y()) && |
| 71 | isIntegerAligned(dstDevRect.x()) && |
| 72 | isIntegerAligned(dstDevRect.y())); |
Stan Iliev | 134372d | 2019-07-10 16:46:09 -0400 | [diff] [blame] | 73 | } else { |
| 74 | // As long as src and device rects are translated by the same fractional amount, |
| 75 | // filtering won't be needed |
| 76 | return !(MathUtils::areEqual(SkScalarFraction(srcRect.x()), |
| 77 | SkScalarFraction(dstDevRect.x())) && |
| 78 | MathUtils::areEqual(SkScalarFraction(srcRect.y()), |
| 79 | SkScalarFraction(dstDevRect.y()))); |
| 80 | } |
John Reck | 0aff62d | 2018-11-26 16:41:34 -0800 | [diff] [blame] | 81 | } |
| 82 | |
Leon Scroggins III | 1a12ab2 | 2018-03-26 15:00:49 -0400 | [diff] [blame] | 83 | bool LayerDrawable::DrawLayer(GrContext* context, SkCanvas* canvas, Layer* layer, |
Stan Iliev | 1a025a7 | 2018-09-05 16:35:11 -0400 | [diff] [blame] | 84 | const SkRect* srcRect, const SkRect* dstRect, |
| 85 | bool useLayerTransform) { |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 86 | if (context == nullptr) { |
| 87 | SkDEBUGF(("Attempting to draw LayerDrawable into an unsupported surface")); |
| 88 | return false; |
| 89 | } |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 90 | // transform the matrix based on the layer |
Stan Iliev | 564ca3e | 2018-09-04 22:00:00 +0000 | [diff] [blame] | 91 | SkMatrix layerTransform = layer->getTransform(); |
| 92 | sk_sp<SkImage> layerImage = layer->getImage(); |
Leon Scroggins III | 1a12ab2 | 2018-03-26 15:00:49 -0400 | [diff] [blame] | 93 | const int layerWidth = layer->getWidth(); |
| 94 | const int layerHeight = layer->getHeight(); |
Greg Daniel | 45ec62b | 2017-01-04 14:27:00 -0500 | [diff] [blame] | 95 | |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 96 | if (layerImage) { |
Leon Scroggins III | 1a12ab2 | 2018-03-26 15:00:49 -0400 | [diff] [blame] | 97 | SkMatrix textureMatrixInv; |
Stan Iliev | 564ca3e | 2018-09-04 22:00:00 +0000 | [diff] [blame] | 98 | textureMatrixInv = layer->getTexTransform(); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 99 | // TODO: after skia bug https://bugs.chromium.org/p/skia/issues/detail?id=7075 is fixed |
Stan Iliev | 944dbf2 | 2017-09-27 11:05:29 -0400 | [diff] [blame] | 100 | // use bottom left origin and remove flipV and invert transformations. |
| 101 | SkMatrix flipV; |
| 102 | flipV.setAll(1, 0, 0, 0, -1, 1, 0, 0, 1); |
Leon Scroggins III | 1a12ab2 | 2018-03-26 15:00:49 -0400 | [diff] [blame] | 103 | textureMatrixInv.preConcat(flipV); |
| 104 | textureMatrixInv.preScale(1.0f / layerWidth, 1.0f / layerHeight); |
Stan Iliev | 564ca3e | 2018-09-04 22:00:00 +0000 | [diff] [blame] | 105 | textureMatrixInv.postScale(layerImage->width(), layerImage->height()); |
Leon Scroggins III | 1a12ab2 | 2018-03-26 15:00:49 -0400 | [diff] [blame] | 106 | SkMatrix textureMatrix; |
| 107 | if (!textureMatrixInv.invert(&textureMatrix)) { |
| 108 | textureMatrix = textureMatrixInv; |
Stan Iliev | 944dbf2 | 2017-09-27 11:05:29 -0400 | [diff] [blame] | 109 | } |
| 110 | |
Stan Iliev | aac878f | 2018-07-12 16:53:59 -0400 | [diff] [blame] | 111 | SkMatrix matrix; |
Stan Iliev | 1a025a7 | 2018-09-05 16:35:11 -0400 | [diff] [blame] | 112 | if (useLayerTransform) { |
Stan Iliev | aac878f | 2018-07-12 16:53:59 -0400 | [diff] [blame] | 113 | matrix = SkMatrix::Concat(layerTransform, textureMatrix); |
Stan Iliev | 1a025a7 | 2018-09-05 16:35:11 -0400 | [diff] [blame] | 114 | } else { |
| 115 | matrix = textureMatrix; |
Stan Iliev | aac878f | 2018-07-12 16:53:59 -0400 | [diff] [blame] | 116 | } |
Stan Iliev | 944dbf2 | 2017-09-27 11:05:29 -0400 | [diff] [blame] | 117 | |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 118 | SkPaint paint; |
Derek Sollenberger | c4fbada | 2016-11-07 16:05:41 -0500 | [diff] [blame] | 119 | paint.setAlpha(layer->getAlpha()); |
| 120 | paint.setBlendMode(layer->getMode()); |
Derek Sollenberger | d01b591 | 2018-10-19 15:55:33 -0400 | [diff] [blame] | 121 | paint.setColorFilter(layer->getColorFilter()); |
Stan Iliev | a73b0be | 2017-10-06 10:16:58 -0400 | [diff] [blame] | 122 | const bool nonIdentityMatrix = !matrix.isIdentity(); |
| 123 | if (nonIdentityMatrix) { |
| 124 | canvas->save(); |
| 125 | canvas->concat(matrix); |
| 126 | } |
Stan Iliev | aa0a331 | 2018-10-19 15:26:08 -0400 | [diff] [blame] | 127 | const SkMatrix& totalMatrix = canvas->getTotalMatrix(); |
Stan Iliev | 1a025a7 | 2018-09-05 16:35:11 -0400 | [diff] [blame] | 128 | if (dstRect || srcRect) { |
Leon Scroggins III | 1a12ab2 | 2018-03-26 15:00:49 -0400 | [diff] [blame] | 129 | SkMatrix matrixInv; |
| 130 | if (!matrix.invert(&matrixInv)) { |
| 131 | matrixInv = matrix; |
| 132 | } |
Stan Iliev | 1a025a7 | 2018-09-05 16:35:11 -0400 | [diff] [blame] | 133 | SkRect skiaSrcRect; |
| 134 | if (srcRect) { |
| 135 | skiaSrcRect = *srcRect; |
| 136 | } else { |
| 137 | skiaSrcRect = SkRect::MakeIWH(layerWidth, layerHeight); |
| 138 | } |
| 139 | matrixInv.mapRect(&skiaSrcRect); |
| 140 | SkRect skiaDestRect; |
| 141 | if (dstRect) { |
| 142 | skiaDestRect = *dstRect; |
| 143 | } else { |
| 144 | skiaDestRect = SkRect::MakeIWH(layerWidth, layerHeight); |
| 145 | } |
Leon Scroggins III | 1a12ab2 | 2018-03-26 15:00:49 -0400 | [diff] [blame] | 146 | matrixInv.mapRect(&skiaDestRect); |
Stan Iliev | 134372d | 2019-07-10 16:46:09 -0400 | [diff] [blame] | 147 | // If (matrix is a rect-to-rect transform) |
| 148 | // and (src/dst buffers size match in screen coordinates) |
| 149 | // and (src/dst corners align fractionally), |
Stan Iliev | aa0a331 | 2018-10-19 15:26:08 -0400 | [diff] [blame] | 150 | // then use nearest neighbor, otherwise use bilerp sampling. |
Stan Iliev | aa0a331 | 2018-10-19 15:26:08 -0400 | [diff] [blame] | 151 | // Skia TextureOp has the above logic build-in, but not NonAAFillRectOp. TextureOp works |
| 152 | // only for SrcOver blending and without color filter (readback uses Src blending). |
Stan Iliev | 134372d | 2019-07-10 16:46:09 -0400 | [diff] [blame] | 153 | if (layer->getForceFilter() || |
| 154 | shouldFilterRect(totalMatrix, skiaSrcRect, skiaDestRect)) { |
Stan Iliev | aa0a331 | 2018-10-19 15:26:08 -0400 | [diff] [blame] | 155 | paint.setFilterQuality(kLow_SkFilterQuality); |
| 156 | } |
Stan Iliev | 1a025a7 | 2018-09-05 16:35:11 -0400 | [diff] [blame] | 157 | canvas->drawImageRect(layerImage.get(), skiaSrcRect, skiaDestRect, &paint, |
Leon Scroggins III | 1a12ab2 | 2018-03-26 15:00:49 -0400 | [diff] [blame] | 158 | SkCanvas::kFast_SrcRectConstraint); |
| 159 | } else { |
Stan Iliev | 134372d | 2019-07-10 16:46:09 -0400 | [diff] [blame] | 160 | SkRect imageRect = SkRect::MakeIWH(layerImage->width(), layerImage->height()); |
| 161 | if (layer->getForceFilter() || shouldFilterRect(totalMatrix, imageRect, imageRect)) { |
Stan Iliev | aa0a331 | 2018-10-19 15:26:08 -0400 | [diff] [blame] | 162 | paint.setFilterQuality(kLow_SkFilterQuality); |
| 163 | } |
Leon Scroggins III | 1a12ab2 | 2018-03-26 15:00:49 -0400 | [diff] [blame] | 164 | canvas->drawImage(layerImage.get(), 0, 0, &paint); |
| 165 | } |
Stan Iliev | a73b0be | 2017-10-06 10:16:58 -0400 | [diff] [blame] | 166 | // restore the original matrix |
| 167 | if (nonIdentityMatrix) { |
| 168 | canvas->restore(); |
| 169 | } |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 170 | } |
Derek Sollenberger | c4fbada | 2016-11-07 16:05:41 -0500 | [diff] [blame] | 171 | |
Ben Wagner | 6b62ac0 | 2018-05-29 14:16:02 -0400 | [diff] [blame] | 172 | return layerImage != nullptr; |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 173 | } |
| 174 | |
Chris Blume | 7b8a808 | 2018-11-30 15:51:58 -0800 | [diff] [blame] | 175 | } // namespace skiapipeline |
| 176 | } // namespace uirenderer |
| 177 | } // namespace android |