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

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

Continue cleanup refactoring in OpenGLRenderer. 

Methods that still need refactoring:
    - drawLines
    - composeLayerRegion

Change-Id: If546641adf598d49c330988803667264fda50ac2
parent fa7952db

libs/hwui/OpenGLRenderer.cpp

+81 −155
Original line number Diff line number Diff line
@@ -856,6 +856,16 @@ void OpenGLRenderer::setupDrawColor(int color) { 
    mSetShaderColor = mDescription.setColor(mColorR, mColorG, mColorB, mColorA);

}



void OpenGLRenderer::setupDrawAlpha8Color(int color, int alpha) {

    mColorA = alpha / 255.0f;

    const float a = mColorA / 255.0f;

    mColorR = a * ((color >> 16) & 0xFF);

    mColorG = a * ((color >>  8) & 0xFF);

    mColorB = a * ((color      ) & 0xFF);

    mColorSet = true;

    mSetShaderColor = mDescription.setAlpha8Color(mColorR, mColorG, mColorB, mColorA);

}



void OpenGLRenderer::setupDrawColor(float r, float g, float b, float a) {

    mColorA = a;

    mColorR = r;
@@ -865,6 +875,15 @@ void OpenGLRenderer::setupDrawColor(float r, float g, float b, float a) { 
    mSetShaderColor = mDescription.setColor(r, g, b, a);

}



void OpenGLRenderer::setupDrawAlpha8Color(float r, float g, float b, float a) {

    mColorA = a;

    mColorR = r;

    mColorG = g;

    mColorB = b;

    mColorSet = true;

    mSetShaderColor = mDescription.setAlpha8Color(r, g, b, a);

}



void OpenGLRenderer::setupDrawShader() {

    if (mShader) {

        mShader->describe(mDescription, mCaches.extensions);
@@ -912,15 +931,18 @@ void OpenGLRenderer::setupDrawModelView(float left, float top, float right, floa 
    if (!ignoreModelView) {

        mModelView.loadTranslate(left, top, 0.0f);

        mModelView.scale(right - left, bottom - top, 1.0f);

    } else {

        mModelView.loadIdentity();

    }

    bool dirty = right - left > 0.0f && bottom - top > 0.0f;

    if (!ignoreTransform) {

        mCaches.currentProgram->set(mOrthoMatrix, mModelView, *mSnapshot->transform);

            if (mTrackDirtyRegions) dirtyLayer(left, top, right, bottom, *mSnapshot->transform);

        } else {

            mCaches.currentProgram->set(mOrthoMatrix, mModelView, mIdentity);

            if (mTrackDirtyRegions) dirtyLayer(left, top, right, bottom);

        if (mTrackDirtyRegions && dirty) {

            dirtyLayer(left, top, right, bottom, *mSnapshot->transform);

        }

    } else {

        mModelView.loadIdentity();

        mCaches.currentProgram->set(mOrthoMatrix, mModelView, mIdentity);

        if (mTrackDirtyRegions && dirty) dirtyLayer(left, top, right, bottom);

    }

}
@@ -930,9 +952,9 @@ void OpenGLRenderer::setupDrawColorUniforms() { 
    }

}



void OpenGLRenderer::setupDrawColorAlphaUniforms() {

void OpenGLRenderer::setupDrawPureColorUniforms() {

    if (mSetShaderColor) {

        mCaches.currentProgram->setColor(mColorA, mColorA, mColorA, mColorA);

        mCaches.currentProgram->setColor(mColorR, mColorG, mColorB, mColorA);

    }

}
@@ -1000,7 +1022,7 @@ void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint 
        return;

    }



    glActiveTexture(GL_TEXTURE0);

    glActiveTexture(gTextureUnits[0]);

    Texture* texture = mCaches.textureCache.get(bitmap);

    if (!texture) return;

    const AutoTexture autoCleanup(texture);
@@ -1017,7 +1039,7 @@ void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* pai 
        return;

    }



    glActiveTexture(GL_TEXTURE0);

    glActiveTexture(gTextureUnits[0]);

    Texture* texture = mCaches.textureCache.get(bitmap);

    if (!texture) return;

    const AutoTexture autoCleanup(texture);
@@ -1325,48 +1347,60 @@ void OpenGLRenderer::drawText(const char* text, int bytesCount, int count, 
        y = (int) floorf(y + mSnapshot->transform->getTranslateY() + 0.5f);

    }



    int alpha;

    SkXfermode::Mode mode;

    getAlphaAndMode(paint, &alpha, &mode);



    uint32_t color = paint->getColor();

    const GLfloat a = alpha / 255.0f;

    const GLfloat r = a * ((color >> 16) & 0xFF) / 255.0f;

    const GLfloat g = a * ((color >>  8) & 0xFF) / 255.0f;

    const GLfloat b = a * ((color      ) & 0xFF) / 255.0f;



    FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer(paint);

    fontRenderer.setFont(paint, SkTypeface::UniqueID(paint->getTypeface()),

            paint->getTextSize());



    setupDraw();

    int alpha;

    SkXfermode::Mode mode;

    getAlphaAndMode(paint, &alpha, &mode);



    if (mHasShadow) {

        glActiveTexture(gTextureUnits[0]);

        mCaches.dropShadowCache.setFontRenderer(fontRenderer);

        const ShadowTexture* shadow = mCaches.dropShadowCache.get(paint, text, bytesCount,

                count, mShadowRadius);

        const AutoTexture autoCleanup(shadow);



        setupShadow(shadow, x, y, mode, a, pureTranslate);

        const float sx = x - shadow->left + mShadowDx;

        const float sy = y - shadow->top + mShadowDy;



        const int shadowAlpha = ((mShadowColor >> 24) & 0xFF);



        glActiveTexture(gTextureUnits[0]);

        setupDraw();

        setupDrawWithTexture(true);

        setupDrawAlpha8Color(mShadowColor, shadowAlpha < 255 ? shadowAlpha : alpha);

        setupDrawBlending(true, mode);

        setupDrawProgram();

        setupDrawModelView(sx, sy, sx + shadow->width, sy + shadow->height, pureTranslate);

        setupDrawTexture(shadow->id);

        setupDrawPureColorUniforms();

        setupDrawMesh(NULL, (GLvoid*) gMeshTextureOffset);



        // Draw the mesh

        glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);

        glDisableVertexAttribArray(mCaches.currentProgram->getAttrib("texCoords"));

        finishDrawTexture();

    }



    GLuint textureUnit = 0;

    glActiveTexture(gTextureUnits[textureUnit]);



    // Pick the appropriate texture filtering

    bool linearFilter = mSnapshot->transform->changesBounds();

    if (pureTranslate && !linearFilter) {

        linearFilter = fabs(y - (int) y) > 0.0f || fabs(x - (int) x) > 0.0f;

    }



    // Dimensions are set to (0,0), the layer (if any) won't be dirtied

    setupTextureAlpha8(fontRenderer.getTexture(linearFilter), 0, 0, textureUnit,

            x, y, r, g, b, a, mode, false, true, NULL, NULL, 0, pureTranslate);

    glActiveTexture(gTextureUnits[0]);

    setupDraw();

    setupDrawDirtyRegionsDisabled();

    setupDrawWithTexture(true);

    setupDrawAlpha8Color(paint->getColor(), alpha);

    setupDrawColorFilter();

    setupDrawShader();

    setupDrawBlending(true, mode);

    setupDrawProgram();

    setupDrawModelView(x, y, x, y, pureTranslate, true);

    setupDrawTexture(fontRenderer.getTexture(linearFilter));

    setupDrawPureColorUniforms();

    setupDrawColorFilterUniforms();

    setupDrawShaderUniforms(pureTranslate);



    const Rect* clip = pureTranslate ? mSnapshot->clipRect : &mSnapshot->getLocalClip();

    Rect bounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);
