Merge "Add support for circular gradients to the GL renderer." (76f60911) · Commits · e / os / android_frameworks_base

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"