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

Commit f219da5e authored by Romain Guy's avatar Romain Guy
Browse files

Don't blend transparent pixels when rendering layers. 

With this change, the rendere keeps track of what regions are rendered into
and generates a mesh that matches these regions exactly. The mesh is used
to composite the layer on screen.

Change-Id: I1f342576b9134fb29caff7fb8f4c1da179fe956d
parent a47aa87a

libs/hwui/Layer.h

+16 −0
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 


#include "Rect.h"

#include "SkiaColorFilter.h"

#include "Vertex.h"



namespace android {

namespace uirenderer {
@@ -41,6 +42,14 @@ namespace uirenderer { 
struct Layer {

    Layer(const uint32_t layerWidth, const uint32_t layerHeight):

            width(layerWidth), height(layerHeight) {

        mesh = NULL;

        meshIndices = NULL;

        meshElementCount = 0;

    }



    ~Layer() {

        if (mesh) delete mesh;

        if (meshIndices) delete meshIndices;

    }



    /**
@@ -99,6 +108,13 @@ struct Layer { 
     * Color filter used to draw this layer. Optional.

     */

    SkiaColorFilter* colorFilter;



    /**

     * If the layer can be rendered as a mesh, this is non-null.

     */

    TextureVertex* mesh;

    uint16_t* meshIndices;

    GLsizei meshElementCount;

}; // struct Layer



}; // namespace uirenderer

libs/hwui/LayerRenderer.cpp

+91 −1
Original line number Diff line number Diff line
@@ -29,6 +29,10 @@ namespace uirenderer { 
void LayerRenderer::prepare(bool opaque) {

    LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->fbo);



#if RENDER_LAYERS_AS_REGIONS

    mLayer->region.clear();

#endif



    glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &mPreviousFbo);

