1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
/*
* Copyright (C) 2021 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include "Properties.h"
#include "utils/MathUtils.h"
#include <SkImage.h>
#include <SkImageFilter.h>
#include <SkMatrix.h>
#include <SkPoint.h>
#include <SkRect.h>
#include <SkRuntimeEffect.h>
namespace android::uirenderer {
class StretchEffect {
public:
StretchEffect(const SkVector& direction,
float maxStretchAmountX,
float maxStretchAmountY)
: maxStretchAmountX(maxStretchAmountX)
, maxStretchAmountY(maxStretchAmountY)
, mStretchDirection(direction) { }
StretchEffect() {}
bool isEmpty() const { return isZero(mStretchDirection.x()) && isZero(mStretchDirection.y()); }
void setEmpty() {
*this = StretchEffect{};
}
StretchEffect& operator=(const StretchEffect& other) {
this->mStretchDirection = other.mStretchDirection;
this->maxStretchAmountX = other.maxStretchAmountX;
this->maxStretchAmountY = other.maxStretchAmountY;
return *this;
}
bool operator==(const StretchEffect& other) const {
return mStretchDirection == other.mStretchDirection &&
maxStretchAmountX == other.maxStretchAmountX &&
maxStretchAmountY == other.maxStretchAmountY;
}
void mergeWith(const StretchEffect& other) {
if (other.isEmpty()) {
return;
}
if (isEmpty()) {
*this = other;
return;
}
mStretchDirection += other.mStretchDirection;
if (isEmpty()) {
return setEmpty();
}
maxStretchAmountX = std::max(maxStretchAmountX, other.maxStretchAmountX);
maxStretchAmountY = std::max(maxStretchAmountY, other.maxStretchAmountY);
}
/**
* Return the stretched x position given the normalized x position with
* the current horizontal stretch direction
* @param normalizedX x position on the input texture from 0 to 1
* @return x position when the horizontal stretch direction applied
*/
float computeStretchedPositionX(float normalizedX) const;
/**
* Return the stretched y position given the normalized y position with
* the current horizontal stretch direction
* @param normalizedX y position on the input texture from 0 to 1
* @return y position when the horizontal stretch direction applied
*/
float computeStretchedPositionY(float normalizedY) const;
sk_sp<SkShader> getShader(float width, float height, const sk_sp<SkImage>& snapshotImage,
const SkMatrix* matrix) const;
float maxStretchAmountX = 0;
float maxStretchAmountY = 0;
const SkVector getStretchDirection() const { return mStretchDirection; }
SkMatrix makeLinearStretch(float width, float height) const {
SkMatrix matrix;
auto [sX, sY] = getStretchDirection();
matrix.setScale(1 + std::abs(sX), 1 + std::abs(sY), sX > 0 ? 0 : width,
sY > 0 ? 0 : height);
return matrix;
}
bool requiresLayer() const {
return !isEmpty();
}
void clear() {
mBuilder = nullptr;
}
private:
// The epsilon for StretchEffect is less than in MathUtils because
// the range is 0-1 for an entire screen and should be significantly
// less than 1 pixel for a smooth stretch animation.
inline static bool isZero(float value) {
// Using fabsf is more performant as ARM computes
// fabsf in a single instruction.
return fabsf(value) <= NON_ZERO_EPSILON;
}
// This should be good for 1/25,000 of a screen and should be good for
// screens with less than ~8000 pixels in one dimension with only 1/4 pixel
// cut-off.
static constexpr float NON_ZERO_EPSILON = 0.00004f;
static sk_sp<SkRuntimeEffect> getStretchEffect();
mutable SkVector mStretchDirection{0, 0};
mutable std::unique_ptr<SkRuntimeShaderBuilder> mBuilder;
};
} // namespace android::uirenderer
|
