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
Loading
Loading
Loading
Loading
+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;
+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;
+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,
+199 −1325

File changed.

Preview size limit exceeded, changes collapsed.

+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;

Loading