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

Commit 523735d8 authored by Chris Craik's avatar Chris Craik Committed by Android (Google) Code Review
Browse files

Merge "Delete pre-glop path"

parents dda35c37 82840735

libs/hwui/FontRenderer.cpp

+5 −75
Original line number Diff line number Diff line
@@ -46,51 +46,11 @@ namespace uirenderer { 
// blur inputs smaller than this constant will bypass renderscript

#define RS_MIN_INPUT_CUTOFF 10000



#define USE_GLOPS true



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

// TextSetupFunctor

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

void TextSetupFunctor::setup(GLenum glyphFormat) {

    renderer->setupDraw();

    renderer->setupDrawTextGamma(paint);

    renderer->setupDrawDirtyRegionsDisabled();

    renderer->setupDrawWithTexture(glyphFormat == GL_ALPHA);

    switch (glyphFormat) {

        case GL_ALPHA: {

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

            break;

        }

        case GL_RGBA: {

            float floatAlpha = alpha / 255.0f;

            renderer->setupDrawColor(floatAlpha, floatAlpha, floatAlpha, floatAlpha);

            break;

        }

        default: {

#if DEBUG_FONT_RENDERER

            ALOGD("TextSetupFunctor: called with unknown glyph format %x", glyphFormat);

#endif

            break;

        }

    }

    renderer->setupDrawColorFilter(paint->getColorFilter());

    renderer->setupDrawShader(paint->getShader());

    renderer->setupDrawBlending(paint);

    renderer->setupDrawProgram();

    renderer->setupDrawModelView(kModelViewMode_Translate, false,

            0.0f, 0.0f, 0.0f, 0.0f, pureTranslate);

    // Calling setupDrawTexture with the name 0 will enable the

    // uv attributes and increase the texture unit count

    // texture binding will be performed by the font renderer as

    // needed

    renderer->setupDrawTexture(0);

    renderer->setupDrawPureColorUniforms();

    renderer->setupDrawColorFilterUniforms(paint->getColorFilter());

    renderer->setupDrawShaderUniforms(paint->getShader(), pureTranslate);

    renderer->setupDrawTextGammaUniforms();

}



void TextSetupFunctor::draw(CacheTexture& texture, bool linearFiltering) {



void TextDrawFunctor::draw(CacheTexture& texture, bool linearFiltering) {

    int textureFillFlags = static_cast<int>(texture.getFormat() == GL_ALPHA

            ? TextureFillFlags::kIsAlphaMaskTexture : TextureFillFlags::kNone);

    if (linearFiltering) {
@@ -508,11 +468,6 @@ void FontRenderer::checkTextureUpdate() { 
void FontRenderer::issueDrawCommand(Vector<CacheTexture*>& cacheTextures) {

    if (!mFunctor) return;



#if !USE_GLOPS

    Caches& caches = mFunctor->renderer->getCaches();

    RenderState& renderState = mFunctor->renderer->renderState();

#endif



    bool first = true;

    bool forceRebind = false;

    for (uint32_t i = 0; i < cacheTextures.size(); i++) {
@@ -520,37 +475,12 @@ void FontRenderer::issueDrawCommand(Vector<CacheTexture*>& cacheTextures) { 
        if (texture->canDraw()) {

            if (first) {

                checkTextureUpdate();

#if !USE_GLOPS

                mFunctor->setup(texture->getFormat());



                renderState.meshState().bindQuadIndicesBuffer();



                // If returns true, a VBO was bound and we must

                // rebind our vertex attrib pointers even if

                // they have the same values as the current pointers

                forceRebind = renderState.meshState().unbindMeshBuffer();



                caches.textureState().activateTexture(0);

#endif

                first = false;

                mDrawn = true;

            }

#if USE_GLOPS

            mFunctor->draw(*texture, mLinearFiltering);

#endif



#if !USE_GLOPS

            caches.textureState().bindTexture(texture->getTextureId());

            texture->setLinearFiltering(mLinearFiltering);



            TextureVertex* mesh = texture->mesh();

            MeshState& meshState = renderState.meshState();

            meshState.bindPositionVertexPointer(forceRebind, &mesh[0].x);

            meshState.bindTexCoordsVertexPointer(forceRebind, &mesh[0].u);

            mFunctor->draw(*texture, mLinearFiltering);



            glDrawElements(GL_TRIANGLES, texture->meshElementCount(),

                    GL_UNSIGNED_SHORT, texture->indices());

#endif

            texture->resetMesh();

            forceRebind = false;

        }
@@ -689,7 +619,7 @@ FontRenderer::DropShadow FontRenderer::renderDropShadow(const SkPaint* paint, co 
    return image;

}



void FontRenderer::initRender(const Rect* clip, Rect* bounds, TextSetupFunctor* functor) {

void FontRenderer::initRender(const Rect* clip, Rect* bounds, TextDrawFunctor* functor) {

    checkInit();



    mDrawn = false;
@@ -717,7 +647,7 @@ void FontRenderer::endPrecaching() { 


bool FontRenderer::renderPosText(const SkPaint* paint, const Rect* clip, const char *text,

        uint32_t startIndex, uint32_t len, int numGlyphs, int x, int y,

        const float* positions, Rect* bounds, TextSetupFunctor* functor, bool forceFinish) {

        const float* positions, Rect* bounds, TextDrawFunctor* functor, bool forceFinish) {

    if (!mCurrentFont) {

        ALOGE("No font set");

        return false;
@@ -735,7 +665,7 @@ bool FontRenderer::renderPosText(const SkPaint* paint, const Rect* clip, const c 


bool FontRenderer::renderTextOnPath(const SkPaint* paint, const Rect* clip, const char *text,

        uint32_t startIndex, uint32_t len, int numGlyphs, const SkPath* path,

        float hOffset, float vOffset, Rect* bounds, TextSetupFunctor* functor) {

        float hOffset, float vOffset, Rect* bounds, TextDrawFunctor* functor) {

    if (!mCurrentFont) {

        ALOGE("No font set");

        return false;

libs/hwui/FontRenderer.h

+6 −8
Original line number Diff line number Diff line
@@ -46,9 +46,9 @@ namespace uirenderer { 


class OpenGLRenderer;



class TextSetupFunctor {

class TextDrawFunctor {

public:

    TextSetupFunctor(OpenGLRenderer* renderer, float x, float y, bool pureTranslate,

    TextDrawFunctor(OpenGLRenderer* renderer, float x, float y, bool pureTranslate,

            int alpha, SkXfermode::Mode mode, const SkPaint* paint)

        : renderer(renderer)

        , x(x)
@@ -59,8 +59,6 @@ public: 
        , paint(paint) {

    }



    void setup(GLenum glyphFormat);



    void draw(CacheTexture& texture, bool linearFiltering);



    OpenGLRenderer* renderer;
@@ -92,12 +90,12 @@ public: 
    // bounds is an out parameter

    bool renderPosText(const SkPaint* paint, const Rect* clip, const char *text,

            uint32_t startIndex, uint32_t len, int numGlyphs, int x, int y, const float* positions,

            Rect* bounds, TextSetupFunctor* functor, bool forceFinish = true);

            Rect* bounds, TextDrawFunctor* functor, bool forceFinish = true);



    // bounds is an out parameter

    bool renderTextOnPath(const SkPaint* paint, const Rect* clip, const char *text,

            uint32_t startIndex, uint32_t len, int numGlyphs, const SkPath* path,

            float hOffset, float vOffset, Rect* bounds, TextSetupFunctor* functor);

            float hOffset, float vOffset, Rect* bounds, TextDrawFunctor* functor);



    struct DropShadow {

        uint32_t width;
@@ -135,7 +133,7 @@ private: 
    void flushAllAndInvalidate();



    void checkInit();

    void initRender(const Rect* clip, Rect* bounds, TextSetupFunctor* functor);

    void initRender(const Rect* clip, Rect* bounds, TextDrawFunctor* functor);

    void finishRender();



    void issueDrawCommand(Vector<CacheTexture*>& cacheTextures);
@@ -176,7 +174,7 @@ private: 


    bool mUploadTexture;



    TextSetupFunctor* mFunctor;

    TextDrawFunctor* mFunctor;

    const Rect* mClip;

    Rect* mBounds;

    bool mDrawn;

libs/hwui/GlopBuilder.cpp

+6 −0
Original line number Diff line number Diff line
@@ -586,6 +586,12 @@ void GlopBuilder::build() { 
    mDescription.hasColors = mOutGlop->mesh.vertices.attribFlags & VertexAttribFlags::kColor;

    mDescription.hasVertexAlpha = mOutGlop->mesh.vertices.attribFlags & VertexAttribFlags::kAlpha;



    // Enable debug highlight when what we're about to draw is tested against

    // the stencil buffer and if stencil highlight debugging is on

    mDescription.hasDebugHighlight = !mCaches.debugOverdraw

            && mCaches.debugStencilClip == Caches::kStencilShowHighlight

            && mRenderState.stencil().isTestEnabled();



    // serialize shader info into ShaderData

    GLuint textureUnit = mOutGlop->fill.texture.texture ? 1 : 0;

    SkiaShader::store(mCaches, mShader, mOutGlop->transform.modelView,

libs/hwui/OpenGLRenderer.cpp

+199 −1325

File changed.

Preview size limit exceeded, changes collapsed.

libs/hwui/OpenGLRenderer.h

+2 −171
Original line number Diff line number Diff line
@@ -65,7 +65,7 @@ class DeferredDisplayState; 
struct Glop;

class RenderState;

class RenderNode;

class TextSetupFunctor;

class TextDrawFunctor;

class VertexBuffer;



struct DrawModifiers {
@@ -726,15 +726,6 @@ private: 
     */

    void drawShape(float left, float top, PathTexture* texture, const SkPaint* paint);



    /**

     * Draws the specified texture as an alpha bitmap. Alpha bitmaps obey

     * different compositing rules.

     *

     * @param texture The texture to draw with

     * @param paint The paint to render with

     */

    void drawAlphaBitmap(Texture* texture, const SkPaint* paint);



    /**

     * Renders a strip of polygons with the specified paint, used for tessellated geometry.

     *
@@ -761,60 +752,6 @@ private: 
     */

    void drawConvexPath(const SkPath& path, const SkPaint* paint);



    /**

     * Draws a textured rectangle with the specified texture.

     *

     * @param texture The texture to use

     * @param paint The paint containing the alpha, blending mode, etc.

     */

    void drawTextureRect(Texture* texture, const SkPaint* paint);



    /**

     * Draws a textured mesh with the specified texture. If the indices are omitted,

     * the mesh is drawn as a simple quad. The mesh pointers become offsets when a

     * VBO is bound.

     *

     * @param left The left coordinate of the rectangle

     * @param top The top coordinate of the rectangle

     * @param right The right coordinate of the rectangle

     * @param bottom The bottom coordinate of the rectangle

     * @param texture The texture name to map onto the rectangle

     * @param paint The paint containing the alpha, blending mode, colorFilter, etc.

     * @param blend True if the texture contains an alpha channel

     * @param vertices The vertices that define the mesh

     * @param texCoords The texture coordinates of each vertex

     * @param elementsCount The number of elements in the mesh, required by indices

     * @param swapSrcDst Whether or not the src and dst blending operations should be swapped

     * @param ignoreTransform True if the current transform should be ignored

     * @param vbo The VBO used to draw the mesh

     * @param modelViewMode Defines whether the model view matrix should be scaled

     * @param dirty True if calling this method should dirty the current layer

     */

    void drawTextureMesh(float left, float top, float right, float bottom, GLuint texture,

            const SkPaint* paint, bool blend,

            GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount,

            bool swapSrcDst = false, bool ignoreTransform = false, GLuint vbo = 0,

            ModelViewMode modelViewMode = kModelViewMode_TranslateAndScale, bool dirty = true);



    void drawIndexedTextureMesh(float left, float top, float right, float bottom, GLuint texture,

            const SkPaint* paint, bool blend,

            GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount,

            bool swapSrcDst = false, bool ignoreTransform = false, GLuint vbo = 0,

            ModelViewMode modelViewMode = kModelViewMode_TranslateAndScale, bool dirty = true);



    void drawAlpha8TextureMesh(float left, float top, float right, float bottom,

            GLuint texture, const SkPaint* paint,

            GLvoid* vertices, GLvoid* texCoords, GLenum drawMode, GLsizei elementsCount,

            bool ignoreTransform, ModelViewMode modelViewMode = kModelViewMode_TranslateAndScale,

            bool dirty = true);



    /**

     * Draws the specified list of vertices as quads using indexed GL_TRIANGLES.

     * If the number of vertices to draw exceeds the number of indices we have

     * pre-allocated, this method will generate several glDrawElements() calls.

     */

    void issueIndexedQuadDraw(Vertex* mesh, GLsizei quadsCount);



    /**

     * Draws text underline and strike-through if needed.

     *
@@ -873,78 +810,6 @@ private: 
     */

    bool canSkipText(const SkPaint* paint) const;



    /**

     * Enable or disable blending as necessary. This function sets the appropriate

     * blend function based on the specified xfermode.

     */

    inline void chooseBlending(bool blend, SkXfermode::Mode mode, ProgramDescription& description,

            bool swapSrcDst = false);



    /**

     * Invoked before any drawing operation. This sets required state.

     */

    void setupDraw(bool clear = true);



    /**

     * Various methods to setup OpenGL rendering.

     */

    void setupDrawWithTexture(bool isAlpha8 = false);

    void setupDrawWithTextureAndColor(bool isAlpha8 = false);

    void setupDrawWithExternalTexture();

    void setupDrawNoTexture();

    void setupDrawVertexAlpha(bool useShadowAlphaInterp);

    void setupDrawColor(int color, int alpha);

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

    void setupDrawAlpha8Color(int color, int alpha);

    void setupDrawTextGamma(const SkPaint* paint);

    void setupDrawShader(const SkShader* shader);

    void setupDrawColorFilter(const SkColorFilter* filter);

    void setupDrawBlending(const Layer* layer, bool swapSrcDst = false);

    void setupDrawBlending(const SkPaint* paint, bool blend = true, bool swapSrcDst = false);

    void setupDrawProgram();

    void setupDrawDirtyRegionsDisabled();



    /**

     * Setup the current program matrices based upon the nature of the geometry.

     *

     * @param mode If kModelViewMode_Translate, the geometry must be translated by the left and top

     * parameters. If kModelViewMode_TranslateAndScale, the geometry that exists in the (0,0, 1,1)

     * space must be scaled up and translated to fill the quad provided in (l,t,r,b). These

     * transformations are stored in the modelView matrix and uploaded to the shader.

     *

     * @param offset Set to true if the the matrix should be fudged (translated) slightly to

     * disambiguate geometry pixel positioning. See Vertex::GeometryFudgeFactor().

     *

     * @param ignoreTransform Set to true if l,t,r,b coordinates already in layer space,

     * currentTransform() will be ignored. (e.g. when drawing clip in layer coordinates to stencil,

     * or when simple translation has been extracted)

     */

    void setupDrawModelView(ModelViewMode mode, bool offset,

            float left, float top, float right, float bottom, bool ignoreTransform = false);

    void setupDrawColorUniforms(bool hasShader);

    void setupDrawPureColorUniforms();



    /**

     * Setup uniforms for the current shader.

     *

     * @param shader SkShader on the current paint.

     *

     * @param ignoreTransform Set to true to ignore the transform in shader.

     */

    void setupDrawShaderUniforms(const SkShader* shader, bool ignoreTransform = false);

    void setupDrawColorFilterUniforms(const SkColorFilter* paint);

    void setupDrawSimpleMesh();

    void setupDrawTexture(GLuint texture);

    void setupDrawExternalTexture(GLuint texture);

    void setupDrawTextureTransform();

    void setupDrawTextureTransformUniforms(mat4& transform);

    void setupDrawTextGammaUniforms();

    void setupDrawMesh(const GLvoid* vertices, const GLvoid* texCoords = nullptr, GLuint vbo = 0);

    void setupDrawMesh(const GLvoid* vertices, const GLvoid* texCoords, const GLvoid* colors);

    void setupDrawMeshIndices(const GLvoid* vertices, const GLvoid* texCoords, GLuint vbo = 0);

    void setupDrawIndexedVertices(GLvoid* vertices);

    void accountForClear(SkXfermode::Mode mode);



    bool updateLayer(Layer* layer, bool inFrame);

    void updateLayers();

    void flushLayers();
@@ -993,22 +858,6 @@ private: 
    inline Snapshot* writableSnapshot() { return mState.writableSnapshot(); }

    inline const Snapshot* currentSnapshot() const { return mState.currentSnapshot(); }



    /**

     * Model-view matrix used to position/size objects

     *

     * Stores operation-local modifications to the draw matrix that aren't incorporated into the

     * currentTransform().

     *

     * If generated with kModelViewMode_Translate, mModelViewMatrix will reflect an x/y offset,

     * e.g. the offset in drawLayer(). If generated with kModelViewMode_TranslateAndScale,

     * mModelViewMatrix will reflect a translation and scale, e.g. the translation and scale

     * required to make VBO 0 (a rect of (0,0,1,1)) scaled to match the x,y offset, and width/height

     * of a bitmap.

     *

     * Used as input to SkiaShader transformation.

     */

    mat4 mModelViewMatrix;



    // State used to define the clipping region

    Rect mTilingClip;

    // Is the target render surface opaque
@@ -1016,9 +865,6 @@ private: 
    // Is a frame currently being rendered

    bool mFrameStarted;



    // Used to draw textured quads

    TextureVertex mMeshVertices[4];



    // Default UV mapper

    const UvMapper mUvMapper;
@@ -1031,21 +877,6 @@ private: 
    // List of layers to update at the beginning of a frame

    Vector< sp<Layer> > mLayerUpdates;



    // The following fields are used to setup drawing

    // Used to describe the shaders to generate

    ProgramDescription mDescription;

    // Color description

    bool mColorSet;

    FloatColor mColor;

    // Indicates that the shader should get a color

    bool mSetShaderColor;

    // Current texture unit

    GLuint mTextureUnit;

    // Track dirty regions, true by default

    bool mTrackDirtyRegions;

    // Indicate whether we are drawing an opaque frame

    bool mOpaqueFrame;



    // See PROPERTY_DISABLE_SCISSOR_OPTIMIZATION in

    // Properties.h

    bool mScissorOptimizationDisabled;
@@ -1070,7 +901,7 @@ private: 
    std::vector<std::unique_ptr<SkPath>> mTempPaths;



    friend class Layer;

    friend class TextSetupFunctor;

    friend class TextDrawFunctor;

    friend class DrawBitmapOp;

    friend class DrawPatchOp;