305 lines
11 KiB
C++
305 lines
11 KiB
C++
/*
|
|
* Copyright (C) 2012 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 "PathRenderer"
|
|
#define LOG_NDEBUG 1
|
|
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
|
|
|
|
#define VERTEX_DEBUG 0
|
|
|
|
#include <SkPath.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <utils/Log.h>
|
|
#include <utils/Trace.h>
|
|
|
|
#include "PathRenderer.h"
|
|
#include "Matrix.h"
|
|
#include "Vector.h"
|
|
#include "Vertex.h"
|
|
|
|
namespace android {
|
|
namespace uirenderer {
|
|
|
|
#define THRESHOLD 0.5f
|
|
|
|
void PathRenderer::computeInverseScales(const mat4 *transform,
|
|
float &inverseScaleX, float& inverseScaleY) {
|
|
inverseScaleX = 1.0f;
|
|
inverseScaleY = 1.0f;
|
|
if (CC_UNLIKELY(!transform->isPureTranslate())) {
|
|
float m00 = transform->data[Matrix4::kScaleX];
|
|
float m01 = transform->data[Matrix4::kSkewY];
|
|
float m10 = transform->data[Matrix4::kSkewX];
|
|
float m11 = transform->data[Matrix4::kScaleY];
|
|
float scaleX = sqrt(m00 * m00 + m01 * m01);
|
|
float scaleY = sqrt(m10 * m10 + m11 * m11);
|
|
inverseScaleX = (scaleX != 0) ? (inverseScaleX / scaleX) : 0;
|
|
inverseScaleY = (scaleY != 0) ? (inverseScaleY / scaleY) : 0;
|
|
}
|
|
}
|
|
|
|
void PathRenderer::convexPathFillVertices(const SkPath &path, const mat4 *transform,
|
|
VertexBuffer &vertexBuffer, bool isAA) {
|
|
ATRACE_CALL();
|
|
float inverseScaleX;
|
|
float inverseScaleY;
|
|
computeInverseScales(transform, inverseScaleX, inverseScaleY);
|
|
|
|
Vector<Vertex> tempVertices;
|
|
float thresholdx = THRESHOLD * inverseScaleX;
|
|
float thresholdy = THRESHOLD * inverseScaleY;
|
|
convexPathVertices(path,
|
|
thresholdx * thresholdx,
|
|
thresholdy * thresholdy,
|
|
tempVertices);
|
|
|
|
#if VERTEX_DEBUG
|
|
for (unsigned int i = 0; i < tempVertices.size(); i++) {
|
|
ALOGD("orig path: point at %f %f",
|
|
tempVertices[i].position[0],
|
|
tempVertices[i].position[1]);
|
|
}
|
|
#endif
|
|
int currentIndex = 0;
|
|
if (!isAA) {
|
|
Vertex* buffer = vertexBuffer.alloc<Vertex>(tempVertices.size());
|
|
|
|
// zig zag between all previous points on the inside of the hull to create a
|
|
// triangle strip that fills the hull
|
|
int srcAindex = 0;
|
|
int srcBindex = tempVertices.size() - 1;
|
|
while (srcAindex <= srcBindex) {
|
|
Vertex::set(&buffer[currentIndex++],
|
|
tempVertices.editArray()[srcAindex].position[0],
|
|
tempVertices.editArray()[srcAindex].position[1]);
|
|
if (srcAindex == srcBindex) break;
|
|
Vertex::set(&buffer[currentIndex++],
|
|
tempVertices.editArray()[srcBindex].position[0],
|
|
tempVertices.editArray()[srcBindex].position[1]);
|
|
srcAindex++;
|
|
srcBindex--;
|
|
}
|
|
return;
|
|
}
|
|
AlphaVertex* buffer = vertexBuffer.alloc<AlphaVertex>(tempVertices.size() * 3 + 2);
|
|
|
|
// generate alpha points - fill Alpha vertex gaps in between each point with
|
|
// alpha 0 vertex, offset by a scaled normal.
|
|
Vertex* last = &(tempVertices.editArray()[tempVertices.size()-1]);
|
|
|
|
for (unsigned int i = 0; i<tempVertices.size(); i++) {
|
|
Vertex* current = &(tempVertices.editArray()[i]);
|
|
Vertex* next = &(tempVertices.editArray()[i + 1 >= tempVertices.size() ? 0 : i + 1]);
|
|
|
|
vec2 lastNormal(current->position[1] - last->position[1],
|
|
last->position[0] - current->position[0]);
|
|
lastNormal.normalize();
|
|
vec2 nextNormal(next->position[1] - current->position[1],
|
|
current->position[0] - next->position[0]);
|
|
nextNormal.normalize();
|
|
|
|
// AA point offset from original point is that point's normal, such that
|
|
// each side is offset by .5 pixels
|
|
vec2 totalOffset = (lastNormal + nextNormal) / (2 * (1 + lastNormal.dot(nextNormal)));
|
|
totalOffset.x *= inverseScaleX;
|
|
totalOffset.y *= inverseScaleY;
|
|
|
|
AlphaVertex::set(&buffer[currentIndex++],
|
|
current->position[0] + totalOffset.x,
|
|
current->position[1] + totalOffset.y,
|
|
0.0f);
|
|
AlphaVertex::set(&buffer[currentIndex++],
|
|
current->position[0] - totalOffset.x,
|
|
current->position[1] - totalOffset.y,
|
|
1.0f);
|
|
last = current;
|
|
}
|
|
|
|
// wrap around to beginning
|
|
AlphaVertex::set(&buffer[currentIndex++],
|
|
buffer[0].position[0],
|
|
buffer[0].position[1], 0.0f);
|
|
AlphaVertex::set(&buffer[currentIndex++],
|
|
buffer[1].position[0],
|
|
buffer[1].position[1], 1.0f);
|
|
|
|
// zig zag between all previous points on the inside of the hull to create a
|
|
// triangle strip that fills the hull, repeating the first inner point to
|
|
// create degenerate tris to start inside path
|
|
int srcAindex = 0;
|
|
int srcBindex = tempVertices.size() - 1;
|
|
while (srcAindex <= srcBindex) {
|
|
AlphaVertex::set(&buffer[currentIndex++],
|
|
buffer[srcAindex * 2 + 1].position[0],
|
|
buffer[srcAindex * 2 + 1].position[1],
|
|
1.0f);
|
|
if (srcAindex == srcBindex) break;
|
|
AlphaVertex::set(&buffer[currentIndex++],
|
|
buffer[srcBindex * 2 + 1].position[0],
|
|
buffer[srcBindex * 2 + 1].position[1],
|
|
1.0f);
|
|
srcAindex++;
|
|
srcBindex--;
|
|
}
|
|
|
|
#if VERTEX_DEBUG
|
|
for (unsigned int i = 0; i < vertexBuffer.mSize; i++) {
|
|
ALOGD("point at %f %f",
|
|
buffer[i].position[0],
|
|
buffer[i].position[1]);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
void PathRenderer::convexPathVertices(const SkPath &path, float thresholdx, float thresholdy,
|
|
Vector<Vertex> &outputVertices) {
|
|
ATRACE_CALL();
|
|
|
|
SkPath::Iter iter(path, true);
|
|
SkPoint pos;
|
|
SkPoint pts[4];
|
|
SkPath::Verb v;
|
|
Vertex* newVertex = 0;
|
|
while (SkPath::kDone_Verb != (v = iter.next(pts))) {
|
|
switch (v) {
|
|
case SkPath::kMove_Verb:
|
|
pos = pts[0];
|
|
ALOGV("Move to pos %f %f", pts[0].x(), pts[0].y());
|
|
break;
|
|
case SkPath::kClose_Verb:
|
|
ALOGV("Close at pos %f %f", pts[0].x(), pts[0].y());
|
|
break;
|
|
case SkPath::kLine_Verb:
|
|
ALOGV("kLine_Verb %f %f -> %f %f",
|
|
pts[0].x(), pts[0].y(),
|
|
pts[1].x(), pts[1].y());
|
|
|
|
// TODO: make this not yuck
|
|
outputVertices.push();
|
|
newVertex = &(outputVertices.editArray()[outputVertices.size()-1]);
|
|
Vertex::set(newVertex, pts[1].x(), pts[1].y());
|
|
break;
|
|
case SkPath::kQuad_Verb:
|
|
ALOGV("kQuad_Verb");
|
|
recursiveQuadraticBezierVertices(
|
|
pts[0].x(), pts[0].y(),
|
|
pts[2].x(), pts[2].y(),
|
|
pts[1].x(), pts[1].y(),
|
|
thresholdx, thresholdy,
|
|
outputVertices);
|
|
break;
|
|
case SkPath::kCubic_Verb:
|
|
ALOGV("kCubic_Verb");
|
|
recursiveCubicBezierVertices(
|
|
pts[0].x(), pts[0].y(),
|
|
pts[1].x(), pts[1].y(),
|
|
pts[3].x(), pts[3].y(),
|
|
pts[2].x(), pts[2].y(),
|
|
thresholdx, thresholdy, outputVertices);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void PathRenderer::recursiveCubicBezierVertices(
|
|
float p1x, float p1y, float c1x, float c1y,
|
|
float p2x, float p2y, float c2x, float c2y,
|
|
float thresholdx, float thresholdy, Vector<Vertex> &outputVertices) {
|
|
float dx = p2x - p1x;
|
|
float dy = p2y - p1y;
|
|
float d1 = fabs((c1x - p2x) * dy - (c1y - p2y) * dx);
|
|
float d2 = fabs((c2x - p2x) * dy - (c2y - p2y) * dx);
|
|
float d = d1 + d2;
|
|
|
|
if (d * d < (thresholdx * (dx * dx) + thresholdy * (dy * dy))) {
|
|
// below thresh, draw line by adding endpoint
|
|
// TODO: make this not yuck
|
|
outputVertices.push();
|
|
Vertex* newVertex = &(outputVertices.editArray()[outputVertices.size()-1]);
|
|
Vertex::set(newVertex, p2x, p2y);
|
|
} else {
|
|
float p1c1x = (p1x + c1x) * 0.5f;
|
|
float p1c1y = (p1y + c1y) * 0.5f;
|
|
float p2c2x = (p2x + c2x) * 0.5f;
|
|
float p2c2y = (p2y + c2y) * 0.5f;
|
|
|
|
float c1c2x = (c1x + c2x) * 0.5f;
|
|
float c1c2y = (c1y + c2y) * 0.5f;
|
|
|
|
float p1c1c2x = (p1c1x + c1c2x) * 0.5f;
|
|
float p1c1c2y = (p1c1y + c1c2y) * 0.5f;
|
|
|
|
float p2c1c2x = (p2c2x + c1c2x) * 0.5f;
|
|
float p2c1c2y = (p2c2y + c1c2y) * 0.5f;
|
|
|
|
float mx = (p1c1c2x + p2c1c2x) * 0.5f;
|
|
float my = (p1c1c2y + p2c1c2y) * 0.5f;
|
|
|
|
recursiveCubicBezierVertices(
|
|
p1x, p1y, p1c1x, p1c1y,
|
|
mx, my, p1c1c2x, p1c1c2y,
|
|
thresholdx, thresholdy,
|
|
outputVertices);
|
|
recursiveCubicBezierVertices(
|
|
mx, my, p2c1c2x, p2c1c2y,
|
|
p2x, p2y, p2c2x, p2c2y,
|
|
thresholdx, thresholdy,
|
|
outputVertices);
|
|
}
|
|
}
|
|
|
|
void PathRenderer::recursiveQuadraticBezierVertices(
|
|
float ax, float ay,
|
|
float bx, float by,
|
|
float cx, float cy,
|
|
float thresholdx, float thresholdy, Vector<Vertex> &outputVertices) {
|
|
float dx = bx - ax;
|
|
float dy = by - ay;
|
|
float d = (cx - bx) * dy - (cy - by) * dx;
|
|
|
|
if (d * d < (thresholdx * (dx * dx) + thresholdy * (dy * dy))) {
|
|
// below thresh, draw line by adding endpoint
|
|
// TODO: make this not yuck
|
|
outputVertices.push();
|
|
Vertex* newVertex = &(outputVertices.editArray()[outputVertices.size()-1]);
|
|
Vertex::set(newVertex, bx, by);
|
|
} else {
|
|
float acx = (ax + cx) * 0.5f;
|
|
float bcx = (bx + cx) * 0.5f;
|
|
float acy = (ay + cy) * 0.5f;
|
|
float bcy = (by + cy) * 0.5f;
|
|
|
|
// midpoint
|
|
float mx = (acx + bcx) * 0.5f;
|
|
float my = (acy + bcy) * 0.5f;
|
|
|
|
recursiveQuadraticBezierVertices(ax, ay, mx, my, acx, acy,
|
|
thresholdx, thresholdy, outputVertices);
|
|
recursiveQuadraticBezierVertices(mx, my, bx, by, bcx, bcy,
|
|
thresholdx, thresholdy, outputVertices);
|
|
}
|
|
}
|
|
|
|
}; // namespace uirenderer
|
|
}; // namespace android
|