android_view_RenderNode.cpp revision 8de65a8e05285df52a1e6f0c1d5616dd233298a7
1/* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define LOG_TAG "OpenGLRenderer" 18 19#include <EGL/egl.h> 20 21#include "jni.h" 22#include "GraphicsJNI.h" 23#include <nativehelper/JNIHelp.h> 24#include <android_runtime/AndroidRuntime.h> 25 26#include <DisplayListRenderer.h> 27#include <RenderNode.h> 28 29namespace android { 30 31using namespace uirenderer; 32 33/** 34 * Note: OpenGLRenderer JNI layer is generated and compiled only on supported 35 * devices. This means all the logic must be compiled only when the 36 * preprocessor variable USE_OPENGL_RENDERER is defined. 37 */ 38#ifdef USE_OPENGL_RENDERER 39 40// ---------------------------------------------------------------------------- 41// DisplayList view properties 42// ---------------------------------------------------------------------------- 43 44static void android_view_RenderNode_output(JNIEnv* env, 45 jobject clazz, jlong renderNodePtr) { 46 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 47 renderNode->output(); 48} 49 50static jlong android_view_RenderNode_create(JNIEnv* env, jobject clazz, jstring name) { 51 RenderNode* renderNode = new RenderNode(); 52 renderNode->incStrong(0); 53 if (name != NULL) { 54 const char* textArray = env->GetStringUTFChars(name, NULL); 55 renderNode->setName(textArray); 56 env->ReleaseStringUTFChars(name, textArray); 57 } 58 return reinterpret_cast<jlong>(renderNode); 59} 60 61static void android_view_RenderNode_destroyRenderNode(JNIEnv* env, 62 jobject clazz, jlong renderNodePtr) { 63 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 64 renderNode->decStrong(0); 65} 66 67static void android_view_RenderNode_setDisplayListData(JNIEnv* env, 68 jobject clazz, jlong renderNodePtr, jlong newDataPtr) { 69 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 70 DisplayListData* newData = reinterpret_cast<DisplayListData*>(newDataPtr); 71 renderNode->setStagingDisplayList(newData); 72} 73 74// ---------------------------------------------------------------------------- 75// RenderProperties - setters 76// ---------------------------------------------------------------------------- 77 78static void android_view_RenderNode_setCaching(JNIEnv* env, 79 jobject clazz, jlong renderNodePtr, jboolean caching) { 80 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 81 renderNode->mutateStagingProperties().setCaching(caching); 82} 83 84static void android_view_RenderNode_setStaticMatrix(JNIEnv* env, 85 jobject clazz, jlong renderNodePtr, jlong matrixPtr) { 86 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 87 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr); 88 renderNode->mutateStagingProperties().setStaticMatrix(matrix); 89} 90 91static void android_view_RenderNode_setAnimationMatrix(JNIEnv* env, 92 jobject clazz, jlong renderNodePtr, jlong matrixPtr) { 93 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 94 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr); 95 renderNode->mutateStagingProperties().setAnimationMatrix(matrix); 96} 97 98static void android_view_RenderNode_setClipToBounds(JNIEnv* env, 99 jobject clazz, jlong renderNodePtr, jboolean clipToBounds) { 100 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 101 renderNode->mutateStagingProperties().setClipToBounds(clipToBounds); 102} 103 104static void android_view_RenderNode_setProjectBackwards(JNIEnv* env, 105 jobject clazz, jlong renderNodePtr, jboolean shouldProject) { 106 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 107 renderNode->mutateStagingProperties().setProjectBackwards(shouldProject); 108} 109 110static void android_view_RenderNode_setProjectionReceiver(JNIEnv* env, 111 jobject clazz, jlong renderNodePtr, jboolean shouldRecieve) { 112 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 113 renderNode->mutateStagingProperties().setProjectionReceiver(shouldRecieve); 114} 115 116static void android_view_RenderNode_setOutlineRoundRect(JNIEnv* env, 117 jobject clazz, jlong renderNodePtr, jint left, jint top, 118 jint right, jint bottom, jfloat radius) { 119 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 120 renderNode->mutateStagingProperties().mutableOutline().setRoundRect(left, top, right, bottom, radius); 121 renderNode->mutateStagingProperties().updateClipPath(); 122} 123 124static void android_view_RenderNode_setOutlineConvexPath(JNIEnv* env, 125 jobject clazz, jlong renderNodePtr, jlong outlinePathPtr) { 126 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 127 SkPath* outlinePath = reinterpret_cast<SkPath*>(outlinePathPtr); 128 renderNode->mutateStagingProperties().mutableOutline().setConvexPath(outlinePath); 129 renderNode->mutateStagingProperties().updateClipPath(); 130} 131 132static void android_view_RenderNode_setOutlineEmpty(JNIEnv* env, 133 jobject clazz, jlong renderNodePtr) { 134 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 135 renderNode->mutateStagingProperties().mutableOutline().setEmpty(); 136 renderNode->mutateStagingProperties().updateClipPath(); 137} 138 139static void android_view_RenderNode_setClipToOutline(JNIEnv* env, 140 jobject clazz, jlong renderNodePtr, jboolean clipToOutline) { 141 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 142 renderNode->mutateStagingProperties().mutableOutline().setShouldClip(clipToOutline); 143 renderNode->mutateStagingProperties().updateClipPath(); 144} 145 146static void android_view_RenderNode_setRevealClip(JNIEnv* env, 147 jobject clazz, jlong renderNodePtr, jboolean shouldClip, jboolean inverseClip, 148 jfloat x, jfloat y, jfloat radius) { 149 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 150 renderNode->mutateStagingProperties().mutableRevealClip().set( 151 shouldClip, inverseClip, x, y, radius); 152 renderNode->mutateStagingProperties().updateClipPath(); 153} 154 155static void android_view_RenderNode_setAlpha(JNIEnv* env, 156 jobject clazz, jlong renderNodePtr, float alpha) { 157 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 158 renderNode->mutateStagingProperties().setAlpha(alpha); 159} 160 161static void android_view_RenderNode_setHasOverlappingRendering(JNIEnv* env, 162 jobject clazz, jlong renderNodePtr, bool hasOverlappingRendering) { 163 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 164 renderNode->mutateStagingProperties().setHasOverlappingRendering(hasOverlappingRendering); 165} 166 167static void android_view_RenderNode_setTranslationX(JNIEnv* env, 168 jobject clazz, jlong renderNodePtr, float tx) { 169 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 170 renderNode->mutateStagingProperties().setTranslationX(tx); 171} 172 173static void android_view_RenderNode_setTranslationY(JNIEnv* env, 174 jobject clazz, jlong renderNodePtr, float ty) { 175 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 176 renderNode->mutateStagingProperties().setTranslationY(ty); 177} 178 179static void android_view_RenderNode_setTranslationZ(JNIEnv* env, 180 jobject clazz, jlong renderNodePtr, float tz) { 181 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 182 renderNode->mutateStagingProperties().setTranslationZ(tz); 183} 184 185static void android_view_RenderNode_setRotation(JNIEnv* env, 186 jobject clazz, jlong renderNodePtr, float rotation) { 187 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 188 renderNode->mutateStagingProperties().setRotation(rotation); 189} 190 191static void android_view_RenderNode_setRotationX(JNIEnv* env, 192 jobject clazz, jlong renderNodePtr, float rx) { 193 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 194 renderNode->mutateStagingProperties().setRotationX(rx); 195} 196 197static void android_view_RenderNode_setRotationY(JNIEnv* env, 198 jobject clazz, jlong renderNodePtr, float ry) { 199 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 200 renderNode->mutateStagingProperties().setRotationY(ry); 201} 202 203static void android_view_RenderNode_setScaleX(JNIEnv* env, 204 jobject clazz, jlong renderNodePtr, float sx) { 205 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 206 renderNode->mutateStagingProperties().setScaleX(sx); 207} 208 209static void android_view_RenderNode_setScaleY(JNIEnv* env, 210 jobject clazz, jlong renderNodePtr, float sy) { 211 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 212 renderNode->mutateStagingProperties().setScaleY(sy); 213} 214 215static void android_view_RenderNode_setPivotX(JNIEnv* env, 216 jobject clazz, jlong renderNodePtr, float px) { 217 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 218 renderNode->mutateStagingProperties().setPivotX(px); 219} 220 221static void android_view_RenderNode_setPivotY(JNIEnv* env, 222 jobject clazz, jlong renderNodePtr, float py) { 223 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 224 renderNode->mutateStagingProperties().setPivotY(py); 225} 226 227static void android_view_RenderNode_setCameraDistance(JNIEnv* env, 228 jobject clazz, jlong renderNodePtr, float distance) { 229 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 230 renderNode->mutateStagingProperties().setCameraDistance(distance); 231} 232 233static void android_view_RenderNode_setLeft(JNIEnv* env, 234 jobject clazz, jlong renderNodePtr, int left) { 235 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 236 renderNode->mutateStagingProperties().setLeft(left); 237} 238 239static void android_view_RenderNode_setTop(JNIEnv* env, 240 jobject clazz, jlong renderNodePtr, int top) { 241 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 242 renderNode->mutateStagingProperties().setTop(top); 243} 244 245static void android_view_RenderNode_setRight(JNIEnv* env, 246 jobject clazz, jlong renderNodePtr, int right) { 247 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 248 renderNode->mutateStagingProperties().setRight(right); 249} 250 251static void android_view_RenderNode_setBottom(JNIEnv* env, 252 jobject clazz, jlong renderNodePtr, int bottom) { 253 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 254 renderNode->mutateStagingProperties().setBottom(bottom); 255} 256 257static void android_view_RenderNode_setLeftTopRightBottom(JNIEnv* env, 258 jobject clazz, jlong renderNodePtr, int left, int top, 259 int right, int bottom) { 260 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 261 renderNode->mutateStagingProperties().setLeftTopRightBottom(left, top, right, bottom); 262} 263 264static void android_view_RenderNode_offsetLeftAndRight(JNIEnv* env, 265 jobject clazz, jlong renderNodePtr, float offset) { 266 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 267 renderNode->mutateStagingProperties().offsetLeftRight(offset); 268} 269 270static void android_view_RenderNode_offsetTopAndBottom(JNIEnv* env, 271 jobject clazz, jlong renderNodePtr, float offset) { 272 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 273 renderNode->mutateStagingProperties().offsetTopBottom(offset); 274} 275 276// ---------------------------------------------------------------------------- 277// RenderProperties - getters 278// ---------------------------------------------------------------------------- 279 280static jboolean android_view_RenderNode_hasOverlappingRendering(JNIEnv* env, 281 jobject clazz, jlong renderNodePtr) { 282 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 283 return renderNode->stagingProperties().hasOverlappingRendering(); 284} 285 286static jfloat android_view_RenderNode_getAlpha(JNIEnv* env, 287 jobject clazz, jlong renderNodePtr) { 288 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 289 return renderNode->stagingProperties().getAlpha(); 290} 291 292static jfloat android_view_RenderNode_getLeft(JNIEnv* env, 293 jobject clazz, jlong renderNodePtr) { 294 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 295 return renderNode->stagingProperties().getLeft(); 296} 297 298static jfloat android_view_RenderNode_getTop(JNIEnv* env, 299 jobject clazz, jlong renderNodePtr) { 300 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 301 return renderNode->stagingProperties().getTop(); 302} 303 304static jfloat android_view_RenderNode_getRight(JNIEnv* env, 305 jobject clazz, jlong renderNodePtr) { 306 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 307 return renderNode->stagingProperties().getRight(); 308} 309 310static jfloat android_view_RenderNode_getBottom(JNIEnv* env, 311 jobject clazz, jlong renderNodePtr) { 312 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 313 return renderNode->stagingProperties().getBottom(); 314} 315 316static jfloat android_view_RenderNode_getCameraDistance(JNIEnv* env, 317 jobject clazz, jlong renderNodePtr) { 318 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 319 return renderNode->stagingProperties().getCameraDistance(); 320} 321 322static jfloat android_view_RenderNode_getScaleX(JNIEnv* env, 323 jobject clazz, jlong renderNodePtr) { 324 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 325 return renderNode->stagingProperties().getScaleX(); 326} 327 328static jfloat android_view_RenderNode_getScaleY(JNIEnv* env, 329 jobject clazz, jlong renderNodePtr) { 330 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 331 return renderNode->stagingProperties().getScaleY(); 332} 333 334static jfloat android_view_RenderNode_getTranslationX(JNIEnv* env, 335 jobject clazz, jlong renderNodePtr) { 336 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 337 return renderNode->stagingProperties().getTranslationX(); 338} 339 340static jfloat android_view_RenderNode_getTranslationY(JNIEnv* env, 341 jobject clazz, jlong renderNodePtr) { 342 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 343 return renderNode->stagingProperties().getTranslationY(); 344} 345 346static jfloat android_view_RenderNode_getTranslationZ(JNIEnv* env, 347 jobject clazz, jlong renderNodePtr) { 348 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 349 return renderNode->stagingProperties().getTranslationZ(); 350} 351 352static jfloat android_view_RenderNode_getRotation(JNIEnv* env, 353 jobject clazz, jlong renderNodePtr) { 354 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 355 return renderNode->stagingProperties().getRotation(); 356} 357 358static jfloat android_view_RenderNode_getRotationX(JNIEnv* env, 359 jobject clazz, jlong renderNodePtr) { 360 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 361 return renderNode->stagingProperties().getRotationX(); 362} 363 364static jfloat android_view_RenderNode_getRotationY(JNIEnv* env, 365 jobject clazz, jlong renderNodePtr) { 366 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 367 return renderNode->stagingProperties().getRotationY(); 368} 369 370static jboolean android_view_RenderNode_isPivotExplicitlySet(JNIEnv* env, 371 jobject clazz, jlong renderNodePtr) { 372 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 373 return renderNode->stagingProperties().isPivotExplicitlySet(); 374} 375 376static jboolean android_view_RenderNode_hasIdentityMatrix(JNIEnv* env, 377 jobject clazz, jlong renderNodePtr) { 378 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 379 return renderNode->stagingProperties().getMatrixFlags() == 0; 380} 381 382// ---------------------------------------------------------------------------- 383// RenderProperties - computed getters 384// ---------------------------------------------------------------------------- 385 386static void android_view_RenderNode_getTransformMatrix(JNIEnv* env, 387 jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) { 388 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 389 SkMatrix* outMatrix = reinterpret_cast<SkMatrix*>(outMatrixPtr); 390 391 renderNode->mutateStagingProperties().updateMatrix(); 392 const SkMatrix* transformMatrix = renderNode->stagingProperties().getTransformMatrix(); 393 394 if (renderNode->stagingProperties().getMatrixFlags() == TRANSLATION) { 395 outMatrix->setTranslate(renderNode->stagingProperties().getTranslationX(), 396 renderNode->stagingProperties().getTranslationY()); 397 } else if (transformMatrix) { 398 *outMatrix = *transformMatrix; 399 } else { 400 outMatrix->setIdentity(); 401 } 402} 403 404static void android_view_RenderNode_getInverseTransformMatrix(JNIEnv* env, 405 jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) { 406 // load transform matrix 407 android_view_RenderNode_getTransformMatrix(env, clazz, renderNodePtr, outMatrixPtr); 408 SkMatrix* outMatrix = reinterpret_cast<SkMatrix*>(outMatrixPtr); 409 410 // return it inverted 411 if (!outMatrix->invert(outMatrix)) { 412 // failed to load inverse, pass back identity 413 outMatrix->setIdentity(); 414 } 415} 416 417static jfloat android_view_RenderNode_getPivotX(JNIEnv* env, 418 jobject clazz, jlong renderNodePtr) { 419 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 420 renderNode->mutateStagingProperties().updateMatrix(); 421 return renderNode->stagingProperties().getPivotX(); 422} 423 424static jfloat android_view_RenderNode_getPivotY(JNIEnv* env, 425 jobject clazz, jlong renderNodePtr) { 426 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 427 renderNode->mutateStagingProperties().updateMatrix(); 428 return renderNode->stagingProperties().getPivotY(); 429} 430 431#endif // USE_OPENGL_RENDERER 432 433// ---------------------------------------------------------------------------- 434// JNI Glue 435// ---------------------------------------------------------------------------- 436 437const char* const kClassPathName = "android/view/RenderNode"; 438 439static JNINativeMethod gMethods[] = { 440#ifdef USE_OPENGL_RENDERER 441 { "nCreate", "(Ljava/lang/String;)J", (void*) android_view_RenderNode_create }, 442 { "nDestroyRenderNode", "(J)V", (void*) android_view_RenderNode_destroyRenderNode }, 443 { "nSetDisplayListData", "(JJ)V", (void*) android_view_RenderNode_setDisplayListData }, 444 { "nOutput", "(J)V", (void*) android_view_RenderNode_output }, 445 446 { "nSetCaching", "(JZ)V", (void*) android_view_RenderNode_setCaching }, 447 { "nSetStaticMatrix", "(JJ)V", (void*) android_view_RenderNode_setStaticMatrix }, 448 { "nSetAnimationMatrix", "(JJ)V", (void*) android_view_RenderNode_setAnimationMatrix }, 449 { "nSetClipToBounds", "(JZ)V", (void*) android_view_RenderNode_setClipToBounds }, 450 { "nSetProjectBackwards", "(JZ)V", (void*) android_view_RenderNode_setProjectBackwards }, 451 { "nSetProjectionReceiver","(JZ)V", (void*) android_view_RenderNode_setProjectionReceiver }, 452 453 { "nSetOutlineRoundRect", "(JIIIIF)V", (void*) android_view_RenderNode_setOutlineRoundRect }, 454 { "nSetOutlineConvexPath", "(JJ)V", (void*) android_view_RenderNode_setOutlineConvexPath }, 455 { "nSetOutlineEmpty", "(J)V", (void*) android_view_RenderNode_setOutlineEmpty }, 456 { "nSetClipToOutline", "(JZ)V", (void*) android_view_RenderNode_setClipToOutline }, 457 { "nSetRevealClip", "(JZZFFF)V", (void*) android_view_RenderNode_setRevealClip }, 458 459 { "nSetAlpha", "(JF)V", (void*) android_view_RenderNode_setAlpha }, 460 { "nSetHasOverlappingRendering", "(JZ)V", 461 (void*) android_view_RenderNode_setHasOverlappingRendering }, 462 { "nSetTranslationX", "(JF)V", (void*) android_view_RenderNode_setTranslationX }, 463 { "nSetTranslationY", "(JF)V", (void*) android_view_RenderNode_setTranslationY }, 464 { "nSetTranslationZ", "(JF)V", (void*) android_view_RenderNode_setTranslationZ }, 465 { "nSetRotation", "(JF)V", (void*) android_view_RenderNode_setRotation }, 466 { "nSetRotationX", "(JF)V", (void*) android_view_RenderNode_setRotationX }, 467 { "nSetRotationY", "(JF)V", (void*) android_view_RenderNode_setRotationY }, 468 { "nSetScaleX", "(JF)V", (void*) android_view_RenderNode_setScaleX }, 469 { "nSetScaleY", "(JF)V", (void*) android_view_RenderNode_setScaleY }, 470 { "nSetPivotX", "(JF)V", (void*) android_view_RenderNode_setPivotX }, 471 { "nSetPivotY", "(JF)V", (void*) android_view_RenderNode_setPivotY }, 472 { "nSetCameraDistance", "(JF)V", (void*) android_view_RenderNode_setCameraDistance }, 473 { "nSetLeft", "(JI)V", (void*) android_view_RenderNode_setLeft }, 474 { "nSetTop", "(JI)V", (void*) android_view_RenderNode_setTop }, 475 { "nSetRight", "(JI)V", (void*) android_view_RenderNode_setRight }, 476 { "nSetBottom", "(JI)V", (void*) android_view_RenderNode_setBottom }, 477 { "nSetLeftTopRightBottom","(JIIII)V", (void*) android_view_RenderNode_setLeftTopRightBottom }, 478 { "nOffsetLeftAndRight", "(JF)V", (void*) android_view_RenderNode_offsetLeftAndRight }, 479 { "nOffsetTopAndBottom", "(JF)V", (void*) android_view_RenderNode_offsetTopAndBottom }, 480 481 { "nHasOverlappingRendering", "(J)Z", (void*) android_view_RenderNode_hasOverlappingRendering }, 482 { "nGetAlpha", "(J)F", (void*) android_view_RenderNode_getAlpha }, 483 { "nGetLeft", "(J)F", (void*) android_view_RenderNode_getLeft }, 484 { "nGetTop", "(J)F", (void*) android_view_RenderNode_getTop }, 485 { "nGetRight", "(J)F", (void*) android_view_RenderNode_getRight }, 486 { "nGetBottom", "(J)F", (void*) android_view_RenderNode_getBottom }, 487 { "nGetCameraDistance", "(J)F", (void*) android_view_RenderNode_getCameraDistance }, 488 { "nGetScaleX", "(J)F", (void*) android_view_RenderNode_getScaleX }, 489 { "nGetScaleY", "(J)F", (void*) android_view_RenderNode_getScaleY }, 490 { "nGetTranslationX", "(J)F", (void*) android_view_RenderNode_getTranslationX }, 491 { "nGetTranslationY", "(J)F", (void*) android_view_RenderNode_getTranslationY }, 492 { "nGetTranslationZ", "(J)F", (void*) android_view_RenderNode_getTranslationZ }, 493 { "nGetRotation", "(J)F", (void*) android_view_RenderNode_getRotation }, 494 { "nGetRotationX", "(J)F", (void*) android_view_RenderNode_getRotationX }, 495 { "nGetRotationY", "(J)F", (void*) android_view_RenderNode_getRotationY }, 496 { "nIsPivotExplicitlySet", "(J)Z", (void*) android_view_RenderNode_isPivotExplicitlySet }, 497 { "nHasIdentityMatrix", "(J)Z", (void*) android_view_RenderNode_hasIdentityMatrix }, 498 499 { "nGetTransformMatrix", "(JJ)V", (void*) android_view_RenderNode_getTransformMatrix }, 500 { "nGetInverseTransformMatrix","(JJ)V", (void*) android_view_RenderNode_getInverseTransformMatrix }, 501 502 { "nGetPivotX", "(J)F", (void*) android_view_RenderNode_getPivotX }, 503 { "nGetPivotY", "(J)F", (void*) android_view_RenderNode_getPivotY }, 504#endif 505}; 506 507#ifdef USE_OPENGL_RENDERER 508 #define FIND_CLASS(var, className) \ 509 var = env->FindClass(className); \ 510 LOG_FATAL_IF(! var, "Unable to find class " className); 511 512 #define GET_METHOD_ID(var, clazz, methodName, methodDescriptor) \ 513 var = env->GetMethodID(clazz, methodName, methodDescriptor); \ 514 LOG_FATAL_IF(! var, "Unable to find method " methodName); 515#else 516 #define FIND_CLASS(var, className) 517 #define GET_METHOD_ID(var, clazz, methodName, methodDescriptor) 518#endif 519 520int register_android_view_RenderNode(JNIEnv* env) { 521 return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods)); 522} 523 524}; 525 526