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

Commit 7fbcc049 authored by Romain Guy's avatar Romain Guy
Browse files

Add support for paths. 

Rendering is implementing by rasterizing the paths into A8 textures.
This cna be extremely inefficient if the path changes often.

Change-Id: I609343f304ae38e0d319359403ee73b9b5b3c93a
parent bc9151bc

core/java/android/view/GLES20Canvas.java

+5 −2
Original line number Diff line number Diff line
@@ -350,7 +350,6 @@ class GLES20Canvas extends Canvas { 


    @Override

    public void setDrawFilter(DrawFilter filter) {

        // TODO: Implement PaintDrawFilter

        mFilter = filter;

    }
@@ -522,9 +521,13 @@ class GLES20Canvas extends Canvas { 


    @Override

    public void drawPath(Path path, Paint paint) {

        throw new UnsupportedOperationException();

        boolean hasModifier = setupModifiers(paint);

        nDrawPath(mRenderer, path.mNativePath, paint.mNativePaint);

        if (hasModifier) nResetModifiers(mRenderer);

    }



    private native void nDrawPath(int renderer, int path, int paint);



    @Override

    public void drawPicture(Picture picture) {

        throw new UnsupportedOperationException();

core/jni/android_view_GLES20Canvas.cpp

+6 −0
Original line number Diff line number Diff line
@@ -228,6 +228,11 @@ static void android_view_GLES20Canvas_drawRect(JNIEnv* env, jobject canvas, 
    renderer->drawRect(left, top, right, bottom, paint);

}



static void android_view_GLES20Canvas_drawPath(JNIEnv* env, jobject canvas,

        OpenGLRenderer* renderer, SkPath* path, SkPaint* paint) {

    renderer->drawPath(path, paint);

}



// ----------------------------------------------------------------------------

// Shaders and color filters

// ----------------------------------------------------------------------------
@@ -317,6 +322,7 @@ static JNINativeMethod gMethods[] = { 
    {   "nDrawPatch",         "(II[BFFFFI)V",    (void*) android_view_GLES20Canvas_drawPatch },

    {   "nDrawColor",         "(III)V",          (void*) android_view_GLES20Canvas_drawColor },

    {   "nDrawRect",          "(IFFFFI)V",       (void*) android_view_GLES20Canvas_drawRect },

    {   "nDrawPath",          "(III)V",          (void*) android_view_GLES20Canvas_drawPath },



    {   "nResetModifiers",    "(I)V",            (void*) android_view_GLES20Canvas_resetModifiers },

    {   "nSetupShader",       "(II)V",           (void*) android_view_GLES20Canvas_setupShader },

graphics/java/android/graphics/Path.java

+4 −1
Original line number Diff line number Diff line
@@ -593,5 +593,8 @@ public class Path { 
    private static native void native_transform(int nPath, int matrix);

    private static native void finalizer(int nPath);



    private final int mNativePath;

    /**

     * @hide

     */

    public final int mNativePath;

}

libs/hwui/Android.mk

+1 −0
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ LOCAL_SRC_FILES:= \ 
	OpenGLRenderer.cpp \

	Patch.cpp \

	PatchCache.cpp \

	PathCache.cpp \

	Program.cpp \

	ProgramCache.cpp \

	SkiaColorFilter.cpp \

libs/hwui/OpenGLRenderer.cpp

+78 −2
Original line number Diff line number Diff line
@@ -37,7 +37,8 @@ namespace uirenderer { 
///////////////////////////////////////////////////////////////////////////////



#define DEFAULT_TEXTURE_CACHE_SIZE 20.0f

#define DEFAULT_LAYER_CACHE_SIZE 10.0f

#define DEFAULT_LAYER_CACHE_SIZE 6.0f

#define DEFAULT_PATH_CACHE_SIZE 6.0f

#define DEFAULT_PATCH_CACHE_SIZE 100

#define DEFAULT_GRADIENT_CACHE_SIZE 0.5f
@@ -105,6 +106,7 @@ OpenGLRenderer::OpenGLRenderer(): 
        mTextureCache(MB(DEFAULT_TEXTURE_CACHE_SIZE)),

        mLayerCache(MB(DEFAULT_LAYER_CACHE_SIZE)),

        mGradientCache(MB(DEFAULT_GRADIENT_CACHE_SIZE)),

        mPathCache(MB(DEFAULT_PATH_CACHE_SIZE)),

        mPatchCache(DEFAULT_PATCH_CACHE_SIZE) {

    LOGD("Create OpenGLRenderer");
@@ -125,11 +127,18 @@ OpenGLRenderer::OpenGLRenderer(): 


    if (property_get(PROPERTY_GRADIENT_CACHE_SIZE, property, NULL) > 0) {

        LOGD("  Setting gradient cache size to %sMB", property);

        mLayerCache.setMaxSize(MB(atof(property)));

        mGradientCache.setMaxSize(MB(atof(property)));

    } else {

        LOGD("  Using default gradient cache size of %.2fMB", DEFAULT_GRADIENT_CACHE_SIZE);

    }



    if (property_get(PROPERTY_PATH_CACHE_SIZE, property, NULL) > 0) {

        LOGD("  Setting path cache size to %sMB", property);

        mPathCache.setMaxSize(MB(atof(property)));

    } else {

        LOGD("  Using default path cache size of %.2fMB", DEFAULT_PATH_CACHE_SIZE);

    }



    mCurrentProgram = NULL;

    mShader = NULL;

    mColorFilter = NULL;
@@ -597,6 +606,73 @@ void OpenGLRenderer::drawText(const char* text, int bytesCount, int count, 
    glDisableVertexAttribArray(texCoordsSlot);

}



void OpenGLRenderer::drawPath(SkPath* path, SkPaint* paint) {

    GLuint textureUnit = 0;

    glActiveTexture(gTextureUnits[textureUnit]);



    PathTexture* texture = mPathCache.get(path, paint);



    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;



    // Describe the required shaders

    ProgramDescription description;

    description.hasTexture = true;

    description.hasAlpha8Texture = true;

    if (mShader) {

        mShader->describe(description, mExtensions);

    }

    if (mColorFilter) {

        mColorFilter->describe(description, mExtensions);

    }



    // Build and use the appropriate shader

    useProgram(mProgramCache.get(description));



    // Setup the blending mode

    chooseBlending(true, mode);

    bindTexture(texture->id, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, textureUnit);

    glUniform1i(mCurrentProgram->getUniform("sampler"), textureUnit);



    int texCoordsSlot = mCurrentProgram->getAttrib("texCoords");

    glEnableVertexAttribArray(texCoordsSlot);



    // Setup attributes

    glVertexAttribPointer(mCurrentProgram->position, 2, GL_FLOAT, GL_FALSE,

            gMeshStride, &mMeshVertices[0].position[0]);

    glVertexAttribPointer(texCoordsSlot, 2, GL_FLOAT, GL_FALSE,

            gMeshStride, &mMeshVertices[0].texture[0]);



    // Setup uniforms

    mModelView.loadTranslate(texture->left - texture->offset,

            texture->top - texture->offset, 0.0f);

    mModelView.scale(texture->width, texture->height, 1.0f);

    mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);



    glUniform4f(mCurrentProgram->color, r, g, b, a);



    textureUnit++;

    // Setup attributes and uniforms required by the shaders

    if (mShader) {

        mShader->setupProgram(mCurrentProgram, mModelView, *mSnapshot, &textureUnit);

    }

    if (mColorFilter) {

        mColorFilter->setupProgram(mCurrentProgram);

    }



    // Draw the mesh

    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);



    glDisableVertexAttribArray(texCoordsSlot);

}



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

// Shaders

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