@@ -1421,19 +1455,23 @@ void OpenGLRenderer::drawPath(SkPath* path, SkPaint* paint) { 
    SkXfermode::Mode mode;

    getAlphaAndMode(paint, &alpha, &mode);



    uint32_t color = paint->getColor();

    const GLfloat a = alpha / 255.0f;

    const GLfloat r = a * ((color >> 16) & 0xFF) / 255.0f;

    const GLfloat g = a * ((color >>  8) & 0xFF) / 255.0f;

    const GLfloat b = a * ((color      ) & 0xFF) / 255.0f;



    setupTextureAlpha8(texture, textureUnit, x, y, r, g, b, a, mode, true, true);



    setupDraw();

    setupDrawWithTexture(true);

    setupDrawAlpha8Color(paint->getColor(), alpha);

    setupDrawColorFilter();

    setupDrawShader();

    setupDrawBlending(true, mode);

    setupDrawProgram();

    setupDrawModelView(x, y, x + texture->width, y + texture->height);

    setupDrawTexture(texture->id);

    setupDrawPureColorUniforms();

    setupDrawColorFilterUniforms();

    setupDrawShaderUniforms();

    setupDrawMesh(NULL, (GLvoid*) gMeshTextureOffset);



    // Draw the mesh

    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);

    glDisableVertexAttribArray(mCaches.currentProgram->getAttrib("texCoords"));



    finishDrawTexture();

}



