Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3380cfdc authored by Romain Guy's avatar Romain Guy
Browse files

Replace float arrays with readable names 

Change-Id: I32a8be560b60a4ac5cbee2fec4574b2c5df9f825
parent 9a988085

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;

    }