Merge "Crop shadows by parent layer crop" into main

Author: cairno-google

libs/renderengine/include/renderengine/LayerSettings.h

@@ -93,6 +93,10 @@ struct Geometry {
 
     // Rectangle within which corners will be rounded.
     FloatRect roundedCornersCrop = FloatRect();
+
+    // Crop geometry in local space, used for cropping outset rendering, e.g. shadows.
+    vec2 otherRoundedCornersRadius = vec2(0.0f, 0.0f);
+    FloatRect otherCrop = FloatRect();
 };
 
 // Descriptor of the source pixels for this layer.
@@ -228,6 +232,12 @@ static inline void PrintTo(const Geometry& settings, ::std::ostream* os) {
     *os << "\n    .roundedCornersRadiusY = " << settings.roundedCornersRadius.y;
     *os << "\n    .roundedCornersCrop = ";
     PrintTo(settings.roundedCornersCrop, os);
+
+    *os << "\n    .otherRoundedCornersRadiusX = " << settings.otherRoundedCornersRadius.x;
+    *os << "\n    .otherRoundedCornersRadiusY = " << settings.otherRoundedCornersRadius.y;
+    *os << "\n    .otherCrop = ";
+    PrintTo(settings.otherCrop, os);
+
     *os << "\n}";
 }
 

libs/renderengine/skia/SkiaRenderEngine.cpp

