Merge "Replace float arrays with readable names" (2d4b7111) · Commits · e / os / android_frameworks_base

libs/hwui/Caches.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -62,7 +62,7 @@ namespace uirenderer {
		static const uint32_t gMaxNumberOfQuads = 2048;

		// Generates simple and textured vertices
		#define FV(x, y, u, v) { { x, y }, { u, v } }
		#define FV(x, y, u, v) { x, y, u, v }

		// This array is never used directly but used as a memcpy source in the
		// OpenGLRenderer constructor

libs/hwui/DisplayListOp.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -1029,8 +1029,8 @@ public:
		TextureVertex* opVertices = opMesh->vertices;
		for (uint32_t j = 0; j < vertexCount; j++, opVertices++) {
		TextureVertex::set(vertex++,
		opVertices->position[0] + tx, opVertices->position[1] + ty,
		opVertices->texture[0], opVertices->texture[1]);
		opVertices->x + tx, opVertices->y + ty,
		opVertices->u, opVertices->v);
		}

		// Dirty the current layer if possible. When the 9-patch does not

libs/hwui/FontRenderer.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -514,8 +514,8 @@ void FontRenderer::issueDrawCommand(Vector<CacheTexture*>& cacheTextures) {
		texture->setLinearFiltering(mLinearFiltering, false);

		TextureVertex* mesh = texture->mesh();
		caches.bindPositionVertexPointer(force, &mesh[0].position[0]);
		caches.bindTexCoordsVertexPointer(force, &mesh[0].texture[0]);
		caches.bindPositionVertexPointer(force, &mesh[0].x);
		caches.bindTexCoordsVertexPointer(force, &mesh[0].u);
		force = false;

		glDrawElements(GL_TRIANGLES, texture->meshElementCount(),

libs/hwui/OpenGLRenderer.cpp

+13 −13

Original line number	Diff line number	Diff line
		@@ -1109,7 +1109,7 @@ void OpenGLRenderer::drawTextureLayer(Layer* layer, const Rect& rect) {
		setupDrawModelView(rect.left, rect.top, rect.right, rect.bottom);
		}
		setupDrawTextureTransformUniforms(layer->getTexTransform());
		setupDrawMesh(&mMeshVertices[0].position[0], &mMeshVertices[0].texture[0]);
		setupDrawMesh(&mMeshVertices[0].x, &mMeshVertices[0].u);

		glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
		}
		@@ -1142,7 +1142,7 @@ void OpenGLRenderer::composeLayerRect(Layer* layer, const Rect& rect, bool swap)
		bool blend = layer->isBlend() \|\| alpha < 1.0f;
		drawTextureMesh(x, y, x + rect.getWidth(), y + rect.getHeight(),
		layer->getTexture(), alpha, layer->getMode(), blend,
		&mMeshVertices[0].position[0], &mMeshVertices[0].texture[0],
		&mMeshVertices[0].x, &mMeshVertices[0].u,
		GL_TRIANGLE_STRIP, gMeshCount, swap, swap \|\| simpleTransform);

		resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
		@@ -1223,7 +1223,7 @@ void OpenGLRenderer::composeLayerRegion(Layer* layer, const Rect& rect) {
		layer->setFilter(GL_LINEAR);
		setupDrawModelViewTranslate(rect.left, rect.top, rect.right, rect.bottom);
		}
		setupDrawMeshIndices(&mesh[0].position[0], &mesh[0].texture[0]);
		setupDrawMeshIndices(&mesh[0].x, &mesh[0].u);

		for (size_t i = 0; i < count; i++) {
		const android::Rect* r = &rects[i];
		@@ -1337,7 +1337,7 @@ void OpenGLRenderer::drawIndexedQuads(Vertex* mesh, GLsizei quadsCount) {
		while (elementsCount > 0) {
		GLsizei drawCount = min(elementsCount, (GLsizei) gMaxNumberOfQuads * 6);

		setupDrawIndexedVertices(&mesh[0].position[0]);
		setupDrawIndexedVertices(&mesh[0].x);
		glDrawElements(GL_TRIANGLES, drawCount, GL_UNSIGNED_SHORT, NULL);

		elementsCount -= drawCount;
		@@ -2110,12 +2110,12 @@ status_t OpenGLRenderer::drawBitmaps(SkBitmap* bitmap, AssetAtlas::Entry* entry,
		int color = paint != NULL ? paint->getColor() : 0;
		drawAlpha8TextureMesh(x, y, x + bounds.getWidth(), y + bounds.getHeight(),
		texture->id, paint != NULL, color, alpha, mode,
		&vertices[0].position[0], &vertices[0].texture[0],
		&vertices[0].x, &vertices[0].u,
		GL_TRIANGLES, bitmapCount * 6, true, true, false);
		} else {
		drawTextureMesh(x, y, x + bounds.getWidth(), y + bounds.getHeight(),
		texture->id, alpha / 255.0f, mode, texture->blend,
		&vertices[0].position[0], &vertices[0].texture[0],
		&vertices[0].x, &vertices[0].u,
		GL_TRIANGLES, bitmapCount * 6, false, true, 0, true, false);
		}

		@@ -2297,7 +2297,7 @@ status_t OpenGLRenderer::drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int mes
		setupDrawTexture(texture->id);
		setupDrawPureColorUniforms();
		setupDrawColorFilterUniforms();
		setupDrawMesh(&mesh[0].position[0], &mesh[0].texture[0], &mesh[0].color[0]);
		setupDrawMesh(&mesh[0].x, &mesh[0].u, &mesh[0].r);

		glDrawArrays(GL_TRIANGLES, 0, count);

		@@ -2385,12 +2385,12 @@ status_t OpenGLRenderer::drawBitmap(SkBitmap* bitmap,
		int color = paint ? paint->getColor() : 0;
		drawAlpha8TextureMesh(dstLeft, dstTop, dstRight, dstBottom,
		texture->id, paint != NULL, color, alpha, mode,
		&mMeshVertices[0].position[0], &mMeshVertices[0].texture[0],
		&mMeshVertices[0].x, &mMeshVertices[0].u,
		GL_TRIANGLE_STRIP, gMeshCount, ignoreTransform);
		} else {
		drawTextureMesh(dstLeft, dstTop, dstRight, dstBottom,
		texture->id, alpha / 255.0f, mode, texture->blend,
		&mMeshVertices[0].position[0], &mMeshVertices[0].texture[0],
		&mMeshVertices[0].x, &mMeshVertices[0].u,
		GL_TRIANGLE_STRIP, gMeshCount, false, ignoreTransform);
		}

		@@ -2495,7 +2495,7 @@ status_t OpenGLRenderer::drawPatches(SkBitmap* bitmap, AssetAtlas::Entry* entry,
		getAlphaAndMode(paint, &alpha, &mode);

		drawIndexedTextureMesh(0.0f, 0.0f, 1.0f, 1.0f, texture->id, alpha / 255.0f,
		mode, texture->blend, &vertices[0].position[0], &vertices[0].texture[0],
		mode, texture->blend, &vertices[0].x, &vertices[0].u,
		GL_TRIANGLES, indexCount, false, true, 0, true, false);

		return DrawGlInfo::kStatusDrew;
		@@ -3115,7 +3115,7 @@ status_t OpenGLRenderer::drawLayer(Layer* layer, float x, float y) {
		while (elementsCount > 0) {
		GLsizei drawCount = min(elementsCount, (GLsizei) gMaxNumberOfQuads * 6);

		setupDrawMeshIndices(&mesh[0].position[0], &mesh[0].texture[0]);
		setupDrawMeshIndices(&mesh[0].x, &mesh[0].u);
		DRAW_DOUBLE_STENCIL_IF(!layer->hasDrawnSinceUpdate,
		glDrawElements(GL_TRIANGLES, drawCount, GL_UNSIGNED_SHORT, NULL));

		@@ -3418,8 +3418,8 @@ void OpenGLRenderer::drawTextureRect(float left, float top, float right, float b
		GLvoid* texCoords = (GLvoid*) gMeshTextureOffset;

		if (texture->uvMapper) {
		vertices = &mMeshVertices[0].position[0];
		texCoords = &mMeshVertices[0].texture[0];
		vertices = &mMeshVertices[0].x;
		texCoords = &mMeshVertices[0].u;

		Rect uvs(0.0f, 0.0f, 1.0f, 1.0f);
		texture->uvMapper->map(uvs);

libs/hwui/PathTessellator.cpp

+71 −71

Original line number	Diff line number	Diff line
		@@ -24,11 +24,11 @@
		#define DEBUG_DUMP_ALPHA_BUFFER() \
		for (unsigned int i = 0; i < vertexBuffer.getSize(); i++) { \
		ALOGD("point %d at %f %f, alpha %f", \
		i, buffer[i].position[0], buffer[i].position[1], buffer[i].alpha); \
		i, buffer[i].x, buffer[i].y, buffer[i].alpha); \
		}
		#define DEBUG_DUMP_BUFFER() \
		for (unsigned int i = 0; i < vertexBuffer.getSize(); i++) { \
		ALOGD("point %d at %f %f", i, buffer[i].position[0], buffer[i].position[1]); \
		ALOGD("point %d at %f %f", i, buffer[i].x, buffer[i].y); \
		}
		#else
		#define DEBUG_DUMP_ALPHA_BUFFER()
		@@ -67,11 +67,11 @@ void PathTessellator::expandBoundsForStroke(SkRect& bounds, const SkPaint* paint
		}

		inline static void copyVertex(Vertex* destPtr, const Vertex* srcPtr) {
		Vertex::set(destPtr, srcPtr->position[0], srcPtr->position[1]);
		Vertex::set(destPtr, srcPtr->x, srcPtr->y);
		}

		inline static void copyAlphaVertex(AlphaVertex* destPtr, const AlphaVertex* srcPtr) {
		AlphaVertex::set(destPtr, srcPtr->position[0], srcPtr->position[1], srcPtr->alpha);
		AlphaVertex::set(destPtr, srcPtr->x, srcPtr->y, srcPtr->alpha);
		}

		/**
		@@ -192,25 +192,25 @@ void getStrokeVerticesFromPerimeter(const PaintInfo& paintInfo, const Vector<Ver
		int currentIndex = 0;
		const Vertex* last = &(perimeter[perimeter.size() - 1]);
		const Vertex* current = &(perimeter[0]);
		vec2 lastNormal(current->position[1] - last->position[1],
		last->position[0] - current->position[0]);
		vec2 lastNormal(current->y - last->y,
		last->x - current->x);
		lastNormal.normalize();
		for (unsigned int i = 0; i < perimeter.size(); i++) {
		const Vertex* next = &(perimeter[i + 1 >= perimeter.size() ? 0 : i + 1]);
		vec2 nextNormal(next->position[1] - current->position[1],
		current->position[0] - next->position[0]);
		vec2 nextNormal(next->y - current->y,
		current->x - next->x);
		nextNormal.normalize();

		vec2 totalOffset = totalOffsetFromNormals(lastNormal, nextNormal);
		paintInfo.scaleOffsetForStrokeWidth(totalOffset);

		Vertex::set(&buffer[currentIndex++],
		current->position[0] + totalOffset.x,
		current->position[1] + totalOffset.y);
		current->x + totalOffset.x,
		current->y + totalOffset.y);

		Vertex::set(&buffer[currentIndex++],
		current->position[0] - totalOffset.x,
		current->position[1] - totalOffset.y);
		current->x - totalOffset.x,
		current->y - totalOffset.y);

		last = current;
		current = next;
		@@ -229,7 +229,7 @@ static inline void storeBeginEnd(const PaintInfo& paintInfo, const Vertex& cente
		vec2 strokeOffset = normal;
		paintInfo.scaleOffsetForStrokeWidth(strokeOffset);

		vec2 referencePoint(center.position[0], center.position[1]);
		vec2 referencePoint(center.x, center.y);
		if (paintInfo.cap == SkPaint::kSquare_Cap) {
		referencePoint += vec2(-strokeOffset.y, strokeOffset.x) * (begin ? -1 : 1);
		}
		@@ -255,11 +255,11 @@ void getStrokeVerticesFromUnclosedVertices(const PaintInfo& paintInfo,
		if (extra > 0) {
		// tessellate both round caps
		float beginTheta = atan2(
		- (vertices[0].position[0] - vertices[1].position[0]),
		vertices[0].position[1] - vertices[1].position[1]);
		- (vertices[0].x - vertices[1].x),
		vertices[0].y - vertices[1].y);
		float endTheta = atan2(
		- (vertices[lastIndex].position[0] - vertices[lastIndex - 1].position[0]),
		vertices[lastIndex].position[1] - vertices[lastIndex - 1].position[1]);
		- (vertices[lastIndex].x - vertices[lastIndex - 1].x),
		vertices[lastIndex].y - vertices[lastIndex - 1].y);
		const float dTheta = PI / (extra + 1);
		const float radialScale = 2.0f / (1 + cos(dTheta));

		@@ -275,37 +275,37 @@ void getStrokeVerticesFromUnclosedVertices(const PaintInfo& paintInfo,
		vec2 beginRadialOffset(cos(beginTheta), sin(beginTheta));
		paintInfo.scaleOffsetForStrokeWidth(beginRadialOffset);
		Vertex::set(&buffer[capOffset],
		vertices[0].position[0] + beginRadialOffset.x,
		vertices[0].position[1] + beginRadialOffset.y);
		vertices[0].x + beginRadialOffset.x,
		vertices[0].y + beginRadialOffset.y);

		endTheta += dTheta;
		vec2 endRadialOffset(cos(endTheta), sin(endTheta));
		paintInfo.scaleOffsetForStrokeWidth(endRadialOffset);
		Vertex::set(&buffer[allocSize - 1 - capOffset],
		vertices[lastIndex].position[0] + endRadialOffset.x,
		vertices[lastIndex].position[1] + endRadialOffset.y);
		vertices[lastIndex].x + endRadialOffset.x,
		vertices[lastIndex].y + endRadialOffset.y);
		}
		}

		int currentIndex = extra;
		const Vertex* last = &(vertices[0]);
		const Vertex* current = &(vertices[1]);
		vec2 lastNormal(current->position[1] - last->position[1],
		last->position[0] - current->position[0]);
		vec2 lastNormal(current->y - last->y,
		last->x - current->x);
		lastNormal.normalize();

		storeBeginEnd(paintInfo, vertices[0], lastNormal, buffer, currentIndex, true);

		for (unsigned int i = 1; i < vertices.size() - 1; i++) {
		const Vertex* next = &(vertices[i + 1]);
		vec2 nextNormal(next->position[1] - current->position[1],
		current->position[0] - next->position[0]);
		vec2 nextNormal(next->y - current->y,
		current->x - next->x);
		nextNormal.normalize();

		vec2 strokeOffset = totalOffsetFromNormals(lastNormal, nextNormal);
		paintInfo.scaleOffsetForStrokeWidth(strokeOffset);

		vec2 center(current->position[0], current->position[1]);
		vec2 center(current->x, current->y);
		Vertex::set(&buffer[currentIndex++], center + strokeOffset);
		Vertex::set(&buffer[currentIndex++], center - strokeOffset);

		@@ -337,13 +337,13 @@ void getFillVerticesFromPerimeterAA(const PaintInfo& paintInfo, const Vector<Ver
		int currentIndex = 0;
		const Vertex* last = &(perimeter[perimeter.size() - 1]);
		const Vertex* current = &(perimeter[0]);
		vec2 lastNormal(current->position[1] - last->position[1],
		last->position[0] - current->position[0]);
		vec2 lastNormal(current->y - last->y,
		last->x - current->x);
		lastNormal.normalize();
		for (unsigned int i = 0; i < perimeter.size(); i++) {
		const Vertex* next = &(perimeter[i + 1 >= perimeter.size() ? 0 : i + 1]);
		vec2 nextNormal(next->position[1] - current->position[1],
		current->position[0] - next->position[0]);
		vec2 nextNormal(next->y - current->y,
		current->x - next->x);
		nextNormal.normalize();

		// AA point offset from original point is that point's normal, such that each side is offset
		@@ -351,12 +351,12 @@ void getFillVerticesFromPerimeterAA(const PaintInfo& paintInfo, const Vector<Ver
		vec2 totalOffset = paintInfo.deriveAAOffset(totalOffsetFromNormals(lastNormal, nextNormal));

		AlphaVertex::set(&buffer[currentIndex++],
		current->position[0] + totalOffset.x,
		current->position[1] + totalOffset.y,
		current->x + totalOffset.x,
		current->y + totalOffset.y,
		0.0f);
		AlphaVertex::set(&buffer[currentIndex++],
		current->position[0] - totalOffset.x,
		current->position[1] - totalOffset.y,
		current->x - totalOffset.x,
		current->y - totalOffset.y,
		1.0f);

		last = current;
		@@ -416,7 +416,7 @@ inline static void storeCapAA(const PaintInfo& paintInfo, const Vector<Vertex>&

		// determine referencePoint, the center point for the 4 primary cap vertices
		const Vertex* point = isFirst ? vertices.begin() : (vertices.end() - 1);
		vec2 referencePoint(point->position[0], point->position[1]);
		vec2 referencePoint(point->x, point->y);
		if (paintInfo.cap == SkPaint::kSquare_Cap) {
		// To account for square cap, move the primary cap vertices (that create the AA edge) by the
		// stroke offset vector (rotated to be parallel to the stroke)
		@@ -576,8 +576,8 @@ void getStrokeVerticesFromUnclosedVerticesAA(const PaintInfo& paintInfo,

		const Vertex* last = &(vertices[0]);
		const Vertex* current = &(vertices[1]);
		vec2 lastNormal(current->position[1] - last->position[1],
		last->position[0] - current->position[0]);
		vec2 lastNormal(current->y - last->y,
		last->x - current->x);
		lastNormal.normalize();

		// TODO: use normal from bezier traversal for cap, instead of from vertices
		@@ -585,8 +585,8 @@ void getStrokeVerticesFromUnclosedVerticesAA(const PaintInfo& paintInfo,

		for (unsigned int i = 1; i < vertices.size() - 1; i++) {
		const Vertex* next = &(vertices[i + 1]);
		vec2 nextNormal(next->position[1] - current->position[1],
		current->position[0] - next->position[0]);
		vec2 nextNormal(next->y - current->y,
		current->x - next->x);
		nextNormal.normalize();

		vec2 totalOffset = totalOffsetFromNormals(lastNormal, nextNormal);
		@@ -598,30 +598,30 @@ void getStrokeVerticesFromUnclosedVerticesAA(const PaintInfo& paintInfo,
		innerOffset -= AAOffset;

		AlphaVertex::set(&buffer[currentAAOuterIndex++],
		current->position[0] + outerOffset.x,
		current->position[1] + outerOffset.y,
		current->x + outerOffset.x,
		current->y + outerOffset.y,
		0.0f);
		AlphaVertex::set(&buffer[currentAAOuterIndex++],
		current->position[0] + innerOffset.x,
		current->position[1] + innerOffset.y,
		current->x + innerOffset.x,
		current->y + innerOffset.y,
		paintInfo.maxAlpha);

		AlphaVertex::set(&buffer[currentStrokeIndex++],
		current->position[0] + innerOffset.x,
		current->position[1] + innerOffset.y,
		current->x + innerOffset.x,
		current->y + innerOffset.y,
		paintInfo.maxAlpha);
		AlphaVertex::set(&buffer[currentStrokeIndex++],
		current->position[0] - innerOffset.x,
		current->position[1] - innerOffset.y,
		current->x - innerOffset.x,
		current->y - innerOffset.y,
		paintInfo.maxAlpha);

		AlphaVertex::set(&buffer[currentAAInnerIndex--],
		current->position[0] - innerOffset.x,
		current->position[1] - innerOffset.y,
		current->x - innerOffset.x,
		current->y - innerOffset.y,
		paintInfo.maxAlpha);
		AlphaVertex::set(&buffer[currentAAInnerIndex--],
		current->position[0] - outerOffset.x,
		current->position[1] - outerOffset.y,
		current->x - outerOffset.x,
		current->y - outerOffset.y,
		0.0f);

		current = next;
		@@ -646,13 +646,13 @@ void getStrokeVerticesFromPerimeterAA(const PaintInfo& paintInfo, const Vector<V

		const Vertex* last = &(perimeter[perimeter.size() - 1]);
		const Vertex* current = &(perimeter[0]);
		vec2 lastNormal(current->position[1] - last->position[1],
		last->position[0] - current->position[0]);
		vec2 lastNormal(current->y - last->y,
		last->x - current->x);
		lastNormal.normalize();
		for (unsigned int i = 0; i < perimeter.size(); i++) {
		const Vertex* next = &(perimeter[i + 1 >= perimeter.size() ? 0 : i + 1]);
		vec2 nextNormal(next->position[1] - current->position[1],
		current->position[0] - next->position[0]);
		vec2 nextNormal(next->y - current->y,
		current->x - next->x);
		nextNormal.normalize();

		vec2 totalOffset = totalOffsetFromNormals(lastNormal, nextNormal);
		@@ -664,30 +664,30 @@ void getStrokeVerticesFromPerimeterAA(const PaintInfo& paintInfo, const Vector<V
		innerOffset -= AAOffset;

		AlphaVertex::set(&buffer[currentAAOuterIndex++],
		current->position[0] + outerOffset.x,
		current->position[1] + outerOffset.y,
		current->x + outerOffset.x,
		current->y + outerOffset.y,
		0.0f);
		AlphaVertex::set(&buffer[currentAAOuterIndex++],
		current->position[0] + innerOffset.x,
		current->position[1] + innerOffset.y,
		current->x + innerOffset.x,
		current->y + innerOffset.y,
		paintInfo.maxAlpha);

		AlphaVertex::set(&buffer[currentStrokeIndex++],
		current->position[0] + innerOffset.x,
		current->position[1] + innerOffset.y,
		current->x + innerOffset.x,
		current->y + innerOffset.y,
		paintInfo.maxAlpha);
		AlphaVertex::set(&buffer[currentStrokeIndex++],
		current->position[0] - innerOffset.x,
		current->position[1] - innerOffset.y,
		current->x - innerOffset.x,
		current->y - innerOffset.y,
		paintInfo.maxAlpha);

		AlphaVertex::set(&buffer[currentAAInnerIndex++],
		current->position[0] - innerOffset.x,
		current->position[1] - innerOffset.y,
		current->x - innerOffset.x,
		current->y - innerOffset.y,
		paintInfo.maxAlpha);
		AlphaVertex::set(&buffer[currentAAInnerIndex++],
		current->position[0] - outerOffset.x,
		current->position[1] - outerOffset.y,
		current->x - outerOffset.x,
		current->y - outerOffset.y,
		0.0f);

		last = current;
		@@ -743,7 +743,7 @@ void PathTessellator::tessellatePath(const SkPath &path, const SkPaint* paint,
		#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]);
		tempVertices[i].x, tempVertices[i].y);
		}
		#endif

		@@ -780,7 +780,7 @@ static void expandRectToCoverVertex(SkRect& rect, float x, float y) {
		rect.fBottom = fmaxf(rect.fBottom, y);
		}
		static void expandRectToCoverVertex(SkRect& rect, const Vertex& vertex) {
		expandRectToCoverVertex(rect, vertex.position[0], vertex.position[1]);
		expandRectToCoverVertex(rect, vertex.x, vertex.y);
		}

		template <class TYPE>
		@@ -939,8 +939,8 @@ bool PathTessellator::approximatePathOutlineVertices(const SkPath& path, bool fo
		}

		int size = outputVertices.size();
		if (size >= 2 && outputVertices[0].position[0] == outputVertices[size - 1].position[0] &&
		outputVertices[0].position[1] == outputVertices[size - 1].position[1]) {
		if (size >= 2 && outputVertices[0].x == outputVertices[size - 1].x &&
		outputVertices[0].y == outputVertices[size - 1].y) {
		outputVertices.pop();
		return true;
		}