///////////////////////////////////////////////////////////////////////////////
@@ -1483,118 +1521,6 @@ void OpenGLRenderer::setupShadow(float radius, float dx, float dy, int color) { 
// Drawing implementation

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



void OpenGLRenderer::setupShadow(const ShadowTexture* texture, float x, float y,

        SkXfermode::Mode mode, float alpha, bool ignoreTransforms) {

    const float sx = x - texture->left + mShadowDx;

    const float sy = y - texture->top + mShadowDy;



    const int shadowAlpha = ((mShadowColor >> 24) & 0xFF);

    const GLfloat a = shadowAlpha < 255 ? shadowAlpha / 255.0f : alpha;

    const GLfloat r = a * ((mShadowColor >> 16) & 0xFF) / 255.0f;

    const GLfloat g = a * ((mShadowColor >>  8) & 0xFF) / 255.0f;

    const GLfloat b = a * ((mShadowColor      ) & 0xFF) / 255.0f;



    GLuint textureUnit = 0;

    setupTextureAlpha8(texture->id, texture->width, texture->height, textureUnit,

            sx, sy, r, g, b, a, mode, true, false,

            (GLvoid*) 0, (GLvoid*) gMeshTextureOffset, 0, ignoreTransforms);

}



void OpenGLRenderer::setupTextureAlpha8(const Texture* texture, GLuint& textureUnit,

        float x, float y, float r, float g, float b, float a, SkXfermode::Mode mode,

        bool transforms, bool applyFilters) {

    setupTextureAlpha8(texture->id, texture->width, texture->height, textureUnit,

            x, y, r, g, b, a, mode, transforms, applyFilters,

            (GLvoid*) 0, (GLvoid*) gMeshTextureOffset);

}



void OpenGLRenderer::setupTextureAlpha8(GLuint texture, uint32_t width, uint32_t height,

        GLuint& textureUnit, float x, float y, float r, float g, float b, float a,

        SkXfermode::Mode mode, bool transforms, bool applyFilters) {

    setupTextureAlpha8(texture, width, height, textureUnit, x, y, r, g, b, a, mode,

            transforms, applyFilters, (GLvoid*) 0, (GLvoid*) gMeshTextureOffset);

}



void OpenGLRenderer::setupTextureAlpha8(GLuint texture, uint32_t width, uint32_t height,

        GLuint& textureUnit, float x, float y, float r, float g, float b, float a,

        SkXfermode::Mode mode, bool transforms, bool applyFilters,

        GLvoid* vertices, GLvoid* texCoords, GLuint vbo, bool ignoreTransform) {

     // Describe the required shaders

     ProgramDescription description;

     description.hasTexture = true;

     description.hasAlpha8Texture = true;

     const bool setColor = description.setAlpha8Color(r, g, b, a);



     if (applyFilters) {

         if (mShader) {

             mShader->describe(description, mCaches.extensions);

         }

         if (mColorFilter) {

             mColorFilter->describe(description, mCaches.extensions);

         }

     }



     // Setup the blending mode

     chooseBlending(true, mode, description);



     // Build and use the appropriate shader

     useProgram(mCaches.programCache.get(description));



     bindTexture(texture);

     glUniform1i(mCaches.currentProgram->getUniform("sampler"), textureUnit);



     int texCoordsSlot = mCaches.currentProgram->getAttrib("texCoords");

     glEnableVertexAttribArray(texCoordsSlot);



     if (texCoords) {

         // Setup attributes

         if (!vertices) {

             mCaches.bindMeshBuffer(vbo == 0 ? mCaches.meshBuffer : vbo);

         } else {

             mCaches.unbindMeshBuffer();

         }

         glVertexAttribPointer(mCaches.currentProgram->position, 2, GL_FLOAT, GL_FALSE,

                 gMeshStride, vertices);

         glVertexAttribPointer(texCoordsSlot, 2, GL_FLOAT, GL_FALSE, gMeshStride, texCoords);

     }



     // Setup uniforms

     if (transforms) {

         mModelView.loadTranslate(x, y, 0.0f);

         mModelView.scale(width, height, 1.0f);

     } else {

         mModelView.loadIdentity();

     }



     mat4 t;

     if (!ignoreTransform) {

         t.load(*mSnapshot->transform);

     }



     mCaches.currentProgram->set(mOrthoMatrix, mModelView, t);

     if (width > 0 && height > 0) {

         dirtyLayer(x, y, x + width, y + height, t);

     }



     if (setColor) {

         mCaches.currentProgram->setColor(r, g, b, a);

     }



     textureUnit++;

     if (applyFilters) {

         // Setup attributes and uniforms required by the shaders

         if (mShader) {

             if (ignoreTransform) {

                 mModelView.loadInverse(*mSnapshot->transform);

             }

             mShader->setupProgram(mCaches.currentProgram, mModelView, *mSnapshot, &textureUnit);

         }

         if (mColorFilter) {

             mColorFilter->setupProgram(mCaches.currentProgram);

         }

     }

}



// Same values used by Skia

#define kStdStrikeThru_Offset   (-6.0f / 21.0f)

#define kStdUnderline_Offset    (1.0f / 9.0f)
@@ -1727,7 +1653,7 @@ void OpenGLRenderer::drawTextureMesh(float left, float top, float right, float b 
    } else {

        setupDrawModelViewTranslate(left, top, right, bottom, ignoreTransform);

    }

    setupDrawColorAlphaUniforms();

    setupDrawPureColorUniforms();

    setupDrawColorFilterUniforms();

    setupDrawTexture(texture);

    setupDrawMesh(vertices, texCoords, vbo);

libs/hwui/OpenGLRenderer.h

+3 −68
Original line number Diff line number Diff line
@@ -278,73 +278,6 @@ private: 
            bool swapSrcDst = false, bool ignoreTransform = false, GLuint vbo = 0,

            bool ignoreScale = false, bool dirty = true);



    /**

     * Prepares the renderer to draw the specified shadow. The active texture

     * unit must be 0 and the other units must be unbound.

     *

     * @param texture The shadow texture

     * @param x The x coordinate of the shadow

     * @param y The y coordinate of the shadow

     * @param mode The blending mode

     * @param alpha The alpha value

     * @param ignoreTransforms True if the coordinates are already in screen space

     */

    void setupShadow(const ShadowTexture* texture, float x, float y, SkXfermode::Mode mode,

            float alpha, bool ignoreTransforms = false);



    /**

     * Prepares the renderer to draw the specified Alpha8 texture as a rectangle.

     *

     * @param texture The texture to render with

     * @param textureUnit The texture unit to use, may be modified

     * @param x The x coordinate of the rectangle to draw

     * @param y The y coordinate of the rectangle to draw

     * @param r The red component of the color

     * @param g The green component of the color

     * @param b The blue component of the color

     * @param a The alpha component of the color

     * @param mode The blending mode

     * @param transforms True if the matrix passed to the shader should be multiplied

     *        by the model-view matrix

     * @param applyFilters Whether or not to take color filters and

     *        shaders into account

     */

    void setupTextureAlpha8(const Texture* texture, GLuint& textureUnit, float x, float y,

            float r, float g, float b, float a, SkXfermode::Mode mode, bool transforms,

            bool applyFilters);



    /**

     * Prepares the renderer to draw the specified Alpha8 texture as a rectangle.

     *

     * @param texture The texture to render with

     * @param width The width of the texture

     * @param height The height of the texture

     * @param textureUnit The texture unit to use, may be modified

     * @param x The x coordinate of the rectangle to draw

     * @param y The y coordinate of the rectangle to draw

     * @param r The red component of the color

     * @param g The green component of the color

     * @param b The blue component of the color

     * @param a The alpha component of the color

     * @param mode The blending mode

     * @param transforms True if the matrix passed to the shader should be multiplied

     *        by the model-view matrix

     * @param applyFilters Whether or not to take color filters and

     *        shaders into account

     */

    void setupTextureAlpha8(GLuint texture, uint32_t width, uint32_t height,

            GLuint& textureUnit, float x, float y, float r, float g, float b, float a,

            SkXfermode::Mode mode, bool transforms, bool applyFilters);



    /**

     * Same as above setupTextureAlpha8() but specifies the mesh's vertices

     * and texCoords pointers. The pointers become offsets when a VBO is bound.

     */

    void setupTextureAlpha8(GLuint texture, uint32_t width, uint32_t height,

            GLuint& textureUnit, float x, float y, float r, float g, float b, float a,

            SkXfermode::Mode mode, bool transforms, bool applyFilters,

            GLvoid* vertices, GLvoid* texCoords, GLuint vbo = 0, bool ignoreTransform = false);



    /**

     * Draws text underline and strike-through if needed.

     *
@@ -430,6 +363,8 @@ private: 
    void setupDrawWithTexture(bool isAlpha8 = false);

    void setupDrawColor(int color);

    void setupDrawColor(float r, float g, float b, float a);

    void setupDrawAlpha8Color(int color, int alpha);

    void setupDrawAlpha8Color(float r, float g, float b, float a);

    void setupDrawShader();

    void setupDrawColorFilter();

    void setupDrawBlending(SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode,
@@ -443,7 +378,7 @@ private: 
    void setupDrawModelViewTranslate(float left, float top, float right, float bottom,

            bool ignoreTransform = false);

    void setupDrawColorUniforms();

    void setupDrawColorAlphaUniforms();

    void setupDrawPureColorUniforms();

    void setupDrawShaderUniforms(bool ignoreTransform = false);

    void setupDrawColorFilterUniforms();

    void setupDrawSimpleMesh();