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