    glBindFramebuffer(GL_FRAMEBUFFER, mLayer->fbo);
@@ -39,11 +43,97 @@ void LayerRenderer::finish() { 
    OpenGLRenderer::finish();

    glBindFramebuffer(GL_FRAMEBUFFER, mPreviousFbo);



    generateMesh();



    LAYER_RENDERER_LOGD("Finished rendering into layer, fbo = %d", mLayer->mFbo);

}



///////////////////////////////////////////////////////////////////////////////

// Static functions

// Dirty region tracking

///////////////////////////////////////////////////////////////////////////////



bool LayerRenderer::hasLayer() {

    return true;

}



Region* LayerRenderer::getRegion() {

#if RENDER_LAYERS_AS_REGIONS

    if (getSnapshot()->flags & Snapshot::kFlagFboTarget) {

        return OpenGLRenderer::getRegion();

    }

    return &mLayer->region;

#else

    return OpenGLRenderer::getRegion();

#endif

}



void LayerRenderer::generateMesh() {

#if RENDER_LAYERS_AS_REGIONS

    if (mLayer->region.isRect() || mLayer->region.isEmpty()) {

        if (mLayer->mesh) {

            delete mLayer->mesh;

            delete mLayer->meshIndices;



            mLayer->mesh = NULL;

            mLayer->meshIndices = NULL;

            mLayer->meshElementCount = 0;

        }

        return;

    }



    size_t count;

    const android::Rect* rects = mLayer->region.getArray(&count);



    GLsizei elementCount = count * 6;



    if (mLayer->mesh && mLayer->meshElementCount < elementCount) {

        delete mLayer->mesh;

        delete mLayer->meshIndices;



        mLayer->mesh = NULL;

        mLayer->meshIndices = NULL;

    }



    if (!mLayer->mesh) {

        mLayer->mesh = new TextureVertex[count * 4];

        mLayer->meshIndices = new uint16_t[elementCount];

        mLayer->meshElementCount = elementCount;

    }



    const float texX = 1.0f / float(mLayer->width);

    const float texY = 1.0f / float(mLayer->height);

    const float height = mLayer->layer.getHeight();



    TextureVertex* mesh = mLayer->mesh;

    uint16_t* indices = mLayer->meshIndices;



    for (size_t i = 0; i < count; i++) {

        const android::Rect* r = &rects[i];



        const float u1 = r->left * texX;

        const float v1 = (height - r->top) * texY;

        const float u2 = r->right * texX;

        const float v2 = (height - r->bottom) * texY;



        TextureVertex::set(mesh++, r->left, r->top, u1, v1);

        TextureVertex::set(mesh++, r->right, r->top, u2, v1);

        TextureVertex::set(mesh++, r->left, r->bottom, u1, v2);

        TextureVertex::set(mesh++, r->right, r->bottom, u2, v2);



        uint16_t quad = i * 4;

        int index = i * 6;

        indices[index    ] = quad;       // top-left

        indices[index + 1] = quad + 1;   // top-right

        indices[index + 2] = quad + 2;   // bottom-left

        indices[index + 3] = quad + 2;   // bottom-left

        indices[index + 4] = quad + 1;   // top-right

        indices[index + 5] = quad + 3;   // bottom-right

    }

#endif

}



///////////////////////////////////////////////////////////////////////////////

// Layers management

///////////////////////////////////////////////////////////////////////////////



Layer* LayerRenderer::createLayer(uint32_t width, uint32_t height, bool isOpaque) {

libs/hwui/LayerRenderer.h

+5 −0
Original line number Diff line number Diff line
@@ -49,12 +49,17 @@ public: 
    void prepare(bool opaque);

    void finish();



    bool hasLayer();

    Region* getRegion();



    static Layer* createLayer(uint32_t width, uint32_t height, bool isOpaque = false);

    static bool resizeLayer(Layer* layer, uint32_t width, uint32_t height);

    static void destroyLayer(Layer* layer);

    static void destroyLayerDeferred(Layer* layer);



private:

    void generateMesh();



    Layer* mLayer;

    GLuint mPreviousFbo;

libs/hwui/OpenGLRenderer.cpp

+40 −15
Original line number Diff line number Diff line
@@ -615,6 +615,7 @@ void OpenGLRenderer::composeLayerRegion(Layer* layer, const Rect& rect) { 
        const float alpha = layer->alpha / 255.0f;

        const float texX = 1.0f / float(layer->width);

        const float texY = 1.0f / float(layer->height);

        const float height = rect.getHeight();



        TextureVertex* mesh = mCaches.getRegionMesh();

        GLsizei numQuads = 0;
@@ -636,9 +637,9 @@ void OpenGLRenderer::composeLayerRegion(Layer* layer, const Rect& rect) { 
            const android::Rect* r = &rects[i];



            const float u1 = r->left * texX;

            const float v1 = (rect.getHeight() - r->top) * texY;

            const float v1 = (height - r->top) * texY;

            const float u2 = r->right * texX;

            const float v2 = (rect.getHeight() - r->bottom) * texY;

            const float v2 = (height - r->bottom) * texY;



            // TODO: Reject quads outside of the clip

            TextureVertex::set(mesh++, r->left, r->top, u1, v1);
@@ -694,10 +695,10 @@ void OpenGLRenderer::composeLayerRegion(Layer* layer, const Rect& rect) { 
void OpenGLRenderer::dirtyLayer(const float left, const float top,

        const float right, const float bottom, const mat4 transform) {

#if RENDER_LAYERS_AS_REGIONS

    if ((mSnapshot->flags & Snapshot::kFlagFboTarget) && mSnapshot->region) {

    if (hasLayer()) {

        Rect bounds(left, top, right, bottom);

        transform.mapRect(bounds);

        dirtyLayerUnchecked(bounds, mSnapshot->region);

        dirtyLayerUnchecked(bounds, getRegion());

    }

#endif

}
@@ -705,9 +706,9 @@ void OpenGLRenderer::dirtyLayer(const float left, const float top, 
void OpenGLRenderer::dirtyLayer(const float left, const float top,

        const float right, const float bottom) {

#if RENDER_LAYERS_AS_REGIONS

    if ((mSnapshot->flags & Snapshot::kFlagFboTarget) && mSnapshot->region) {

    if (hasLayer()) {

        Rect bounds(left, top, right, bottom);

        dirtyLayerUnchecked(bounds, mSnapshot->region);

        dirtyLayerUnchecked(bounds, getRegion());

    }

#endif

}
@@ -1419,24 +1420,20 @@ void OpenGLRenderer::drawText(const char* text, int bytesCount, int count, 
    Rect bounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);



#if RENDER_LAYERS_AS_REGIONS

    bool hasLayer = (mSnapshot->flags & Snapshot::kFlagFboTarget) && mSnapshot->region;

    bool hasActiveLayer = hasLayer();

#else

    bool hasLayer = false;

    bool hasActiveLayer = false;

#endif



    mCaches.unbindMeshBuffer();

    if (fontRenderer.renderText(paint, clip, text, 0, bytesCount, count, x, y,

            hasLayer ? &bounds : NULL)) {

            hasActiveLayer ? &bounds : NULL)) {

#if RENDER_LAYERS_AS_REGIONS

        if (hasLayer) {

        if (hasActiveLayer) {

            if (!pureTranslate) {

                mSnapshot->transform->mapRect(bounds);

            }

            bounds.intersect(*mSnapshot->clipRect);

            bounds.snapToPixelBoundaries();



            android::Rect dirty(bounds.left, bounds.top, bounds.right, bounds.bottom);

            mSnapshot->region->orSelf(dirty);

            dirtyLayerUnchecked(bounds, getRegion());

        }

#endif

    }
@@ -1501,8 +1498,36 @@ void OpenGLRenderer::drawLayer(Layer* layer, float x, float y, SkPaint* paint) { 
    layer->alpha = alpha;

    layer->mode = mode;





#if RENDER_LAYERS_AS_REGIONS

    if (layer->region.isRect()) {

        const Rect r(x, y, x + layer->layer.getWidth(), y + layer->layer.getHeight());

        composeLayerRect(layer, r);

    } else if (!layer->region.isEmpty() && layer->mesh) {

        const Rect& rect = layer->layer;



        setupDraw();

        setupDrawWithTexture();

        setupDrawColor(alpha, alpha, alpha, alpha);

        setupDrawColorFilter();

        setupDrawBlending(layer->blend || layer->alpha < 255, layer->mode, false);

        setupDrawProgram();

        setupDrawDirtyRegionsDisabled();

        setupDrawPureColorUniforms();

        setupDrawColorFilterUniforms();

        setupDrawTexture(layer->texture);

        setupDrawModelViewTranslate(rect.left, rect.top, rect.right, rect.bottom);

        setupDrawMesh(&layer->mesh[0].position[0], &layer->mesh[0].texture[0]);



        glDrawElements(GL_TRIANGLES, layer->meshElementCount,

                GL_UNSIGNED_SHORT, layer->meshIndices);



        finishDrawTexture();

    }

#else

    const Rect r(x, y, x + layer->layer.getWidth(), y + layer->layer.getHeight());

    composeLayerRect(layer, r);

#endif

}



///////////////////////////////////////////////////////////////////////////////

libs/hwui/OpenGLRenderer.h

+26 −8
Original line number Diff line number Diff line
@@ -133,19 +133,24 @@ protected: 
    virtual void composeLayer(sp<Snapshot> current, sp<Snapshot> previous);



    /**

     * Mark the layer as dirty at the specified coordinates. The coordinates

     * are transformed with the supplied matrix.

     * Marks the specified region as dirty at the specified bounds.

     */

    virtual void dirtyLayer(const float left, const float top,

            const float right, const float bottom, const mat4 transform);

    void dirtyLayerUnchecked(Rect& bounds, Region* region);



    /**

     * Mark the layer as dirty at the specified coordinates.

     * Returns the current snapshot.

     */

    virtual void dirtyLayer(const float left, const float top,

            const float right, const float bottom);

    sp<Snapshot> getSnapshot() {

        return mSnapshot;

    }



    void dirtyLayerUnchecked(Rect& bounds, Region* region);

    virtual Region* getRegion() {

        return mSnapshot->region;

    }



    virtual bool hasLayer() {

        return (mSnapshot->flags & Snapshot::kFlagFboTarget) && mSnapshot->region;

    }



private:

    /**
@@ -224,6 +229,19 @@ private: 
     */

    void clearLayerRegions();



    /**

     * Mark the layer as dirty at the specified coordinates. The coordinates

     * are transformed with the supplied matrix.

     */

    void dirtyLayer(const float left, const float top,

            const float right, const float bottom, const mat4 transform);



    /**

     * Mark the layer as dirty at the specified coordinates.

     */

    void dirtyLayer(const float left, const float top,

            const float right, const float bottom);



    /**

     * Draws a colored rectangle with the specified color. The specified coordinates

     * are transformed by the current snapshot's transform matrix.