Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 80116e5d authored by Galia Peycheva's avatar Galia Peycheva
Browse files

Unify drawing for background blur and blur regions 

Bug: 171681577
Test: manual

Change-Id: I21f00c706ffd085a6dcc8275c8b1b9f1b0ef7379
parent 69df21f1

libs/renderengine/skia/SkiaGLRenderEngine.cpp

+30 −12
Original line number Diff line number Diff line
@@ -547,9 +547,11 @@ status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display, 
            const auto layerRect = drawTransform.mapRect(dest);

            if (layer->backgroundBlurRadius > 0) {

                ATRACE_NAME("BackgroundBlur");

                auto blurredSurface =

                        mBlurFilter->draw(canvas, surface, layer->backgroundBlurRadius, layerRect);

                auto blurredSurface = mBlurFilter->generate(canvas, surface,

                                                            layer->backgroundBlurRadius, layerRect);

                cachedBlurs[layer->backgroundBlurRadius] = blurredSurface;



                drawBlurRegion(canvas, getBlurRegion(layer), drawTransform, blurredSurface);

            }

            if (layer->blurRegions.size() > 0) {

                for (auto region : layer->blurRegions) {
@@ -663,13 +665,13 @@ status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display, 


        paint.setColorFilter(SkColorFilters::Matrix(toSkColorMatrix(display.colorTransform)));



        canvas->save();

        canvas->concat(drawTransform);



        for (const auto effectRegion : layer->blurRegions) {

            drawBlurRegion(canvas, effectRegion, dest, cachedBlurs[effectRegion.blurRadius]);

            drawBlurRegion(canvas, effectRegion, drawTransform,

                           cachedBlurs[effectRegion.blurRadius]);

        }



        canvas->save();

        canvas->concat(drawTransform);

        if (layer->shadow.length > 0) {

            const auto rect = layer->geometry.roundedCornersRadius > 0

                    ? getSkRect(layer->geometry.roundedCornersCrop)
@@ -730,6 +732,21 @@ inline SkRRect SkiaGLRenderEngine::getRoundedRect(const LayerSettings* layer) { 
    return SkRRect::MakeRectXY(rect, cornerRadius, cornerRadius);

}



inline BlurRegion SkiaGLRenderEngine::getBlurRegion(const LayerSettings* layer) {

    const auto rect = getSkRect(layer->geometry.boundaries);

    const auto cornersRadius = layer->geometry.roundedCornersRadius;

    return BlurRegion{.blurRadius = static_cast<uint32_t>(layer->backgroundBlurRadius),

                      .cornerRadiusTL = cornersRadius,

                      .cornerRadiusTR = cornersRadius,

                      .cornerRadiusBL = cornersRadius,

                      .cornerRadiusBR = cornersRadius,

                      .alpha = 1,

                      .left = static_cast<int>(rect.fLeft),

                      .top = static_cast<int>(rect.fTop),

                      .right = static_cast<int>(rect.fRight),

                      .bottom = static_cast<int>(rect.fBottom)};

}



inline SkColor SkiaGLRenderEngine::getSkColor(const vec4& color) {

    return SkColorSetARGB(color.a * 255, color.r * 255, color.g * 255, color.b * 255);

}
@@ -777,18 +794,19 @@ void SkiaGLRenderEngine::drawShadow(SkCanvas* canvas, const SkRect& casterRect, 
}



void SkiaGLRenderEngine::drawBlurRegion(SkCanvas* canvas, const BlurRegion& effectRegion,

                                        const SkRect& layerBoundaries,

                                        const SkMatrix& drawTransform,

                                        sk_sp<SkSurface> blurredSurface) {

    ATRACE_CALL();



    SkPaint paint;

    paint.setAlpha(static_cast<int>(effectRegion.alpha * 255));

    const auto rect = SkRect::MakeLTRB(effectRegion.left, effectRegion.top, effectRegion.right,

                                       effectRegion.bottom);



    const auto matrix = mBlurFilter->getShaderMatrix(

            SkMatrix::MakeTrans(layerBoundaries.left(), layerBoundaries.top()));

    const auto matrix = mBlurFilter->getShaderMatrix();

    paint.setShader(blurredSurface->makeImageSnapshot()->makeShader(matrix));



    auto rect = SkRect::MakeLTRB(effectRegion.left, effectRegion.top, effectRegion.right,

                                 effectRegion.bottom);

    drawTransform.mapRect(&rect);



    if (effectRegion.cornerRadiusTL > 0 || effectRegion.cornerRadiusTR > 0 ||

        effectRegion.cornerRadiusBL > 0 || effectRegion.cornerRadiusBR > 0) {

        const SkVector radii[4] =

libs/renderengine/skia/SkiaGLRenderEngine.h

+3 −2
Original line number Diff line number Diff line
@@ -67,6 +67,7 @@ private: 
    inline SkRect getSkRect(const FloatRect& layer);

    inline SkRect getSkRect(const Rect& layer);

    inline SkRRect getRoundedRect(const LayerSettings* layer);

    inline BlurRegion getBlurRegion(const LayerSettings* layer);

    inline SkColor getSkColor(const vec4& color);

    inline SkM44 getSkM44(const mat4& matrix);

    inline SkMatrix getDrawTransform(const LayerSettings* layer, const SkMatrix& screenTransform);
@@ -76,8 +77,8 @@ private: 
    bool waitFence(base::unique_fd fenceFd);

    void drawShadow(SkCanvas* canvas, const SkRect& casterRect, float casterCornerRadius,

                    const ShadowSettings& shadowSettings);

    void drawBlurRegion(SkCanvas* canvas, const BlurRegion& blurRegion, const SkRect& layerBounds,

                        sk_sp<SkSurface> blurrendSurface);

    void drawBlurRegion(SkCanvas* canvas, const BlurRegion& blurRegion,

                        const SkMatrix& drawTransform, sk_sp<SkSurface> blurrendSurface);



    EGLDisplay mEGLDisplay;

    EGLConfig mEGLConfig;

libs/renderengine/skia/filters/BlurFilter.cpp

+2 −20
Original line number Diff line number Diff line
@@ -130,26 +130,8 @@ sk_sp<SkSurface> BlurFilter::generate(SkCanvas* canvas, const sk_sp<SkSurface> i 
    return lastDrawTarget;

}



sk_sp<SkSurface> BlurFilter::draw(SkCanvas* canvas, const sk_sp<SkSurface> input,

                                  const uint32_t blurRadius, SkRect rect) const {

    ATRACE_CALL();

    sk_sp<SkSurface> surface = generate(canvas, input, blurRadius, rect);

    const auto image = surface->makeImageSnapshot();



    SkPaint paint;

    paint.setShader(image->makeShader(SkMatrix::MakeScale(kInverseInputScale)));

    paint.setFilterQuality(kLow_SkFilterQuality);

    paint.setAlpha(std::min(1.0f, (float)blurRadius / kMaxCrossFadeRadius) * 255);



    canvas->drawRect(rect, paint);



    return surface;

}



SkMatrix BlurFilter::getShaderMatrix(const SkMatrix& transformMatrix) const {

    SkMatrix matrix;

    matrix.setConcat(transformMatrix, SkMatrix::MakeScale(kInverseInputScale));

    return matrix;

SkMatrix BlurFilter::getShaderMatrix() const {

    return SkMatrix::MakeScale(kInverseInputScale);

}



} // namespace skia

libs/renderengine/skia/filters/BlurFilter.h

+1 −4
Original line number Diff line number Diff line
@@ -50,11 +50,8 @@ public: 
    // Execute blur, saving it to a texture

    sk_sp<SkSurface> generate(SkCanvas* canvas, const sk_sp<SkSurface> input, const uint32_t radius,

                              SkRect rect) const;

    // Same as generate but also drawing to the screen

    sk_sp<SkSurface> draw(SkCanvas* canvas, const sk_sp<SkSurface> input, const uint32_t radius,

                          SkRect rect) const;

    // Returns a matrix that should be applied to the blur shader

    SkMatrix getShaderMatrix(const SkMatrix& transformMatrix) const;

    SkMatrix getShaderMatrix() const;



private:

    sk_sp<SkRuntimeEffect> mBlurEffect;