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