Imported initial version of osgAndroid
[osgandroid:osgandroid.git] / org.openscenegraph.android / jni / JNIosg.cpp
1 /* @License
2  -------------------------------------------------------------------------------
3  | osgAndroid - Copyright (C) 2012 Rafael Gait\87n, Mirage Technologies S.L.     |
4  |                                                                             |
5  | This library is free software; you can redistribute it and/or modify        |
6  | it under the terms of the GNU Lesser General Public License as published    |
7  | by the Free Software Foundation; either version 3 of the License, or        |
8  | (at your option) any later version.                                         |
9  |                                                                             |
10  | This library is distributed in the hope that it will be useful, but         |
11  | WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY  |
12  | or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public     |
13  | License for more details.                                                   |
14  |                                                                             |
15  | You should have received a copy of the GNU Lesser General Public License    |
16  | along with this software; if not, write to the Free Software Foundation,    |
17  | Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.               |
18  ---------------------------------------------------------------------------- */
19
20 #include <jni.h>
21 #include <android/log.h>
22
23 #include "JNIUtils.h"
24
25 #include <osg/Node>
26 #include <osg/Group>
27 #include <osg/MatrixTransform>
28 #include <osg/Camera>
29 #include <osg/Vec3>
30 #include <osg/Vec4>
31 #include <osg/Matrixf>
32 #include <osg/AnimationPath>
33 #include <osg/io_utils>
34 #include <osg/Texture2D>
35
36 #define  LOG_TAG    "org.openscenegraph.osg.db.JNIOSGCore"
37 #define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
38 #define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
39
40 extern "C"
41 {
42
43 /**
44  * osg::Node
45  */
46 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Node_nativeDispose(JNIEnv *, jclass, jlong cptr)
47 {
48         osg::Node *node = reinterpret_cast<osg::Node *>(cptr);
49         if(node != 0)
50                 node->unref();
51 }
52
53 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Node_nativeSetUpdateCallback(JNIEnv *, jclass, jlong cptr,
54                 jlong lucb)
55 {
56         osg::Node *node = reinterpret_cast<osg::Node *>(cptr);
57         osg::NodeCallback *ucb = reinterpret_cast<osg::NodeCallback *>(lucb);
58         if(node != 0)
59                 node->setUpdateCallback(ucb);
60 }
61
62 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Node_nativeSetRenderBinDetails(JNIEnv *env, jclass, jlong cptr,
63                 jint order, jstring bin)
64 {
65         osg::Node *node = reinterpret_cast<osg::Node *>(cptr);
66         if(node != 0)
67         {
68                 node->getOrCreateStateSet()->setRenderBinDetails(order,jstring2string(env,bin));
69         }
70 }
71
72 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Node_nativeSetTexture2D(JNIEnv *env, jclass, jlong cptr, jlong cptrimage)
73 {
74         osg::Node *node = reinterpret_cast<osg::Node *>(cptr);
75         osg::Image *image = reinterpret_cast<osg::Image *>(cptrimage);
76         if(node != 0 && image != 0)
77         {
78                 LOGE("Setting TEXTURE");
79                 osg::Texture2D *tex = new osg::Texture2D(image);
80                 node->getOrCreateStateSet()->setTextureAttribute(0,tex,
81                                 osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
82         }
83 }
84
85 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Node_nativeSetMode(JNIEnv *env, jclass, jlong cptr,
86                 jint mode, jint value)
87 {
88         osg::Node *node = reinterpret_cast<osg::Node *>(cptr);
89         if(node != 0)
90         {
91                 node->getOrCreateStateSet()->setMode( static_cast<GLenum>(mode),
92                                 static_cast<unsigned int>(value));
93         }
94 }
95
96
97 /**
98  * osg::Group
99  */
100 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Group_nativeDispose(JNIEnv *, jclass, jlong cptr)
101 {
102     osg::Group *g = reinterpret_cast<osg::Group *>(cptr);
103     if(g != 0)
104         g->unref();
105 }
106
107 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Group_nativeCreateGroup(JNIEnv *, jclass, jlong cptr)
108 {
109     osg::Group *g = new osg::Group();
110     g->ref();
111     return reinterpret_cast<jlong>(g);
112 }
113
114 JNIEXPORT jboolean JNICALL Java_org_openscenegraph_osg_core_Group_nativeAddChild(JNIEnv *, jclass, jlong cptr,
115                                                                              jlong cptrnode)
116 {
117     osg::Group *g = reinterpret_cast<osg::Group *>(cptr);
118     osg::Node *n = reinterpret_cast<osg::Node *>(cptrnode);
119     if(g != 0 && n != 0)
120         return g->addChild(n)?JNI_TRUE:JNI_FALSE;
121     return JNI_FALSE;
122 }
123
124 JNIEXPORT jboolean JNICALL Java_org_openscenegraph_osg_core_Group_nativeRemoveChild(JNIEnv *, jclass, jlong cptr,
125                                                                              jlong cptrnode)
126 {
127     osg::Group *g = reinterpret_cast<osg::Group *>(cptr);
128     osg::Node *n = reinterpret_cast<osg::Node *>(cptrnode);
129     if(g != 0 && n != 0)
130         return g->removeChild(n)?JNI_TRUE:JNI_FALSE;
131     return JNI_FALSE;
132 }
133
134 JNIEXPORT jint JNICALL Java_org_openscenegraph_osg_core_Group_nativeGetNumChildren(JNIEnv *, jclass, jlong cptr)
135 {
136     osg::Group *g = reinterpret_cast<osg::Group *>(cptr);
137     if(g != 0)
138         return g->getNumChildren();
139     return 0;
140 }
141
142 /**
143  * osg::MatrixTransform
144  */
145 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_MatrixTransform_nativeDispose(JNIEnv *, jclass, jlong cptr)
146 {
147     osg::MatrixTransform *g = reinterpret_cast<osg::MatrixTransform *>(cptr);
148     g->getOrCreateStateSet()->setMode(GL_NORMALIZE,osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
149     if(g != 0)
150         g->unref();
151 }
152
153 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_MatrixTransform_nativeCreateMatrixTransform(JNIEnv *, jclass, jlong cptr)
154 {
155     osg::MatrixTransform *g = new osg::MatrixTransform();
156     g->ref();
157     return reinterpret_cast<jlong>(g);
158 }
159
160 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_MatrixTransform_nativeSetMatrix(JNIEnv *, jclass, jlong cptr,
161                                                                              jlong cptrmatrix)
162 {
163     osg::MatrixTransform *g = reinterpret_cast<osg::MatrixTransform *>(cptr);
164     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptrmatrix);
165     if(g != 0 && m != 0)
166     {
167         g->setMatrix(*m);
168         //LOGI("SETTING MATRIX");
169     }
170 }
171
172 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_MatrixTransform_nativeGetMatrix(JNIEnv *, jclass, jlong cptr)
173 {
174     osg::MatrixTransform *g = reinterpret_cast<osg::MatrixTransform *>(cptr);
175     if(g != 0)
176     {
177         osg::Matrix mat = g->getMatrix();
178         osg::RefMatrixf *matrix = new osg::RefMatrixf(mat);
179         matrix->ref();
180         return reinterpret_cast<jlong>(matrix);
181     }
182     return 0l;
183 }
184
185
186 /**
187  * osg::Camera
188  */
189 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Camera_nativeDispose(JNIEnv *, jclass, jlong cptr)
190 {
191         osg::Camera *camera = reinterpret_cast<osg::Camera *>(cptr);
192         if(camera != 0)
193                 camera->unref();
194 }
195
196 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Camera_nativeSetClearColor(JNIEnv *, jclass, jlong cptr,
197                                                                                                                                                         jfloat r, jfloat g, jfloat b, jfloat a)
198 {
199         osg::Camera *camera = reinterpret_cast<osg::Camera *>(cptr);
200         if(camera != 0)
201         {
202                 camera->setClearColor(osg::Vec4(r,g,b,a));
203         }
204 }
205
206 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Camera_nativeSetViewMatrixAsLookAt(JNIEnv *, jclass, jlong cptr,
207                                                                             jlong eye, jlong center, jlong up)
208 {
209     osg::Camera *camera = reinterpret_cast<osg::Camera *>(cptr);
210     RefVec3 *e = reinterpret_cast<RefVec3 *>(eye);
211     RefVec3 *c = reinterpret_cast<RefVec3 *>(center);
212     RefVec3 *u = reinterpret_cast<RefVec3 *>(up);
213     if(camera != 0)
214     {
215         camera->setViewMatrixAsLookAt(*e,*c,*u);
216     }
217 }
218
219 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Camera_nativeSetViewMatrix(JNIEnv *, jclass, jlong cptr,
220                                                                             jlong cptrmatrix)
221 {
222     osg::Camera *camera = reinterpret_cast<osg::Camera *>(cptr);
223     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptrmatrix);
224     if(camera != 0 && m!=0)
225     {
226         camera->setViewMatrix(*m);
227     }
228 }
229
230 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Camera_nativeSetProjectionMatrix(JNIEnv *, jclass, jlong cptr,
231                                                                             jlong cptrmatrix)
232 {
233     osg::Camera *camera = reinterpret_cast<osg::Camera *>(cptr);
234     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptrmatrix);
235     if(camera != 0 && m!=0)
236     {
237         camera->setProjectionMatrix(*m);
238     }
239 }
240
241 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Camera_nativeSetProjectionMatrixAsOrtho2D(JNIEnv *, jclass, jlong cptr,
242                                                                             jdouble left, jdouble right, jdouble bottom, jdouble top)
243 {
244     osg::Camera *camera = reinterpret_cast<osg::Camera *>(cptr);
245     if(camera != 0)
246     {
247         camera->setProjectionMatrixAsOrtho2D(left,right,bottom,top);
248     }
249 }
250
251 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Camera_nativeSetProjectionMatrixAsPerspective(JNIEnv *, jclass, jlong cptr,
252                                                                             jdouble fovy, jdouble aspectRatio, jdouble zNear, jdouble zFar)
253 {
254     osg::Camera *camera = reinterpret_cast<osg::Camera *>(cptr);
255     if(camera != 0)
256     {
257         camera->setProjectionMatrixAsPerspective(fovy,aspectRatio,zNear,zFar);
258     }
259 }
260
261 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Camera_nativeSetCullLeftMask(JNIEnv *env, jclass, jlong cptr,
262                 jboolean value)
263 {
264     osg::Camera *camera = reinterpret_cast<osg::Camera *>(cptr);
265     if(camera != 0)
266     {
267         if(value == JNI_TRUE)
268         {
269                 camera->setNodeMask(0x00000001);
270         }
271         else
272         {
273                 camera->setNodeMask(0xffffffff);
274         }
275     }
276 }
277
278 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Camera_nativeSetCullRightMask(JNIEnv *env, jclass, jlong cptr,
279                 jboolean value)
280 {
281     osg::Camera *camera = reinterpret_cast<osg::Camera *>(cptr);
282     if(camera != 0)
283     {
284         if(value == JNI_TRUE)
285         {
286                 camera->setNodeMask(0x00000002);
287         }
288         else
289         {
290                 camera->setNodeMask(0xffffffff);
291         }
292     }
293 }
294
295 /**
296  * osg::Vec3
297  */
298 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeDispose(JNIEnv *, jclass, jlong cptr)
299 {
300         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
301         if(v != 0)
302                 v->unref();
303 }
304
305 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeCreateVec3(JNIEnv *, jclass)
306 {
307         RefVec3 *v = new RefVec3();
308         v->ref();
309         return reinterpret_cast<jlong>(v);
310 }
311
312 JNIEXPORT float JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeX(JNIEnv *, jclass, jlong cptr)
313 {
314         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
315         if(v != 0)
316         {
317                 return v->x();
318         }
319         return 0.0f;
320 }
321
322 JNIEXPORT float JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeY(JNIEnv *, jclass, jlong cptr)
323 {
324         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
325         if(v != 0)
326         {
327                 return v->y();
328         }
329         return 0.0f;
330 }
331
332 JNIEXPORT float JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeZ(JNIEnv *, jclass, jlong cptr)
333 {
334         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
335         if(v != 0)
336         {
337                 return v->z();
338         }
339         return 0.0f;
340 }
341
342 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeSet(JNIEnv *, jclass, jlong cptr,
343                 jfloat x, jfloat y, jfloat z)
344 {
345         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
346         if(v != 0)
347         {
348                 v->set(x,y,z);
349         }
350 }
351
352 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeSetX(JNIEnv *, jclass, jlong cptr,
353                 jfloat value)
354 {
355         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
356         if(v != 0)
357         {
358                 v->x() = value;
359         }
360 }
361
362 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeSetY(JNIEnv *, jclass, jlong cptr,
363                 jfloat value)
364 {
365         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
366         if(v != 0)
367         {
368                 v->y() = value;
369         }
370 }
371
372 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeSetZ(JNIEnv *, jclass, jlong cptr,
373                 jfloat value)
374 {
375         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
376         if(v != 0)
377         {
378                 v->z() = value;
379         }
380 }
381
382 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeLength(JNIEnv *, jclass, jlong cptr)
383 {
384         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
385         if(v != 0)
386         {
387                 return v->length();
388         }
389         return 0.0f;
390 }
391
392 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeLength2(JNIEnv *, jclass, jlong cptr)
393 {
394         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
395         if(v != 0)
396         {
397                 return v->length2();
398         }
399         return 0.0f;
400 }
401
402 JNIEXPORT long JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeDiv(JNIEnv *, jclass, jlong cptr,
403                 jfloat value)
404 {
405         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
406         if(v != 0)
407         {
408                 osg::Vec3 res = *v/value;
409                 RefVec3 *refRes = new RefVec3();
410                 refRes->set(res);
411                 refRes->ref();
412                 return reinterpret_cast<jlong>(refRes);
413         }
414         return 0l;
415 }
416
417 JNIEXPORT float JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeDotProduct(JNIEnv *, jclass, jlong cptr,
418                 jlong lrhs)
419 {
420         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
421         RefVec3 *rhs = reinterpret_cast<RefVec3 *>(lrhs);
422         if(v != 0 && rhs !=0)
423         {
424                 return (*v)*(*rhs);
425         }
426         return 0;
427 }
428
429 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeCrossProduct(JNIEnv *, jclass, jlong cptr,
430                 jlong lrhs)
431 {
432         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
433         RefVec3 *rhs = reinterpret_cast<RefVec3 *>(lrhs);
434         if(v != 0 && rhs !=0)
435         {
436                 osg::Vec3 res = (*v)^(*rhs);
437                 RefVec3 *refRes = new RefVec3();
438                 refRes->set(res);
439                 refRes->ref();
440                 return reinterpret_cast<jlong>(refRes);
441         }
442         return 0l;
443 }
444
445 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeEscalarProduct(JNIEnv *, jclass, jlong cptr,
446                 jfloat value)
447 {
448         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
449         if(v != 0)
450         {
451                 osg::Vec3 res = (*v)*value;
452                 RefVec3 *refRes = new RefVec3();
453                 refRes->set(res);
454                 refRes->ref();
455                 return reinterpret_cast<jlong>(refRes);
456         }
457         return 0l;
458 }
459
460 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeSum(JNIEnv *, jclass, jlong cptr,
461                 jlong lrhs)
462 {
463         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
464         RefVec3 *rhs = reinterpret_cast<RefVec3 *>(lrhs);
465         if(v != 0 && rhs !=0)
466         {
467                 osg::Vec3 res = (*v)+(*rhs);
468                 RefVec3 *refRes = new RefVec3();
469                 refRes->set(res);
470                 refRes->ref();
471                 return reinterpret_cast<jlong>(refRes);
472         }
473         return 0l;
474 }
475
476 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeSub(JNIEnv *, jclass, jlong cptr,
477                 jlong lrhs)
478 {
479         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
480         RefVec3 *rhs = reinterpret_cast<RefVec3 *>(lrhs);
481         if(v != 0 && rhs !=0)
482         {
483                 osg::Vec3 res = (*v)-(*rhs);
484                 RefVec3 *refRes = new RefVec3();
485                 refRes->set(res);
486                 refRes->ref();
487                 return reinterpret_cast<jlong>(refRes);
488         }
489         return 0l;
490 }
491
492 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeNormalize(JNIEnv *, jclass, jlong cptr)
493 {
494         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
495         if(v != 0)
496         {
497                 return v->normalize();
498         }
499         return 0;
500 }
501
502 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Vec3_nativeNegation(JNIEnv *, jclass, jlong cptr)
503 {
504         RefVec3 *v = reinterpret_cast<RefVec3 *>(cptr);
505         if(v != 0)
506         {
507                 osg::Vec3 res = -(*v);
508                 RefVec3 *refRes = new RefVec3();
509                 refRes->set(res);
510                 refRes->ref();
511                 return reinterpret_cast<jlong>(refRes);
512         }
513         return 0l;
514 }
515
516 /**
517  * osg::Vec4
518  */
519 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeDispose(JNIEnv *, jclass, jlong cptr)
520 {
521         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
522         if(v != 0)
523                 v->unref();
524 }
525
526 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeCreateVec4(JNIEnv *, jclass)
527 {
528         RefVec4 *v = new RefVec4();
529         v->ref();
530         return reinterpret_cast<jlong>(v);
531 }
532
533 JNIEXPORT float JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeX(JNIEnv *, jclass, jlong cptr)
534 {
535         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
536         if(v != 0)
537         {
538                 return v->x();
539         }
540         return 0.0f;
541 }
542
543 JNIEXPORT float JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeY(JNIEnv *, jclass, jlong cptr)
544 {
545         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
546         if(v != 0)
547         {
548                 return v->y();
549         }
550         return 0.0f;
551 }
552
553 JNIEXPORT float JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeZ(JNIEnv *, jclass, jlong cptr)
554 {
555         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
556         if(v != 0)
557         {
558                 return v->z();
559         }
560         return 0.0f;
561 }
562
563 JNIEXPORT float JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeW(JNIEnv *, jclass, jlong cptr)
564 {
565         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
566         if(v != 0)
567         {
568                 return v->w();
569         }
570         return 0.0f;
571 }
572
573 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeSet(JNIEnv *, jclass, jlong cptr,
574                 jfloat x, jfloat y, jfloat z, jfloat w)
575 {
576         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
577         if(v != 0)
578         {
579                 v->set(x,y,z,w);
580         }
581 }
582
583 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeSetX(JNIEnv *, jclass, jlong cptr,
584                 jfloat value)
585 {
586         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
587         if(v != 0)
588         {
589                 v->x() = value;
590         }
591 }
592
593 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeSetY(JNIEnv *, jclass, jlong cptr,
594                 jfloat value)
595 {
596         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
597         if(v != 0)
598         {
599                 v->y() = value;
600         }
601 }
602
603 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeSetZ(JNIEnv *, jclass, jlong cptr,
604                 jfloat value)
605 {
606         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
607         if(v != 0)
608         {
609                 v->z() = value;
610         }
611 }
612
613 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeSetW(JNIEnv *, jclass, jlong cptr,
614                 jfloat value)
615 {
616         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
617         if(v != 0)
618         {
619                 v->w() = value;
620         }
621 }
622
623
624 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeLength(JNIEnv *, jclass, jlong cptr)
625 {
626         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
627         if(v != 0)
628         {
629                 return v->length();
630         }
631         return 0.0f;
632 }
633
634 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeLength2(JNIEnv *, jclass, jlong cptr)
635 {
636         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
637         if(v != 0)
638         {
639                 return v->length2();
640         }
641         return 0.0f;
642 }
643
644 JNIEXPORT long JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeDiv(JNIEnv *, jclass, jlong cptr,
645                 jfloat value)
646 {
647         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
648         if(v != 0)
649         {
650                 osg::Vec4 res = *v/value;
651                 RefVec4 *refRes = new RefVec4();
652                 refRes->set(res.x(),res.y(),res.z(),res.w());
653                 refRes->ref();
654                 return reinterpret_cast<jlong>(refRes);
655         }
656         return 0l;
657 }
658
659 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeEscalarProduct(JNIEnv *, jclass, jlong cptr,
660                 jfloat value)
661 {
662         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
663         if(v != 0)
664         {
665                 osg::Vec4 res = (*v)*value;
666                 RefVec4 *refRes = new RefVec4();
667                 refRes->set(res.x(),res.y(),res.z(),res.w());
668                 refRes->ref();
669                 return reinterpret_cast<jlong>(refRes);
670         }
671         return 0l;
672 }
673
674 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeSum(JNIEnv *, jclass, jlong cptr,
675                 jlong lrhs)
676 {
677         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
678         RefVec4 *rhs = reinterpret_cast<RefVec4 *>(lrhs);
679         if(v != 0 && rhs !=0)
680         {
681                 osg::Vec4 res = (*v)+(*rhs);
682                 RefVec4 *refRes = new RefVec4();
683                 refRes->set(res.x(),res.y(),res.z(),res.w());
684                 refRes->ref();
685                 return reinterpret_cast<jlong>(refRes);
686         }
687         return 0l;
688 }
689
690 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeSub(JNIEnv *, jclass, jlong cptr,
691                 jlong lrhs)
692 {
693         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
694         RefVec4 *rhs = reinterpret_cast<RefVec4 *>(lrhs);
695         if(v != 0 && rhs !=0)
696         {
697                 osg::Vec4 res = (*v)-(*rhs);
698                 RefVec4 *refRes = new RefVec4();
699                 refRes->set(res.x(),res.y(),res.z(),res.w());
700                 refRes->ref();
701                 return reinterpret_cast<jlong>(refRes);
702         }
703         return 0l;
704 }
705
706 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeNormalize(JNIEnv *, jclass, jlong cptr)
707 {
708         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
709         if(v != 0)
710         {
711                 return v->normalize();
712         }
713         return 0;
714 }
715
716 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Vec4_nativeNegation(JNIEnv *, jclass, jlong cptr)
717 {
718         RefVec4 *v = reinterpret_cast<RefVec4 *>(cptr);
719         if(v != 0)
720         {
721                 osg::Vec4 res = -(*v);
722                 RefVec4 *refRes = new RefVec4();
723                 refRes->set(res.x(),res.y(),res.z(),res.w());
724                 refRes->ref();
725                 return reinterpret_cast<jlong>(refRes);
726         }
727         return 0l;
728 }
729
730 /**
731  * osg::Quat
732  */
733 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Quat_nativeDispose(JNIEnv *, jclass, jlong cptr)
734 {
735         RefQuat *q = reinterpret_cast<RefQuat *>(cptr);
736         if(q != 0)
737                 q->unref();
738 }
739
740 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Quat_nativeCreateQuat(JNIEnv *, jclass)
741 {
742         RefQuat *q = new RefQuat();
743         q->set(0,0,0,1);
744         q->ref();
745         return reinterpret_cast<jlong>(q);
746 }
747 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Quat_nativeSet(JNIEnv *, jclass, jlong cptr,
748                 jfloat q1, jfloat q2, jfloat q3, jfloat q4)
749 {
750         RefQuat *q = reinterpret_cast<RefQuat *>(cptr);
751         if(q != 0)
752                 q->set(q1,q2,q3,q4);
753 }
754 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Quat_nativeX(JNIEnv *, jclass, jlong cptr)
755 {
756         RefQuat *q = reinterpret_cast<RefQuat *>(cptr);
757         if(q != 0)
758                 return q->x();
759         return 0.0f;
760 }
761 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Quat_nativeY(JNIEnv *, jclass, jlong cptr)
762 {
763         RefQuat *q = reinterpret_cast<RefQuat *>(cptr);
764         if(q != 0)
765                 return q->y();
766         return 0.0f;
767 }
768 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Quat_nativeZ(JNIEnv *, jclass, jlong cptr)
769 {
770         RefQuat *q = reinterpret_cast<RefQuat *>(cptr);
771         if(q != 0)
772                 return q->z();
773         return 0.0f;
774 }
775 JNIEXPORT jfloat JNICALL Java_org_openscenegraph_osg_core_Quat_nativeW(JNIEnv *, jclass, jlong cptr)
776 {
777         RefQuat *q = reinterpret_cast<RefQuat *>(cptr);
778         if(q != 0)
779                 return q->w();
780         return 1.0f;
781 }
782 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Quat_nativeMakeRotateAngleVec3(JNIEnv *, jclass, jlong cptr,
783                 jfloat angle, jfloat x, jfloat y, jfloat z)
784 {
785         RefQuat *q = reinterpret_cast<RefQuat *>(cptr);
786         if(q != 0)
787                 q->makeRotate(angle, x, y, z);
788 }
789 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Quat_nativeMakeRotateVec3Vec3(JNIEnv *, jclass, jlong cptr,
790                 jlong lvec1, jlong lvec2)
791 {
792         RefQuat *q = reinterpret_cast<RefQuat *>(cptr);
793         RefVec3 *vec1 = reinterpret_cast<RefVec3 *>(lvec1);
794         RefVec3 *vec2 = reinterpret_cast<RefVec3 *>(lvec2);
795         if(q != 0 && vec1 != 0 && vec2 != 0)
796                 q->makeRotate(*vec1,*vec2);
797 }
798
799 /**
800  * osg::Matrix
801  */
802 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeCreateMatrix(JNIEnv *, jclass)
803 {
804     osg::RefMatrixf *m = new osg::RefMatrixf();
805     m->ref();
806     return reinterpret_cast<jlong>(m);
807 }
808
809 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeDispose(JNIEnv *, jclass, jlong cptr)
810 {
811     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
812     if(m != 0)
813     {
814         m->unref();
815     }
816 }
817
818 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeSet(JNIEnv *, jclass, jlong cptr,
819         jfloat a00, jfloat a01, jfloat a02, jfloat a03, jfloat a10, jfloat a11, jfloat a12, jfloat a13,
820         jfloat a20, jfloat a21, jfloat a22, jfloat a23, jfloat a30, jfloat a31, jfloat a32, jfloat a33)
821 {
822     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
823     if(m != 0)
824     {
825         m->set(a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22,
826                 a23, a30, a31, a32, a33);
827         //osg::notify(osg::NOTICE) << "Matrix:" << *m << std::endl;
828     }
829 }
830
831 JNIEXPORT jboolean JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeIsIdentity(JNIEnv *, jclass, jlong cptr)
832 {
833     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
834     if(m != 0)
835     {
836         return m->isIdentity()?JNI_TRUE:JNI_FALSE;
837     }
838     return JNI_FALSE;
839 }
840
841 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeMakeIdentity(JNIEnv *, jclass, jlong cptr)
842 {
843     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
844     if(m != 0)
845     {
846         m->makeIdentity();
847     }
848 }
849
850 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeMakeScale(JNIEnv *, jclass, jlong cptr, jfloat v1, jfloat v2,
851         jfloat v3)
852 {
853     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
854     if(m != 0)
855     {
856         m->makeScale(v1,v2,v3);
857     }
858 }
859
860 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeMakeTranslate(JNIEnv *, jclass, jlong cptr, jfloat v1,
861         jfloat v2, jfloat v3)
862 {
863     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
864     if(m != 0)
865     {
866         m->makeTranslate(v1,v2,v3);
867     }
868 }
869
870 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeMakeRotate(JNIEnv *, jclass, jlong cptr, jfloat angle,
871         jfloat x, jfloat y, jfloat z)
872 {
873     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
874     if(m != 0)
875     {
876         m->makeRotate(angle,x,y,z);
877     }
878 }
879
880 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeMakeRotateQuat(JNIEnv *, jclass, jlong cptr, jlong quat)
881 {
882     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
883     RefQuat *q = reinterpret_cast<RefQuat*>(quat);
884     if(m != 0 && q != 0)
885     {
886         m->makeRotate(*q);
887     }
888 }
889
890 JNIEXPORT jboolean JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeInvert(JNIEnv *, jclass, jlong cptr,
891                                                                                 jlong matrix)
892 {
893     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
894     osg::RefMatrixf *rhs = reinterpret_cast<osg::RefMatrixf *>(cptr);
895     if(m != 0)
896     {
897         return m->invert(*rhs)?JNI_TRUE:JNI_FALSE;
898     }
899     return JNI_FALSE;
900 }
901
902 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Matrix_nativePreMult(JNIEnv *, jclass, jlong cptr, jlong matrix)
903 {
904     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
905     osg::RefMatrixf *rhs = reinterpret_cast<osg::RefMatrixf *>(cptr);
906     if(m != 0)
907     {
908         m->preMult(*rhs);
909     }
910 }
911
912 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Matrix_nativePostMult(JNIEnv *, jclass, jlong cptr, jlong matrix)
913 {
914     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
915     osg::RefMatrixf *rhs = reinterpret_cast<osg::RefMatrixf *>(cptr);
916     if(m != 0)
917     {
918         m->postMult(*rhs);
919     }
920 }
921
922 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Matrix_nativeMakeLookAt(JNIEnv *, jclass, jlong cptr,
923                 jlong cptr_eye, jlong cptr_center, jlong cptr_up)
924 {
925     osg::RefMatrixf *m = reinterpret_cast<osg::RefMatrixf *>(cptr);
926     RefVec3 *eye = reinterpret_cast<RefVec3 *>(cptr_eye);
927     RefVec3 *center = reinterpret_cast<RefVec3 *>(cptr_center);
928     RefVec3 *up = reinterpret_cast<RefVec3 *>(cptr_up);
929     if(m != 0 && eye !=0 && center != 0 && up != 0)
930     {
931         m->makeLookAt(*eye,*center,*up);
932     }
933 }
934
935
936
937 /**
938  * osg::AnimationPathCallback
939  */
940 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeDispose(JNIEnv *, jclass, jlong cptr)
941 {
942         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
943         if(cb != 0)
944         {
945                 cb->unref();
946         }
947 }
948
949 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeCreateAnimationPathCallback(JNIEnv *, jclass)
950 {
951         osg::AnimationPathCallback *cb = new osg::AnimationPathCallback();
952         cb->ref();
953         return reinterpret_cast<jlong>(cb);
954 }
955 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeSetAnimationPath(JNIEnv *, jclass, jlong cptr,
956                 jlong path)
957 {
958         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
959         osg::AnimationPath *ap = reinterpret_cast<osg::AnimationPath *>(path);
960         if(cb != 0 && ap != 0)
961         {
962                 cb->setAnimationPath(ap);
963         }
964 }
965 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeGetAnimationPath(JNIEnv *, jclass, jlong cptr)
966 {
967         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
968         if(cb != 0)
969         {
970                 return reinterpret_cast<jlong>(cb->getAnimationPath());
971         }
972         return 0L;
973 }
974 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeSetPivotPoint(JNIEnv *, jclass, jlong cptr,
975                 jlong vec3)
976 {
977         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
978         RefVec3 *pivot = reinterpret_cast<RefVec3 *>(vec3);
979         if(cb != 0 && pivot != 0)
980         {
981                 cb->setPivotPoint(*pivot);
982         }
983 }
984 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeGetPivotPoint(JNIEnv *, jclass, jlong cptr)
985 {
986         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
987         if(cb != 0)
988         {
989                 osg::Vec3 ret = cb->getPivotPoint();
990                 RefVec3 *refRet = new RefVec3();
991                 refRet->set(ret.x(),ret.y(),ret.z());
992                 refRet->ref();
993                 return reinterpret_cast<jlong>(refRet);
994         }
995         return 0L;
996 }
997 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeSetUseInverseMatrix(JNIEnv *, jclass, jlong cptr,
998                 jboolean useInverseMatrix)
999 {
1000         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
1001         if(cb != 0)
1002         {
1003                 cb->setUseInverseMatrix((useInverseMatrix==JNI_TRUE)?true:false);
1004         }
1005 }
1006 JNIEXPORT jboolean JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeGetUseInverseMatrix(JNIEnv *, jclass, jlong cptr)
1007 {
1008         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
1009         if(cb != 0)
1010         {
1011                 return cb->getUseInverseMatrix()?JNI_TRUE:JNI_FALSE;
1012         }
1013         return JNI_FALSE;
1014 }
1015 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeSetTimeOffset(JNIEnv *, jclass, jlong cptr,
1016                 jdouble offset)
1017 {
1018         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
1019         if(cb != 0)
1020         {
1021                 cb->setTimeOffset(offset);
1022         }
1023 }
1024 JNIEXPORT jdouble JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeGetTimeOffset(JNIEnv *, jclass, jlong cptr)
1025 {
1026         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
1027         if(cb != 0)
1028         {
1029                 return cb->getTimeOffset();
1030         }
1031         return 0.0;
1032 }
1033
1034 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeSetTimeMultiplier(JNIEnv *, jclass, jlong cptr,
1035                 jdouble multiplier)
1036 {
1037         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
1038         if(cb != 0)
1039         {
1040                 cb->setTimeMultiplier(multiplier);
1041         }
1042 }
1043 JNIEXPORT jdouble JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeGetTimeMultiplier(JNIEnv *, jclass, jlong cptr)
1044 {
1045         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
1046         if(cb != 0)
1047         {
1048                 return cb->getTimeMultiplier();
1049         }
1050         return 0.0;
1051 }
1052 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeReset(JNIEnv *, jclass, jlong cptr)
1053 {
1054         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
1055         if(cb != 0)
1056         {
1057                 cb->reset();
1058         }
1059 }
1060 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeSetPause(JNIEnv *, jclass, jlong cptr,
1061                 jboolean pause)
1062 {
1063         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
1064         if(cb != 0)
1065         {
1066                 cb->setPause((pause==JNI_TRUE)?true:false);
1067         }
1068 }
1069 JNIEXPORT jboolean JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeGetPause(JNIEnv *, jclass, jlong cptr)
1070 {
1071         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
1072         if(cb != 0)
1073         {
1074                 return cb->getPause()?JNI_TRUE:JNI_FALSE;
1075         }
1076         return JNI_FALSE;
1077 }
1078 JNIEXPORT jdouble JNICALL Java_org_openscenegraph_osg_core_AnimationPathCallback_nativeGetAnimationTime(JNIEnv *, jclass, jlong cptr)
1079 {
1080         osg::AnimationPathCallback *cb = reinterpret_cast<osg::AnimationPathCallback *>(cptr);
1081         if(cb != 0)
1082         {
1083                 return cb->getAnimationTime();
1084         }
1085         return 0.0;
1086 }
1087
1088
1089 /**
1090  * osg::AnimationPath
1091  */
1092 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPath_nativeDispose(JNIEnv *, jclass, jlong cptr)
1093 {
1094         osg::AnimationPath *am = reinterpret_cast<osg::AnimationPath *>(cptr);
1095         if(am != 0)
1096         {
1097                 am->unref();
1098         }
1099 }
1100
1101 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_AnimationPath_nativeCreateAnimationPath(JNIEnv *, jclass)
1102 {
1103         osg::AnimationPath *am = new osg::AnimationPath();
1104         am->ref();
1105         return reinterpret_cast<jlong>(am);
1106 }
1107
1108 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPath_nativeInsert(JNIEnv *, jclass, jlong cptr,
1109                 jdouble time, jlong position, jlong rotation, jlong scale)
1110 {
1111         osg::AnimationPath *am = reinterpret_cast<osg::AnimationPath *>(cptr);
1112         RefVec3 *p = reinterpret_cast<RefVec3 *>(position);
1113         RefQuat *q = reinterpret_cast<RefQuat *>(rotation);
1114         RefVec3 *s = reinterpret_cast<RefVec3 *>(scale);
1115         if(     am != 0 &&
1116                 p != 0 &&
1117                 q != 0 &&
1118                 s != 0)
1119         {
1120                 osg::AnimationPath::ControlPoint cp;
1121                 cp.setPosition(*p);
1122                 cp.setRotation(*q);
1123                 cp.setScale(*s);
1124                 am->insert(time,cp);
1125         }
1126 }
1127 JNIEXPORT jdouble JNICALL Java_org_openscenegraph_osg_core_AnimationPath_nativeGetFirstTime(JNIEnv *, jclass, jlong cptr)
1128 {
1129         osg::AnimationPath *am = reinterpret_cast<osg::AnimationPath *>(cptr);
1130         if(am != 0)
1131         {
1132                 return am->getFirstTime();
1133         }
1134 }
1135 JNIEXPORT jdouble JNICALL Java_org_openscenegraph_osg_core_AnimationPath_nativeGetLastTime(JNIEnv *, jclass, jlong cptr)
1136 {
1137         osg::AnimationPath *am = reinterpret_cast<osg::AnimationPath *>(cptr);
1138         if(am != 0)
1139         {
1140                 return am->getLastTime();
1141         }
1142 }
1143 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_AnimationPath_nativeSetLoopMode(JNIEnv *, jclass, jlong cptr,
1144                 jint lm)
1145 {
1146         osg::AnimationPath *am = reinterpret_cast<osg::AnimationPath *>(cptr);
1147         if(am != 0)
1148         {
1149                 am->setLoopMode(osg::AnimationPath::LoopMode(lm));
1150         }
1151 }
1152 JNIEXPORT jint JNICALL Java_org_openscenegraph_osg_core_AnimationPath_nativeGetLoopMode(JNIEnv *, jclass, jlong cptr)
1153 {
1154         osg::AnimationPath *am = reinterpret_cast<osg::AnimationPath *>(cptr);
1155         if(am != 0)
1156         {
1157                 return (int)am->getLoopMode();
1158         }
1159         return 0;
1160 }
1161
1162 /**
1163  *  osg::Image
1164 **/
1165
1166 JNIEXPORT jlong JNICALL Java_org_openscenegraph_osg_core_Image_nativeCreateImage(JNIEnv *, jclass)
1167 {
1168         osg::Image *image = new osg::Image();
1169         image->ref();
1170         return reinterpret_cast<jlong>(image);
1171 }
1172
1173
1174 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Image_nativeDispose(JNIEnv *, jclass, long cptr)
1175 {
1176         osg::Image *im = reinterpret_cast<osg::Image *>(cptr);
1177         if(im != 0)
1178         {
1179                 im->unref();
1180         }
1181 }
1182         
1183 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Image_nativeSetImage(JNIEnv *env, jclass, long cptr, 
1184                             jint s,jint t,jint r,
1185                             jint internalTextureformat,
1186                             jint pixelFormat,jint type,
1187                             jbyteArray buffer)
1188 {
1189         osg::Image *im = reinterpret_cast<osg::Image *>(cptr);
1190         if(im != 0)
1191         {
1192                 jbyte *imageBuffer;
1193                 imageBuffer = env->GetByteArrayElements(buffer, JNI_FALSE);
1194                 int ms = s;
1195                 int mt = t;
1196                 int mr = r;
1197                 int imageSize = mr*mt*mr*4;
1198                 OSG_WARN << "Setting IMAGE of (my) computed size:" <<mr*mt*mr*4 << std::endl;
1199         //unsigned char* imageBuffer = (unsigned char *)env->GetDirectBufferAddress(buffer);
1200         //int imageSize = (int) env->GetDirectBufferCapacity(buffer);
1201         //LOGE("Setting IMAGE of size:%d",imageSize);
1202                 if(!im->data())
1203                 {
1204                         im->allocateImage(ms, mt, mr, static_cast<GLenum>(pixelFormat), static_cast<GLenum>(type), 1);
1205                         im->setInternalTextureFormat(4);
1206                 }
1207         memcpy(im->data(), imageBuffer, imageSize);
1208                 //release arrays:
1209                 env->ReleaseByteArrayElements(buffer, imageBuffer, 0);
1210         }
1211 }
1212
1213 JNIEXPORT void JNICALL Java_org_openscenegraph_osg_core_Image_nativeDirty(JNIEnv *, jclass, long cptr)
1214 {
1215         osg::Image *im = reinterpret_cast<osg::Image *>(cptr);
1216         if(im != 0)
1217         {
1218                 im->dirty();
1219         }
1220 }
1221
1222 }