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 #define LOG_TAG "OpenGLRenderer"
18
19 #include <cmath>
20
21 #include <utils/Log.h>
22
23 #include "Patch.h"
24 #include "Caches.h"
25 #include "Properties.h"
26
27 namespace android {
28 namespace uirenderer {
29
30 ///////////////////////////////////////////////////////////////////////////////
31 // Constructors/destructor
32 ///////////////////////////////////////////////////////////////////////////////
33
Patch(const uint32_t xCount,const uint32_t yCount,const int8_t emptyQuads)34 Patch::Patch(const uint32_t xCount, const uint32_t yCount, const int8_t emptyQuads):
35 mXCount(xCount), mYCount(yCount), mEmptyQuads(emptyQuads) {
36 // Initialized with the maximum number of vertices we will need
37 // 2 triangles per patch, 3 vertices per triangle
38 uint32_t maxVertices = ((xCount + 1) * (yCount + 1) - emptyQuads) * 2 * 3;
39 mVertices = new TextureVertex[maxVertices];
40 mUploaded = false;
41
42 verticesCount = 0;
43 hasEmptyQuads = emptyQuads > 0;
44
45 mColorKey = 0;
46 mXDivs = new int32_t[mXCount];
47 mYDivs = new int32_t[mYCount];
48
49 PATCH_LOGD(" patch: xCount = %d, yCount = %d, emptyQuads = %d, max vertices = %d",
50 xCount, yCount, emptyQuads, maxVertices);
51
52 glGenBuffers(1, &meshBuffer);
53 }
54
~Patch()55 Patch::~Patch() {
56 delete[] mVertices;
57 delete[] mXDivs;
58 delete[] mYDivs;
59 glDeleteBuffers(1, &meshBuffer);
60 }
61
62 ///////////////////////////////////////////////////////////////////////////////
63 // Patch management
64 ///////////////////////////////////////////////////////////////////////////////
65
copy(const int32_t * xDivs,const int32_t * yDivs)66 void Patch::copy(const int32_t* xDivs, const int32_t* yDivs) {
67 memcpy(mXDivs, xDivs, mXCount * sizeof(int32_t));
68 memcpy(mYDivs, yDivs, mYCount * sizeof(int32_t));
69 }
70
copy(const int32_t * yDivs)71 void Patch::copy(const int32_t* yDivs) {
72 memcpy(mYDivs, yDivs, mYCount * sizeof(int32_t));
73 }
74
updateColorKey(const uint32_t colorKey)75 void Patch::updateColorKey(const uint32_t colorKey) {
76 mColorKey = colorKey;
77 }
78
matches(const int32_t * xDivs,const int32_t * yDivs,const uint32_t colorKey)79 bool Patch::matches(const int32_t* xDivs, const int32_t* yDivs, const uint32_t colorKey) {
80 if (mColorKey != colorKey) {
81 updateColorKey(colorKey);
82 copy(xDivs, yDivs);
83 return false;
84 }
85
86 for (uint32_t i = 0; i < mXCount; i++) {
87 if (mXDivs[i] != xDivs[i]) {
88 // The Y divs may or may not match, copy everything
89 copy(xDivs, yDivs);
90 return false;
91 }
92 }
93
94 for (uint32_t i = 0; i < mYCount; i++) {
95 if (mYDivs[i] != yDivs[i]) {
96 // We know all the X divs match, copy only Y divs
97 copy(yDivs);
98 return false;
99 }
100 }
101
102 return true;
103 }
104
105 ///////////////////////////////////////////////////////////////////////////////
106 // Vertices management
107 ///////////////////////////////////////////////////////////////////////////////
108
updateVertices(const float bitmapWidth,const float bitmapHeight,float left,float top,float right,float bottom)109 void Patch::updateVertices(const float bitmapWidth, const float bitmapHeight,
110 float left, float top, float right, float bottom) {
111 if (hasEmptyQuads) quads.clear();
112
113 // Reset the vertices count here, we will count exactly how many
114 // vertices we actually need when generating the quads
115 verticesCount = 0;
116
117 const uint32_t xStretchCount = (mXCount + 1) >> 1;
118 const uint32_t yStretchCount = (mYCount + 1) >> 1;
119
120 float stretchX = 0.0f;
121 float stretchY = 0.0f;
122
123 float rescaleX = 1.0f;
124 float rescaleY = 1.0f;
125
126 const float meshWidth = right - left;
127
128 if (xStretchCount > 0) {
129 uint32_t stretchSize = 0;
130 for (uint32_t i = 1; i < mXCount; i += 2) {
131 stretchSize += mXDivs[i] - mXDivs[i - 1];
132 }
133 const float xStretchTex = stretchSize;
134 const float fixed = bitmapWidth - stretchSize;
135 const float xStretch = fmaxf(right - left - fixed, 0.0f);
136 stretchX = xStretch / xStretchTex;
137 rescaleX = fixed == 0.0f ? 0.0f : fminf(fmaxf(right - left, 0.0f) / fixed, 1.0f);
138 }
139
140 if (yStretchCount > 0) {
141 uint32_t stretchSize = 0;
142 for (uint32_t i = 1; i < mYCount; i += 2) {
143 stretchSize += mYDivs[i] - mYDivs[i - 1];
144 }
145 const float yStretchTex = stretchSize;
146 const float fixed = bitmapHeight - stretchSize;
147 const float yStretch = fmaxf(bottom - top - fixed, 0.0f);
148 stretchY = yStretch / yStretchTex;
149 rescaleY = fixed == 0.0f ? 0.0f : fminf(fmaxf(bottom - top, 0.0f) / fixed, 1.0f);
150 }
151
152 TextureVertex* vertex = mVertices;
153 uint32_t quadCount = 0;
154
155 float previousStepY = 0.0f;
156
157 float y1 = 0.0f;
158 float y2 = 0.0f;
159 float v1 = 0.0f;
160
161 for (uint32_t i = 0; i < mYCount; i++) {
162 float stepY = mYDivs[i];
163 const float segment = stepY - previousStepY;
164
165 if (i & 1) {
166 y2 = y1 + floorf(segment * stretchY + 0.5f);
167 } else {
168 y2 = y1 + segment * rescaleY;
169 }
170
171 float vOffset = y1 == y2 ? 0.0f : 0.5 - (0.5 * segment / (y2 - y1));
172 float v2 = fmax(0.0f, stepY - vOffset) / bitmapHeight;
173 v1 += vOffset / bitmapHeight;
174
175 if (stepY > 0.0f) {
176 #if DEBUG_EXPLODE_PATCHES
177 y1 += i * EXPLODE_GAP;
178 y2 += i * EXPLODE_GAP;
179 #endif
180 generateRow(vertex, y1, y2, v1, v2, stretchX, rescaleX, right - left,
181 bitmapWidth, quadCount);
182 #if DEBUG_EXPLODE_PATCHES
183 y2 -= i * EXPLODE_GAP;
184 #endif
185 }
186
187 y1 = y2;
188 v1 = stepY / bitmapHeight;
189
190 previousStepY = stepY;
191 }
192
193 if (previousStepY != bitmapHeight) {
194 y2 = bottom - top;
195 #if DEBUG_EXPLODE_PATCHES
196 y1 += mYCount * EXPLODE_GAP;
197 y2 += mYCount * EXPLODE_GAP;
198 #endif
199 generateRow(vertex, y1, y2, v1, 1.0f, stretchX, rescaleX, right - left,
200 bitmapWidth, quadCount);
201 }
202
203 if (verticesCount > 0) {
204 Caches& caches = Caches::getInstance();
205 caches.bindMeshBuffer(meshBuffer);
206 if (!mUploaded) {
207 glBufferData(GL_ARRAY_BUFFER, sizeof(TextureVertex) * verticesCount,
208 mVertices, GL_DYNAMIC_DRAW);
209 mUploaded = true;
210 } else {
211 glBufferSubData(GL_ARRAY_BUFFER, 0,
212 sizeof(TextureVertex) * verticesCount, mVertices);
213 }
214 caches.resetVertexPointers();
215 }
216
217 PATCH_LOGD(" patch: new vertices count = %d", verticesCount);
218 }
219
generateRow(TextureVertex * & vertex,float y1,float y2,float v1,float v2,float stretchX,float rescaleX,float width,float bitmapWidth,uint32_t & quadCount)220 void Patch::generateRow(TextureVertex*& vertex, float y1, float y2, float v1, float v2,
221 float stretchX, float rescaleX, float width, float bitmapWidth, uint32_t& quadCount) {
222 float previousStepX = 0.0f;
223
224 float x1 = 0.0f;
225 float x2 = 0.0f;
226 float u1 = 0.0f;
227
228 // Generate the row quad by quad
229 for (uint32_t i = 0; i < mXCount; i++) {
230 float stepX = mXDivs[i];
231 const float segment = stepX - previousStepX;
232
233 if (i & 1) {
234 x2 = x1 + floorf(segment * stretchX + 0.5f);
235 } else {
236 x2 = x1 + segment * rescaleX;
237 }
238
239 float uOffset = x1 == x2 ? 0.0f : 0.5 - (0.5 * segment / (x2 - x1));
240 float u2 = fmax(0.0f, stepX - uOffset) / bitmapWidth;
241 u1 += uOffset / bitmapWidth;
242
243 if (stepX > 0.0f) {
244 #if DEBUG_EXPLODE_PATCHES
245 x1 += i * EXPLODE_GAP;
246 x2 += i * EXPLODE_GAP;
247 #endif
248 generateQuad(vertex, x1, y1, x2, y2, u1, v1, u2, v2, quadCount);
249 #if DEBUG_EXPLODE_PATCHES
250 x2 -= i * EXPLODE_GAP;
251 #endif
252 }
253
254 x1 = x2;
255 u1 = stepX / bitmapWidth;
256
257 previousStepX = stepX;
258 }
259
260 if (previousStepX != bitmapWidth) {
261 x2 = width;
262 #if DEBUG_EXPLODE_PATCHES
263 x1 += mXCount * EXPLODE_GAP;
264 x2 += mXCount * EXPLODE_GAP;
265 #endif
266 generateQuad(vertex, x1, y1, x2, y2, u1, v1, 1.0f, v2, quadCount);
267 }
268 }
269
generateQuad(TextureVertex * & vertex,float x1,float y1,float x2,float y2,float u1,float v1,float u2,float v2,uint32_t & quadCount)270 void Patch::generateQuad(TextureVertex*& vertex, float x1, float y1, float x2, float y2,
271 float u1, float v1, float u2, float v2, uint32_t& quadCount) {
272 const uint32_t oldQuadCount = quadCount;
273 quadCount++;
274
275 if (x1 < 0.0f) x1 = 0.0f;
276 if (x2 < 0.0f) x2 = 0.0f;
277 if (y1 < 0.0f) y1 = 0.0f;
278 if (y2 < 0.0f) y2 = 0.0f;
279
280 // Skip degenerate and transparent (empty) quads
281 if (((mColorKey >> oldQuadCount) & 0x1) || x1 >= x2 || y1 >= y2) {
282 #if DEBUG_PATCHES_EMPTY_VERTICES
283 PATCH_LOGD(" quad %d (empty)", oldQuadCount);
284 PATCH_LOGD(" left, top = %.2f, %.2f\t\tu1, v1 = %.4f, %.4f", x1, y1, u1, v1);
285 PATCH_LOGD(" right, bottom = %.2f, %.2f\t\tu2, v2 = %.4f, %.4f", x2, y2, u2, v2);
286 #endif
287 return;
288 }
289
290 // Record all non empty quads
291 if (hasEmptyQuads) {
292 Rect bounds(x1, y1, x2, y2);
293 quads.add(bounds);
294 }
295
296 // Left triangle
297 TextureVertex::set(vertex++, x1, y1, u1, v1);
298 TextureVertex::set(vertex++, x2, y1, u2, v1);
299 TextureVertex::set(vertex++, x1, y2, u1, v2);
300
301 // Right triangle
302 TextureVertex::set(vertex++, x1, y2, u1, v2);
303 TextureVertex::set(vertex++, x2, y1, u2, v1);
304 TextureVertex::set(vertex++, x2, y2, u2, v2);
305
306 // A quad is made of 2 triangles, 6 vertices
307 verticesCount += 6;
308
309 #if DEBUG_PATCHES_VERTICES
310 PATCH_LOGD(" quad %d", oldQuadCount);
311 PATCH_LOGD(" left, top = %.2f, %.2f\t\tu1, v1 = %.4f, %.4f", x1, y1, u1, v1);
312 PATCH_LOGD(" right, bottom = %.2f, %.2f\t\tu2, v2 = %.4f, %.4f", x2, y2, u2, v2);
313 #endif
314 }
315
316 }; // namespace uirenderer
317 }; // namespace android
318