1 /*
2 * Copyright (C) 2010 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 "Patch.h"
18
19 #include "Caches.h"
20 #include "Properties.h"
21 #include "UvMapper.h"
22 #include "utils/MathUtils.h"
23
24 #include <algorithm>
25 #include <utils/Log.h>
26
27 namespace android {
28 namespace uirenderer {
29
30 ///////////////////////////////////////////////////////////////////////////////
31 // Vertices management
32 ///////////////////////////////////////////////////////////////////////////////
33
getSize() const34 uint32_t Patch::getSize() const {
35 return verticesCount * sizeof(TextureVertex);
36 }
37
Patch(const float bitmapWidth,const float bitmapHeight,float width,float height,const UvMapper & mapper,const Res_png_9patch * patch)38 Patch::Patch(const float bitmapWidth, const float bitmapHeight,
39 float width, float height, const UvMapper& mapper, const Res_png_9patch* patch)
40 : mColors(patch->getColors()) {
41
42 int8_t emptyQuads = 0;
43 const int8_t numColors = patch->numColors;
44 if (uint8_t(numColors) < sizeof(uint32_t) * 4) {
45 for (int8_t i = 0; i < numColors; i++) {
46 if (mColors[i] == 0x0) {
47 emptyQuads++;
48 }
49 }
50 }
51
52 hasEmptyQuads = emptyQuads > 0;
53
54 uint32_t xCount = patch->numXDivs;
55 uint32_t yCount = patch->numYDivs;
56
57 uint32_t maxVertices = ((xCount + 1) * (yCount + 1) - emptyQuads) * 4;
58 if (maxVertices == 0) return;
59
60 vertices.reset(new TextureVertex[maxVertices]);
61 TextureVertex* vertex = vertices.get();
62
63 const int32_t* xDivs = patch->getXDivs();
64 const int32_t* yDivs = patch->getYDivs();
65
66 const uint32_t xStretchCount = (xCount + 1) >> 1;
67 const uint32_t yStretchCount = (yCount + 1) >> 1;
68
69 float stretchX = 0.0f;
70 float stretchY = 0.0f;
71
72 float rescaleX = 1.0f;
73 float rescaleY = 1.0f;
74
75 if (xStretchCount > 0) {
76 uint32_t stretchSize = 0;
77 for (uint32_t i = 1; i < xCount; i += 2) {
78 stretchSize += xDivs[i] - xDivs[i - 1];
79 }
80 const float xStretchTex = stretchSize;
81 const float fixed = bitmapWidth - stretchSize;
82 const float xStretch = std::max(width - fixed, 0.0f);
83 stretchX = xStretch / xStretchTex;
84 rescaleX = fixed == 0.0f ? 0.0f : std::min(std::max(width, 0.0f) / fixed, 1.0f);
85 }
86
87 if (yStretchCount > 0) {
88 uint32_t stretchSize = 0;
89 for (uint32_t i = 1; i < yCount; i += 2) {
90 stretchSize += yDivs[i] - yDivs[i - 1];
91 }
92 const float yStretchTex = stretchSize;
93 const float fixed = bitmapHeight - stretchSize;
94 const float yStretch = std::max(height - fixed, 0.0f);
95 stretchY = yStretch / yStretchTex;
96 rescaleY = fixed == 0.0f ? 0.0f : std::min(std::max(height, 0.0f) / fixed, 1.0f);
97 }
98
99 uint32_t quadCount = 0;
100
101 float previousStepY = 0.0f;
102
103 float y1 = 0.0f;
104 float y2 = 0.0f;
105 float v1 = 0.0f;
106
107 mUvMapper = mapper;
108
109 for (uint32_t i = 0; i < yCount; i++) {
110 float stepY = yDivs[i];
111 const float segment = stepY - previousStepY;
112
113 if (i & 1) {
114 y2 = y1 + floorf(segment * stretchY + 0.5f);
115 } else {
116 y2 = y1 + segment * rescaleY;
117 }
118
119 float vOffset = y1 == y2 ? 0.0f : 0.5 - (0.5 * segment / (y2 - y1));
120 float v2 = std::max(0.0f, stepY - vOffset) / bitmapHeight;
121 v1 += vOffset / bitmapHeight;
122
123 if (stepY > 0.0f) {
124 generateRow(xDivs, xCount, vertex, y1, y2, v1, v2, stretchX, rescaleX,
125 width, bitmapWidth, quadCount);
126 }
127
128 y1 = y2;
129 v1 = stepY / bitmapHeight;
130
131 previousStepY = stepY;
132 }
133
134 if (previousStepY != bitmapHeight) {
135 y2 = height;
136 generateRow(xDivs, xCount, vertex, y1, y2, v1, 1.0f, stretchX, rescaleX,
137 width, bitmapWidth, quadCount);
138 }
139
140 if (verticesCount != maxVertices) {
141 std::unique_ptr<TextureVertex[]> reducedVertices(new TextureVertex[verticesCount]);
142 memcpy(reducedVertices.get(), vertices.get(), verticesCount * sizeof(TextureVertex));
143 vertices = std::move(reducedVertices);
144 }
145 }
146
generateRow(const int32_t * xDivs,uint32_t xCount,TextureVertex * & vertex,float y1,float y2,float v1,float v2,float stretchX,float rescaleX,float width,float bitmapWidth,uint32_t & quadCount)147 void Patch::generateRow(const int32_t* xDivs, uint32_t xCount, TextureVertex*& vertex,
148 float y1, float y2, float v1, float v2, float stretchX, float rescaleX,
149 float width, float bitmapWidth, uint32_t& quadCount) {
150 float previousStepX = 0.0f;
151
152 float x1 = 0.0f;
153 float x2 = 0.0f;
154 float u1 = 0.0f;
155
156 // Generate the row quad by quad
157 for (uint32_t i = 0; i < xCount; i++) {
158 float stepX = xDivs[i];
159 const float segment = stepX - previousStepX;
160
161 if (i & 1) {
162 x2 = x1 + floorf(segment * stretchX + 0.5f);
163 } else {
164 x2 = x1 + segment * rescaleX;
165 }
166
167 float uOffset = x1 == x2 ? 0.0f : 0.5 - (0.5 * segment / (x2 - x1));
168 float u2 = std::max(0.0f, stepX - uOffset) / bitmapWidth;
169 u1 += uOffset / bitmapWidth;
170
171 if (stepX > 0.0f) {
172 generateQuad(vertex, x1, y1, x2, y2, u1, v1, u2, v2, quadCount);
173 }
174
175 x1 = x2;
176 u1 = stepX / bitmapWidth;
177
178 previousStepX = stepX;
179 }
180
181 if (previousStepX != bitmapWidth) {
182 x2 = width;
183 generateQuad(vertex, x1, y1, x2, y2, u1, v1, 1.0f, v2, quadCount);
184 }
185 }
186
generateQuad(TextureVertex * & vertex,float x1,float y1,float x2,float y2,float u1,float v1,float u2,float v2,uint32_t & quadCount)187 void Patch::generateQuad(TextureVertex*& vertex, float x1, float y1, float x2, float y2,
188 float u1, float v1, float u2, float v2, uint32_t& quadCount) {
189 const uint32_t oldQuadCount = quadCount;
190 quadCount++;
191
192 x1 = std::max(x1, 0.0f);
193 x2 = std::max(x2, 0.0f);
194 y1 = std::max(y1, 0.0f);
195 y2 = std::max(y2, 0.0f);
196
197 // Skip degenerate and transparent (empty) quads
198 if ((mColors[oldQuadCount] == 0) || x1 >= x2 || y1 >= y2) {
199 #if DEBUG_PATCHES_EMPTY_VERTICES
200 PATCH_LOGD(" quad %d (empty)", oldQuadCount);
201 PATCH_LOGD(" left, top = %.2f, %.2f\t\tu1, v1 = %.8f, %.8f", x1, y1, u1, v1);
202 PATCH_LOGD(" right, bottom = %.2f, %.2f\t\tu2, v2 = %.8f, %.8f", x2, y2, u2, v2);
203 #endif
204 return;
205 }
206
207 // Record all non empty quads
208 if (hasEmptyQuads) {
209 quads.emplace_back(x1, y1, x2, y2);
210 }
211
212 mUvMapper.map(u1, v1, u2, v2);
213
214 TextureVertex::set(vertex++, x1, y1, u1, v1);
215 TextureVertex::set(vertex++, x2, y1, u2, v1);
216 TextureVertex::set(vertex++, x1, y2, u1, v2);
217 TextureVertex::set(vertex++, x2, y2, u2, v2);
218
219 verticesCount += 4;
220 indexCount += 6;
221
222 #if DEBUG_PATCHES_VERTICES
223 PATCH_LOGD(" quad %d", oldQuadCount);
224 PATCH_LOGD(" left, top = %.2f, %.2f\t\tu1, v1 = %.8f, %.8f", x1, y1, u1, v1);
225 PATCH_LOGD(" right, bottom = %.2f, %.2f\t\tu2, v2 = %.8f, %.8f", x2, y2, u2, v2);
226 #endif
227 }
228
229 }; // namespace uirenderer
230 }; // namespace android
231