libs/hwui/PathRenderer.cpp - platform/frameworks/base - Gitiles

 /*
  * 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
	/*
	* 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