blob: 47a2c99dd60a8e6cd86ced093d9a72d1b74b42f4 [file] [log] [blame]
/*
* Copyright (C) 2010 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.
*/
#define LOG_TAG "OpenGLRenderer"
#include <cmath>
#include <utils/Log.h>
#include "Patch.h"
#include "Caches.h"
#include "Properties.h"
namespace android {
namespace uirenderer {
///////////////////////////////////////////////////////////////////////////////
// Constructors/destructor
///////////////////////////////////////////////////////////////////////////////
Patch::Patch(const uint32_t xCount, const uint32_t yCount, const int8_t emptyQuads):
mXCount(xCount), mYCount(yCount), mEmptyQuads(emptyQuads) {
// Initialized with the maximum number of vertices we will need
// 2 triangles per patch, 3 vertices per triangle
uint32_t maxVertices = ((xCount + 1) * (yCount + 1) - emptyQuads) * 2 * 3;
mVertices = new TextureVertex[maxVertices];
mUploaded = false;
verticesCount = 0;
hasEmptyQuads = emptyQuads > 0;
mColorKey = 0;
mXDivs = new int32_t[mXCount];
mYDivs = new int32_t[mYCount];
PATCH_LOGD(" patch: xCount = %d, yCount = %d, emptyQuads = %d, max vertices = %d",
xCount, yCount, emptyQuads, maxVertices);
glGenBuffers(1, &meshBuffer);
}
Patch::~Patch() {
delete[] mVertices;
delete[] mXDivs;
delete[] mYDivs;
glDeleteBuffers(1, &meshBuffer);
}
///////////////////////////////////////////////////////////////////////////////
// Patch management
///////////////////////////////////////////////////////////////////////////////
void Patch::copy(const int32_t* xDivs, const int32_t* yDivs) {
memcpy(mXDivs, xDivs, mXCount * sizeof(int32_t));
memcpy(mYDivs, yDivs, mYCount * sizeof(int32_t));
}
void Patch::copy(const int32_t* yDivs) {
memcpy(mYDivs, yDivs, mYCount * sizeof(int32_t));
}
void Patch::updateColorKey(const uint32_t colorKey) {
mColorKey = colorKey;
}
bool Patch::matches(const int32_t* xDivs, const int32_t* yDivs, const uint32_t colorKey) {
if (mColorKey != colorKey) {
updateColorKey(colorKey);
copy(xDivs, yDivs);
return false;
}
for (uint32_t i = 0; i < mXCount; i++) {
if (mXDivs[i] != xDivs[i]) {
// The Y divs may or may not match, copy everything
copy(xDivs, yDivs);
return false;
}
}
for (uint32_t i = 0; i < mYCount; i++) {
if (mYDivs[i] != yDivs[i]) {
// We know all the X divs match, copy only Y divs
copy(yDivs);
return false;
}
}
return true;
}
///////////////////////////////////////////////////////////////////////////////
// Vertices management
///////////////////////////////////////////////////////////////////////////////
void Patch::updateVertices(const float bitmapWidth, const float bitmapHeight,
float left, float top, float right, float bottom) {
#if RENDER_LAYERS_AS_REGIONS
if (hasEmptyQuads) quads.clear();
#endif
// Reset the vertices count here, we will count exactly how many
// vertices we actually need when generating the quads
verticesCount = 0;
const uint32_t xStretchCount = (mXCount + 1) >> 1;
const uint32_t yStretchCount = (mYCount + 1) >> 1;
float stretchX = 0.0f;
float stretchY = 0.0;
const float meshWidth = right - left;
if (xStretchCount > 0) {
uint32_t stretchSize = 0;
for (uint32_t i = 1; i < mXCount; i += 2) {
stretchSize += mXDivs[i] - mXDivs[i - 1];
}
const float xStretchTex = stretchSize;
const float fixed = bitmapWidth - stretchSize;
const float xStretch = right - left - fixed;
stretchX = xStretch / xStretchTex;
}
if (yStretchCount > 0) {
uint32_t stretchSize = 0;
for (uint32_t i = 1; i < mYCount; i += 2) {
stretchSize += mYDivs[i] - mYDivs[i - 1];
}
const float yStretchTex = stretchSize;
const float fixed = bitmapHeight - stretchSize;
const float yStretch = bottom - top - fixed;
stretchY = yStretch / yStretchTex;
}
TextureVertex* vertex = mVertices;
uint32_t quadCount = 0;
float previousStepY = 0.0f;
float y1 = 0.0f;
float y2 = 0.0f;
float v1 = 0.0f;
for (uint32_t i = 0; i < mYCount; i++) {
float stepY = mYDivs[i];
const float segment = stepY - previousStepY;
if (i & 1) {
y2 = y1 + floorf(segment * stretchY + 0.5f);
} else {
y2 = y1 + segment;
}
float vOffset = y1 == y2 ? 0.0f : 0.5 - (0.5 * segment / (y2 - y1));
float v2 = fmax(0.0f, stepY - vOffset) / bitmapHeight;
v1 += vOffset / bitmapHeight;
if (stepY > 0.0f) {
#if DEBUG_EXPLODE_PATCHES
y1 += i * EXPLODE_GAP;
y2 += i * EXPLODE_GAP;
#endif
generateRow(vertex, y1, y2, v1, v2, stretchX, right - left,
bitmapWidth, quadCount);
#if DEBUG_EXPLODE_PATCHES
y2 -= i * EXPLODE_GAP;
#endif
}
y1 = y2;
v1 = stepY / bitmapHeight;
previousStepY = stepY;
}
if (previousStepY != bitmapHeight) {
y2 = bottom - top;
#if DEBUG_EXPLODE_PATCHES
y1 += mYCount * EXPLODE_GAP;
y2 += mYCount * EXPLODE_GAP;
#endif
generateRow(vertex, y1, y2, v1, 1.0f, stretchX, right - left, bitmapWidth, quadCount);
}
if (verticesCount > 0) {
Caches::getInstance().bindMeshBuffer(meshBuffer);
if (!mUploaded) {
glBufferData(GL_ARRAY_BUFFER, sizeof(TextureVertex) * verticesCount,
mVertices, GL_DYNAMIC_DRAW);
mUploaded = true;
} else {
glBufferSubData(GL_ARRAY_BUFFER, 0,
sizeof(TextureVertex) * verticesCount, mVertices);
}
}
PATCH_LOGD(" patch: new vertices count = %d", verticesCount);
}
void Patch::generateRow(TextureVertex*& vertex, float y1, float y2, float v1, float v2,
float stretchX, float width, float bitmapWidth, uint32_t& quadCount) {
float previousStepX = 0.0f;
float x1 = 0.0f;
float x2 = 0.0f;
float u1 = 0.0f;
// Generate the row quad by quad
for (uint32_t i = 0; i < mXCount; i++) {
float stepX = mXDivs[i];
const float segment = stepX - previousStepX;
if (i & 1) {
x2 = x1 + floorf(segment * stretchX + 0.5f);
} else {
x2 = x1 + segment;
}
float uOffset = x1 == x2 ? 0.0f : 0.5 - (0.5 * segment / (x2 - x1));
float u2 = fmax(0.0f, stepX - uOffset) / bitmapWidth;
u1 += uOffset / bitmapWidth;
if (stepX > 0.0f) {
#if DEBUG_EXPLODE_PATCHES
x1 += i * EXPLODE_GAP;
x2 += i * EXPLODE_GAP;
#endif
generateQuad(vertex, x1, y1, x2, y2, u1, v1, u2, v2, quadCount);
#if DEBUG_EXPLODE_PATCHES
x2 -= i * EXPLODE_GAP;
#endif
}
x1 = x2;
u1 = stepX / bitmapWidth;
previousStepX = stepX;
}
if (previousStepX != bitmapWidth) {
x2 = width;
#if DEBUG_EXPLODE_PATCHES
x1 += mXCount * EXPLODE_GAP;
x2 += mXCount * EXPLODE_GAP;
#endif
generateQuad(vertex, x1, y1, x2, y2, u1, v1, 1.0f, v2, quadCount);
}
}
void Patch::generateQuad(TextureVertex*& vertex, float x1, float y1, float x2, float y2,
float u1, float v1, float u2, float v2, uint32_t& quadCount) {
const uint32_t oldQuadCount = quadCount;
quadCount++;
// Skip degenerate and transparent (empty) quads
if ((mColorKey >> oldQuadCount) & 0x1) {
#if DEBUG_PATCHES_EMPTY_VERTICES
PATCH_LOGD(" quad %d (empty)", oldQuadCount);
PATCH_LOGD(" left, top = %.2f, %.2f\t\tu1, v1 = %.4f, %.4f", x1, y1, u1, v1);
PATCH_LOGD(" right, bottom = %.2f, %.2f\t\tu2, v2 = %.4f, %.4f", x2, y2, u2, v2);
#endif
return;
}
#if RENDER_LAYERS_AS_REGIONS
// Record all non empty quads
if (hasEmptyQuads) {
Rect bounds(x1, y1, x2, y2);
quads.add(bounds);
}
#endif
// Left triangle
TextureVertex::set(vertex++, x1, y1, u1, v1);
TextureVertex::set(vertex++, x2, y1, u2, v1);
TextureVertex::set(vertex++, x1, y2, u1, v2);
// Right triangle
TextureVertex::set(vertex++, x1, y2, u1, v2);
TextureVertex::set(vertex++, x2, y1, u2, v1);
TextureVertex::set(vertex++, x2, y2, u2, v2);
// A quad is made of 2 triangles, 6 vertices
verticesCount += 6;
#if DEBUG_PATCHES_VERTICES
PATCH_LOGD(" quad %d", oldQuadCount);
PATCH_LOGD(" left, top = %.2f, %.2f\t\tu1, v1 = %.4f, %.4f", x1, y1, u1, v1);
PATCH_LOGD(" right, bottom = %.2f, %.2f\t\tu2, v2 = %.4f, %.4f", x2, y2, u2, v2);
#endif
}
}; // namespace uirenderer
}; // namespace android