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

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

Add support for circular gradients to the GL renderer. 

This change also adds full support for local transformation matrices on
sweep and radial gradients.

Change-Id: Id8773bc0766575190e3f3d51984fc5e57b266c3f
parent ee916f14

core/jni/android/graphics/Shader.cpp

+71 −20
Original line number Diff line number Diff line
@@ -226,10 +226,8 @@ static SkShader* LinearGradient_create2(JNIEnv* env, jobject o, 


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



static SkShader* RadialGradient_create1(JNIEnv* env, jobject,

                                        float x, float y, float radius,

                                        jintArray colorArray, jfloatArray posArray, int tileMode)

{

static SkShader* RadialGradient_create1(JNIEnv* env, jobject, float x, float y, float radius,

        jintArray colorArray, jfloatArray posArray, int tileMode) {

    SkPoint center;

    center.set(SkFloatToScalar(x), SkFloatToScalar(y));
@@ -259,10 +257,8 @@ static SkShader* RadialGradient_create1(JNIEnv* env, jobject, 
    return shader;

}



static SkShader* RadialGradient_create2(JNIEnv* env, jobject,

                                        float x, float y, float radius,

                                        int color0, int color1, int tileMode)

{

static SkShader* RadialGradient_create2(JNIEnv* env, jobject, float x, float y, float radius,

        int color0, int color1, int tileMode) {

    SkPoint center;

    center.set(SkFloatToScalar(x), SkFloatToScalar(y));
@@ -276,11 +272,65 @@ static SkShader* RadialGradient_create2(JNIEnv* env, jobject, 
    return s;

}



static SkiaShader* RadialGradient_postCreate1(JNIEnv* env, jobject o, SkShader* shader,

        float x, float y, float radius, jintArray colorArray, jfloatArray posArray, int tileMode) {

#ifdef USE_OPENGL_RENDERER

    size_t count = env->GetArrayLength(colorArray);

    const jint* colorValues = env->GetIntArrayElements(colorArray, NULL);



    jfloat* storedPositions = new jfloat[count];

    uint32_t* storedColors = new uint32_t[count];

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

        storedColors[i] = static_cast<uint32_t>(colorValues[i]);

    }



    if (posArray) {

        AutoJavaFloatArray autoPos(env, posArray, count);

        const float* posValues = autoPos.ptr();

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

            storedPositions[i] = posValues[i];

        }

    } else {

        storedPositions[0] = 0.0f;

        storedPositions[1] = 1.0f;

    }



    SkiaShader* skiaShader = new SkiaCircularGradientShader(x, y, radius, storedColors,

            storedPositions, count, shader, (SkShader::TileMode) tileMode, NULL,

            (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0);



    env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT);

    return skiaShader;

#else

    return NULL;

#endif

}



static SkiaShader* RadialGradient_postCreate2(JNIEnv* env, jobject o, SkShader* shader,

        float x, float y, float radius, int color0, int color1, int tileMode) {

#ifdef USE_OPENGL_RENDERER

    float* storedPositions = new float[2];

    storedPositions[0] = 0.0f;

    storedPositions[1] = 1.0f;



    uint32_t* storedColors = new uint32_t[2];

    storedColors[0] = static_cast<uint32_t>(color0);

    storedColors[1] = static_cast<uint32_t>(color1);



    SkiaShader* skiaShader = new SkiaCircularGradientShader(x, y, radius, storedColors,

            storedPositions, 2, shader, (SkShader::TileMode) tileMode, NULL,

            (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0);



    return skiaShader;

#else

    return NULL;

#endif

}



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



static SkShader* SweepGradient_create1(JNIEnv* env, jobject, float x, float y,

                                    jintArray jcolors, jfloatArray jpositions)

{

        jintArray jcolors, jfloatArray jpositions) {

    size_t      count = env->GetArrayLength(jcolors);

    const jint* colors = env->GetIntArrayElements(jcolors, NULL);
@@ -307,8 +357,7 @@ static SkShader* SweepGradient_create1(JNIEnv* env, jobject, float x, float y, 
}



static SkShader* SweepGradient_create2(JNIEnv* env, jobject, float x, float y,

                                        int color0, int color1)

{

        int color0, int color1) {

    SkColor colors[2];

    colors[0] = color0;

    colors[1] = color1;
@@ -438,7 +487,9 @@ static JNINativeMethod gLinearGradientMethods[] = { 


static JNINativeMethod gRadialGradientMethods[] = {

    { "nativeCreate1",     "(FFF[I[FI)I",  (void*)RadialGradient_create1     },

    {"nativeCreate2",   "(FFFIII)I",    (void*)RadialGradient_create2   }

    { "nativeCreate2",     "(FFFIII)I",    (void*)RadialGradient_create2     },

    { "nativePostCreate1", "(IFFF[I[FI)I", (void*)RadialGradient_postCreate1 },

    { "nativePostCreate2", "(IFFFIII)I",   (void*)RadialGradient_postCreate2 }

};



static JNINativeMethod gSweepGradientMethods[] = {

graphics/java/android/graphics/RadialGradient.java

+11 −2
Original line number Diff line number Diff line
@@ -40,6 +40,8 @@ public class RadialGradient extends Shader { 
            throw new IllegalArgumentException("color and position arrays must be of equal length");

        }

        native_instance = nativeCreate1(x, y, radius, colors, positions, tile.nativeInt);

        native_shader = nativePostCreate1(native_instance, x, y, radius, colors, positions,

                tile.nativeInt);

    }



	/**	Create a shader that draws a radial gradient given the center and radius.
@@ -56,11 +58,18 @@ public class RadialGradient extends Shader { 
            throw new IllegalArgumentException("radius must be > 0");

        }

        native_instance = nativeCreate2(x, y, radius, color0, color1, tile.nativeInt);

        native_shader = nativePostCreate2(native_instance, x, y, radius, color0, color1,

                tile.nativeInt);

    }



	private static native int nativeCreate1(float x, float y, float radius,

            int colors[], float positions[], int tileMode);

	private static native int nativeCreate2(float x, float y, float radius,

            int color0, int color1, int tileMode);



    private static native int nativePostCreate1(int native_shader, float x, float y, float radius,

            int colors[], float positions[], int tileMode);

    private static native int nativePostCreate2(int native_shader, float x, float y, float radius,

            int color0, int color1, int tileMode);

}

libs/hwui/Matrix.cpp

+6 −0
Original line number Diff line number Diff line
@@ -144,6 +144,12 @@ float Matrix4::getTranslateY() { 
    return data[kTranslateY];

}



void Matrix4::multiply(float v) {

    for (int i = 0; i < 16; i++) {

        data[i] *= v;

    }

}



void Matrix4::loadTranslate(float x, float y, float z) {

    loadIdentity();

    data[kTranslateX] = x;

libs/hwui/Matrix.h

+2 −0
Original line number Diff line number Diff line
@@ -83,6 +83,8 @@ public: 
        load(u);

    }



    void multiply(float v);



    void translate(float x, float y, float z) {

        Matrix4 u;

        u.loadTranslate(x, y, z);

libs/hwui/ProgramCache.cpp

+11 −5
Original line number Diff line number Diff line
@@ -40,9 +40,12 @@ const char* gVS_Header_Uniforms_HasGradient[3] = { 
        "uniform vec2 gradientStart;\n"

        "uniform mat4 screenSpace;\n",

        // Circular

        "",

        "uniform vec2 gradientStart;\n"

        "uniform mat4 gradientMatrix;\n"

        "uniform mat4 screenSpace;\n",

        // Sweep

        "uniform vec2 gradientStart;\n"

        "uniform mat4 gradientMatrix;\n"

        "uniform mat4 screenSpace;\n"

};

const char* gVS_Header_Uniforms_HasBitmap =
@@ -56,7 +59,7 @@ const char* gVS_Header_Varyings_HasGradient[3] = { 
        // Linear

        "varying float index;\n",

        // Circular

        "",

        "varying vec2 circular;\n",

        // Sweep

        "varying vec2 sweep;\n"

};
@@ -69,10 +72,11 @@ const char* gVS_Main_OutGradient[3] = { 
        "    vec4 location = screenSpace * position;\n"

        "    index = dot(location.xy - gradientStart, gradient) * gradientLength;\n",

        // Circular

        "",

        "    vec4 location = screenSpace * position;\n"

        "    circular = (gradientMatrix * vec4(location.xy - gradientStart, 0.0, 0.0)).xy;\n",

        // Sweep

        "    vec4 location = screenSpace * position;\n"

        "    sweep = location.xy - gradientStart;\n"

        "    sweep = (gradientMatrix * vec4(location.xy - gradientStart, 0.0, 0.0)).xy;\n"

};

const char* gVS_Main_OutBitmapTexCoords =

        "    vec4 bitmapCoords = textureTransform * position;\n"
@@ -98,6 +102,7 @@ const char* gFS_Uniforms_GradientSampler[3] = { 
        // Linear

        "uniform sampler2D gradientSampler;\n",

        // Circular

        "uniform float gradientRadius;\n"

        "uniform sampler2D gradientSampler;\n",

        // Sweep

        "uniform sampler2D gradientSampler;\n"
@@ -129,7 +134,8 @@ const char* gFS_Main_FetchGradient[3] = { 
        // Linear

        "    vec4 gradientColor = texture2D(gradientSampler, vec2(index, 0.5));\n",

        // Circular

        "",

        "    float index = length(circular) * gradientRadius;\n"

        "    vec4 gradientColor = texture2D(gradientSampler, vec2(index, 0.5));\n",

        // Sweep

        "    float index = atan(sweep.y, sweep.x) * 0.15915494309; // inv(2 * PI)\n"

        "    vec4 gradientColor = texture2D(gradientSampler, vec2(index - floor(index), 0.5));\n"