@@ -887,6 +887,7 @@ void SkiaRenderEngine::drawLayersInternal(
         const auto [bounds, roundRectClip] =
                 getBoundsAndClip(layer.geometry.boundaries, layer.geometry.roundedCornersCrop,
                                  layer.geometry.roundedCornersRadius);
+
         if (mBlurFilter && layerHasBlur(layer, ctModifiesAlpha)) {
             std::unordered_map<uint32_t, sk_sp<SkImage>> cachedBlurs;
 
@@ -963,66 +964,82 @@ void SkiaRenderEngine::drawLayersInternal(
             }
         }
 
-        if (layer.shadow.length > 0) {
-            // This would require a new parameter/flag to SkShadowUtils::DrawShadow
-            LOG_ALWAYS_FATAL_IF(layer.disableBlending, "Cannot disableBlending with a shadow");
-
-            SkRRect shadowBounds, shadowClip;
-            if (layer.geometry.boundaries == layer.shadow.boundaries) {
-                shadowBounds = bounds;
-                shadowClip = roundRectClip;
-            } else {
-                std::tie(shadowBounds, shadowClip) =
-                        getBoundsAndClip(layer.shadow.boundaries, layer.geometry.roundedCornersCrop,
-                                         layer.geometry.roundedCornersRadius);
+        {
+            SkRRect otherCrop;
+            otherCrop.setRectXY(getSkRect(layer.geometry.otherCrop),
+                                layer.geometry.otherRoundedCornersRadius.x,
+                                layer.geometry.otherRoundedCornersRadius.y);
+            // Outset rendering needs to be clipped by parent.
+            SkAutoCanvasRestore acr(canvas, true);
+            if (!otherCrop.isEmpty()) {
+                canvas->clipRRect(otherCrop, true);
             }
 
-            // Technically, if bounds is a rect and roundRectClip is not empty,
-            // it means that the bounds and roundedCornersCrop were different
-            // enough that we should intersect them to find the proper shadow.
-            // In practice, this often happens when the two rectangles appear to
-            // not match due to rounding errors. Draw the rounded version, which
-            // looks more like the intent.
-            const auto& rrect =
-                    shadowBounds.isRect() && !shadowClip.isEmpty() ? shadowClip : shadowBounds;
-            drawShadow(canvas, rrect, layer.shadow);
-        }
+            if (layer.shadow.length > 0) {
+                // This would require a new parameter/flag to SkShadowUtils::DrawShadow
+                LOG_ALWAYS_FATAL_IF(layer.disableBlending, "Cannot disableBlending with a shadow");
+
+                SkRRect shadowBounds, shadowClip;
+                if (layer.geometry.boundaries == layer.shadow.boundaries) {
+                    shadowBounds = bounds;
+                    shadowClip = roundRectClip;
+                } else {
+                    std::tie(shadowBounds, shadowClip) =
+                            getBoundsAndClip(layer.shadow.boundaries,
+                                             layer.geometry.roundedCornersCrop,
+                                             layer.geometry.roundedCornersRadius);
+                }
 
-        // TODO(b/367464660): Move this code above and
-        // update elevation shadow rendering to use these bounds since they should be
-        // identical.
-        SkRRect originalBounds, originalClip;
-        std::tie(originalBounds, originalClip) =
-                getBoundsAndClip(layer.geometry.originalBounds, layer.geometry.roundedCornersCrop,
-                                 layer.geometry.roundedCornersRadius);
-        const SkRRect& preferredOriginalBounds =
-                originalBounds.isRect() && !originalClip.isEmpty() ? originalClip : originalBounds;
+                // Technically, if bounds is a rect and roundRectClip is not empty,
+                // it means that the bounds and roundedCornersCrop were different
+                // enough that we should intersect them to find the proper shadow.
+                // In practice, this often happens when the two rectangles appear to
+                // not match due to rounding errors. Draw the rounded version, which
+                // looks more like the intent.
+                const auto& rrect =
+                        shadowBounds.isRect() && !shadowClip.isEmpty() ? shadowClip : shadowBounds;
+                drawShadow(canvas, rrect, layer.shadow);
+            }
 
-        // Similar to shadows, do the rendering before the clip is applied because even when the
-        // layer is occluded it should have an outline.
-        if (layer.borderSettings.strokeWidth > 0) {
-            SkRRect outlineRect = preferredOriginalBounds;
-            outlineRect.outset(layer.borderSettings.strokeWidth, layer.borderSettings.strokeWidth);
+            // TODO(b/367464660): Move this code above and
+            // update elevation shadow rendering to use these bounds since they should be
+            // identical.
+            SkRRect originalBounds, originalClip;
+            std::tie(originalBounds, originalClip) =
+                    getBoundsAndClip(layer.geometry.originalBounds,
+                                     layer.geometry.roundedCornersCrop,
+                                     layer.geometry.roundedCornersRadius);
+            const SkRRect& preferredOriginalBounds =
+                    originalBounds.isRect() && !originalClip.isEmpty() ? originalClip
+                                                                       : originalBounds;
+
+            // Similar to shadows, do the rendering before the clip is applied because even when the
+            // layer is occluded it should have an outline.
+            if (layer.borderSettings.strokeWidth > 0) {
+                SkRRect outlineRect = preferredOriginalBounds;
+                outlineRect.outset(layer.borderSettings.strokeWidth,
+                                   layer.borderSettings.strokeWidth);
 
-            SkPaint paint;
-            paint.setAntiAlias(true);
-            paint.setColor(layer.borderSettings.color);
-            paint.setStyle(SkPaint::kFill_Style);
-            canvas->drawDRRect(outlineRect, preferredOriginalBounds, paint);
-        }
+                SkPaint paint;
+                paint.setAntiAlias(true);
+                paint.setColor(layer.borderSettings.color);
+                paint.setStyle(SkPaint::kFill_Style);
+                canvas->drawDRRect(outlineRect, preferredOriginalBounds, paint);
+            }
 
-        if (!layer.boxShadowSettings.boxShadows.empty()) {
-            for (const gui::BoxShadowSettings::BoxShadowParams& box :
-                 layer.boxShadowSettings.boxShadows) {
-                SkRRect boxRect = preferredOriginalBounds;
-                boxRect.outset(box.spreadRadius, box.spreadRadius);
-                boxRect.offset(box.offsetX, box.offsetY);
-                float sigma = convertBlurUserRadiusToSigma(box.blurRadius);
-                SkPaint blur;
-                blur.setAntiAlias(true);
-                blur.setColor(box.color);
-                blur.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma, false));
-                canvas->drawRRect(boxRect, blur);
+            if (!layer.boxShadowSettings.boxShadows.empty()) {
+                for (const gui::BoxShadowSettings::BoxShadowParams& box :
+                     layer.boxShadowSettings.boxShadows) {
+                    SkRRect boxRect = preferredOriginalBounds;
+                    boxRect.outset(box.spreadRadius, box.spreadRadius);
+                    boxRect.offset(box.offsetX, box.offsetY);
+                    float sigma = convertBlurUserRadiusToSigma(box.blurRadius);
+                    SkPaint blur;
+                    blur.setAntiAlias(true);
+                    blur.setColor(box.color);
+                    blur.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma, false));
+                    canvas->drawRRect(boxRect, blur);
+                }
             }
         }
 

services/surfaceflinger/FrontEnd/LayerSnapshot.h

