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