| #include "GraphicsJNI.h" |
| #include "SkGradientShader.h" |
| #include "SkImagePriv.h" |
| #include "SkShader.h" |
| #include "SkBlendMode.h" |
| #include "core_jni_helpers.h" |
| |
| #include <Caches.h> |
| #include <jni.h> |
| |
| using namespace android::uirenderer; |
| |
| /** |
| * By default Skia gradients will interpolate their colors in unpremul space |
| * and then premultiply each of the results. We must set this flag to preserve |
| * backwards compatiblity by premultiplying the colors of the gradient first, |
| * and then interpolating between them. |
| */ |
| static const uint32_t sGradientShaderFlags = SkGradientShader::kInterpolateColorsInPremul_Flag; |
| |
| static void ThrowIAE_IfNull(JNIEnv* env, void* ptr) { |
| if (NULL == ptr) { |
| doThrowIAE(env); |
| } |
| } |
| |
| static void Color_RGBToHSV(JNIEnv* env, jobject, jint red, jint green, jint blue, jfloatArray hsvArray) |
| { |
| SkScalar hsv[3]; |
| SkRGBToHSV(red, green, blue, hsv); |
| |
| AutoJavaFloatArray autoHSV(env, hsvArray, 3); |
| float* values = autoHSV.ptr(); |
| for (int i = 0; i < 3; i++) { |
| values[i] = SkScalarToFloat(hsv[i]); |
| } |
| } |
| |
| static jint Color_HSVToColor(JNIEnv* env, jobject, jint alpha, jfloatArray hsvArray) |
| { |
| AutoJavaFloatArray autoHSV(env, hsvArray, 3); |
| #ifdef SK_SCALAR_IS_FLOAT |
| SkScalar* hsv = autoHSV.ptr(); |
| #else |
| #error Need to convert float array to SkScalar array before calling the following function. |
| #endif |
| |
| return static_cast<jint>(SkHSVToColor(alpha, hsv)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static void Shader_safeUnref(SkShader* shader) { |
| SkSafeUnref(shader); |
| } |
| |
| static jlong Shader_getNativeFinalizer(JNIEnv*, jobject) { |
| return static_cast<jlong>(reinterpret_cast<uintptr_t>(&Shader_safeUnref)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong matrixPtr, jobject jbitmap, |
| jint tileModeX, jint tileModeY) { |
| const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr); |
| SkBitmap bitmap; |
| if (jbitmap) { |
| // Only pass a valid SkBitmap object to the constructor if the Bitmap exists. Otherwise, |
| // we'll pass an empty SkBitmap to avoid crashing/excepting for compatibility. |
| android::bitmap::toBitmap(env, jbitmap).getSkBitmapForShaders(&bitmap); |
| } |
| |
| sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode); |
| sk_sp<SkShader> baseShader = image->makeShader( |
| (SkShader::TileMode)tileModeX, (SkShader::TileMode)tileModeY); |
| |
| SkShader* shader; |
| if (matrix) { |
| shader = baseShader->makeWithLocalMatrix(*matrix).release(); |
| } else { |
| shader = baseShader.release(); |
| } |
| |
| ThrowIAE_IfNull(env, shader); |
| return reinterpret_cast<jlong>(shader); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static jlong LinearGradient_create1(JNIEnv* env, jobject o, jlong matrixPtr, |
| jfloat x0, jfloat y0, jfloat x1, jfloat y1, |
| jintArray colorArray, jfloatArray posArray, jint tileMode) { |
| const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr); |
| SkPoint pts[2]; |
| pts[0].set(x0, y0); |
| pts[1].set(x1, y1); |
| |
| size_t count = env->GetArrayLength(colorArray); |
| const jint* colorValues = env->GetIntArrayElements(colorArray, NULL); |
| |
| AutoJavaFloatArray autoPos(env, posArray, count); |
| #ifdef SK_SCALAR_IS_FLOAT |
| SkScalar* pos = autoPos.ptr(); |
| #else |
| #error Need to convert float array to SkScalar array before calling the following function. |
| #endif |
| |
| sk_sp<SkShader> baseShader(SkGradientShader::MakeLinear(pts, |
| reinterpret_cast<const SkColor*>(colorValues), pos, count, |
| static_cast<SkShader::TileMode>(tileMode), sGradientShaderFlags, NULL)); |
| |
| SkShader* shader; |
| if (matrix) { |
| shader = baseShader->makeWithLocalMatrix(*matrix).release(); |
| } else { |
| shader = baseShader.release(); |
| } |
| |
| env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT); |
| ThrowIAE_IfNull(env, shader); |
| return reinterpret_cast<jlong>(shader); |
| } |
| |
| static jlong LinearGradient_create2(JNIEnv* env, jobject o, jlong matrixPtr, |
| jfloat x0, jfloat y0, jfloat x1, jfloat y1, jint color0, jint color1, jint tileMode) { |
| const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr); |
| |
| SkPoint pts[2]; |
| pts[0].set(x0, y0); |
| pts[1].set(x1, y1); |
| |
| SkColor colors[2]; |
| colors[0] = color0; |
| colors[1] = color1; |
| |
| sk_sp<SkShader> baseShader(SkGradientShader::MakeLinear(pts, colors, NULL, 2, |
| static_cast<SkShader::TileMode>(tileMode), sGradientShaderFlags, NULL)); |
| |
| SkShader* s; |
| if (matrix) { |
| s = baseShader->makeWithLocalMatrix(*matrix).release(); |
| } else { |
| s = baseShader.release(); |
| } |
| |
| ThrowIAE_IfNull(env, s); |
| return reinterpret_cast<jlong>(s); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static jlong RadialGradient_create1(JNIEnv* env, jobject, jlong matrixPtr, jfloat x, jfloat y, |
| jfloat radius, jintArray colorArray, jfloatArray posArray, jint tileMode) { |
| const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr); |
| SkPoint center; |
| center.set(x, y); |
| |
| size_t count = env->GetArrayLength(colorArray); |
| const jint* colorValues = env->GetIntArrayElements(colorArray, NULL); |
| |
| AutoJavaFloatArray autoPos(env, posArray, count); |
| #ifdef SK_SCALAR_IS_FLOAT |
| SkScalar* pos = autoPos.ptr(); |
| #else |
| #error Need to convert float array to SkScalar array before calling the following function. |
| #endif |
| |
| sk_sp<SkShader> baseShader = SkGradientShader::MakeRadial(center, radius, |
| reinterpret_cast<const SkColor*>(colorValues), pos, count, |
| static_cast<SkShader::TileMode>(tileMode), sGradientShaderFlags, NULL); |
| |
| SkShader* shader; |
| if (matrix) { |
| shader = baseShader->makeWithLocalMatrix(*matrix).release(); |
| } else { |
| shader = baseShader.release(); |
| } |
| |
| env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), |
| JNI_ABORT); |
| |
| ThrowIAE_IfNull(env, shader); |
| return reinterpret_cast<jlong>(shader); |
| } |
| |
| static jlong RadialGradient_create2(JNIEnv* env, jobject, jlong matrixPtr, jfloat x, jfloat y, jfloat radius, |
| jint color0, jint color1, jint tileMode) { |
| const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr); |
| SkPoint center; |
| center.set(x, y); |
| |
| SkColor colors[2]; |
| colors[0] = color0; |
| colors[1] = color1; |
| |
| sk_sp<SkShader> baseShader = SkGradientShader::MakeRadial(center, radius, colors, NULL, 2, |
| static_cast<SkShader::TileMode>(tileMode), sGradientShaderFlags, NULL); |
| |
| SkShader* shader; |
| if (matrix) { |
| shader = baseShader->makeWithLocalMatrix(*matrix).release(); |
| } else { |
| shader = baseShader.release(); |
| } |
| ThrowIAE_IfNull(env, shader); |
| return reinterpret_cast<jlong>(shader); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| static jlong SweepGradient_create1(JNIEnv* env, jobject, jlong matrixPtr, jfloat x, jfloat y, |
| jintArray jcolors, jfloatArray jpositions) { |
| const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr); |
| size_t count = env->GetArrayLength(jcolors); |
| const jint* colors = env->GetIntArrayElements(jcolors, NULL); |
| |
| AutoJavaFloatArray autoPos(env, jpositions, count); |
| #ifdef SK_SCALAR_IS_FLOAT |
| SkScalar* pos = autoPos.ptr(); |
| #else |
| #error Need to convert float array to SkScalar array before calling the following function. |
| #endif |
| |
| sk_sp<SkShader> baseShader = SkGradientShader::MakeSweep(x, y, |
| reinterpret_cast<const SkColor*>(colors), pos, count, |
| sGradientShaderFlags, NULL); |
| |
| SkShader* shader; |
| if (matrix) { |
| shader = baseShader->makeWithLocalMatrix(*matrix).release(); |
| } else { |
| shader = baseShader.release(); |
| } |
| |
| env->ReleaseIntArrayElements(jcolors, const_cast<jint*>(colors), |
| JNI_ABORT); |
| ThrowIAE_IfNull(env, shader); |
| return reinterpret_cast<jlong>(shader); |
| } |
| |
| static jlong SweepGradient_create2(JNIEnv* env, jobject, jlong matrixPtr, jfloat x, jfloat y, |
| int color0, int color1) { |
| const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr); |
| SkColor colors[2]; |
| colors[0] = color0; |
| colors[1] = color1; |
| |
| sk_sp<SkShader> baseShader = SkGradientShader::MakeSweep(x, y, colors, |
| NULL, 2, sGradientShaderFlags, NULL); |
| |
| SkShader* shader; |
| if (matrix) { |
| shader = baseShader->makeWithLocalMatrix(*matrix).release(); |
| } else { |
| shader = baseShader.release(); |
| } |
| ThrowIAE_IfNull(env, shader); |
| return reinterpret_cast<jlong>(shader); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static jlong ComposeShader_create(JNIEnv* env, jobject o, jlong matrixPtr, |
| jlong shaderAHandle, jlong shaderBHandle, jint xfermodeHandle) { |
| const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr); |
| SkShader* shaderA = reinterpret_cast<SkShader *>(shaderAHandle); |
| SkShader* shaderB = reinterpret_cast<SkShader *>(shaderBHandle); |
| SkBlendMode mode = static_cast<SkBlendMode>(xfermodeHandle); |
| sk_sp<SkShader> baseShader(SkShader::MakeComposeShader( |
| sk_ref_sp(shaderA), sk_ref_sp(shaderB), mode)); |
| |
| SkShader* shader; |
| |
| if (matrix) { |
| shader = baseShader->makeWithLocalMatrix(*matrix).release(); |
| } else { |
| shader = baseShader.release(); |
| } |
| return reinterpret_cast<jlong>(shader); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static const JNINativeMethod gColorMethods[] = { |
| { "nativeRGBToHSV", "(III[F)V", (void*)Color_RGBToHSV }, |
| { "nativeHSVToColor", "(I[F)I", (void*)Color_HSVToColor } |
| }; |
| |
| static const JNINativeMethod gShaderMethods[] = { |
| { "nativeGetFinalizer", "()J", (void*)Shader_getNativeFinalizer }, |
| }; |
| |
| static const JNINativeMethod gBitmapShaderMethods[] = { |
| { "nativeCreate", "(JLandroid/graphics/Bitmap;II)J", (void*)BitmapShader_constructor }, |
| }; |
| |
| static const JNINativeMethod gLinearGradientMethods[] = { |
| { "nativeCreate1", "(JFFFF[I[FI)J", (void*)LinearGradient_create1 }, |
| { "nativeCreate2", "(JFFFFIII)J", (void*)LinearGradient_create2 }, |
| }; |
| |
| static const JNINativeMethod gRadialGradientMethods[] = { |
| { "nativeCreate1", "(JFFF[I[FI)J", (void*)RadialGradient_create1 }, |
| { "nativeCreate2", "(JFFFIII)J", (void*)RadialGradient_create2 }, |
| }; |
| |
| static const JNINativeMethod gSweepGradientMethods[] = { |
| { "nativeCreate1", "(JFF[I[F)J", (void*)SweepGradient_create1 }, |
| { "nativeCreate2", "(JFFII)J", (void*)SweepGradient_create2 }, |
| }; |
| |
| static const JNINativeMethod gComposeShaderMethods[] = { |
| { "nativeCreate", "(JJJI)J", (void*)ComposeShader_create }, |
| }; |
| |
| int register_android_graphics_Shader(JNIEnv* env) |
| { |
| android::RegisterMethodsOrDie(env, "android/graphics/Color", gColorMethods, |
| NELEM(gColorMethods)); |
| android::RegisterMethodsOrDie(env, "android/graphics/Shader", gShaderMethods, |
| NELEM(gShaderMethods)); |
| android::RegisterMethodsOrDie(env, "android/graphics/BitmapShader", gBitmapShaderMethods, |
| NELEM(gBitmapShaderMethods)); |
| android::RegisterMethodsOrDie(env, "android/graphics/LinearGradient", gLinearGradientMethods, |
| NELEM(gLinearGradientMethods)); |
| android::RegisterMethodsOrDie(env, "android/graphics/RadialGradient", gRadialGradientMethods, |
| NELEM(gRadialGradientMethods)); |
| android::RegisterMethodsOrDie(env, "android/graphics/SweepGradient", gSweepGradientMethods, |
| NELEM(gSweepGradientMethods)); |
| android::RegisterMethodsOrDie(env, "android/graphics/ComposeShader", gComposeShaderMethods, |
| NELEM(gComposeShaderMethods)); |
| |
| return 0; |
| } |