Matrix.cpp revision 20e987bfc35d0ae6cb6344ead65ed44ee7cf8750
1/* libs/android_runtime/android/graphics/Matrix.cpp 2** 3** Copyright 2006, The Android Open Source Project 4** 5** Licensed under the Apache License, Version 2.0 (the "License"); 6** you may not use this file except in compliance with the License. 7** You may obtain a copy of the License at 8** 9** http://www.apache.org/licenses/LICENSE-2.0 10** 11** Unless required by applicable law or agreed to in writing, software 12** distributed under the License is distributed on an "AS IS" BASIS, 13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14** See the License for the specific language governing permissions and 15** limitations under the License. 16*/ 17 18// This file was generated from the C++ include file: SkMatrix.h 19// Any changes made to this file will be discarded by the build. 20// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, 21// or one of the auxilary file specifications in device/tools/gluemaker. 22 23#include "jni.h" 24#include "GraphicsJNI.h" 25#include <android_runtime/AndroidRuntime.h> 26 27#include "SkMatrix.h" 28#include "SkTemplates.h" 29 30#include "Matrix.h" 31 32namespace android { 33 34class SkMatrixGlue { 35public: 36 37 static void finalizer(JNIEnv* env, jobject clazz, SkMatrix* obj) { 38 delete obj; 39 } 40 41 static SkMatrix* create(JNIEnv* env, jobject clazz, const SkMatrix* src) { 42 SkMatrix* obj = new SkMatrix(); 43 if (src) 44 *obj = *src; 45 else 46 obj->reset(); 47 return obj; 48 } 49 50 static jboolean isIdentity(JNIEnv* env, jobject clazz, SkMatrix* obj) { 51 return obj->isIdentity(); 52 } 53 54 static jboolean rectStaysRect(JNIEnv* env, jobject clazz, SkMatrix* obj) { 55 return obj->rectStaysRect(); 56 } 57 58 static void reset(JNIEnv* env, jobject clazz, SkMatrix* obj) { 59 obj->reset(); 60 } 61 62 static void set(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) { 63 *obj = *other; 64 } 65 66 static void setTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { 67 SkScalar dx_ = SkFloatToScalar(dx); 68 SkScalar dy_ = SkFloatToScalar(dy); 69 obj->setTranslate(dx_, dy_); 70 } 71 72 static void setScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { 73 SkScalar sx_ = SkFloatToScalar(sx); 74 SkScalar sy_ = SkFloatToScalar(sy); 75 SkScalar px_ = SkFloatToScalar(px); 76 SkScalar py_ = SkFloatToScalar(py); 77 obj->setScale(sx_, sy_, px_, py_); 78 } 79 80 static void setScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { 81 SkScalar sx_ = SkFloatToScalar(sx); 82 SkScalar sy_ = SkFloatToScalar(sy); 83 obj->setScale(sx_, sy_); 84 } 85 86 static void setRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { 87 SkScalar degrees_ = SkFloatToScalar(degrees); 88 SkScalar px_ = SkFloatToScalar(px); 89 SkScalar py_ = SkFloatToScalar(py); 90 obj->setRotate(degrees_, px_, py_); 91 } 92 93 static void setRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { 94 SkScalar degrees_ = SkFloatToScalar(degrees); 95 obj->setRotate(degrees_); 96 } 97 98 static void setSinCos__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) { 99 SkScalar sinValue_ = SkFloatToScalar(sinValue); 100 SkScalar cosValue_ = SkFloatToScalar(cosValue); 101 SkScalar px_ = SkFloatToScalar(px); 102 SkScalar py_ = SkFloatToScalar(py); 103 obj->setSinCos(sinValue_, cosValue_, px_, py_); 104 } 105 106 static void setSinCos__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue) { 107 SkScalar sinValue_ = SkFloatToScalar(sinValue); 108 SkScalar cosValue_ = SkFloatToScalar(cosValue); 109 obj->setSinCos(sinValue_, cosValue_); 110 } 111 112 static void setSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { 113 SkScalar kx_ = SkFloatToScalar(kx); 114 SkScalar ky_ = SkFloatToScalar(ky); 115 SkScalar px_ = SkFloatToScalar(px); 116 SkScalar py_ = SkFloatToScalar(py); 117 obj->setSkew(kx_, ky_, px_, py_); 118 } 119 120 static void setSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) { 121 SkScalar kx_ = SkFloatToScalar(kx); 122 SkScalar ky_ = SkFloatToScalar(ky); 123 obj->setSkew(kx_, ky_); 124 } 125 126 static jboolean setConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* a, SkMatrix* b) { 127 return obj->setConcat(*a, *b); 128 } 129 130 static jboolean preTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { 131 SkScalar dx_ = SkFloatToScalar(dx); 132 SkScalar dy_ = SkFloatToScalar(dy); 133 return obj->preTranslate(dx_, dy_); 134 } 135 136 static jboolean preScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { 137 SkScalar sx_ = SkFloatToScalar(sx); 138 SkScalar sy_ = SkFloatToScalar(sy); 139 SkScalar px_ = SkFloatToScalar(px); 140 SkScalar py_ = SkFloatToScalar(py); 141 return obj->preScale(sx_, sy_, px_, py_); 142 } 143 144 static jboolean preScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { 145 SkScalar sx_ = SkFloatToScalar(sx); 146 SkScalar sy_ = SkFloatToScalar(sy); 147 return obj->preScale(sx_, sy_); 148 } 149 150 static jboolean preRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { 151 SkScalar degrees_ = SkFloatToScalar(degrees); 152 SkScalar px_ = SkFloatToScalar(px); 153 SkScalar py_ = SkFloatToScalar(py); 154 return obj->preRotate(degrees_, px_, py_); 155 } 156 157 static jboolean preRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { 158 SkScalar degrees_ = SkFloatToScalar(degrees); 159 return obj->preRotate(degrees_); 160 } 161 162 static jboolean preSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { 163 SkScalar kx_ = SkFloatToScalar(kx); 164 SkScalar ky_ = SkFloatToScalar(ky); 165 SkScalar px_ = SkFloatToScalar(px); 166 SkScalar py_ = SkFloatToScalar(py); 167 return obj->preSkew(kx_, ky_, px_, py_); 168 } 169 170 static jboolean preSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) { 171 SkScalar kx_ = SkFloatToScalar(kx); 172 SkScalar ky_ = SkFloatToScalar(ky); 173 return obj->preSkew(kx_, ky_); 174 } 175 176 static jboolean preConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) { 177 return obj->preConcat(*other); 178 } 179 180 static jboolean postTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { 181 SkScalar dx_ = SkFloatToScalar(dx); 182 SkScalar dy_ = SkFloatToScalar(dy); 183 return obj->postTranslate(dx_, dy_); 184 } 185 186 static jboolean postScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { 187 SkScalar sx_ = SkFloatToScalar(sx); 188 SkScalar sy_ = SkFloatToScalar(sy); 189 SkScalar px_ = SkFloatToScalar(px); 190 SkScalar py_ = SkFloatToScalar(py); 191 return obj->postScale(sx_, sy_, px_, py_); 192 } 193 194 static jboolean postScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { 195 SkScalar sx_ = SkFloatToScalar(sx); 196 SkScalar sy_ = SkFloatToScalar(sy); 197 return obj->postScale(sx_, sy_); 198 } 199 200 static jboolean postRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { 201 SkScalar degrees_ = SkFloatToScalar(degrees); 202 SkScalar px_ = SkFloatToScalar(px); 203 SkScalar py_ = SkFloatToScalar(py); 204 return obj->postRotate(degrees_, px_, py_); 205 } 206 207 static jboolean postRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { 208 SkScalar degrees_ = SkFloatToScalar(degrees); 209 return obj->postRotate(degrees_); 210 } 211 212 static jboolean postSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { 213 SkScalar kx_ = SkFloatToScalar(kx); 214 SkScalar ky_ = SkFloatToScalar(ky); 215 SkScalar px_ = SkFloatToScalar(px); 216 SkScalar py_ = SkFloatToScalar(py); 217 return obj->postSkew(kx_, ky_, px_, py_); 218 } 219 220 static jboolean postSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat kx, jfloat ky) { 221 SkScalar kx_ = SkFloatToScalar(kx); 222 SkScalar ky_ = SkFloatToScalar(ky); 223 return matrix->postSkew(kx_, ky_); 224 } 225 226 static jboolean postConcat(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* other) { 227 return matrix->postConcat(*other); 228 } 229 230 static jboolean setRectToRect(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobject src, jobject dst, SkMatrix::ScaleToFit stf) { 231 SkRect src_; 232 GraphicsJNI::jrectf_to_rect(env, src, &src_); 233 SkRect dst_; 234 GraphicsJNI::jrectf_to_rect(env, dst, &dst_); 235 return matrix->setRectToRect(src_, dst_, stf); 236 } 237 238 static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, SkMatrix* matrix, 239 jfloatArray jsrc, int srcIndex, 240 jfloatArray jdst, int dstIndex, int ptCount) { 241 SkASSERT(srcIndex >= 0); 242 SkASSERT(dstIndex >= 0); 243 SkASSERT((unsigned)ptCount <= 4); 244 245 AutoJavaFloatArray autoSrc(env, jsrc, srcIndex + (ptCount << 1)); 246 AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1)); 247 float* src = autoSrc.ptr() + srcIndex; 248 float* dst = autoDst.ptr() + dstIndex; 249 250#ifdef SK_SCALAR_IS_FIXED 251 SkPoint srcPt[4], dstPt[4]; 252 for (int i = 0; i < ptCount; i++) { 253 int x = i << 1; 254 int y = x + 1; 255 srcPt[i].set(SkFloatToScalar(src[x]), SkFloatToScalar(src[y])); 256 dstPt[i].set(SkFloatToScalar(dst[x]), SkFloatToScalar(dst[y])); 257 } 258 return matrix->setPolyToPoly(srcPt, dstPt, ptCount); 259#else 260 return matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst, 261 ptCount); 262#endif 263 } 264 265 static jboolean invert(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* inverse) { 266 return matrix->invert(inverse); 267 } 268 269 static void mapPoints(JNIEnv* env, jobject clazz, SkMatrix* matrix, 270 jfloatArray dst, int dstIndex, 271 jfloatArray src, int srcIndex, 272 int ptCount, bool isPts) { 273 SkASSERT(ptCount >= 0); 274 AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1)); 275 AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1)); 276 float* srcArray = autoSrc.ptr() + srcIndex; 277 float* dstArray = autoDst.ptr() + dstIndex; 278 279#ifdef SK_SCALAR_IS_FIXED 280 // we allocate twice the count, 1 set for src, 1 for dst 281 SkAutoSTMalloc<32, SkPoint> storage(ptCount * 2); 282 SkPoint* pts = storage.get(); 283 SkPoint* srcPt = pts; 284 SkPoint* dstPt = pts + ptCount; 285 286 int i; 287 for (i = 0; i < ptCount; i++) { 288 srcPt[i].set(SkFloatToScalar(srcArray[i << 1]), 289 SkFloatToScalar(srcArray[(i << 1) + 1])); 290 } 291 292 if (isPts) 293 matrix->mapPoints(dstPt, srcPt, ptCount); 294 else 295 matrix->mapVectors(dstPt, srcPt, ptCount); 296 297 for (i = 0; i < ptCount; i++) { 298 dstArray[i << 1] = SkScalarToFloat(dstPt[i].fX); 299 dstArray[(i << 1) + 1] = SkScalarToFloat(dstPt[i].fY); 300 } 301#else 302 if (isPts) 303 matrix->mapPoints((SkPoint*)dstArray, (const SkPoint*)srcArray, 304 ptCount); 305 else 306 matrix->mapVectors((SkVector*)dstArray, (const SkVector*)srcArray, 307 ptCount); 308#endif 309 } 310 311 static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobjectArray dst, jobject src) { 312 SkRect dst_, src_; 313 GraphicsJNI::jrectf_to_rect(env, src, &src_); 314 jboolean rectStaysRect = matrix->mapRect(&dst_, src_); 315 GraphicsJNI::rect_to_jrectf(dst_, env, dst); 316 return rectStaysRect; 317 } 318 319 static jfloat mapRadius(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat radius) { 320 return SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius))); 321 } 322 323 static void getValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) { 324 AutoJavaFloatArray autoValues(env, values, 9); 325 float* dst = autoValues.ptr(); 326 327#ifdef SK_SCALAR_IS_FIXED 328 for (int i = 0; i < 6; i++) { 329 dst[i] = SkFixedToFloat(matrix->get(i)); 330 } 331 for (int j = 6; j < 9; j++) { 332 dst[j] = SkFractToFloat(matrix->get(j)); 333 } 334#else 335 for (int i = 0; i < 9; i++) { 336 dst[i] = matrix->get(i); 337 } 338#endif 339 } 340 341 static void setValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) { 342 AutoJavaFloatArray autoValues(env, values, 9); 343 const float* src = autoValues.ptr(); 344 345#ifdef SK_SCALAR_IS_FIXED 346 for (int i = 0; i < 6; i++) { 347 matrix->set(i, SkFloatToFixed(src[i])); 348 } 349 for (int j = 6; j < 9; j++) { 350 matrix->set(j, SkFloatToFract(src[j])); 351 } 352#else 353 for (int i = 0; i < 9; i++) { 354 matrix->set(i, src[i]); 355 } 356#endif 357 } 358 359 static jboolean equals(JNIEnv* env, jobject clazz, const SkMatrix* a, const SkMatrix* b) { 360 return *a == *b; 361 } 362 }; 363 364static JNINativeMethod methods[] = { 365 {"finalizer", "(I)V", (void*) SkMatrixGlue::finalizer}, 366 {"native_create","(I)I", (void*) SkMatrixGlue::create}, 367 {"native_isIdentity","(I)Z", (void*) SkMatrixGlue::isIdentity}, 368 {"native_rectStaysRect","(I)Z", (void*) SkMatrixGlue::rectStaysRect}, 369 {"native_reset","(I)V", (void*) SkMatrixGlue::reset}, 370 {"native_set","(II)V", (void*) SkMatrixGlue::set}, 371 {"native_setTranslate","(IFF)V", (void*) SkMatrixGlue::setTranslate}, 372 {"native_setScale","(IFFFF)V", (void*) SkMatrixGlue::setScale__FFFF}, 373 {"native_setScale","(IFF)V", (void*) SkMatrixGlue::setScale__FF}, 374 {"native_setRotate","(IFFF)V", (void*) SkMatrixGlue::setRotate__FFF}, 375 {"native_setRotate","(IF)V", (void*) SkMatrixGlue::setRotate__F}, 376 {"native_setSinCos","(IFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF}, 377 {"native_setSinCos","(IFF)V", (void*) SkMatrixGlue::setSinCos__FF}, 378 {"native_setSkew","(IFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF}, 379 {"native_setSkew","(IFF)V", (void*) SkMatrixGlue::setSkew__FF}, 380 {"native_setConcat","(III)Z", (void*) SkMatrixGlue::setConcat}, 381 {"native_preTranslate","(IFF)Z", (void*) SkMatrixGlue::preTranslate}, 382 {"native_preScale","(IFFFF)Z", (void*) SkMatrixGlue::preScale__FFFF}, 383 {"native_preScale","(IFF)Z", (void*) SkMatrixGlue::preScale__FF}, 384 {"native_preRotate","(IFFF)Z", (void*) SkMatrixGlue::preRotate__FFF}, 385 {"native_preRotate","(IF)Z", (void*) SkMatrixGlue::preRotate__F}, 386 {"native_preSkew","(IFFFF)Z", (void*) SkMatrixGlue::preSkew__FFFF}, 387 {"native_preSkew","(IFF)Z", (void*) SkMatrixGlue::preSkew__FF}, 388 {"native_preConcat","(II)Z", (void*) SkMatrixGlue::preConcat}, 389 {"native_postTranslate","(IFF)Z", (void*) SkMatrixGlue::postTranslate}, 390 {"native_postScale","(IFFFF)Z", (void*) SkMatrixGlue::postScale__FFFF}, 391 {"native_postScale","(IFF)Z", (void*) SkMatrixGlue::postScale__FF}, 392 {"native_postRotate","(IFFF)Z", (void*) SkMatrixGlue::postRotate__FFF}, 393 {"native_postRotate","(IF)Z", (void*) SkMatrixGlue::postRotate__F}, 394 {"native_postSkew","(IFFFF)Z", (void*) SkMatrixGlue::postSkew__FFFF}, 395 {"native_postSkew","(IFF)Z", (void*) SkMatrixGlue::postSkew__FF}, 396 {"native_postConcat","(II)Z", (void*) SkMatrixGlue::postConcat}, 397 {"native_setRectToRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect}, 398 {"native_setPolyToPoly","(I[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly}, 399 {"native_invert","(II)Z", (void*) SkMatrixGlue::invert}, 400 {"native_mapPoints","(I[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints}, 401 {"native_mapRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF}, 402 {"native_mapRadius","(IF)F", (void*) SkMatrixGlue::mapRadius}, 403 {"native_getValues","(I[F)V", (void*) SkMatrixGlue::getValues}, 404 {"native_setValues","(I[F)V", (void*) SkMatrixGlue::setValues}, 405 {"native_equals", "(II)Z", (void*) SkMatrixGlue::equals} 406}; 407 408static jfieldID sNativeInstanceField; 409 410int register_android_graphics_Matrix(JNIEnv* env) { 411 int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Matrix", methods, 412 sizeof(methods) / sizeof(methods[0])); 413 414 jclass clazz = env->FindClass("android/graphics/Matrix"); 415 sNativeInstanceField = env->GetFieldID(clazz, "native_instance", "I"); 416 417 return result; 418} 419 420SkMatrix* android_graphics_Matrix_getSkMatrix(JNIEnv* env, jobject matrixObj) { 421 return reinterpret_cast<SkMatrix*>(env->GetIntField(matrixObj, sNativeInstanceField)); 422} 423 424} 425