@@ -76,6 +76,11 @@ struct LayerSnapshot : public compositionengine::LayerFECompositionState {
     bool contentOpaque;
     bool layerOpaqueFlagSet;
     RoundedCornerState roundedCorner;
+    // roundedCorner of the parent but in local space.
+    RoundedCornerState parentRoundedCorner;
+    // geomLayerCrop of the parent but in local space.
+    FloatRect parentGeomLayerCrop;
+
     FloatRect transformedBounds;
     Rect transformedBoundsWithoutTransparentRegion;
     bool premultipliedAlpha;

services/surfaceflinger/FrontEnd/LayerSnapshotBuilder.cpp

@@ -1048,6 +1048,8 @@ void LayerSnapshotBuilder::updateRoundedCorner(LayerSnapshot& snapshot,
     } else {
         snapshot.roundedCorner.radius = snapshot.roundedCorner.requestedRadius;
     }
+
+    snapshot.parentRoundedCorner = parentRoundedCorner;
 }
 
 /**
@@ -1134,6 +1136,9 @@ void LayerSnapshotBuilder::updateLayerBounds(LayerSnapshot& snapshot,
                                                         requested.getTransparentRegion());
         snapshot.cursorFrame = snapshot.geomLayerTransform.transform(bounds);
     }
+
+    snapshot.parentGeomLayerCrop =
+            snapshot.localTransform.inverse().transform(parentSnapshot.geomLayerCrop);
 }
 
 void LayerSnapshotBuilder::updateShadows(LayerSnapshot& snapshot, const RequestedLayerState&,

services/surfaceflinger/LayerFE.cpp

@@ -124,6 +124,14 @@ std::optional<compositionengine::LayerFE::LayerSettings> LayerFE::prepareClientC
     SFTRACE_CALL();
     compositionengine::LayerFE::LayerSettings layerSettings;
     layerSettings.geometry.originalBounds = mSnapshot->geomLayerBounds;
+
+    if (mSnapshot->parentRoundedCorner.hasRequestedRadius()) {
+        layerSettings.geometry.otherRoundedCornersRadius = mSnapshot->parentRoundedCorner.radius;
+        layerSettings.geometry.otherCrop = mSnapshot->parentRoundedCorner.cropRect;
+    } else {
+        layerSettings.geometry.otherCrop = mSnapshot->parentGeomLayerCrop;
+    }
+
     layerSettings.geometry.boundaries =
             reduce(mSnapshot->geomLayerBounds, mSnapshot->transparentRegionHint);
     layerSettings.geometry.positionTransform = mSnapshot->geomLayerTransform.asMatrix4();

services/surfaceflinger/tests/LayerTypeAndRenderTypeTransaction_test.cpp

@@ -868,6 +868,38 @@ TEST_P(LayerTypeAndRenderTypeTransactionTest, SetBoxShadowSettings) {
     }
 }
 
+TEST_P(LayerTypeAndRenderTypeTransactionTest, CropElevationShadowByParent) {
+    sp<SurfaceControl> parent;
+    sp<SurfaceControl> child;
+    const uint32_t size = 64;
+    const uint32_t parentSize = size * 3;
+    ASSERT_NO_FATAL_FAILURE(parent = createLayer("parent", parentSize, parentSize));
+    ASSERT_NO_FATAL_FAILURE(fillLayerColor(parent, Color::WHITE, parentSize, parentSize));
+    ASSERT_NO_FATAL_FAILURE(child = createLayer("child", size, size));
+    ASSERT_NO_FATAL_FAILURE(fillLayerColor(child, Color::GREEN, size, size));
+
+    // TODO(b/377194534): This test fails on Tangor because global shadow
+    // settings seem to not respect rotation.
+    SurfaceComposerClient::getDefault()->setGlobalShadowSettings({1, 0, 0, 0.5f}, {0, 1, 0, 0.5f},
+                                                                 0, 500.0f, 800.0f);
+
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    Transaction()
+            .setCrop(parent, Rect(0, 0, parentSize / 2, parentSize))
+            .reparent(child, parent)
+            .setCrop(child, Rect(0, 0, size, size))
+            .setPosition(child, size, size)
+            .setCornerRadius(child, 20.0f)
+            .setShadowRadius(child, 20.0f)
+            .apply(true);
+
+    auto shot = getScreenCapture();
+
+    shot->expectBufferMatchesImageFromFile(Rect(0, 0, parentSize, parentSize),
+                                           "testdata/CropElevationShadowByParent.png");
+}
+
 TEST_P(LayerTypeAndRenderTypeTransactionTest, SetBackgroundBlurRadiusSimple) {
     if (!deviceSupportsBlurs()) GTEST_SKIP();
     if (!deviceUsesSkiaRenderEngine()) GTEST_SKIP();