1 /* ---------------------------------------------------------------------------- 2 * This file was automatically generated by SWIG (http://www.swig.org). 3 * Version 3.0.8 4 * 5 * This file is not intended to be easily readable and contains a number of 6 * coding conventions designed to improve portability and efficiency. Do not make 7 * changes to this file unless you know what you are doing--modify the SWIG 8 * interface file instead. 9 * ----------------------------------------------------------------------------- */ 10 11 12 #ifndef SWIGJAVA 13 #define SWIGJAVA 14 #endif 15 16 #define SWIG_DIRECTORS 17 18 19 #ifdef __cplusplus 20 /* SwigValueWrapper is described in swig.swg */ 21 template<typename T> class SwigValueWrapper { 22 struct SwigMovePointer { 23 T *ptr; 24 SwigMovePointer(T *p) : ptr(p) { } 25 ~SwigMovePointer() { delete ptr; } 26 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } 27 } pointer; 28 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs); 29 SwigValueWrapper(const SwigValueWrapper<T>& rhs); 30 public: 31 SwigValueWrapper() : pointer(0) { } 32 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } 33 operator T&() const { return *pointer.ptr; } 34 T *operator&() { return pointer.ptr; } 35 }; 36 37 template <typename T> T SwigValueInit() { 38 return T(); 39 } 40 #endif 41 42 /* ----------------------------------------------------------------------------- 43 * This section contains generic SWIG labels for method/variable 44 * declarations/attributes, and other compiler dependent labels. 45 * ----------------------------------------------------------------------------- */ 46 47 /* template workaround for compilers that cannot correctly implement the C++ standard */ 48 #ifndef SWIGTEMPLATEDISAMBIGUATOR 49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) 50 # define SWIGTEMPLATEDISAMBIGUATOR template 51 # elif defined(__HP_aCC) 52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ 53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ 54 # define SWIGTEMPLATEDISAMBIGUATOR template 55 # else 56 # define SWIGTEMPLATEDISAMBIGUATOR 57 # endif 58 #endif 59 60 /* inline attribute */ 61 #ifndef SWIGINLINE 62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) 63 # define SWIGINLINE inline 64 # else 65 # define SWIGINLINE 66 # endif 67 #endif 68 69 /* attribute recognised by some compilers to avoid 'unused' warnings */ 70 #ifndef SWIGUNUSED 71 # if defined(__GNUC__) 72 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 73 # define SWIGUNUSED __attribute__ ((__unused__)) 74 # else 75 # define SWIGUNUSED 76 # endif 77 # elif defined(__ICC) 78 # define SWIGUNUSED __attribute__ ((__unused__)) 79 # else 80 # define SWIGUNUSED 81 # endif 82 #endif 83 84 #ifndef SWIG_MSC_UNSUPPRESS_4505 85 # if defined(_MSC_VER) 86 # pragma warning(disable : 4505) /* unreferenced local function has been removed */ 87 # endif 88 #endif 89 90 #ifndef SWIGUNUSEDPARM 91 # ifdef __cplusplus 92 # define SWIGUNUSEDPARM(p) 93 # else 94 # define SWIGUNUSEDPARM(p) p SWIGUNUSED 95 # endif 96 #endif 97 98 /* internal SWIG method */ 99 #ifndef SWIGINTERN 100 # define SWIGINTERN static SWIGUNUSED 101 #endif 102 103 /* internal inline SWIG method */ 104 #ifndef SWIGINTERNINLINE 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE 106 #endif 107 108 /* exporting methods */ 109 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) 110 # ifndef GCC_HASCLASSVISIBILITY 111 # define GCC_HASCLASSVISIBILITY 112 # endif 113 #endif 114 115 #ifndef SWIGEXPORT 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 117 # if defined(STATIC_LINKED) 118 # define SWIGEXPORT 119 # else 120 # define SWIGEXPORT __declspec(dllexport) 121 # endif 122 # else 123 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) 124 # define SWIGEXPORT __attribute__ ((visibility("default"))) 125 # else 126 # define SWIGEXPORT 127 # endif 128 # endif 129 #endif 130 131 /* calling conventions for Windows */ 132 #ifndef SWIGSTDCALL 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 134 # define SWIGSTDCALL __stdcall 135 # else 136 # define SWIGSTDCALL 137 # endif 138 #endif 139 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) 142 # define _CRT_SECURE_NO_DEPRECATE 143 #endif 144 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) 147 # define _SCL_SECURE_NO_DEPRECATE 148 #endif 149 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 153 #endif 154 155 /* Intel's compiler complains if a variable which was never initialised is 156 * cast to void, which is a common idiom which we use to indicate that we 157 * are aware a variable isn't used. So we just silence that warning. 158 * See: https://github.com/swig/swig/issues/192 for more discussion. 159 */ 160 #ifdef __INTEL_COMPILER 161 # pragma warning disable 592 162 #endif 163 164 165 /* Fix for jlong on some versions of gcc on Windows */ 166 #if defined(__GNUC__) && !defined(__INTEL_COMPILER) 167 typedef long long __int64; 168 #endif 169 170 /* Fix for jlong on 64-bit x86 Solaris */ 171 #if defined(__x86_64) 172 # ifdef _LP64 173 # undef _LP64 174 # endif 175 #endif 176 177 #include <jni.h> 178 #include <stdlib.h> 179 #include <string.h> 180 181 182 /* Support for throwing Java exceptions */ 183 typedef enum { 184 SWIG_JavaOutOfMemoryError = 1, 185 SWIG_JavaIOException, 186 SWIG_JavaRuntimeException, 187 SWIG_JavaIndexOutOfBoundsException, 188 SWIG_JavaArithmeticException, 189 SWIG_JavaIllegalArgumentException, 190 SWIG_JavaNullPointerException, 191 SWIG_JavaDirectorPureVirtual, 192 SWIG_JavaUnknownError 193 } SWIG_JavaExceptionCodes; 194 195 typedef struct { 196 SWIG_JavaExceptionCodes code; 197 const char *java_exception; 198 } SWIG_JavaExceptions_t; 199 200 201 static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) { 202 jclass excep; 203 static const SWIG_JavaExceptions_t java_exceptions[] = { 204 { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" }, 205 { SWIG_JavaIOException, "java/io/IOException" }, 206 { SWIG_JavaRuntimeException, "java/lang/RuntimeException" }, 207 { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" }, 208 { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" }, 209 { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" }, 210 { SWIG_JavaNullPointerException, "java/lang/NullPointerException" }, 211 { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" }, 212 { SWIG_JavaUnknownError, "java/lang/UnknownError" }, 213 { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" } 214 }; 215 const SWIG_JavaExceptions_t *except_ptr = java_exceptions; 216 217 while (except_ptr->code != code && except_ptr->code) 218 except_ptr++; 219 220 jenv->ExceptionClear(); 221 excep = jenv->FindClass(except_ptr->java_exception); 222 if (excep) 223 jenv->ThrowNew(excep, msg); 224 } 225 226 227 /* Contract support */ 228 229 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else 230 231 /* ----------------------------------------------------------------------------- 232 * director_common.swg 233 * 234 * This file contains support for director classes which is common between 235 * languages. 236 * ----------------------------------------------------------------------------- */ 237 238 /* 239 Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the 240 'Swig' namespace. This could be useful for multi-modules projects. 241 */ 242 #ifdef SWIG_DIRECTOR_STATIC 243 /* Force anonymous (static) namespace */ 244 #define Swig 245 #endif 246 /* ----------------------------------------------------------------------------- 247 * director.swg 248 * 249 * This file contains support for director classes so that Java proxy 250 * methods can be called from C++. 251 * ----------------------------------------------------------------------------- */ 252 253 #if defined(DEBUG_DIRECTOR_OWNED) || defined(DEBUG_DIRECTOR_EXCEPTION) 254 #include <iostream> 255 #endif 256 257 #include <exception> 258 259 namespace Swig { 260 261 /* Java object wrapper */ 262 class JObjectWrapper { 263 public: 264 JObjectWrapper() : jthis_(NULL), weak_global_(true) { 265 } 266 267 ~JObjectWrapper() { 268 jthis_ = NULL; 269 weak_global_ = true; 270 } 271 272 bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) { 273 if (!jthis_) { 274 weak_global_ = !mem_own; // hold as weak global if explicitly requested or not owned 275 if (jobj) 276 jthis_ = weak_global_ ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj); 277 #if defined(DEBUG_DIRECTOR_OWNED) 278 std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl; 279 #endif 280 return true; 281 } else { 282 #if defined(DEBUG_DIRECTOR_OWNED) 283 std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl; 284 #endif 285 return false; 286 } 287 } 288 289 jobject get(JNIEnv *jenv) const { 290 #if defined(DEBUG_DIRECTOR_OWNED) 291 std::cout << "JObjectWrapper::get("; 292 if (jthis_) 293 std::cout << jthis_; 294 else 295 std::cout << "null"; 296 std::cout << ") -> return new local ref" << std::endl; 297 #endif 298 return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_); 299 } 300 301 void release(JNIEnv *jenv) { 302 #if defined(DEBUG_DIRECTOR_OWNED) 303 std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl; 304 #endif 305 if (jthis_) { 306 if (weak_global_) { 307 if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE) 308 jenv->DeleteWeakGlobalRef((jweak)jthis_); 309 } else 310 jenv->DeleteGlobalRef(jthis_); 311 } 312 313 jthis_ = NULL; 314 weak_global_ = true; 315 } 316 317 /* Only call peek if you know what you are doing wrt to weak/global references */ 318 jobject peek() { 319 return jthis_; 320 } 321 322 /* Java proxy releases ownership of C++ object, C++ object is now 323 responsible for destruction (creates NewGlobalRef to pin Java proxy) */ 324 void java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) { 325 if (take_or_release) { /* Java takes ownership of C++ object's lifetime. */ 326 if (!weak_global_) { 327 jenv->DeleteGlobalRef(jthis_); 328 jthis_ = jenv->NewWeakGlobalRef(jself); 329 weak_global_ = true; 330 } 331 } else { 332 /* Java releases ownership of C++ object's lifetime */ 333 if (weak_global_) { 334 jenv->DeleteWeakGlobalRef((jweak)jthis_); 335 jthis_ = jenv->NewGlobalRef(jself); 336 weak_global_ = false; 337 } 338 } 339 } 340 341 private: 342 /* pointer to Java object */ 343 jobject jthis_; 344 /* Local or global reference flag */ 345 bool weak_global_; 346 }; 347 348 /* Local JNI reference deleter */ 349 class LocalRefGuard { 350 JNIEnv *jenv_; 351 jobject jobj_; 352 353 // non-copyable 354 LocalRefGuard(const LocalRefGuard &); 355 LocalRefGuard &operator=(const LocalRefGuard &); 356 public: 357 LocalRefGuard(JNIEnv *jenv, jobject jobj): jenv_(jenv), jobj_(jobj) {} 358 ~LocalRefGuard() { 359 if (jobj_) 360 jenv_->DeleteLocalRef(jobj_); 361 } 362 }; 363 364 /* director base class */ 365 class Director { 366 /* pointer to Java virtual machine */ 367 JavaVM *swig_jvm_; 368 369 protected: 370 #if defined (_MSC_VER) && (_MSC_VER<1300) 371 class JNIEnvWrapper; 372 friend class JNIEnvWrapper; 373 #endif 374 /* Utility class for managing the JNI environment */ 375 class JNIEnvWrapper { 376 const Director *director_; 377 JNIEnv *jenv_; 378 int env_status; 379 public: 380 JNIEnvWrapper(const Director *director) : director_(director), jenv_(0), env_status(0) { 381 #if defined(__ANDROID__) 382 JNIEnv **jenv = &jenv_; 383 #else 384 void **jenv = (void **)&jenv_; 385 #endif 386 env_status = director_->swig_jvm_->GetEnv((void **)&jenv_, JNI_VERSION_1_2); 387 #if defined(SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON) 388 // Attach a daemon thread to the JVM. Useful when the JVM should not wait for 389 // the thread to exit upon shutdown. Only for jdk-1.4 and later. 390 director_->swig_jvm_->AttachCurrentThreadAsDaemon(jenv, NULL); 391 #else 392 director_->swig_jvm_->AttachCurrentThread(jenv, NULL); 393 #endif 394 } 395 ~JNIEnvWrapper() { 396 #if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD) 397 // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call. 398 // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak. 399 if (env_status == JNI_EDETACHED) 400 director_->swig_jvm_->DetachCurrentThread(); 401 #endif 402 } 403 JNIEnv *getJNIEnv() const { 404 return jenv_; 405 } 406 }; 407 408 /* Java object wrapper */ 409 JObjectWrapper swig_self_; 410 411 /* Disconnect director from Java object */ 412 void swig_disconnect_director_self(const char *disconn_method) { 413 JNIEnvWrapper jnienv(this) ; 414 JNIEnv *jenv = jnienv.getJNIEnv() ; 415 jobject jobj = swig_self_.get(jenv); 416 LocalRefGuard ref_deleter(jenv, jobj); 417 #if defined(DEBUG_DIRECTOR_OWNED) 418 std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl; 419 #endif 420 if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) { 421 jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V"); 422 if (disconn_meth) { 423 #if defined(DEBUG_DIRECTOR_OWNED) 424 std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl; 425 #endif 426 jenv->CallVoidMethod(jobj, disconn_meth); 427 } 428 } 429 } 430 431 public: 432 Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() { 433 /* Acquire the Java VM pointer */ 434 jenv->GetJavaVM(&swig_jvm_); 435 } 436 437 virtual ~Director() { 438 JNIEnvWrapper jnienv(this) ; 439 JNIEnv *jenv = jnienv.getJNIEnv() ; 440 swig_self_.release(jenv); 441 } 442 443 bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) { 444 return swig_self_.set(jenv, jself, mem_own, weak_global); 445 } 446 447 jobject swig_get_self(JNIEnv *jenv) const { 448 return swig_self_.get(jenv); 449 } 450 451 // Change C++ object's ownership, relative to Java 452 void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) { 453 swig_self_.java_change_ownership(jenv, jself, take_or_release); 454 } 455 }; 456 457 // Zero initialized bool array 458 template<size_t N> class BoolArray { 459 bool array_[N]; 460 public: 461 BoolArray() { 462 memset(array_, 0, sizeof(array_)); 463 } 464 bool& operator[](size_t n) { 465 return array_[n]; 466 } 467 bool operator[](size_t n) const { 468 return array_[n]; 469 } 470 }; 471 472 // Utility classes and functions for exception handling. 473 474 // Simple holder for a Java string during exception handling, providing access to a c-style string 475 class JavaString { 476 public: 477 JavaString(JNIEnv *jenv, jstring jstr) : jenv_(jenv), jstr_(jstr), cstr_(0) { 478 if (jenv_ && jstr_) 479 cstr_ = (const char *) jenv_->GetStringUTFChars(jstr_, NULL); 480 } 481 482 ~JavaString() { 483 if (jenv_ && jstr_ && cstr_) 484 jenv_->ReleaseStringUTFChars(jstr_, cstr_); 485 } 486 487 const char *c_str(const char *null_string = "null JavaString") const { 488 return cstr_ ? cstr_ : null_string; 489 } 490 491 private: 492 // non-copyable 493 JavaString(const JavaString &); 494 JavaString &operator=(const JavaString &); 495 496 JNIEnv *jenv_; 497 jstring jstr_; 498 const char *cstr_; 499 }; 500 501 // Helper class to extract the exception message from a Java throwable 502 class JavaExceptionMessage { 503 public: 504 JavaExceptionMessage(JNIEnv *jenv, jthrowable throwable) : message_(jenv, exceptionMessageFromThrowable(jenv, throwable)) { 505 } 506 507 const char *message() const { 508 return message_.c_str("Could not get exception message in JavaExceptionMessage"); 509 } 510 511 private: 512 // non-copyable 513 JavaExceptionMessage(const JavaExceptionMessage &); 514 JavaExceptionMessage &operator=(const JavaExceptionMessage &); 515 516 // Get exception message by calling Java method Throwable.getMessage() 517 static jstring exceptionMessageFromThrowable(JNIEnv *jenv, jthrowable throwable) { 518 jstring jmsg = NULL; 519 if (jenv && throwable) { 520 jenv->ExceptionClear(); // Cannot invoke methods with any pending exceptions 521 jclass throwclz = jenv->GetObjectClass(throwable); 522 if (throwclz) { 523 // All Throwable classes have a getMessage() method, so call it to extract the exception message 524 jmethodID getMessageMethodID = jenv->GetMethodID(throwclz, "getMessage", "()Ljava/lang/String;"); 525 if (getMessageMethodID) 526 jmsg = (jstring)jenv->CallObjectMethod(throwable, getMessageMethodID); 527 } 528 if (jmsg == NULL && jenv->ExceptionCheck()) 529 jenv->ExceptionClear(); 530 } 531 return jmsg; 532 } 533 534 JavaString message_; 535 }; 536 537 // C++ Exception class for handling Java exceptions thrown during a director method Java upcall 538 class DirectorException : public std::exception { 539 public: 540 541 // Construct exception from a Java throwable 542 DirectorException(JNIEnv *jenv, jthrowable throwable) : classname_(0), msg_(0) { 543 544 // Call Java method Object.getClass().getName() to obtain the throwable's class name (delimited by '/') 545 if (throwable) { 546 jclass throwclz = jenv->GetObjectClass(throwable); 547 if (throwclz) { 548 jclass clzclz = jenv->GetObjectClass(throwclz); 549 if (clzclz) { 550 jmethodID getNameMethodID = jenv->GetMethodID(clzclz, "getName", "()Ljava/lang/String;"); 551 if (getNameMethodID) { 552 jstring jstr_classname = (jstring)(jenv->CallObjectMethod(throwclz, getNameMethodID)); 553 // Copy strings, since there is no guarantee that jenv will be active when handled 554 if (jstr_classname) { 555 JavaString jsclassname(jenv, jstr_classname); 556 const char *classname = jsclassname.c_str(0); 557 if (classname) 558 classname_ = copypath(classname); 559 } 560 } 561 } 562 } 563 } 564 565 JavaExceptionMessage exceptionmsg(jenv, throwable); 566 msg_ = copystr(exceptionmsg.message()); 567 } 568 569 // More general constructor for handling as a java.lang.RuntimeException 570 DirectorException(const char *msg) : classname_(0), msg_(copystr(msg ? msg : "Unspecified DirectorException message")) { 571 } 572 573 ~DirectorException() throw() { 574 delete[] classname_; 575 delete[] msg_; 576 } 577 578 const char *what() const throw() { 579 return msg_; 580 } 581 582 // Reconstruct and raise/throw the Java Exception that caused the DirectorException 583 // Note that any error in the JNI exception handling results in a Java RuntimeException 584 void raiseJavaException(JNIEnv *jenv) const { 585 if (jenv) { 586 jenv->ExceptionClear(); 587 588 jmethodID ctorMethodID = 0; 589 jclass throwableclass = 0; 590 if (classname_) { 591 throwableclass = jenv->FindClass(classname_); 592 if (throwableclass) 593 ctorMethodID = jenv->GetMethodID(throwableclass, "<init>", "(Ljava/lang/String;)V"); 594 } 595 596 if (ctorMethodID) { 597 jenv->ThrowNew(throwableclass, what()); 598 } else { 599 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, what()); 600 } 601 } 602 } 603 604 private: 605 static char *copypath(const char *srcmsg) { 606 char *target = copystr(srcmsg); 607 for (char *c=target; *c; ++c) { 608 if ('.' == *c) 609 *c = '/'; 610 } 611 return target; 612 } 613 614 static char *copystr(const char *srcmsg) { 615 char *target = 0; 616 if (srcmsg) { 617 size_t msglen = strlen(srcmsg) + 1; 618 target = new char[msglen]; 619 strncpy(target, srcmsg, msglen); 620 } 621 return target; 622 } 623 624 const char *classname_; 625 const char *msg_; 626 }; 627 628 // Helper method to determine if a Java throwable matches a particular Java class type 629 SWIGINTERN inline bool ExceptionMatches(JNIEnv *jenv, jthrowable throwable, const char *classname) { 630 bool matches = false; 631 632 if (throwable && jenv && classname) { 633 // Exceptions need to be cleared for correct behavior. 634 // The caller of ExceptionMatches should restore pending exceptions if desired - 635 // the caller already has the throwable. 636 jenv->ExceptionClear(); 637 638 jclass clz = jenv->FindClass(classname); 639 if (clz) { 640 jclass classclz = jenv->GetObjectClass(clz); 641 jmethodID isInstanceMethodID = jenv->GetMethodID(classclz, "isInstance", "(Ljava/lang/Object;)Z"); 642 if (isInstanceMethodID) { 643 matches = jenv->CallBooleanMethod(clz, isInstanceMethodID, throwable) != 0; 644 } 645 } 646 647 #if defined(DEBUG_DIRECTOR_EXCEPTION) 648 if (jenv->ExceptionCheck()) { 649 // Typically occurs when an invalid classname argument is passed resulting in a ClassNotFoundException 650 JavaExceptionMessage exc(jenv, jenv->ExceptionOccurred()); 651 std::cout << "Error: ExceptionMatches: class '" << classname << "' : " << exc.message() << std::endl; 652 } 653 #endif 654 } 655 return matches; 656 } 657 } 658 659 namespace Swig { 660 namespace { 661 jclass jclass_LinearMathJNI = NULL; 662 jmethodID director_method_ids[29]; 663 } 664 } 665 666 #ifndef BT_INFINITY 667 static int btInfinityMask = 0x7F800000; 668 #define BT_INFINITY (*(float*)&btInfinityMask) 669 #endif 670 671 672 #include <gdx/common/jniHelpers.h> 673 674 675 #if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS) 676 677 678 static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input); 679 static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input); 680 static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz); 681 682 683 static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input); 684 static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input); 685 static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz); 686 687 688 static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input); 689 static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input); 690 static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz); 691 692 693 static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input); 694 static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input); 695 static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz); 696 697 698 static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input); 699 static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input); 700 static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz); 701 702 703 static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input); 704 static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input); 705 static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz); 706 707 708 static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input); 709 static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input); 710 static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz); 711 712 713 static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input); 714 static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input); 715 static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz); 716 717 718 static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input); 719 static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input); 720 static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz); 721 722 723 static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input); 724 static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input); 725 static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz); 726 727 728 static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input); 729 static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input); 730 static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz); 731 732 733 static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input); 734 static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input); 735 static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz); 736 737 738 #else 739 740 741 /* bool[] support */ 742 static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input) { 743 int i; 744 jsize sz; 745 if (!input) { 746 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 747 return 0; 748 } 749 sz = jenv->GetArrayLength(input); 750 *jarr = jenv->GetBooleanArrayElements(input, 0); 751 if (!*jarr) 752 return 0; 753 *carr = new bool[sz]; 754 if (!*carr) { 755 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 756 return 0; 757 } 758 for (i=0; i<sz; i++) 759 (*carr)[i] = ((*jarr)[i] != 0); 760 return 1; 761 } 762 763 static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input) { 764 int i; 765 jsize sz = jenv->GetArrayLength(input); 766 for (i=0; i<sz; i++) 767 jarr[i] = (jboolean)carr[i]; 768 jenv->ReleaseBooleanArrayElements(input, jarr, 0); 769 } 770 771 static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz) { 772 jboolean *arr; 773 int i; 774 jbooleanArray jresult = jenv->NewBooleanArray(sz); 775 if (!jresult) 776 return NULL; 777 arr = jenv->GetBooleanArrayElements(jresult, 0); 778 if (!arr) 779 return NULL; 780 for (i=0; i<sz; i++) 781 arr[i] = (jboolean)result[i]; 782 jenv->ReleaseBooleanArrayElements(jresult, arr, 0); 783 return jresult; 784 } 785 786 787 /* signed char[] support */ 788 static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input) { 789 int i; 790 jsize sz; 791 if (!input) { 792 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 793 return 0; 794 } 795 sz = jenv->GetArrayLength(input); 796 *jarr = jenv->GetByteArrayElements(input, 0); 797 if (!*jarr) 798 return 0; 799 *carr = new signed char[sz]; 800 if (!*carr) { 801 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 802 return 0; 803 } 804 for (i=0; i<sz; i++) 805 (*carr)[i] = (signed char)(*jarr)[i]; 806 return 1; 807 } 808 809 static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input) { 810 int i; 811 jsize sz = jenv->GetArrayLength(input); 812 for (i=0; i<sz; i++) 813 jarr[i] = (jbyte)carr[i]; 814 jenv->ReleaseByteArrayElements(input, jarr, 0); 815 } 816 817 static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz) { 818 jbyte *arr; 819 int i; 820 jbyteArray jresult = jenv->NewByteArray(sz); 821 if (!jresult) 822 return NULL; 823 arr = jenv->GetByteArrayElements(jresult, 0); 824 if (!arr) 825 return NULL; 826 for (i=0; i<sz; i++) 827 arr[i] = (jbyte)result[i]; 828 jenv->ReleaseByteArrayElements(jresult, arr, 0); 829 return jresult; 830 } 831 832 833 /* unsigned char[] support */ 834 static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input) { 835 int i; 836 jsize sz; 837 if (!input) { 838 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 839 return 0; 840 } 841 sz = jenv->GetArrayLength(input); 842 *jarr = jenv->GetShortArrayElements(input, 0); 843 if (!*jarr) 844 return 0; 845 *carr = new unsigned char[sz]; 846 if (!*carr) { 847 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 848 return 0; 849 } 850 for (i=0; i<sz; i++) 851 (*carr)[i] = (unsigned char)(*jarr)[i]; 852 return 1; 853 } 854 855 static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input) { 856 int i; 857 jsize sz = jenv->GetArrayLength(input); 858 for (i=0; i<sz; i++) 859 jarr[i] = (jshort)carr[i]; 860 jenv->ReleaseShortArrayElements(input, jarr, 0); 861 } 862 863 static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz) { 864 jshort *arr; 865 int i; 866 jshortArray jresult = jenv->NewShortArray(sz); 867 if (!jresult) 868 return NULL; 869 arr = jenv->GetShortArrayElements(jresult, 0); 870 if (!arr) 871 return NULL; 872 for (i=0; i<sz; i++) 873 arr[i] = (jshort)result[i]; 874 jenv->ReleaseShortArrayElements(jresult, arr, 0); 875 return jresult; 876 } 877 878 879 /* short[] support */ 880 static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input) { 881 int i; 882 jsize sz; 883 if (!input) { 884 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 885 return 0; 886 } 887 sz = jenv->GetArrayLength(input); 888 *jarr = jenv->GetShortArrayElements(input, 0); 889 if (!*jarr) 890 return 0; 891 *carr = new short[sz]; 892 if (!*carr) { 893 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 894 return 0; 895 } 896 for (i=0; i<sz; i++) 897 (*carr)[i] = (short)(*jarr)[i]; 898 return 1; 899 } 900 901 static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input) { 902 int i; 903 jsize sz = jenv->GetArrayLength(input); 904 for (i=0; i<sz; i++) 905 jarr[i] = (jshort)carr[i]; 906 jenv->ReleaseShortArrayElements(input, jarr, 0); 907 } 908 909 static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz) { 910 jshort *arr; 911 int i; 912 jshortArray jresult = jenv->NewShortArray(sz); 913 if (!jresult) 914 return NULL; 915 arr = jenv->GetShortArrayElements(jresult, 0); 916 if (!arr) 917 return NULL; 918 for (i=0; i<sz; i++) 919 arr[i] = (jshort)result[i]; 920 jenv->ReleaseShortArrayElements(jresult, arr, 0); 921 return jresult; 922 } 923 924 925 /* unsigned short[] support */ 926 static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input) { 927 int i; 928 jsize sz; 929 if (!input) { 930 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 931 return 0; 932 } 933 sz = jenv->GetArrayLength(input); 934 *jarr = jenv->GetIntArrayElements(input, 0); 935 if (!*jarr) 936 return 0; 937 *carr = new unsigned short[sz]; 938 if (!*carr) { 939 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 940 return 0; 941 } 942 for (i=0; i<sz; i++) 943 (*carr)[i] = (unsigned short)(*jarr)[i]; 944 return 1; 945 } 946 947 static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input) { 948 int i; 949 jsize sz = jenv->GetArrayLength(input); 950 for (i=0; i<sz; i++) 951 jarr[i] = (jint)carr[i]; 952 jenv->ReleaseIntArrayElements(input, jarr, 0); 953 } 954 955 static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz) { 956 jint *arr; 957 int i; 958 jintArray jresult = jenv->NewIntArray(sz); 959 if (!jresult) 960 return NULL; 961 arr = jenv->GetIntArrayElements(jresult, 0); 962 if (!arr) 963 return NULL; 964 for (i=0; i<sz; i++) 965 arr[i] = (jint)result[i]; 966 jenv->ReleaseIntArrayElements(jresult, arr, 0); 967 return jresult; 968 } 969 970 971 /* int[] support */ 972 static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input) { 973 int i; 974 jsize sz; 975 if (!input) { 976 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 977 return 0; 978 } 979 sz = jenv->GetArrayLength(input); 980 *jarr = jenv->GetIntArrayElements(input, 0); 981 if (!*jarr) 982 return 0; 983 *carr = new int[sz]; 984 if (!*carr) { 985 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 986 return 0; 987 } 988 for (i=0; i<sz; i++) 989 (*carr)[i] = (int)(*jarr)[i]; 990 return 1; 991 } 992 993 static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input) { 994 int i; 995 jsize sz = jenv->GetArrayLength(input); 996 for (i=0; i<sz; i++) 997 jarr[i] = (jint)carr[i]; 998 jenv->ReleaseIntArrayElements(input, jarr, 0); 999 } 1000 1001 static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz) { 1002 jint *arr; 1003 int i; 1004 jintArray jresult = jenv->NewIntArray(sz); 1005 if (!jresult) 1006 return NULL; 1007 arr = jenv->GetIntArrayElements(jresult, 0); 1008 if (!arr) 1009 return NULL; 1010 for (i=0; i<sz; i++) 1011 arr[i] = (jint)result[i]; 1012 jenv->ReleaseIntArrayElements(jresult, arr, 0); 1013 return jresult; 1014 } 1015 1016 1017 /* unsigned int[] support */ 1018 static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input) { 1019 int i; 1020 jsize sz; 1021 if (!input) { 1022 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1023 return 0; 1024 } 1025 sz = jenv->GetArrayLength(input); 1026 *jarr = jenv->GetLongArrayElements(input, 0); 1027 if (!*jarr) 1028 return 0; 1029 *carr = new unsigned int[sz]; 1030 if (!*carr) { 1031 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1032 return 0; 1033 } 1034 for (i=0; i<sz; i++) 1035 (*carr)[i] = (unsigned int)(*jarr)[i]; 1036 return 1; 1037 } 1038 1039 static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input) { 1040 int i; 1041 jsize sz = jenv->GetArrayLength(input); 1042 for (i=0; i<sz; i++) 1043 jarr[i] = (jlong)carr[i]; 1044 jenv->ReleaseLongArrayElements(input, jarr, 0); 1045 } 1046 1047 static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz) { 1048 jlong *arr; 1049 int i; 1050 jlongArray jresult = jenv->NewLongArray(sz); 1051 if (!jresult) 1052 return NULL; 1053 arr = jenv->GetLongArrayElements(jresult, 0); 1054 if (!arr) 1055 return NULL; 1056 for (i=0; i<sz; i++) 1057 arr[i] = (jlong)result[i]; 1058 jenv->ReleaseLongArrayElements(jresult, arr, 0); 1059 return jresult; 1060 } 1061 1062 1063 /* long[] support */ 1064 static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input) { 1065 int i; 1066 jsize sz; 1067 if (!input) { 1068 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1069 return 0; 1070 } 1071 sz = jenv->GetArrayLength(input); 1072 *jarr = jenv->GetIntArrayElements(input, 0); 1073 if (!*jarr) 1074 return 0; 1075 *carr = new long[sz]; 1076 if (!*carr) { 1077 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1078 return 0; 1079 } 1080 for (i=0; i<sz; i++) 1081 (*carr)[i] = (long)(*jarr)[i]; 1082 return 1; 1083 } 1084 1085 static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input) { 1086 int i; 1087 jsize sz = jenv->GetArrayLength(input); 1088 for (i=0; i<sz; i++) 1089 jarr[i] = (jint)carr[i]; 1090 jenv->ReleaseIntArrayElements(input, jarr, 0); 1091 } 1092 1093 static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz) { 1094 jint *arr; 1095 int i; 1096 jintArray jresult = jenv->NewIntArray(sz); 1097 if (!jresult) 1098 return NULL; 1099 arr = jenv->GetIntArrayElements(jresult, 0); 1100 if (!arr) 1101 return NULL; 1102 for (i=0; i<sz; i++) 1103 arr[i] = (jint)result[i]; 1104 jenv->ReleaseIntArrayElements(jresult, arr, 0); 1105 return jresult; 1106 } 1107 1108 1109 /* unsigned long[] support */ 1110 static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input) { 1111 int i; 1112 jsize sz; 1113 if (!input) { 1114 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1115 return 0; 1116 } 1117 sz = jenv->GetArrayLength(input); 1118 *jarr = jenv->GetLongArrayElements(input, 0); 1119 if (!*jarr) 1120 return 0; 1121 *carr = new unsigned long[sz]; 1122 if (!*carr) { 1123 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1124 return 0; 1125 } 1126 for (i=0; i<sz; i++) 1127 (*carr)[i] = (unsigned long)(*jarr)[i]; 1128 return 1; 1129 } 1130 1131 static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input) { 1132 int i; 1133 jsize sz = jenv->GetArrayLength(input); 1134 for (i=0; i<sz; i++) 1135 jarr[i] = (jlong)carr[i]; 1136 jenv->ReleaseLongArrayElements(input, jarr, 0); 1137 } 1138 1139 static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz) { 1140 jlong *arr; 1141 int i; 1142 jlongArray jresult = jenv->NewLongArray(sz); 1143 if (!jresult) 1144 return NULL; 1145 arr = jenv->GetLongArrayElements(jresult, 0); 1146 if (!arr) 1147 return NULL; 1148 for (i=0; i<sz; i++) 1149 arr[i] = (jlong)result[i]; 1150 jenv->ReleaseLongArrayElements(jresult, arr, 0); 1151 return jresult; 1152 } 1153 1154 1155 /* jlong[] support */ 1156 static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input) { 1157 int i; 1158 jsize sz; 1159 if (!input) { 1160 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1161 return 0; 1162 } 1163 sz = jenv->GetArrayLength(input); 1164 *jarr = jenv->GetLongArrayElements(input, 0); 1165 if (!*jarr) 1166 return 0; 1167 *carr = new jlong[sz]; 1168 if (!*carr) { 1169 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1170 return 0; 1171 } 1172 for (i=0; i<sz; i++) 1173 (*carr)[i] = (jlong)(*jarr)[i]; 1174 return 1; 1175 } 1176 1177 static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input) { 1178 int i; 1179 jsize sz = jenv->GetArrayLength(input); 1180 for (i=0; i<sz; i++) 1181 jarr[i] = (jlong)carr[i]; 1182 jenv->ReleaseLongArrayElements(input, jarr, 0); 1183 } 1184 1185 static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz) { 1186 jlong *arr; 1187 int i; 1188 jlongArray jresult = jenv->NewLongArray(sz); 1189 if (!jresult) 1190 return NULL; 1191 arr = jenv->GetLongArrayElements(jresult, 0); 1192 if (!arr) 1193 return NULL; 1194 for (i=0; i<sz; i++) 1195 arr[i] = (jlong)result[i]; 1196 jenv->ReleaseLongArrayElements(jresult, arr, 0); 1197 return jresult; 1198 } 1199 1200 1201 /* float[] support */ 1202 static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input) { 1203 int i; 1204 jsize sz; 1205 if (!input) { 1206 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1207 return 0; 1208 } 1209 sz = jenv->GetArrayLength(input); 1210 *jarr = jenv->GetFloatArrayElements(input, 0); 1211 if (!*jarr) 1212 return 0; 1213 *carr = new float[sz]; 1214 if (!*carr) { 1215 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1216 return 0; 1217 } 1218 for (i=0; i<sz; i++) 1219 (*carr)[i] = (float)(*jarr)[i]; 1220 return 1; 1221 } 1222 1223 static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input) { 1224 int i; 1225 jsize sz = jenv->GetArrayLength(input); 1226 for (i=0; i<sz; i++) 1227 jarr[i] = (jfloat)carr[i]; 1228 jenv->ReleaseFloatArrayElements(input, jarr, 0); 1229 } 1230 1231 static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz) { 1232 jfloat *arr; 1233 int i; 1234 jfloatArray jresult = jenv->NewFloatArray(sz); 1235 if (!jresult) 1236 return NULL; 1237 arr = jenv->GetFloatArrayElements(jresult, 0); 1238 if (!arr) 1239 return NULL; 1240 for (i=0; i<sz; i++) 1241 arr[i] = (jfloat)result[i]; 1242 jenv->ReleaseFloatArrayElements(jresult, arr, 0); 1243 return jresult; 1244 } 1245 1246 1247 /* double[] support */ 1248 static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input) { 1249 int i; 1250 jsize sz; 1251 if (!input) { 1252 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1253 return 0; 1254 } 1255 sz = jenv->GetArrayLength(input); 1256 *jarr = jenv->GetDoubleArrayElements(input, 0); 1257 if (!*jarr) 1258 return 0; 1259 *carr = new double[sz]; 1260 if (!*carr) { 1261 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1262 return 0; 1263 } 1264 for (i=0; i<sz; i++) 1265 (*carr)[i] = (double)(*jarr)[i]; 1266 return 1; 1267 } 1268 1269 static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input) { 1270 int i; 1271 jsize sz = jenv->GetArrayLength(input); 1272 for (i=0; i<sz; i++) 1273 jarr[i] = (jdouble)carr[i]; 1274 jenv->ReleaseDoubleArrayElements(input, jarr, 0); 1275 } 1276 1277 static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz) { 1278 jdouble *arr; 1279 int i; 1280 jdoubleArray jresult = jenv->NewDoubleArray(sz); 1281 if (!jresult) 1282 return NULL; 1283 arr = jenv->GetDoubleArrayElements(jresult, 0); 1284 if (!arr) 1285 return NULL; 1286 for (i=0; i<sz; i++) 1287 arr[i] = (jdouble)result[i]; 1288 jenv->ReleaseDoubleArrayElements(jresult, arr, 0); 1289 return jresult; 1290 } 1291 1292 1293 #endif 1294 1295 1296 #include <stdint.h> 1297 1298 1299 #include <gdx/linearmath/mathtypes.h> 1300 #include <LinearMath/btVector3.h> 1301 #include <LinearMath/btQuaternion.h> 1302 #include <LinearMath/btMatrix3x3.h> 1303 #include <LinearMath/btTransform.h> 1304 1305 1306 #include <LinearMath/btTransform.h> 1307 1308 1309 1310 /* Gets a global ref to the temp class. Do not release this. */ 1311 SWIGINTERN inline jclass gdx_getTempClassQuaternion(JNIEnv * jenv) { 1312 static jclass cls = NULL; 1313 if (cls == NULL) { 1314 cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); 1315 } 1316 return cls; 1317 } 1318 1319 SWIGINTERN inline jobject gdx_takePoolObjectQuaternion(JNIEnv * jenv, const char * poolName) { 1320 jclass tempClass = gdx_getTempClassQuaternion(jenv); 1321 1322 static jfieldID poolField = NULL; 1323 if (poolField == NULL) { 1324 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1325 } 1326 1327 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1328 jclass poolClass = jenv->GetObjectClass(poolObject); 1329 1330 static jmethodID obtainMethod = NULL; 1331 if (obtainMethod == NULL) { 1332 obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); 1333 } 1334 1335 jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); 1336 1337 jenv->DeleteLocalRef(poolObject); 1338 jenv->DeleteLocalRef(poolClass); 1339 1340 return ret; 1341 } 1342 1343 SWIGINTERN inline void gdx_releasePoolObjectQuaternion(JNIEnv * jenv, const char * poolName, jobject obj) { 1344 jclass tempClass = gdx_getTempClassQuaternion(jenv); 1345 1346 static jfieldID poolField = NULL; 1347 if (poolField == NULL) { 1348 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1349 } 1350 1351 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1352 jclass poolClass = jenv->GetObjectClass(poolObject); 1353 1354 static jmethodID freeMethod = NULL; 1355 if (freeMethod == NULL) { 1356 freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); 1357 } 1358 1359 jenv->CallVoidMethod(poolObject, freeMethod, obj); 1360 1361 jenv->DeleteLocalRef(poolObject); 1362 jenv->DeleteLocalRef(poolClass); 1363 jenv->DeleteLocalRef(obj); 1364 } 1365 1366 /* 1367 * A simple RAII wrapper to release jobjects we obtain from pools in 1368 * directorin typemaps. SWIG doesn't have hooks to release them after 1369 * they're used. 1370 */ 1371 class gdxPoolAutoReleaseQuaternion { 1372 private: 1373 JNIEnv * jenv; 1374 const char * poolName; 1375 jobject obj; 1376 public: 1377 gdxPoolAutoReleaseQuaternion(JNIEnv * jenv, const char * poolName, jobject obj) : 1378 jenv(jenv), poolName(poolName), obj(obj) { }; 1379 virtual ~gdxPoolAutoReleaseQuaternion() { 1380 gdx_releasePoolObjectQuaternion(this->jenv, this->poolName, this->obj); 1381 }; 1382 }; 1383 1384 1385 1386 // Workaround for some strange swig behaviour 1387 1388 1389 /* Gets a global ref to the temp class's Return Quaternion. Do not release this. */ 1390 SWIGINTERN inline jobject gdx_getReturnQuaternion(JNIEnv * jenv) { 1391 static jobject ret = NULL; 1392 if (ret == NULL) { 1393 jclass tempClass = gdx_getTempClassQuaternion(jenv); 1394 jfieldID field = jenv->GetStaticFieldID(tempClass, "staticQuaternion", "Lcom/badlogic/gdx/math/Quaternion;"); 1395 ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); 1396 } 1397 return ret; 1398 } 1399 1400 /* Sets the data in the Bullet type from the Gdx type. */ 1401 SWIGINTERN inline void gdx_setbtQuaternionFromQuaternion(JNIEnv * jenv, btQuaternion & target, jobject source) { 1402 Quaternion_to_btQuaternion(jenv, target, source); 1403 } 1404 1405 SWIGINTERN inline void gdx_setbtQuaternionFromQuaternion(JNIEnv * jenv, btQuaternion * target, jobject source) { 1406 gdx_setbtQuaternionFromQuaternion(jenv, *target, source); 1407 } 1408 1409 /* Sets the data in the Gdx type from the Bullet type. */ 1410 SWIGINTERN inline void gdx_setQuaternionFrombtQuaternion(JNIEnv * jenv, jobject target, const btQuaternion & source) { 1411 btQuaternion_to_Quaternion(jenv, target, source); 1412 } 1413 1414 SWIGINTERN inline void gdx_setQuaternionFrombtQuaternion(JNIEnv * jenv, jobject target, const btQuaternion * source) { 1415 gdx_setQuaternionFrombtQuaternion(jenv, target, *source); 1416 } 1417 1418 /* 1419 * RAII wrapper to commit changes made to a local btQuaternion back to Quaternion 1420 */ 1421 class gdxAutoCommitQuaternion { 1422 private: 1423 JNIEnv * jenv; 1424 jobject jQuaternion; 1425 btQuaternion & cbtQuaternion; 1426 public: 1427 gdxAutoCommitQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion & cbtQuaternion) : 1428 jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(cbtQuaternion) { }; 1429 gdxAutoCommitQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion * cbtQuaternion) : 1430 jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(*cbtQuaternion) { }; 1431 virtual ~gdxAutoCommitQuaternion() { 1432 gdx_setQuaternionFrombtQuaternion(this->jenv, this->jQuaternion, this->cbtQuaternion); 1433 }; 1434 }; 1435 1436 class gdxAutoCommitbtQuaternionAndReleaseQuaternion { 1437 private: 1438 JNIEnv * jenv; 1439 jobject jQuaternion; 1440 btQuaternion & cbtQuaternion; 1441 const char * poolName; 1442 public: 1443 gdxAutoCommitbtQuaternionAndReleaseQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion & cbtQuaternion, const char *poolName) : 1444 jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(cbtQuaternion), poolName(poolName) { }; 1445 gdxAutoCommitbtQuaternionAndReleaseQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion * cbtQuaternion, const char *poolName) : 1446 jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(*cbtQuaternion), poolName(poolName) { }; 1447 virtual ~gdxAutoCommitbtQuaternionAndReleaseQuaternion() { 1448 gdx_setbtQuaternionFromQuaternion(this->jenv, this->cbtQuaternion, this->jQuaternion); 1449 gdx_releasePoolObjectQuaternion(this->jenv, this->poolName, this->jQuaternion); 1450 }; 1451 }; 1452 1453 1454 1455 /* Gets a global ref to the temp class. Do not release this. */ 1456 SWIGINTERN inline jclass gdx_getTempClassVector3(JNIEnv * jenv) { 1457 static jclass cls = NULL; 1458 if (cls == NULL) { 1459 cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); 1460 } 1461 return cls; 1462 } 1463 1464 SWIGINTERN inline jobject gdx_takePoolObjectVector3(JNIEnv * jenv, const char * poolName) { 1465 jclass tempClass = gdx_getTempClassVector3(jenv); 1466 1467 static jfieldID poolField = NULL; 1468 if (poolField == NULL) { 1469 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1470 } 1471 1472 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1473 jclass poolClass = jenv->GetObjectClass(poolObject); 1474 1475 static jmethodID obtainMethod = NULL; 1476 if (obtainMethod == NULL) { 1477 obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); 1478 } 1479 1480 jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); 1481 1482 jenv->DeleteLocalRef(poolObject); 1483 jenv->DeleteLocalRef(poolClass); 1484 1485 return ret; 1486 } 1487 1488 SWIGINTERN inline void gdx_releasePoolObjectVector3(JNIEnv * jenv, const char * poolName, jobject obj) { 1489 jclass tempClass = gdx_getTempClassVector3(jenv); 1490 1491 static jfieldID poolField = NULL; 1492 if (poolField == NULL) { 1493 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1494 } 1495 1496 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1497 jclass poolClass = jenv->GetObjectClass(poolObject); 1498 1499 static jmethodID freeMethod = NULL; 1500 if (freeMethod == NULL) { 1501 freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); 1502 } 1503 1504 jenv->CallVoidMethod(poolObject, freeMethod, obj); 1505 1506 jenv->DeleteLocalRef(poolObject); 1507 jenv->DeleteLocalRef(poolClass); 1508 jenv->DeleteLocalRef(obj); 1509 } 1510 1511 /* 1512 * A simple RAII wrapper to release jobjects we obtain from pools in 1513 * directorin typemaps. SWIG doesn't have hooks to release them after 1514 * they're used. 1515 */ 1516 class gdxPoolAutoReleaseVector3 { 1517 private: 1518 JNIEnv * jenv; 1519 const char * poolName; 1520 jobject obj; 1521 public: 1522 gdxPoolAutoReleaseVector3(JNIEnv * jenv, const char * poolName, jobject obj) : 1523 jenv(jenv), poolName(poolName), obj(obj) { }; 1524 virtual ~gdxPoolAutoReleaseVector3() { 1525 gdx_releasePoolObjectVector3(this->jenv, this->poolName, this->obj); 1526 }; 1527 }; 1528 1529 1530 1531 // Workaround for some strange swig behaviour 1532 1533 1534 /* Gets a global ref to the temp class's Return Vector3. Do not release this. */ 1535 SWIGINTERN inline jobject gdx_getReturnVector3(JNIEnv * jenv) { 1536 static jobject ret = NULL; 1537 if (ret == NULL) { 1538 jclass tempClass = gdx_getTempClassVector3(jenv); 1539 jfieldID field = jenv->GetStaticFieldID(tempClass, "staticVector3", "Lcom/badlogic/gdx/math/Vector3;"); 1540 ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); 1541 } 1542 return ret; 1543 } 1544 1545 /* Sets the data in the Bullet type from the Gdx type. */ 1546 SWIGINTERN inline void gdx_setbtVector3FromVector3(JNIEnv * jenv, btVector3 & target, jobject source) { 1547 Vector3_to_btVector3(jenv, target, source); 1548 } 1549 1550 SWIGINTERN inline void gdx_setbtVector3FromVector3(JNIEnv * jenv, btVector3 * target, jobject source) { 1551 gdx_setbtVector3FromVector3(jenv, *target, source); 1552 } 1553 1554 /* Sets the data in the Gdx type from the Bullet type. */ 1555 SWIGINTERN inline void gdx_setVector3FrombtVector3(JNIEnv * jenv, jobject target, const btVector3 & source) { 1556 btVector3_to_Vector3(jenv, target, source); 1557 } 1558 1559 SWIGINTERN inline void gdx_setVector3FrombtVector3(JNIEnv * jenv, jobject target, const btVector3 * source) { 1560 gdx_setVector3FrombtVector3(jenv, target, *source); 1561 } 1562 1563 /* 1564 * RAII wrapper to commit changes made to a local btVector3 back to Vector3 1565 */ 1566 class gdxAutoCommitVector3 { 1567 private: 1568 JNIEnv * jenv; 1569 jobject jVector3; 1570 btVector3 & cbtVector3; 1571 public: 1572 gdxAutoCommitVector3(JNIEnv * jenv, jobject jVector3, btVector3 & cbtVector3) : 1573 jenv(jenv), jVector3(jVector3), cbtVector3(cbtVector3) { }; 1574 gdxAutoCommitVector3(JNIEnv * jenv, jobject jVector3, btVector3 * cbtVector3) : 1575 jenv(jenv), jVector3(jVector3), cbtVector3(*cbtVector3) { }; 1576 virtual ~gdxAutoCommitVector3() { 1577 gdx_setVector3FrombtVector3(this->jenv, this->jVector3, this->cbtVector3); 1578 }; 1579 }; 1580 1581 class gdxAutoCommitbtVector3AndReleaseVector3 { 1582 private: 1583 JNIEnv * jenv; 1584 jobject jVector3; 1585 btVector3 & cbtVector3; 1586 const char * poolName; 1587 public: 1588 gdxAutoCommitbtVector3AndReleaseVector3(JNIEnv * jenv, jobject jVector3, btVector3 & cbtVector3, const char *poolName) : 1589 jenv(jenv), jVector3(jVector3), cbtVector3(cbtVector3), poolName(poolName) { }; 1590 gdxAutoCommitbtVector3AndReleaseVector3(JNIEnv * jenv, jobject jVector3, btVector3 * cbtVector3, const char *poolName) : 1591 jenv(jenv), jVector3(jVector3), cbtVector3(*cbtVector3), poolName(poolName) { }; 1592 virtual ~gdxAutoCommitbtVector3AndReleaseVector3() { 1593 gdx_setbtVector3FromVector3(this->jenv, this->cbtVector3, this->jVector3); 1594 gdx_releasePoolObjectVector3(this->jenv, this->poolName, this->jVector3); 1595 }; 1596 }; 1597 1598 1599 1600 /* Gets a global ref to the temp class. Do not release this. */ 1601 SWIGINTERN inline jclass gdx_getTempClassMatrix3(JNIEnv * jenv) { 1602 static jclass cls = NULL; 1603 if (cls == NULL) { 1604 cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); 1605 } 1606 return cls; 1607 } 1608 1609 SWIGINTERN inline jobject gdx_takePoolObjectMatrix3(JNIEnv * jenv, const char * poolName) { 1610 jclass tempClass = gdx_getTempClassMatrix3(jenv); 1611 1612 static jfieldID poolField = NULL; 1613 if (poolField == NULL) { 1614 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1615 } 1616 1617 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1618 jclass poolClass = jenv->GetObjectClass(poolObject); 1619 1620 static jmethodID obtainMethod = NULL; 1621 if (obtainMethod == NULL) { 1622 obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); 1623 } 1624 1625 jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); 1626 1627 jenv->DeleteLocalRef(poolObject); 1628 jenv->DeleteLocalRef(poolClass); 1629 1630 return ret; 1631 } 1632 1633 SWIGINTERN inline void gdx_releasePoolObjectMatrix3(JNIEnv * jenv, const char * poolName, jobject obj) { 1634 jclass tempClass = gdx_getTempClassMatrix3(jenv); 1635 1636 static jfieldID poolField = NULL; 1637 if (poolField == NULL) { 1638 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1639 } 1640 1641 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1642 jclass poolClass = jenv->GetObjectClass(poolObject); 1643 1644 static jmethodID freeMethod = NULL; 1645 if (freeMethod == NULL) { 1646 freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); 1647 } 1648 1649 jenv->CallVoidMethod(poolObject, freeMethod, obj); 1650 1651 jenv->DeleteLocalRef(poolObject); 1652 jenv->DeleteLocalRef(poolClass); 1653 jenv->DeleteLocalRef(obj); 1654 } 1655 1656 /* 1657 * A simple RAII wrapper to release jobjects we obtain from pools in 1658 * directorin typemaps. SWIG doesn't have hooks to release them after 1659 * they're used. 1660 */ 1661 class gdxPoolAutoReleaseMatrix3 { 1662 private: 1663 JNIEnv * jenv; 1664 const char * poolName; 1665 jobject obj; 1666 public: 1667 gdxPoolAutoReleaseMatrix3(JNIEnv * jenv, const char * poolName, jobject obj) : 1668 jenv(jenv), poolName(poolName), obj(obj) { }; 1669 virtual ~gdxPoolAutoReleaseMatrix3() { 1670 gdx_releasePoolObjectMatrix3(this->jenv, this->poolName, this->obj); 1671 }; 1672 }; 1673 1674 1675 1676 // Workaround for some strange swig behaviour 1677 1678 1679 /* Gets a global ref to the temp class's Return Matrix3. Do not release this. */ 1680 SWIGINTERN inline jobject gdx_getReturnMatrix3(JNIEnv * jenv) { 1681 static jobject ret = NULL; 1682 if (ret == NULL) { 1683 jclass tempClass = gdx_getTempClassMatrix3(jenv); 1684 jfieldID field = jenv->GetStaticFieldID(tempClass, "staticMatrix3", "Lcom/badlogic/gdx/math/Matrix3;"); 1685 ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); 1686 } 1687 return ret; 1688 } 1689 1690 /* Sets the data in the Bullet type from the Gdx type. */ 1691 SWIGINTERN inline void gdx_setbtMatrix3x3FromMatrix3(JNIEnv * jenv, btMatrix3x3 & target, jobject source) { 1692 Matrix3_to_btMatrix3(jenv, target, source); 1693 } 1694 1695 SWIGINTERN inline void gdx_setbtMatrix3x3FromMatrix3(JNIEnv * jenv, btMatrix3x3 * target, jobject source) { 1696 gdx_setbtMatrix3x3FromMatrix3(jenv, *target, source); 1697 } 1698 1699 /* Sets the data in the Gdx type from the Bullet type. */ 1700 SWIGINTERN inline void gdx_setMatrix3FrombtMatrix3x3(JNIEnv * jenv, jobject target, const btMatrix3x3 & source) { 1701 btMatrix3_to_Matrix3(jenv, target, source); 1702 } 1703 1704 SWIGINTERN inline void gdx_setMatrix3FrombtMatrix3x3(JNIEnv * jenv, jobject target, const btMatrix3x3 * source) { 1705 gdx_setMatrix3FrombtMatrix3x3(jenv, target, *source); 1706 } 1707 1708 /* 1709 * RAII wrapper to commit changes made to a local btMatrix3x3 back to Matrix3 1710 */ 1711 class gdxAutoCommitMatrix3 { 1712 private: 1713 JNIEnv * jenv; 1714 jobject jMatrix3; 1715 btMatrix3x3 & cbtMatrix3x3; 1716 public: 1717 gdxAutoCommitMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 & cbtMatrix3x3) : 1718 jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(cbtMatrix3x3) { }; 1719 gdxAutoCommitMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 * cbtMatrix3x3) : 1720 jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(*cbtMatrix3x3) { }; 1721 virtual ~gdxAutoCommitMatrix3() { 1722 gdx_setMatrix3FrombtMatrix3x3(this->jenv, this->jMatrix3, this->cbtMatrix3x3); 1723 }; 1724 }; 1725 1726 class gdxAutoCommitbtMatrix3x3AndReleaseMatrix3 { 1727 private: 1728 JNIEnv * jenv; 1729 jobject jMatrix3; 1730 btMatrix3x3 & cbtMatrix3x3; 1731 const char * poolName; 1732 public: 1733 gdxAutoCommitbtMatrix3x3AndReleaseMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 & cbtMatrix3x3, const char *poolName) : 1734 jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(cbtMatrix3x3), poolName(poolName) { }; 1735 gdxAutoCommitbtMatrix3x3AndReleaseMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 * cbtMatrix3x3, const char *poolName) : 1736 jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(*cbtMatrix3x3), poolName(poolName) { }; 1737 virtual ~gdxAutoCommitbtMatrix3x3AndReleaseMatrix3() { 1738 gdx_setbtMatrix3x3FromMatrix3(this->jenv, this->cbtMatrix3x3, this->jMatrix3); 1739 gdx_releasePoolObjectMatrix3(this->jenv, this->poolName, this->jMatrix3); 1740 }; 1741 }; 1742 1743 1744 1745 /* Gets a global ref to the temp class. Do not release this. */ 1746 SWIGINTERN inline jclass gdx_getTempClassMatrix4(JNIEnv * jenv) { 1747 static jclass cls = NULL; 1748 if (cls == NULL) { 1749 cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); 1750 } 1751 return cls; 1752 } 1753 1754 SWIGINTERN inline jobject gdx_takePoolObjectMatrix4(JNIEnv * jenv, const char * poolName) { 1755 jclass tempClass = gdx_getTempClassMatrix4(jenv); 1756 1757 static jfieldID poolField = NULL; 1758 if (poolField == NULL) { 1759 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1760 } 1761 1762 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1763 jclass poolClass = jenv->GetObjectClass(poolObject); 1764 1765 static jmethodID obtainMethod = NULL; 1766 if (obtainMethod == NULL) { 1767 obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); 1768 } 1769 1770 jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); 1771 1772 jenv->DeleteLocalRef(poolObject); 1773 jenv->DeleteLocalRef(poolClass); 1774 1775 return ret; 1776 } 1777 1778 SWIGINTERN inline void gdx_releasePoolObjectMatrix4(JNIEnv * jenv, const char * poolName, jobject obj) { 1779 jclass tempClass = gdx_getTempClassMatrix4(jenv); 1780 1781 static jfieldID poolField = NULL; 1782 if (poolField == NULL) { 1783 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1784 } 1785 1786 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1787 jclass poolClass = jenv->GetObjectClass(poolObject); 1788 1789 static jmethodID freeMethod = NULL; 1790 if (freeMethod == NULL) { 1791 freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); 1792 } 1793 1794 jenv->CallVoidMethod(poolObject, freeMethod, obj); 1795 1796 jenv->DeleteLocalRef(poolObject); 1797 jenv->DeleteLocalRef(poolClass); 1798 jenv->DeleteLocalRef(obj); 1799 } 1800 1801 /* 1802 * A simple RAII wrapper to release jobjects we obtain from pools in 1803 * directorin typemaps. SWIG doesn't have hooks to release them after 1804 * they're used. 1805 */ 1806 class gdxPoolAutoReleaseMatrix4 { 1807 private: 1808 JNIEnv * jenv; 1809 const char * poolName; 1810 jobject obj; 1811 public: 1812 gdxPoolAutoReleaseMatrix4(JNIEnv * jenv, const char * poolName, jobject obj) : 1813 jenv(jenv), poolName(poolName), obj(obj) { }; 1814 virtual ~gdxPoolAutoReleaseMatrix4() { 1815 gdx_releasePoolObjectMatrix4(this->jenv, this->poolName, this->obj); 1816 }; 1817 }; 1818 1819 1820 1821 // Workaround for some strange swig behaviour 1822 1823 1824 /* Gets a global ref to the temp class's Return Matrix4. Do not release this. */ 1825 SWIGINTERN inline jobject gdx_getReturnMatrix4(JNIEnv * jenv) { 1826 static jobject ret = NULL; 1827 if (ret == NULL) { 1828 jclass tempClass = gdx_getTempClassMatrix4(jenv); 1829 jfieldID field = jenv->GetStaticFieldID(tempClass, "staticMatrix4", "Lcom/badlogic/gdx/math/Matrix4;"); 1830 ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); 1831 } 1832 return ret; 1833 } 1834 1835 /* Sets the data in the Bullet type from the Gdx type. */ 1836 SWIGINTERN inline void gdx_setbtTransformFromMatrix4(JNIEnv * jenv, btTransform & target, jobject source) { 1837 Matrix4_to_btTransform(jenv, target, source); 1838 } 1839 1840 SWIGINTERN inline void gdx_setbtTransformFromMatrix4(JNIEnv * jenv, btTransform * target, jobject source) { 1841 gdx_setbtTransformFromMatrix4(jenv, *target, source); 1842 } 1843 1844 /* Sets the data in the Gdx type from the Bullet type. */ 1845 SWIGINTERN inline void gdx_setMatrix4FrombtTransform(JNIEnv * jenv, jobject target, const btTransform & source) { 1846 btTransform_to_Matrix4(jenv, target, source); 1847 } 1848 1849 SWIGINTERN inline void gdx_setMatrix4FrombtTransform(JNIEnv * jenv, jobject target, const btTransform * source) { 1850 gdx_setMatrix4FrombtTransform(jenv, target, *source); 1851 } 1852 1853 /* 1854 * RAII wrapper to commit changes made to a local btTransform back to Matrix4 1855 */ 1856 class gdxAutoCommitMatrix4 { 1857 private: 1858 JNIEnv * jenv; 1859 jobject jMatrix4; 1860 btTransform & cbtTransform; 1861 public: 1862 gdxAutoCommitMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform & cbtTransform) : 1863 jenv(jenv), jMatrix4(jMatrix4), cbtTransform(cbtTransform) { }; 1864 gdxAutoCommitMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform * cbtTransform) : 1865 jenv(jenv), jMatrix4(jMatrix4), cbtTransform(*cbtTransform) { }; 1866 virtual ~gdxAutoCommitMatrix4() { 1867 gdx_setMatrix4FrombtTransform(this->jenv, this->jMatrix4, this->cbtTransform); 1868 }; 1869 }; 1870 1871 class gdxAutoCommitbtTransformAndReleaseMatrix4 { 1872 private: 1873 JNIEnv * jenv; 1874 jobject jMatrix4; 1875 btTransform & cbtTransform; 1876 const char * poolName; 1877 public: 1878 gdxAutoCommitbtTransformAndReleaseMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform & cbtTransform, const char *poolName) : 1879 jenv(jenv), jMatrix4(jMatrix4), cbtTransform(cbtTransform), poolName(poolName) { }; 1880 gdxAutoCommitbtTransformAndReleaseMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform * cbtTransform, const char *poolName) : 1881 jenv(jenv), jMatrix4(jMatrix4), cbtTransform(*cbtTransform), poolName(poolName) { }; 1882 virtual ~gdxAutoCommitbtTransformAndReleaseMatrix4() { 1883 gdx_setbtTransformFromMatrix4(this->jenv, this->cbtTransform, this->jMatrix4); 1884 gdx_releasePoolObjectMatrix4(this->jenv, this->poolName, this->jMatrix4); 1885 }; 1886 }; 1887 1888 1889 #include <LinearMath/btVector3.h> 1890 1891 1892 #include <LinearMath/btQuaternion.h> 1893 1894 1895 #include <LinearMath/btQuadWord.h> 1896 1897 1898 #include <LinearMath/btMatrix3x3.h> 1899 1900 1901 #include <LinearMath/btAabbUtil2.h> 1902 1903 1904 #include <LinearMath/btIDebugDraw.h> 1905 1906 1907 #include <LinearMath/btGeometryUtil.h> 1908 1909 bool btGeometryUtil::isInside(btAlignedObjectArray<btVector3> const&, btVector3 const&, float) 1910 { 1911 return false; 1912 } 1913 1914 1915 #include <LinearMath/btRandom.h> 1916 1917 1918 #include <LinearMath/btTransformUtil.h> 1919 1920 1921 #include <LinearMath/btConvexHull.h> 1922 1923 1924 #include <LinearMath/btGrahamScan2dConvexHull.h> 1925 1926 1927 #include <LinearMath/btPoolAllocator.h> 1928 1929 1930 #include <LinearMath/btQuickprof.h> 1931 1932 1933 #include <LinearMath/btConvexHullComputer.h> 1934 1935 1936 #include <LinearMath/btAlignedObjectArray.h> 1937 1938 1939 #include <LinearMath/btList.h> 1940 1941 1942 #include <LinearMath/btAlignedAllocator.h> 1943 1944 1945 #include <LinearMath/btHashMap.h> 1946 1947 1948 #include <LinearMath/btStackAlloc.h> 1949 1950 1951 #include <LinearMath/btMinMax.h> 1952 1953 1954 #include <LinearMath/btMotionState.h> 1955 1956 1957 #include <LinearMath/btDefaultMotionState.h> 1958 1959 SWIGINTERN void btDefaultMotionState_getGraphicsWorldTrans(btDefaultMotionState *self,btTransform &out){ 1960 out = self->m_graphicsWorldTrans; 1961 } 1962 SWIGINTERN void btDefaultMotionState_getCenterOfMassOffset(btDefaultMotionState *self,btTransform &out){ 1963 out = self->m_centerOfMassOffset; 1964 } 1965 SWIGINTERN void btDefaultMotionState_getStartWorldTrans(btDefaultMotionState *self,btTransform &out){ 1966 out = self->m_startWorldTrans; 1967 } 1968 1969 1970 /* --------------------------------------------------- 1971 * C++ director class methods 1972 * --------------------------------------------------- */ 1973 1974 #include "linearmath_wrap.h" 1975 1976 SwigDirector_btIDebugDraw::SwigDirector_btIDebugDraw(JNIEnv *jenv) : btIDebugDraw(), Swig::Director(jenv) { 1977 } 1978 1979 SwigDirector_btIDebugDraw::~SwigDirector_btIDebugDraw() { 1980 swig_disconnect_director_self("swigDirectorDisconnect"); 1981 } 1982 1983 1984 btIDebugDraw::DefaultColors SwigDirector_btIDebugDraw::getDefaultColors() const { 1985 btIDebugDraw::DefaultColors c_result ; 1986 jlong jresult = 0 ; 1987 JNIEnvWrapper swigjnienv(this) ; 1988 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 1989 jobject swigjobj = (jobject) NULL ; 1990 btIDebugDraw::DefaultColors *argp ; 1991 1992 if (!swig_override[0]) { 1993 return btIDebugDraw::getDefaultColors(); 1994 } 1995 swigjobj = swig_get_self(jenv); 1996 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 1997 jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[0], swigjobj); 1998 jthrowable swigerror = jenv->ExceptionOccurred(); 1999 if (swigerror) { 2000 jenv->ExceptionClear(); 2001 throw Swig::DirectorException(jenv, swigerror); 2002 } 2003 2004 argp = *(btIDebugDraw::DefaultColors **)&jresult; 2005 if (!argp) { 2006 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type btIDebugDraw::DefaultColors"); 2007 return c_result; 2008 } 2009 c_result = *argp; 2010 } else { 2011 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::getDefaultColors "); 2012 } 2013 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2014 return c_result; 2015 } 2016 2017 void SwigDirector_btIDebugDraw::setDefaultColors(btIDebugDraw::DefaultColors const &arg0) { 2018 JNIEnvWrapper swigjnienv(this) ; 2019 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2020 jobject swigjobj = (jobject) NULL ; 2021 jlong jarg0 = 0 ; 2022 2023 if (!swig_override[1]) { 2024 btIDebugDraw::setDefaultColors(arg0); 2025 return; 2026 } 2027 swigjobj = swig_get_self(jenv); 2028 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2029 *(btIDebugDraw::DefaultColors **)&jarg0 = (btIDebugDraw::DefaultColors *) &arg0; 2030 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[1], swigjobj, jarg0); 2031 jthrowable swigerror = jenv->ExceptionOccurred(); 2032 if (swigerror) { 2033 jenv->ExceptionClear(); 2034 throw Swig::DirectorException(jenv, swigerror); 2035 } 2036 2037 } else { 2038 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::setDefaultColors "); 2039 } 2040 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2041 } 2042 2043 void SwigDirector_btIDebugDraw::drawLine(btVector3 const &from, btVector3 const &to, btVector3 const &color) { 2044 JNIEnvWrapper swigjnienv(this) ; 2045 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2046 jobject swigjobj = (jobject) NULL ; 2047 jobject jfrom = 0 ; 2048 jobject jto = 0 ; 2049 jobject jcolor = 0 ; 2050 2051 if (!swig_override[2]) { 2052 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::drawLine."); 2053 return; 2054 } 2055 swigjobj = swig_get_self(jenv); 2056 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2057 jfrom = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2058 gdx_setVector3FrombtVector3(jenv, jfrom, from); 2059 gdxPoolAutoReleaseVector3 autoRelease_jfrom(jenv, "poolVector3", jfrom); 2060 jto = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2061 gdx_setVector3FrombtVector3(jenv, jto, to); 2062 gdxPoolAutoReleaseVector3 autoRelease_jto(jenv, "poolVector3", jto); 2063 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2064 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2065 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2066 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[2], swigjobj, jfrom, jto, jcolor); 2067 jthrowable swigerror = jenv->ExceptionOccurred(); 2068 if (swigerror) { 2069 jenv->ExceptionClear(); 2070 throw Swig::DirectorException(jenv, swigerror); 2071 } 2072 2073 } else { 2074 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawLine "); 2075 } 2076 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2077 } 2078 2079 void SwigDirector_btIDebugDraw::drawLine(btVector3 const &from, btVector3 const &to, btVector3 const &fromColor, btVector3 const &toColor) { 2080 JNIEnvWrapper swigjnienv(this) ; 2081 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2082 jobject swigjobj = (jobject) NULL ; 2083 jobject jfrom = 0 ; 2084 jobject jto = 0 ; 2085 jobject jfromColor = 0 ; 2086 jobject jtoColor = 0 ; 2087 2088 if (!swig_override[3]) { 2089 btIDebugDraw::drawLine(from,to,fromColor,toColor); 2090 return; 2091 } 2092 swigjobj = swig_get_self(jenv); 2093 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2094 jfrom = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2095 gdx_setVector3FrombtVector3(jenv, jfrom, from); 2096 gdxPoolAutoReleaseVector3 autoRelease_jfrom(jenv, "poolVector3", jfrom); 2097 jto = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2098 gdx_setVector3FrombtVector3(jenv, jto, to); 2099 gdxPoolAutoReleaseVector3 autoRelease_jto(jenv, "poolVector3", jto); 2100 jfromColor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2101 gdx_setVector3FrombtVector3(jenv, jfromColor, fromColor); 2102 gdxPoolAutoReleaseVector3 autoRelease_jfromColor(jenv, "poolVector3", jfromColor); 2103 jtoColor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2104 gdx_setVector3FrombtVector3(jenv, jtoColor, toColor); 2105 gdxPoolAutoReleaseVector3 autoRelease_jtoColor(jenv, "poolVector3", jtoColor); 2106 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[3], swigjobj, jfrom, jto, jfromColor, jtoColor); 2107 jthrowable swigerror = jenv->ExceptionOccurred(); 2108 if (swigerror) { 2109 jenv->ExceptionClear(); 2110 throw Swig::DirectorException(jenv, swigerror); 2111 } 2112 2113 } else { 2114 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawLine "); 2115 } 2116 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2117 } 2118 2119 void SwigDirector_btIDebugDraw::drawSphere(btScalar radius, btTransform const &transform, btVector3 const &color) { 2120 JNIEnvWrapper swigjnienv(this) ; 2121 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2122 jobject swigjobj = (jobject) NULL ; 2123 jfloat jradius ; 2124 jobject jtransform = 0 ; 2125 jobject jcolor = 0 ; 2126 2127 if (!swig_override[4]) { 2128 btIDebugDraw::drawSphere(radius,transform,color); 2129 return; 2130 } 2131 swigjobj = swig_get_self(jenv); 2132 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2133 jradius = (jfloat) radius; 2134 jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); 2135 gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); 2136 gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); 2137 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2138 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2139 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2140 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[4], swigjobj, jradius, jtransform, jcolor); 2141 jthrowable swigerror = jenv->ExceptionOccurred(); 2142 if (swigerror) { 2143 jenv->ExceptionClear(); 2144 throw Swig::DirectorException(jenv, swigerror); 2145 } 2146 2147 } else { 2148 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawSphere "); 2149 } 2150 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2151 } 2152 2153 void SwigDirector_btIDebugDraw::drawSphere(btVector3 const &p, btScalar radius, btVector3 const &color) { 2154 JNIEnvWrapper swigjnienv(this) ; 2155 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2156 jobject swigjobj = (jobject) NULL ; 2157 jobject jp = 0 ; 2158 jfloat jradius ; 2159 jobject jcolor = 0 ; 2160 2161 if (!swig_override[5]) { 2162 btIDebugDraw::drawSphere(p,radius,color); 2163 return; 2164 } 2165 swigjobj = swig_get_self(jenv); 2166 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2167 jp = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2168 gdx_setVector3FrombtVector3(jenv, jp, p); 2169 gdxPoolAutoReleaseVector3 autoRelease_jp(jenv, "poolVector3", jp); 2170 jradius = (jfloat) radius; 2171 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2172 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2173 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2174 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[5], swigjobj, jp, jradius, jcolor); 2175 jthrowable swigerror = jenv->ExceptionOccurred(); 2176 if (swigerror) { 2177 jenv->ExceptionClear(); 2178 throw Swig::DirectorException(jenv, swigerror); 2179 } 2180 2181 } else { 2182 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawSphere "); 2183 } 2184 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2185 } 2186 2187 void SwigDirector_btIDebugDraw::drawTriangle(btVector3 const &v0, btVector3 const &v1, btVector3 const &v2, btVector3 const &arg3, btVector3 const &arg4, btVector3 const &arg5, btVector3 const &color, btScalar alpha) { 2188 JNIEnvWrapper swigjnienv(this) ; 2189 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2190 jobject swigjobj = (jobject) NULL ; 2191 jobject jv0 = 0 ; 2192 jobject jv1 = 0 ; 2193 jobject jv2 = 0 ; 2194 jobject jarg3 = 0 ; 2195 jobject jarg4 = 0 ; 2196 jobject jarg5 = 0 ; 2197 jobject jcolor = 0 ; 2198 jfloat jalpha ; 2199 2200 if (!swig_override[6]) { 2201 btIDebugDraw::drawTriangle(v0,v1,v2,arg3,arg4,arg5,color,alpha); 2202 return; 2203 } 2204 swigjobj = swig_get_self(jenv); 2205 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2206 jv0 = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2207 gdx_setVector3FrombtVector3(jenv, jv0, v0); 2208 gdxPoolAutoReleaseVector3 autoRelease_jv0(jenv, "poolVector3", jv0); 2209 jv1 = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2210 gdx_setVector3FrombtVector3(jenv, jv1, v1); 2211 gdxPoolAutoReleaseVector3 autoRelease_jv1(jenv, "poolVector3", jv1); 2212 jv2 = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2213 gdx_setVector3FrombtVector3(jenv, jv2, v2); 2214 gdxPoolAutoReleaseVector3 autoRelease_jv2(jenv, "poolVector3", jv2); 2215 jarg3 = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2216 gdx_setVector3FrombtVector3(jenv, jarg3, arg3); 2217 gdxPoolAutoReleaseVector3 autoRelease_jarg3(jenv, "poolVector3", jarg3); 2218 jarg4 = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2219 gdx_setVector3FrombtVector3(jenv, jarg4, arg4); 2220 gdxPoolAutoReleaseVector3 autoRelease_jarg4(jenv, "poolVector3", jarg4); 2221 jarg5 = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2222 gdx_setVector3FrombtVector3(jenv, jarg5, arg5); 2223 gdxPoolAutoReleaseVector3 autoRelease_jarg5(jenv, "poolVector3", jarg5); 2224 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2225 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2226 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2227 jalpha = (jfloat) alpha; 2228 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[6], swigjobj, jv0, jv1, jv2, jarg3, jarg4, jarg5, jcolor, jalpha); 2229 jthrowable swigerror = jenv->ExceptionOccurred(); 2230 if (swigerror) { 2231 jenv->ExceptionClear(); 2232 throw Swig::DirectorException(jenv, swigerror); 2233 } 2234 2235 } else { 2236 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawTriangle "); 2237 } 2238 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2239 } 2240 2241 void SwigDirector_btIDebugDraw::drawTriangle(btVector3 const &v0, btVector3 const &v1, btVector3 const &v2, btVector3 const &color, btScalar arg4) { 2242 JNIEnvWrapper swigjnienv(this) ; 2243 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2244 jobject swigjobj = (jobject) NULL ; 2245 jobject jv0 = 0 ; 2246 jobject jv1 = 0 ; 2247 jobject jv2 = 0 ; 2248 jobject jcolor = 0 ; 2249 jfloat jarg4 ; 2250 2251 if (!swig_override[7]) { 2252 btIDebugDraw::drawTriangle(v0,v1,v2,color,arg4); 2253 return; 2254 } 2255 swigjobj = swig_get_self(jenv); 2256 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2257 jv0 = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2258 gdx_setVector3FrombtVector3(jenv, jv0, v0); 2259 gdxPoolAutoReleaseVector3 autoRelease_jv0(jenv, "poolVector3", jv0); 2260 jv1 = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2261 gdx_setVector3FrombtVector3(jenv, jv1, v1); 2262 gdxPoolAutoReleaseVector3 autoRelease_jv1(jenv, "poolVector3", jv1); 2263 jv2 = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2264 gdx_setVector3FrombtVector3(jenv, jv2, v2); 2265 gdxPoolAutoReleaseVector3 autoRelease_jv2(jenv, "poolVector3", jv2); 2266 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2267 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2268 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2269 jarg4 = (jfloat) arg4; 2270 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[7], swigjobj, jv0, jv1, jv2, jcolor, jarg4); 2271 jthrowable swigerror = jenv->ExceptionOccurred(); 2272 if (swigerror) { 2273 jenv->ExceptionClear(); 2274 throw Swig::DirectorException(jenv, swigerror); 2275 } 2276 2277 } else { 2278 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawTriangle "); 2279 } 2280 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2281 } 2282 2283 void SwigDirector_btIDebugDraw::drawContactPoint(btVector3 const &PointOnB, btVector3 const &normalOnB, btScalar distance, int lifeTime, btVector3 const &color) { 2284 JNIEnvWrapper swigjnienv(this) ; 2285 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2286 jobject swigjobj = (jobject) NULL ; 2287 jobject jPointOnB = 0 ; 2288 jobject jnormalOnB = 0 ; 2289 jfloat jdistance ; 2290 jint jlifeTime ; 2291 jobject jcolor = 0 ; 2292 2293 if (!swig_override[8]) { 2294 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::drawContactPoint."); 2295 return; 2296 } 2297 swigjobj = swig_get_self(jenv); 2298 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2299 jPointOnB = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2300 gdx_setVector3FrombtVector3(jenv, jPointOnB, PointOnB); 2301 gdxPoolAutoReleaseVector3 autoRelease_jPointOnB(jenv, "poolVector3", jPointOnB); 2302 jnormalOnB = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2303 gdx_setVector3FrombtVector3(jenv, jnormalOnB, normalOnB); 2304 gdxPoolAutoReleaseVector3 autoRelease_jnormalOnB(jenv, "poolVector3", jnormalOnB); 2305 jdistance = (jfloat) distance; 2306 jlifeTime = (jint) lifeTime; 2307 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2308 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2309 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2310 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[8], swigjobj, jPointOnB, jnormalOnB, jdistance, jlifeTime, jcolor); 2311 jthrowable swigerror = jenv->ExceptionOccurred(); 2312 if (swigerror) { 2313 jenv->ExceptionClear(); 2314 throw Swig::DirectorException(jenv, swigerror); 2315 } 2316 2317 } else { 2318 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawContactPoint "); 2319 } 2320 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2321 } 2322 2323 void SwigDirector_btIDebugDraw::reportErrorWarning(char const *warningString) { 2324 JNIEnvWrapper swigjnienv(this) ; 2325 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2326 jobject swigjobj = (jobject) NULL ; 2327 jstring jwarningString = 0 ; 2328 2329 if (!swig_override[9]) { 2330 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::reportErrorWarning."); 2331 return; 2332 } 2333 swigjobj = swig_get_self(jenv); 2334 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2335 jwarningString = 0; 2336 if (warningString) { 2337 jwarningString = jenv->NewStringUTF((const char *)warningString); 2338 if (!jwarningString) return ; 2339 } 2340 Swig::LocalRefGuard warningString_refguard(jenv, jwarningString); 2341 // boohoo 2342 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[9], swigjobj, jwarningString); 2343 jthrowable swigerror = jenv->ExceptionOccurred(); 2344 if (swigerror) { 2345 jenv->ExceptionClear(); 2346 throw Swig::DirectorException(jenv, swigerror); 2347 } 2348 2349 } else { 2350 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::reportErrorWarning "); 2351 } 2352 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2353 } 2354 2355 void SwigDirector_btIDebugDraw::draw3dText(btVector3 const &location, char const *textString) { 2356 JNIEnvWrapper swigjnienv(this) ; 2357 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2358 jobject swigjobj = (jobject) NULL ; 2359 jobject jlocation = 0 ; 2360 jstring jtextString = 0 ; 2361 2362 if (!swig_override[10]) { 2363 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::draw3dText."); 2364 return; 2365 } 2366 swigjobj = swig_get_self(jenv); 2367 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2368 jlocation = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2369 gdx_setVector3FrombtVector3(jenv, jlocation, location); 2370 gdxPoolAutoReleaseVector3 autoRelease_jlocation(jenv, "poolVector3", jlocation); 2371 jtextString = 0; 2372 if (textString) { 2373 jtextString = jenv->NewStringUTF((const char *)textString); 2374 if (!jtextString) return ; 2375 } 2376 Swig::LocalRefGuard textString_refguard(jenv, jtextString); 2377 // boohoo 2378 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[10], swigjobj, jlocation, jtextString); 2379 jthrowable swigerror = jenv->ExceptionOccurred(); 2380 if (swigerror) { 2381 jenv->ExceptionClear(); 2382 throw Swig::DirectorException(jenv, swigerror); 2383 } 2384 2385 } else { 2386 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::draw3dText "); 2387 } 2388 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2389 } 2390 2391 void SwigDirector_btIDebugDraw::setDebugMode(int debugMode) { 2392 JNIEnvWrapper swigjnienv(this) ; 2393 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2394 jobject swigjobj = (jobject) NULL ; 2395 jint jdebugMode ; 2396 2397 if (!swig_override[11]) { 2398 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::setDebugMode."); 2399 return; 2400 } 2401 swigjobj = swig_get_self(jenv); 2402 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2403 jdebugMode = (jint) debugMode; 2404 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[11], swigjobj, jdebugMode); 2405 jthrowable swigerror = jenv->ExceptionOccurred(); 2406 if (swigerror) { 2407 jenv->ExceptionClear(); 2408 throw Swig::DirectorException(jenv, swigerror); 2409 } 2410 2411 } else { 2412 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::setDebugMode "); 2413 } 2414 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2415 } 2416 2417 int SwigDirector_btIDebugDraw::getDebugMode() const { 2418 int c_result = SwigValueInit< int >() ; 2419 jint jresult = 0 ; 2420 JNIEnvWrapper swigjnienv(this) ; 2421 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2422 jobject swigjobj = (jobject) NULL ; 2423 2424 if (!swig_override[12]) { 2425 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::getDebugMode."); 2426 return c_result; 2427 } 2428 swigjobj = swig_get_self(jenv); 2429 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2430 jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[12], swigjobj); 2431 jthrowable swigerror = jenv->ExceptionOccurred(); 2432 if (swigerror) { 2433 jenv->ExceptionClear(); 2434 throw Swig::DirectorException(jenv, swigerror); 2435 } 2436 2437 c_result = (int)jresult; 2438 } else { 2439 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::getDebugMode "); 2440 } 2441 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2442 return c_result; 2443 } 2444 2445 void SwigDirector_btIDebugDraw::drawAabb(btVector3 const &from, btVector3 const &to, btVector3 const &color) { 2446 JNIEnvWrapper swigjnienv(this) ; 2447 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2448 jobject swigjobj = (jobject) NULL ; 2449 jobject jfrom = 0 ; 2450 jobject jto = 0 ; 2451 jobject jcolor = 0 ; 2452 2453 if (!swig_override[13]) { 2454 btIDebugDraw::drawAabb(from,to,color); 2455 return; 2456 } 2457 swigjobj = swig_get_self(jenv); 2458 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2459 jfrom = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2460 gdx_setVector3FrombtVector3(jenv, jfrom, from); 2461 gdxPoolAutoReleaseVector3 autoRelease_jfrom(jenv, "poolVector3", jfrom); 2462 jto = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2463 gdx_setVector3FrombtVector3(jenv, jto, to); 2464 gdxPoolAutoReleaseVector3 autoRelease_jto(jenv, "poolVector3", jto); 2465 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2466 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2467 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2468 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[13], swigjobj, jfrom, jto, jcolor); 2469 jthrowable swigerror = jenv->ExceptionOccurred(); 2470 if (swigerror) { 2471 jenv->ExceptionClear(); 2472 throw Swig::DirectorException(jenv, swigerror); 2473 } 2474 2475 } else { 2476 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawAabb "); 2477 } 2478 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2479 } 2480 2481 void SwigDirector_btIDebugDraw::drawTransform(btTransform const &transform, btScalar orthoLen) { 2482 JNIEnvWrapper swigjnienv(this) ; 2483 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2484 jobject swigjobj = (jobject) NULL ; 2485 jobject jtransform = 0 ; 2486 jfloat jorthoLen ; 2487 2488 if (!swig_override[14]) { 2489 btIDebugDraw::drawTransform(transform,orthoLen); 2490 return; 2491 } 2492 swigjobj = swig_get_self(jenv); 2493 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2494 jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); 2495 gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); 2496 gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); 2497 jorthoLen = (jfloat) orthoLen; 2498 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[14], swigjobj, jtransform, jorthoLen); 2499 jthrowable swigerror = jenv->ExceptionOccurred(); 2500 if (swigerror) { 2501 jenv->ExceptionClear(); 2502 throw Swig::DirectorException(jenv, swigerror); 2503 } 2504 2505 } else { 2506 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawTransform "); 2507 } 2508 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2509 } 2510 2511 void SwigDirector_btIDebugDraw::drawArc(btVector3 const ¢er, btVector3 const &normal, btVector3 const &axis, btScalar radiusA, btScalar radiusB, btScalar minAngle, btScalar maxAngle, btVector3 const &color, bool drawSect, btScalar stepDegrees) { 2512 JNIEnvWrapper swigjnienv(this) ; 2513 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2514 jobject swigjobj = (jobject) NULL ; 2515 jobject jcenter = 0 ; 2516 jobject jnormal = 0 ; 2517 jobject jaxis = 0 ; 2518 jfloat jradiusA ; 2519 jfloat jradiusB ; 2520 jfloat jminAngle ; 2521 jfloat jmaxAngle ; 2522 jobject jcolor = 0 ; 2523 jboolean jdrawSect ; 2524 jfloat jstepDegrees ; 2525 2526 if (!swig_override[15]) { 2527 btIDebugDraw::drawArc(center,normal,axis,radiusA,radiusB,minAngle,maxAngle,color,drawSect,stepDegrees); 2528 return; 2529 } 2530 swigjobj = swig_get_self(jenv); 2531 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2532 jcenter = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2533 gdx_setVector3FrombtVector3(jenv, jcenter, center); 2534 gdxPoolAutoReleaseVector3 autoRelease_jcenter(jenv, "poolVector3", jcenter); 2535 jnormal = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2536 gdx_setVector3FrombtVector3(jenv, jnormal, normal); 2537 gdxPoolAutoReleaseVector3 autoRelease_jnormal(jenv, "poolVector3", jnormal); 2538 jaxis = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2539 gdx_setVector3FrombtVector3(jenv, jaxis, axis); 2540 gdxPoolAutoReleaseVector3 autoRelease_jaxis(jenv, "poolVector3", jaxis); 2541 jradiusA = (jfloat) radiusA; 2542 jradiusB = (jfloat) radiusB; 2543 jminAngle = (jfloat) minAngle; 2544 jmaxAngle = (jfloat) maxAngle; 2545 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2546 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2547 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2548 jdrawSect = (jboolean) drawSect; 2549 jstepDegrees = (jfloat) stepDegrees; 2550 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[15], swigjobj, jcenter, jnormal, jaxis, jradiusA, jradiusB, jminAngle, jmaxAngle, jcolor, jdrawSect, jstepDegrees); 2551 jthrowable swigerror = jenv->ExceptionOccurred(); 2552 if (swigerror) { 2553 jenv->ExceptionClear(); 2554 throw Swig::DirectorException(jenv, swigerror); 2555 } 2556 2557 } else { 2558 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawArc "); 2559 } 2560 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2561 } 2562 2563 void SwigDirector_btIDebugDraw::drawSpherePatch(btVector3 const ¢er, btVector3 const &up, btVector3 const &axis, btScalar radius, btScalar minTh, btScalar maxTh, btScalar minPs, btScalar maxPs, btVector3 const &color, btScalar stepDegrees, bool drawCenter) { 2564 JNIEnvWrapper swigjnienv(this) ; 2565 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2566 jobject swigjobj = (jobject) NULL ; 2567 jobject jcenter = 0 ; 2568 jobject jup = 0 ; 2569 jobject jaxis = 0 ; 2570 jfloat jradius ; 2571 jfloat jminTh ; 2572 jfloat jmaxTh ; 2573 jfloat jminPs ; 2574 jfloat jmaxPs ; 2575 jobject jcolor = 0 ; 2576 jfloat jstepDegrees ; 2577 jboolean jdrawCenter ; 2578 2579 if (!swig_override[17]) { 2580 btIDebugDraw::drawSpherePatch(center,up,axis,radius,minTh,maxTh,minPs,maxPs,color,stepDegrees,drawCenter); 2581 return; 2582 } 2583 swigjobj = swig_get_self(jenv); 2584 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2585 jcenter = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2586 gdx_setVector3FrombtVector3(jenv, jcenter, center); 2587 gdxPoolAutoReleaseVector3 autoRelease_jcenter(jenv, "poolVector3", jcenter); 2588 jup = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2589 gdx_setVector3FrombtVector3(jenv, jup, up); 2590 gdxPoolAutoReleaseVector3 autoRelease_jup(jenv, "poolVector3", jup); 2591 jaxis = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2592 gdx_setVector3FrombtVector3(jenv, jaxis, axis); 2593 gdxPoolAutoReleaseVector3 autoRelease_jaxis(jenv, "poolVector3", jaxis); 2594 jradius = (jfloat) radius; 2595 jminTh = (jfloat) minTh; 2596 jmaxTh = (jfloat) maxTh; 2597 jminPs = (jfloat) minPs; 2598 jmaxPs = (jfloat) maxPs; 2599 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2600 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2601 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2602 jstepDegrees = (jfloat) stepDegrees; 2603 jdrawCenter = (jboolean) drawCenter; 2604 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[17], swigjobj, jcenter, jup, jaxis, jradius, jminTh, jmaxTh, jminPs, jmaxPs, jcolor, jstepDegrees, jdrawCenter); 2605 jthrowable swigerror = jenv->ExceptionOccurred(); 2606 if (swigerror) { 2607 jenv->ExceptionClear(); 2608 throw Swig::DirectorException(jenv, swigerror); 2609 } 2610 2611 } else { 2612 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawSpherePatch "); 2613 } 2614 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2615 } 2616 2617 void SwigDirector_btIDebugDraw::drawBox(btVector3 const &bbMin, btVector3 const &bbMax, btVector3 const &color) { 2618 JNIEnvWrapper swigjnienv(this) ; 2619 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2620 jobject swigjobj = (jobject) NULL ; 2621 jobject jbbMin = 0 ; 2622 jobject jbbMax = 0 ; 2623 jobject jcolor = 0 ; 2624 2625 if (!swig_override[20]) { 2626 btIDebugDraw::drawBox(bbMin,bbMax,color); 2627 return; 2628 } 2629 swigjobj = swig_get_self(jenv); 2630 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2631 jbbMin = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2632 gdx_setVector3FrombtVector3(jenv, jbbMin, bbMin); 2633 gdxPoolAutoReleaseVector3 autoRelease_jbbMin(jenv, "poolVector3", jbbMin); 2634 jbbMax = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2635 gdx_setVector3FrombtVector3(jenv, jbbMax, bbMax); 2636 gdxPoolAutoReleaseVector3 autoRelease_jbbMax(jenv, "poolVector3", jbbMax); 2637 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2638 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2639 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2640 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[20], swigjobj, jbbMin, jbbMax, jcolor); 2641 jthrowable swigerror = jenv->ExceptionOccurred(); 2642 if (swigerror) { 2643 jenv->ExceptionClear(); 2644 throw Swig::DirectorException(jenv, swigerror); 2645 } 2646 2647 } else { 2648 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawBox "); 2649 } 2650 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2651 } 2652 2653 void SwigDirector_btIDebugDraw::drawBox(btVector3 const &bbMin, btVector3 const &bbMax, btTransform const &trans, btVector3 const &color) { 2654 JNIEnvWrapper swigjnienv(this) ; 2655 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2656 jobject swigjobj = (jobject) NULL ; 2657 jobject jbbMin = 0 ; 2658 jobject jbbMax = 0 ; 2659 jobject jtrans = 0 ; 2660 jobject jcolor = 0 ; 2661 2662 if (!swig_override[21]) { 2663 btIDebugDraw::drawBox(bbMin,bbMax,trans,color); 2664 return; 2665 } 2666 swigjobj = swig_get_self(jenv); 2667 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2668 jbbMin = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2669 gdx_setVector3FrombtVector3(jenv, jbbMin, bbMin); 2670 gdxPoolAutoReleaseVector3 autoRelease_jbbMin(jenv, "poolVector3", jbbMin); 2671 jbbMax = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2672 gdx_setVector3FrombtVector3(jenv, jbbMax, bbMax); 2673 gdxPoolAutoReleaseVector3 autoRelease_jbbMax(jenv, "poolVector3", jbbMax); 2674 jtrans = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); 2675 gdx_setMatrix4FrombtTransform(jenv, jtrans, trans); 2676 gdxPoolAutoReleaseMatrix4 autoRelease_jtrans(jenv, "poolMatrix4", jtrans); 2677 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2678 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2679 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2680 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[21], swigjobj, jbbMin, jbbMax, jtrans, jcolor); 2681 jthrowable swigerror = jenv->ExceptionOccurred(); 2682 if (swigerror) { 2683 jenv->ExceptionClear(); 2684 throw Swig::DirectorException(jenv, swigerror); 2685 } 2686 2687 } else { 2688 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawBox "); 2689 } 2690 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2691 } 2692 2693 void SwigDirector_btIDebugDraw::drawCapsule(btScalar radius, btScalar halfHeight, int upAxis, btTransform const &transform, btVector3 const &color) { 2694 JNIEnvWrapper swigjnienv(this) ; 2695 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2696 jobject swigjobj = (jobject) NULL ; 2697 jfloat jradius ; 2698 jfloat jhalfHeight ; 2699 jint jupAxis ; 2700 jobject jtransform = 0 ; 2701 jobject jcolor = 0 ; 2702 2703 if (!swig_override[22]) { 2704 btIDebugDraw::drawCapsule(radius,halfHeight,upAxis,transform,color); 2705 return; 2706 } 2707 swigjobj = swig_get_self(jenv); 2708 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2709 jradius = (jfloat) radius; 2710 jhalfHeight = (jfloat) halfHeight; 2711 jupAxis = (jint) upAxis; 2712 jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); 2713 gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); 2714 gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); 2715 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2716 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2717 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2718 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[22], swigjobj, jradius, jhalfHeight, jupAxis, jtransform, jcolor); 2719 jthrowable swigerror = jenv->ExceptionOccurred(); 2720 if (swigerror) { 2721 jenv->ExceptionClear(); 2722 throw Swig::DirectorException(jenv, swigerror); 2723 } 2724 2725 } else { 2726 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawCapsule "); 2727 } 2728 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2729 } 2730 2731 void SwigDirector_btIDebugDraw::drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, btTransform const &transform, btVector3 const &color) { 2732 JNIEnvWrapper swigjnienv(this) ; 2733 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2734 jobject swigjobj = (jobject) NULL ; 2735 jfloat jradius ; 2736 jfloat jhalfHeight ; 2737 jint jupAxis ; 2738 jobject jtransform = 0 ; 2739 jobject jcolor = 0 ; 2740 2741 if (!swig_override[23]) { 2742 btIDebugDraw::drawCylinder(radius,halfHeight,upAxis,transform,color); 2743 return; 2744 } 2745 swigjobj = swig_get_self(jenv); 2746 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2747 jradius = (jfloat) radius; 2748 jhalfHeight = (jfloat) halfHeight; 2749 jupAxis = (jint) upAxis; 2750 jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); 2751 gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); 2752 gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); 2753 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2754 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2755 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2756 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[23], swigjobj, jradius, jhalfHeight, jupAxis, jtransform, jcolor); 2757 jthrowable swigerror = jenv->ExceptionOccurred(); 2758 if (swigerror) { 2759 jenv->ExceptionClear(); 2760 throw Swig::DirectorException(jenv, swigerror); 2761 } 2762 2763 } else { 2764 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawCylinder "); 2765 } 2766 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2767 } 2768 2769 void SwigDirector_btIDebugDraw::drawCone(btScalar radius, btScalar height, int upAxis, btTransform const &transform, btVector3 const &color) { 2770 JNIEnvWrapper swigjnienv(this) ; 2771 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2772 jobject swigjobj = (jobject) NULL ; 2773 jfloat jradius ; 2774 jfloat jheight ; 2775 jint jupAxis ; 2776 jobject jtransform = 0 ; 2777 jobject jcolor = 0 ; 2778 2779 if (!swig_override[24]) { 2780 btIDebugDraw::drawCone(radius,height,upAxis,transform,color); 2781 return; 2782 } 2783 swigjobj = swig_get_self(jenv); 2784 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2785 jradius = (jfloat) radius; 2786 jheight = (jfloat) height; 2787 jupAxis = (jint) upAxis; 2788 jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); 2789 gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); 2790 gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); 2791 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2792 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2793 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2794 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[24], swigjobj, jradius, jheight, jupAxis, jtransform, jcolor); 2795 jthrowable swigerror = jenv->ExceptionOccurred(); 2796 if (swigerror) { 2797 jenv->ExceptionClear(); 2798 throw Swig::DirectorException(jenv, swigerror); 2799 } 2800 2801 } else { 2802 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawCone "); 2803 } 2804 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2805 } 2806 2807 void SwigDirector_btIDebugDraw::drawPlane(btVector3 const &planeNormal, btScalar planeConst, btTransform const &transform, btVector3 const &color) { 2808 JNIEnvWrapper swigjnienv(this) ; 2809 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2810 jobject swigjobj = (jobject) NULL ; 2811 jobject jplaneNormal = 0 ; 2812 jfloat jplaneConst ; 2813 jobject jtransform = 0 ; 2814 jobject jcolor = 0 ; 2815 2816 if (!swig_override[25]) { 2817 btIDebugDraw::drawPlane(planeNormal,planeConst,transform,color); 2818 return; 2819 } 2820 swigjobj = swig_get_self(jenv); 2821 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2822 jplaneNormal = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2823 gdx_setVector3FrombtVector3(jenv, jplaneNormal, planeNormal); 2824 gdxPoolAutoReleaseVector3 autoRelease_jplaneNormal(jenv, "poolVector3", jplaneNormal); 2825 jplaneConst = (jfloat) planeConst; 2826 jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); 2827 gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); 2828 gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); 2829 jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); 2830 gdx_setVector3FrombtVector3(jenv, jcolor, color); 2831 gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); 2832 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[25], swigjobj, jplaneNormal, jplaneConst, jtransform, jcolor); 2833 jthrowable swigerror = jenv->ExceptionOccurred(); 2834 if (swigerror) { 2835 jenv->ExceptionClear(); 2836 throw Swig::DirectorException(jenv, swigerror); 2837 } 2838 2839 } else { 2840 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawPlane "); 2841 } 2842 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2843 } 2844 2845 void SwigDirector_btIDebugDraw::flushLines() { 2846 JNIEnvWrapper swigjnienv(this) ; 2847 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2848 jobject swigjobj = (jobject) NULL ; 2849 2850 if (!swig_override[26]) { 2851 btIDebugDraw::flushLines(); 2852 return; 2853 } 2854 swigjobj = swig_get_self(jenv); 2855 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2856 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[26], swigjobj); 2857 jthrowable swigerror = jenv->ExceptionOccurred(); 2858 if (swigerror) { 2859 jenv->ExceptionClear(); 2860 throw Swig::DirectorException(jenv, swigerror); 2861 } 2862 2863 } else { 2864 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::flushLines "); 2865 } 2866 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2867 } 2868 2869 void SwigDirector_btIDebugDraw::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 2870 static struct { 2871 const char *mname; 2872 const char *mdesc; 2873 jmethodID base_methid; 2874 } methods[] = { 2875 { 2876 "getDefaultColors", "()Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw$DefaultColors;", NULL 2877 }, 2878 { 2879 "setDefaultColors", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw$DefaultColors;)V", NULL 2880 }, 2881 { 2882 "drawLine", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V", NULL 2883 }, 2884 { 2885 "drawLine", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V", NULL 2886 }, 2887 { 2888 "drawSphere", "(FLcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL 2889 }, 2890 { 2891 "drawSphere", "(Lcom/badlogic/gdx/math/Vector3;FLcom/badlogic/gdx/math/Vector3;)V", NULL 2892 }, 2893 { 2894 "drawTriangle", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;F)V", NULL 2895 }, 2896 { 2897 "drawTriangle", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;F)V", NULL 2898 }, 2899 { 2900 "drawContactPoint", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FILcom/badlogic/gdx/math/Vector3;)V", NULL 2901 }, 2902 { 2903 "reportErrorWarning", "(Ljava/lang/String;)V", NULL 2904 }, 2905 { 2906 "draw3dText", "(Lcom/badlogic/gdx/math/Vector3;Ljava/lang/String;)V", NULL 2907 }, 2908 { 2909 "setDebugMode", "(I)V", NULL 2910 }, 2911 { 2912 "getDebugMode", "()I", NULL 2913 }, 2914 { 2915 "drawAabb", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V", NULL 2916 }, 2917 { 2918 "drawTransform", "(Lcom/badlogic/gdx/math/Matrix4;F)V", NULL 2919 }, 2920 { 2921 "drawArc", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFLcom/badlogic/gdx/math/Vector3;ZF)V", NULL 2922 }, 2923 { 2924 "drawArc", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFLcom/badlogic/gdx/math/Vector3;Z)V", NULL 2925 }, 2926 { 2927 "drawSpherePatch", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;FZ)V", NULL 2928 }, 2929 { 2930 "drawSpherePatch", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;F)V", NULL 2931 }, 2932 { 2933 "drawSpherePatch", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;)V", NULL 2934 }, 2935 { 2936 "drawBox", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V", NULL 2937 }, 2938 { 2939 "drawBox", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL 2940 }, 2941 { 2942 "drawCapsule", "(FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL 2943 }, 2944 { 2945 "drawCylinder", "(FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL 2946 }, 2947 { 2948 "drawCone", "(FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL 2949 }, 2950 { 2951 "drawPlane", "(Lcom/badlogic/gdx/math/Vector3;FLcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL 2952 }, 2953 { 2954 "flushLines", "()V", NULL 2955 } 2956 }; 2957 2958 static jclass baseclass = 0 ; 2959 2960 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 2961 if (!baseclass) { 2962 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw"); 2963 if (!baseclass) return; 2964 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 2965 } 2966 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 2967 for (int i = 0; i < 27; ++i) { 2968 if (!methods[i].base_methid) { 2969 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 2970 if (!methods[i].base_methid) return; 2971 } 2972 swig_override[i] = false; 2973 if (derived) { 2974 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 2975 swig_override[i] = (methid != methods[i].base_methid); 2976 jenv->ExceptionClear(); 2977 } 2978 } 2979 } 2980 } 2981 2982 2983 SwigDirector_btMotionState::SwigDirector_btMotionState(JNIEnv *jenv) : btMotionState(), Swig::Director(jenv) { 2984 } 2985 2986 SwigDirector_btMotionState::~SwigDirector_btMotionState() { 2987 swig_disconnect_director_self("swigDirectorDisconnect"); 2988 } 2989 2990 2991 void SwigDirector_btMotionState::getWorldTransform(btTransform &worldTrans) const { 2992 JNIEnvWrapper swigjnienv(this) ; 2993 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2994 jobject swigjobj = (jobject) NULL ; 2995 jobject jworldTrans = 0 ; 2996 2997 if (!swig_override[0]) { 2998 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btMotionState::getWorldTransform."); 2999 return; 3000 } 3001 swigjobj = swig_get_self(jenv); 3002 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3003 jworldTrans = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); 3004 gdx_setMatrix4FrombtTransform(jenv, jworldTrans, worldTrans); 3005 gdxAutoCommitbtTransformAndReleaseMatrix4 auto_commit_worldTrans(jenv, jworldTrans, &worldTrans, "poolMatrix4"); 3006 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[27], swigjobj, jworldTrans); 3007 jthrowable swigerror = jenv->ExceptionOccurred(); 3008 if (swigerror) { 3009 jenv->ExceptionClear(); 3010 throw Swig::DirectorException(jenv, swigerror); 3011 } 3012 3013 } else { 3014 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btMotionState::getWorldTransform "); 3015 } 3016 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3017 } 3018 3019 void SwigDirector_btMotionState::setWorldTransform(btTransform const &worldTrans) { 3020 JNIEnvWrapper swigjnienv(this) ; 3021 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3022 jobject swigjobj = (jobject) NULL ; 3023 jobject jworldTrans = 0 ; 3024 3025 if (!swig_override[1]) { 3026 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btMotionState::setWorldTransform."); 3027 return; 3028 } 3029 swigjobj = swig_get_self(jenv); 3030 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3031 jworldTrans = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); 3032 gdx_setMatrix4FrombtTransform(jenv, jworldTrans, worldTrans); 3033 gdxPoolAutoReleaseMatrix4 autoRelease_jworldTrans(jenv, "poolMatrix4", jworldTrans); 3034 jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[28], swigjobj, jworldTrans); 3035 jthrowable swigerror = jenv->ExceptionOccurred(); 3036 if (swigerror) { 3037 jenv->ExceptionClear(); 3038 throw Swig::DirectorException(jenv, swigerror); 3039 } 3040 3041 } else { 3042 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btMotionState::setWorldTransform "); 3043 } 3044 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3045 } 3046 3047 void SwigDirector_btMotionState::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3048 static struct { 3049 const char *mname; 3050 const char *mdesc; 3051 jmethodID base_methid; 3052 } methods[] = { 3053 { 3054 "getWorldTransform", "(Lcom/badlogic/gdx/math/Matrix4;)V", NULL 3055 }, 3056 { 3057 "setWorldTransform", "(Lcom/badlogic/gdx/math/Matrix4;)V", NULL 3058 } 3059 }; 3060 3061 static jclass baseclass = 0 ; 3062 3063 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 3064 if (!baseclass) { 3065 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/btMotionState"); 3066 if (!baseclass) return; 3067 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 3068 } 3069 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 3070 for (int i = 0; i < 2; ++i) { 3071 if (!methods[i].base_methid) { 3072 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 3073 if (!methods[i].base_methid) return; 3074 } 3075 swig_override[i] = false; 3076 if (derived) { 3077 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 3078 swig_override[i] = (methid != methods[i].base_methid); 3079 jenv->ExceptionClear(); 3080 } 3081 } 3082 } 3083 } 3084 3085 3086 3087 #ifdef __cplusplus 3088 extern "C" { 3089 #endif 3090 3091 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGetVersion(JNIEnv *jenv, jclass jcls) { 3092 jint jresult = 0 ; 3093 int result; 3094 3095 (void)jenv; 3096 (void)jcls; 3097 result = (int)btGetVersion(); 3098 jresult = (jint)result; 3099 return jresult; 3100 } 3101 3102 3103 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSqrt(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3104 jfloat jresult = 0 ; 3105 btScalar arg1 ; 3106 btScalar result; 3107 3108 (void)jenv; 3109 (void)jcls; 3110 arg1 = (btScalar)jarg1; 3111 result = (btScalar)btSqrt(arg1); 3112 jresult = (jfloat)result; 3113 return jresult; 3114 } 3115 3116 3117 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btFabs(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3118 jfloat jresult = 0 ; 3119 btScalar arg1 ; 3120 btScalar result; 3121 3122 (void)jenv; 3123 (void)jcls; 3124 arg1 = (btScalar)jarg1; 3125 result = (btScalar)btFabs(arg1); 3126 jresult = (jfloat)result; 3127 return jresult; 3128 } 3129 3130 3131 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btCos(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3132 jfloat jresult = 0 ; 3133 btScalar arg1 ; 3134 btScalar result; 3135 3136 (void)jenv; 3137 (void)jcls; 3138 arg1 = (btScalar)jarg1; 3139 result = (btScalar)btCos(arg1); 3140 jresult = (jfloat)result; 3141 return jresult; 3142 } 3143 3144 3145 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSin(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3146 jfloat jresult = 0 ; 3147 btScalar arg1 ; 3148 btScalar result; 3149 3150 (void)jenv; 3151 (void)jcls; 3152 arg1 = (btScalar)jarg1; 3153 result = (btScalar)btSin(arg1); 3154 jresult = (jfloat)result; 3155 return jresult; 3156 } 3157 3158 3159 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTan(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3160 jfloat jresult = 0 ; 3161 btScalar arg1 ; 3162 btScalar result; 3163 3164 (void)jenv; 3165 (void)jcls; 3166 arg1 = (btScalar)jarg1; 3167 result = (btScalar)btTan(arg1); 3168 jresult = (jfloat)result; 3169 return jresult; 3170 } 3171 3172 3173 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAcos(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3174 jfloat jresult = 0 ; 3175 btScalar arg1 ; 3176 btScalar result; 3177 3178 (void)jenv; 3179 (void)jcls; 3180 arg1 = (btScalar)jarg1; 3181 result = (btScalar)btAcos(arg1); 3182 jresult = (jfloat)result; 3183 return jresult; 3184 } 3185 3186 3187 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAsin(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3188 jfloat jresult = 0 ; 3189 btScalar arg1 ; 3190 btScalar result; 3191 3192 (void)jenv; 3193 (void)jcls; 3194 arg1 = (btScalar)jarg1; 3195 result = (btScalar)btAsin(arg1); 3196 jresult = (jfloat)result; 3197 return jresult; 3198 } 3199 3200 3201 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAtan(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3202 jfloat jresult = 0 ; 3203 btScalar arg1 ; 3204 btScalar result; 3205 3206 (void)jenv; 3207 (void)jcls; 3208 arg1 = (btScalar)jarg1; 3209 result = (btScalar)btAtan(arg1); 3210 jresult = (jfloat)result; 3211 return jresult; 3212 } 3213 3214 3215 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAtan2(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { 3216 jfloat jresult = 0 ; 3217 btScalar arg1 ; 3218 btScalar arg2 ; 3219 btScalar result; 3220 3221 (void)jenv; 3222 (void)jcls; 3223 arg1 = (btScalar)jarg1; 3224 arg2 = (btScalar)jarg2; 3225 result = (btScalar)btAtan2(arg1,arg2); 3226 jresult = (jfloat)result; 3227 return jresult; 3228 } 3229 3230 3231 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btExp(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3232 jfloat jresult = 0 ; 3233 btScalar arg1 ; 3234 btScalar result; 3235 3236 (void)jenv; 3237 (void)jcls; 3238 arg1 = (btScalar)jarg1; 3239 result = (btScalar)btExp(arg1); 3240 jresult = (jfloat)result; 3241 return jresult; 3242 } 3243 3244 3245 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btLog(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3246 jfloat jresult = 0 ; 3247 btScalar arg1 ; 3248 btScalar result; 3249 3250 (void)jenv; 3251 (void)jcls; 3252 arg1 = (btScalar)jarg1; 3253 result = (btScalar)btLog(arg1); 3254 jresult = (jfloat)result; 3255 return jresult; 3256 } 3257 3258 3259 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPow(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { 3260 jfloat jresult = 0 ; 3261 btScalar arg1 ; 3262 btScalar arg2 ; 3263 btScalar result; 3264 3265 (void)jenv; 3266 (void)jcls; 3267 arg1 = (btScalar)jarg1; 3268 arg2 = (btScalar)jarg2; 3269 result = (btScalar)btPow(arg1,arg2); 3270 jresult = (jfloat)result; 3271 return jresult; 3272 } 3273 3274 3275 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btFmod(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { 3276 jfloat jresult = 0 ; 3277 btScalar arg1 ; 3278 btScalar arg2 ; 3279 btScalar result; 3280 3281 (void)jenv; 3282 (void)jcls; 3283 arg1 = (btScalar)jarg1; 3284 arg2 = (btScalar)jarg2; 3285 result = (btScalar)btFmod(arg1,arg2); 3286 jresult = (jfloat)result; 3287 return jresult; 3288 } 3289 3290 3291 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAtan2Fast(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { 3292 jfloat jresult = 0 ; 3293 btScalar arg1 ; 3294 btScalar arg2 ; 3295 btScalar result; 3296 3297 (void)jenv; 3298 (void)jcls; 3299 arg1 = (btScalar)jarg1; 3300 arg2 = (btScalar)jarg2; 3301 result = (btScalar)btAtan2Fast(arg1,arg2); 3302 jresult = (jfloat)result; 3303 return jresult; 3304 } 3305 3306 3307 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btFuzzyZero(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3308 jboolean jresult = 0 ; 3309 btScalar arg1 ; 3310 bool result; 3311 3312 (void)jenv; 3313 (void)jcls; 3314 arg1 = (btScalar)jarg1; 3315 result = (bool)btFuzzyZero(arg1); 3316 jresult = (jboolean)result; 3317 return jresult; 3318 } 3319 3320 3321 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btEqual(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { 3322 jboolean jresult = 0 ; 3323 btScalar arg1 ; 3324 btScalar arg2 ; 3325 bool result; 3326 3327 (void)jenv; 3328 (void)jcls; 3329 arg1 = (btScalar)jarg1; 3330 arg2 = (btScalar)jarg2; 3331 result = (bool)btEqual(arg1,arg2); 3332 jresult = (jboolean)result; 3333 return jresult; 3334 } 3335 3336 3337 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGreaterEqual(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { 3338 jboolean jresult = 0 ; 3339 btScalar arg1 ; 3340 btScalar arg2 ; 3341 bool result; 3342 3343 (void)jenv; 3344 (void)jcls; 3345 arg1 = (btScalar)jarg1; 3346 arg2 = (btScalar)jarg2; 3347 result = (bool)btGreaterEqual(arg1,arg2); 3348 jresult = (jboolean)result; 3349 return jresult; 3350 } 3351 3352 3353 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIsNegative(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3354 jint jresult = 0 ; 3355 btScalar arg1 ; 3356 int result; 3357 3358 (void)jenv; 3359 (void)jcls; 3360 arg1 = (btScalar)jarg1; 3361 result = (int)btIsNegative(arg1); 3362 jresult = (jint)result; 3363 return jresult; 3364 } 3365 3366 3367 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btRadians(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3368 jfloat jresult = 0 ; 3369 btScalar arg1 ; 3370 btScalar result; 3371 3372 (void)jenv; 3373 (void)jcls; 3374 arg1 = (btScalar)jarg1; 3375 result = (btScalar)btRadians(arg1); 3376 jresult = (jfloat)result; 3377 return jresult; 3378 } 3379 3380 3381 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDegrees(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3382 jfloat jresult = 0 ; 3383 btScalar arg1 ; 3384 btScalar result; 3385 3386 (void)jenv; 3387 (void)jcls; 3388 arg1 = (btScalar)jarg1; 3389 result = (btScalar)btDegrees(arg1); 3390 jresult = (jfloat)result; 3391 return jresult; 3392 } 3393 3394 3395 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btFsel(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2, jfloat jarg3) { 3396 jfloat jresult = 0 ; 3397 btScalar arg1 ; 3398 btScalar arg2 ; 3399 btScalar arg3 ; 3400 btScalar result; 3401 3402 (void)jenv; 3403 (void)jcls; 3404 arg1 = (btScalar)jarg1; 3405 arg2 = (btScalar)jarg2; 3406 arg3 = (btScalar)jarg3; 3407 result = (btScalar)btFsel(arg1,arg2,arg3); 3408 jresult = (jfloat)result; 3409 return jresult; 3410 } 3411 3412 3413 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btMachineIsLittleEndian(JNIEnv *jenv, jclass jcls) { 3414 jboolean jresult = 0 ; 3415 bool result; 3416 3417 (void)jenv; 3418 (void)jcls; 3419 result = (bool)btMachineIsLittleEndian(); 3420 jresult = (jboolean)result; 3421 return jresult; 3422 } 3423 3424 3425 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSelect_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { 3426 jlong jresult = 0 ; 3427 unsigned int arg1 ; 3428 unsigned int arg2 ; 3429 unsigned int arg3 ; 3430 unsigned int result; 3431 3432 (void)jenv; 3433 (void)jcls; 3434 arg1 = (unsigned int)jarg1; 3435 arg2 = (unsigned int)jarg2; 3436 arg3 = (unsigned int)jarg3; 3437 result = (unsigned int)btSelect(arg1,arg2,arg3); 3438 jresult = (jlong)result; 3439 return jresult; 3440 } 3441 3442 3443 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSelect_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jint jarg3) { 3444 jint jresult = 0 ; 3445 unsigned int arg1 ; 3446 int arg2 ; 3447 int arg3 ; 3448 int result; 3449 3450 (void)jenv; 3451 (void)jcls; 3452 arg1 = (unsigned int)jarg1; 3453 arg2 = (int)jarg2; 3454 arg3 = (int)jarg3; 3455 result = (int)btSelect(arg1,arg2,arg3); 3456 jresult = (jint)result; 3457 return jresult; 3458 } 3459 3460 3461 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSelect_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jfloat jarg2, jfloat jarg3) { 3462 jfloat jresult = 0 ; 3463 unsigned int arg1 ; 3464 float arg2 ; 3465 float arg3 ; 3466 float result; 3467 3468 (void)jenv; 3469 (void)jcls; 3470 arg1 = (unsigned int)jarg1; 3471 arg2 = (float)jarg2; 3472 arg3 = (float)jarg3; 3473 result = (float)btSelect(arg1,arg2,arg3); 3474 jresult = (jfloat)result; 3475 return jresult; 3476 } 3477 3478 3479 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapEndian_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1) { 3480 jlong jresult = 0 ; 3481 unsigned int arg1 ; 3482 unsigned int result; 3483 3484 (void)jenv; 3485 (void)jcls; 3486 arg1 = (unsigned int)jarg1; 3487 result = (unsigned int)btSwapEndian(arg1); 3488 jresult = (jlong)result; 3489 return jresult; 3490 } 3491 3492 3493 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapEndian_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1) { 3494 jint jresult = 0 ; 3495 unsigned short arg1 ; 3496 unsigned short result; 3497 3498 (void)jenv; 3499 (void)jcls; 3500 arg1 = (unsigned short)jarg1; 3501 result = (unsigned short)btSwapEndian(arg1); 3502 jresult = (jint)result; 3503 return jresult; 3504 } 3505 3506 3507 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapEndian_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jshort jarg1) { 3508 jint jresult = 0 ; 3509 short arg1 ; 3510 unsigned short result; 3511 3512 (void)jenv; 3513 (void)jcls; 3514 arg1 = (short)jarg1; 3515 result = (unsigned short)btSwapEndian(arg1); 3516 jresult = (jint)result; 3517 return jresult; 3518 } 3519 3520 3521 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapEndianFloat(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3522 jlong jresult = 0 ; 3523 float arg1 ; 3524 unsigned int result; 3525 3526 (void)jenv; 3527 (void)jcls; 3528 arg1 = (float)jarg1; 3529 result = (unsigned int)btSwapEndianFloat(arg1); 3530 jresult = (jlong)result; 3531 return jresult; 3532 } 3533 3534 3535 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btUnswapEndianFloat(JNIEnv *jenv, jclass jcls, jlong jarg1) { 3536 jfloat jresult = 0 ; 3537 unsigned int arg1 ; 3538 float result; 3539 3540 (void)jenv; 3541 (void)jcls; 3542 arg1 = (unsigned int)jarg1; 3543 result = (float)btUnswapEndianFloat(arg1); 3544 jresult = (jfloat)result; 3545 return jresult; 3546 } 3547 3548 3549 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapEndianDouble(JNIEnv *jenv, jclass jcls, jdouble jarg1, jobject jarg2) { 3550 double arg1 ; 3551 unsigned char *arg2 = (unsigned char *) 0 ; 3552 3553 (void)jenv; 3554 (void)jcls; 3555 arg1 = (double)jarg1; 3556 { 3557 arg2 = (unsigned char*)jenv->GetDirectBufferAddress(jarg2); 3558 if (arg2 == NULL) { 3559 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 3560 } 3561 } 3562 btSwapEndianDouble(arg1,arg2); 3563 3564 } 3565 3566 3567 SWIGEXPORT jdouble JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btUnswapEndianDouble(JNIEnv *jenv, jclass jcls, jobject jarg1) { 3568 jdouble jresult = 0 ; 3569 unsigned char *arg1 = (unsigned char *) 0 ; 3570 double result; 3571 3572 (void)jenv; 3573 (void)jcls; 3574 { 3575 arg1 = (unsigned char*)jenv->GetDirectBufferAddress(jarg1); 3576 if (arg1 == NULL) { 3577 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 3578 } 3579 } 3580 result = (double)btUnswapEndianDouble((unsigned char const *)arg1); 3581 jresult = (jdouble)result; 3582 3583 return jresult; 3584 } 3585 3586 3587 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btLargeDot(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3) { 3588 jfloat jresult = 0 ; 3589 btScalar *arg1 = (btScalar *) 0 ; 3590 btScalar *arg2 = (btScalar *) 0 ; 3591 int arg3 ; 3592 btScalar result; 3593 3594 (void)jenv; 3595 (void)jcls; 3596 { 3597 arg1 = (btScalar*)jenv->GetDirectBufferAddress(jarg1); 3598 if (arg1 == NULL) { 3599 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 3600 } 3601 } 3602 { 3603 arg2 = (btScalar*)jenv->GetDirectBufferAddress(jarg2); 3604 if (arg2 == NULL) { 3605 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 3606 } 3607 } 3608 arg3 = (int)jarg3; 3609 result = (btScalar)btLargeDot((float const *)arg1,(float const *)arg2,arg3); 3610 jresult = (jfloat)result; 3611 3612 3613 return jresult; 3614 } 3615 3616 3617 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btNormalizeAngle(JNIEnv *jenv, jclass jcls, jfloat jarg1) { 3618 jfloat jresult = 0 ; 3619 btScalar arg1 ; 3620 btScalar result; 3621 3622 (void)jenv; 3623 (void)jcls; 3624 arg1 = (btScalar)jarg1; 3625 result = (btScalar)btNormalizeAngle(arg1); 3626 jresult = (jfloat)result; 3627 return jresult; 3628 } 3629 3630 3631 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTypedObject(JNIEnv *jenv, jclass jcls, jint jarg1) { 3632 jlong jresult = 0 ; 3633 int arg1 ; 3634 btTypedObject *result = 0 ; 3635 3636 (void)jenv; 3637 (void)jcls; 3638 arg1 = (int)jarg1; 3639 result = (btTypedObject *)new btTypedObject(arg1); 3640 *(btTypedObject **)&jresult = result; 3641 return jresult; 3642 } 3643 3644 3645 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTypedObject_1objectType_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 3646 btTypedObject *arg1 = (btTypedObject *) 0 ; 3647 int arg2 ; 3648 3649 (void)jenv; 3650 (void)jcls; 3651 (void)jarg1_; 3652 arg1 = *(btTypedObject **)&jarg1; 3653 arg2 = (int)jarg2; 3654 if (arg1) (arg1)->m_objectType = arg2; 3655 } 3656 3657 3658 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTypedObject_1objectType_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 3659 jint jresult = 0 ; 3660 btTypedObject *arg1 = (btTypedObject *) 0 ; 3661 int result; 3662 3663 (void)jenv; 3664 (void)jcls; 3665 (void)jarg1_; 3666 arg1 = *(btTypedObject **)&jarg1; 3667 result = (int) ((arg1)->m_objectType); 3668 jresult = (jint)result; 3669 return jresult; 3670 } 3671 3672 3673 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btTypedObject(JNIEnv *jenv, jclass jcls, jlong jarg1) { 3674 btTypedObject *arg1 = (btTypedObject *) 0 ; 3675 3676 (void)jenv; 3677 (void)jcls; 3678 arg1 = *(btTypedObject **)&jarg1; 3679 delete arg1; 3680 } 3681 3682 3683 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 3684 jlong jresult = 0 ; 3685 btTransform *result = 0 ; 3686 3687 (void)jenv; 3688 (void)jcls; 3689 result = (btTransform *)new btTransform(); 3690 *(btTransform **)&jresult = result; 3691 return jresult; 3692 } 3693 3694 3695 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 3696 jlong jresult = 0 ; 3697 btQuaternion *arg1 = 0 ; 3698 btVector3 *arg2 = 0 ; 3699 btTransform *result = 0 ; 3700 3701 (void)jenv; 3702 (void)jcls; 3703 btQuaternion local_arg1; 3704 gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); 3705 arg1 = &local_arg1; 3706 gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); 3707 btVector3 local_arg2; 3708 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 3709 arg2 = &local_arg2; 3710 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 3711 result = (btTransform *)new btTransform((btQuaternion const &)*arg1,(btVector3 const &)*arg2); 3712 *(btTransform **)&jresult = result; 3713 return jresult; 3714 } 3715 3716 3717 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jobject jarg1) { 3718 jlong jresult = 0 ; 3719 btQuaternion *arg1 = 0 ; 3720 btTransform *result = 0 ; 3721 3722 (void)jenv; 3723 (void)jcls; 3724 btQuaternion local_arg1; 3725 gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); 3726 arg1 = &local_arg1; 3727 gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); 3728 result = (btTransform *)new btTransform((btQuaternion const &)*arg1); 3729 *(btTransform **)&jresult = result; 3730 return jresult; 3731 } 3732 3733 3734 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 3735 jlong jresult = 0 ; 3736 btMatrix3x3 *arg1 = 0 ; 3737 btVector3 *arg2 = 0 ; 3738 btTransform *result = 0 ; 3739 3740 (void)jenv; 3741 (void)jcls; 3742 btMatrix3x3 local_arg1; 3743 gdx_setbtMatrix3x3FromMatrix3(jenv, local_arg1, jarg1); 3744 arg1 = &local_arg1; 3745 gdxAutoCommitMatrix3 auto_commit_arg1(jenv, jarg1, &local_arg1); 3746 btVector3 local_arg2; 3747 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 3748 arg2 = &local_arg2; 3749 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 3750 result = (btTransform *)new btTransform((btMatrix3x3 const &)*arg1,(btVector3 const &)*arg2); 3751 *(btTransform **)&jresult = result; 3752 return jresult; 3753 } 3754 3755 3756 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jobject jarg1) { 3757 jlong jresult = 0 ; 3758 btMatrix3x3 *arg1 = 0 ; 3759 btTransform *result = 0 ; 3760 3761 (void)jenv; 3762 (void)jcls; 3763 btMatrix3x3 local_arg1; 3764 gdx_setbtMatrix3x3FromMatrix3(jenv, local_arg1, jarg1); 3765 arg1 = &local_arg1; 3766 gdxAutoCommitMatrix3 auto_commit_arg1(jenv, jarg1, &local_arg1); 3767 result = (btTransform *)new btTransform((btMatrix3x3 const &)*arg1); 3768 *(btTransform **)&jresult = result; 3769 return jresult; 3770 } 3771 3772 3773 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jobject jarg1) { 3774 jlong jresult = 0 ; 3775 btTransform *arg1 = 0 ; 3776 btTransform *result = 0 ; 3777 3778 (void)jenv; 3779 (void)jcls; 3780 btTransform local_arg1; 3781 gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); 3782 arg1 = &local_arg1; 3783 gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); 3784 result = (btTransform *)new btTransform((btTransform const &)*arg1); 3785 *(btTransform **)&jresult = result; 3786 return jresult; 3787 } 3788 3789 3790 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1mult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { 3791 btTransform *arg1 = (btTransform *) 0 ; 3792 btTransform *arg2 = 0 ; 3793 btTransform *arg3 = 0 ; 3794 3795 (void)jenv; 3796 (void)jcls; 3797 (void)jarg1_; 3798 arg1 = *(btTransform **)&jarg1; 3799 btTransform local_arg2; 3800 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 3801 arg2 = &local_arg2; 3802 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 3803 btTransform local_arg3; 3804 gdx_setbtTransformFromMatrix4(jenv, local_arg3, jarg3); 3805 arg3 = &local_arg3; 3806 gdxAutoCommitMatrix4 auto_commit_arg3(jenv, jarg3, &local_arg3); 3807 (arg1)->mult((btTransform const &)*arg2,(btTransform const &)*arg3); 3808 } 3809 3810 3811 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1getBasis_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 3812 jobject jresult = 0 ; 3813 btTransform *arg1 = (btTransform *) 0 ; 3814 btMatrix3x3 *result = 0 ; 3815 3816 (void)jenv; 3817 (void)jcls; 3818 (void)jarg1_; 3819 arg1 = *(btTransform **)&jarg1; 3820 result = (btMatrix3x3 *) &(arg1)->getBasis(); 3821 jresult = gdx_getReturnMatrix3(jenv); 3822 gdx_setMatrix3FrombtMatrix3x3(jenv, jresult, result); 3823 return jresult; 3824 } 3825 3826 3827 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1getOrigin_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 3828 jobject jresult = 0 ; 3829 btTransform *arg1 = (btTransform *) 0 ; 3830 btVector3 *result = 0 ; 3831 3832 (void)jenv; 3833 (void)jcls; 3834 (void)jarg1_; 3835 arg1 = *(btTransform **)&jarg1; 3836 result = (btVector3 *) &(arg1)->getOrigin(); 3837 jresult = gdx_getReturnVector3(jenv); 3838 gdx_setVector3FrombtVector3(jenv, jresult, result); 3839 return jresult; 3840 } 3841 3842 3843 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1getRotation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 3844 jobject jresult = 0 ; 3845 btTransform *arg1 = (btTransform *) 0 ; 3846 btQuaternion result; 3847 3848 (void)jenv; 3849 (void)jcls; 3850 (void)jarg1_; 3851 arg1 = *(btTransform **)&jarg1; 3852 result = ((btTransform const *)arg1)->getRotation(); 3853 jresult = gdx_getReturnQuaternion(jenv); 3854 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 3855 return jresult; 3856 } 3857 3858 3859 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1setFromOpenGLMatrix(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloatArray jarg2) { 3860 btTransform *arg1 = (btTransform *) 0 ; 3861 btScalar *arg2 = (btScalar *) 0 ; 3862 jfloat *jarr2 ; 3863 3864 (void)jenv; 3865 (void)jcls; 3866 (void)jarg1_; 3867 arg1 = *(btTransform **)&jarg1; 3868 if (!SWIG_JavaArrayInFloat(jenv, &jarr2, (float **)&arg2, jarg2)) return ; 3869 (arg1)->setFromOpenGLMatrix((btScalar const *)arg2); 3870 SWIG_JavaArrayArgoutFloat(jenv, jarr2, (float *)arg2, jarg2); 3871 delete [] arg2; 3872 } 3873 3874 3875 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1getOpenGLMatrix(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloatArray jarg2) { 3876 btTransform *arg1 = (btTransform *) 0 ; 3877 btScalar *arg2 = (btScalar *) 0 ; 3878 jfloat *jarr2 ; 3879 3880 (void)jenv; 3881 (void)jcls; 3882 (void)jarg1_; 3883 arg1 = *(btTransform **)&jarg1; 3884 if (!SWIG_JavaArrayInFloat(jenv, &jarr2, (float **)&arg2, jarg2)) return ; 3885 ((btTransform const *)arg1)->getOpenGLMatrix(arg2); 3886 SWIG_JavaArrayArgoutFloat(jenv, jarr2, (float *)arg2, jarg2); 3887 delete [] arg2; 3888 } 3889 3890 3891 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1setOrigin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 3892 btTransform *arg1 = (btTransform *) 0 ; 3893 btVector3 *arg2 = 0 ; 3894 3895 (void)jenv; 3896 (void)jcls; 3897 (void)jarg1_; 3898 arg1 = *(btTransform **)&jarg1; 3899 btVector3 local_arg2; 3900 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 3901 arg2 = &local_arg2; 3902 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 3903 (arg1)->setOrigin((btVector3 const &)*arg2); 3904 } 3905 3906 3907 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1invXform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 3908 jobject jresult = 0 ; 3909 btTransform *arg1 = (btTransform *) 0 ; 3910 btVector3 *arg2 = 0 ; 3911 btVector3 result; 3912 3913 (void)jenv; 3914 (void)jcls; 3915 (void)jarg1_; 3916 arg1 = *(btTransform **)&jarg1; 3917 btVector3 local_arg2; 3918 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 3919 arg2 = &local_arg2; 3920 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 3921 result = ((btTransform const *)arg1)->invXform((btVector3 const &)*arg2); 3922 jresult = gdx_getReturnVector3(jenv); 3923 gdx_setVector3FrombtVector3(jenv, jresult, result); 3924 return jresult; 3925 } 3926 3927 3928 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1setBasis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 3929 btTransform *arg1 = (btTransform *) 0 ; 3930 btMatrix3x3 *arg2 = 0 ; 3931 3932 (void)jenv; 3933 (void)jcls; 3934 (void)jarg1_; 3935 arg1 = *(btTransform **)&jarg1; 3936 btMatrix3x3 local_arg2; 3937 gdx_setbtMatrix3x3FromMatrix3(jenv, local_arg2, jarg2); 3938 arg2 = &local_arg2; 3939 gdxAutoCommitMatrix3 auto_commit_arg2(jenv, jarg2, &local_arg2); 3940 (arg1)->setBasis((btMatrix3x3 const &)*arg2); 3941 } 3942 3943 3944 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1setRotation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 3945 btTransform *arg1 = (btTransform *) 0 ; 3946 btQuaternion *arg2 = 0 ; 3947 3948 (void)jenv; 3949 (void)jcls; 3950 (void)jarg1_; 3951 arg1 = *(btTransform **)&jarg1; 3952 btQuaternion local_arg2; 3953 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 3954 arg2 = &local_arg2; 3955 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 3956 (arg1)->setRotation((btQuaternion const &)*arg2); 3957 } 3958 3959 3960 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1setIdentity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 3961 btTransform *arg1 = (btTransform *) 0 ; 3962 3963 (void)jenv; 3964 (void)jcls; 3965 (void)jarg1_; 3966 arg1 = *(btTransform **)&jarg1; 3967 (arg1)->setIdentity(); 3968 } 3969 3970 3971 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1inverse(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 3972 jobject jresult = 0 ; 3973 btTransform *arg1 = (btTransform *) 0 ; 3974 btTransform result; 3975 3976 (void)jenv; 3977 (void)jcls; 3978 (void)jarg1_; 3979 arg1 = *(btTransform **)&jarg1; 3980 result = ((btTransform const *)arg1)->inverse(); 3981 jresult = gdx_getReturnMatrix4(jenv); 3982 gdx_setMatrix4FrombtTransform(jenv, jresult, result); 3983 return jresult; 3984 } 3985 3986 3987 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1inverseTimes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 3988 jobject jresult = 0 ; 3989 btTransform *arg1 = (btTransform *) 0 ; 3990 btTransform *arg2 = 0 ; 3991 btTransform result; 3992 3993 (void)jenv; 3994 (void)jcls; 3995 (void)jarg1_; 3996 arg1 = *(btTransform **)&jarg1; 3997 btTransform local_arg2; 3998 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 3999 arg2 = &local_arg2; 4000 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 4001 result = ((btTransform const *)arg1)->inverseTimes((btTransform const &)*arg2); 4002 jresult = gdx_getReturnMatrix4(jenv); 4003 gdx_setMatrix4FrombtTransform(jenv, jresult, result); 4004 return jresult; 4005 } 4006 4007 4008 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1getIdentity(JNIEnv *jenv, jclass jcls) { 4009 jobject jresult = 0 ; 4010 btTransform *result = 0 ; 4011 4012 (void)jenv; 4013 (void)jcls; 4014 result = (btTransform *) &btTransform::getIdentity(); 4015 jresult = gdx_getReturnMatrix4(jenv); 4016 gdx_setMatrix4FrombtTransform(jenv, jresult, result); 4017 return jresult; 4018 } 4019 4020 4021 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1serialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 4022 btTransform *arg1 = (btTransform *) 0 ; 4023 btTransformFloatData *arg2 = 0 ; 4024 4025 (void)jenv; 4026 (void)jcls; 4027 (void)jarg1_; 4028 (void)jarg2_; 4029 arg1 = *(btTransform **)&jarg1; 4030 arg2 = *(btTransformFloatData **)&jarg2; 4031 if (!arg2) { 4032 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btTransformFloatData & reference is null"); 4033 return ; 4034 } 4035 ((btTransform const *)arg1)->serialize(*arg2); 4036 } 4037 4038 4039 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1serializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 4040 btTransform *arg1 = (btTransform *) 0 ; 4041 btTransformFloatData *arg2 = 0 ; 4042 4043 (void)jenv; 4044 (void)jcls; 4045 (void)jarg1_; 4046 (void)jarg2_; 4047 arg1 = *(btTransform **)&jarg1; 4048 arg2 = *(btTransformFloatData **)&jarg2; 4049 if (!arg2) { 4050 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btTransformFloatData & reference is null"); 4051 return ; 4052 } 4053 ((btTransform const *)arg1)->serializeFloat(*arg2); 4054 } 4055 4056 4057 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1deSerialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 4058 btTransform *arg1 = (btTransform *) 0 ; 4059 btTransformFloatData *arg2 = 0 ; 4060 4061 (void)jenv; 4062 (void)jcls; 4063 (void)jarg1_; 4064 (void)jarg2_; 4065 arg1 = *(btTransform **)&jarg1; 4066 arg2 = *(btTransformFloatData **)&jarg2; 4067 if (!arg2) { 4068 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btTransformFloatData const & reference is null"); 4069 return ; 4070 } 4071 (arg1)->deSerialize((btTransformFloatData const &)*arg2); 4072 } 4073 4074 4075 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1deSerializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 4076 btTransform *arg1 = (btTransform *) 0 ; 4077 btTransformDoubleData *arg2 = 0 ; 4078 4079 (void)jenv; 4080 (void)jcls; 4081 (void)jarg1_; 4082 (void)jarg2_; 4083 arg1 = *(btTransform **)&jarg1; 4084 arg2 = *(btTransformDoubleData **)&jarg2; 4085 if (!arg2) { 4086 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btTransformDoubleData const & reference is null"); 4087 return ; 4088 } 4089 (arg1)->deSerializeDouble((btTransformDoubleData const &)*arg2); 4090 } 4091 4092 4093 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1deSerializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 4094 btTransform *arg1 = (btTransform *) 0 ; 4095 btTransformFloatData *arg2 = 0 ; 4096 4097 (void)jenv; 4098 (void)jcls; 4099 (void)jarg1_; 4100 (void)jarg2_; 4101 arg1 = *(btTransform **)&jarg1; 4102 arg2 = *(btTransformFloatData **)&jarg2; 4103 if (!arg2) { 4104 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btTransformFloatData const & reference is null"); 4105 return ; 4106 } 4107 (arg1)->deSerializeFloat((btTransformFloatData const &)*arg2); 4108 } 4109 4110 4111 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btTransform(JNIEnv *jenv, jclass jcls, jlong jarg1) { 4112 btTransform *arg1 = (btTransform *) 0 ; 4113 4114 (void)jenv; 4115 (void)jcls; 4116 arg1 = *(btTransform **)&jarg1; 4117 delete arg1; 4118 } 4119 4120 4121 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformFloatData_1basis_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 4122 btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; 4123 btMatrix3x3FloatData arg2 ; 4124 btMatrix3x3FloatData *argp2 ; 4125 4126 (void)jenv; 4127 (void)jcls; 4128 (void)jarg1_; 4129 arg1 = *(btTransformFloatData **)&jarg1; 4130 argp2 = *(btMatrix3x3FloatData **)&jarg2; 4131 if (!argp2) { 4132 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null btMatrix3x3FloatData"); 4133 return ; 4134 } 4135 arg2 = *argp2; 4136 if (arg1) (arg1)->m_basis = arg2; 4137 } 4138 4139 4140 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformFloatData_1basis_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4141 jlong jresult = 0 ; 4142 btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; 4143 btMatrix3x3FloatData result; 4144 4145 (void)jenv; 4146 (void)jcls; 4147 (void)jarg1_; 4148 arg1 = *(btTransformFloatData **)&jarg1; 4149 result = ((arg1)->m_basis); 4150 *(btMatrix3x3FloatData **)&jresult = new btMatrix3x3FloatData((const btMatrix3x3FloatData &)result); 4151 return jresult; 4152 } 4153 4154 4155 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformFloatData_1origin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 4156 btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; 4157 btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; 4158 4159 (void)jenv; 4160 (void)jcls; 4161 (void)jarg1_; 4162 (void)jarg2_; 4163 arg1 = *(btTransformFloatData **)&jarg1; 4164 arg2 = *(btVector3FloatData **)&jarg2; 4165 if (arg1) (arg1)->m_origin = *arg2; 4166 } 4167 4168 4169 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformFloatData_1origin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4170 jlong jresult = 0 ; 4171 btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; 4172 btVector3FloatData *result = 0 ; 4173 4174 (void)jenv; 4175 (void)jcls; 4176 (void)jarg1_; 4177 arg1 = *(btTransformFloatData **)&jarg1; 4178 result = (btVector3FloatData *)& ((arg1)->m_origin); 4179 *(btVector3FloatData **)&jresult = result; 4180 return jresult; 4181 } 4182 4183 4184 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransformFloatData(JNIEnv *jenv, jclass jcls) { 4185 jlong jresult = 0 ; 4186 btTransformFloatData *result = 0 ; 4187 4188 (void)jenv; 4189 (void)jcls; 4190 result = (btTransformFloatData *)new btTransformFloatData(); 4191 *(btTransformFloatData **)&jresult = result; 4192 return jresult; 4193 } 4194 4195 4196 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btTransformFloatData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 4197 btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; 4198 4199 (void)jenv; 4200 (void)jcls; 4201 arg1 = *(btTransformFloatData **)&jarg1; 4202 delete arg1; 4203 } 4204 4205 4206 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformDoubleData_1basis_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 4207 btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; 4208 btMatrix3x3DoubleData arg2 ; 4209 btMatrix3x3DoubleData *argp2 ; 4210 4211 (void)jenv; 4212 (void)jcls; 4213 (void)jarg1_; 4214 arg1 = *(btTransformDoubleData **)&jarg1; 4215 argp2 = *(btMatrix3x3DoubleData **)&jarg2; 4216 if (!argp2) { 4217 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null btMatrix3x3DoubleData"); 4218 return ; 4219 } 4220 arg2 = *argp2; 4221 if (arg1) (arg1)->m_basis = arg2; 4222 } 4223 4224 4225 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformDoubleData_1basis_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4226 jlong jresult = 0 ; 4227 btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; 4228 btMatrix3x3DoubleData result; 4229 4230 (void)jenv; 4231 (void)jcls; 4232 (void)jarg1_; 4233 arg1 = *(btTransformDoubleData **)&jarg1; 4234 result = ((arg1)->m_basis); 4235 *(btMatrix3x3DoubleData **)&jresult = new btMatrix3x3DoubleData((const btMatrix3x3DoubleData &)result); 4236 return jresult; 4237 } 4238 4239 4240 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformDoubleData_1origin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 4241 btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; 4242 btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; 4243 4244 (void)jenv; 4245 (void)jcls; 4246 (void)jarg1_; 4247 (void)jarg2_; 4248 arg1 = *(btTransformDoubleData **)&jarg1; 4249 arg2 = *(btVector3DoubleData **)&jarg2; 4250 if (arg1) (arg1)->m_origin = *arg2; 4251 } 4252 4253 4254 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformDoubleData_1origin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4255 jlong jresult = 0 ; 4256 btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; 4257 btVector3DoubleData *result = 0 ; 4258 4259 (void)jenv; 4260 (void)jcls; 4261 (void)jarg1_; 4262 arg1 = *(btTransformDoubleData **)&jarg1; 4263 result = (btVector3DoubleData *)& ((arg1)->m_origin); 4264 *(btVector3DoubleData **)&jresult = result; 4265 return jresult; 4266 } 4267 4268 4269 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransformDoubleData(JNIEnv *jenv, jclass jcls) { 4270 jlong jresult = 0 ; 4271 btTransformDoubleData *result = 0 ; 4272 4273 (void)jenv; 4274 (void)jcls; 4275 result = (btTransformDoubleData *)new btTransformDoubleData(); 4276 *(btTransformDoubleData **)&jresult = result; 4277 return jresult; 4278 } 4279 4280 4281 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btTransformDoubleData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 4282 btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; 4283 4284 (void)jenv; 4285 (void)jcls; 4286 arg1 = *(btTransformDoubleData **)&jarg1; 4287 delete arg1; 4288 } 4289 4290 4291 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1floats_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloatArray jarg2) { 4292 btVector3 *arg1 = (btVector3 *) 0 ; 4293 btScalar *arg2 ; 4294 jfloat *jarr2 ; 4295 4296 (void)jenv; 4297 (void)jcls; 4298 (void)jarg1_; 4299 arg1 = *(btVector3 **)&jarg1; 4300 if (jarg2 && jenv->GetArrayLength(jarg2) != 4) { 4301 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 4302 return ; 4303 } 4304 if (!SWIG_JavaArrayInFloat(jenv, &jarr2, (float **)&arg2, jarg2)) return ; 4305 { 4306 size_t ii; 4307 btScalar *b = (btScalar *) arg1->m_floats; 4308 for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btScalar *) arg2 + ii); 4309 } 4310 SWIG_JavaArrayArgoutFloat(jenv, jarr2, (float *)arg2, jarg2); 4311 delete [] arg2; 4312 } 4313 4314 4315 SWIGEXPORT jfloatArray JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1floats_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4316 jfloatArray jresult = 0 ; 4317 btVector3 *arg1 = (btVector3 *) 0 ; 4318 btScalar *result = 0 ; 4319 4320 (void)jenv; 4321 (void)jcls; 4322 (void)jarg1_; 4323 arg1 = *(btVector3 **)&jarg1; 4324 result = (btScalar *)(btScalar *) ((arg1)->m_floats); 4325 jresult = SWIG_JavaArrayOutFloat(jenv, (float *)result, 4); 4326 return jresult; 4327 } 4328 4329 4330 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 4331 jlong jresult = 0 ; 4332 btVector3 *result = 0 ; 4333 4334 (void)jenv; 4335 (void)jcls; 4336 result = (btVector3 *)new btVector3(); 4337 *(btVector3 **)&jresult = result; 4338 return jresult; 4339 } 4340 4341 4342 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2, jfloat jarg3) { 4343 jlong jresult = 0 ; 4344 btScalar *arg1 = 0 ; 4345 btScalar *arg2 = 0 ; 4346 btScalar *arg3 = 0 ; 4347 btScalar temp1 ; 4348 btScalar temp2 ; 4349 btScalar temp3 ; 4350 btVector3 *result = 0 ; 4351 4352 (void)jenv; 4353 (void)jcls; 4354 temp1 = (btScalar)jarg1; 4355 arg1 = &temp1; 4356 temp2 = (btScalar)jarg2; 4357 arg2 = &temp2; 4358 temp3 = (btScalar)jarg3; 4359 arg3 = &temp3; 4360 result = (btVector3 *)new btVector3((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3); 4361 *(btVector3 **)&jresult = result; 4362 return jresult; 4363 } 4364 4365 4366 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1dot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 4367 jfloat jresult = 0 ; 4368 btVector3 *arg1 = (btVector3 *) 0 ; 4369 btVector3 *arg2 = 0 ; 4370 btScalar result; 4371 4372 (void)jenv; 4373 (void)jcls; 4374 (void)jarg1_; 4375 arg1 = *(btVector3 **)&jarg1; 4376 btVector3 local_arg2; 4377 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4378 arg2 = &local_arg2; 4379 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4380 result = (btScalar)((btVector3 const *)arg1)->dot((btVector3 const &)*arg2); 4381 jresult = (jfloat)result; 4382 return jresult; 4383 } 4384 4385 4386 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1length2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4387 jfloat jresult = 0 ; 4388 btVector3 *arg1 = (btVector3 *) 0 ; 4389 btScalar result; 4390 4391 (void)jenv; 4392 (void)jcls; 4393 (void)jarg1_; 4394 arg1 = *(btVector3 **)&jarg1; 4395 result = (btScalar)((btVector3 const *)arg1)->length2(); 4396 jresult = (jfloat)result; 4397 return jresult; 4398 } 4399 4400 4401 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1length(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4402 jfloat jresult = 0 ; 4403 btVector3 *arg1 = (btVector3 *) 0 ; 4404 btScalar result; 4405 4406 (void)jenv; 4407 (void)jcls; 4408 (void)jarg1_; 4409 arg1 = *(btVector3 **)&jarg1; 4410 result = (btScalar)((btVector3 const *)arg1)->length(); 4411 jresult = (jfloat)result; 4412 return jresult; 4413 } 4414 4415 4416 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1norm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4417 jfloat jresult = 0 ; 4418 btVector3 *arg1 = (btVector3 *) 0 ; 4419 btScalar result; 4420 4421 (void)jenv; 4422 (void)jcls; 4423 (void)jarg1_; 4424 arg1 = *(btVector3 **)&jarg1; 4425 result = (btScalar)((btVector3 const *)arg1)->norm(); 4426 jresult = (jfloat)result; 4427 return jresult; 4428 } 4429 4430 4431 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1distance2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 4432 jfloat jresult = 0 ; 4433 btVector3 *arg1 = (btVector3 *) 0 ; 4434 btVector3 *arg2 = 0 ; 4435 btScalar result; 4436 4437 (void)jenv; 4438 (void)jcls; 4439 (void)jarg1_; 4440 arg1 = *(btVector3 **)&jarg1; 4441 btVector3 local_arg2; 4442 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4443 arg2 = &local_arg2; 4444 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4445 result = (btScalar)((btVector3 const *)arg1)->distance2((btVector3 const &)*arg2); 4446 jresult = (jfloat)result; 4447 return jresult; 4448 } 4449 4450 4451 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1distance(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 4452 jfloat jresult = 0 ; 4453 btVector3 *arg1 = (btVector3 *) 0 ; 4454 btVector3 *arg2 = 0 ; 4455 btScalar result; 4456 4457 (void)jenv; 4458 (void)jcls; 4459 (void)jarg1_; 4460 arg1 = *(btVector3 **)&jarg1; 4461 btVector3 local_arg2; 4462 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4463 arg2 = &local_arg2; 4464 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4465 result = (btScalar)((btVector3 const *)arg1)->distance((btVector3 const &)*arg2); 4466 jresult = (jfloat)result; 4467 return jresult; 4468 } 4469 4470 4471 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1safeNormalize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4472 jobject jresult = 0 ; 4473 btVector3 *arg1 = (btVector3 *) 0 ; 4474 btVector3 *result = 0 ; 4475 4476 (void)jenv; 4477 (void)jcls; 4478 (void)jarg1_; 4479 arg1 = *(btVector3 **)&jarg1; 4480 result = (btVector3 *) &(arg1)->safeNormalize(); 4481 jresult = gdx_getReturnVector3(jenv); 4482 gdx_setVector3FrombtVector3(jenv, jresult, result); 4483 return jresult; 4484 } 4485 4486 4487 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1normalize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4488 jobject jresult = 0 ; 4489 btVector3 *arg1 = (btVector3 *) 0 ; 4490 btVector3 *result = 0 ; 4491 4492 (void)jenv; 4493 (void)jcls; 4494 (void)jarg1_; 4495 arg1 = *(btVector3 **)&jarg1; 4496 result = (btVector3 *) &(arg1)->normalize(); 4497 jresult = gdx_getReturnVector3(jenv); 4498 gdx_setVector3FrombtVector3(jenv, jresult, result); 4499 return jresult; 4500 } 4501 4502 4503 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1normalized(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4504 jobject jresult = 0 ; 4505 btVector3 *arg1 = (btVector3 *) 0 ; 4506 btVector3 result; 4507 4508 (void)jenv; 4509 (void)jcls; 4510 (void)jarg1_; 4511 arg1 = *(btVector3 **)&jarg1; 4512 result = ((btVector3 const *)arg1)->normalized(); 4513 jresult = gdx_getReturnVector3(jenv); 4514 gdx_setVector3FrombtVector3(jenv, jresult, result); 4515 return jresult; 4516 } 4517 4518 4519 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1rotate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { 4520 jobject jresult = 0 ; 4521 btVector3 *arg1 = (btVector3 *) 0 ; 4522 btVector3 *arg2 = 0 ; 4523 btScalar arg3 ; 4524 btVector3 result; 4525 4526 (void)jenv; 4527 (void)jcls; 4528 (void)jarg1_; 4529 arg1 = *(btVector3 **)&jarg1; 4530 btVector3 local_arg2; 4531 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4532 arg2 = &local_arg2; 4533 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4534 arg3 = (btScalar)jarg3; 4535 result = ((btVector3 const *)arg1)->rotate((btVector3 const &)*arg2,arg3); 4536 jresult = gdx_getReturnVector3(jenv); 4537 gdx_setVector3FrombtVector3(jenv, jresult, result); 4538 return jresult; 4539 } 4540 4541 4542 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1angle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 4543 jfloat jresult = 0 ; 4544 btVector3 *arg1 = (btVector3 *) 0 ; 4545 btVector3 *arg2 = 0 ; 4546 btScalar result; 4547 4548 (void)jenv; 4549 (void)jcls; 4550 (void)jarg1_; 4551 arg1 = *(btVector3 **)&jarg1; 4552 btVector3 local_arg2; 4553 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4554 arg2 = &local_arg2; 4555 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4556 result = (btScalar)((btVector3 const *)arg1)->angle((btVector3 const &)*arg2); 4557 jresult = (jfloat)result; 4558 return jresult; 4559 } 4560 4561 4562 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1absolute(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4563 jobject jresult = 0 ; 4564 btVector3 *arg1 = (btVector3 *) 0 ; 4565 btVector3 result; 4566 4567 (void)jenv; 4568 (void)jcls; 4569 (void)jarg1_; 4570 arg1 = *(btVector3 **)&jarg1; 4571 result = ((btVector3 const *)arg1)->absolute(); 4572 jresult = gdx_getReturnVector3(jenv); 4573 gdx_setVector3FrombtVector3(jenv, jresult, result); 4574 return jresult; 4575 } 4576 4577 4578 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1cross(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 4579 jobject jresult = 0 ; 4580 btVector3 *arg1 = (btVector3 *) 0 ; 4581 btVector3 *arg2 = 0 ; 4582 btVector3 result; 4583 4584 (void)jenv; 4585 (void)jcls; 4586 (void)jarg1_; 4587 arg1 = *(btVector3 **)&jarg1; 4588 btVector3 local_arg2; 4589 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4590 arg2 = &local_arg2; 4591 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4592 result = ((btVector3 const *)arg1)->cross((btVector3 const &)*arg2); 4593 jresult = gdx_getReturnVector3(jenv); 4594 gdx_setVector3FrombtVector3(jenv, jresult, result); 4595 return jresult; 4596 } 4597 4598 4599 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1triple(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { 4600 jfloat jresult = 0 ; 4601 btVector3 *arg1 = (btVector3 *) 0 ; 4602 btVector3 *arg2 = 0 ; 4603 btVector3 *arg3 = 0 ; 4604 btScalar result; 4605 4606 (void)jenv; 4607 (void)jcls; 4608 (void)jarg1_; 4609 arg1 = *(btVector3 **)&jarg1; 4610 btVector3 local_arg2; 4611 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4612 arg2 = &local_arg2; 4613 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4614 btVector3 local_arg3; 4615 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 4616 arg3 = &local_arg3; 4617 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 4618 result = (btScalar)((btVector3 const *)arg1)->triple((btVector3 const &)*arg2,(btVector3 const &)*arg3); 4619 jresult = (jfloat)result; 4620 return jresult; 4621 } 4622 4623 4624 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1minAxis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4625 jint jresult = 0 ; 4626 btVector3 *arg1 = (btVector3 *) 0 ; 4627 int result; 4628 4629 (void)jenv; 4630 (void)jcls; 4631 (void)jarg1_; 4632 arg1 = *(btVector3 **)&jarg1; 4633 result = (int)((btVector3 const *)arg1)->minAxis(); 4634 jresult = (jint)result; 4635 return jresult; 4636 } 4637 4638 4639 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1maxAxis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4640 jint jresult = 0 ; 4641 btVector3 *arg1 = (btVector3 *) 0 ; 4642 int result; 4643 4644 (void)jenv; 4645 (void)jcls; 4646 (void)jarg1_; 4647 arg1 = *(btVector3 **)&jarg1; 4648 result = (int)((btVector3 const *)arg1)->maxAxis(); 4649 jresult = (jint)result; 4650 return jresult; 4651 } 4652 4653 4654 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1furthestAxis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4655 jint jresult = 0 ; 4656 btVector3 *arg1 = (btVector3 *) 0 ; 4657 int result; 4658 4659 (void)jenv; 4660 (void)jcls; 4661 (void)jarg1_; 4662 arg1 = *(btVector3 **)&jarg1; 4663 result = (int)((btVector3 const *)arg1)->furthestAxis(); 4664 jresult = (jint)result; 4665 return jresult; 4666 } 4667 4668 4669 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1closestAxis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4670 jint jresult = 0 ; 4671 btVector3 *arg1 = (btVector3 *) 0 ; 4672 int result; 4673 4674 (void)jenv; 4675 (void)jcls; 4676 (void)jarg1_; 4677 arg1 = *(btVector3 **)&jarg1; 4678 result = (int)((btVector3 const *)arg1)->closestAxis(); 4679 jresult = (jint)result; 4680 return jresult; 4681 } 4682 4683 4684 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setInterpolate3(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jfloat jarg4) { 4685 btVector3 *arg1 = (btVector3 *) 0 ; 4686 btVector3 *arg2 = 0 ; 4687 btVector3 *arg3 = 0 ; 4688 btScalar arg4 ; 4689 4690 (void)jenv; 4691 (void)jcls; 4692 (void)jarg1_; 4693 arg1 = *(btVector3 **)&jarg1; 4694 btVector3 local_arg2; 4695 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4696 arg2 = &local_arg2; 4697 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4698 btVector3 local_arg3; 4699 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 4700 arg3 = &local_arg3; 4701 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 4702 arg4 = (btScalar)jarg4; 4703 (arg1)->setInterpolate3((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); 4704 } 4705 4706 4707 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1lerp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { 4708 jobject jresult = 0 ; 4709 btVector3 *arg1 = (btVector3 *) 0 ; 4710 btVector3 *arg2 = 0 ; 4711 btScalar *arg3 = 0 ; 4712 btScalar temp3 ; 4713 btVector3 result; 4714 4715 (void)jenv; 4716 (void)jcls; 4717 (void)jarg1_; 4718 arg1 = *(btVector3 **)&jarg1; 4719 btVector3 local_arg2; 4720 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4721 arg2 = &local_arg2; 4722 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4723 temp3 = (btScalar)jarg3; 4724 arg3 = &temp3; 4725 result = ((btVector3 const *)arg1)->lerp((btVector3 const &)*arg2,(btScalar const &)*arg3); 4726 jresult = gdx_getReturnVector3(jenv); 4727 gdx_setVector3FrombtVector3(jenv, jresult, result); 4728 return jresult; 4729 } 4730 4731 4732 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1getX(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4733 jfloat jresult = 0 ; 4734 btVector3 *arg1 = (btVector3 *) 0 ; 4735 btScalar *result = 0 ; 4736 4737 (void)jenv; 4738 (void)jcls; 4739 (void)jarg1_; 4740 arg1 = *(btVector3 **)&jarg1; 4741 result = (btScalar *) &((btVector3 const *)arg1)->getX(); 4742 jresult = (jfloat)*result; 4743 return jresult; 4744 } 4745 4746 4747 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1getY(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4748 jfloat jresult = 0 ; 4749 btVector3 *arg1 = (btVector3 *) 0 ; 4750 btScalar *result = 0 ; 4751 4752 (void)jenv; 4753 (void)jcls; 4754 (void)jarg1_; 4755 arg1 = *(btVector3 **)&jarg1; 4756 result = (btScalar *) &((btVector3 const *)arg1)->getY(); 4757 jresult = (jfloat)*result; 4758 return jresult; 4759 } 4760 4761 4762 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1getZ(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4763 jfloat jresult = 0 ; 4764 btVector3 *arg1 = (btVector3 *) 0 ; 4765 btScalar *result = 0 ; 4766 4767 (void)jenv; 4768 (void)jcls; 4769 (void)jarg1_; 4770 arg1 = *(btVector3 **)&jarg1; 4771 result = (btScalar *) &((btVector3 const *)arg1)->getZ(); 4772 jresult = (jfloat)*result; 4773 return jresult; 4774 } 4775 4776 4777 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setX(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 4778 btVector3 *arg1 = (btVector3 *) 0 ; 4779 btScalar arg2 ; 4780 4781 (void)jenv; 4782 (void)jcls; 4783 (void)jarg1_; 4784 arg1 = *(btVector3 **)&jarg1; 4785 arg2 = (btScalar)jarg2; 4786 (arg1)->setX(arg2); 4787 } 4788 4789 4790 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setY(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 4791 btVector3 *arg1 = (btVector3 *) 0 ; 4792 btScalar arg2 ; 4793 4794 (void)jenv; 4795 (void)jcls; 4796 (void)jarg1_; 4797 arg1 = *(btVector3 **)&jarg1; 4798 arg2 = (btScalar)jarg2; 4799 (arg1)->setY(arg2); 4800 } 4801 4802 4803 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setZ(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 4804 btVector3 *arg1 = (btVector3 *) 0 ; 4805 btScalar arg2 ; 4806 4807 (void)jenv; 4808 (void)jcls; 4809 (void)jarg1_; 4810 arg1 = *(btVector3 **)&jarg1; 4811 arg2 = (btScalar)jarg2; 4812 (arg1)->setZ(arg2); 4813 } 4814 4815 4816 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setW(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 4817 btVector3 *arg1 = (btVector3 *) 0 ; 4818 btScalar arg2 ; 4819 4820 (void)jenv; 4821 (void)jcls; 4822 (void)jarg1_; 4823 arg1 = *(btVector3 **)&jarg1; 4824 arg2 = (btScalar)jarg2; 4825 (arg1)->setW(arg2); 4826 } 4827 4828 4829 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1x(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4830 jfloat jresult = 0 ; 4831 btVector3 *arg1 = (btVector3 *) 0 ; 4832 btScalar *result = 0 ; 4833 4834 (void)jenv; 4835 (void)jcls; 4836 (void)jarg1_; 4837 arg1 = *(btVector3 **)&jarg1; 4838 result = (btScalar *) &((btVector3 const *)arg1)->x(); 4839 jresult = (jfloat)*result; 4840 return jresult; 4841 } 4842 4843 4844 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1y(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4845 jfloat jresult = 0 ; 4846 btVector3 *arg1 = (btVector3 *) 0 ; 4847 btScalar *result = 0 ; 4848 4849 (void)jenv; 4850 (void)jcls; 4851 (void)jarg1_; 4852 arg1 = *(btVector3 **)&jarg1; 4853 result = (btScalar *) &((btVector3 const *)arg1)->y(); 4854 jresult = (jfloat)*result; 4855 return jresult; 4856 } 4857 4858 4859 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1z(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4860 jfloat jresult = 0 ; 4861 btVector3 *arg1 = (btVector3 *) 0 ; 4862 btScalar *result = 0 ; 4863 4864 (void)jenv; 4865 (void)jcls; 4866 (void)jarg1_; 4867 arg1 = *(btVector3 **)&jarg1; 4868 result = (btScalar *) &((btVector3 const *)arg1)->z(); 4869 jresult = (jfloat)*result; 4870 return jresult; 4871 } 4872 4873 4874 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1w(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4875 jfloat jresult = 0 ; 4876 btVector3 *arg1 = (btVector3 *) 0 ; 4877 btScalar *result = 0 ; 4878 4879 (void)jenv; 4880 (void)jcls; 4881 (void)jarg1_; 4882 arg1 = *(btVector3 **)&jarg1; 4883 result = (btScalar *) &((btVector3 const *)arg1)->w(); 4884 jresult = (jfloat)*result; 4885 return jresult; 4886 } 4887 4888 4889 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setMax(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 4890 btVector3 *arg1 = (btVector3 *) 0 ; 4891 btVector3 *arg2 = 0 ; 4892 4893 (void)jenv; 4894 (void)jcls; 4895 (void)jarg1_; 4896 arg1 = *(btVector3 **)&jarg1; 4897 btVector3 local_arg2; 4898 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4899 arg2 = &local_arg2; 4900 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4901 (arg1)->setMax((btVector3 const &)*arg2); 4902 } 4903 4904 4905 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setMin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 4906 btVector3 *arg1 = (btVector3 *) 0 ; 4907 btVector3 *arg2 = 0 ; 4908 4909 (void)jenv; 4910 (void)jcls; 4911 (void)jarg1_; 4912 arg1 = *(btVector3 **)&jarg1; 4913 btVector3 local_arg2; 4914 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 4915 arg2 = &local_arg2; 4916 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 4917 (arg1)->setMin((btVector3 const &)*arg2); 4918 } 4919 4920 4921 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jfloat jarg4) { 4922 btVector3 *arg1 = (btVector3 *) 0 ; 4923 btScalar *arg2 = 0 ; 4924 btScalar *arg3 = 0 ; 4925 btScalar *arg4 = 0 ; 4926 btScalar temp2 ; 4927 btScalar temp3 ; 4928 btScalar temp4 ; 4929 4930 (void)jenv; 4931 (void)jcls; 4932 (void)jarg1_; 4933 arg1 = *(btVector3 **)&jarg1; 4934 temp2 = (btScalar)jarg2; 4935 arg2 = &temp2; 4936 temp3 = (btScalar)jarg3; 4937 arg3 = &temp3; 4938 temp4 = (btScalar)jarg4; 4939 arg4 = &temp4; 4940 (arg1)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); 4941 } 4942 4943 4944 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1getSkewSymmetricMatrix(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) { 4945 btVector3 *arg1 = (btVector3 *) 0 ; 4946 btVector3 *arg2 = (btVector3 *) 0 ; 4947 btVector3 *arg3 = (btVector3 *) 0 ; 4948 btVector3 *arg4 = (btVector3 *) 0 ; 4949 4950 (void)jenv; 4951 (void)jcls; 4952 (void)jarg1_; 4953 (void)jarg2_; 4954 (void)jarg3_; 4955 (void)jarg4_; 4956 arg1 = *(btVector3 **)&jarg1; 4957 arg2 = *(btVector3 **)&jarg2; 4958 arg3 = *(btVector3 **)&jarg3; 4959 arg4 = *(btVector3 **)&jarg4; 4960 ((btVector3 const *)arg1)->getSkewSymmetricMatrix(arg2,arg3,arg4); 4961 } 4962 4963 4964 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4965 btVector3 *arg1 = (btVector3 *) 0 ; 4966 4967 (void)jenv; 4968 (void)jcls; 4969 (void)jarg1_; 4970 arg1 = *(btVector3 **)&jarg1; 4971 (arg1)->setZero(); 4972 } 4973 4974 4975 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1isZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4976 jboolean jresult = 0 ; 4977 btVector3 *arg1 = (btVector3 *) 0 ; 4978 bool result; 4979 4980 (void)jenv; 4981 (void)jcls; 4982 (void)jarg1_; 4983 arg1 = *(btVector3 **)&jarg1; 4984 result = (bool)((btVector3 const *)arg1)->isZero(); 4985 jresult = (jboolean)result; 4986 return jresult; 4987 } 4988 4989 4990 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1fuzzyZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4991 jboolean jresult = 0 ; 4992 btVector3 *arg1 = (btVector3 *) 0 ; 4993 bool result; 4994 4995 (void)jenv; 4996 (void)jcls; 4997 (void)jarg1_; 4998 arg1 = *(btVector3 **)&jarg1; 4999 result = (bool)((btVector3 const *)arg1)->fuzzyZero(); 5000 jresult = (jboolean)result; 5001 return jresult; 5002 } 5003 5004 5005 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1serialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 5006 btVector3 *arg1 = (btVector3 *) 0 ; 5007 btVector3FloatData *arg2 = 0 ; 5008 5009 (void)jenv; 5010 (void)jcls; 5011 (void)jarg1_; 5012 (void)jarg2_; 5013 arg1 = *(btVector3 **)&jarg1; 5014 arg2 = *(btVector3FloatData **)&jarg2; 5015 if (!arg2) { 5016 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3FloatData & reference is null"); 5017 return ; 5018 } 5019 ((btVector3 const *)arg1)->serialize(*arg2); 5020 } 5021 5022 5023 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1deSerialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 5024 btVector3 *arg1 = (btVector3 *) 0 ; 5025 btVector3FloatData *arg2 = 0 ; 5026 5027 (void)jenv; 5028 (void)jcls; 5029 (void)jarg1_; 5030 (void)jarg2_; 5031 arg1 = *(btVector3 **)&jarg1; 5032 arg2 = *(btVector3FloatData **)&jarg2; 5033 if (!arg2) { 5034 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3FloatData const & reference is null"); 5035 return ; 5036 } 5037 (arg1)->deSerialize((btVector3FloatData const &)*arg2); 5038 } 5039 5040 5041 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1serializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 5042 btVector3 *arg1 = (btVector3 *) 0 ; 5043 btVector3FloatData *arg2 = 0 ; 5044 5045 (void)jenv; 5046 (void)jcls; 5047 (void)jarg1_; 5048 (void)jarg2_; 5049 arg1 = *(btVector3 **)&jarg1; 5050 arg2 = *(btVector3FloatData **)&jarg2; 5051 if (!arg2) { 5052 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3FloatData & reference is null"); 5053 return ; 5054 } 5055 ((btVector3 const *)arg1)->serializeFloat(*arg2); 5056 } 5057 5058 5059 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1deSerializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 5060 btVector3 *arg1 = (btVector3 *) 0 ; 5061 btVector3FloatData *arg2 = 0 ; 5062 5063 (void)jenv; 5064 (void)jcls; 5065 (void)jarg1_; 5066 (void)jarg2_; 5067 arg1 = *(btVector3 **)&jarg1; 5068 arg2 = *(btVector3FloatData **)&jarg2; 5069 if (!arg2) { 5070 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3FloatData const & reference is null"); 5071 return ; 5072 } 5073 (arg1)->deSerializeFloat((btVector3FloatData const &)*arg2); 5074 } 5075 5076 5077 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1serializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 5078 btVector3 *arg1 = (btVector3 *) 0 ; 5079 btVector3DoubleData *arg2 = 0 ; 5080 5081 (void)jenv; 5082 (void)jcls; 5083 (void)jarg1_; 5084 (void)jarg2_; 5085 arg1 = *(btVector3 **)&jarg1; 5086 arg2 = *(btVector3DoubleData **)&jarg2; 5087 if (!arg2) { 5088 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3DoubleData & reference is null"); 5089 return ; 5090 } 5091 ((btVector3 const *)arg1)->serializeDouble(*arg2); 5092 } 5093 5094 5095 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1deSerializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 5096 btVector3 *arg1 = (btVector3 *) 0 ; 5097 btVector3DoubleData *arg2 = 0 ; 5098 5099 (void)jenv; 5100 (void)jcls; 5101 (void)jarg1_; 5102 (void)jarg2_; 5103 arg1 = *(btVector3 **)&jarg1; 5104 arg2 = *(btVector3DoubleData **)&jarg2; 5105 if (!arg2) { 5106 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3DoubleData const & reference is null"); 5107 return ; 5108 } 5109 (arg1)->deSerializeDouble((btVector3DoubleData const &)*arg2); 5110 } 5111 5112 5113 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1maxDot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jlong jarg4) { 5114 jint jresult = 0 ; 5115 btVector3 *arg1 = (btVector3 *) 0 ; 5116 btVector3 *arg2 = (btVector3 *) 0 ; 5117 long arg3 ; 5118 btScalar *arg4 = 0 ; 5119 long result; 5120 5121 (void)jenv; 5122 (void)jcls; 5123 (void)jarg1_; 5124 (void)jarg2_; 5125 arg1 = *(btVector3 **)&jarg1; 5126 arg2 = *(btVector3 **)&jarg2; 5127 arg3 = (long)jarg3; 5128 arg4 = *(btScalar **)&jarg4; 5129 if (!arg4) { 5130 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); 5131 return 0; 5132 } 5133 result = (long)((btVector3 const *)arg1)->maxDot((btVector3 const *)arg2,arg3,*arg4); 5134 jresult = (jint)result; 5135 return jresult; 5136 } 5137 5138 5139 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1minDot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jlong jarg4) { 5140 jint jresult = 0 ; 5141 btVector3 *arg1 = (btVector3 *) 0 ; 5142 btVector3 *arg2 = (btVector3 *) 0 ; 5143 long arg3 ; 5144 btScalar *arg4 = 0 ; 5145 long result; 5146 5147 (void)jenv; 5148 (void)jcls; 5149 (void)jarg1_; 5150 (void)jarg2_; 5151 arg1 = *(btVector3 **)&jarg1; 5152 arg2 = *(btVector3 **)&jarg2; 5153 arg3 = (long)jarg3; 5154 arg4 = *(btScalar **)&jarg4; 5155 if (!arg4) { 5156 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); 5157 return 0; 5158 } 5159 result = (long)((btVector3 const *)arg1)->minDot((btVector3 const *)arg2,arg3,*arg4); 5160 jresult = (jint)result; 5161 return jresult; 5162 } 5163 5164 5165 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1dot3(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { 5166 jobject jresult = 0 ; 5167 btVector3 *arg1 = (btVector3 *) 0 ; 5168 btVector3 *arg2 = 0 ; 5169 btVector3 *arg3 = 0 ; 5170 btVector3 *arg4 = 0 ; 5171 btVector3 result; 5172 5173 (void)jenv; 5174 (void)jcls; 5175 (void)jarg1_; 5176 arg1 = *(btVector3 **)&jarg1; 5177 btVector3 local_arg2; 5178 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 5179 arg2 = &local_arg2; 5180 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 5181 btVector3 local_arg3; 5182 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 5183 arg3 = &local_arg3; 5184 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 5185 btVector3 local_arg4; 5186 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 5187 arg4 = &local_arg4; 5188 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 5189 result = ((btVector3 const *)arg1)->dot3((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); 5190 jresult = gdx_getReturnVector3(jenv); 5191 gdx_setVector3FrombtVector3(jenv, jresult, result); 5192 return jresult; 5193 } 5194 5195 5196 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector3(JNIEnv *jenv, jclass jcls, jlong jarg1) { 5197 btVector3 *arg1 = (btVector3 *) 0 ; 5198 5199 (void)jenv; 5200 (void)jcls; 5201 arg1 = *(btVector3 **)&jarg1; 5202 delete arg1; 5203 } 5204 5205 5206 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDot(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 5207 jfloat jresult = 0 ; 5208 btVector3 *arg1 = 0 ; 5209 btVector3 *arg2 = 0 ; 5210 btScalar result; 5211 5212 (void)jenv; 5213 (void)jcls; 5214 btVector3 local_arg1; 5215 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 5216 arg1 = &local_arg1; 5217 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 5218 btVector3 local_arg2; 5219 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 5220 arg2 = &local_arg2; 5221 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 5222 result = (btScalar)btDot((btVector3 const &)*arg1,(btVector3 const &)*arg2); 5223 jresult = (jfloat)result; 5224 return jresult; 5225 } 5226 5227 5228 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDistance2(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 5229 jfloat jresult = 0 ; 5230 btVector3 *arg1 = 0 ; 5231 btVector3 *arg2 = 0 ; 5232 btScalar result; 5233 5234 (void)jenv; 5235 (void)jcls; 5236 btVector3 local_arg1; 5237 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 5238 arg1 = &local_arg1; 5239 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 5240 btVector3 local_arg2; 5241 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 5242 arg2 = &local_arg2; 5243 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 5244 result = (btScalar)btDistance2((btVector3 const &)*arg1,(btVector3 const &)*arg2); 5245 jresult = (jfloat)result; 5246 return jresult; 5247 } 5248 5249 5250 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDistance(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 5251 jfloat jresult = 0 ; 5252 btVector3 *arg1 = 0 ; 5253 btVector3 *arg2 = 0 ; 5254 btScalar result; 5255 5256 (void)jenv; 5257 (void)jcls; 5258 btVector3 local_arg1; 5259 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 5260 arg1 = &local_arg1; 5261 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 5262 btVector3 local_arg2; 5263 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 5264 arg2 = &local_arg2; 5265 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 5266 result = (btScalar)btDistance((btVector3 const &)*arg1,(btVector3 const &)*arg2); 5267 jresult = (jfloat)result; 5268 return jresult; 5269 } 5270 5271 5272 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAngle_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 5273 jfloat jresult = 0 ; 5274 btVector3 *arg1 = 0 ; 5275 btVector3 *arg2 = 0 ; 5276 btScalar result; 5277 5278 (void)jenv; 5279 (void)jcls; 5280 btVector3 local_arg1; 5281 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 5282 arg1 = &local_arg1; 5283 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 5284 btVector3 local_arg2; 5285 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 5286 arg2 = &local_arg2; 5287 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 5288 result = (btScalar)btAngle((btVector3 const &)*arg1,(btVector3 const &)*arg2); 5289 jresult = (jfloat)result; 5290 return jresult; 5291 } 5292 5293 5294 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btCross(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 5295 jobject jresult = 0 ; 5296 btVector3 *arg1 = 0 ; 5297 btVector3 *arg2 = 0 ; 5298 btVector3 result; 5299 5300 (void)jenv; 5301 (void)jcls; 5302 btVector3 local_arg1; 5303 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 5304 arg1 = &local_arg1; 5305 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 5306 btVector3 local_arg2; 5307 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 5308 arg2 = &local_arg2; 5309 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 5310 result = btCross((btVector3 const &)*arg1,(btVector3 const &)*arg2); 5311 jresult = gdx_getReturnVector3(jenv); 5312 gdx_setVector3FrombtVector3(jenv, jresult, result); 5313 return jresult; 5314 } 5315 5316 5317 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTriple(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3) { 5318 jfloat jresult = 0 ; 5319 btVector3 *arg1 = 0 ; 5320 btVector3 *arg2 = 0 ; 5321 btVector3 *arg3 = 0 ; 5322 btScalar result; 5323 5324 (void)jenv; 5325 (void)jcls; 5326 btVector3 local_arg1; 5327 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 5328 arg1 = &local_arg1; 5329 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 5330 btVector3 local_arg2; 5331 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 5332 arg2 = &local_arg2; 5333 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 5334 btVector3 local_arg3; 5335 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 5336 arg3 = &local_arg3; 5337 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 5338 result = (btScalar)btTriple((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); 5339 jresult = (jfloat)result; 5340 return jresult; 5341 } 5342 5343 5344 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_lerp(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jfloat jarg3) { 5345 jobject jresult = 0 ; 5346 btVector3 *arg1 = 0 ; 5347 btVector3 *arg2 = 0 ; 5348 btScalar *arg3 = 0 ; 5349 btScalar temp3 ; 5350 btVector3 result; 5351 5352 (void)jenv; 5353 (void)jcls; 5354 btVector3 local_arg1; 5355 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 5356 arg1 = &local_arg1; 5357 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 5358 btVector3 local_arg2; 5359 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 5360 arg2 = &local_arg2; 5361 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 5362 temp3 = (btScalar)jarg3; 5363 arg3 = &temp3; 5364 result = lerp((btVector3 const &)*arg1,(btVector3 const &)*arg2,(float const &)*arg3); 5365 jresult = gdx_getReturnVector3(jenv); 5366 gdx_setVector3FrombtVector3(jenv, jresult, result); 5367 return jresult; 5368 } 5369 5370 5371 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector4_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 5372 jlong jresult = 0 ; 5373 btVector4 *result = 0 ; 5374 5375 (void)jenv; 5376 (void)jcls; 5377 result = (btVector4 *)new btVector4(); 5378 *(btVector4 **)&jresult = result; 5379 return jresult; 5380 } 5381 5382 5383 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector4_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2, jfloat jarg3, jfloat jarg4) { 5384 jlong jresult = 0 ; 5385 btScalar *arg1 = 0 ; 5386 btScalar *arg2 = 0 ; 5387 btScalar *arg3 = 0 ; 5388 btScalar *arg4 = 0 ; 5389 btScalar temp1 ; 5390 btScalar temp2 ; 5391 btScalar temp3 ; 5392 btScalar temp4 ; 5393 btVector4 *result = 0 ; 5394 5395 (void)jenv; 5396 (void)jcls; 5397 temp1 = (btScalar)jarg1; 5398 arg1 = &temp1; 5399 temp2 = (btScalar)jarg2; 5400 arg2 = &temp2; 5401 temp3 = (btScalar)jarg3; 5402 arg3 = &temp3; 5403 temp4 = (btScalar)jarg4; 5404 arg4 = &temp4; 5405 result = (btVector4 *)new btVector4((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); 5406 *(btVector4 **)&jresult = result; 5407 return jresult; 5408 } 5409 5410 5411 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1absolute4(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5412 jlong jresult = 0 ; 5413 btVector4 *arg1 = (btVector4 *) 0 ; 5414 btVector4 result; 5415 5416 (void)jenv; 5417 (void)jcls; 5418 (void)jarg1_; 5419 arg1 = *(btVector4 **)&jarg1; 5420 result = ((btVector4 const *)arg1)->absolute4(); 5421 *(btVector4 **)&jresult = new btVector4((const btVector4 &)result); 5422 return jresult; 5423 } 5424 5425 5426 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1getW(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5427 jfloat jresult = 0 ; 5428 btVector4 *arg1 = (btVector4 *) 0 ; 5429 btScalar result; 5430 5431 (void)jenv; 5432 (void)jcls; 5433 (void)jarg1_; 5434 arg1 = *(btVector4 **)&jarg1; 5435 result = (btScalar)((btVector4 const *)arg1)->getW(); 5436 jresult = (jfloat)result; 5437 return jresult; 5438 } 5439 5440 5441 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1maxAxis4(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5442 jint jresult = 0 ; 5443 btVector4 *arg1 = (btVector4 *) 0 ; 5444 int result; 5445 5446 (void)jenv; 5447 (void)jcls; 5448 (void)jarg1_; 5449 arg1 = *(btVector4 **)&jarg1; 5450 result = (int)((btVector4 const *)arg1)->maxAxis4(); 5451 jresult = (jint)result; 5452 return jresult; 5453 } 5454 5455 5456 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1minAxis4(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5457 jint jresult = 0 ; 5458 btVector4 *arg1 = (btVector4 *) 0 ; 5459 int result; 5460 5461 (void)jenv; 5462 (void)jcls; 5463 (void)jarg1_; 5464 arg1 = *(btVector4 **)&jarg1; 5465 result = (int)((btVector4 const *)arg1)->minAxis4(); 5466 jresult = (jint)result; 5467 return jresult; 5468 } 5469 5470 5471 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1closestAxis4(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5472 jint jresult = 0 ; 5473 btVector4 *arg1 = (btVector4 *) 0 ; 5474 int result; 5475 5476 (void)jenv; 5477 (void)jcls; 5478 (void)jarg1_; 5479 arg1 = *(btVector4 **)&jarg1; 5480 result = (int)((btVector4 const *)arg1)->closestAxis4(); 5481 jresult = (jint)result; 5482 return jresult; 5483 } 5484 5485 5486 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jfloat jarg4, jfloat jarg5) { 5487 btVector4 *arg1 = (btVector4 *) 0 ; 5488 btScalar *arg2 = 0 ; 5489 btScalar *arg3 = 0 ; 5490 btScalar *arg4 = 0 ; 5491 btScalar *arg5 = 0 ; 5492 btScalar temp2 ; 5493 btScalar temp3 ; 5494 btScalar temp4 ; 5495 btScalar temp5 ; 5496 5497 (void)jenv; 5498 (void)jcls; 5499 (void)jarg1_; 5500 arg1 = *(btVector4 **)&jarg1; 5501 temp2 = (btScalar)jarg2; 5502 arg2 = &temp2; 5503 temp3 = (btScalar)jarg3; 5504 arg3 = &temp3; 5505 temp4 = (btScalar)jarg4; 5506 arg4 = &temp4; 5507 temp5 = (btScalar)jarg5; 5508 arg5 = &temp5; 5509 (arg1)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4,(btScalar const &)*arg5); 5510 } 5511 5512 5513 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector4(JNIEnv *jenv, jclass jcls, jlong jarg1) { 5514 btVector4 *arg1 = (btVector4 *) 0 ; 5515 5516 (void)jenv; 5517 (void)jcls; 5518 arg1 = *(btVector4 **)&jarg1; 5519 delete arg1; 5520 } 5521 5522 5523 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapScalarEndian(JNIEnv *jenv, jclass jcls, jfloat jarg1, jlong jarg2) { 5524 btScalar *arg1 = 0 ; 5525 btScalar *arg2 = 0 ; 5526 btScalar temp1 ; 5527 5528 (void)jenv; 5529 (void)jcls; 5530 temp1 = (btScalar)jarg1; 5531 arg1 = &temp1; 5532 arg2 = *(btScalar **)&jarg2; 5533 if (!arg2) { 5534 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); 5535 return ; 5536 } 5537 btSwapScalarEndian((float const &)*arg1,*arg2); 5538 } 5539 5540 5541 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapVector3Endian(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 5542 btVector3 *arg1 = 0 ; 5543 btVector3 *arg2 = 0 ; 5544 5545 (void)jenv; 5546 (void)jcls; 5547 btVector3 local_arg1; 5548 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 5549 arg1 = &local_arg1; 5550 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 5551 btVector3 local_arg2; 5552 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 5553 arg2 = &local_arg2; 5554 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 5555 btSwapVector3Endian((btVector3 const &)*arg1,*arg2); 5556 } 5557 5558 5559 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btUnSwapVector3Endian(JNIEnv *jenv, jclass jcls, jobject jarg1) { 5560 btVector3 *arg1 = 0 ; 5561 5562 (void)jenv; 5563 (void)jcls; 5564 btVector3 local_arg1; 5565 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 5566 arg1 = &local_arg1; 5567 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 5568 btUnSwapVector3Endian(*arg1); 5569 } 5570 5571 5572 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3FloatData_1floats_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloatArray jarg2) { 5573 btVector3FloatData *arg1 = (btVector3FloatData *) 0 ; 5574 float *arg2 ; 5575 jfloat *jarr2 ; 5576 5577 (void)jenv; 5578 (void)jcls; 5579 (void)jarg1_; 5580 arg1 = *(btVector3FloatData **)&jarg1; 5581 if (jarg2 && jenv->GetArrayLength(jarg2) != 4) { 5582 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 5583 return ; 5584 } 5585 if (!SWIG_JavaArrayInFloat(jenv, &jarr2, (float **)&arg2, jarg2)) return ; 5586 { 5587 size_t ii; 5588 float *b = (float *) arg1->m_floats; 5589 for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); 5590 } 5591 SWIG_JavaArrayArgoutFloat(jenv, jarr2, (float *)arg2, jarg2); 5592 delete [] arg2; 5593 } 5594 5595 5596 SWIGEXPORT jfloatArray JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3FloatData_1floats_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5597 jfloatArray jresult = 0 ; 5598 btVector3FloatData *arg1 = (btVector3FloatData *) 0 ; 5599 float *result = 0 ; 5600 5601 (void)jenv; 5602 (void)jcls; 5603 (void)jarg1_; 5604 arg1 = *(btVector3FloatData **)&jarg1; 5605 result = (float *)(float *) ((arg1)->m_floats); 5606 jresult = SWIG_JavaArrayOutFloat(jenv, (float *)result, 4); 5607 return jresult; 5608 } 5609 5610 5611 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3FloatData(JNIEnv *jenv, jclass jcls) { 5612 jlong jresult = 0 ; 5613 btVector3FloatData *result = 0 ; 5614 5615 (void)jenv; 5616 (void)jcls; 5617 result = (btVector3FloatData *)new btVector3FloatData(); 5618 *(btVector3FloatData **)&jresult = result; 5619 return jresult; 5620 } 5621 5622 5623 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector3FloatData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 5624 btVector3FloatData *arg1 = (btVector3FloatData *) 0 ; 5625 5626 (void)jenv; 5627 (void)jcls; 5628 arg1 = *(btVector3FloatData **)&jarg1; 5629 delete arg1; 5630 } 5631 5632 5633 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3DoubleData_1floats_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2) { 5634 btVector3DoubleData *arg1 = (btVector3DoubleData *) 0 ; 5635 double *arg2 ; 5636 jdouble *jarr2 ; 5637 5638 (void)jenv; 5639 (void)jcls; 5640 (void)jarg1_; 5641 arg1 = *(btVector3DoubleData **)&jarg1; 5642 if (jarg2 && jenv->GetArrayLength(jarg2) != 4) { 5643 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 5644 return ; 5645 } 5646 if (!SWIG_JavaArrayInDouble(jenv, &jarr2, (double **)&arg2, jarg2)) return ; 5647 { 5648 size_t ii; 5649 double *b = (double *) arg1->m_floats; 5650 for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); 5651 } 5652 SWIG_JavaArrayArgoutDouble(jenv, jarr2, (double *)arg2, jarg2); 5653 delete [] arg2; 5654 } 5655 5656 5657 SWIGEXPORT jdoubleArray JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3DoubleData_1floats_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5658 jdoubleArray jresult = 0 ; 5659 btVector3DoubleData *arg1 = (btVector3DoubleData *) 0 ; 5660 double *result = 0 ; 5661 5662 (void)jenv; 5663 (void)jcls; 5664 (void)jarg1_; 5665 arg1 = *(btVector3DoubleData **)&jarg1; 5666 result = (double *)(double *) ((arg1)->m_floats); 5667 jresult = SWIG_JavaArrayOutDouble(jenv, (double *)result, 4); 5668 return jresult; 5669 } 5670 5671 5672 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3DoubleData(JNIEnv *jenv, jclass jcls) { 5673 jlong jresult = 0 ; 5674 btVector3DoubleData *result = 0 ; 5675 5676 (void)jenv; 5677 (void)jcls; 5678 result = (btVector3DoubleData *)new btVector3DoubleData(); 5679 *(btVector3DoubleData **)&jresult = result; 5680 return jresult; 5681 } 5682 5683 5684 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector3DoubleData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 5685 btVector3DoubleData *arg1 = (btVector3DoubleData *) 0 ; 5686 5687 (void)jenv; 5688 (void)jcls; 5689 arg1 = *(btVector3DoubleData **)&jarg1; 5690 delete arg1; 5691 } 5692 5693 5694 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternion_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 5695 jlong jresult = 0 ; 5696 btQuaternion *result = 0 ; 5697 5698 (void)jenv; 5699 (void)jcls; 5700 result = (btQuaternion *)new btQuaternion(); 5701 *(btQuaternion **)&jresult = result; 5702 return jresult; 5703 } 5704 5705 5706 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternion_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2, jfloat jarg3, jfloat jarg4) { 5707 jlong jresult = 0 ; 5708 btScalar *arg1 = 0 ; 5709 btScalar *arg2 = 0 ; 5710 btScalar *arg3 = 0 ; 5711 btScalar *arg4 = 0 ; 5712 btScalar temp1 ; 5713 btScalar temp2 ; 5714 btScalar temp3 ; 5715 btScalar temp4 ; 5716 btQuaternion *result = 0 ; 5717 5718 (void)jenv; 5719 (void)jcls; 5720 temp1 = (btScalar)jarg1; 5721 arg1 = &temp1; 5722 temp2 = (btScalar)jarg2; 5723 arg2 = &temp2; 5724 temp3 = (btScalar)jarg3; 5725 arg3 = &temp3; 5726 temp4 = (btScalar)jarg4; 5727 arg4 = &temp4; 5728 result = (btQuaternion *)new btQuaternion((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); 5729 *(btQuaternion **)&jresult = result; 5730 return jresult; 5731 } 5732 5733 5734 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternion_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jobject jarg1, jfloat jarg2) { 5735 jlong jresult = 0 ; 5736 btVector3 *arg1 = 0 ; 5737 btScalar *arg2 = 0 ; 5738 btScalar temp2 ; 5739 btQuaternion *result = 0 ; 5740 5741 (void)jenv; 5742 (void)jcls; 5743 btVector3 local_arg1; 5744 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 5745 arg1 = &local_arg1; 5746 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 5747 temp2 = (btScalar)jarg2; 5748 arg2 = &temp2; 5749 result = (btQuaternion *)new btQuaternion((btVector3 const &)*arg1,(btScalar const &)*arg2); 5750 *(btQuaternion **)&jresult = result; 5751 return jresult; 5752 } 5753 5754 5755 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternion_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2, jfloat jarg3) { 5756 jlong jresult = 0 ; 5757 btScalar *arg1 = 0 ; 5758 btScalar *arg2 = 0 ; 5759 btScalar *arg3 = 0 ; 5760 btScalar temp1 ; 5761 btScalar temp2 ; 5762 btScalar temp3 ; 5763 btQuaternion *result = 0 ; 5764 5765 (void)jenv; 5766 (void)jcls; 5767 temp1 = (btScalar)jarg1; 5768 arg1 = &temp1; 5769 temp2 = (btScalar)jarg2; 5770 arg2 = &temp2; 5771 temp3 = (btScalar)jarg3; 5772 arg3 = &temp3; 5773 result = (btQuaternion *)new btQuaternion((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3); 5774 *(btQuaternion **)&jresult = result; 5775 return jresult; 5776 } 5777 5778 5779 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1setRotation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { 5780 btQuaternion *arg1 = (btQuaternion *) 0 ; 5781 btVector3 *arg2 = 0 ; 5782 btScalar *arg3 = 0 ; 5783 btScalar temp3 ; 5784 5785 (void)jenv; 5786 (void)jcls; 5787 (void)jarg1_; 5788 arg1 = *(btQuaternion **)&jarg1; 5789 btVector3 local_arg2; 5790 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 5791 arg2 = &local_arg2; 5792 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 5793 temp3 = (btScalar)jarg3; 5794 arg3 = &temp3; 5795 (arg1)->setRotation((btVector3 const &)*arg2,(btScalar const &)*arg3); 5796 } 5797 5798 5799 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1setEuler(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jfloat jarg4) { 5800 btQuaternion *arg1 = (btQuaternion *) 0 ; 5801 btScalar *arg2 = 0 ; 5802 btScalar *arg3 = 0 ; 5803 btScalar *arg4 = 0 ; 5804 btScalar temp2 ; 5805 btScalar temp3 ; 5806 btScalar temp4 ; 5807 5808 (void)jenv; 5809 (void)jcls; 5810 (void)jarg1_; 5811 arg1 = *(btQuaternion **)&jarg1; 5812 temp2 = (btScalar)jarg2; 5813 arg2 = &temp2; 5814 temp3 = (btScalar)jarg3; 5815 arg3 = &temp3; 5816 temp4 = (btScalar)jarg4; 5817 arg4 = &temp4; 5818 (arg1)->setEuler((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); 5819 } 5820 5821 5822 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1setEulerZYX(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jfloat jarg4) { 5823 btQuaternion *arg1 = (btQuaternion *) 0 ; 5824 btScalar *arg2 = 0 ; 5825 btScalar *arg3 = 0 ; 5826 btScalar *arg4 = 0 ; 5827 btScalar temp2 ; 5828 btScalar temp3 ; 5829 btScalar temp4 ; 5830 5831 (void)jenv; 5832 (void)jcls; 5833 (void)jarg1_; 5834 arg1 = *(btQuaternion **)&jarg1; 5835 temp2 = (btScalar)jarg2; 5836 arg2 = &temp2; 5837 temp3 = (btScalar)jarg3; 5838 arg3 = &temp3; 5839 temp4 = (btScalar)jarg4; 5840 arg4 = &temp4; 5841 (arg1)->setEulerZYX((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); 5842 } 5843 5844 5845 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1dot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 5846 jfloat jresult = 0 ; 5847 btQuaternion *arg1 = (btQuaternion *) 0 ; 5848 btQuaternion *arg2 = 0 ; 5849 btScalar result; 5850 5851 (void)jenv; 5852 (void)jcls; 5853 (void)jarg1_; 5854 arg1 = *(btQuaternion **)&jarg1; 5855 btQuaternion local_arg2; 5856 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 5857 arg2 = &local_arg2; 5858 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 5859 result = (btScalar)((btQuaternion const *)arg1)->dot((btQuaternion const &)*arg2); 5860 jresult = (jfloat)result; 5861 return jresult; 5862 } 5863 5864 5865 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1length2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5866 jfloat jresult = 0 ; 5867 btQuaternion *arg1 = (btQuaternion *) 0 ; 5868 btScalar result; 5869 5870 (void)jenv; 5871 (void)jcls; 5872 (void)jarg1_; 5873 arg1 = *(btQuaternion **)&jarg1; 5874 result = (btScalar)((btQuaternion const *)arg1)->length2(); 5875 jresult = (jfloat)result; 5876 return jresult; 5877 } 5878 5879 5880 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1length(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5881 jfloat jresult = 0 ; 5882 btQuaternion *arg1 = (btQuaternion *) 0 ; 5883 btScalar result; 5884 5885 (void)jenv; 5886 (void)jcls; 5887 (void)jarg1_; 5888 arg1 = *(btQuaternion **)&jarg1; 5889 result = (btScalar)((btQuaternion const *)arg1)->length(); 5890 jresult = (jfloat)result; 5891 return jresult; 5892 } 5893 5894 5895 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1normalize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5896 jobject jresult = 0 ; 5897 btQuaternion *arg1 = (btQuaternion *) 0 ; 5898 btQuaternion *result = 0 ; 5899 5900 (void)jenv; 5901 (void)jcls; 5902 (void)jarg1_; 5903 arg1 = *(btQuaternion **)&jarg1; 5904 result = (btQuaternion *) &(arg1)->normalize(); 5905 jresult = gdx_getReturnQuaternion(jenv); 5906 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 5907 return jresult; 5908 } 5909 5910 5911 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1normalized(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5912 jobject jresult = 0 ; 5913 btQuaternion *arg1 = (btQuaternion *) 0 ; 5914 btQuaternion result; 5915 5916 (void)jenv; 5917 (void)jcls; 5918 (void)jarg1_; 5919 arg1 = *(btQuaternion **)&jarg1; 5920 result = ((btQuaternion const *)arg1)->normalized(); 5921 jresult = gdx_getReturnQuaternion(jenv); 5922 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 5923 return jresult; 5924 } 5925 5926 5927 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1angle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 5928 jfloat jresult = 0 ; 5929 btQuaternion *arg1 = (btQuaternion *) 0 ; 5930 btQuaternion *arg2 = 0 ; 5931 btScalar result; 5932 5933 (void)jenv; 5934 (void)jcls; 5935 (void)jarg1_; 5936 arg1 = *(btQuaternion **)&jarg1; 5937 btQuaternion local_arg2; 5938 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 5939 arg2 = &local_arg2; 5940 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 5941 result = (btScalar)((btQuaternion const *)arg1)->angle((btQuaternion const &)*arg2); 5942 jresult = (jfloat)result; 5943 return jresult; 5944 } 5945 5946 5947 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1angleShortestPath(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 5948 jfloat jresult = 0 ; 5949 btQuaternion *arg1 = (btQuaternion *) 0 ; 5950 btQuaternion *arg2 = 0 ; 5951 btScalar result; 5952 5953 (void)jenv; 5954 (void)jcls; 5955 (void)jarg1_; 5956 arg1 = *(btQuaternion **)&jarg1; 5957 btQuaternion local_arg2; 5958 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 5959 arg2 = &local_arg2; 5960 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 5961 result = (btScalar)((btQuaternion const *)arg1)->angleShortestPath((btQuaternion const &)*arg2); 5962 jresult = (jfloat)result; 5963 return jresult; 5964 } 5965 5966 5967 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1getAngle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5968 jfloat jresult = 0 ; 5969 btQuaternion *arg1 = (btQuaternion *) 0 ; 5970 btScalar result; 5971 5972 (void)jenv; 5973 (void)jcls; 5974 (void)jarg1_; 5975 arg1 = *(btQuaternion **)&jarg1; 5976 result = (btScalar)((btQuaternion const *)arg1)->getAngle(); 5977 jresult = (jfloat)result; 5978 return jresult; 5979 } 5980 5981 5982 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1getAngleShortestPath(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5983 jfloat jresult = 0 ; 5984 btQuaternion *arg1 = (btQuaternion *) 0 ; 5985 btScalar result; 5986 5987 (void)jenv; 5988 (void)jcls; 5989 (void)jarg1_; 5990 arg1 = *(btQuaternion **)&jarg1; 5991 result = (btScalar)((btQuaternion const *)arg1)->getAngleShortestPath(); 5992 jresult = (jfloat)result; 5993 return jresult; 5994 } 5995 5996 5997 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1getAxis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 5998 jobject jresult = 0 ; 5999 btQuaternion *arg1 = (btQuaternion *) 0 ; 6000 btVector3 result; 6001 6002 (void)jenv; 6003 (void)jcls; 6004 (void)jarg1_; 6005 arg1 = *(btQuaternion **)&jarg1; 6006 result = ((btQuaternion const *)arg1)->getAxis(); 6007 jresult = gdx_getReturnVector3(jenv); 6008 gdx_setVector3FrombtVector3(jenv, jresult, result); 6009 return jresult; 6010 } 6011 6012 6013 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1inverse(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6014 jobject jresult = 0 ; 6015 btQuaternion *arg1 = (btQuaternion *) 0 ; 6016 btQuaternion result; 6017 6018 (void)jenv; 6019 (void)jcls; 6020 (void)jarg1_; 6021 arg1 = *(btQuaternion **)&jarg1; 6022 result = ((btQuaternion const *)arg1)->inverse(); 6023 jresult = gdx_getReturnQuaternion(jenv); 6024 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 6025 return jresult; 6026 } 6027 6028 6029 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1farthest(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 6030 jobject jresult = 0 ; 6031 btQuaternion *arg1 = (btQuaternion *) 0 ; 6032 btQuaternion *arg2 = 0 ; 6033 btQuaternion result; 6034 6035 (void)jenv; 6036 (void)jcls; 6037 (void)jarg1_; 6038 arg1 = *(btQuaternion **)&jarg1; 6039 btQuaternion local_arg2; 6040 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 6041 arg2 = &local_arg2; 6042 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 6043 result = ((btQuaternion const *)arg1)->farthest((btQuaternion const &)*arg2); 6044 jresult = gdx_getReturnQuaternion(jenv); 6045 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 6046 return jresult; 6047 } 6048 6049 6050 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1nearest(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 6051 jobject jresult = 0 ; 6052 btQuaternion *arg1 = (btQuaternion *) 0 ; 6053 btQuaternion *arg2 = 0 ; 6054 btQuaternion result; 6055 6056 (void)jenv; 6057 (void)jcls; 6058 (void)jarg1_; 6059 arg1 = *(btQuaternion **)&jarg1; 6060 btQuaternion local_arg2; 6061 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 6062 arg2 = &local_arg2; 6063 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 6064 result = ((btQuaternion const *)arg1)->nearest((btQuaternion const &)*arg2); 6065 jresult = gdx_getReturnQuaternion(jenv); 6066 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 6067 return jresult; 6068 } 6069 6070 6071 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1slerp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { 6072 jobject jresult = 0 ; 6073 btQuaternion *arg1 = (btQuaternion *) 0 ; 6074 btQuaternion *arg2 = 0 ; 6075 btScalar *arg3 = 0 ; 6076 btScalar temp3 ; 6077 btQuaternion result; 6078 6079 (void)jenv; 6080 (void)jcls; 6081 (void)jarg1_; 6082 arg1 = *(btQuaternion **)&jarg1; 6083 btQuaternion local_arg2; 6084 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 6085 arg2 = &local_arg2; 6086 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 6087 temp3 = (btScalar)jarg3; 6088 arg3 = &temp3; 6089 result = ((btQuaternion const *)arg1)->slerp((btQuaternion const &)*arg2,(btScalar const &)*arg3); 6090 jresult = gdx_getReturnQuaternion(jenv); 6091 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 6092 return jresult; 6093 } 6094 6095 6096 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1getIdentity(JNIEnv *jenv, jclass jcls) { 6097 jobject jresult = 0 ; 6098 btQuaternion *result = 0 ; 6099 6100 (void)jenv; 6101 (void)jcls; 6102 result = (btQuaternion *) &btQuaternion::getIdentity(); 6103 jresult = gdx_getReturnQuaternion(jenv); 6104 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 6105 return jresult; 6106 } 6107 6108 6109 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1getW(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6110 jfloat jresult = 0 ; 6111 btQuaternion *arg1 = (btQuaternion *) 0 ; 6112 btScalar *result = 0 ; 6113 6114 (void)jenv; 6115 (void)jcls; 6116 (void)jarg1_; 6117 arg1 = *(btQuaternion **)&jarg1; 6118 result = (btScalar *) &((btQuaternion const *)arg1)->getW(); 6119 jresult = (jfloat)*result; 6120 return jresult; 6121 } 6122 6123 6124 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1serialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6125 btQuaternion *arg1 = (btQuaternion *) 0 ; 6126 btQuaternionFloatData *arg2 = 0 ; 6127 6128 (void)jenv; 6129 (void)jcls; 6130 (void)jarg1_; 6131 (void)jarg2_; 6132 arg1 = *(btQuaternion **)&jarg1; 6133 arg2 = *(btQuaternionFloatData **)&jarg2; 6134 if (!arg2) { 6135 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionFloatData & reference is null"); 6136 return ; 6137 } 6138 ((btQuaternion const *)arg1)->serialize(*arg2); 6139 } 6140 6141 6142 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1deSerialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6143 btQuaternion *arg1 = (btQuaternion *) 0 ; 6144 btQuaternionFloatData *arg2 = 0 ; 6145 6146 (void)jenv; 6147 (void)jcls; 6148 (void)jarg1_; 6149 (void)jarg2_; 6150 arg1 = *(btQuaternion **)&jarg1; 6151 arg2 = *(btQuaternionFloatData **)&jarg2; 6152 if (!arg2) { 6153 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionFloatData const & reference is null"); 6154 return ; 6155 } 6156 (arg1)->deSerialize((btQuaternionFloatData const &)*arg2); 6157 } 6158 6159 6160 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1serializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6161 btQuaternion *arg1 = (btQuaternion *) 0 ; 6162 btQuaternionFloatData *arg2 = 0 ; 6163 6164 (void)jenv; 6165 (void)jcls; 6166 (void)jarg1_; 6167 (void)jarg2_; 6168 arg1 = *(btQuaternion **)&jarg1; 6169 arg2 = *(btQuaternionFloatData **)&jarg2; 6170 if (!arg2) { 6171 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionFloatData & reference is null"); 6172 return ; 6173 } 6174 ((btQuaternion const *)arg1)->serializeFloat(*arg2); 6175 } 6176 6177 6178 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1deSerializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6179 btQuaternion *arg1 = (btQuaternion *) 0 ; 6180 btQuaternionFloatData *arg2 = 0 ; 6181 6182 (void)jenv; 6183 (void)jcls; 6184 (void)jarg1_; 6185 (void)jarg2_; 6186 arg1 = *(btQuaternion **)&jarg1; 6187 arg2 = *(btQuaternionFloatData **)&jarg2; 6188 if (!arg2) { 6189 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionFloatData const & reference is null"); 6190 return ; 6191 } 6192 (arg1)->deSerializeFloat((btQuaternionFloatData const &)*arg2); 6193 } 6194 6195 6196 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1serializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6197 btQuaternion *arg1 = (btQuaternion *) 0 ; 6198 btQuaternionDoubleData *arg2 = 0 ; 6199 6200 (void)jenv; 6201 (void)jcls; 6202 (void)jarg1_; 6203 (void)jarg2_; 6204 arg1 = *(btQuaternion **)&jarg1; 6205 arg2 = *(btQuaternionDoubleData **)&jarg2; 6206 if (!arg2) { 6207 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionDoubleData & reference is null"); 6208 return ; 6209 } 6210 ((btQuaternion const *)arg1)->serializeDouble(*arg2); 6211 } 6212 6213 6214 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1deSerializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6215 btQuaternion *arg1 = (btQuaternion *) 0 ; 6216 btQuaternionDoubleData *arg2 = 0 ; 6217 6218 (void)jenv; 6219 (void)jcls; 6220 (void)jarg1_; 6221 (void)jarg2_; 6222 arg1 = *(btQuaternion **)&jarg1; 6223 arg2 = *(btQuaternionDoubleData **)&jarg2; 6224 if (!arg2) { 6225 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionDoubleData const & reference is null"); 6226 return ; 6227 } 6228 (arg1)->deSerializeDouble((btQuaternionDoubleData const &)*arg2); 6229 } 6230 6231 6232 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btQuaternion(JNIEnv *jenv, jclass jcls, jlong jarg1) { 6233 btQuaternion *arg1 = (btQuaternion *) 0 ; 6234 6235 (void)jenv; 6236 (void)jcls; 6237 arg1 = *(btQuaternion **)&jarg1; 6238 delete arg1; 6239 } 6240 6241 6242 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_dot(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 6243 jfloat jresult = 0 ; 6244 btQuaternion *arg1 = 0 ; 6245 btQuaternion *arg2 = 0 ; 6246 btScalar result; 6247 6248 (void)jenv; 6249 (void)jcls; 6250 btQuaternion local_arg1; 6251 gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); 6252 arg1 = &local_arg1; 6253 gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); 6254 btQuaternion local_arg2; 6255 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 6256 arg2 = &local_arg2; 6257 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 6258 result = (btScalar)dot((btQuaternion const &)*arg1,(btQuaternion const &)*arg2); 6259 jresult = (jfloat)result; 6260 return jresult; 6261 } 6262 6263 6264 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_length(JNIEnv *jenv, jclass jcls, jobject jarg1) { 6265 jfloat jresult = 0 ; 6266 btQuaternion *arg1 = 0 ; 6267 btScalar result; 6268 6269 (void)jenv; 6270 (void)jcls; 6271 btQuaternion local_arg1; 6272 gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); 6273 arg1 = &local_arg1; 6274 gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); 6275 result = (btScalar)length((btQuaternion const &)*arg1); 6276 jresult = (jfloat)result; 6277 return jresult; 6278 } 6279 6280 6281 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAngle_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 6282 jfloat jresult = 0 ; 6283 btQuaternion *arg1 = 0 ; 6284 btQuaternion *arg2 = 0 ; 6285 btScalar result; 6286 6287 (void)jenv; 6288 (void)jcls; 6289 btQuaternion local_arg1; 6290 gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); 6291 arg1 = &local_arg1; 6292 gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); 6293 btQuaternion local_arg2; 6294 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 6295 arg2 = &local_arg2; 6296 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 6297 result = (btScalar)btAngle((btQuaternion const &)*arg1,(btQuaternion const &)*arg2); 6298 jresult = (jfloat)result; 6299 return jresult; 6300 } 6301 6302 6303 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_inverse(JNIEnv *jenv, jclass jcls, jobject jarg1) { 6304 jobject jresult = 0 ; 6305 btQuaternion *arg1 = 0 ; 6306 btQuaternion result; 6307 6308 (void)jenv; 6309 (void)jcls; 6310 btQuaternion local_arg1; 6311 gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); 6312 arg1 = &local_arg1; 6313 gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); 6314 result = inverse((btQuaternion const &)*arg1); 6315 jresult = gdx_getReturnQuaternion(jenv); 6316 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 6317 return jresult; 6318 } 6319 6320 6321 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_slerp(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jfloat jarg3) { 6322 jobject jresult = 0 ; 6323 btQuaternion *arg1 = 0 ; 6324 btQuaternion *arg2 = 0 ; 6325 btScalar *arg3 = 0 ; 6326 btScalar temp3 ; 6327 btQuaternion result; 6328 6329 (void)jenv; 6330 (void)jcls; 6331 btQuaternion local_arg1; 6332 gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); 6333 arg1 = &local_arg1; 6334 gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); 6335 btQuaternion local_arg2; 6336 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 6337 arg2 = &local_arg2; 6338 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 6339 temp3 = (btScalar)jarg3; 6340 arg3 = &temp3; 6341 result = slerp((btQuaternion const &)*arg1,(btQuaternion const &)*arg2,(float const &)*arg3); 6342 jresult = gdx_getReturnQuaternion(jenv); 6343 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 6344 return jresult; 6345 } 6346 6347 6348 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_quatRotate(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 6349 jobject jresult = 0 ; 6350 btQuaternion *arg1 = 0 ; 6351 btVector3 *arg2 = 0 ; 6352 btVector3 result; 6353 6354 (void)jenv; 6355 (void)jcls; 6356 btQuaternion local_arg1; 6357 gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); 6358 arg1 = &local_arg1; 6359 gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); 6360 btVector3 local_arg2; 6361 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6362 arg2 = &local_arg2; 6363 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6364 result = quatRotate((btQuaternion const &)*arg1,(btVector3 const &)*arg2); 6365 jresult = gdx_getReturnVector3(jenv); 6366 gdx_setVector3FrombtVector3(jenv, jresult, result); 6367 return jresult; 6368 } 6369 6370 6371 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_shortestArcQuat(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 6372 jobject jresult = 0 ; 6373 btVector3 *arg1 = 0 ; 6374 btVector3 *arg2 = 0 ; 6375 btQuaternion result; 6376 6377 (void)jenv; 6378 (void)jcls; 6379 btVector3 local_arg1; 6380 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6381 arg1 = &local_arg1; 6382 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6383 btVector3 local_arg2; 6384 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6385 arg2 = &local_arg2; 6386 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6387 result = shortestArcQuat((btVector3 const &)*arg1,(btVector3 const &)*arg2); 6388 jresult = gdx_getReturnQuaternion(jenv); 6389 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 6390 return jresult; 6391 } 6392 6393 6394 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_shortestArcQuatNormalize2(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 6395 jobject jresult = 0 ; 6396 btVector3 *arg1 = 0 ; 6397 btVector3 *arg2 = 0 ; 6398 btQuaternion result; 6399 6400 (void)jenv; 6401 (void)jcls; 6402 btVector3 local_arg1; 6403 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6404 arg1 = &local_arg1; 6405 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6406 btVector3 local_arg2; 6407 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6408 arg2 = &local_arg2; 6409 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6410 result = shortestArcQuatNormalize2(*arg1,*arg2); 6411 jresult = gdx_getReturnQuaternion(jenv); 6412 gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); 6413 return jresult; 6414 } 6415 6416 6417 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternionFloatData_1floats_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloatArray jarg2) { 6418 btQuaternionFloatData *arg1 = (btQuaternionFloatData *) 0 ; 6419 float *arg2 ; 6420 jfloat *jarr2 ; 6421 6422 (void)jenv; 6423 (void)jcls; 6424 (void)jarg1_; 6425 arg1 = *(btQuaternionFloatData **)&jarg1; 6426 if (jarg2 && jenv->GetArrayLength(jarg2) != 4) { 6427 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 6428 return ; 6429 } 6430 if (!SWIG_JavaArrayInFloat(jenv, &jarr2, (float **)&arg2, jarg2)) return ; 6431 { 6432 size_t ii; 6433 float *b = (float *) arg1->m_floats; 6434 for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); 6435 } 6436 SWIG_JavaArrayArgoutFloat(jenv, jarr2, (float *)arg2, jarg2); 6437 delete [] arg2; 6438 } 6439 6440 6441 SWIGEXPORT jfloatArray JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternionFloatData_1floats_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6442 jfloatArray jresult = 0 ; 6443 btQuaternionFloatData *arg1 = (btQuaternionFloatData *) 0 ; 6444 float *result = 0 ; 6445 6446 (void)jenv; 6447 (void)jcls; 6448 (void)jarg1_; 6449 arg1 = *(btQuaternionFloatData **)&jarg1; 6450 result = (float *)(float *) ((arg1)->m_floats); 6451 jresult = SWIG_JavaArrayOutFloat(jenv, (float *)result, 4); 6452 return jresult; 6453 } 6454 6455 6456 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternionFloatData(JNIEnv *jenv, jclass jcls) { 6457 jlong jresult = 0 ; 6458 btQuaternionFloatData *result = 0 ; 6459 6460 (void)jenv; 6461 (void)jcls; 6462 result = (btQuaternionFloatData *)new btQuaternionFloatData(); 6463 *(btQuaternionFloatData **)&jresult = result; 6464 return jresult; 6465 } 6466 6467 6468 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btQuaternionFloatData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 6469 btQuaternionFloatData *arg1 = (btQuaternionFloatData *) 0 ; 6470 6471 (void)jenv; 6472 (void)jcls; 6473 arg1 = *(btQuaternionFloatData **)&jarg1; 6474 delete arg1; 6475 } 6476 6477 6478 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternionDoubleData_1floats_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2) { 6479 btQuaternionDoubleData *arg1 = (btQuaternionDoubleData *) 0 ; 6480 double *arg2 ; 6481 jdouble *jarr2 ; 6482 6483 (void)jenv; 6484 (void)jcls; 6485 (void)jarg1_; 6486 arg1 = *(btQuaternionDoubleData **)&jarg1; 6487 if (jarg2 && jenv->GetArrayLength(jarg2) != 4) { 6488 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 6489 return ; 6490 } 6491 if (!SWIG_JavaArrayInDouble(jenv, &jarr2, (double **)&arg2, jarg2)) return ; 6492 { 6493 size_t ii; 6494 double *b = (double *) arg1->m_floats; 6495 for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); 6496 } 6497 SWIG_JavaArrayArgoutDouble(jenv, jarr2, (double *)arg2, jarg2); 6498 delete [] arg2; 6499 } 6500 6501 6502 SWIGEXPORT jdoubleArray JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternionDoubleData_1floats_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6503 jdoubleArray jresult = 0 ; 6504 btQuaternionDoubleData *arg1 = (btQuaternionDoubleData *) 0 ; 6505 double *result = 0 ; 6506 6507 (void)jenv; 6508 (void)jcls; 6509 (void)jarg1_; 6510 arg1 = *(btQuaternionDoubleData **)&jarg1; 6511 result = (double *)(double *) ((arg1)->m_floats); 6512 jresult = SWIG_JavaArrayOutDouble(jenv, (double *)result, 4); 6513 return jresult; 6514 } 6515 6516 6517 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternionDoubleData(JNIEnv *jenv, jclass jcls) { 6518 jlong jresult = 0 ; 6519 btQuaternionDoubleData *result = 0 ; 6520 6521 (void)jenv; 6522 (void)jcls; 6523 result = (btQuaternionDoubleData *)new btQuaternionDoubleData(); 6524 *(btQuaternionDoubleData **)&jresult = result; 6525 return jresult; 6526 } 6527 6528 6529 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btQuaternionDoubleData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 6530 btQuaternionDoubleData *arg1 = (btQuaternionDoubleData *) 0 ; 6531 6532 (void)jenv; 6533 (void)jcls; 6534 arg1 = *(btQuaternionDoubleData **)&jarg1; 6535 delete arg1; 6536 } 6537 6538 6539 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_AabbExpand(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jobject jarg4) { 6540 btVector3 *arg1 = 0 ; 6541 btVector3 *arg2 = 0 ; 6542 btVector3 *arg3 = 0 ; 6543 btVector3 *arg4 = 0 ; 6544 6545 (void)jenv; 6546 (void)jcls; 6547 btVector3 local_arg1; 6548 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6549 arg1 = &local_arg1; 6550 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6551 btVector3 local_arg2; 6552 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6553 arg2 = &local_arg2; 6554 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6555 btVector3 local_arg3; 6556 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 6557 arg3 = &local_arg3; 6558 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 6559 btVector3 local_arg4; 6560 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 6561 arg4 = &local_arg4; 6562 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 6563 AabbExpand(*arg1,*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); 6564 } 6565 6566 6567 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_TestPointAgainstAabb2(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3) { 6568 jboolean jresult = 0 ; 6569 btVector3 *arg1 = 0 ; 6570 btVector3 *arg2 = 0 ; 6571 btVector3 *arg3 = 0 ; 6572 bool result; 6573 6574 (void)jenv; 6575 (void)jcls; 6576 btVector3 local_arg1; 6577 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6578 arg1 = &local_arg1; 6579 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6580 btVector3 local_arg2; 6581 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6582 arg2 = &local_arg2; 6583 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6584 btVector3 local_arg3; 6585 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 6586 arg3 = &local_arg3; 6587 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 6588 result = (bool)TestPointAgainstAabb2((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); 6589 jresult = (jboolean)result; 6590 return jresult; 6591 } 6592 6593 6594 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_TestAabbAgainstAabb2(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jobject jarg4) { 6595 jboolean jresult = 0 ; 6596 btVector3 *arg1 = 0 ; 6597 btVector3 *arg2 = 0 ; 6598 btVector3 *arg3 = 0 ; 6599 btVector3 *arg4 = 0 ; 6600 bool result; 6601 6602 (void)jenv; 6603 (void)jcls; 6604 btVector3 local_arg1; 6605 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6606 arg1 = &local_arg1; 6607 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6608 btVector3 local_arg2; 6609 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6610 arg2 = &local_arg2; 6611 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6612 btVector3 local_arg3; 6613 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 6614 arg3 = &local_arg3; 6615 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 6616 btVector3 local_arg4; 6617 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 6618 arg4 = &local_arg4; 6619 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 6620 result = (bool)TestAabbAgainstAabb2((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); 6621 jresult = (jboolean)result; 6622 return jresult; 6623 } 6624 6625 6626 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_TestTriangleAgainstAabb2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { 6627 jboolean jresult = 0 ; 6628 btVector3 *arg1 = (btVector3 *) 0 ; 6629 btVector3 *arg2 = 0 ; 6630 btVector3 *arg3 = 0 ; 6631 bool result; 6632 6633 (void)jenv; 6634 (void)jcls; 6635 (void)jarg1_; 6636 arg1 = *(btVector3 **)&jarg1; 6637 btVector3 local_arg2; 6638 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6639 arg2 = &local_arg2; 6640 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6641 btVector3 local_arg3; 6642 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 6643 arg3 = &local_arg3; 6644 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 6645 result = (bool)TestTriangleAgainstAabb2((btVector3 const *)arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); 6646 jresult = (jboolean)result; 6647 return jresult; 6648 } 6649 6650 6651 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btOutcode(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 6652 jint jresult = 0 ; 6653 btVector3 *arg1 = 0 ; 6654 btVector3 *arg2 = 0 ; 6655 int result; 6656 6657 (void)jenv; 6658 (void)jcls; 6659 btVector3 local_arg1; 6660 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6661 arg1 = &local_arg1; 6662 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6663 btVector3 local_arg2; 6664 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6665 arg2 = &local_arg2; 6666 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6667 result = (int)btOutcode((btVector3 const &)*arg1,(btVector3 const &)*arg2); 6668 jresult = (jint)result; 6669 return jresult; 6670 } 6671 6672 6673 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btRayAabb2(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlongArray jarg3, jlong jarg4, jobject jarg4_, jlong jarg5, jfloat jarg6, jfloat jarg7) { 6674 jboolean jresult = 0 ; 6675 btVector3 *arg1 = 0 ; 6676 btVector3 *arg2 = 0 ; 6677 unsigned int *arg3 ; 6678 btVector3 *arg4 ; 6679 btScalar *arg5 = 0 ; 6680 btScalar arg6 ; 6681 btScalar arg7 ; 6682 jlong *jarr3 ; 6683 bool result; 6684 6685 (void)jenv; 6686 (void)jcls; 6687 (void)jarg4_; 6688 btVector3 local_arg1; 6689 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6690 arg1 = &local_arg1; 6691 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6692 btVector3 local_arg2; 6693 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6694 arg2 = &local_arg2; 6695 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6696 if (jarg3 && jenv->GetArrayLength(jarg3) != 3) { 6697 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 6698 return 0; 6699 } 6700 if (!SWIG_JavaArrayInUint(jenv, &jarr3, (unsigned int **)&arg3, jarg3)) return 0; 6701 arg4 = *(btVector3 **)&jarg4; 6702 arg5 = *(btScalar **)&jarg5; 6703 if (!arg5) { 6704 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); 6705 return 0; 6706 } 6707 arg6 = (btScalar)jarg6; 6708 arg7 = (btScalar)jarg7; 6709 result = (bool)btRayAabb2((btVector3 const &)*arg1,(btVector3 const &)*arg2,(unsigned int const (*))arg3,(btVector3 const (*))arg4,*arg5,arg6,arg7); 6710 jresult = (jboolean)result; 6711 SWIG_JavaArrayArgoutUint(jenv, jarr3, (unsigned int *)arg3, jarg3); 6712 delete [] arg3; 6713 6714 return jresult; 6715 } 6716 6717 6718 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btRayAabb(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jobject jarg4, jlong jarg5, jobject jarg6) { 6719 jboolean jresult = 0 ; 6720 btVector3 *arg1 = 0 ; 6721 btVector3 *arg2 = 0 ; 6722 btVector3 *arg3 = 0 ; 6723 btVector3 *arg4 = 0 ; 6724 btScalar *arg5 = 0 ; 6725 btVector3 *arg6 = 0 ; 6726 bool result; 6727 6728 (void)jenv; 6729 (void)jcls; 6730 btVector3 local_arg1; 6731 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6732 arg1 = &local_arg1; 6733 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6734 btVector3 local_arg2; 6735 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6736 arg2 = &local_arg2; 6737 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6738 btVector3 local_arg3; 6739 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 6740 arg3 = &local_arg3; 6741 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 6742 btVector3 local_arg4; 6743 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 6744 arg4 = &local_arg4; 6745 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 6746 arg5 = *(btScalar **)&jarg5; 6747 if (!arg5) { 6748 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); 6749 return 0; 6750 } 6751 btVector3 local_arg6; 6752 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 6753 arg6 = &local_arg6; 6754 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 6755 result = (bool)btRayAabb((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,*arg5,*arg6); 6756 jresult = (jboolean)result; 6757 return jresult; 6758 } 6759 6760 6761 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformAabb_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jfloat jarg2, jobject jarg3, jobject jarg4, jobject jarg5) { 6762 btVector3 *arg1 = 0 ; 6763 btScalar arg2 ; 6764 btTransform *arg3 = 0 ; 6765 btVector3 *arg4 = 0 ; 6766 btVector3 *arg5 = 0 ; 6767 6768 (void)jenv; 6769 (void)jcls; 6770 btVector3 local_arg1; 6771 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6772 arg1 = &local_arg1; 6773 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6774 arg2 = (btScalar)jarg2; 6775 btTransform local_arg3; 6776 gdx_setbtTransformFromMatrix4(jenv, local_arg3, jarg3); 6777 arg3 = &local_arg3; 6778 gdxAutoCommitMatrix4 auto_commit_arg3(jenv, jarg3, &local_arg3); 6779 btVector3 local_arg4; 6780 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 6781 arg4 = &local_arg4; 6782 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 6783 btVector3 local_arg5; 6784 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 6785 arg5 = &local_arg5; 6786 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 6787 btTransformAabb((btVector3 const &)*arg1,arg2,(btTransform const &)*arg3,*arg4,*arg5); 6788 } 6789 6790 6791 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformAabb_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jfloat jarg3, jobject jarg4, jobject jarg5, jobject jarg6) { 6792 btVector3 *arg1 = 0 ; 6793 btVector3 *arg2 = 0 ; 6794 btScalar arg3 ; 6795 btTransform *arg4 = 0 ; 6796 btVector3 *arg5 = 0 ; 6797 btVector3 *arg6 = 0 ; 6798 6799 (void)jenv; 6800 (void)jcls; 6801 btVector3 local_arg1; 6802 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6803 arg1 = &local_arg1; 6804 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6805 btVector3 local_arg2; 6806 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6807 arg2 = &local_arg2; 6808 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6809 arg3 = (btScalar)jarg3; 6810 btTransform local_arg4; 6811 gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); 6812 arg4 = &local_arg4; 6813 gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); 6814 btVector3 local_arg5; 6815 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 6816 arg5 = &local_arg5; 6817 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 6818 btVector3 local_arg6; 6819 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 6820 arg6 = &local_arg6; 6821 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 6822 btTransformAabb((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,*arg5,*arg6); 6823 } 6824 6825 6826 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_testQuantizedAabbAgainstQuantizedAabb(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jobject jarg4) { 6827 jlong jresult = 0 ; 6828 unsigned short *arg1 = (unsigned short *) 0 ; 6829 unsigned short *arg2 = (unsigned short *) 0 ; 6830 unsigned short *arg3 = (unsigned short *) 0 ; 6831 unsigned short *arg4 = (unsigned short *) 0 ; 6832 unsigned int result; 6833 6834 (void)jenv; 6835 (void)jcls; 6836 { 6837 arg1 = (unsigned short*)jenv->GetDirectBufferAddress(jarg1); 6838 if (arg1 == NULL) { 6839 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 6840 } 6841 } 6842 { 6843 arg2 = (unsigned short*)jenv->GetDirectBufferAddress(jarg2); 6844 if (arg2 == NULL) { 6845 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 6846 } 6847 } 6848 { 6849 arg3 = (unsigned short*)jenv->GetDirectBufferAddress(jarg3); 6850 if (arg3 == NULL) { 6851 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 6852 } 6853 } 6854 { 6855 arg4 = (unsigned short*)jenv->GetDirectBufferAddress(jarg4); 6856 if (arg4 == NULL) { 6857 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 6858 } 6859 } 6860 result = (unsigned int)testQuantizedAabbAgainstQuantizedAabb((unsigned short const *)arg1,(unsigned short const *)arg2,(unsigned short const *)arg3,(unsigned short const *)arg4); 6861 jresult = (jlong)result; 6862 6863 6864 6865 6866 return jresult; 6867 } 6868 6869 6870 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1activeObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6871 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 6872 btVector3 *arg2 = (btVector3 *) 0 ; 6873 6874 (void)jenv; 6875 (void)jcls; 6876 (void)jarg1_; 6877 (void)jarg2_; 6878 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 6879 arg2 = *(btVector3 **)&jarg2; 6880 if (arg1) (arg1)->m_activeObject = *arg2; 6881 } 6882 6883 6884 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1activeObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6885 jlong jresult = 0 ; 6886 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 6887 btVector3 *result = 0 ; 6888 6889 (void)jenv; 6890 (void)jcls; 6891 (void)jarg1_; 6892 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 6893 result = (btVector3 *)& ((arg1)->m_activeObject); 6894 *(btVector3 **)&jresult = result; 6895 return jresult; 6896 } 6897 6898 6899 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1deactivatedObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6900 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 6901 btVector3 *arg2 = (btVector3 *) 0 ; 6902 6903 (void)jenv; 6904 (void)jcls; 6905 (void)jarg1_; 6906 (void)jarg2_; 6907 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 6908 arg2 = *(btVector3 **)&jarg2; 6909 if (arg1) (arg1)->m_deactivatedObject = *arg2; 6910 } 6911 6912 6913 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1deactivatedObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6914 jlong jresult = 0 ; 6915 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 6916 btVector3 *result = 0 ; 6917 6918 (void)jenv; 6919 (void)jcls; 6920 (void)jarg1_; 6921 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 6922 result = (btVector3 *)& ((arg1)->m_deactivatedObject); 6923 *(btVector3 **)&jresult = result; 6924 return jresult; 6925 } 6926 6927 6928 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1wantsDeactivationObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6929 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 6930 btVector3 *arg2 = (btVector3 *) 0 ; 6931 6932 (void)jenv; 6933 (void)jcls; 6934 (void)jarg1_; 6935 (void)jarg2_; 6936 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 6937 arg2 = *(btVector3 **)&jarg2; 6938 if (arg1) (arg1)->m_wantsDeactivationObject = *arg2; 6939 } 6940 6941 6942 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1wantsDeactivationObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6943 jlong jresult = 0 ; 6944 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 6945 btVector3 *result = 0 ; 6946 6947 (void)jenv; 6948 (void)jcls; 6949 (void)jarg1_; 6950 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 6951 result = (btVector3 *)& ((arg1)->m_wantsDeactivationObject); 6952 *(btVector3 **)&jresult = result; 6953 return jresult; 6954 } 6955 6956 6957 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1disabledDeactivationObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6958 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 6959 btVector3 *arg2 = (btVector3 *) 0 ; 6960 6961 (void)jenv; 6962 (void)jcls; 6963 (void)jarg1_; 6964 (void)jarg2_; 6965 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 6966 arg2 = *(btVector3 **)&jarg2; 6967 if (arg1) (arg1)->m_disabledDeactivationObject = *arg2; 6968 } 6969 6970 6971 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1disabledDeactivationObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6972 jlong jresult = 0 ; 6973 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 6974 btVector3 *result = 0 ; 6975 6976 (void)jenv; 6977 (void)jcls; 6978 (void)jarg1_; 6979 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 6980 result = (btVector3 *)& ((arg1)->m_disabledDeactivationObject); 6981 *(btVector3 **)&jresult = result; 6982 return jresult; 6983 } 6984 6985 6986 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1disabledSimulationObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6987 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 6988 btVector3 *arg2 = (btVector3 *) 0 ; 6989 6990 (void)jenv; 6991 (void)jcls; 6992 (void)jarg1_; 6993 (void)jarg2_; 6994 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 6995 arg2 = *(btVector3 **)&jarg2; 6996 if (arg1) (arg1)->m_disabledSimulationObject = *arg2; 6997 } 6998 6999 7000 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1disabledSimulationObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7001 jlong jresult = 0 ; 7002 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 7003 btVector3 *result = 0 ; 7004 7005 (void)jenv; 7006 (void)jcls; 7007 (void)jarg1_; 7008 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 7009 result = (btVector3 *)& ((arg1)->m_disabledSimulationObject); 7010 *(btVector3 **)&jresult = result; 7011 return jresult; 7012 } 7013 7014 7015 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1aabb_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 7016 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 7017 btVector3 *arg2 = (btVector3 *) 0 ; 7018 7019 (void)jenv; 7020 (void)jcls; 7021 (void)jarg1_; 7022 (void)jarg2_; 7023 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 7024 arg2 = *(btVector3 **)&jarg2; 7025 if (arg1) (arg1)->m_aabb = *arg2; 7026 } 7027 7028 7029 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1aabb_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7030 jlong jresult = 0 ; 7031 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 7032 btVector3 *result = 0 ; 7033 7034 (void)jenv; 7035 (void)jcls; 7036 (void)jarg1_; 7037 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 7038 result = (btVector3 *)& ((arg1)->m_aabb); 7039 *(btVector3 **)&jresult = result; 7040 return jresult; 7041 } 7042 7043 7044 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1contactPoint_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 7045 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 7046 btVector3 *arg2 = (btVector3 *) 0 ; 7047 7048 (void)jenv; 7049 (void)jcls; 7050 (void)jarg1_; 7051 (void)jarg2_; 7052 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 7053 arg2 = *(btVector3 **)&jarg2; 7054 if (arg1) (arg1)->m_contactPoint = *arg2; 7055 } 7056 7057 7058 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1contactPoint_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7059 jlong jresult = 0 ; 7060 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 7061 btVector3 *result = 0 ; 7062 7063 (void)jenv; 7064 (void)jcls; 7065 (void)jarg1_; 7066 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 7067 result = (btVector3 *)& ((arg1)->m_contactPoint); 7068 *(btVector3 **)&jresult = result; 7069 return jresult; 7070 } 7071 7072 7073 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btIDebugDraw_1DefaultColors(JNIEnv *jenv, jclass jcls) { 7074 jlong jresult = 0 ; 7075 btIDebugDraw::DefaultColors *result = 0 ; 7076 7077 (void)jenv; 7078 (void)jcls; 7079 result = (btIDebugDraw::DefaultColors *)new btIDebugDraw::DefaultColors(); 7080 *(btIDebugDraw::DefaultColors **)&jresult = result; 7081 return jresult; 7082 } 7083 7084 7085 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btIDebugDraw_1DefaultColors(JNIEnv *jenv, jclass jcls, jlong jarg1) { 7086 btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; 7087 7088 (void)jenv; 7089 (void)jcls; 7090 arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; 7091 delete arg1; 7092 } 7093 7094 7095 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1) { 7096 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7097 7098 (void)jenv; 7099 (void)jcls; 7100 arg1 = *(btIDebugDraw **)&jarg1; 7101 delete arg1; 7102 } 7103 7104 7105 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1getDefaultColors(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7106 jlong jresult = 0 ; 7107 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7108 btIDebugDraw::DefaultColors result; 7109 7110 (void)jenv; 7111 (void)jcls; 7112 (void)jarg1_; 7113 arg1 = *(btIDebugDraw **)&jarg1; 7114 result = ((btIDebugDraw const *)arg1)->getDefaultColors(); 7115 *(btIDebugDraw::DefaultColors **)&jresult = new btIDebugDraw::DefaultColors((const btIDebugDraw::DefaultColors &)result); 7116 return jresult; 7117 } 7118 7119 7120 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1getDefaultColorsSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7121 jlong jresult = 0 ; 7122 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7123 btIDebugDraw::DefaultColors result; 7124 7125 (void)jenv; 7126 (void)jcls; 7127 (void)jarg1_; 7128 arg1 = *(btIDebugDraw **)&jarg1; 7129 result = ((btIDebugDraw const *)arg1)->btIDebugDraw::getDefaultColors(); 7130 *(btIDebugDraw::DefaultColors **)&jresult = new btIDebugDraw::DefaultColors((const btIDebugDraw::DefaultColors &)result); 7131 return jresult; 7132 } 7133 7134 7135 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1setDefaultColors(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 7136 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7137 btIDebugDraw::DefaultColors *arg2 = 0 ; 7138 7139 (void)jenv; 7140 (void)jcls; 7141 (void)jarg1_; 7142 (void)jarg2_; 7143 arg1 = *(btIDebugDraw **)&jarg1; 7144 arg2 = *(btIDebugDraw::DefaultColors **)&jarg2; 7145 if (!arg2) { 7146 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btIDebugDraw::DefaultColors const & reference is null"); 7147 return ; 7148 } 7149 (arg1)->setDefaultColors((btIDebugDraw::DefaultColors const &)*arg2); 7150 } 7151 7152 7153 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1setDefaultColorsSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 7154 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7155 btIDebugDraw::DefaultColors *arg2 = 0 ; 7156 7157 (void)jenv; 7158 (void)jcls; 7159 (void)jarg1_; 7160 (void)jarg2_; 7161 arg1 = *(btIDebugDraw **)&jarg1; 7162 arg2 = *(btIDebugDraw::DefaultColors **)&jarg2; 7163 if (!arg2) { 7164 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btIDebugDraw::DefaultColors const & reference is null"); 7165 return ; 7166 } 7167 (arg1)->btIDebugDraw::setDefaultColors((btIDebugDraw::DefaultColors const &)*arg2); 7168 } 7169 7170 7171 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawLine_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { 7172 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7173 btVector3 *arg2 = 0 ; 7174 btVector3 *arg3 = 0 ; 7175 btVector3 *arg4 = 0 ; 7176 7177 (void)jenv; 7178 (void)jcls; 7179 (void)jarg1_; 7180 arg1 = *(btIDebugDraw **)&jarg1; 7181 btVector3 local_arg2; 7182 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7183 arg2 = &local_arg2; 7184 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7185 btVector3 local_arg3; 7186 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7187 arg3 = &local_arg3; 7188 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7189 btVector3 local_arg4; 7190 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7191 arg4 = &local_arg4; 7192 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7193 (arg1)->drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); 7194 } 7195 7196 7197 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawLine_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5) { 7198 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7199 btVector3 *arg2 = 0 ; 7200 btVector3 *arg3 = 0 ; 7201 btVector3 *arg4 = 0 ; 7202 btVector3 *arg5 = 0 ; 7203 7204 (void)jenv; 7205 (void)jcls; 7206 (void)jarg1_; 7207 arg1 = *(btIDebugDraw **)&jarg1; 7208 btVector3 local_arg2; 7209 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7210 arg2 = &local_arg2; 7211 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7212 btVector3 local_arg3; 7213 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7214 arg3 = &local_arg3; 7215 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7216 btVector3 local_arg4; 7217 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7218 arg4 = &local_arg4; 7219 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7220 btVector3 local_arg5; 7221 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 7222 arg5 = &local_arg5; 7223 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 7224 (arg1)->drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5); 7225 } 7226 7227 7228 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawLineSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5) { 7229 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7230 btVector3 *arg2 = 0 ; 7231 btVector3 *arg3 = 0 ; 7232 btVector3 *arg4 = 0 ; 7233 btVector3 *arg5 = 0 ; 7234 7235 (void)jenv; 7236 (void)jcls; 7237 (void)jarg1_; 7238 arg1 = *(btIDebugDraw **)&jarg1; 7239 btVector3 local_arg2; 7240 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7241 arg2 = &local_arg2; 7242 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7243 btVector3 local_arg3; 7244 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7245 arg3 = &local_arg3; 7246 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7247 btVector3 local_arg4; 7248 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7249 arg4 = &local_arg4; 7250 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7251 btVector3 local_arg5; 7252 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 7253 arg5 = &local_arg5; 7254 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 7255 (arg1)->btIDebugDraw::drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5); 7256 } 7257 7258 7259 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSphere_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jobject jarg3, jobject jarg4) { 7260 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7261 btScalar arg2 ; 7262 btTransform *arg3 = 0 ; 7263 btVector3 *arg4 = 0 ; 7264 7265 (void)jenv; 7266 (void)jcls; 7267 (void)jarg1_; 7268 arg1 = *(btIDebugDraw **)&jarg1; 7269 arg2 = (btScalar)jarg2; 7270 btTransform local_arg3; 7271 gdx_setbtTransformFromMatrix4(jenv, local_arg3, jarg3); 7272 arg3 = &local_arg3; 7273 gdxAutoCommitMatrix4 auto_commit_arg3(jenv, jarg3, &local_arg3); 7274 btVector3 local_arg4; 7275 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7276 arg4 = &local_arg4; 7277 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7278 (arg1)->drawSphere(arg2,(btTransform const &)*arg3,(btVector3 const &)*arg4); 7279 } 7280 7281 7282 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSphereSwigExplicitbtIDebugDraw_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jobject jarg3, jobject jarg4) { 7283 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7284 btScalar arg2 ; 7285 btTransform *arg3 = 0 ; 7286 btVector3 *arg4 = 0 ; 7287 7288 (void)jenv; 7289 (void)jcls; 7290 (void)jarg1_; 7291 arg1 = *(btIDebugDraw **)&jarg1; 7292 arg2 = (btScalar)jarg2; 7293 btTransform local_arg3; 7294 gdx_setbtTransformFromMatrix4(jenv, local_arg3, jarg3); 7295 arg3 = &local_arg3; 7296 gdxAutoCommitMatrix4 auto_commit_arg3(jenv, jarg3, &local_arg3); 7297 btVector3 local_arg4; 7298 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7299 arg4 = &local_arg4; 7300 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7301 (arg1)->btIDebugDraw::drawSphere(arg2,(btTransform const &)*arg3,(btVector3 const &)*arg4); 7302 } 7303 7304 7305 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSphere_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3, jobject jarg4) { 7306 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7307 btVector3 *arg2 = 0 ; 7308 btScalar arg3 ; 7309 btVector3 *arg4 = 0 ; 7310 7311 (void)jenv; 7312 (void)jcls; 7313 (void)jarg1_; 7314 arg1 = *(btIDebugDraw **)&jarg1; 7315 btVector3 local_arg2; 7316 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7317 arg2 = &local_arg2; 7318 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7319 arg3 = (btScalar)jarg3; 7320 btVector3 local_arg4; 7321 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7322 arg4 = &local_arg4; 7323 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7324 (arg1)->drawSphere((btVector3 const &)*arg2,arg3,(btVector3 const &)*arg4); 7325 } 7326 7327 7328 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSphereSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3, jobject jarg4) { 7329 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7330 btVector3 *arg2 = 0 ; 7331 btScalar arg3 ; 7332 btVector3 *arg4 = 0 ; 7333 7334 (void)jenv; 7335 (void)jcls; 7336 (void)jarg1_; 7337 arg1 = *(btIDebugDraw **)&jarg1; 7338 btVector3 local_arg2; 7339 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7340 arg2 = &local_arg2; 7341 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7342 arg3 = (btScalar)jarg3; 7343 btVector3 local_arg4; 7344 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7345 arg4 = &local_arg4; 7346 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7347 (arg1)->btIDebugDraw::drawSphere((btVector3 const &)*arg2,arg3,(btVector3 const &)*arg4); 7348 } 7349 7350 7351 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTriangle_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5, jobject jarg6, jobject jarg7, jobject jarg8, jfloat jarg9) { 7352 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7353 btVector3 *arg2 = 0 ; 7354 btVector3 *arg3 = 0 ; 7355 btVector3 *arg4 = 0 ; 7356 btVector3 *arg5 = 0 ; 7357 btVector3 *arg6 = 0 ; 7358 btVector3 *arg7 = 0 ; 7359 btVector3 *arg8 = 0 ; 7360 btScalar arg9 ; 7361 7362 (void)jenv; 7363 (void)jcls; 7364 (void)jarg1_; 7365 arg1 = *(btIDebugDraw **)&jarg1; 7366 btVector3 local_arg2; 7367 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7368 arg2 = &local_arg2; 7369 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7370 btVector3 local_arg3; 7371 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7372 arg3 = &local_arg3; 7373 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7374 btVector3 local_arg4; 7375 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7376 arg4 = &local_arg4; 7377 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7378 btVector3 local_arg5; 7379 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 7380 arg5 = &local_arg5; 7381 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 7382 btVector3 local_arg6; 7383 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 7384 arg6 = &local_arg6; 7385 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 7386 btVector3 local_arg7; 7387 gdx_setbtVector3FromVector3(jenv, local_arg7, jarg7); 7388 arg7 = &local_arg7; 7389 gdxAutoCommitVector3 auto_commit_arg7(jenv, jarg7, &local_arg7); 7390 btVector3 local_arg8; 7391 gdx_setbtVector3FromVector3(jenv, local_arg8, jarg8); 7392 arg8 = &local_arg8; 7393 gdxAutoCommitVector3 auto_commit_arg8(jenv, jarg8, &local_arg8); 7394 arg9 = (btScalar)jarg9; 7395 (arg1)->drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8,arg9); 7396 } 7397 7398 7399 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTriangleSwigExplicitbtIDebugDraw_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5, jobject jarg6, jobject jarg7, jobject jarg8, jfloat jarg9) { 7400 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7401 btVector3 *arg2 = 0 ; 7402 btVector3 *arg3 = 0 ; 7403 btVector3 *arg4 = 0 ; 7404 btVector3 *arg5 = 0 ; 7405 btVector3 *arg6 = 0 ; 7406 btVector3 *arg7 = 0 ; 7407 btVector3 *arg8 = 0 ; 7408 btScalar arg9 ; 7409 7410 (void)jenv; 7411 (void)jcls; 7412 (void)jarg1_; 7413 arg1 = *(btIDebugDraw **)&jarg1; 7414 btVector3 local_arg2; 7415 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7416 arg2 = &local_arg2; 7417 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7418 btVector3 local_arg3; 7419 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7420 arg3 = &local_arg3; 7421 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7422 btVector3 local_arg4; 7423 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7424 arg4 = &local_arg4; 7425 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7426 btVector3 local_arg5; 7427 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 7428 arg5 = &local_arg5; 7429 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 7430 btVector3 local_arg6; 7431 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 7432 arg6 = &local_arg6; 7433 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 7434 btVector3 local_arg7; 7435 gdx_setbtVector3FromVector3(jenv, local_arg7, jarg7); 7436 arg7 = &local_arg7; 7437 gdxAutoCommitVector3 auto_commit_arg7(jenv, jarg7, &local_arg7); 7438 btVector3 local_arg8; 7439 gdx_setbtVector3FromVector3(jenv, local_arg8, jarg8); 7440 arg8 = &local_arg8; 7441 gdxAutoCommitVector3 auto_commit_arg8(jenv, jarg8, &local_arg8); 7442 arg9 = (btScalar)jarg9; 7443 (arg1)->btIDebugDraw::drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8,arg9); 7444 } 7445 7446 7447 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTriangle_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5, jfloat jarg6) { 7448 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7449 btVector3 *arg2 = 0 ; 7450 btVector3 *arg3 = 0 ; 7451 btVector3 *arg4 = 0 ; 7452 btVector3 *arg5 = 0 ; 7453 btScalar arg6 ; 7454 7455 (void)jenv; 7456 (void)jcls; 7457 (void)jarg1_; 7458 arg1 = *(btIDebugDraw **)&jarg1; 7459 btVector3 local_arg2; 7460 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7461 arg2 = &local_arg2; 7462 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7463 btVector3 local_arg3; 7464 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7465 arg3 = &local_arg3; 7466 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7467 btVector3 local_arg4; 7468 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7469 arg4 = &local_arg4; 7470 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7471 btVector3 local_arg5; 7472 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 7473 arg5 = &local_arg5; 7474 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 7475 arg6 = (btScalar)jarg6; 7476 (arg1)->drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,arg6); 7477 } 7478 7479 7480 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTriangleSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5, jfloat jarg6) { 7481 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7482 btVector3 *arg2 = 0 ; 7483 btVector3 *arg3 = 0 ; 7484 btVector3 *arg4 = 0 ; 7485 btVector3 *arg5 = 0 ; 7486 btScalar arg6 ; 7487 7488 (void)jenv; 7489 (void)jcls; 7490 (void)jarg1_; 7491 arg1 = *(btIDebugDraw **)&jarg1; 7492 btVector3 local_arg2; 7493 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7494 arg2 = &local_arg2; 7495 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7496 btVector3 local_arg3; 7497 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7498 arg3 = &local_arg3; 7499 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7500 btVector3 local_arg4; 7501 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7502 arg4 = &local_arg4; 7503 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7504 btVector3 local_arg5; 7505 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 7506 arg5 = &local_arg5; 7507 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 7508 arg6 = (btScalar)jarg6; 7509 (arg1)->btIDebugDraw::drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,arg6); 7510 } 7511 7512 7513 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawContactPoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jfloat jarg4, jint jarg5, jobject jarg6) { 7514 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7515 btVector3 *arg2 = 0 ; 7516 btVector3 *arg3 = 0 ; 7517 btScalar arg4 ; 7518 int arg5 ; 7519 btVector3 *arg6 = 0 ; 7520 7521 (void)jenv; 7522 (void)jcls; 7523 (void)jarg1_; 7524 arg1 = *(btIDebugDraw **)&jarg1; 7525 btVector3 local_arg2; 7526 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7527 arg2 = &local_arg2; 7528 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7529 btVector3 local_arg3; 7530 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7531 arg3 = &local_arg3; 7532 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7533 arg4 = (btScalar)jarg4; 7534 arg5 = (int)jarg5; 7535 btVector3 local_arg6; 7536 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 7537 arg6 = &local_arg6; 7538 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 7539 (arg1)->drawContactPoint((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5,(btVector3 const &)*arg6); 7540 } 7541 7542 7543 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1reportErrorWarning(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 7544 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7545 char *arg2 = (char *) 0 ; 7546 7547 (void)jenv; 7548 (void)jcls; 7549 (void)jarg1_; 7550 arg1 = *(btIDebugDraw **)&jarg1; 7551 arg2 = 0; 7552 if (jarg2) { 7553 arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); 7554 if (!arg2) return ; 7555 } 7556 (arg1)->reportErrorWarning((char const *)arg2); 7557 if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); 7558 } 7559 7560 7561 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1draw3dText(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jstring jarg3) { 7562 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7563 btVector3 *arg2 = 0 ; 7564 char *arg3 = (char *) 0 ; 7565 7566 (void)jenv; 7567 (void)jcls; 7568 (void)jarg1_; 7569 arg1 = *(btIDebugDraw **)&jarg1; 7570 btVector3 local_arg2; 7571 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7572 arg2 = &local_arg2; 7573 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7574 arg3 = 0; 7575 if (jarg3) { 7576 arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); 7577 if (!arg3) return ; 7578 } 7579 (arg1)->draw3dText((btVector3 const &)*arg2,(char const *)arg3); 7580 if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); 7581 } 7582 7583 7584 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1setDebugMode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 7585 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7586 int arg2 ; 7587 7588 (void)jenv; 7589 (void)jcls; 7590 (void)jarg1_; 7591 arg1 = *(btIDebugDraw **)&jarg1; 7592 arg2 = (int)jarg2; 7593 (arg1)->setDebugMode(arg2); 7594 } 7595 7596 7597 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1getDebugMode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7598 jint jresult = 0 ; 7599 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7600 int result; 7601 7602 (void)jenv; 7603 (void)jcls; 7604 (void)jarg1_; 7605 arg1 = *(btIDebugDraw **)&jarg1; 7606 result = (int)((btIDebugDraw const *)arg1)->getDebugMode(); 7607 jresult = (jint)result; 7608 return jresult; 7609 } 7610 7611 7612 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawAabb(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { 7613 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7614 btVector3 *arg2 = 0 ; 7615 btVector3 *arg3 = 0 ; 7616 btVector3 *arg4 = 0 ; 7617 7618 (void)jenv; 7619 (void)jcls; 7620 (void)jarg1_; 7621 arg1 = *(btIDebugDraw **)&jarg1; 7622 btVector3 local_arg2; 7623 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7624 arg2 = &local_arg2; 7625 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7626 btVector3 local_arg3; 7627 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7628 arg3 = &local_arg3; 7629 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7630 btVector3 local_arg4; 7631 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7632 arg4 = &local_arg4; 7633 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7634 (arg1)->drawAabb((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); 7635 } 7636 7637 7638 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawAabbSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { 7639 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7640 btVector3 *arg2 = 0 ; 7641 btVector3 *arg3 = 0 ; 7642 btVector3 *arg4 = 0 ; 7643 7644 (void)jenv; 7645 (void)jcls; 7646 (void)jarg1_; 7647 arg1 = *(btIDebugDraw **)&jarg1; 7648 btVector3 local_arg2; 7649 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7650 arg2 = &local_arg2; 7651 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7652 btVector3 local_arg3; 7653 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7654 arg3 = &local_arg3; 7655 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7656 btVector3 local_arg4; 7657 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7658 arg4 = &local_arg4; 7659 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7660 (arg1)->btIDebugDraw::drawAabb((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); 7661 } 7662 7663 7664 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTransform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { 7665 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7666 btTransform *arg2 = 0 ; 7667 btScalar arg3 ; 7668 7669 (void)jenv; 7670 (void)jcls; 7671 (void)jarg1_; 7672 arg1 = *(btIDebugDraw **)&jarg1; 7673 btTransform local_arg2; 7674 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 7675 arg2 = &local_arg2; 7676 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 7677 arg3 = (btScalar)jarg3; 7678 (arg1)->drawTransform((btTransform const &)*arg2,arg3); 7679 } 7680 7681 7682 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTransformSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { 7683 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7684 btTransform *arg2 = 0 ; 7685 btScalar arg3 ; 7686 7687 (void)jenv; 7688 (void)jcls; 7689 (void)jarg1_; 7690 arg1 = *(btIDebugDraw **)&jarg1; 7691 btTransform local_arg2; 7692 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 7693 arg2 = &local_arg2; 7694 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 7695 arg3 = (btScalar)jarg3; 7696 (arg1)->btIDebugDraw::drawTransform((btTransform const &)*arg2,arg3); 7697 } 7698 7699 7700 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawArc_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jobject jarg9, jboolean jarg10, jfloat jarg11) { 7701 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7702 btVector3 *arg2 = 0 ; 7703 btVector3 *arg3 = 0 ; 7704 btVector3 *arg4 = 0 ; 7705 btScalar arg5 ; 7706 btScalar arg6 ; 7707 btScalar arg7 ; 7708 btScalar arg8 ; 7709 btVector3 *arg9 = 0 ; 7710 bool arg10 ; 7711 btScalar arg11 ; 7712 7713 (void)jenv; 7714 (void)jcls; 7715 (void)jarg1_; 7716 arg1 = *(btIDebugDraw **)&jarg1; 7717 btVector3 local_arg2; 7718 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7719 arg2 = &local_arg2; 7720 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7721 btVector3 local_arg3; 7722 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7723 arg3 = &local_arg3; 7724 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7725 btVector3 local_arg4; 7726 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7727 arg4 = &local_arg4; 7728 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7729 arg5 = (btScalar)jarg5; 7730 arg6 = (btScalar)jarg6; 7731 arg7 = (btScalar)jarg7; 7732 arg8 = (btScalar)jarg8; 7733 btVector3 local_arg9; 7734 gdx_setbtVector3FromVector3(jenv, local_arg9, jarg9); 7735 arg9 = &local_arg9; 7736 gdxAutoCommitVector3 auto_commit_arg9(jenv, jarg9, &local_arg9); 7737 arg10 = jarg10 ? true : false; 7738 arg11 = (btScalar)jarg11; 7739 (arg1)->drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10,arg11); 7740 } 7741 7742 7743 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawArcSwigExplicitbtIDebugDraw_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jobject jarg9, jboolean jarg10, jfloat jarg11) { 7744 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7745 btVector3 *arg2 = 0 ; 7746 btVector3 *arg3 = 0 ; 7747 btVector3 *arg4 = 0 ; 7748 btScalar arg5 ; 7749 btScalar arg6 ; 7750 btScalar arg7 ; 7751 btScalar arg8 ; 7752 btVector3 *arg9 = 0 ; 7753 bool arg10 ; 7754 btScalar arg11 ; 7755 7756 (void)jenv; 7757 (void)jcls; 7758 (void)jarg1_; 7759 arg1 = *(btIDebugDraw **)&jarg1; 7760 btVector3 local_arg2; 7761 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7762 arg2 = &local_arg2; 7763 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7764 btVector3 local_arg3; 7765 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7766 arg3 = &local_arg3; 7767 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7768 btVector3 local_arg4; 7769 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7770 arg4 = &local_arg4; 7771 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7772 arg5 = (btScalar)jarg5; 7773 arg6 = (btScalar)jarg6; 7774 arg7 = (btScalar)jarg7; 7775 arg8 = (btScalar)jarg8; 7776 btVector3 local_arg9; 7777 gdx_setbtVector3FromVector3(jenv, local_arg9, jarg9); 7778 arg9 = &local_arg9; 7779 gdxAutoCommitVector3 auto_commit_arg9(jenv, jarg9, &local_arg9); 7780 arg10 = jarg10 ? true : false; 7781 arg11 = (btScalar)jarg11; 7782 (arg1)->btIDebugDraw::drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10,arg11); 7783 } 7784 7785 7786 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawArc_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jobject jarg9, jboolean jarg10) { 7787 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7788 btVector3 *arg2 = 0 ; 7789 btVector3 *arg3 = 0 ; 7790 btVector3 *arg4 = 0 ; 7791 btScalar arg5 ; 7792 btScalar arg6 ; 7793 btScalar arg7 ; 7794 btScalar arg8 ; 7795 btVector3 *arg9 = 0 ; 7796 bool arg10 ; 7797 7798 (void)jenv; 7799 (void)jcls; 7800 (void)jarg1_; 7801 arg1 = *(btIDebugDraw **)&jarg1; 7802 btVector3 local_arg2; 7803 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7804 arg2 = &local_arg2; 7805 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7806 btVector3 local_arg3; 7807 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7808 arg3 = &local_arg3; 7809 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7810 btVector3 local_arg4; 7811 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7812 arg4 = &local_arg4; 7813 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7814 arg5 = (btScalar)jarg5; 7815 arg6 = (btScalar)jarg6; 7816 arg7 = (btScalar)jarg7; 7817 arg8 = (btScalar)jarg8; 7818 btVector3 local_arg9; 7819 gdx_setbtVector3FromVector3(jenv, local_arg9, jarg9); 7820 arg9 = &local_arg9; 7821 gdxAutoCommitVector3 auto_commit_arg9(jenv, jarg9, &local_arg9); 7822 arg10 = jarg10 ? true : false; 7823 (arg1)->drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10); 7824 } 7825 7826 7827 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawArcSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jobject jarg9, jboolean jarg10) { 7828 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7829 btVector3 *arg2 = 0 ; 7830 btVector3 *arg3 = 0 ; 7831 btVector3 *arg4 = 0 ; 7832 btScalar arg5 ; 7833 btScalar arg6 ; 7834 btScalar arg7 ; 7835 btScalar arg8 ; 7836 btVector3 *arg9 = 0 ; 7837 bool arg10 ; 7838 7839 (void)jenv; 7840 (void)jcls; 7841 (void)jarg1_; 7842 arg1 = *(btIDebugDraw **)&jarg1; 7843 btVector3 local_arg2; 7844 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7845 arg2 = &local_arg2; 7846 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7847 btVector3 local_arg3; 7848 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7849 arg3 = &local_arg3; 7850 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7851 btVector3 local_arg4; 7852 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7853 arg4 = &local_arg4; 7854 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7855 arg5 = (btScalar)jarg5; 7856 arg6 = (btScalar)jarg6; 7857 arg7 = (btScalar)jarg7; 7858 arg8 = (btScalar)jarg8; 7859 btVector3 local_arg9; 7860 gdx_setbtVector3FromVector3(jenv, local_arg9, jarg9); 7861 arg9 = &local_arg9; 7862 gdxAutoCommitVector3 auto_commit_arg9(jenv, jarg9, &local_arg9); 7863 arg10 = jarg10 ? true : false; 7864 (arg1)->btIDebugDraw::drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10); 7865 } 7866 7867 7868 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatch_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10, jfloat jarg11, jboolean jarg12) { 7869 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7870 btVector3 *arg2 = 0 ; 7871 btVector3 *arg3 = 0 ; 7872 btVector3 *arg4 = 0 ; 7873 btScalar arg5 ; 7874 btScalar arg6 ; 7875 btScalar arg7 ; 7876 btScalar arg8 ; 7877 btScalar arg9 ; 7878 btVector3 *arg10 = 0 ; 7879 btScalar arg11 ; 7880 bool arg12 ; 7881 7882 (void)jenv; 7883 (void)jcls; 7884 (void)jarg1_; 7885 arg1 = *(btIDebugDraw **)&jarg1; 7886 btVector3 local_arg2; 7887 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7888 arg2 = &local_arg2; 7889 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7890 btVector3 local_arg3; 7891 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7892 arg3 = &local_arg3; 7893 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7894 btVector3 local_arg4; 7895 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7896 arg4 = &local_arg4; 7897 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7898 arg5 = (btScalar)jarg5; 7899 arg6 = (btScalar)jarg6; 7900 arg7 = (btScalar)jarg7; 7901 arg8 = (btScalar)jarg8; 7902 arg9 = (btScalar)jarg9; 7903 btVector3 local_arg10; 7904 gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); 7905 arg10 = &local_arg10; 7906 gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); 7907 arg11 = (btScalar)jarg11; 7908 arg12 = jarg12 ? true : false; 7909 (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11,arg12); 7910 } 7911 7912 7913 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatchSwigExplicitbtIDebugDraw_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10, jfloat jarg11, jboolean jarg12) { 7914 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7915 btVector3 *arg2 = 0 ; 7916 btVector3 *arg3 = 0 ; 7917 btVector3 *arg4 = 0 ; 7918 btScalar arg5 ; 7919 btScalar arg6 ; 7920 btScalar arg7 ; 7921 btScalar arg8 ; 7922 btScalar arg9 ; 7923 btVector3 *arg10 = 0 ; 7924 btScalar arg11 ; 7925 bool arg12 ; 7926 7927 (void)jenv; 7928 (void)jcls; 7929 (void)jarg1_; 7930 arg1 = *(btIDebugDraw **)&jarg1; 7931 btVector3 local_arg2; 7932 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7933 arg2 = &local_arg2; 7934 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7935 btVector3 local_arg3; 7936 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7937 arg3 = &local_arg3; 7938 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7939 btVector3 local_arg4; 7940 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7941 arg4 = &local_arg4; 7942 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7943 arg5 = (btScalar)jarg5; 7944 arg6 = (btScalar)jarg6; 7945 arg7 = (btScalar)jarg7; 7946 arg8 = (btScalar)jarg8; 7947 arg9 = (btScalar)jarg9; 7948 btVector3 local_arg10; 7949 gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); 7950 arg10 = &local_arg10; 7951 gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); 7952 arg11 = (btScalar)jarg11; 7953 arg12 = jarg12 ? true : false; 7954 (arg1)->btIDebugDraw::drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11,arg12); 7955 } 7956 7957 7958 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatch_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10, jfloat jarg11) { 7959 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 7960 btVector3 *arg2 = 0 ; 7961 btVector3 *arg3 = 0 ; 7962 btVector3 *arg4 = 0 ; 7963 btScalar arg5 ; 7964 btScalar arg6 ; 7965 btScalar arg7 ; 7966 btScalar arg8 ; 7967 btScalar arg9 ; 7968 btVector3 *arg10 = 0 ; 7969 btScalar arg11 ; 7970 7971 (void)jenv; 7972 (void)jcls; 7973 (void)jarg1_; 7974 arg1 = *(btIDebugDraw **)&jarg1; 7975 btVector3 local_arg2; 7976 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7977 arg2 = &local_arg2; 7978 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7979 btVector3 local_arg3; 7980 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7981 arg3 = &local_arg3; 7982 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7983 btVector3 local_arg4; 7984 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7985 arg4 = &local_arg4; 7986 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7987 arg5 = (btScalar)jarg5; 7988 arg6 = (btScalar)jarg6; 7989 arg7 = (btScalar)jarg7; 7990 arg8 = (btScalar)jarg8; 7991 arg9 = (btScalar)jarg9; 7992 btVector3 local_arg10; 7993 gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); 7994 arg10 = &local_arg10; 7995 gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); 7996 arg11 = (btScalar)jarg11; 7997 (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11); 7998 } 7999 8000 8001 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatchSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10, jfloat jarg11) { 8002 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8003 btVector3 *arg2 = 0 ; 8004 btVector3 *arg3 = 0 ; 8005 btVector3 *arg4 = 0 ; 8006 btScalar arg5 ; 8007 btScalar arg6 ; 8008 btScalar arg7 ; 8009 btScalar arg8 ; 8010 btScalar arg9 ; 8011 btVector3 *arg10 = 0 ; 8012 btScalar arg11 ; 8013 8014 (void)jenv; 8015 (void)jcls; 8016 (void)jarg1_; 8017 arg1 = *(btIDebugDraw **)&jarg1; 8018 btVector3 local_arg2; 8019 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8020 arg2 = &local_arg2; 8021 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8022 btVector3 local_arg3; 8023 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8024 arg3 = &local_arg3; 8025 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8026 btVector3 local_arg4; 8027 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 8028 arg4 = &local_arg4; 8029 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 8030 arg5 = (btScalar)jarg5; 8031 arg6 = (btScalar)jarg6; 8032 arg7 = (btScalar)jarg7; 8033 arg8 = (btScalar)jarg8; 8034 arg9 = (btScalar)jarg9; 8035 btVector3 local_arg10; 8036 gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); 8037 arg10 = &local_arg10; 8038 gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); 8039 arg11 = (btScalar)jarg11; 8040 (arg1)->btIDebugDraw::drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11); 8041 } 8042 8043 8044 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatch_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10) { 8045 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8046 btVector3 *arg2 = 0 ; 8047 btVector3 *arg3 = 0 ; 8048 btVector3 *arg4 = 0 ; 8049 btScalar arg5 ; 8050 btScalar arg6 ; 8051 btScalar arg7 ; 8052 btScalar arg8 ; 8053 btScalar arg9 ; 8054 btVector3 *arg10 = 0 ; 8055 8056 (void)jenv; 8057 (void)jcls; 8058 (void)jarg1_; 8059 arg1 = *(btIDebugDraw **)&jarg1; 8060 btVector3 local_arg2; 8061 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8062 arg2 = &local_arg2; 8063 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8064 btVector3 local_arg3; 8065 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8066 arg3 = &local_arg3; 8067 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8068 btVector3 local_arg4; 8069 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 8070 arg4 = &local_arg4; 8071 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 8072 arg5 = (btScalar)jarg5; 8073 arg6 = (btScalar)jarg6; 8074 arg7 = (btScalar)jarg7; 8075 arg8 = (btScalar)jarg8; 8076 arg9 = (btScalar)jarg9; 8077 btVector3 local_arg10; 8078 gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); 8079 arg10 = &local_arg10; 8080 gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); 8081 (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10); 8082 } 8083 8084 8085 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatchSwigExplicitbtIDebugDraw_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10) { 8086 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8087 btVector3 *arg2 = 0 ; 8088 btVector3 *arg3 = 0 ; 8089 btVector3 *arg4 = 0 ; 8090 btScalar arg5 ; 8091 btScalar arg6 ; 8092 btScalar arg7 ; 8093 btScalar arg8 ; 8094 btScalar arg9 ; 8095 btVector3 *arg10 = 0 ; 8096 8097 (void)jenv; 8098 (void)jcls; 8099 (void)jarg1_; 8100 arg1 = *(btIDebugDraw **)&jarg1; 8101 btVector3 local_arg2; 8102 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8103 arg2 = &local_arg2; 8104 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8105 btVector3 local_arg3; 8106 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8107 arg3 = &local_arg3; 8108 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8109 btVector3 local_arg4; 8110 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 8111 arg4 = &local_arg4; 8112 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 8113 arg5 = (btScalar)jarg5; 8114 arg6 = (btScalar)jarg6; 8115 arg7 = (btScalar)jarg7; 8116 arg8 = (btScalar)jarg8; 8117 arg9 = (btScalar)jarg9; 8118 btVector3 local_arg10; 8119 gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); 8120 arg10 = &local_arg10; 8121 gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); 8122 (arg1)->btIDebugDraw::drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10); 8123 } 8124 8125 8126 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawBox_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { 8127 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8128 btVector3 *arg2 = 0 ; 8129 btVector3 *arg3 = 0 ; 8130 btVector3 *arg4 = 0 ; 8131 8132 (void)jenv; 8133 (void)jcls; 8134 (void)jarg1_; 8135 arg1 = *(btIDebugDraw **)&jarg1; 8136 btVector3 local_arg2; 8137 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8138 arg2 = &local_arg2; 8139 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8140 btVector3 local_arg3; 8141 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8142 arg3 = &local_arg3; 8143 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8144 btVector3 local_arg4; 8145 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 8146 arg4 = &local_arg4; 8147 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 8148 (arg1)->drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); 8149 } 8150 8151 8152 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawBoxSwigExplicitbtIDebugDraw_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { 8153 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8154 btVector3 *arg2 = 0 ; 8155 btVector3 *arg3 = 0 ; 8156 btVector3 *arg4 = 0 ; 8157 8158 (void)jenv; 8159 (void)jcls; 8160 (void)jarg1_; 8161 arg1 = *(btIDebugDraw **)&jarg1; 8162 btVector3 local_arg2; 8163 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8164 arg2 = &local_arg2; 8165 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8166 btVector3 local_arg3; 8167 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8168 arg3 = &local_arg3; 8169 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8170 btVector3 local_arg4; 8171 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 8172 arg4 = &local_arg4; 8173 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 8174 (arg1)->btIDebugDraw::drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); 8175 } 8176 8177 8178 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawBox_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5) { 8179 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8180 btVector3 *arg2 = 0 ; 8181 btVector3 *arg3 = 0 ; 8182 btTransform *arg4 = 0 ; 8183 btVector3 *arg5 = 0 ; 8184 8185 (void)jenv; 8186 (void)jcls; 8187 (void)jarg1_; 8188 arg1 = *(btIDebugDraw **)&jarg1; 8189 btVector3 local_arg2; 8190 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8191 arg2 = &local_arg2; 8192 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8193 btVector3 local_arg3; 8194 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8195 arg3 = &local_arg3; 8196 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8197 btTransform local_arg4; 8198 gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); 8199 arg4 = &local_arg4; 8200 gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); 8201 btVector3 local_arg5; 8202 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 8203 arg5 = &local_arg5; 8204 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 8205 (arg1)->drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); 8206 } 8207 8208 8209 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawBoxSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5) { 8210 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8211 btVector3 *arg2 = 0 ; 8212 btVector3 *arg3 = 0 ; 8213 btTransform *arg4 = 0 ; 8214 btVector3 *arg5 = 0 ; 8215 8216 (void)jenv; 8217 (void)jcls; 8218 (void)jarg1_; 8219 arg1 = *(btIDebugDraw **)&jarg1; 8220 btVector3 local_arg2; 8221 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8222 arg2 = &local_arg2; 8223 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8224 btVector3 local_arg3; 8225 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8226 arg3 = &local_arg3; 8227 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8228 btTransform local_arg4; 8229 gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); 8230 arg4 = &local_arg4; 8231 gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); 8232 btVector3 local_arg5; 8233 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 8234 arg5 = &local_arg5; 8235 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 8236 (arg1)->btIDebugDraw::drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); 8237 } 8238 8239 8240 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawCapsule(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { 8241 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8242 btScalar arg2 ; 8243 btScalar arg3 ; 8244 int arg4 ; 8245 btTransform *arg5 = 0 ; 8246 btVector3 *arg6 = 0 ; 8247 8248 (void)jenv; 8249 (void)jcls; 8250 (void)jarg1_; 8251 arg1 = *(btIDebugDraw **)&jarg1; 8252 arg2 = (btScalar)jarg2; 8253 arg3 = (btScalar)jarg3; 8254 arg4 = (int)jarg4; 8255 btTransform local_arg5; 8256 gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); 8257 arg5 = &local_arg5; 8258 gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); 8259 btVector3 local_arg6; 8260 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 8261 arg6 = &local_arg6; 8262 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 8263 (arg1)->drawCapsule(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); 8264 } 8265 8266 8267 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawCapsuleSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { 8268 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8269 btScalar arg2 ; 8270 btScalar arg3 ; 8271 int arg4 ; 8272 btTransform *arg5 = 0 ; 8273 btVector3 *arg6 = 0 ; 8274 8275 (void)jenv; 8276 (void)jcls; 8277 (void)jarg1_; 8278 arg1 = *(btIDebugDraw **)&jarg1; 8279 arg2 = (btScalar)jarg2; 8280 arg3 = (btScalar)jarg3; 8281 arg4 = (int)jarg4; 8282 btTransform local_arg5; 8283 gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); 8284 arg5 = &local_arg5; 8285 gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); 8286 btVector3 local_arg6; 8287 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 8288 arg6 = &local_arg6; 8289 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 8290 (arg1)->btIDebugDraw::drawCapsule(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); 8291 } 8292 8293 8294 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawCylinder(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { 8295 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8296 btScalar arg2 ; 8297 btScalar arg3 ; 8298 int arg4 ; 8299 btTransform *arg5 = 0 ; 8300 btVector3 *arg6 = 0 ; 8301 8302 (void)jenv; 8303 (void)jcls; 8304 (void)jarg1_; 8305 arg1 = *(btIDebugDraw **)&jarg1; 8306 arg2 = (btScalar)jarg2; 8307 arg3 = (btScalar)jarg3; 8308 arg4 = (int)jarg4; 8309 btTransform local_arg5; 8310 gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); 8311 arg5 = &local_arg5; 8312 gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); 8313 btVector3 local_arg6; 8314 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 8315 arg6 = &local_arg6; 8316 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 8317 (arg1)->drawCylinder(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); 8318 } 8319 8320 8321 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawCylinderSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { 8322 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8323 btScalar arg2 ; 8324 btScalar arg3 ; 8325 int arg4 ; 8326 btTransform *arg5 = 0 ; 8327 btVector3 *arg6 = 0 ; 8328 8329 (void)jenv; 8330 (void)jcls; 8331 (void)jarg1_; 8332 arg1 = *(btIDebugDraw **)&jarg1; 8333 arg2 = (btScalar)jarg2; 8334 arg3 = (btScalar)jarg3; 8335 arg4 = (int)jarg4; 8336 btTransform local_arg5; 8337 gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); 8338 arg5 = &local_arg5; 8339 gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); 8340 btVector3 local_arg6; 8341 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 8342 arg6 = &local_arg6; 8343 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 8344 (arg1)->btIDebugDraw::drawCylinder(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); 8345 } 8346 8347 8348 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawCone(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { 8349 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8350 btScalar arg2 ; 8351 btScalar arg3 ; 8352 int arg4 ; 8353 btTransform *arg5 = 0 ; 8354 btVector3 *arg6 = 0 ; 8355 8356 (void)jenv; 8357 (void)jcls; 8358 (void)jarg1_; 8359 arg1 = *(btIDebugDraw **)&jarg1; 8360 arg2 = (btScalar)jarg2; 8361 arg3 = (btScalar)jarg3; 8362 arg4 = (int)jarg4; 8363 btTransform local_arg5; 8364 gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); 8365 arg5 = &local_arg5; 8366 gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); 8367 btVector3 local_arg6; 8368 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 8369 arg6 = &local_arg6; 8370 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 8371 (arg1)->drawCone(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); 8372 } 8373 8374 8375 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawConeSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { 8376 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8377 btScalar arg2 ; 8378 btScalar arg3 ; 8379 int arg4 ; 8380 btTransform *arg5 = 0 ; 8381 btVector3 *arg6 = 0 ; 8382 8383 (void)jenv; 8384 (void)jcls; 8385 (void)jarg1_; 8386 arg1 = *(btIDebugDraw **)&jarg1; 8387 arg2 = (btScalar)jarg2; 8388 arg3 = (btScalar)jarg3; 8389 arg4 = (int)jarg4; 8390 btTransform local_arg5; 8391 gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); 8392 arg5 = &local_arg5; 8393 gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); 8394 btVector3 local_arg6; 8395 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 8396 arg6 = &local_arg6; 8397 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 8398 (arg1)->btIDebugDraw::drawCone(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); 8399 } 8400 8401 8402 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawPlane(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3, jobject jarg4, jobject jarg5) { 8403 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8404 btVector3 *arg2 = 0 ; 8405 btScalar arg3 ; 8406 btTransform *arg4 = 0 ; 8407 btVector3 *arg5 = 0 ; 8408 8409 (void)jenv; 8410 (void)jcls; 8411 (void)jarg1_; 8412 arg1 = *(btIDebugDraw **)&jarg1; 8413 btVector3 local_arg2; 8414 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8415 arg2 = &local_arg2; 8416 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8417 arg3 = (btScalar)jarg3; 8418 btTransform local_arg4; 8419 gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); 8420 arg4 = &local_arg4; 8421 gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); 8422 btVector3 local_arg5; 8423 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 8424 arg5 = &local_arg5; 8425 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 8426 (arg1)->drawPlane((btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); 8427 } 8428 8429 8430 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawPlaneSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3, jobject jarg4, jobject jarg5) { 8431 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8432 btVector3 *arg2 = 0 ; 8433 btScalar arg3 ; 8434 btTransform *arg4 = 0 ; 8435 btVector3 *arg5 = 0 ; 8436 8437 (void)jenv; 8438 (void)jcls; 8439 (void)jarg1_; 8440 arg1 = *(btIDebugDraw **)&jarg1; 8441 btVector3 local_arg2; 8442 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8443 arg2 = &local_arg2; 8444 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8445 arg3 = (btScalar)jarg3; 8446 btTransform local_arg4; 8447 gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); 8448 arg4 = &local_arg4; 8449 gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); 8450 btVector3 local_arg5; 8451 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 8452 arg5 = &local_arg5; 8453 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 8454 (arg1)->btIDebugDraw::drawPlane((btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); 8455 } 8456 8457 8458 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1flushLines(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8459 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8460 8461 (void)jenv; 8462 (void)jcls; 8463 (void)jarg1_; 8464 arg1 = *(btIDebugDraw **)&jarg1; 8465 (arg1)->flushLines(); 8466 } 8467 8468 8469 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1flushLinesSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8470 btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; 8471 8472 (void)jenv; 8473 (void)jcls; 8474 (void)jarg1_; 8475 arg1 = *(btIDebugDraw **)&jarg1; 8476 (arg1)->btIDebugDraw::flushLines(); 8477 } 8478 8479 8480 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btIDebugDraw(JNIEnv *jenv, jclass jcls) { 8481 jlong jresult = 0 ; 8482 btIDebugDraw *result = 0 ; 8483 8484 (void)jenv; 8485 (void)jcls; 8486 result = (btIDebugDraw *)new SwigDirector_btIDebugDraw(jenv); 8487 *(btIDebugDraw **)&jresult = result; 8488 return jresult; 8489 } 8490 8491 8492 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { 8493 btIDebugDraw *obj = *((btIDebugDraw **)&objarg); 8494 (void)jcls; 8495 SwigDirector_btIDebugDraw *director = (SwigDirector_btIDebugDraw *)(obj); 8496 if (director) { 8497 director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); 8498 } 8499 } 8500 8501 8502 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { 8503 btIDebugDraw *obj = *((btIDebugDraw **)&objarg); 8504 SwigDirector_btIDebugDraw *director = (SwigDirector_btIDebugDraw *)(obj); 8505 (void)jcls; 8506 if (director) { 8507 director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); 8508 } 8509 } 8510 8511 8512 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGeometryUtil_1getPlaneEquationsFromVertices(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 8513 btAlignedObjectArray< btVector3 > *arg1 = 0 ; 8514 btAlignedObjectArray< btVector3 > *arg2 = 0 ; 8515 8516 (void)jenv; 8517 (void)jcls; 8518 (void)jarg1_; 8519 (void)jarg2_; 8520 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 8521 if (!arg1) { 8522 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > & reference is null"); 8523 return ; 8524 } 8525 arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; 8526 if (!arg2) { 8527 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > & reference is null"); 8528 return ; 8529 } 8530 btGeometryUtil::getPlaneEquationsFromVertices(*arg1,*arg2); 8531 } 8532 8533 8534 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGeometryUtil_1getVerticesFromPlaneEquations(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 8535 btAlignedObjectArray< btVector3 > *arg1 = 0 ; 8536 btAlignedObjectArray< btVector3 > *arg2 = 0 ; 8537 8538 (void)jenv; 8539 (void)jcls; 8540 (void)jarg1_; 8541 (void)jarg2_; 8542 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 8543 if (!arg1) { 8544 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); 8545 return ; 8546 } 8547 arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; 8548 if (!arg2) { 8549 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > & reference is null"); 8550 return ; 8551 } 8552 btGeometryUtil::getVerticesFromPlaneEquations((btAlignedObjectArray< btVector3 > const &)*arg1,*arg2); 8553 } 8554 8555 8556 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGeometryUtil_1isInside(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { 8557 jboolean jresult = 0 ; 8558 btAlignedObjectArray< btVector3 > *arg1 = 0 ; 8559 btVector3 *arg2 = 0 ; 8560 btScalar arg3 ; 8561 bool result; 8562 8563 (void)jenv; 8564 (void)jcls; 8565 (void)jarg1_; 8566 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 8567 if (!arg1) { 8568 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); 8569 return 0; 8570 } 8571 btVector3 local_arg2; 8572 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8573 arg2 = &local_arg2; 8574 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8575 arg3 = (btScalar)jarg3; 8576 result = (bool)btGeometryUtil::isInside((btAlignedObjectArray< btVector3 > const &)*arg1,(btVector3 const &)*arg2,arg3); 8577 jresult = (jboolean)result; 8578 return jresult; 8579 } 8580 8581 8582 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGeometryUtil_1isPointInsidePlanes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { 8583 jboolean jresult = 0 ; 8584 btAlignedObjectArray< btVector3 > *arg1 = 0 ; 8585 btVector3 *arg2 = 0 ; 8586 btScalar arg3 ; 8587 bool result; 8588 8589 (void)jenv; 8590 (void)jcls; 8591 (void)jarg1_; 8592 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 8593 if (!arg1) { 8594 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); 8595 return 0; 8596 } 8597 btVector3 local_arg2; 8598 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8599 arg2 = &local_arg2; 8600 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8601 arg3 = (btScalar)jarg3; 8602 result = (bool)btGeometryUtil::isPointInsidePlanes((btAlignedObjectArray< btVector3 > const &)*arg1,(btVector3 const &)*arg2,arg3); 8603 jresult = (jboolean)result; 8604 return jresult; 8605 } 8606 8607 8608 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGeometryUtil_1areVerticesBehindPlane(JNIEnv *jenv, jclass jcls, jobject jarg1, jlong jarg2, jobject jarg2_, jfloat jarg3) { 8609 jboolean jresult = 0 ; 8610 btVector3 *arg1 = 0 ; 8611 btAlignedObjectArray< btVector3 > *arg2 = 0 ; 8612 btScalar arg3 ; 8613 bool result; 8614 8615 (void)jenv; 8616 (void)jcls; 8617 (void)jarg2_; 8618 btVector3 local_arg1; 8619 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 8620 arg1 = &local_arg1; 8621 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 8622 arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; 8623 if (!arg2) { 8624 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); 8625 return 0; 8626 } 8627 arg3 = (btScalar)jarg3; 8628 result = (bool)btGeometryUtil::areVerticesBehindPlane((btVector3 const &)*arg1,(btAlignedObjectArray< btVector3 > const &)*arg2,arg3); 8629 jresult = (jboolean)result; 8630 return jresult; 8631 } 8632 8633 8634 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btGeometryUtil(JNIEnv *jenv, jclass jcls) { 8635 jlong jresult = 0 ; 8636 btGeometryUtil *result = 0 ; 8637 8638 (void)jenv; 8639 (void)jcls; 8640 result = (btGeometryUtil *)new btGeometryUtil(); 8641 *(btGeometryUtil **)&jresult = result; 8642 return jresult; 8643 } 8644 8645 8646 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btGeometryUtil(JNIEnv *jenv, jclass jcls, jlong jarg1) { 8647 btGeometryUtil *arg1 = (btGeometryUtil *) 0 ; 8648 8649 (void)jenv; 8650 (void)jcls; 8651 arg1 = *(btGeometryUtil **)&jarg1; 8652 delete arg1; 8653 } 8654 8655 8656 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GEN_1srand(JNIEnv *jenv, jclass jcls, jlong jarg1) { 8657 unsigned int arg1 ; 8658 8659 (void)jenv; 8660 (void)jcls; 8661 arg1 = (unsigned int)jarg1; 8662 GEN_srand(arg1); 8663 } 8664 8665 8666 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GEN_1rand(JNIEnv *jenv, jclass jcls) { 8667 jlong jresult = 0 ; 8668 unsigned int result; 8669 8670 (void)jenv; 8671 (void)jcls; 8672 result = (unsigned int)GEN_rand(); 8673 jresult = (jlong)result; 8674 return jresult; 8675 } 8676 8677 8678 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAabbSupport(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 8679 jobject jresult = 0 ; 8680 btVector3 *arg1 = 0 ; 8681 btVector3 *arg2 = 0 ; 8682 btVector3 result; 8683 8684 (void)jenv; 8685 (void)jcls; 8686 btVector3 local_arg1; 8687 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 8688 arg1 = &local_arg1; 8689 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 8690 btVector3 local_arg2; 8691 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8692 arg2 = &local_arg2; 8693 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8694 result = btAabbSupport((btVector3 const &)*arg1,(btVector3 const &)*arg2); 8695 jresult = gdx_getReturnVector3(jenv); 8696 gdx_setVector3FrombtVector3(jenv, jresult, result); 8697 return jresult; 8698 } 8699 8700 8701 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformUtil_1integrateTransform(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jfloat jarg4, jobject jarg5) { 8702 btTransform *arg1 = 0 ; 8703 btVector3 *arg2 = 0 ; 8704 btVector3 *arg3 = 0 ; 8705 btScalar arg4 ; 8706 btTransform *arg5 = 0 ; 8707 8708 (void)jenv; 8709 (void)jcls; 8710 btTransform local_arg1; 8711 gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); 8712 arg1 = &local_arg1; 8713 gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); 8714 btVector3 local_arg2; 8715 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8716 arg2 = &local_arg2; 8717 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8718 btVector3 local_arg3; 8719 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8720 arg3 = &local_arg3; 8721 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8722 arg4 = (btScalar)jarg4; 8723 btTransform local_arg5; 8724 gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); 8725 arg5 = &local_arg5; 8726 gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); 8727 btTransformUtil::integrateTransform((btTransform const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,*arg5); 8728 } 8729 8730 8731 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformUtil_1calculateVelocityQuaternion(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jobject jarg6, jobject jarg7) { 8732 btVector3 *arg1 = 0 ; 8733 btVector3 *arg2 = 0 ; 8734 btQuaternion *arg3 = 0 ; 8735 btQuaternion *arg4 = 0 ; 8736 btScalar arg5 ; 8737 btVector3 *arg6 = 0 ; 8738 btVector3 *arg7 = 0 ; 8739 8740 (void)jenv; 8741 (void)jcls; 8742 btVector3 local_arg1; 8743 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 8744 arg1 = &local_arg1; 8745 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 8746 btVector3 local_arg2; 8747 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8748 arg2 = &local_arg2; 8749 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8750 btQuaternion local_arg3; 8751 gdx_setbtQuaternionFromQuaternion(jenv, local_arg3, jarg3); 8752 arg3 = &local_arg3; 8753 gdxAutoCommitQuaternion auto_commit_arg3(jenv, jarg3, &local_arg3); 8754 btQuaternion local_arg4; 8755 gdx_setbtQuaternionFromQuaternion(jenv, local_arg4, jarg4); 8756 arg4 = &local_arg4; 8757 gdxAutoCommitQuaternion auto_commit_arg4(jenv, jarg4, &local_arg4); 8758 arg5 = (btScalar)jarg5; 8759 btVector3 local_arg6; 8760 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 8761 arg6 = &local_arg6; 8762 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 8763 btVector3 local_arg7; 8764 gdx_setbtVector3FromVector3(jenv, local_arg7, jarg7); 8765 arg7 = &local_arg7; 8766 gdxAutoCommitVector3 auto_commit_arg7(jenv, jarg7, &local_arg7); 8767 btTransformUtil::calculateVelocityQuaternion((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btQuaternion const &)*arg3,(btQuaternion const &)*arg4,arg5,*arg6,*arg7); 8768 } 8769 8770 8771 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformUtil_1calculateDiffAxisAngleQuaternion(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jlong jarg4) { 8772 btQuaternion *arg1 = 0 ; 8773 btQuaternion *arg2 = 0 ; 8774 btVector3 *arg3 = 0 ; 8775 btScalar *arg4 = 0 ; 8776 8777 (void)jenv; 8778 (void)jcls; 8779 btQuaternion local_arg1; 8780 gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); 8781 arg1 = &local_arg1; 8782 gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); 8783 btQuaternion local_arg2; 8784 gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); 8785 arg2 = &local_arg2; 8786 gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); 8787 btVector3 local_arg3; 8788 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8789 arg3 = &local_arg3; 8790 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8791 arg4 = *(btScalar **)&jarg4; 8792 if (!arg4) { 8793 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); 8794 return ; 8795 } 8796 btTransformUtil::calculateDiffAxisAngleQuaternion((btQuaternion const &)*arg1,(btQuaternion const &)*arg2,*arg3,*arg4); 8797 } 8798 8799 8800 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformUtil_1calculateVelocity(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jfloat jarg3, jobject jarg4, jobject jarg5) { 8801 btTransform *arg1 = 0 ; 8802 btTransform *arg2 = 0 ; 8803 btScalar arg3 ; 8804 btVector3 *arg4 = 0 ; 8805 btVector3 *arg5 = 0 ; 8806 8807 (void)jenv; 8808 (void)jcls; 8809 btTransform local_arg1; 8810 gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); 8811 arg1 = &local_arg1; 8812 gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); 8813 btTransform local_arg2; 8814 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 8815 arg2 = &local_arg2; 8816 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 8817 arg3 = (btScalar)jarg3; 8818 btVector3 local_arg4; 8819 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 8820 arg4 = &local_arg4; 8821 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 8822 btVector3 local_arg5; 8823 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 8824 arg5 = &local_arg5; 8825 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 8826 btTransformUtil::calculateVelocity((btTransform const &)*arg1,(btTransform const &)*arg2,arg3,*arg4,*arg5); 8827 } 8828 8829 8830 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformUtil_1calculateDiffAxisAngle(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jlong jarg4) { 8831 btTransform *arg1 = 0 ; 8832 btTransform *arg2 = 0 ; 8833 btVector3 *arg3 = 0 ; 8834 btScalar *arg4 = 0 ; 8835 8836 (void)jenv; 8837 (void)jcls; 8838 btTransform local_arg1; 8839 gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); 8840 arg1 = &local_arg1; 8841 gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); 8842 btTransform local_arg2; 8843 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 8844 arg2 = &local_arg2; 8845 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 8846 btVector3 local_arg3; 8847 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8848 arg3 = &local_arg3; 8849 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8850 arg4 = *(btScalar **)&jarg4; 8851 if (!arg4) { 8852 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); 8853 return ; 8854 } 8855 btTransformUtil::calculateDiffAxisAngle((btTransform const &)*arg1,(btTransform const &)*arg2,*arg3,*arg4); 8856 } 8857 8858 8859 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransformUtil(JNIEnv *jenv, jclass jcls) { 8860 jlong jresult = 0 ; 8861 btTransformUtil *result = 0 ; 8862 8863 (void)jenv; 8864 (void)jcls; 8865 result = (btTransformUtil *)new btTransformUtil(); 8866 *(btTransformUtil **)&jresult = result; 8867 return jresult; 8868 } 8869 8870 8871 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btTransformUtil(JNIEnv *jenv, jclass jcls, jlong jarg1) { 8872 btTransformUtil *arg1 = (btTransformUtil *) 0 ; 8873 8874 (void)jenv; 8875 (void)jcls; 8876 arg1 = *(btTransformUtil **)&jarg1; 8877 delete arg1; 8878 } 8879 8880 8881 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btConvexSeparatingDistanceUtil(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { 8882 jlong jresult = 0 ; 8883 btScalar arg1 ; 8884 btScalar arg2 ; 8885 btConvexSeparatingDistanceUtil *result = 0 ; 8886 8887 (void)jenv; 8888 (void)jcls; 8889 arg1 = (btScalar)jarg1; 8890 arg2 = (btScalar)jarg2; 8891 result = (btConvexSeparatingDistanceUtil *)new btConvexSeparatingDistanceUtil(arg1,arg2); 8892 *(btConvexSeparatingDistanceUtil **)&jresult = result; 8893 return jresult; 8894 } 8895 8896 8897 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexSeparatingDistanceUtil_1getConservativeSeparatingDistance(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8898 jfloat jresult = 0 ; 8899 btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; 8900 btScalar result; 8901 8902 (void)jenv; 8903 (void)jcls; 8904 (void)jarg1_; 8905 arg1 = *(btConvexSeparatingDistanceUtil **)&jarg1; 8906 result = (btScalar)(arg1)->getConservativeSeparatingDistance(); 8907 jresult = (jfloat)result; 8908 return jresult; 8909 } 8910 8911 8912 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexSeparatingDistanceUtil_1updateSeparatingDistance(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { 8913 btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; 8914 btTransform *arg2 = 0 ; 8915 btTransform *arg3 = 0 ; 8916 8917 (void)jenv; 8918 (void)jcls; 8919 (void)jarg1_; 8920 arg1 = *(btConvexSeparatingDistanceUtil **)&jarg1; 8921 btTransform local_arg2; 8922 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 8923 arg2 = &local_arg2; 8924 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 8925 btTransform local_arg3; 8926 gdx_setbtTransformFromMatrix4(jenv, local_arg3, jarg3); 8927 arg3 = &local_arg3; 8928 gdxAutoCommitMatrix4 auto_commit_arg3(jenv, jarg3, &local_arg3); 8929 (arg1)->updateSeparatingDistance((btTransform const &)*arg2,(btTransform const &)*arg3); 8930 } 8931 8932 8933 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexSeparatingDistanceUtil_1initSeparatingDistance(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3, jobject jarg4, jobject jarg5) { 8934 btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; 8935 btVector3 *arg2 = 0 ; 8936 btScalar arg3 ; 8937 btTransform *arg4 = 0 ; 8938 btTransform *arg5 = 0 ; 8939 8940 (void)jenv; 8941 (void)jcls; 8942 (void)jarg1_; 8943 arg1 = *(btConvexSeparatingDistanceUtil **)&jarg1; 8944 btVector3 local_arg2; 8945 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8946 arg2 = &local_arg2; 8947 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8948 arg3 = (btScalar)jarg3; 8949 btTransform local_arg4; 8950 gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); 8951 arg4 = &local_arg4; 8952 gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); 8953 btTransform local_arg5; 8954 gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); 8955 arg5 = &local_arg5; 8956 gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); 8957 (arg1)->initSeparatingDistance((btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,(btTransform const &)*arg5); 8958 } 8959 8960 8961 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btConvexSeparatingDistanceUtil(JNIEnv *jenv, jclass jcls, jlong jarg1) { 8962 btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; 8963 8964 (void)jenv; 8965 (void)jcls; 8966 arg1 = *(btConvexSeparatingDistanceUtil **)&jarg1; 8967 delete arg1; 8968 } 8969 8970 8971 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1HullResult(JNIEnv *jenv, jclass jcls) { 8972 jlong jresult = 0 ; 8973 HullResult *result = 0 ; 8974 8975 (void)jenv; 8976 (void)jcls; 8977 result = (HullResult *)new HullResult(); 8978 *(HullResult **)&jresult = result; 8979 return jresult; 8980 } 8981 8982 8983 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mPolygons_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 8984 HullResult *arg1 = (HullResult *) 0 ; 8985 bool arg2 ; 8986 8987 (void)jenv; 8988 (void)jcls; 8989 (void)jarg1_; 8990 arg1 = *(HullResult **)&jarg1; 8991 arg2 = jarg2 ? true : false; 8992 if (arg1) (arg1)->mPolygons = arg2; 8993 } 8994 8995 8996 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mPolygons_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8997 jboolean jresult = 0 ; 8998 HullResult *arg1 = (HullResult *) 0 ; 8999 bool result; 9000 9001 (void)jenv; 9002 (void)jcls; 9003 (void)jarg1_; 9004 arg1 = *(HullResult **)&jarg1; 9005 result = (bool) ((arg1)->mPolygons); 9006 jresult = (jboolean)result; 9007 return jresult; 9008 } 9009 9010 9011 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumOutputVertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9012 HullResult *arg1 = (HullResult *) 0 ; 9013 unsigned int arg2 ; 9014 9015 (void)jenv; 9016 (void)jcls; 9017 (void)jarg1_; 9018 arg1 = *(HullResult **)&jarg1; 9019 arg2 = (unsigned int)jarg2; 9020 if (arg1) (arg1)->mNumOutputVertices = arg2; 9021 } 9022 9023 9024 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumOutputVertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9025 jlong jresult = 0 ; 9026 HullResult *arg1 = (HullResult *) 0 ; 9027 unsigned int result; 9028 9029 (void)jenv; 9030 (void)jcls; 9031 (void)jarg1_; 9032 arg1 = *(HullResult **)&jarg1; 9033 result = (unsigned int) ((arg1)->mNumOutputVertices); 9034 jresult = (jlong)result; 9035 return jresult; 9036 } 9037 9038 9039 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1OutputVertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9040 HullResult *arg1 = (HullResult *) 0 ; 9041 btAlignedObjectArray< btVector3 > *arg2 = (btAlignedObjectArray< btVector3 > *) 0 ; 9042 9043 (void)jenv; 9044 (void)jcls; 9045 (void)jarg1_; 9046 (void)jarg2_; 9047 arg1 = *(HullResult **)&jarg1; 9048 arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; 9049 if (arg1) (arg1)->m_OutputVertices = *arg2; 9050 } 9051 9052 9053 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1OutputVertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9054 jlong jresult = 0 ; 9055 HullResult *arg1 = (HullResult *) 0 ; 9056 btAlignedObjectArray< btVector3 > *result = 0 ; 9057 9058 (void)jenv; 9059 (void)jcls; 9060 (void)jarg1_; 9061 arg1 = *(HullResult **)&jarg1; 9062 result = (btAlignedObjectArray< btVector3 > *)& ((arg1)->m_OutputVertices); 9063 *(btAlignedObjectArray< btVector3 > **)&jresult = result; 9064 return jresult; 9065 } 9066 9067 9068 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumFaces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9069 HullResult *arg1 = (HullResult *) 0 ; 9070 unsigned int arg2 ; 9071 9072 (void)jenv; 9073 (void)jcls; 9074 (void)jarg1_; 9075 arg1 = *(HullResult **)&jarg1; 9076 arg2 = (unsigned int)jarg2; 9077 if (arg1) (arg1)->mNumFaces = arg2; 9078 } 9079 9080 9081 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumFaces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9082 jlong jresult = 0 ; 9083 HullResult *arg1 = (HullResult *) 0 ; 9084 unsigned int result; 9085 9086 (void)jenv; 9087 (void)jcls; 9088 (void)jarg1_; 9089 arg1 = *(HullResult **)&jarg1; 9090 result = (unsigned int) ((arg1)->mNumFaces); 9091 jresult = (jlong)result; 9092 return jresult; 9093 } 9094 9095 9096 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumIndices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9097 HullResult *arg1 = (HullResult *) 0 ; 9098 unsigned int arg2 ; 9099 9100 (void)jenv; 9101 (void)jcls; 9102 (void)jarg1_; 9103 arg1 = *(HullResult **)&jarg1; 9104 arg2 = (unsigned int)jarg2; 9105 if (arg1) (arg1)->mNumIndices = arg2; 9106 } 9107 9108 9109 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumIndices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9110 jlong jresult = 0 ; 9111 HullResult *arg1 = (HullResult *) 0 ; 9112 unsigned int result; 9113 9114 (void)jenv; 9115 (void)jcls; 9116 (void)jarg1_; 9117 arg1 = *(HullResult **)&jarg1; 9118 result = (unsigned int) ((arg1)->mNumIndices); 9119 jresult = (jlong)result; 9120 return jresult; 9121 } 9122 9123 9124 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1Indices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9125 HullResult *arg1 = (HullResult *) 0 ; 9126 btAlignedObjectArray< unsigned int > *arg2 = (btAlignedObjectArray< unsigned int > *) 0 ; 9127 9128 (void)jenv; 9129 (void)jcls; 9130 (void)jarg1_; 9131 arg1 = *(HullResult **)&jarg1; 9132 arg2 = *(btAlignedObjectArray< unsigned int > **)&jarg2; 9133 if (arg1) (arg1)->m_Indices = *arg2; 9134 } 9135 9136 9137 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1Indices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9138 jlong jresult = 0 ; 9139 HullResult *arg1 = (HullResult *) 0 ; 9140 btAlignedObjectArray< unsigned int > *result = 0 ; 9141 9142 (void)jenv; 9143 (void)jcls; 9144 (void)jarg1_; 9145 arg1 = *(HullResult **)&jarg1; 9146 result = (btAlignedObjectArray< unsigned int > *)& ((arg1)->m_Indices); 9147 *(btAlignedObjectArray< unsigned int > **)&jresult = result; 9148 return jresult; 9149 } 9150 9151 9152 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1HullResult(JNIEnv *jenv, jclass jcls, jlong jarg1) { 9153 HullResult *arg1 = (HullResult *) 0 ; 9154 9155 (void)jenv; 9156 (void)jcls; 9157 arg1 = *(HullResult **)&jarg1; 9158 delete arg1; 9159 } 9160 9161 9162 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1HullDesc_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 9163 jlong jresult = 0 ; 9164 HullDesc *result = 0 ; 9165 9166 (void)jenv; 9167 (void)jcls; 9168 result = (HullDesc *)new HullDesc(); 9169 *(HullDesc **)&jresult = result; 9170 return jresult; 9171 } 9172 9173 9174 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1HullDesc_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jlong jarg3, jobject jarg3_, jlong jarg4) { 9175 jlong jresult = 0 ; 9176 HullFlag arg1 ; 9177 unsigned int arg2 ; 9178 btVector3 *arg3 = (btVector3 *) 0 ; 9179 unsigned int arg4 ; 9180 HullDesc *result = 0 ; 9181 9182 (void)jenv; 9183 (void)jcls; 9184 (void)jarg3_; 9185 arg1 = (HullFlag)jarg1; 9186 arg2 = (unsigned int)jarg2; 9187 arg3 = *(btVector3 **)&jarg3; 9188 arg4 = (unsigned int)jarg4; 9189 result = (HullDesc *)new HullDesc(arg1,arg2,(btVector3 const *)arg3,arg4); 9190 *(HullDesc **)&jresult = result; 9191 return jresult; 9192 } 9193 9194 9195 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1HullDesc_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jlong jarg3, jobject jarg3_) { 9196 jlong jresult = 0 ; 9197 HullFlag arg1 ; 9198 unsigned int arg2 ; 9199 btVector3 *arg3 = (btVector3 *) 0 ; 9200 HullDesc *result = 0 ; 9201 9202 (void)jenv; 9203 (void)jcls; 9204 (void)jarg3_; 9205 arg1 = (HullFlag)jarg1; 9206 arg2 = (unsigned int)jarg2; 9207 arg3 = *(btVector3 **)&jarg3; 9208 result = (HullDesc *)new HullDesc(arg1,arg2,(btVector3 const *)arg3); 9209 *(HullDesc **)&jresult = result; 9210 return jresult; 9211 } 9212 9213 9214 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1HasHullFlag(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9215 jboolean jresult = 0 ; 9216 HullDesc *arg1 = (HullDesc *) 0 ; 9217 HullFlag arg2 ; 9218 bool result; 9219 9220 (void)jenv; 9221 (void)jcls; 9222 (void)jarg1_; 9223 arg1 = *(HullDesc **)&jarg1; 9224 arg2 = (HullFlag)jarg2; 9225 result = (bool)((HullDesc const *)arg1)->HasHullFlag(arg2); 9226 jresult = (jboolean)result; 9227 return jresult; 9228 } 9229 9230 9231 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1SetHullFlag(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9232 HullDesc *arg1 = (HullDesc *) 0 ; 9233 HullFlag arg2 ; 9234 9235 (void)jenv; 9236 (void)jcls; 9237 (void)jarg1_; 9238 arg1 = *(HullDesc **)&jarg1; 9239 arg2 = (HullFlag)jarg2; 9240 (arg1)->SetHullFlag(arg2); 9241 } 9242 9243 9244 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1ClearHullFlag(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9245 HullDesc *arg1 = (HullDesc *) 0 ; 9246 HullFlag arg2 ; 9247 9248 (void)jenv; 9249 (void)jcls; 9250 (void)jarg1_; 9251 arg1 = *(HullDesc **)&jarg1; 9252 arg2 = (HullFlag)jarg2; 9253 (arg1)->ClearHullFlag(arg2); 9254 } 9255 9256 9257 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mFlags_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9258 HullDesc *arg1 = (HullDesc *) 0 ; 9259 unsigned int arg2 ; 9260 9261 (void)jenv; 9262 (void)jcls; 9263 (void)jarg1_; 9264 arg1 = *(HullDesc **)&jarg1; 9265 arg2 = (unsigned int)jarg2; 9266 if (arg1) (arg1)->mFlags = arg2; 9267 } 9268 9269 9270 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mFlags_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9271 jlong jresult = 0 ; 9272 HullDesc *arg1 = (HullDesc *) 0 ; 9273 unsigned int result; 9274 9275 (void)jenv; 9276 (void)jcls; 9277 (void)jarg1_; 9278 arg1 = *(HullDesc **)&jarg1; 9279 result = (unsigned int) ((arg1)->mFlags); 9280 jresult = (jlong)result; 9281 return jresult; 9282 } 9283 9284 9285 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVcount_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9286 HullDesc *arg1 = (HullDesc *) 0 ; 9287 unsigned int arg2 ; 9288 9289 (void)jenv; 9290 (void)jcls; 9291 (void)jarg1_; 9292 arg1 = *(HullDesc **)&jarg1; 9293 arg2 = (unsigned int)jarg2; 9294 if (arg1) (arg1)->mVcount = arg2; 9295 } 9296 9297 9298 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVcount_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9299 jlong jresult = 0 ; 9300 HullDesc *arg1 = (HullDesc *) 0 ; 9301 unsigned int result; 9302 9303 (void)jenv; 9304 (void)jcls; 9305 (void)jarg1_; 9306 arg1 = *(HullDesc **)&jarg1; 9307 result = (unsigned int) ((arg1)->mVcount); 9308 jresult = (jlong)result; 9309 return jresult; 9310 } 9311 9312 9313 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9314 HullDesc *arg1 = (HullDesc *) 0 ; 9315 btVector3 *arg2 = (btVector3 *) 0 ; 9316 9317 (void)jenv; 9318 (void)jcls; 9319 (void)jarg1_; 9320 (void)jarg2_; 9321 arg1 = *(HullDesc **)&jarg1; 9322 arg2 = *(btVector3 **)&jarg2; 9323 if (arg1) (arg1)->mVertices = (btVector3 const *)arg2; 9324 } 9325 9326 9327 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9328 jlong jresult = 0 ; 9329 HullDesc *arg1 = (HullDesc *) 0 ; 9330 btVector3 *result = 0 ; 9331 9332 (void)jenv; 9333 (void)jcls; 9334 (void)jarg1_; 9335 arg1 = *(HullDesc **)&jarg1; 9336 result = (btVector3 *) ((arg1)->mVertices); 9337 *(btVector3 **)&jresult = result; 9338 return jresult; 9339 } 9340 9341 9342 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVertexStride_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9343 HullDesc *arg1 = (HullDesc *) 0 ; 9344 unsigned int arg2 ; 9345 9346 (void)jenv; 9347 (void)jcls; 9348 (void)jarg1_; 9349 arg1 = *(HullDesc **)&jarg1; 9350 arg2 = (unsigned int)jarg2; 9351 if (arg1) (arg1)->mVertexStride = arg2; 9352 } 9353 9354 9355 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVertexStride_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9356 jlong jresult = 0 ; 9357 HullDesc *arg1 = (HullDesc *) 0 ; 9358 unsigned int result; 9359 9360 (void)jenv; 9361 (void)jcls; 9362 (void)jarg1_; 9363 arg1 = *(HullDesc **)&jarg1; 9364 result = (unsigned int) ((arg1)->mVertexStride); 9365 jresult = (jlong)result; 9366 return jresult; 9367 } 9368 9369 9370 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mNormalEpsilon_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 9371 HullDesc *arg1 = (HullDesc *) 0 ; 9372 btScalar arg2 ; 9373 9374 (void)jenv; 9375 (void)jcls; 9376 (void)jarg1_; 9377 arg1 = *(HullDesc **)&jarg1; 9378 arg2 = (btScalar)jarg2; 9379 if (arg1) (arg1)->mNormalEpsilon = arg2; 9380 } 9381 9382 9383 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mNormalEpsilon_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9384 jfloat jresult = 0 ; 9385 HullDesc *arg1 = (HullDesc *) 0 ; 9386 btScalar result; 9387 9388 (void)jenv; 9389 (void)jcls; 9390 (void)jarg1_; 9391 arg1 = *(HullDesc **)&jarg1; 9392 result = (btScalar) ((arg1)->mNormalEpsilon); 9393 jresult = (jfloat)result; 9394 return jresult; 9395 } 9396 9397 9398 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mMaxVertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9399 HullDesc *arg1 = (HullDesc *) 0 ; 9400 unsigned int arg2 ; 9401 9402 (void)jenv; 9403 (void)jcls; 9404 (void)jarg1_; 9405 arg1 = *(HullDesc **)&jarg1; 9406 arg2 = (unsigned int)jarg2; 9407 if (arg1) (arg1)->mMaxVertices = arg2; 9408 } 9409 9410 9411 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mMaxVertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9412 jlong jresult = 0 ; 9413 HullDesc *arg1 = (HullDesc *) 0 ; 9414 unsigned int result; 9415 9416 (void)jenv; 9417 (void)jcls; 9418 (void)jarg1_; 9419 arg1 = *(HullDesc **)&jarg1; 9420 result = (unsigned int) ((arg1)->mMaxVertices); 9421 jresult = (jlong)result; 9422 return jresult; 9423 } 9424 9425 9426 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mMaxFaces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9427 HullDesc *arg1 = (HullDesc *) 0 ; 9428 unsigned int arg2 ; 9429 9430 (void)jenv; 9431 (void)jcls; 9432 (void)jarg1_; 9433 arg1 = *(HullDesc **)&jarg1; 9434 arg2 = (unsigned int)jarg2; 9435 if (arg1) (arg1)->mMaxFaces = arg2; 9436 } 9437 9438 9439 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mMaxFaces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9440 jlong jresult = 0 ; 9441 HullDesc *arg1 = (HullDesc *) 0 ; 9442 unsigned int result; 9443 9444 (void)jenv; 9445 (void)jcls; 9446 (void)jarg1_; 9447 arg1 = *(HullDesc **)&jarg1; 9448 result = (unsigned int) ((arg1)->mMaxFaces); 9449 jresult = (jlong)result; 9450 return jresult; 9451 } 9452 9453 9454 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1HullDesc(JNIEnv *jenv, jclass jcls, jlong jarg1) { 9455 HullDesc *arg1 = (HullDesc *) 0 ; 9456 9457 (void)jenv; 9458 (void)jcls; 9459 arg1 = *(HullDesc **)&jarg1; 9460 delete arg1; 9461 } 9462 9463 9464 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPlane_1normal_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9465 btPlane *arg1 = (btPlane *) 0 ; 9466 btVector3 *arg2 = (btVector3 *) 0 ; 9467 9468 (void)jenv; 9469 (void)jcls; 9470 (void)jarg1_; 9471 (void)jarg2_; 9472 arg1 = *(btPlane **)&jarg1; 9473 arg2 = *(btVector3 **)&jarg2; 9474 if (arg1) (arg1)->normal = *arg2; 9475 } 9476 9477 9478 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPlane_1normal_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9479 jlong jresult = 0 ; 9480 btPlane *arg1 = (btPlane *) 0 ; 9481 btVector3 *result = 0 ; 9482 9483 (void)jenv; 9484 (void)jcls; 9485 (void)jarg1_; 9486 arg1 = *(btPlane **)&jarg1; 9487 result = (btVector3 *)& ((arg1)->normal); 9488 *(btVector3 **)&jresult = result; 9489 return jresult; 9490 } 9491 9492 9493 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPlane_1dist_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 9494 btPlane *arg1 = (btPlane *) 0 ; 9495 btScalar arg2 ; 9496 9497 (void)jenv; 9498 (void)jcls; 9499 (void)jarg1_; 9500 arg1 = *(btPlane **)&jarg1; 9501 arg2 = (btScalar)jarg2; 9502 if (arg1) (arg1)->dist = arg2; 9503 } 9504 9505 9506 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPlane_1dist_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9507 jfloat jresult = 0 ; 9508 btPlane *arg1 = (btPlane *) 0 ; 9509 btScalar result; 9510 9511 (void)jenv; 9512 (void)jcls; 9513 (void)jarg1_; 9514 arg1 = *(btPlane **)&jarg1; 9515 result = (btScalar) ((arg1)->dist); 9516 jresult = (jfloat)result; 9517 return jresult; 9518 } 9519 9520 9521 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btPlane_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jfloat jarg2) { 9522 jlong jresult = 0 ; 9523 btVector3 *arg1 = 0 ; 9524 btScalar arg2 ; 9525 btPlane *result = 0 ; 9526 9527 (void)jenv; 9528 (void)jcls; 9529 btVector3 local_arg1; 9530 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 9531 arg1 = &local_arg1; 9532 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 9533 arg2 = (btScalar)jarg2; 9534 result = (btPlane *)new btPlane((btVector3 const &)*arg1,arg2); 9535 *(btPlane **)&jresult = result; 9536 return jresult; 9537 } 9538 9539 9540 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btPlane_1_1SWIG_11(JNIEnv *jenv, jclass jcls) { 9541 jlong jresult = 0 ; 9542 btPlane *result = 0 ; 9543 9544 (void)jenv; 9545 (void)jcls; 9546 result = (btPlane *)new btPlane(); 9547 *(btPlane **)&jresult = result; 9548 return jresult; 9549 } 9550 9551 9552 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btPlane(JNIEnv *jenv, jclass jcls, jlong jarg1) { 9553 btPlane *arg1 = (btPlane *) 0 ; 9554 9555 (void)jenv; 9556 (void)jcls; 9557 arg1 = *(btPlane **)&jarg1; 9558 delete arg1; 9559 } 9560 9561 9562 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1ea_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { 9563 ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; 9564 short arg2 ; 9565 9566 (void)jenv; 9567 (void)jcls; 9568 (void)jarg1_; 9569 arg1 = *(ConvexH::HalfEdge **)&jarg1; 9570 arg2 = (short)jarg2; 9571 if (arg1) (arg1)->ea = arg2; 9572 } 9573 9574 9575 SWIGEXPORT jshort JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1ea_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9576 jshort jresult = 0 ; 9577 ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; 9578 short result; 9579 9580 (void)jenv; 9581 (void)jcls; 9582 (void)jarg1_; 9583 arg1 = *(ConvexH::HalfEdge **)&jarg1; 9584 result = (short) ((arg1)->ea); 9585 jresult = (jshort)result; 9586 return jresult; 9587 } 9588 9589 9590 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1v_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { 9591 ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; 9592 unsigned char arg2 ; 9593 9594 (void)jenv; 9595 (void)jcls; 9596 (void)jarg1_; 9597 arg1 = *(ConvexH::HalfEdge **)&jarg1; 9598 arg2 = (unsigned char)jarg2; 9599 if (arg1) (arg1)->v = arg2; 9600 } 9601 9602 9603 SWIGEXPORT jshort JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1v_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9604 jshort jresult = 0 ; 9605 ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; 9606 unsigned char result; 9607 9608 (void)jenv; 9609 (void)jcls; 9610 (void)jarg1_; 9611 arg1 = *(ConvexH::HalfEdge **)&jarg1; 9612 result = (unsigned char) ((arg1)->v); 9613 jresult = (jshort)result; 9614 return jresult; 9615 } 9616 9617 9618 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1p_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { 9619 ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; 9620 unsigned char arg2 ; 9621 9622 (void)jenv; 9623 (void)jcls; 9624 (void)jarg1_; 9625 arg1 = *(ConvexH::HalfEdge **)&jarg1; 9626 arg2 = (unsigned char)jarg2; 9627 if (arg1) (arg1)->p = arg2; 9628 } 9629 9630 9631 SWIGEXPORT jshort JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1p_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9632 jshort jresult = 0 ; 9633 ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; 9634 unsigned char result; 9635 9636 (void)jenv; 9637 (void)jcls; 9638 (void)jarg1_; 9639 arg1 = *(ConvexH::HalfEdge **)&jarg1; 9640 result = (unsigned char) ((arg1)->p); 9641 jresult = (jshort)result; 9642 return jresult; 9643 } 9644 9645 9646 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1ConvexH_1HalfEdge_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 9647 jlong jresult = 0 ; 9648 ConvexH::HalfEdge *result = 0 ; 9649 9650 (void)jenv; 9651 (void)jcls; 9652 result = (ConvexH::HalfEdge *)new ConvexH::HalfEdge(); 9653 *(ConvexH::HalfEdge **)&jresult = result; 9654 return jresult; 9655 } 9656 9657 9658 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1ConvexH_1HalfEdge_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jshort jarg1, jshort jarg2, jshort jarg3) { 9659 jlong jresult = 0 ; 9660 short arg1 ; 9661 unsigned char arg2 ; 9662 unsigned char arg3 ; 9663 ConvexH::HalfEdge *result = 0 ; 9664 9665 (void)jenv; 9666 (void)jcls; 9667 arg1 = (short)jarg1; 9668 arg2 = (unsigned char)jarg2; 9669 arg3 = (unsigned char)jarg3; 9670 result = (ConvexH::HalfEdge *)new ConvexH::HalfEdge(arg1,arg2,arg3); 9671 *(ConvexH::HalfEdge **)&jresult = result; 9672 return jresult; 9673 } 9674 9675 9676 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1ConvexH_1HalfEdge(JNIEnv *jenv, jclass jcls, jlong jarg1) { 9677 ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; 9678 9679 (void)jenv; 9680 (void)jcls; 9681 arg1 = *(ConvexH::HalfEdge **)&jarg1; 9682 delete arg1; 9683 } 9684 9685 9686 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1ConvexH_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 9687 jlong jresult = 0 ; 9688 ConvexH *result = 0 ; 9689 9690 (void)jenv; 9691 (void)jcls; 9692 result = (ConvexH *)new ConvexH(); 9693 *(ConvexH **)&jresult = result; 9694 return jresult; 9695 } 9696 9697 9698 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1ConvexH(JNIEnv *jenv, jclass jcls, jlong jarg1) { 9699 ConvexH *arg1 = (ConvexH *) 0 ; 9700 9701 (void)jenv; 9702 (void)jcls; 9703 arg1 = *(ConvexH **)&jarg1; 9704 delete arg1; 9705 } 9706 9707 9708 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1vertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9709 ConvexH *arg1 = (ConvexH *) 0 ; 9710 btAlignedObjectArray< btVector3 > *arg2 = (btAlignedObjectArray< btVector3 > *) 0 ; 9711 9712 (void)jenv; 9713 (void)jcls; 9714 (void)jarg1_; 9715 (void)jarg2_; 9716 arg1 = *(ConvexH **)&jarg1; 9717 arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; 9718 if (arg1) (arg1)->vertices = *arg2; 9719 } 9720 9721 9722 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1vertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9723 jlong jresult = 0 ; 9724 ConvexH *arg1 = (ConvexH *) 0 ; 9725 btAlignedObjectArray< btVector3 > *result = 0 ; 9726 9727 (void)jenv; 9728 (void)jcls; 9729 (void)jarg1_; 9730 arg1 = *(ConvexH **)&jarg1; 9731 result = (btAlignedObjectArray< btVector3 > *)& ((arg1)->vertices); 9732 *(btAlignedObjectArray< btVector3 > **)&jresult = result; 9733 return jresult; 9734 } 9735 9736 9737 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1edges_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9738 ConvexH *arg1 = (ConvexH *) 0 ; 9739 btAlignedObjectArray< ConvexH::HalfEdge > *arg2 = (btAlignedObjectArray< ConvexH::HalfEdge > *) 0 ; 9740 9741 (void)jenv; 9742 (void)jcls; 9743 (void)jarg1_; 9744 arg1 = *(ConvexH **)&jarg1; 9745 arg2 = *(btAlignedObjectArray< ConvexH::HalfEdge > **)&jarg2; 9746 if (arg1) (arg1)->edges = *arg2; 9747 } 9748 9749 9750 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1edges_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9751 jlong jresult = 0 ; 9752 ConvexH *arg1 = (ConvexH *) 0 ; 9753 btAlignedObjectArray< ConvexH::HalfEdge > *result = 0 ; 9754 9755 (void)jenv; 9756 (void)jcls; 9757 (void)jarg1_; 9758 arg1 = *(ConvexH **)&jarg1; 9759 result = (btAlignedObjectArray< ConvexH::HalfEdge > *)& ((arg1)->edges); 9760 *(btAlignedObjectArray< ConvexH::HalfEdge > **)&jresult = result; 9761 return jresult; 9762 } 9763 9764 9765 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1facets_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9766 ConvexH *arg1 = (ConvexH *) 0 ; 9767 btAlignedObjectArray< btPlane > *arg2 = (btAlignedObjectArray< btPlane > *) 0 ; 9768 9769 (void)jenv; 9770 (void)jcls; 9771 (void)jarg1_; 9772 arg1 = *(ConvexH **)&jarg1; 9773 arg2 = *(btAlignedObjectArray< btPlane > **)&jarg2; 9774 if (arg1) (arg1)->facets = *arg2; 9775 } 9776 9777 9778 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1facets_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9779 jlong jresult = 0 ; 9780 ConvexH *arg1 = (ConvexH *) 0 ; 9781 btAlignedObjectArray< btPlane > *result = 0 ; 9782 9783 (void)jenv; 9784 (void)jcls; 9785 (void)jarg1_; 9786 arg1 = *(ConvexH **)&jarg1; 9787 result = (btAlignedObjectArray< btPlane > *)& ((arg1)->facets); 9788 *(btAlignedObjectArray< btPlane > **)&jresult = result; 9789 return jresult; 9790 } 9791 9792 9793 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1ConvexH_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3) { 9794 jlong jresult = 0 ; 9795 int arg1 ; 9796 int arg2 ; 9797 int arg3 ; 9798 ConvexH *result = 0 ; 9799 9800 (void)jenv; 9801 (void)jcls; 9802 arg1 = (int)jarg1; 9803 arg2 = (int)jarg2; 9804 arg3 = (int)jarg3; 9805 result = (ConvexH *)new ConvexH(arg1,arg2,arg3); 9806 *(ConvexH **)&jresult = result; 9807 return jresult; 9808 } 9809 9810 9811 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1x_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9812 int4 *arg1 = (int4 *) 0 ; 9813 int arg2 ; 9814 9815 (void)jenv; 9816 (void)jcls; 9817 (void)jarg1_; 9818 arg1 = *(int4 **)&jarg1; 9819 arg2 = (int)jarg2; 9820 if (arg1) (arg1)->x = arg2; 9821 } 9822 9823 9824 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1x_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9825 jint jresult = 0 ; 9826 int4 *arg1 = (int4 *) 0 ; 9827 int result; 9828 9829 (void)jenv; 9830 (void)jcls; 9831 (void)jarg1_; 9832 arg1 = *(int4 **)&jarg1; 9833 result = (int) ((arg1)->x); 9834 jresult = (jint)result; 9835 return jresult; 9836 } 9837 9838 9839 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1y_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9840 int4 *arg1 = (int4 *) 0 ; 9841 int arg2 ; 9842 9843 (void)jenv; 9844 (void)jcls; 9845 (void)jarg1_; 9846 arg1 = *(int4 **)&jarg1; 9847 arg2 = (int)jarg2; 9848 if (arg1) (arg1)->y = arg2; 9849 } 9850 9851 9852 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1y_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9853 jint jresult = 0 ; 9854 int4 *arg1 = (int4 *) 0 ; 9855 int result; 9856 9857 (void)jenv; 9858 (void)jcls; 9859 (void)jarg1_; 9860 arg1 = *(int4 **)&jarg1; 9861 result = (int) ((arg1)->y); 9862 jresult = (jint)result; 9863 return jresult; 9864 } 9865 9866 9867 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1z_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9868 int4 *arg1 = (int4 *) 0 ; 9869 int arg2 ; 9870 9871 (void)jenv; 9872 (void)jcls; 9873 (void)jarg1_; 9874 arg1 = *(int4 **)&jarg1; 9875 arg2 = (int)jarg2; 9876 if (arg1) (arg1)->z = arg2; 9877 } 9878 9879 9880 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1z_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9881 jint jresult = 0 ; 9882 int4 *arg1 = (int4 *) 0 ; 9883 int result; 9884 9885 (void)jenv; 9886 (void)jcls; 9887 (void)jarg1_; 9888 arg1 = *(int4 **)&jarg1; 9889 result = (int) ((arg1)->z); 9890 jresult = (jint)result; 9891 return jresult; 9892 } 9893 9894 9895 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1w_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9896 int4 *arg1 = (int4 *) 0 ; 9897 int arg2 ; 9898 9899 (void)jenv; 9900 (void)jcls; 9901 (void)jarg1_; 9902 arg1 = *(int4 **)&jarg1; 9903 arg2 = (int)jarg2; 9904 if (arg1) (arg1)->w = arg2; 9905 } 9906 9907 9908 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1w_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9909 jint jresult = 0 ; 9910 int4 *arg1 = (int4 *) 0 ; 9911 int result; 9912 9913 (void)jenv; 9914 (void)jcls; 9915 (void)jarg1_; 9916 arg1 = *(int4 **)&jarg1; 9917 result = (int) ((arg1)->w); 9918 jresult = (jint)result; 9919 return jresult; 9920 } 9921 9922 9923 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1int4_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 9924 jlong jresult = 0 ; 9925 int4 *result = 0 ; 9926 9927 (void)jenv; 9928 (void)jcls; 9929 result = (int4 *)new int4(); 9930 *(int4 **)&jresult = result; 9931 return jresult; 9932 } 9933 9934 9935 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1int4_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4) { 9936 jlong jresult = 0 ; 9937 int arg1 ; 9938 int arg2 ; 9939 int arg3 ; 9940 int arg4 ; 9941 int4 *result = 0 ; 9942 9943 (void)jenv; 9944 (void)jcls; 9945 arg1 = (int)jarg1; 9946 arg2 = (int)jarg2; 9947 arg3 = (int)jarg3; 9948 arg4 = (int)jarg4; 9949 result = (int4 *)new int4(arg1,arg2,arg3,arg4); 9950 *(int4 **)&jresult = result; 9951 return jresult; 9952 } 9953 9954 9955 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1int4(JNIEnv *jenv, jclass jcls, jlong jarg1) { 9956 int4 *arg1 = (int4 *) 0 ; 9957 9958 (void)jenv; 9959 (void)jcls; 9960 arg1 = *(int4 **)&jarg1; 9961 delete arg1; 9962 } 9963 9964 9965 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1PHullResult(JNIEnv *jenv, jclass jcls) { 9966 jlong jresult = 0 ; 9967 PHullResult *result = 0 ; 9968 9969 (void)jenv; 9970 (void)jcls; 9971 result = (PHullResult *)new PHullResult(); 9972 *(PHullResult **)&jresult = result; 9973 return jresult; 9974 } 9975 9976 9977 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mVcount_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 9978 PHullResult *arg1 = (PHullResult *) 0 ; 9979 unsigned int arg2 ; 9980 9981 (void)jenv; 9982 (void)jcls; 9983 (void)jarg1_; 9984 arg1 = *(PHullResult **)&jarg1; 9985 arg2 = (unsigned int)jarg2; 9986 if (arg1) (arg1)->mVcount = arg2; 9987 } 9988 9989 9990 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mVcount_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9991 jlong jresult = 0 ; 9992 PHullResult *arg1 = (PHullResult *) 0 ; 9993 unsigned int result; 9994 9995 (void)jenv; 9996 (void)jcls; 9997 (void)jarg1_; 9998 arg1 = *(PHullResult **)&jarg1; 9999 result = (unsigned int) ((arg1)->mVcount); 10000 jresult = (jlong)result; 10001 return jresult; 10002 } 10003 10004 10005 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mIndexCount_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 10006 PHullResult *arg1 = (PHullResult *) 0 ; 10007 unsigned int arg2 ; 10008 10009 (void)jenv; 10010 (void)jcls; 10011 (void)jarg1_; 10012 arg1 = *(PHullResult **)&jarg1; 10013 arg2 = (unsigned int)jarg2; 10014 if (arg1) (arg1)->mIndexCount = arg2; 10015 } 10016 10017 10018 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mIndexCount_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10019 jlong jresult = 0 ; 10020 PHullResult *arg1 = (PHullResult *) 0 ; 10021 unsigned int result; 10022 10023 (void)jenv; 10024 (void)jcls; 10025 (void)jarg1_; 10026 arg1 = *(PHullResult **)&jarg1; 10027 result = (unsigned int) ((arg1)->mIndexCount); 10028 jresult = (jlong)result; 10029 return jresult; 10030 } 10031 10032 10033 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mFaceCount_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 10034 PHullResult *arg1 = (PHullResult *) 0 ; 10035 unsigned int arg2 ; 10036 10037 (void)jenv; 10038 (void)jcls; 10039 (void)jarg1_; 10040 arg1 = *(PHullResult **)&jarg1; 10041 arg2 = (unsigned int)jarg2; 10042 if (arg1) (arg1)->mFaceCount = arg2; 10043 } 10044 10045 10046 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mFaceCount_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10047 jlong jresult = 0 ; 10048 PHullResult *arg1 = (PHullResult *) 0 ; 10049 unsigned int result; 10050 10051 (void)jenv; 10052 (void)jcls; 10053 (void)jarg1_; 10054 arg1 = *(PHullResult **)&jarg1; 10055 result = (unsigned int) ((arg1)->mFaceCount); 10056 jresult = (jlong)result; 10057 return jresult; 10058 } 10059 10060 10061 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mVertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10062 PHullResult *arg1 = (PHullResult *) 0 ; 10063 btVector3 *arg2 = (btVector3 *) 0 ; 10064 10065 (void)jenv; 10066 (void)jcls; 10067 (void)jarg1_; 10068 (void)jarg2_; 10069 arg1 = *(PHullResult **)&jarg1; 10070 arg2 = *(btVector3 **)&jarg2; 10071 if (arg1) (arg1)->mVertices = arg2; 10072 } 10073 10074 10075 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mVertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10076 jlong jresult = 0 ; 10077 PHullResult *arg1 = (PHullResult *) 0 ; 10078 btVector3 *result = 0 ; 10079 10080 (void)jenv; 10081 (void)jcls; 10082 (void)jarg1_; 10083 arg1 = *(PHullResult **)&jarg1; 10084 result = (btVector3 *) ((arg1)->mVertices); 10085 *(btVector3 **)&jresult = result; 10086 return jresult; 10087 } 10088 10089 10090 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1Indices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 10091 PHullResult *arg1 = (PHullResult *) 0 ; 10092 TUIntArray *arg2 = (TUIntArray *) 0 ; 10093 10094 (void)jenv; 10095 (void)jcls; 10096 (void)jarg1_; 10097 arg1 = *(PHullResult **)&jarg1; 10098 arg2 = *(TUIntArray **)&jarg2; 10099 if (arg1) (arg1)->m_Indices = *arg2; 10100 } 10101 10102 10103 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1Indices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10104 jlong jresult = 0 ; 10105 PHullResult *arg1 = (PHullResult *) 0 ; 10106 TUIntArray *result = 0 ; 10107 10108 (void)jenv; 10109 (void)jcls; 10110 (void)jarg1_; 10111 arg1 = *(PHullResult **)&jarg1; 10112 result = (TUIntArray *)& ((arg1)->m_Indices); 10113 *(TUIntArray **)&jresult = result; 10114 return jresult; 10115 } 10116 10117 10118 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1PHullResult(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10119 PHullResult *arg1 = (PHullResult *) 0 ; 10120 10121 (void)jenv; 10122 (void)jcls; 10123 arg1 = *(PHullResult **)&jarg1; 10124 delete arg1; 10125 } 10126 10127 10128 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullLibrary_1vertexIndexMapping_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 10129 HullLibrary *arg1 = (HullLibrary *) 0 ; 10130 btAlignedObjectArray< int > *arg2 = (btAlignedObjectArray< int > *) 0 ; 10131 10132 (void)jenv; 10133 (void)jcls; 10134 (void)jarg1_; 10135 arg1 = *(HullLibrary **)&jarg1; 10136 arg2 = *(btAlignedObjectArray< int > **)&jarg2; 10137 if (arg1) (arg1)->m_vertexIndexMapping = *arg2; 10138 } 10139 10140 10141 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullLibrary_1vertexIndexMapping_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10142 jlong jresult = 0 ; 10143 HullLibrary *arg1 = (HullLibrary *) 0 ; 10144 btAlignedObjectArray< int > *result = 0 ; 10145 10146 (void)jenv; 10147 (void)jcls; 10148 (void)jarg1_; 10149 arg1 = *(HullLibrary **)&jarg1; 10150 result = (btAlignedObjectArray< int > *)& ((arg1)->m_vertexIndexMapping); 10151 *(btAlignedObjectArray< int > **)&jresult = result; 10152 return jresult; 10153 } 10154 10155 10156 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullLibrary_1CreateConvexHull(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) { 10157 jint jresult = 0 ; 10158 HullLibrary *arg1 = (HullLibrary *) 0 ; 10159 HullDesc *arg2 = 0 ; 10160 HullResult *arg3 = 0 ; 10161 HullError result; 10162 10163 (void)jenv; 10164 (void)jcls; 10165 (void)jarg1_; 10166 (void)jarg2_; 10167 (void)jarg3_; 10168 arg1 = *(HullLibrary **)&jarg1; 10169 arg2 = *(HullDesc **)&jarg2; 10170 if (!arg2) { 10171 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "HullDesc const & reference is null"); 10172 return 0; 10173 } 10174 arg3 = *(HullResult **)&jarg3; 10175 if (!arg3) { 10176 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "HullResult & reference is null"); 10177 return 0; 10178 } 10179 result = (HullError)(arg1)->CreateConvexHull((HullDesc const &)*arg2,*arg3); 10180 jresult = (jint)result; 10181 return jresult; 10182 } 10183 10184 10185 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullLibrary_1ReleaseResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10186 jint jresult = 0 ; 10187 HullLibrary *arg1 = (HullLibrary *) 0 ; 10188 HullResult *arg2 = 0 ; 10189 HullError result; 10190 10191 (void)jenv; 10192 (void)jcls; 10193 (void)jarg1_; 10194 (void)jarg2_; 10195 arg1 = *(HullLibrary **)&jarg1; 10196 arg2 = *(HullResult **)&jarg2; 10197 if (!arg2) { 10198 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "HullResult & reference is null"); 10199 return 0; 10200 } 10201 result = (HullError)(arg1)->ReleaseResult(*arg2); 10202 jresult = (jint)result; 10203 return jresult; 10204 } 10205 10206 10207 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1HullLibrary(JNIEnv *jenv, jclass jcls) { 10208 jlong jresult = 0 ; 10209 HullLibrary *result = 0 ; 10210 10211 (void)jenv; 10212 (void)jcls; 10213 result = (HullLibrary *)new HullLibrary(); 10214 *(HullLibrary **)&jresult = result; 10215 return jresult; 10216 } 10217 10218 10219 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1HullLibrary(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10220 HullLibrary *arg1 = (HullLibrary *) 0 ; 10221 10222 (void)jenv; 10223 (void)jcls; 10224 arg1 = *(HullLibrary **)&jarg1; 10225 delete arg1; 10226 } 10227 10228 10229 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1GrahamVector3(JNIEnv *jenv, jclass jcls, jobject jarg1, jint jarg2) { 10230 jlong jresult = 0 ; 10231 btVector3 *arg1 = 0 ; 10232 int arg2 ; 10233 GrahamVector3 *result = 0 ; 10234 10235 (void)jenv; 10236 (void)jcls; 10237 btVector3 local_arg1; 10238 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 10239 arg1 = &local_arg1; 10240 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 10241 arg2 = (int)jarg2; 10242 result = (GrahamVector3 *)new GrahamVector3((btVector3 const &)*arg1,arg2); 10243 *(GrahamVector3 **)&jresult = result; 10244 return jresult; 10245 } 10246 10247 10248 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamVector3_1angle_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 10249 GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; 10250 btScalar arg2 ; 10251 10252 (void)jenv; 10253 (void)jcls; 10254 (void)jarg1_; 10255 arg1 = *(GrahamVector3 **)&jarg1; 10256 arg2 = (btScalar)jarg2; 10257 if (arg1) (arg1)->m_angle = arg2; 10258 } 10259 10260 10261 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamVector3_1angle_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10262 jfloat jresult = 0 ; 10263 GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; 10264 btScalar result; 10265 10266 (void)jenv; 10267 (void)jcls; 10268 (void)jarg1_; 10269 arg1 = *(GrahamVector3 **)&jarg1; 10270 result = (btScalar) ((arg1)->m_angle); 10271 jresult = (jfloat)result; 10272 return jresult; 10273 } 10274 10275 10276 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamVector3_1orgIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10277 GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; 10278 int arg2 ; 10279 10280 (void)jenv; 10281 (void)jcls; 10282 (void)jarg1_; 10283 arg1 = *(GrahamVector3 **)&jarg1; 10284 arg2 = (int)jarg2; 10285 if (arg1) (arg1)->m_orgIndex = arg2; 10286 } 10287 10288 10289 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamVector3_1orgIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10290 jint jresult = 0 ; 10291 GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; 10292 int result; 10293 10294 (void)jenv; 10295 (void)jcls; 10296 (void)jarg1_; 10297 arg1 = *(GrahamVector3 **)&jarg1; 10298 result = (int) ((arg1)->m_orgIndex); 10299 jresult = (jint)result; 10300 return jresult; 10301 } 10302 10303 10304 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1GrahamVector3(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10305 GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; 10306 10307 (void)jenv; 10308 (void)jcls; 10309 arg1 = *(GrahamVector3 **)&jarg1; 10310 delete arg1; 10311 } 10312 10313 10314 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAngleCompareFunc_1anchor_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10315 btAngleCompareFunc *arg1 = (btAngleCompareFunc *) 0 ; 10316 btVector3 *arg2 = (btVector3 *) 0 ; 10317 10318 (void)jenv; 10319 (void)jcls; 10320 (void)jarg1_; 10321 (void)jarg2_; 10322 arg1 = *(btAngleCompareFunc **)&jarg1; 10323 arg2 = *(btVector3 **)&jarg2; 10324 if (arg1) (arg1)->m_anchor = *arg2; 10325 } 10326 10327 10328 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAngleCompareFunc_1anchor_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10329 jlong jresult = 0 ; 10330 btAngleCompareFunc *arg1 = (btAngleCompareFunc *) 0 ; 10331 btVector3 *result = 0 ; 10332 10333 (void)jenv; 10334 (void)jcls; 10335 (void)jarg1_; 10336 arg1 = *(btAngleCompareFunc **)&jarg1; 10337 result = (btVector3 *)& ((arg1)->m_anchor); 10338 *(btVector3 **)&jresult = result; 10339 return jresult; 10340 } 10341 10342 10343 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btAngleCompareFunc(JNIEnv *jenv, jclass jcls, jobject jarg1) { 10344 jlong jresult = 0 ; 10345 btVector3 *arg1 = 0 ; 10346 btAngleCompareFunc *result = 0 ; 10347 10348 (void)jenv; 10349 (void)jcls; 10350 btVector3 local_arg1; 10351 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 10352 arg1 = &local_arg1; 10353 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 10354 result = (btAngleCompareFunc *)new btAngleCompareFunc((btVector3 const &)*arg1); 10355 *(btAngleCompareFunc **)&jresult = result; 10356 return jresult; 10357 } 10358 10359 10360 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btAngleCompareFunc(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10361 btAngleCompareFunc *arg1 = (btAngleCompareFunc *) 0 ; 10362 10363 (void)jenv; 10364 (void)jcls; 10365 arg1 = *(btAngleCompareFunc **)&jarg1; 10366 delete arg1; 10367 } 10368 10369 10370 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamScanConvexHull2D(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jobject jarg3) { 10371 btAlignedObjectArray< GrahamVector3 > *arg1 = 0 ; 10372 btAlignedObjectArray< GrahamVector3 > *arg2 = 0 ; 10373 btVector3 *arg3 = 0 ; 10374 10375 (void)jenv; 10376 (void)jcls; 10377 arg1 = *(btAlignedObjectArray< GrahamVector3 > **)&jarg1; 10378 if (!arg1) { 10379 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< GrahamVector3 > & reference is null"); 10380 return ; 10381 } 10382 arg2 = *(btAlignedObjectArray< GrahamVector3 > **)&jarg2; 10383 if (!arg2) { 10384 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< GrahamVector3 > & reference is null"); 10385 return ; 10386 } 10387 btVector3 local_arg3; 10388 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 10389 arg3 = &local_arg3; 10390 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 10391 GrahamScanConvexHull2D(*arg1,*arg2,(btVector3 const &)*arg3); 10392 } 10393 10394 10395 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btPoolAllocator(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) { 10396 jlong jresult = 0 ; 10397 int arg1 ; 10398 int arg2 ; 10399 btPoolAllocator *result = 0 ; 10400 10401 (void)jenv; 10402 (void)jcls; 10403 arg1 = (int)jarg1; 10404 arg2 = (int)jarg2; 10405 result = (btPoolAllocator *)new btPoolAllocator(arg1,arg2); 10406 *(btPoolAllocator **)&jresult = result; 10407 return jresult; 10408 } 10409 10410 10411 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btPoolAllocator(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10412 btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; 10413 10414 (void)jenv; 10415 (void)jcls; 10416 arg1 = *(btPoolAllocator **)&jarg1; 10417 delete arg1; 10418 } 10419 10420 10421 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1getFreeCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10422 jint jresult = 0 ; 10423 btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; 10424 int result; 10425 10426 (void)jenv; 10427 (void)jcls; 10428 (void)jarg1_; 10429 arg1 = *(btPoolAllocator **)&jarg1; 10430 result = (int)((btPoolAllocator const *)arg1)->getFreeCount(); 10431 jresult = (jint)result; 10432 return jresult; 10433 } 10434 10435 10436 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1getUsedCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10437 jint jresult = 0 ; 10438 btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; 10439 int result; 10440 10441 (void)jenv; 10442 (void)jcls; 10443 (void)jarg1_; 10444 arg1 = *(btPoolAllocator **)&jarg1; 10445 result = (int)((btPoolAllocator const *)arg1)->getUsedCount(); 10446 jresult = (jint)result; 10447 return jresult; 10448 } 10449 10450 10451 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1getMaxCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10452 jint jresult = 0 ; 10453 btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; 10454 int result; 10455 10456 (void)jenv; 10457 (void)jcls; 10458 (void)jarg1_; 10459 arg1 = *(btPoolAllocator **)&jarg1; 10460 result = (int)((btPoolAllocator const *)arg1)->getMaxCount(); 10461 jresult = (jint)result; 10462 return jresult; 10463 } 10464 10465 10466 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1allocate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10467 jlong jresult = 0 ; 10468 btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; 10469 int arg2 ; 10470 void *result = 0 ; 10471 10472 (void)jenv; 10473 (void)jcls; 10474 (void)jarg1_; 10475 arg1 = *(btPoolAllocator **)&jarg1; 10476 arg2 = (int)jarg2; 10477 result = (void *)(arg1)->allocate(arg2); 10478 jresult = (jlong)result; 10479 return jresult; 10480 } 10481 10482 10483 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1validPtr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 10484 jboolean jresult = 0 ; 10485 btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; 10486 void *arg2 = (void *) 0 ; 10487 bool result; 10488 10489 (void)jenv; 10490 (void)jcls; 10491 (void)jarg1_; 10492 arg1 = *(btPoolAllocator **)&jarg1; 10493 arg2 = (void *)jarg2; 10494 result = (bool)(arg1)->validPtr(arg2); 10495 jresult = (jboolean)result; 10496 return jresult; 10497 } 10498 10499 10500 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1freeMemory(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 10501 btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; 10502 void *arg2 = (void *) 0 ; 10503 10504 (void)jenv; 10505 (void)jcls; 10506 (void)jarg1_; 10507 arg1 = *(btPoolAllocator **)&jarg1; 10508 arg2 = (void *)jarg2; 10509 (arg1)->freeMemory(arg2); 10510 } 10511 10512 10513 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1getElementSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10514 jint jresult = 0 ; 10515 btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; 10516 int result; 10517 10518 (void)jenv; 10519 (void)jcls; 10520 (void)jarg1_; 10521 arg1 = *(btPoolAllocator **)&jarg1; 10522 result = (int)((btPoolAllocator const *)arg1)->getElementSize(); 10523 jresult = (jint)result; 10524 return jresult; 10525 } 10526 10527 10528 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1getPoolAddress_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10529 jobject jresult = 0 ; 10530 btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; 10531 unsigned char *result = 0 ; 10532 10533 (void)jenv; 10534 (void)jcls; 10535 (void)jarg1_; 10536 arg1 = *(btPoolAllocator **)&jarg1; 10537 result = (unsigned char *)(arg1)->getPoolAddress(); 10538 *(unsigned char **)&jresult = result; 10539 return jresult; 10540 } 10541 10542 10543 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1Edge_1getSourceVertex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10544 jint jresult = 0 ; 10545 btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; 10546 int result; 10547 10548 (void)jenv; 10549 (void)jcls; 10550 (void)jarg1_; 10551 arg1 = *(btConvexHullComputer::Edge **)&jarg1; 10552 result = (int)((btConvexHullComputer::Edge const *)arg1)->getSourceVertex(); 10553 jresult = (jint)result; 10554 return jresult; 10555 } 10556 10557 10558 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1Edge_1getTargetVertex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10559 jint jresult = 0 ; 10560 btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; 10561 int result; 10562 10563 (void)jenv; 10564 (void)jcls; 10565 (void)jarg1_; 10566 arg1 = *(btConvexHullComputer::Edge **)&jarg1; 10567 result = (int)((btConvexHullComputer::Edge const *)arg1)->getTargetVertex(); 10568 jresult = (jint)result; 10569 return jresult; 10570 } 10571 10572 10573 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1Edge_1getNextEdgeOfVertex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10574 jlong jresult = 0 ; 10575 btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; 10576 btConvexHullComputer::Edge *result = 0 ; 10577 10578 (void)jenv; 10579 (void)jcls; 10580 (void)jarg1_; 10581 arg1 = *(btConvexHullComputer::Edge **)&jarg1; 10582 result = (btConvexHullComputer::Edge *)((btConvexHullComputer::Edge const *)arg1)->getNextEdgeOfVertex(); 10583 *(btConvexHullComputer::Edge **)&jresult = result; 10584 return jresult; 10585 } 10586 10587 10588 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1Edge_1getNextEdgeOfFace(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10589 jlong jresult = 0 ; 10590 btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; 10591 btConvexHullComputer::Edge *result = 0 ; 10592 10593 (void)jenv; 10594 (void)jcls; 10595 (void)jarg1_; 10596 arg1 = *(btConvexHullComputer::Edge **)&jarg1; 10597 result = (btConvexHullComputer::Edge *)((btConvexHullComputer::Edge const *)arg1)->getNextEdgeOfFace(); 10598 *(btConvexHullComputer::Edge **)&jresult = result; 10599 return jresult; 10600 } 10601 10602 10603 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1Edge_1getReverseEdge(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10604 jlong jresult = 0 ; 10605 btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; 10606 btConvexHullComputer::Edge *result = 0 ; 10607 10608 (void)jenv; 10609 (void)jcls; 10610 (void)jarg1_; 10611 arg1 = *(btConvexHullComputer::Edge **)&jarg1; 10612 result = (btConvexHullComputer::Edge *)((btConvexHullComputer::Edge const *)arg1)->getReverseEdge(); 10613 *(btConvexHullComputer::Edge **)&jresult = result; 10614 return jresult; 10615 } 10616 10617 10618 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btConvexHullComputer_1Edge(JNIEnv *jenv, jclass jcls) { 10619 jlong jresult = 0 ; 10620 btConvexHullComputer::Edge *result = 0 ; 10621 10622 (void)jenv; 10623 (void)jcls; 10624 result = (btConvexHullComputer::Edge *)new btConvexHullComputer::Edge(); 10625 *(btConvexHullComputer::Edge **)&jresult = result; 10626 return jresult; 10627 } 10628 10629 10630 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btConvexHullComputer_1Edge(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10631 btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; 10632 10633 (void)jenv; 10634 (void)jcls; 10635 arg1 = *(btConvexHullComputer::Edge **)&jarg1; 10636 delete arg1; 10637 } 10638 10639 10640 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1vertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10641 btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; 10642 btAlignedObjectArray< btVector3 > *arg2 = (btAlignedObjectArray< btVector3 > *) 0 ; 10643 10644 (void)jenv; 10645 (void)jcls; 10646 (void)jarg1_; 10647 (void)jarg2_; 10648 arg1 = *(btConvexHullComputer **)&jarg1; 10649 arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; 10650 if (arg1) (arg1)->vertices = *arg2; 10651 } 10652 10653 10654 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1vertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10655 jlong jresult = 0 ; 10656 btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; 10657 btAlignedObjectArray< btVector3 > *result = 0 ; 10658 10659 (void)jenv; 10660 (void)jcls; 10661 (void)jarg1_; 10662 arg1 = *(btConvexHullComputer **)&jarg1; 10663 result = (btAlignedObjectArray< btVector3 > *)& ((arg1)->vertices); 10664 *(btAlignedObjectArray< btVector3 > **)&jresult = result; 10665 return jresult; 10666 } 10667 10668 10669 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1edges_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 10670 btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; 10671 btAlignedObjectArray< btConvexHullComputer::Edge > *arg2 = (btAlignedObjectArray< btConvexHullComputer::Edge > *) 0 ; 10672 10673 (void)jenv; 10674 (void)jcls; 10675 (void)jarg1_; 10676 arg1 = *(btConvexHullComputer **)&jarg1; 10677 arg2 = *(btAlignedObjectArray< btConvexHullComputer::Edge > **)&jarg2; 10678 if (arg1) (arg1)->edges = *arg2; 10679 } 10680 10681 10682 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1edges_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10683 jlong jresult = 0 ; 10684 btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; 10685 btAlignedObjectArray< btConvexHullComputer::Edge > *result = 0 ; 10686 10687 (void)jenv; 10688 (void)jcls; 10689 (void)jarg1_; 10690 arg1 = *(btConvexHullComputer **)&jarg1; 10691 result = (btAlignedObjectArray< btConvexHullComputer::Edge > *)& ((arg1)->edges); 10692 *(btAlignedObjectArray< btConvexHullComputer::Edge > **)&jresult = result; 10693 return jresult; 10694 } 10695 10696 10697 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1faces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 10698 btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; 10699 btAlignedObjectArray< int > *arg2 = (btAlignedObjectArray< int > *) 0 ; 10700 10701 (void)jenv; 10702 (void)jcls; 10703 (void)jarg1_; 10704 arg1 = *(btConvexHullComputer **)&jarg1; 10705 arg2 = *(btAlignedObjectArray< int > **)&jarg2; 10706 if (arg1) (arg1)->faces = *arg2; 10707 } 10708 10709 10710 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1faces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10711 jlong jresult = 0 ; 10712 btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; 10713 btAlignedObjectArray< int > *result = 0 ; 10714 10715 (void)jenv; 10716 (void)jcls; 10717 (void)jarg1_; 10718 arg1 = *(btConvexHullComputer **)&jarg1; 10719 result = (btAlignedObjectArray< int > *)& ((arg1)->faces); 10720 *(btAlignedObjectArray< int > **)&jresult = result; 10721 return jresult; 10722 } 10723 10724 10725 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1compute_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jint jarg3, jint jarg4, jfloat jarg5, jfloat jarg6) { 10726 jfloat jresult = 0 ; 10727 btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; 10728 float *arg2 = (float *) 0 ; 10729 int arg3 ; 10730 int arg4 ; 10731 btScalar arg5 ; 10732 btScalar arg6 ; 10733 btScalar result; 10734 10735 (void)jenv; 10736 (void)jcls; 10737 (void)jarg1_; 10738 arg1 = *(btConvexHullComputer **)&jarg1; 10739 { 10740 arg2 = (float*)jenv->GetDirectBufferAddress(jarg2); 10741 if (arg2 == NULL) { 10742 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 10743 } 10744 } 10745 arg3 = (int)jarg3; 10746 arg4 = (int)jarg4; 10747 arg5 = (btScalar)jarg5; 10748 arg6 = (btScalar)jarg6; 10749 result = (btScalar)(arg1)->compute((float const *)arg2,arg3,arg4,arg5,arg6); 10750 jresult = (jfloat)result; 10751 10752 return jresult; 10753 } 10754 10755 10756 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1compute_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jint jarg3, jint jarg4, jfloat jarg5, jfloat jarg6) { 10757 jfloat jresult = 0 ; 10758 btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; 10759 double *arg2 = (double *) 0 ; 10760 int arg3 ; 10761 int arg4 ; 10762 btScalar arg5 ; 10763 btScalar arg6 ; 10764 btScalar result; 10765 10766 (void)jenv; 10767 (void)jcls; 10768 (void)jarg1_; 10769 arg1 = *(btConvexHullComputer **)&jarg1; 10770 { 10771 arg2 = (double*)jenv->GetDirectBufferAddress(jarg2); 10772 if (arg2 == NULL) { 10773 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 10774 } 10775 } 10776 arg3 = (int)jarg3; 10777 arg4 = (int)jarg4; 10778 arg5 = (btScalar)jarg5; 10779 arg6 = (btScalar)jarg6; 10780 result = (btScalar)(arg1)->compute((double const *)arg2,arg3,arg4,arg5,arg6); 10781 jresult = (jfloat)result; 10782 10783 return jresult; 10784 } 10785 10786 10787 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btConvexHullComputer(JNIEnv *jenv, jclass jcls) { 10788 jlong jresult = 0 ; 10789 btConvexHullComputer *result = 0 ; 10790 10791 (void)jenv; 10792 (void)jcls; 10793 result = (btConvexHullComputer *)new btConvexHullComputer(); 10794 *(btConvexHullComputer **)&jresult = result; 10795 return jresult; 10796 } 10797 10798 10799 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btConvexHullComputer(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10800 btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; 10801 10802 (void)jenv; 10803 (void)jcls; 10804 arg1 = *(btConvexHullComputer **)&jarg1; 10805 delete arg1; 10806 } 10807 10808 10809 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btGEN_1Link_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 10810 jlong jresult = 0 ; 10811 btGEN_Link *result = 0 ; 10812 10813 (void)jenv; 10814 (void)jcls; 10815 result = (btGEN_Link *)new btGEN_Link(); 10816 *(btGEN_Link **)&jresult = result; 10817 return jresult; 10818 } 10819 10820 10821 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btGEN_1Link_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10822 jlong jresult = 0 ; 10823 btGEN_Link *arg1 = (btGEN_Link *) 0 ; 10824 btGEN_Link *arg2 = (btGEN_Link *) 0 ; 10825 btGEN_Link *result = 0 ; 10826 10827 (void)jenv; 10828 (void)jcls; 10829 (void)jarg1_; 10830 (void)jarg2_; 10831 arg1 = *(btGEN_Link **)&jarg1; 10832 arg2 = *(btGEN_Link **)&jarg2; 10833 result = (btGEN_Link *)new btGEN_Link(arg1,arg2); 10834 *(btGEN_Link **)&jresult = result; 10835 return jresult; 10836 } 10837 10838 10839 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1getNext(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10840 jlong jresult = 0 ; 10841 btGEN_Link *arg1 = (btGEN_Link *) 0 ; 10842 btGEN_Link *result = 0 ; 10843 10844 (void)jenv; 10845 (void)jcls; 10846 (void)jarg1_; 10847 arg1 = *(btGEN_Link **)&jarg1; 10848 result = (btGEN_Link *)((btGEN_Link const *)arg1)->getNext(); 10849 *(btGEN_Link **)&jresult = result; 10850 return jresult; 10851 } 10852 10853 10854 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1getPrev(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10855 jlong jresult = 0 ; 10856 btGEN_Link *arg1 = (btGEN_Link *) 0 ; 10857 btGEN_Link *result = 0 ; 10858 10859 (void)jenv; 10860 (void)jcls; 10861 (void)jarg1_; 10862 arg1 = *(btGEN_Link **)&jarg1; 10863 result = (btGEN_Link *)((btGEN_Link const *)arg1)->getPrev(); 10864 *(btGEN_Link **)&jresult = result; 10865 return jresult; 10866 } 10867 10868 10869 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1isHead(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10870 jboolean jresult = 0 ; 10871 btGEN_Link *arg1 = (btGEN_Link *) 0 ; 10872 bool result; 10873 10874 (void)jenv; 10875 (void)jcls; 10876 (void)jarg1_; 10877 arg1 = *(btGEN_Link **)&jarg1; 10878 result = (bool)((btGEN_Link const *)arg1)->isHead(); 10879 jresult = (jboolean)result; 10880 return jresult; 10881 } 10882 10883 10884 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1isTail(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10885 jboolean jresult = 0 ; 10886 btGEN_Link *arg1 = (btGEN_Link *) 0 ; 10887 bool result; 10888 10889 (void)jenv; 10890 (void)jcls; 10891 (void)jarg1_; 10892 arg1 = *(btGEN_Link **)&jarg1; 10893 result = (bool)((btGEN_Link const *)arg1)->isTail(); 10894 jresult = (jboolean)result; 10895 return jresult; 10896 } 10897 10898 10899 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1insertBefore(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10900 btGEN_Link *arg1 = (btGEN_Link *) 0 ; 10901 btGEN_Link *arg2 = (btGEN_Link *) 0 ; 10902 10903 (void)jenv; 10904 (void)jcls; 10905 (void)jarg1_; 10906 (void)jarg2_; 10907 arg1 = *(btGEN_Link **)&jarg1; 10908 arg2 = *(btGEN_Link **)&jarg2; 10909 (arg1)->insertBefore(arg2); 10910 } 10911 10912 10913 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1insertAfter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10914 btGEN_Link *arg1 = (btGEN_Link *) 0 ; 10915 btGEN_Link *arg2 = (btGEN_Link *) 0 ; 10916 10917 (void)jenv; 10918 (void)jcls; 10919 (void)jarg1_; 10920 (void)jarg2_; 10921 arg1 = *(btGEN_Link **)&jarg1; 10922 arg2 = *(btGEN_Link **)&jarg2; 10923 (arg1)->insertAfter(arg2); 10924 } 10925 10926 10927 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10928 btGEN_Link *arg1 = (btGEN_Link *) 0 ; 10929 10930 (void)jenv; 10931 (void)jcls; 10932 (void)jarg1_; 10933 arg1 = *(btGEN_Link **)&jarg1; 10934 (arg1)->remove(); 10935 } 10936 10937 10938 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btGEN_1Link(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10939 btGEN_Link *arg1 = (btGEN_Link *) 0 ; 10940 10941 (void)jenv; 10942 (void)jcls; 10943 arg1 = *(btGEN_Link **)&jarg1; 10944 delete arg1; 10945 } 10946 10947 10948 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btGEN_1List(JNIEnv *jenv, jclass jcls) { 10949 jlong jresult = 0 ; 10950 btGEN_List *result = 0 ; 10951 10952 (void)jenv; 10953 (void)jcls; 10954 result = (btGEN_List *)new btGEN_List(); 10955 *(btGEN_List **)&jresult = result; 10956 return jresult; 10957 } 10958 10959 10960 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1List_1getHead(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10961 jlong jresult = 0 ; 10962 btGEN_List *arg1 = (btGEN_List *) 0 ; 10963 btGEN_Link *result = 0 ; 10964 10965 (void)jenv; 10966 (void)jcls; 10967 (void)jarg1_; 10968 arg1 = *(btGEN_List **)&jarg1; 10969 result = (btGEN_Link *)((btGEN_List const *)arg1)->getHead(); 10970 *(btGEN_Link **)&jresult = result; 10971 return jresult; 10972 } 10973 10974 10975 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1List_1getTail(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10976 jlong jresult = 0 ; 10977 btGEN_List *arg1 = (btGEN_List *) 0 ; 10978 btGEN_Link *result = 0 ; 10979 10980 (void)jenv; 10981 (void)jcls; 10982 (void)jarg1_; 10983 arg1 = *(btGEN_List **)&jarg1; 10984 result = (btGEN_Link *)((btGEN_List const *)arg1)->getTail(); 10985 *(btGEN_Link **)&jresult = result; 10986 return jresult; 10987 } 10988 10989 10990 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1List_1addHead(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10991 btGEN_List *arg1 = (btGEN_List *) 0 ; 10992 btGEN_Link *arg2 = (btGEN_Link *) 0 ; 10993 10994 (void)jenv; 10995 (void)jcls; 10996 (void)jarg1_; 10997 (void)jarg2_; 10998 arg1 = *(btGEN_List **)&jarg1; 10999 arg2 = *(btGEN_Link **)&jarg2; 11000 (arg1)->addHead(arg2); 11001 } 11002 11003 11004 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1List_1addTail(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11005 btGEN_List *arg1 = (btGEN_List *) 0 ; 11006 btGEN_Link *arg2 = (btGEN_Link *) 0 ; 11007 11008 (void)jenv; 11009 (void)jcls; 11010 (void)jarg1_; 11011 (void)jarg2_; 11012 arg1 = *(btGEN_List **)&jarg1; 11013 arg2 = *(btGEN_Link **)&jarg2; 11014 (arg1)->addTail(arg2); 11015 } 11016 11017 11018 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btGEN_1List(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11019 btGEN_List *arg1 = (btGEN_List *) 0 ; 11020 11021 (void)jenv; 11022 (void)jcls; 11023 arg1 = *(btGEN_List **)&jarg1; 11024 delete arg1; 11025 } 11026 11027 11028 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAlignedAllocInternal(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { 11029 jlong jresult = 0 ; 11030 size_t arg1 ; 11031 int arg2 ; 11032 void *result = 0 ; 11033 11034 (void)jenv; 11035 (void)jcls; 11036 arg1 = (size_t)jarg1; 11037 arg2 = (int)jarg2; 11038 result = (void *)btAlignedAllocInternal(arg1,arg2); 11039 jresult = (jlong)result; 11040 return jresult; 11041 } 11042 11043 11044 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAlignedFreeInternal(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11045 void *arg1 = (void *) 0 ; 11046 11047 (void)jenv; 11048 (void)jcls; 11049 arg1 = (void *)jarg1; 11050 btAlignedFreeInternal(arg1); 11051 } 11052 11053 11054 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAlignedAllocSetCustom(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { 11055 btAllocFunc *arg1 = (btAllocFunc *) 0 ; 11056 btFreeFunc *arg2 = (btFreeFunc *) 0 ; 11057 11058 (void)jenv; 11059 (void)jcls; 11060 arg1 = *(btAllocFunc **)&jarg1; 11061 arg2 = *(btFreeFunc **)&jarg2; 11062 btAlignedAllocSetCustom(arg1,arg2); 11063 } 11064 11065 11066 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAlignedAllocSetCustomAligned(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { 11067 btAlignedAllocFunc *arg1 = (btAlignedAllocFunc *) 0 ; 11068 btAlignedFreeFunc *arg2 = (btAlignedFreeFunc *) 0 ; 11069 11070 (void)jenv; 11071 (void)jcls; 11072 arg1 = *(btAlignedAllocFunc **)&jarg1; 11073 arg2 = *(btAlignedFreeFunc **)&jarg2; 11074 btAlignedAllocSetCustomAligned(arg1,arg2); 11075 } 11076 11077 11078 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1string_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 11079 btHashString *arg1 = (btHashString *) 0 ; 11080 char *arg2 = (char *) 0 ; 11081 11082 (void)jenv; 11083 (void)jcls; 11084 (void)jarg1_; 11085 arg1 = *(btHashString **)&jarg1; 11086 arg2 = 0; 11087 if (jarg2) { 11088 arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); 11089 if (!arg2) return ; 11090 } 11091 { 11092 if (arg2) { 11093 arg1->m_string = (char const *) (new char[strlen((const char *)arg2)+1]); 11094 strcpy((char *)arg1->m_string, (const char *)arg2); 11095 } else { 11096 arg1->m_string = 0; 11097 } 11098 } 11099 if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); 11100 } 11101 11102 11103 SWIGEXPORT jstring JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1string_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11104 jstring jresult = 0 ; 11105 btHashString *arg1 = (btHashString *) 0 ; 11106 char *result = 0 ; 11107 11108 (void)jenv; 11109 (void)jcls; 11110 (void)jarg1_; 11111 arg1 = *(btHashString **)&jarg1; 11112 result = (char *) ((arg1)->m_string); 11113 if (result) jresult = jenv->NewStringUTF((const char *)result); 11114 return jresult; 11115 } 11116 11117 11118 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 11119 btHashString *arg1 = (btHashString *) 0 ; 11120 unsigned int arg2 ; 11121 11122 (void)jenv; 11123 (void)jcls; 11124 (void)jarg1_; 11125 arg1 = *(btHashString **)&jarg1; 11126 arg2 = (unsigned int)jarg2; 11127 if (arg1) (arg1)->m_hash = arg2; 11128 } 11129 11130 11131 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11132 jlong jresult = 0 ; 11133 btHashString *arg1 = (btHashString *) 0 ; 11134 unsigned int result; 11135 11136 (void)jenv; 11137 (void)jcls; 11138 (void)jarg1_; 11139 arg1 = *(btHashString **)&jarg1; 11140 result = (unsigned int) ((arg1)->m_hash); 11141 jresult = (jlong)result; 11142 return jresult; 11143 } 11144 11145 11146 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btHashString(JNIEnv *jenv, jclass jcls, jstring jarg1) { 11147 jlong jresult = 0 ; 11148 char *arg1 = (char *) 0 ; 11149 btHashString *result = 0 ; 11150 11151 (void)jenv; 11152 (void)jcls; 11153 arg1 = 0; 11154 if (jarg1) { 11155 arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0); 11156 if (!arg1) return 0; 11157 } 11158 result = (btHashString *)new btHashString((char const *)arg1); 11159 *(btHashString **)&jresult = result; 11160 if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1); 11161 return jresult; 11162 } 11163 11164 11165 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1portableStringCompare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) { 11166 jint jresult = 0 ; 11167 btHashString *arg1 = (btHashString *) 0 ; 11168 char *arg2 = (char *) 0 ; 11169 char *arg3 = (char *) 0 ; 11170 int result; 11171 11172 (void)jenv; 11173 (void)jcls; 11174 (void)jarg1_; 11175 arg1 = *(btHashString **)&jarg1; 11176 arg2 = 0; 11177 if (jarg2) { 11178 arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); 11179 if (!arg2) return 0; 11180 } 11181 arg3 = 0; 11182 if (jarg3) { 11183 arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); 11184 if (!arg3) return 0; 11185 } 11186 result = (int)((btHashString const *)arg1)->portableStringCompare((char const *)arg2,(char const *)arg3); 11187 jresult = (jint)result; 11188 if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); 11189 if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); 11190 return jresult; 11191 } 11192 11193 11194 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1equals(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11195 jboolean jresult = 0 ; 11196 btHashString *arg1 = (btHashString *) 0 ; 11197 btHashString *arg2 = 0 ; 11198 bool result; 11199 11200 (void)jenv; 11201 (void)jcls; 11202 (void)jarg1_; 11203 (void)jarg2_; 11204 arg1 = *(btHashString **)&jarg1; 11205 arg2 = *(btHashString **)&jarg2; 11206 if (!arg2) { 11207 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btHashString const & reference is null"); 11208 return 0; 11209 } 11210 result = (bool)((btHashString const *)arg1)->equals((btHashString const &)*arg2); 11211 jresult = (jboolean)result; 11212 return jresult; 11213 } 11214 11215 11216 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btHashString(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11217 btHashString *arg1 = (btHashString *) 0 ; 11218 11219 (void)jenv; 11220 (void)jcls; 11221 arg1 = *(btHashString **)&jarg1; 11222 delete arg1; 11223 } 11224 11225 11226 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_BT_1HASH_1NULL_1get(JNIEnv *jenv, jclass jcls) { 11227 jint jresult = 0 ; 11228 int result; 11229 11230 (void)jenv; 11231 (void)jcls; 11232 result = (int)(int)BT_HASH_NULL; 11233 jresult = (jint)result; 11234 return jresult; 11235 } 11236 11237 11238 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btHashInt(JNIEnv *jenv, jclass jcls, jint jarg1) { 11239 jlong jresult = 0 ; 11240 int arg1 ; 11241 btHashInt *result = 0 ; 11242 11243 (void)jenv; 11244 (void)jcls; 11245 arg1 = (int)jarg1; 11246 result = (btHashInt *)new btHashInt(arg1); 11247 *(btHashInt **)&jresult = result; 11248 return jresult; 11249 } 11250 11251 11252 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashInt_1getUid1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11253 jint jresult = 0 ; 11254 btHashInt *arg1 = (btHashInt *) 0 ; 11255 int result; 11256 11257 (void)jenv; 11258 (void)jcls; 11259 (void)jarg1_; 11260 arg1 = *(btHashInt **)&jarg1; 11261 result = (int)((btHashInt const *)arg1)->getUid1(); 11262 jresult = (jint)result; 11263 return jresult; 11264 } 11265 11266 11267 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashInt_1setUid1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11268 btHashInt *arg1 = (btHashInt *) 0 ; 11269 int arg2 ; 11270 11271 (void)jenv; 11272 (void)jcls; 11273 (void)jarg1_; 11274 arg1 = *(btHashInt **)&jarg1; 11275 arg2 = (int)jarg2; 11276 (arg1)->setUid1(arg2); 11277 } 11278 11279 11280 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashInt_1equals(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11281 jboolean jresult = 0 ; 11282 btHashInt *arg1 = (btHashInt *) 0 ; 11283 btHashInt *arg2 = 0 ; 11284 bool result; 11285 11286 (void)jenv; 11287 (void)jcls; 11288 (void)jarg1_; 11289 (void)jarg2_; 11290 arg1 = *(btHashInt **)&jarg1; 11291 arg2 = *(btHashInt **)&jarg2; 11292 if (!arg2) { 11293 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btHashInt const & reference is null"); 11294 return 0; 11295 } 11296 result = (bool)((btHashInt const *)arg1)->equals((btHashInt const &)*arg2); 11297 jresult = (jboolean)result; 11298 return jresult; 11299 } 11300 11301 11302 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashInt_1getHash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11303 jlong jresult = 0 ; 11304 btHashInt *arg1 = (btHashInt *) 0 ; 11305 unsigned int result; 11306 11307 (void)jenv; 11308 (void)jcls; 11309 (void)jarg1_; 11310 arg1 = *(btHashInt **)&jarg1; 11311 result = (unsigned int)((btHashInt const *)arg1)->getHash(); 11312 jresult = (jlong)result; 11313 return jresult; 11314 } 11315 11316 11317 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btHashInt(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11318 btHashInt *arg1 = (btHashInt *) 0 ; 11319 11320 (void)jenv; 11321 (void)jcls; 11322 arg1 = *(btHashInt **)&jarg1; 11323 delete arg1; 11324 } 11325 11326 11327 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btHashPtr(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11328 jlong jresult = 0 ; 11329 void *arg1 = (void *) 0 ; 11330 btHashPtr *result = 0 ; 11331 11332 (void)jenv; 11333 (void)jcls; 11334 arg1 = (void *)jarg1; 11335 result = (btHashPtr *)new btHashPtr((void const *)arg1); 11336 *(btHashPtr **)&jresult = result; 11337 return jresult; 11338 } 11339 11340 11341 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashPtr_1getPointer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11342 jlong jresult = 0 ; 11343 btHashPtr *arg1 = (btHashPtr *) 0 ; 11344 void *result = 0 ; 11345 11346 (void)jenv; 11347 (void)jcls; 11348 (void)jarg1_; 11349 arg1 = *(btHashPtr **)&jarg1; 11350 result = (void *)((btHashPtr const *)arg1)->getPointer(); 11351 jresult = (jlong)result; 11352 return jresult; 11353 } 11354 11355 11356 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashPtr_1equals(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11357 jboolean jresult = 0 ; 11358 btHashPtr *arg1 = (btHashPtr *) 0 ; 11359 btHashPtr *arg2 = 0 ; 11360 bool result; 11361 11362 (void)jenv; 11363 (void)jcls; 11364 (void)jarg1_; 11365 (void)jarg2_; 11366 arg1 = *(btHashPtr **)&jarg1; 11367 arg2 = *(btHashPtr **)&jarg2; 11368 if (!arg2) { 11369 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btHashPtr const & reference is null"); 11370 return 0; 11371 } 11372 result = (bool)((btHashPtr const *)arg1)->equals((btHashPtr const &)*arg2); 11373 jresult = (jboolean)result; 11374 return jresult; 11375 } 11376 11377 11378 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashPtr_1getHash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11379 jlong jresult = 0 ; 11380 btHashPtr *arg1 = (btHashPtr *) 0 ; 11381 unsigned int result; 11382 11383 (void)jenv; 11384 (void)jcls; 11385 (void)jarg1_; 11386 arg1 = *(btHashPtr **)&jarg1; 11387 result = (unsigned int)((btHashPtr const *)arg1)->getHash(); 11388 jresult = (jlong)result; 11389 return jresult; 11390 } 11391 11392 11393 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btHashPtr(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11394 btHashPtr *arg1 = (btHashPtr *) 0 ; 11395 11396 (void)jenv; 11397 (void)jcls; 11398 arg1 = *(btHashPtr **)&jarg1; 11399 delete arg1; 11400 } 11401 11402 11403 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btBlock_1previous_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11404 btBlock *arg1 = (btBlock *) 0 ; 11405 btBlock *arg2 = (btBlock *) 0 ; 11406 11407 (void)jenv; 11408 (void)jcls; 11409 (void)jarg1_; 11410 (void)jarg2_; 11411 arg1 = *(btBlock **)&jarg1; 11412 arg2 = *(btBlock **)&jarg2; 11413 if (arg1) (arg1)->previous = arg2; 11414 } 11415 11416 11417 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btBlock_1previous_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11418 jlong jresult = 0 ; 11419 btBlock *arg1 = (btBlock *) 0 ; 11420 btBlock *result = 0 ; 11421 11422 (void)jenv; 11423 (void)jcls; 11424 (void)jarg1_; 11425 arg1 = *(btBlock **)&jarg1; 11426 result = (btBlock *) ((arg1)->previous); 11427 *(btBlock **)&jresult = result; 11428 return jresult; 11429 } 11430 11431 11432 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btBlock_1address_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 11433 btBlock *arg1 = (btBlock *) 0 ; 11434 unsigned char *arg2 = (unsigned char *) 0 ; 11435 11436 (void)jenv; 11437 (void)jcls; 11438 (void)jarg1_; 11439 arg1 = *(btBlock **)&jarg1; 11440 { 11441 arg2 = (unsigned char*)jenv->GetDirectBufferAddress(jarg2); 11442 if (arg2 == NULL) { 11443 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 11444 } 11445 } 11446 { 11447 if (arg2) { 11448 arg1->address = arg2; 11449 } else { 11450 arg1->address = 0; 11451 } 11452 } 11453 11454 } 11455 11456 11457 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btBlock_1address_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11458 jobject jresult = 0 ; 11459 btBlock *arg1 = (btBlock *) 0 ; 11460 unsigned char *result = 0 ; 11461 11462 (void)jenv; 11463 (void)jcls; 11464 (void)jarg1_; 11465 arg1 = *(btBlock **)&jarg1; 11466 result = (unsigned char *) ((arg1)->address); 11467 *(unsigned char **)&jresult = result; 11468 return jresult; 11469 } 11470 11471 11472 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btBlock(JNIEnv *jenv, jclass jcls) { 11473 jlong jresult = 0 ; 11474 btBlock *result = 0 ; 11475 11476 (void)jenv; 11477 (void)jcls; 11478 result = (btBlock *)new btBlock(); 11479 *(btBlock **)&jresult = result; 11480 return jresult; 11481 } 11482 11483 11484 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btBlock(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11485 btBlock *arg1 = (btBlock *) 0 ; 11486 11487 (void)jenv; 11488 (void)jcls; 11489 arg1 = *(btBlock **)&jarg1; 11490 delete arg1; 11491 } 11492 11493 11494 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btStackAlloc(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11495 jlong jresult = 0 ; 11496 unsigned int arg1 ; 11497 btStackAlloc *result = 0 ; 11498 11499 (void)jenv; 11500 (void)jcls; 11501 arg1 = (unsigned int)jarg1; 11502 result = (btStackAlloc *)new btStackAlloc(arg1); 11503 *(btStackAlloc **)&jresult = result; 11504 return jresult; 11505 } 11506 11507 11508 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btStackAlloc(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11509 btStackAlloc *arg1 = (btStackAlloc *) 0 ; 11510 11511 (void)jenv; 11512 (void)jcls; 11513 arg1 = *(btStackAlloc **)&jarg1; 11514 delete arg1; 11515 } 11516 11517 11518 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1create(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 11519 btStackAlloc *arg1 = (btStackAlloc *) 0 ; 11520 unsigned int arg2 ; 11521 11522 (void)jenv; 11523 (void)jcls; 11524 (void)jarg1_; 11525 arg1 = *(btStackAlloc **)&jarg1; 11526 arg2 = (unsigned int)jarg2; 11527 (arg1)->create(arg2); 11528 } 11529 11530 11531 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1destroy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11532 btStackAlloc *arg1 = (btStackAlloc *) 0 ; 11533 11534 (void)jenv; 11535 (void)jcls; 11536 (void)jarg1_; 11537 arg1 = *(btStackAlloc **)&jarg1; 11538 (arg1)->destroy(); 11539 } 11540 11541 11542 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1getAvailableMemory(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11543 jint jresult = 0 ; 11544 btStackAlloc *arg1 = (btStackAlloc *) 0 ; 11545 int result; 11546 11547 (void)jenv; 11548 (void)jcls; 11549 (void)jarg1_; 11550 arg1 = *(btStackAlloc **)&jarg1; 11551 result = (int)((btStackAlloc const *)arg1)->getAvailableMemory(); 11552 jresult = (jint)result; 11553 return jresult; 11554 } 11555 11556 11557 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1allocate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 11558 jobject jresult = 0 ; 11559 btStackAlloc *arg1 = (btStackAlloc *) 0 ; 11560 unsigned int arg2 ; 11561 unsigned char *result = 0 ; 11562 11563 (void)jenv; 11564 (void)jcls; 11565 (void)jarg1_; 11566 arg1 = *(btStackAlloc **)&jarg1; 11567 arg2 = (unsigned int)jarg2; 11568 result = (unsigned char *)(arg1)->allocate(arg2); 11569 *(unsigned char **)&jresult = result; 11570 return jresult; 11571 } 11572 11573 11574 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1beginBlock(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11575 jlong jresult = 0 ; 11576 btStackAlloc *arg1 = (btStackAlloc *) 0 ; 11577 btBlock *result = 0 ; 11578 11579 (void)jenv; 11580 (void)jcls; 11581 (void)jarg1_; 11582 arg1 = *(btStackAlloc **)&jarg1; 11583 result = (btBlock *)(arg1)->beginBlock(); 11584 *(btBlock **)&jresult = result; 11585 return jresult; 11586 } 11587 11588 11589 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1endBlock(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11590 btStackAlloc *arg1 = (btStackAlloc *) 0 ; 11591 btBlock *arg2 = (btBlock *) 0 ; 11592 11593 (void)jenv; 11594 (void)jcls; 11595 (void)jarg1_; 11596 (void)jarg2_; 11597 arg1 = *(btStackAlloc **)&jarg1; 11598 arg2 = *(btBlock **)&jarg2; 11599 (arg1)->endBlock(arg2); 11600 } 11601 11602 11603 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btMotionState(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11604 btMotionState *arg1 = (btMotionState *) 0 ; 11605 11606 (void)jenv; 11607 (void)jcls; 11608 arg1 = *(btMotionState **)&jarg1; 11609 delete arg1; 11610 } 11611 11612 11613 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btMotionState_1getWorldTransform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 11614 btMotionState *arg1 = (btMotionState *) 0 ; 11615 btTransform *arg2 = 0 ; 11616 11617 (void)jenv; 11618 (void)jcls; 11619 (void)jarg1_; 11620 arg1 = *(btMotionState **)&jarg1; 11621 btTransform local_arg2; 11622 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 11623 arg2 = &local_arg2; 11624 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 11625 ((btMotionState const *)arg1)->getWorldTransform(*arg2); 11626 } 11627 11628 11629 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btMotionState_1setWorldTransform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 11630 btMotionState *arg1 = (btMotionState *) 0 ; 11631 btTransform *arg2 = 0 ; 11632 11633 (void)jenv; 11634 (void)jcls; 11635 (void)jarg1_; 11636 arg1 = *(btMotionState **)&jarg1; 11637 btTransform local_arg2; 11638 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 11639 arg2 = &local_arg2; 11640 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 11641 (arg1)->setWorldTransform((btTransform const &)*arg2); 11642 } 11643 11644 11645 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btMotionState(JNIEnv *jenv, jclass jcls) { 11646 jlong jresult = 0 ; 11647 btMotionState *result = 0 ; 11648 11649 (void)jenv; 11650 (void)jcls; 11651 result = (btMotionState *)new SwigDirector_btMotionState(jenv); 11652 *(btMotionState **)&jresult = result; 11653 return jresult; 11654 } 11655 11656 11657 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btMotionState_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { 11658 btMotionState *obj = *((btMotionState **)&objarg); 11659 (void)jcls; 11660 SwigDirector_btMotionState *director = (SwigDirector_btMotionState *)(obj); 11661 if (director) { 11662 director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); 11663 } 11664 } 11665 11666 11667 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btMotionState_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { 11668 btMotionState *obj = *((btMotionState **)&objarg); 11669 SwigDirector_btMotionState *director = (SwigDirector_btMotionState *)(obj); 11670 (void)jcls; 11671 if (director) { 11672 director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); 11673 } 11674 } 11675 11676 11677 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1graphicsWorldTrans_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11678 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11679 btTransform *arg2 = (btTransform *) 0 ; 11680 11681 (void)jenv; 11682 (void)jcls; 11683 (void)jarg1_; 11684 (void)jarg2_; 11685 arg1 = *(btDefaultMotionState **)&jarg1; 11686 arg2 = *(btTransform **)&jarg2; 11687 if (arg1) (arg1)->m_graphicsWorldTrans = *arg2; 11688 } 11689 11690 11691 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1graphicsWorldTrans_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11692 jlong jresult = 0 ; 11693 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11694 btTransform *result = 0 ; 11695 11696 (void)jenv; 11697 (void)jcls; 11698 (void)jarg1_; 11699 arg1 = *(btDefaultMotionState **)&jarg1; 11700 result = (btTransform *)& ((arg1)->m_graphicsWorldTrans); 11701 *(btTransform **)&jresult = result; 11702 return jresult; 11703 } 11704 11705 11706 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1centerOfMassOffset_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11707 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11708 btTransform *arg2 = (btTransform *) 0 ; 11709 11710 (void)jenv; 11711 (void)jcls; 11712 (void)jarg1_; 11713 (void)jarg2_; 11714 arg1 = *(btDefaultMotionState **)&jarg1; 11715 arg2 = *(btTransform **)&jarg2; 11716 if (arg1) (arg1)->m_centerOfMassOffset = *arg2; 11717 } 11718 11719 11720 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1centerOfMassOffset_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11721 jlong jresult = 0 ; 11722 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11723 btTransform *result = 0 ; 11724 11725 (void)jenv; 11726 (void)jcls; 11727 (void)jarg1_; 11728 arg1 = *(btDefaultMotionState **)&jarg1; 11729 result = (btTransform *)& ((arg1)->m_centerOfMassOffset); 11730 *(btTransform **)&jresult = result; 11731 return jresult; 11732 } 11733 11734 11735 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1startWorldTrans_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11736 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11737 btTransform *arg2 = (btTransform *) 0 ; 11738 11739 (void)jenv; 11740 (void)jcls; 11741 (void)jarg1_; 11742 (void)jarg2_; 11743 arg1 = *(btDefaultMotionState **)&jarg1; 11744 arg2 = *(btTransform **)&jarg2; 11745 if (arg1) (arg1)->m_startWorldTrans = *arg2; 11746 } 11747 11748 11749 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1startWorldTrans_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11750 jlong jresult = 0 ; 11751 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11752 btTransform *result = 0 ; 11753 11754 (void)jenv; 11755 (void)jcls; 11756 (void)jarg1_; 11757 arg1 = *(btDefaultMotionState **)&jarg1; 11758 result = (btTransform *)& ((arg1)->m_startWorldTrans); 11759 *(btTransform **)&jresult = result; 11760 return jresult; 11761 } 11762 11763 11764 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1userPointer_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 11765 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11766 void *arg2 = (void *) 0 ; 11767 11768 (void)jenv; 11769 (void)jcls; 11770 (void)jarg1_; 11771 arg1 = *(btDefaultMotionState **)&jarg1; 11772 arg2 = (void *)jarg2; 11773 if (arg1) (arg1)->m_userPointer = arg2; 11774 } 11775 11776 11777 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1userPointer_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11778 jlong jresult = 0 ; 11779 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11780 void *result = 0 ; 11781 11782 (void)jenv; 11783 (void)jcls; 11784 (void)jarg1_; 11785 arg1 = *(btDefaultMotionState **)&jarg1; 11786 result = (void *) ((arg1)->m_userPointer); 11787 jresult = (jlong)result; 11788 return jresult; 11789 } 11790 11791 11792 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btDefaultMotionState_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 11793 jlong jresult = 0 ; 11794 btTransform *arg1 = 0 ; 11795 btTransform *arg2 = 0 ; 11796 btDefaultMotionState *result = 0 ; 11797 11798 (void)jenv; 11799 (void)jcls; 11800 btTransform local_arg1; 11801 gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); 11802 arg1 = &local_arg1; 11803 gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); 11804 btTransform local_arg2; 11805 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 11806 arg2 = &local_arg2; 11807 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 11808 result = (btDefaultMotionState *)new btDefaultMotionState((btTransform const &)*arg1,(btTransform const &)*arg2); 11809 *(btDefaultMotionState **)&jresult = result; 11810 return jresult; 11811 } 11812 11813 11814 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btDefaultMotionState_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1) { 11815 jlong jresult = 0 ; 11816 btTransform *arg1 = 0 ; 11817 btDefaultMotionState *result = 0 ; 11818 11819 (void)jenv; 11820 (void)jcls; 11821 btTransform local_arg1; 11822 gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); 11823 arg1 = &local_arg1; 11824 gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); 11825 result = (btDefaultMotionState *)new btDefaultMotionState((btTransform const &)*arg1); 11826 *(btDefaultMotionState **)&jresult = result; 11827 return jresult; 11828 } 11829 11830 11831 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btDefaultMotionState_1_1SWIG_12(JNIEnv *jenv, jclass jcls) { 11832 jlong jresult = 0 ; 11833 btDefaultMotionState *result = 0 ; 11834 11835 (void)jenv; 11836 (void)jcls; 11837 result = (btDefaultMotionState *)new btDefaultMotionState(); 11838 *(btDefaultMotionState **)&jresult = result; 11839 return jresult; 11840 } 11841 11842 11843 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1getGraphicsWorldTrans(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 11844 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11845 btTransform *arg2 = 0 ; 11846 11847 (void)jenv; 11848 (void)jcls; 11849 (void)jarg1_; 11850 arg1 = *(btDefaultMotionState **)&jarg1; 11851 btTransform local_arg2; 11852 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 11853 arg2 = &local_arg2; 11854 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 11855 btDefaultMotionState_getGraphicsWorldTrans(arg1,*arg2); 11856 } 11857 11858 11859 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1getCenterOfMassOffset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 11860 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11861 btTransform *arg2 = 0 ; 11862 11863 (void)jenv; 11864 (void)jcls; 11865 (void)jarg1_; 11866 arg1 = *(btDefaultMotionState **)&jarg1; 11867 btTransform local_arg2; 11868 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 11869 arg2 = &local_arg2; 11870 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 11871 btDefaultMotionState_getCenterOfMassOffset(arg1,*arg2); 11872 } 11873 11874 11875 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1getStartWorldTrans(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 11876 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11877 btTransform *arg2 = 0 ; 11878 11879 (void)jenv; 11880 (void)jcls; 11881 (void)jarg1_; 11882 arg1 = *(btDefaultMotionState **)&jarg1; 11883 btTransform local_arg2; 11884 gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); 11885 arg2 = &local_arg2; 11886 gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); 11887 btDefaultMotionState_getStartWorldTrans(arg1,*arg2); 11888 } 11889 11890 11891 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btDefaultMotionState(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11892 btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; 11893 11894 (void)jenv; 11895 (void)jcls; 11896 arg1 = *(btDefaultMotionState **)&jarg1; 11897 delete arg1; 11898 } 11899 11900 11901 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3Array_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 11902 jlong jresult = 0 ; 11903 btAlignedObjectArray< btVector3 > *result = 0 ; 11904 11905 (void)jenv; 11906 (void)jcls; 11907 result = (btAlignedObjectArray< btVector3 > *)new btAlignedObjectArray< btVector3 >(); 11908 *(btAlignedObjectArray< btVector3 > **)&jresult = result; 11909 return jresult; 11910 } 11911 11912 11913 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector3Array(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11914 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 11915 11916 (void)jenv; 11917 (void)jcls; 11918 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 11919 delete arg1; 11920 } 11921 11922 11923 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3Array_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11924 jlong jresult = 0 ; 11925 btAlignedObjectArray< btVector3 > *arg1 = 0 ; 11926 btAlignedObjectArray< btVector3 > *result = 0 ; 11927 11928 (void)jenv; 11929 (void)jcls; 11930 (void)jarg1_; 11931 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 11932 if (!arg1) { 11933 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); 11934 return 0; 11935 } 11936 result = (btAlignedObjectArray< btVector3 > *)new btAlignedObjectArray< btVector3 >((btAlignedObjectArray< btVector3 > const &)*arg1); 11937 *(btAlignedObjectArray< btVector3 > **)&jresult = result; 11938 return jresult; 11939 } 11940 11941 11942 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11943 jint jresult = 0 ; 11944 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 11945 int result; 11946 11947 (void)jenv; 11948 (void)jcls; 11949 (void)jarg1_; 11950 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 11951 result = (int)((btAlignedObjectArray< btVector3 > const *)arg1)->size(); 11952 jresult = (jint)result; 11953 return jresult; 11954 } 11955 11956 11957 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1at_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11958 jobject jresult = 0 ; 11959 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 11960 int arg2 ; 11961 btVector3 *result = 0 ; 11962 11963 (void)jenv; 11964 (void)jcls; 11965 (void)jarg1_; 11966 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 11967 arg2 = (int)jarg2; 11968 result = (btVector3 *) &((btAlignedObjectArray< btVector3 > const *)arg1)->at(arg2); 11969 jresult = gdx_getReturnVector3(jenv); 11970 gdx_setVector3FrombtVector3(jenv, jresult, result); 11971 return jresult; 11972 } 11973 11974 11975 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11976 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 11977 11978 (void)jenv; 11979 (void)jcls; 11980 (void)jarg1_; 11981 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 11982 (arg1)->clear(); 11983 } 11984 11985 11986 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1pop_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11987 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 11988 11989 (void)jenv; 11990 (void)jcls; 11991 (void)jarg1_; 11992 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 11993 (arg1)->pop_back(); 11994 } 11995 11996 11997 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1resizeNoInitialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11998 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 11999 int arg2 ; 12000 12001 (void)jenv; 12002 (void)jcls; 12003 (void)jarg1_; 12004 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12005 arg2 = (int)jarg2; 12006 (arg1)->resizeNoInitialize(arg2); 12007 } 12008 12009 12010 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1resize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jobject jarg3) { 12011 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12012 int arg2 ; 12013 btVector3 *arg3 = 0 ; 12014 12015 (void)jenv; 12016 (void)jcls; 12017 (void)jarg1_; 12018 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12019 arg2 = (int)jarg2; 12020 btVector3 local_arg3; 12021 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 12022 arg3 = &local_arg3; 12023 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 12024 (arg1)->resize(arg2,(btVector3 const &)*arg3); 12025 } 12026 12027 12028 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1resize_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 12029 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12030 int arg2 ; 12031 12032 (void)jenv; 12033 (void)jcls; 12034 (void)jarg1_; 12035 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12036 arg2 = (int)jarg2; 12037 (arg1)->resize(arg2); 12038 } 12039 12040 12041 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1expandNonInitializing(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12042 jobject jresult = 0 ; 12043 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12044 btVector3 *result = 0 ; 12045 12046 (void)jenv; 12047 (void)jcls; 12048 (void)jarg1_; 12049 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12050 result = (btVector3 *) &(arg1)->expandNonInitializing(); 12051 jresult = gdx_getReturnVector3(jenv); 12052 gdx_setVector3FrombtVector3(jenv, jresult, result); 12053 return jresult; 12054 } 12055 12056 12057 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1expand_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 12058 jobject jresult = 0 ; 12059 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12060 btVector3 *arg2 = 0 ; 12061 btVector3 *result = 0 ; 12062 12063 (void)jenv; 12064 (void)jcls; 12065 (void)jarg1_; 12066 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12067 btVector3 local_arg2; 12068 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12069 arg2 = &local_arg2; 12070 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12071 result = (btVector3 *) &(arg1)->expand((btVector3 const &)*arg2); 12072 jresult = gdx_getReturnVector3(jenv); 12073 gdx_setVector3FrombtVector3(jenv, jresult, result); 12074 return jresult; 12075 } 12076 12077 12078 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1expand_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12079 jobject jresult = 0 ; 12080 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12081 btVector3 *result = 0 ; 12082 12083 (void)jenv; 12084 (void)jcls; 12085 (void)jarg1_; 12086 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12087 result = (btVector3 *) &(arg1)->expand(); 12088 jresult = gdx_getReturnVector3(jenv); 12089 gdx_setVector3FrombtVector3(jenv, jresult, result); 12090 return jresult; 12091 } 12092 12093 12094 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 12095 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12096 btVector3 *arg2 = 0 ; 12097 12098 (void)jenv; 12099 (void)jcls; 12100 (void)jarg1_; 12101 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12102 btVector3 local_arg2; 12103 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12104 arg2 = &local_arg2; 12105 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12106 (arg1)->push_back((btVector3 const &)*arg2); 12107 } 12108 12109 12110 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12111 jint jresult = 0 ; 12112 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12113 int result; 12114 12115 (void)jenv; 12116 (void)jcls; 12117 (void)jarg1_; 12118 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12119 result = (int)((btAlignedObjectArray< btVector3 > const *)arg1)->capacity(); 12120 jresult = (jint)result; 12121 return jresult; 12122 } 12123 12124 12125 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 12126 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12127 int arg2 ; 12128 12129 (void)jenv; 12130 (void)jcls; 12131 (void)jarg1_; 12132 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12133 arg2 = (int)jarg2; 12134 (arg1)->reserve(arg2); 12135 } 12136 12137 12138 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3Array_1less(JNIEnv *jenv, jclass jcls) { 12139 jlong jresult = 0 ; 12140 btAlignedObjectArray< btVector3 >::less *result = 0 ; 12141 12142 (void)jenv; 12143 (void)jcls; 12144 result = (btAlignedObjectArray< btVector3 >::less *)new btAlignedObjectArray< btVector3 >::less(); 12145 *(btAlignedObjectArray< btVector3 >::less **)&jresult = result; 12146 return jresult; 12147 } 12148 12149 12150 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector3Array_1less(JNIEnv *jenv, jclass jcls, jlong jarg1) { 12151 btAlignedObjectArray< btVector3 >::less *arg1 = (btAlignedObjectArray< btVector3 >::less *) 0 ; 12152 12153 (void)jenv; 12154 (void)jcls; 12155 arg1 = *(btAlignedObjectArray< btVector3 >::less **)&jarg1; 12156 delete arg1; 12157 } 12158 12159 12160 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1swap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { 12161 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12162 int arg2 ; 12163 int arg3 ; 12164 12165 (void)jenv; 12166 (void)jcls; 12167 (void)jarg1_; 12168 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12169 arg2 = (int)jarg2; 12170 arg3 = (int)jarg3; 12171 (arg1)->swap(arg2,arg3); 12172 } 12173 12174 12175 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1findBinarySearch(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 12176 jint jresult = 0 ; 12177 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12178 btVector3 *arg2 = 0 ; 12179 int result; 12180 12181 (void)jenv; 12182 (void)jcls; 12183 (void)jarg1_; 12184 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12185 btVector3 local_arg2; 12186 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12187 arg2 = &local_arg2; 12188 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12189 result = (int)((btAlignedObjectArray< btVector3 > const *)arg1)->findBinarySearch((btVector3 const &)*arg2); 12190 jresult = (jint)result; 12191 return jresult; 12192 } 12193 12194 12195 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1findLinearSearch(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 12196 jint jresult = 0 ; 12197 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12198 btVector3 *arg2 = 0 ; 12199 int result; 12200 12201 (void)jenv; 12202 (void)jcls; 12203 (void)jarg1_; 12204 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12205 btVector3 local_arg2; 12206 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12207 arg2 = &local_arg2; 12208 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12209 result = (int)((btAlignedObjectArray< btVector3 > const *)arg1)->findLinearSearch((btVector3 const &)*arg2); 12210 jresult = (jint)result; 12211 return jresult; 12212 } 12213 12214 12215 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 12216 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12217 btVector3 *arg2 = 0 ; 12218 12219 (void)jenv; 12220 (void)jcls; 12221 (void)jarg1_; 12222 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12223 btVector3 local_arg2; 12224 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12225 arg2 = &local_arg2; 12226 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12227 (arg1)->remove((btVector3 const &)*arg2); 12228 } 12229 12230 12231 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1initializeFromBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4) { 12232 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12233 void *arg2 = (void *) 0 ; 12234 int arg3 ; 12235 int arg4 ; 12236 12237 (void)jenv; 12238 (void)jcls; 12239 (void)jarg1_; 12240 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12241 arg2 = (void *)jarg2; 12242 arg3 = (int)jarg3; 12243 arg4 = (int)jarg4; 12244 (arg1)->initializeFromBuffer(arg2,arg3,arg4); 12245 } 12246 12247 12248 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1copyFromArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 12249 btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; 12250 btAlignedObjectArray< btVector3 > *arg2 = 0 ; 12251 12252 (void)jenv; 12253 (void)jcls; 12254 (void)jarg1_; 12255 (void)jarg2_; 12256 arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; 12257 arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; 12258 if (!arg2) { 12259 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); 12260 return ; 12261 } 12262 (arg1)->copyFromArray((btAlignedObjectArray< btVector3 > const &)*arg2); 12263 } 12264 12265 12266 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btScalarArray_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 12267 jlong jresult = 0 ; 12268 btAlignedObjectArray< btScalar > *result = 0 ; 12269 12270 (void)jenv; 12271 (void)jcls; 12272 result = (btAlignedObjectArray< btScalar > *)new btAlignedObjectArray< btScalar >(); 12273 *(btAlignedObjectArray< btScalar > **)&jresult = result; 12274 return jresult; 12275 } 12276 12277 12278 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btScalarArray(JNIEnv *jenv, jclass jcls, jlong jarg1) { 12279 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12280 12281 (void)jenv; 12282 (void)jcls; 12283 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12284 delete arg1; 12285 } 12286 12287 12288 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btScalarArray_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12289 jlong jresult = 0 ; 12290 btAlignedObjectArray< btScalar > *arg1 = 0 ; 12291 btAlignedObjectArray< btScalar > *result = 0 ; 12292 12293 (void)jenv; 12294 (void)jcls; 12295 (void)jarg1_; 12296 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12297 if (!arg1) { 12298 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btScalar > const & reference is null"); 12299 return 0; 12300 } 12301 result = (btAlignedObjectArray< btScalar > *)new btAlignedObjectArray< btScalar >((btAlignedObjectArray< btScalar > const &)*arg1); 12302 *(btAlignedObjectArray< btScalar > **)&jresult = result; 12303 return jresult; 12304 } 12305 12306 12307 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12308 jint jresult = 0 ; 12309 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12310 int result; 12311 12312 (void)jenv; 12313 (void)jcls; 12314 (void)jarg1_; 12315 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12316 result = (int)((btAlignedObjectArray< btScalar > const *)arg1)->size(); 12317 jresult = (jint)result; 12318 return jresult; 12319 } 12320 12321 12322 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1at_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 12323 jfloat jresult = 0 ; 12324 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12325 int arg2 ; 12326 float *result = 0 ; 12327 12328 (void)jenv; 12329 (void)jcls; 12330 (void)jarg1_; 12331 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12332 arg2 = (int)jarg2; 12333 result = (float *) &((btAlignedObjectArray< btScalar > const *)arg1)->at(arg2); 12334 jresult = (jfloat)*result; 12335 return jresult; 12336 } 12337 12338 12339 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12340 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12341 12342 (void)jenv; 12343 (void)jcls; 12344 (void)jarg1_; 12345 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12346 (arg1)->clear(); 12347 } 12348 12349 12350 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1pop_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12351 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12352 12353 (void)jenv; 12354 (void)jcls; 12355 (void)jarg1_; 12356 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12357 (arg1)->pop_back(); 12358 } 12359 12360 12361 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1resizeNoInitialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 12362 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12363 int arg2 ; 12364 12365 (void)jenv; 12366 (void)jcls; 12367 (void)jarg1_; 12368 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12369 arg2 = (int)jarg2; 12370 (arg1)->resizeNoInitialize(arg2); 12371 } 12372 12373 12374 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1resize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jfloat jarg3) { 12375 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12376 int arg2 ; 12377 float *arg3 = 0 ; 12378 float temp3 ; 12379 12380 (void)jenv; 12381 (void)jcls; 12382 (void)jarg1_; 12383 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12384 arg2 = (int)jarg2; 12385 temp3 = (float)jarg3; 12386 arg3 = &temp3; 12387 (arg1)->resize(arg2,(float const &)*arg3); 12388 } 12389 12390 12391 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1resize_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 12392 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12393 int arg2 ; 12394 12395 (void)jenv; 12396 (void)jcls; 12397 (void)jarg1_; 12398 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12399 arg2 = (int)jarg2; 12400 (arg1)->resize(arg2); 12401 } 12402 12403 12404 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1expandNonInitializing(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12405 jlong jresult = 0 ; 12406 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12407 float *result = 0 ; 12408 12409 (void)jenv; 12410 (void)jcls; 12411 (void)jarg1_; 12412 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12413 result = (float *) &(arg1)->expandNonInitializing(); 12414 *(float **)&jresult = result; 12415 return jresult; 12416 } 12417 12418 12419 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1expand_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 12420 jlong jresult = 0 ; 12421 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12422 float *arg2 = 0 ; 12423 float temp2 ; 12424 float *result = 0 ; 12425 12426 (void)jenv; 12427 (void)jcls; 12428 (void)jarg1_; 12429 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12430 temp2 = (float)jarg2; 12431 arg2 = &temp2; 12432 result = (float *) &(arg1)->expand((float const &)*arg2); 12433 *(float **)&jresult = result; 12434 return jresult; 12435 } 12436 12437 12438 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1expand_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12439 jlong jresult = 0 ; 12440 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12441 float *result = 0 ; 12442 12443 (void)jenv; 12444 (void)jcls; 12445 (void)jarg1_; 12446 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12447 result = (float *) &(arg1)->expand(); 12448 *(float **)&jresult = result; 12449 return jresult; 12450 } 12451 12452 12453 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 12454 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12455 float *arg2 = 0 ; 12456 float temp2 ; 12457 12458 (void)jenv; 12459 (void)jcls; 12460 (void)jarg1_; 12461 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12462 temp2 = (float)jarg2; 12463 arg2 = &temp2; 12464 (arg1)->push_back((float const &)*arg2); 12465 } 12466 12467 12468 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12469 jint jresult = 0 ; 12470 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12471 int result; 12472 12473 (void)jenv; 12474 (void)jcls; 12475 (void)jarg1_; 12476 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12477 result = (int)((btAlignedObjectArray< btScalar > const *)arg1)->capacity(); 12478 jresult = (jint)result; 12479 return jresult; 12480 } 12481 12482 12483 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 12484 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12485 int arg2 ; 12486 12487 (void)jenv; 12488 (void)jcls; 12489 (void)jarg1_; 12490 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12491 arg2 = (int)jarg2; 12492 (arg1)->reserve(arg2); 12493 } 12494 12495 12496 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btScalarArray_1less(JNIEnv *jenv, jclass jcls) { 12497 jlong jresult = 0 ; 12498 btAlignedObjectArray< btScalar >::less *result = 0 ; 12499 12500 (void)jenv; 12501 (void)jcls; 12502 result = (btAlignedObjectArray< btScalar >::less *)new btAlignedObjectArray< btScalar >::less(); 12503 *(btAlignedObjectArray< btScalar >::less **)&jresult = result; 12504 return jresult; 12505 } 12506 12507 12508 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btScalarArray_1less(JNIEnv *jenv, jclass jcls, jlong jarg1) { 12509 btAlignedObjectArray< btScalar >::less *arg1 = (btAlignedObjectArray< btScalar >::less *) 0 ; 12510 12511 (void)jenv; 12512 (void)jcls; 12513 arg1 = *(btAlignedObjectArray< btScalar >::less **)&jarg1; 12514 delete arg1; 12515 } 12516 12517 12518 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1swap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { 12519 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12520 int arg2 ; 12521 int arg3 ; 12522 12523 (void)jenv; 12524 (void)jcls; 12525 (void)jarg1_; 12526 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12527 arg2 = (int)jarg2; 12528 arg3 = (int)jarg3; 12529 (arg1)->swap(arg2,arg3); 12530 } 12531 12532 12533 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1findBinarySearch(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 12534 jint jresult = 0 ; 12535 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12536 float *arg2 = 0 ; 12537 float temp2 ; 12538 int result; 12539 12540 (void)jenv; 12541 (void)jcls; 12542 (void)jarg1_; 12543 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12544 temp2 = (float)jarg2; 12545 arg2 = &temp2; 12546 result = (int)((btAlignedObjectArray< btScalar > const *)arg1)->findBinarySearch((float const &)*arg2); 12547 jresult = (jint)result; 12548 return jresult; 12549 } 12550 12551 12552 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1findLinearSearch(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 12553 jint jresult = 0 ; 12554 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12555 float *arg2 = 0 ; 12556 float temp2 ; 12557 int result; 12558 12559 (void)jenv; 12560 (void)jcls; 12561 (void)jarg1_; 12562 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12563 temp2 = (float)jarg2; 12564 arg2 = &temp2; 12565 result = (int)((btAlignedObjectArray< btScalar > const *)arg1)->findLinearSearch((float const &)*arg2); 12566 jresult = (jint)result; 12567 return jresult; 12568 } 12569 12570 12571 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 12572 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12573 float *arg2 = 0 ; 12574 float temp2 ; 12575 12576 (void)jenv; 12577 (void)jcls; 12578 (void)jarg1_; 12579 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12580 temp2 = (float)jarg2; 12581 arg2 = &temp2; 12582 (arg1)->remove((float const &)*arg2); 12583 } 12584 12585 12586 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1initializeFromBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4) { 12587 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12588 void *arg2 = (void *) 0 ; 12589 int arg3 ; 12590 int arg4 ; 12591 12592 (void)jenv; 12593 (void)jcls; 12594 (void)jarg1_; 12595 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12596 arg2 = (void *)jarg2; 12597 arg3 = (int)jarg3; 12598 arg4 = (int)jarg4; 12599 (arg1)->initializeFromBuffer(arg2,arg3,arg4); 12600 } 12601 12602 12603 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1copyFromArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 12604 btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; 12605 btAlignedObjectArray< btScalar > *arg2 = 0 ; 12606 12607 (void)jenv; 12608 (void)jcls; 12609 (void)jarg1_; 12610 (void)jarg2_; 12611 arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; 12612 arg2 = *(btAlignedObjectArray< btScalar > **)&jarg2; 12613 if (!arg2) { 12614 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btScalar > const & reference is null"); 12615 return ; 12616 } 12617 (arg1)->copyFromArray((btAlignedObjectArray< btScalar > const &)*arg2); 12618 } 12619 12620 12621 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) { 12622 jlong baseptr = 0; 12623 (void)jenv; 12624 (void)jcls; 12625 *(btVector3 **)&baseptr = *(btVector4 **)&jarg1; 12626 return baseptr; 12627 } 12628 12629 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamVector3_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) { 12630 jlong baseptr = 0; 12631 (void)jenv; 12632 (void)jcls; 12633 *(btVector3 **)&baseptr = *(GrahamVector3 **)&jarg1; 12634 return baseptr; 12635 } 12636 12637 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) { 12638 jlong baseptr = 0; 12639 (void)jenv; 12640 (void)jcls; 12641 *(btMotionState **)&baseptr = *(btDefaultMotionState **)&jarg1; 12642 return baseptr; 12643 } 12644 12645 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) { 12646 int i; 12647 12648 static struct { 12649 const char *method; 12650 const char *signature; 12651 } methods[29] = { 12652 { 12653 "SwigDirector_btIDebugDraw_getDefaultColors", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;)J" 12654 }, 12655 { 12656 "SwigDirector_btIDebugDraw_setDefaultColors", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;J)V" 12657 }, 12658 { 12659 "SwigDirector_btIDebugDraw_drawLine__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V" 12660 }, 12661 { 12662 "SwigDirector_btIDebugDraw_drawLine__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V" 12663 }, 12664 { 12665 "SwigDirector_btIDebugDraw_drawSphere__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;FLcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" 12666 }, 12667 { 12668 "SwigDirector_btIDebugDraw_drawSphere__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;FLcom/badlogic/gdx/math/Vector3;)V" 12669 }, 12670 { 12671 "SwigDirector_btIDebugDraw_drawTriangle__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;F)V" 12672 }, 12673 { 12674 "SwigDirector_btIDebugDraw_drawTriangle__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;F)V" 12675 }, 12676 { 12677 "SwigDirector_btIDebugDraw_drawContactPoint", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FILcom/badlogic/gdx/math/Vector3;)V" 12678 }, 12679 { 12680 "SwigDirector_btIDebugDraw_reportErrorWarning", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Ljava/lang/String;)V" 12681 }, 12682 { 12683 "SwigDirector_btIDebugDraw_draw3dText", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Ljava/lang/String;)V" 12684 }, 12685 { 12686 "SwigDirector_btIDebugDraw_setDebugMode", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;I)V" 12687 }, 12688 { 12689 "SwigDirector_btIDebugDraw_getDebugMode", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;)I" 12690 }, 12691 { 12692 "SwigDirector_btIDebugDraw_drawAabb", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V" 12693 }, 12694 { 12695 "SwigDirector_btIDebugDraw_drawTransform", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Matrix4;F)V" 12696 }, 12697 { 12698 "SwigDirector_btIDebugDraw_drawArc__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFLcom/badlogic/gdx/math/Vector3;ZF)V" 12699 }, 12700 { 12701 "SwigDirector_btIDebugDraw_drawArc__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFLcom/badlogic/gdx/math/Vector3;Z)V" 12702 }, 12703 { 12704 "SwigDirector_btIDebugDraw_drawSpherePatch__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;FZ)V" 12705 }, 12706 { 12707 "SwigDirector_btIDebugDraw_drawSpherePatch__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;F)V" 12708 }, 12709 { 12710 "SwigDirector_btIDebugDraw_drawSpherePatch__SWIG_2", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;)V" 12711 }, 12712 { 12713 "SwigDirector_btIDebugDraw_drawBox__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V" 12714 }, 12715 { 12716 "SwigDirector_btIDebugDraw_drawBox__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" 12717 }, 12718 { 12719 "SwigDirector_btIDebugDraw_drawCapsule", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" 12720 }, 12721 { 12722 "SwigDirector_btIDebugDraw_drawCylinder", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" 12723 }, 12724 { 12725 "SwigDirector_btIDebugDraw_drawCone", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" 12726 }, 12727 { 12728 "SwigDirector_btIDebugDraw_drawPlane", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;FLcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" 12729 }, 12730 { 12731 "SwigDirector_btIDebugDraw_flushLines", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;)V" 12732 }, 12733 { 12734 "SwigDirector_btMotionState_getWorldTransform", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btMotionState;Lcom/badlogic/gdx/math/Matrix4;)V" 12735 }, 12736 { 12737 "SwigDirector_btMotionState_setWorldTransform", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btMotionState;Lcom/badlogic/gdx/math/Matrix4;)V" 12738 } 12739 }; 12740 Swig::jclass_LinearMathJNI = (jclass) jenv->NewGlobalRef(jcls); 12741 if (!Swig::jclass_LinearMathJNI) return; 12742 for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) { 12743 Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature); 12744 if (!Swig::director_method_ids[i]) return; 12745 } 12746 } 12747 12748 12749 #ifdef __cplusplus 12750 } 12751 #endif 12752 12753
