android_view_RenderNode.cpp revision 0645128b80621edee70f8cab4afb208fe0c26bec 
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 <Animator.h>
27#include <DisplayListRenderer.h>
28#include <RenderNode.h>
29
30namespace android {
31
32using namespace uirenderer;
33
34/**
35 * Note: OpenGLRenderer JNI layer is generated and compiled only on supported
36 *       devices. This means all the logic must be compiled only when the
37 *       preprocessor variable USE_OPENGL_RENDERER is defined.
38 */
39#ifdef USE_OPENGL_RENDERER
40
41#define SET_AND_DIRTY(prop, val, dirtyFlag) \
42    (reinterpret_cast<RenderNode*>(renderNodePtr)->mutateStagingProperties().prop(val) \
43        ? (reinterpret_cast<RenderNode*>(renderNodePtr)->setPropertyFieldsDirty(dirtyFlag), true) \
44        : false)
45
46// ----------------------------------------------------------------------------
47// DisplayList view properties
48// ----------------------------------------------------------------------------
49
50static void android_view_RenderNode_output(JNIEnv* env,
51        jobject clazz, jlong renderNodePtr) {
52    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
53    renderNode->output();
54}
55
56static jint android_view_RenderNode_getDebugSize(JNIEnv* env,
57        jobject clazz, jlong renderNodePtr) {
58    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
59    return renderNode->getDebugSize();
60}
61
62static jlong android_view_RenderNode_create(JNIEnv* env, jobject clazz, jstring name) {
63    RenderNode* renderNode = new RenderNode();
64    renderNode->incStrong(0);
65    if (name != NULL) {
66        const char* textArray = env->GetStringUTFChars(name, NULL);
67        renderNode->setName(textArray);
68        env->ReleaseStringUTFChars(name, textArray);
69    }
70    return reinterpret_cast<jlong>(renderNode);
71}
72
73static void android_view_RenderNode_destroyRenderNode(JNIEnv* env,
74        jobject clazz, jlong renderNodePtr) {
75    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
76    renderNode->decStrong(0);
77}
78
79static void android_view_RenderNode_setDisplayListData(JNIEnv* env,
80        jobject clazz, jlong renderNodePtr, jlong newDataPtr) {
81    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
82    DisplayListData* newData = reinterpret_cast<DisplayListData*>(newDataPtr);
83    renderNode->setStagingDisplayList(newData);
84}
85
86// ----------------------------------------------------------------------------
87// RenderProperties - setters
88// ----------------------------------------------------------------------------
89
90static jboolean android_view_RenderNode_setLayerType(JNIEnv* env,
91        jobject clazz, jlong renderNodePtr, jint jlayerType) {
92    LayerType layerType = static_cast<LayerType>(jlayerType);
93    return SET_AND_DIRTY(mutateLayerProperties().setType, layerType, RenderNode::GENERIC);
94}
95
96static jboolean android_view_RenderNode_setLayerPaint(JNIEnv* env,
97        jobject clazz, jlong renderNodePtr, jlong paintPtr) {
98    SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
99    return SET_AND_DIRTY(mutateLayerProperties().setFromPaint, paint, RenderNode::GENERIC);
100}
101
102static jboolean android_view_RenderNode_setStaticMatrix(JNIEnv* env,
103        jobject clazz, jlong renderNodePtr, jlong matrixPtr) {
104    SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
105    return SET_AND_DIRTY(setStaticMatrix, matrix, RenderNode::GENERIC);
106}
107
108static jboolean android_view_RenderNode_setAnimationMatrix(JNIEnv* env,
109        jobject clazz, jlong renderNodePtr, jlong matrixPtr) {
110    SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
111    return SET_AND_DIRTY(setAnimationMatrix, matrix, RenderNode::GENERIC);
112}
113
114static jboolean android_view_RenderNode_setClipToBounds(JNIEnv* env,
115        jobject clazz, jlong renderNodePtr, jboolean clipToBounds) {
116    return SET_AND_DIRTY(setClipToBounds, clipToBounds, RenderNode::GENERIC);
117}
118
119static jboolean android_view_RenderNode_setProjectBackwards(JNIEnv* env,
120        jobject clazz, jlong renderNodePtr, jboolean shouldProject) {
121    return SET_AND_DIRTY(setProjectBackwards, shouldProject, RenderNode::GENERIC);
122}
123
124static jboolean android_view_RenderNode_setProjectionReceiver(JNIEnv* env,
125        jobject clazz, jlong renderNodePtr, jboolean shouldRecieve) {
126    return SET_AND_DIRTY(setProjectionReceiver, shouldRecieve, RenderNode::GENERIC);
127}
128
129static jboolean android_view_RenderNode_setOutlineRoundRect(JNIEnv* env,
130        jobject clazz, jlong renderNodePtr, jint left, jint top,
131        jint right, jint bottom, jfloat radius) {
132    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
133    renderNode->mutateStagingProperties().mutableOutline().setRoundRect(left, top, right, bottom, radius);
134    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
135    return true;
136}
137
138static jboolean android_view_RenderNode_setOutlineConvexPath(JNIEnv* env,
139        jobject clazz, jlong renderNodePtr, jlong outlinePathPtr) {
140    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
141    SkPath* outlinePath = reinterpret_cast<SkPath*>(outlinePathPtr);
142    renderNode->mutateStagingProperties().mutableOutline().setConvexPath(outlinePath);
143    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
144    return true;
145}
146
147static jboolean android_view_RenderNode_setOutlineEmpty(JNIEnv* env,
148        jobject clazz, jlong renderNodePtr) {
149    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
150    renderNode->mutateStagingProperties().mutableOutline().setEmpty();
151    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
152    return true;
153}
154
155static jboolean android_view_RenderNode_setOutlineNone(JNIEnv* env,
156        jobject clazz, jlong renderNodePtr) {
157    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
158    renderNode->mutateStagingProperties().mutableOutline().setNone();
159    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
160    return true;
161}
162
163static jboolean android_view_RenderNode_setClipToOutline(JNIEnv* env,
164        jobject clazz, jlong renderNodePtr, jboolean clipToOutline) {
165    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
166    renderNode->mutateStagingProperties().mutableOutline().setShouldClip(clipToOutline);
167    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
168    return true;
169}
170
171static jboolean android_view_RenderNode_setRevealClip(JNIEnv* env,
172        jobject clazz, jlong renderNodePtr, jboolean shouldClip, jboolean inverseClip,
173        jfloat x, jfloat y, jfloat radius) {
174    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
175    renderNode->mutateStagingProperties().mutableRevealClip().set(
176            shouldClip, inverseClip, x, y, radius);
177    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
178    return true;
179}
180
181static jboolean android_view_RenderNode_setAlpha(JNIEnv* env,
182        jobject clazz, jlong renderNodePtr, float alpha) {
183    return SET_AND_DIRTY(setAlpha, alpha, RenderNode::ALPHA);
184}
185
186static jboolean android_view_RenderNode_setHasOverlappingRendering(JNIEnv* env,
187        jobject clazz, jlong renderNodePtr, bool hasOverlappingRendering) {
188    return SET_AND_DIRTY(setHasOverlappingRendering, hasOverlappingRendering,
189            RenderNode::GENERIC);
190}
191
192static jboolean android_view_RenderNode_setElevation(JNIEnv* env,
193        jobject clazz, jlong renderNodePtr, float elevation) {
194    return SET_AND_DIRTY(setElevation, elevation, RenderNode::Z);
195}
196
197static jboolean android_view_RenderNode_setTranslationX(JNIEnv* env,
198        jobject clazz, jlong renderNodePtr, float tx) {
199    return SET_AND_DIRTY(setTranslationX, tx, RenderNode::TRANSLATION_X | RenderNode::X);
200}
201
202static jboolean android_view_RenderNode_setTranslationY(JNIEnv* env,
203        jobject clazz, jlong renderNodePtr, float ty) {
204    return SET_AND_DIRTY(setTranslationY, ty, RenderNode::TRANSLATION_Y | RenderNode::Y);
205}
206
207static jboolean android_view_RenderNode_setTranslationZ(JNIEnv* env,
208        jobject clazz, jlong renderNodePtr, float tz) {
209    return SET_AND_DIRTY(setTranslationZ, tz, RenderNode::TRANSLATION_Z | RenderNode::Z);
210}
211
212static jboolean android_view_RenderNode_setRotation(JNIEnv* env,
213        jobject clazz, jlong renderNodePtr, float rotation) {
214    return SET_AND_DIRTY(setRotation, rotation, RenderNode::ROTATION);
215}
216
217static jboolean android_view_RenderNode_setRotationX(JNIEnv* env,
218        jobject clazz, jlong renderNodePtr, float rx) {
219    return SET_AND_DIRTY(setRotationX, rx, RenderNode::ROTATION_X);
220}
221
222static jboolean android_view_RenderNode_setRotationY(JNIEnv* env,
223        jobject clazz, jlong renderNodePtr, float ry) {
224    return SET_AND_DIRTY(setRotationY, ry, RenderNode::ROTATION_Y);
225}
226
227static jboolean android_view_RenderNode_setScaleX(JNIEnv* env,
228        jobject clazz, jlong renderNodePtr, float sx) {
229    return SET_AND_DIRTY(setScaleX, sx, RenderNode::SCALE_X);
230}
231
232static jboolean android_view_RenderNode_setScaleY(JNIEnv* env,
233        jobject clazz, jlong renderNodePtr, float sy) {
234    return SET_AND_DIRTY(setScaleY, sy, RenderNode::SCALE_Y);
235}
236
237static jboolean android_view_RenderNode_setPivotX(JNIEnv* env,
238        jobject clazz, jlong renderNodePtr, float px) {
239    return SET_AND_DIRTY(setPivotX, px, RenderNode::GENERIC);
240}
241
242static jboolean android_view_RenderNode_setPivotY(JNIEnv* env,
243        jobject clazz, jlong renderNodePtr, float py) {
244    return SET_AND_DIRTY(setPivotY, py, RenderNode::GENERIC);
245}
246
247static jboolean android_view_RenderNode_setCameraDistance(JNIEnv* env,
248        jobject clazz, jlong renderNodePtr, float distance) {
249    return SET_AND_DIRTY(setCameraDistance, distance, RenderNode::GENERIC);
250}
251
252static jboolean android_view_RenderNode_setLeft(JNIEnv* env,
253        jobject clazz, jlong renderNodePtr, int left) {
254    return SET_AND_DIRTY(setLeft, left, RenderNode::X);
255}
256
257static jboolean android_view_RenderNode_setTop(JNIEnv* env,
258        jobject clazz, jlong renderNodePtr, int top) {
259    return SET_AND_DIRTY(setTop, top, RenderNode::Y);
260}
261
262static jboolean android_view_RenderNode_setRight(JNIEnv* env,
263        jobject clazz, jlong renderNodePtr, int right) {
264    return SET_AND_DIRTY(setRight, right, RenderNode::X);
265}
266
267static jboolean android_view_RenderNode_setBottom(JNIEnv* env,
268        jobject clazz, jlong renderNodePtr, int bottom) {
269    return SET_AND_DIRTY(setBottom, bottom, RenderNode::Y);
270}
271
272static jboolean android_view_RenderNode_setLeftTopRightBottom(JNIEnv* env,
273        jobject clazz, jlong renderNodePtr, int left, int top,
274        int right, int bottom) {
275    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
276    if (renderNode->mutateStagingProperties().setLeftTopRightBottom(left, top, right, bottom)) {
277        renderNode->setPropertyFieldsDirty(RenderNode::X | RenderNode::Y);
278        return true;
279    }
280    return false;
281}
282
283static jboolean android_view_RenderNode_offsetLeftAndRight(JNIEnv* env,
284        jobject clazz, jlong renderNodePtr, float offset) {
285    return SET_AND_DIRTY(offsetLeftRight, offset, RenderNode::X);
286}
287
288static jboolean android_view_RenderNode_offsetTopAndBottom(JNIEnv* env,
289        jobject clazz, jlong renderNodePtr, float offset) {
290    return SET_AND_DIRTY(offsetTopBottom, offset, RenderNode::Y);
291}
292
293// ----------------------------------------------------------------------------
294// RenderProperties - getters
295// ----------------------------------------------------------------------------
296
297static jboolean android_view_RenderNode_hasOverlappingRendering(JNIEnv* env,
298        jobject clazz, jlong renderNodePtr) {
299    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
300    return renderNode->stagingProperties().hasOverlappingRendering();
301}
302
303static jboolean android_view_RenderNode_getClipToOutline(JNIEnv* env,
304        jobject clazz, jlong renderNodePtr) {
305    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
306    return renderNode->stagingProperties().getOutline().getShouldClip();
307}
308
309static jfloat android_view_RenderNode_getAlpha(JNIEnv* env,
310        jobject clazz, jlong renderNodePtr) {
311    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
312    return renderNode->stagingProperties().getAlpha();
313}
314
315static jfloat android_view_RenderNode_getLeft(JNIEnv* env,
316        jobject clazz, jlong renderNodePtr) {
317    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
318    return renderNode->stagingProperties().getLeft();
319}
320
321static jfloat android_view_RenderNode_getTop(JNIEnv* env,
322        jobject clazz, jlong renderNodePtr) {
323    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
324    return renderNode->stagingProperties().getTop();
325}
326
327static jfloat android_view_RenderNode_getRight(JNIEnv* env,
328        jobject clazz, jlong renderNodePtr) {
329    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
330    return renderNode->stagingProperties().getRight();
331}
332
333static jfloat android_view_RenderNode_getBottom(JNIEnv* env,
334        jobject clazz, jlong renderNodePtr) {
335    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
336    return renderNode->stagingProperties().getBottom();
337}
338
339static jfloat android_view_RenderNode_getCameraDistance(JNIEnv* env,
340        jobject clazz, jlong renderNodePtr) {
341    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
342    return renderNode->stagingProperties().getCameraDistance();
343}
344
345static jfloat android_view_RenderNode_getScaleX(JNIEnv* env,
346        jobject clazz, jlong renderNodePtr) {
347    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
348    return renderNode->stagingProperties().getScaleX();
349}
350
351static jfloat android_view_RenderNode_getScaleY(JNIEnv* env,
352        jobject clazz, jlong renderNodePtr) {
353    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
354    return renderNode->stagingProperties().getScaleY();
355}
356
357static jfloat android_view_RenderNode_getElevation(JNIEnv* env,
358        jobject clazz, jlong renderNodePtr) {
359    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
360    return renderNode->stagingProperties().getElevation();
361}
362
363static jfloat android_view_RenderNode_getTranslationX(JNIEnv* env,
364        jobject clazz, jlong renderNodePtr) {
365    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
366    return renderNode->stagingProperties().getTranslationX();
367}
368
369static jfloat android_view_RenderNode_getTranslationY(JNIEnv* env,
370        jobject clazz, jlong renderNodePtr) {
371    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
372    return renderNode->stagingProperties().getTranslationY();
373}
374
375static jfloat android_view_RenderNode_getTranslationZ(JNIEnv* env,
376        jobject clazz, jlong renderNodePtr) {
377    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
378    return renderNode->stagingProperties().getTranslationZ();
379}
380
381static jfloat android_view_RenderNode_getRotation(JNIEnv* env,
382        jobject clazz, jlong renderNodePtr) {
383    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
384    return renderNode->stagingProperties().getRotation();
385}
386
387static jfloat android_view_RenderNode_getRotationX(JNIEnv* env,
388        jobject clazz, jlong renderNodePtr) {
389    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
390    return renderNode->stagingProperties().getRotationX();
391}
392
393static jfloat android_view_RenderNode_getRotationY(JNIEnv* env,
394        jobject clazz, jlong renderNodePtr) {
395    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
396    return renderNode->stagingProperties().getRotationY();
397}
398
399static jboolean android_view_RenderNode_isPivotExplicitlySet(JNIEnv* env,
400        jobject clazz, jlong renderNodePtr) {
401    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
402    return renderNode->stagingProperties().isPivotExplicitlySet();
403}
404
405static jboolean android_view_RenderNode_hasIdentityMatrix(JNIEnv* env,
406        jobject clazz, jlong renderNodePtr) {
407    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
408    renderNode->mutateStagingProperties().updateMatrix();
409    return !renderNode->stagingProperties().hasTransformMatrix();
410}
411
412// ----------------------------------------------------------------------------
413// RenderProperties - computed getters
414// ----------------------------------------------------------------------------
415
416static void android_view_RenderNode_getTransformMatrix(JNIEnv* env,
417        jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) {
418    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
419    SkMatrix* outMatrix = reinterpret_cast<SkMatrix*>(outMatrixPtr);
420
421    renderNode->mutateStagingProperties().updateMatrix();
422    const SkMatrix* transformMatrix = renderNode->stagingProperties().getTransformMatrix();
423
424    if (transformMatrix) {
425        *outMatrix = *transformMatrix;
426    } else {
427        outMatrix->setIdentity();
428    }
429}
430
431static void android_view_RenderNode_getInverseTransformMatrix(JNIEnv* env,
432        jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) {
433    // load transform matrix
434    android_view_RenderNode_getTransformMatrix(env, clazz, renderNodePtr, outMatrixPtr);
435    SkMatrix* outMatrix = reinterpret_cast<SkMatrix*>(outMatrixPtr);
436
437    // return it inverted
438    if (!outMatrix->invert(outMatrix)) {
439        // failed to load inverse, pass back identity
440        outMatrix->setIdentity();
441    }
442}
443
444static jfloat android_view_RenderNode_getPivotX(JNIEnv* env,
445        jobject clazz, jlong renderNodePtr) {
446    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
447    renderNode->mutateStagingProperties().updateMatrix();
448    return renderNode->stagingProperties().getPivotX();
449}
450
451static jfloat android_view_RenderNode_getPivotY(JNIEnv* env,
452        jobject clazz, jlong renderNodePtr) {
453    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
454    renderNode->mutateStagingProperties().updateMatrix();
455    return renderNode->stagingProperties().getPivotY();
456}
457
458// ----------------------------------------------------------------------------
459// RenderProperties - Animations
460// ----------------------------------------------------------------------------
461
462static void android_view_RenderNode_addAnimator(JNIEnv* env, jobject clazz,
463        jlong renderNodePtr, jlong animatorPtr) {
464    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
465    RenderPropertyAnimator* animator = reinterpret_cast<RenderPropertyAnimator*>(animatorPtr);
466    renderNode->addAnimator(animator);
467}
468
469#endif // USE_OPENGL_RENDERER
470
471// ----------------------------------------------------------------------------
472// JNI Glue
473// ----------------------------------------------------------------------------
474
475const char* const kClassPathName = "android/view/RenderNode";
476
477static JNINativeMethod gMethods[] = {
478#ifdef USE_OPENGL_RENDERER
479    { "nCreate",               "(Ljava/lang/String;)J",    (void*) android_view_RenderNode_create },
480    { "nDestroyRenderNode",   "(J)V",   (void*) android_view_RenderNode_destroyRenderNode },
481    { "nSetDisplayListData",   "(JJ)V", (void*) android_view_RenderNode_setDisplayListData },
482    { "nOutput",               "(J)V",  (void*) android_view_RenderNode_output },
483    { "nGetDebugSize",         "(J)I",  (void*) android_view_RenderNode_getDebugSize },
484
485    { "nSetLayerType",         "(JI)Z",  (void*) android_view_RenderNode_setLayerType },
486    { "nSetLayerPaint",        "(JJ)Z",  (void*) android_view_RenderNode_setLayerPaint },
487    { "nSetStaticMatrix",      "(JJ)Z",  (void*) android_view_RenderNode_setStaticMatrix },
488    { "nSetAnimationMatrix",   "(JJ)Z",  (void*) android_view_RenderNode_setAnimationMatrix },
489    { "nSetClipToBounds",      "(JZ)Z",  (void*) android_view_RenderNode_setClipToBounds },
490    { "nSetProjectBackwards",  "(JZ)Z",  (void*) android_view_RenderNode_setProjectBackwards },
491    { "nSetProjectionReceiver","(JZ)Z",  (void*) android_view_RenderNode_setProjectionReceiver },
492
493    { "nSetOutlineRoundRect",  "(JIIIIF)Z", (void*) android_view_RenderNode_setOutlineRoundRect },
494    { "nSetOutlineConvexPath", "(JJ)Z",  (void*) android_view_RenderNode_setOutlineConvexPath },
495    { "nSetOutlineEmpty",      "(J)Z",   (void*) android_view_RenderNode_setOutlineEmpty },
496    { "nSetOutlineNone",       "(J)Z",   (void*) android_view_RenderNode_setOutlineNone },
497    { "nSetClipToOutline",     "(JZ)Z",  (void*) android_view_RenderNode_setClipToOutline },
498    { "nSetRevealClip",        "(JZZFFF)Z", (void*) android_view_RenderNode_setRevealClip },
499
500    { "nSetAlpha",             "(JF)Z",  (void*) android_view_RenderNode_setAlpha },
501    { "nSetHasOverlappingRendering", "(JZ)Z",
502            (void*) android_view_RenderNode_setHasOverlappingRendering },
503    { "nSetElevation",         "(JF)Z",  (void*) android_view_RenderNode_setElevation },
504    { "nSetTranslationX",      "(JF)Z",  (void*) android_view_RenderNode_setTranslationX },
505    { "nSetTranslationY",      "(JF)Z",  (void*) android_view_RenderNode_setTranslationY },
506    { "nSetTranslationZ",      "(JF)Z",  (void*) android_view_RenderNode_setTranslationZ },
507    { "nSetRotation",          "(JF)Z",  (void*) android_view_RenderNode_setRotation },
508    { "nSetRotationX",         "(JF)Z",  (void*) android_view_RenderNode_setRotationX },
509    { "nSetRotationY",         "(JF)Z",  (void*) android_view_RenderNode_setRotationY },
510    { "nSetScaleX",            "(JF)Z",  (void*) android_view_RenderNode_setScaleX },
511    { "nSetScaleY",            "(JF)Z",  (void*) android_view_RenderNode_setScaleY },
512    { "nSetPivotX",            "(JF)Z",  (void*) android_view_RenderNode_setPivotX },
513    { "nSetPivotY",            "(JF)Z",  (void*) android_view_RenderNode_setPivotY },
514    { "nSetCameraDistance",    "(JF)Z",  (void*) android_view_RenderNode_setCameraDistance },
515    { "nSetLeft",              "(JI)Z",  (void*) android_view_RenderNode_setLeft },
516    { "nSetTop",               "(JI)Z",  (void*) android_view_RenderNode_setTop },
517    { "nSetRight",             "(JI)Z",  (void*) android_view_RenderNode_setRight },
518    { "nSetBottom",            "(JI)Z",  (void*) android_view_RenderNode_setBottom },
519    { "nSetLeftTopRightBottom","(JIIII)Z", (void*) android_view_RenderNode_setLeftTopRightBottom },
520    { "nOffsetLeftAndRight",   "(JF)Z",  (void*) android_view_RenderNode_offsetLeftAndRight },
521    { "nOffsetTopAndBottom",   "(JF)Z",  (void*) android_view_RenderNode_offsetTopAndBottom },
522
523    { "nHasOverlappingRendering", "(J)Z",  (void*) android_view_RenderNode_hasOverlappingRendering },
524    { "nGetClipToOutline",        "(J)Z",  (void*) android_view_RenderNode_getClipToOutline },
525    { "nGetAlpha",                "(J)F",  (void*) android_view_RenderNode_getAlpha },
526    { "nGetLeft",                 "(J)F",  (void*) android_view_RenderNode_getLeft },
527    { "nGetTop",                  "(J)F",  (void*) android_view_RenderNode_getTop },
528    { "nGetRight",                "(J)F",  (void*) android_view_RenderNode_getRight },
529    { "nGetBottom",               "(J)F",  (void*) android_view_RenderNode_getBottom },
530    { "nGetCameraDistance",       "(J)F",  (void*) android_view_RenderNode_getCameraDistance },
531    { "nGetScaleX",               "(J)F",  (void*) android_view_RenderNode_getScaleX },
532    { "nGetScaleY",               "(J)F",  (void*) android_view_RenderNode_getScaleY },
533    { "nGetElevation",            "(J)F",  (void*) android_view_RenderNode_getElevation },
534    { "nGetTranslationX",         "(J)F",  (void*) android_view_RenderNode_getTranslationX },
535    { "nGetTranslationY",         "(J)F",  (void*) android_view_RenderNode_getTranslationY },
536    { "nGetTranslationZ",         "(J)F",  (void*) android_view_RenderNode_getTranslationZ },
537    { "nGetRotation",             "(J)F",  (void*) android_view_RenderNode_getRotation },
538    { "nGetRotationX",            "(J)F",  (void*) android_view_RenderNode_getRotationX },
539    { "nGetRotationY",            "(J)F",  (void*) android_view_RenderNode_getRotationY },
540    { "nIsPivotExplicitlySet",    "(J)Z",  (void*) android_view_RenderNode_isPivotExplicitlySet },
541    { "nHasIdentityMatrix",       "(J)Z",  (void*) android_view_RenderNode_hasIdentityMatrix },
542
543    { "nGetTransformMatrix",       "(JJ)V", (void*) android_view_RenderNode_getTransformMatrix },
544    { "nGetInverseTransformMatrix","(JJ)V", (void*) android_view_RenderNode_getInverseTransformMatrix },
545
546    { "nGetPivotX",                "(J)F",  (void*) android_view_RenderNode_getPivotX },
547    { "nGetPivotY",                "(J)F",  (void*) android_view_RenderNode_getPivotY },
548
549    { "nAddAnimator",              "(JJ)V", (void*) android_view_RenderNode_addAnimator },
550#endif
551};
552
553#ifdef USE_OPENGL_RENDERER
554    #define FIND_CLASS(var, className) \
555            var = env->FindClass(className); \
556            LOG_FATAL_IF(! var, "Unable to find class " className);
557
558    #define GET_METHOD_ID(var, clazz, methodName, methodDescriptor) \
559            var = env->GetMethodID(clazz, methodName, methodDescriptor); \
560            LOG_FATAL_IF(! var, "Unable to find method " methodName);
561#else
562    #define FIND_CLASS(var, className)
563    #define GET_METHOD_ID(var, clazz, methodName, methodDescriptor)
564#endif
565
566int register_android_view_RenderNode(JNIEnv* env) {
567    return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
568}
569
570};
571
572