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_CollisionJNI = NULL; 662 jmethodID director_method_ids[72]; 663 } 664 } 665 666 #if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS) 667 668 669 static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input); 670 static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input); 671 static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz); 672 673 674 static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input); 675 static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input); 676 static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz); 677 678 679 static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input); 680 static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input); 681 static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz); 682 683 684 static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input); 685 static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input); 686 static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz); 687 688 689 static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input); 690 static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input); 691 static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz); 692 693 694 static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input); 695 static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input); 696 static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz); 697 698 699 static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input); 700 static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input); 701 static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz); 702 703 704 static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input); 705 static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input); 706 static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz); 707 708 709 static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input); 710 static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input); 711 static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz); 712 713 714 static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input); 715 static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input); 716 static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz); 717 718 719 static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input); 720 static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input); 721 static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz); 722 723 724 static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input); 725 static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input); 726 static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz); 727 728 729 #else 730 731 732 /* bool[] support */ 733 static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input) { 734 int i; 735 jsize sz; 736 if (!input) { 737 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 738 return 0; 739 } 740 sz = jenv->GetArrayLength(input); 741 *jarr = jenv->GetBooleanArrayElements(input, 0); 742 if (!*jarr) 743 return 0; 744 *carr = new bool[sz]; 745 if (!*carr) { 746 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 747 return 0; 748 } 749 for (i=0; i<sz; i++) 750 (*carr)[i] = ((*jarr)[i] != 0); 751 return 1; 752 } 753 754 static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input) { 755 int i; 756 jsize sz = jenv->GetArrayLength(input); 757 for (i=0; i<sz; i++) 758 jarr[i] = (jboolean)carr[i]; 759 jenv->ReleaseBooleanArrayElements(input, jarr, 0); 760 } 761 762 static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz) { 763 jboolean *arr; 764 int i; 765 jbooleanArray jresult = jenv->NewBooleanArray(sz); 766 if (!jresult) 767 return NULL; 768 arr = jenv->GetBooleanArrayElements(jresult, 0); 769 if (!arr) 770 return NULL; 771 for (i=0; i<sz; i++) 772 arr[i] = (jboolean)result[i]; 773 jenv->ReleaseBooleanArrayElements(jresult, arr, 0); 774 return jresult; 775 } 776 777 778 /* signed char[] support */ 779 static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input) { 780 int i; 781 jsize sz; 782 if (!input) { 783 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 784 return 0; 785 } 786 sz = jenv->GetArrayLength(input); 787 *jarr = jenv->GetByteArrayElements(input, 0); 788 if (!*jarr) 789 return 0; 790 *carr = new signed char[sz]; 791 if (!*carr) { 792 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 793 return 0; 794 } 795 for (i=0; i<sz; i++) 796 (*carr)[i] = (signed char)(*jarr)[i]; 797 return 1; 798 } 799 800 static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input) { 801 int i; 802 jsize sz = jenv->GetArrayLength(input); 803 for (i=0; i<sz; i++) 804 jarr[i] = (jbyte)carr[i]; 805 jenv->ReleaseByteArrayElements(input, jarr, 0); 806 } 807 808 static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz) { 809 jbyte *arr; 810 int i; 811 jbyteArray jresult = jenv->NewByteArray(sz); 812 if (!jresult) 813 return NULL; 814 arr = jenv->GetByteArrayElements(jresult, 0); 815 if (!arr) 816 return NULL; 817 for (i=0; i<sz; i++) 818 arr[i] = (jbyte)result[i]; 819 jenv->ReleaseByteArrayElements(jresult, arr, 0); 820 return jresult; 821 } 822 823 824 /* unsigned char[] support */ 825 static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input) { 826 int i; 827 jsize sz; 828 if (!input) { 829 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 830 return 0; 831 } 832 sz = jenv->GetArrayLength(input); 833 *jarr = jenv->GetShortArrayElements(input, 0); 834 if (!*jarr) 835 return 0; 836 *carr = new unsigned char[sz]; 837 if (!*carr) { 838 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 839 return 0; 840 } 841 for (i=0; i<sz; i++) 842 (*carr)[i] = (unsigned char)(*jarr)[i]; 843 return 1; 844 } 845 846 static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input) { 847 int i; 848 jsize sz = jenv->GetArrayLength(input); 849 for (i=0; i<sz; i++) 850 jarr[i] = (jshort)carr[i]; 851 jenv->ReleaseShortArrayElements(input, jarr, 0); 852 } 853 854 static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz) { 855 jshort *arr; 856 int i; 857 jshortArray jresult = jenv->NewShortArray(sz); 858 if (!jresult) 859 return NULL; 860 arr = jenv->GetShortArrayElements(jresult, 0); 861 if (!arr) 862 return NULL; 863 for (i=0; i<sz; i++) 864 arr[i] = (jshort)result[i]; 865 jenv->ReleaseShortArrayElements(jresult, arr, 0); 866 return jresult; 867 } 868 869 870 /* short[] support */ 871 static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input) { 872 int i; 873 jsize sz; 874 if (!input) { 875 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 876 return 0; 877 } 878 sz = jenv->GetArrayLength(input); 879 *jarr = jenv->GetShortArrayElements(input, 0); 880 if (!*jarr) 881 return 0; 882 *carr = new short[sz]; 883 if (!*carr) { 884 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 885 return 0; 886 } 887 for (i=0; i<sz; i++) 888 (*carr)[i] = (short)(*jarr)[i]; 889 return 1; 890 } 891 892 static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input) { 893 int i; 894 jsize sz = jenv->GetArrayLength(input); 895 for (i=0; i<sz; i++) 896 jarr[i] = (jshort)carr[i]; 897 jenv->ReleaseShortArrayElements(input, jarr, 0); 898 } 899 900 static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz) { 901 jshort *arr; 902 int i; 903 jshortArray jresult = jenv->NewShortArray(sz); 904 if (!jresult) 905 return NULL; 906 arr = jenv->GetShortArrayElements(jresult, 0); 907 if (!arr) 908 return NULL; 909 for (i=0; i<sz; i++) 910 arr[i] = (jshort)result[i]; 911 jenv->ReleaseShortArrayElements(jresult, arr, 0); 912 return jresult; 913 } 914 915 916 /* unsigned short[] support */ 917 static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input) { 918 int i; 919 jsize sz; 920 if (!input) { 921 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 922 return 0; 923 } 924 sz = jenv->GetArrayLength(input); 925 *jarr = jenv->GetIntArrayElements(input, 0); 926 if (!*jarr) 927 return 0; 928 *carr = new unsigned short[sz]; 929 if (!*carr) { 930 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 931 return 0; 932 } 933 for (i=0; i<sz; i++) 934 (*carr)[i] = (unsigned short)(*jarr)[i]; 935 return 1; 936 } 937 938 static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input) { 939 int i; 940 jsize sz = jenv->GetArrayLength(input); 941 for (i=0; i<sz; i++) 942 jarr[i] = (jint)carr[i]; 943 jenv->ReleaseIntArrayElements(input, jarr, 0); 944 } 945 946 static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz) { 947 jint *arr; 948 int i; 949 jintArray jresult = jenv->NewIntArray(sz); 950 if (!jresult) 951 return NULL; 952 arr = jenv->GetIntArrayElements(jresult, 0); 953 if (!arr) 954 return NULL; 955 for (i=0; i<sz; i++) 956 arr[i] = (jint)result[i]; 957 jenv->ReleaseIntArrayElements(jresult, arr, 0); 958 return jresult; 959 } 960 961 962 /* int[] support */ 963 static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input) { 964 int i; 965 jsize sz; 966 if (!input) { 967 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 968 return 0; 969 } 970 sz = jenv->GetArrayLength(input); 971 *jarr = jenv->GetIntArrayElements(input, 0); 972 if (!*jarr) 973 return 0; 974 *carr = new int[sz]; 975 if (!*carr) { 976 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 977 return 0; 978 } 979 for (i=0; i<sz; i++) 980 (*carr)[i] = (int)(*jarr)[i]; 981 return 1; 982 } 983 984 static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input) { 985 int i; 986 jsize sz = jenv->GetArrayLength(input); 987 for (i=0; i<sz; i++) 988 jarr[i] = (jint)carr[i]; 989 jenv->ReleaseIntArrayElements(input, jarr, 0); 990 } 991 992 static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz) { 993 jint *arr; 994 int i; 995 jintArray jresult = jenv->NewIntArray(sz); 996 if (!jresult) 997 return NULL; 998 arr = jenv->GetIntArrayElements(jresult, 0); 999 if (!arr) 1000 return NULL; 1001 for (i=0; i<sz; i++) 1002 arr[i] = (jint)result[i]; 1003 jenv->ReleaseIntArrayElements(jresult, arr, 0); 1004 return jresult; 1005 } 1006 1007 1008 /* unsigned int[] support */ 1009 static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input) { 1010 int i; 1011 jsize sz; 1012 if (!input) { 1013 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1014 return 0; 1015 } 1016 sz = jenv->GetArrayLength(input); 1017 *jarr = jenv->GetLongArrayElements(input, 0); 1018 if (!*jarr) 1019 return 0; 1020 *carr = new unsigned int[sz]; 1021 if (!*carr) { 1022 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1023 return 0; 1024 } 1025 for (i=0; i<sz; i++) 1026 (*carr)[i] = (unsigned int)(*jarr)[i]; 1027 return 1; 1028 } 1029 1030 static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input) { 1031 int i; 1032 jsize sz = jenv->GetArrayLength(input); 1033 for (i=0; i<sz; i++) 1034 jarr[i] = (jlong)carr[i]; 1035 jenv->ReleaseLongArrayElements(input, jarr, 0); 1036 } 1037 1038 static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz) { 1039 jlong *arr; 1040 int i; 1041 jlongArray jresult = jenv->NewLongArray(sz); 1042 if (!jresult) 1043 return NULL; 1044 arr = jenv->GetLongArrayElements(jresult, 0); 1045 if (!arr) 1046 return NULL; 1047 for (i=0; i<sz; i++) 1048 arr[i] = (jlong)result[i]; 1049 jenv->ReleaseLongArrayElements(jresult, arr, 0); 1050 return jresult; 1051 } 1052 1053 1054 /* long[] support */ 1055 static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input) { 1056 int i; 1057 jsize sz; 1058 if (!input) { 1059 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1060 return 0; 1061 } 1062 sz = jenv->GetArrayLength(input); 1063 *jarr = jenv->GetIntArrayElements(input, 0); 1064 if (!*jarr) 1065 return 0; 1066 *carr = new long[sz]; 1067 if (!*carr) { 1068 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1069 return 0; 1070 } 1071 for (i=0; i<sz; i++) 1072 (*carr)[i] = (long)(*jarr)[i]; 1073 return 1; 1074 } 1075 1076 static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input) { 1077 int i; 1078 jsize sz = jenv->GetArrayLength(input); 1079 for (i=0; i<sz; i++) 1080 jarr[i] = (jint)carr[i]; 1081 jenv->ReleaseIntArrayElements(input, jarr, 0); 1082 } 1083 1084 static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz) { 1085 jint *arr; 1086 int i; 1087 jintArray jresult = jenv->NewIntArray(sz); 1088 if (!jresult) 1089 return NULL; 1090 arr = jenv->GetIntArrayElements(jresult, 0); 1091 if (!arr) 1092 return NULL; 1093 for (i=0; i<sz; i++) 1094 arr[i] = (jint)result[i]; 1095 jenv->ReleaseIntArrayElements(jresult, arr, 0); 1096 return jresult; 1097 } 1098 1099 1100 /* unsigned long[] support */ 1101 static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input) { 1102 int i; 1103 jsize sz; 1104 if (!input) { 1105 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1106 return 0; 1107 } 1108 sz = jenv->GetArrayLength(input); 1109 *jarr = jenv->GetLongArrayElements(input, 0); 1110 if (!*jarr) 1111 return 0; 1112 *carr = new unsigned long[sz]; 1113 if (!*carr) { 1114 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1115 return 0; 1116 } 1117 for (i=0; i<sz; i++) 1118 (*carr)[i] = (unsigned long)(*jarr)[i]; 1119 return 1; 1120 } 1121 1122 static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input) { 1123 int i; 1124 jsize sz = jenv->GetArrayLength(input); 1125 for (i=0; i<sz; i++) 1126 jarr[i] = (jlong)carr[i]; 1127 jenv->ReleaseLongArrayElements(input, jarr, 0); 1128 } 1129 1130 static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz) { 1131 jlong *arr; 1132 int i; 1133 jlongArray jresult = jenv->NewLongArray(sz); 1134 if (!jresult) 1135 return NULL; 1136 arr = jenv->GetLongArrayElements(jresult, 0); 1137 if (!arr) 1138 return NULL; 1139 for (i=0; i<sz; i++) 1140 arr[i] = (jlong)result[i]; 1141 jenv->ReleaseLongArrayElements(jresult, arr, 0); 1142 return jresult; 1143 } 1144 1145 1146 /* jlong[] support */ 1147 static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input) { 1148 int i; 1149 jsize sz; 1150 if (!input) { 1151 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1152 return 0; 1153 } 1154 sz = jenv->GetArrayLength(input); 1155 *jarr = jenv->GetLongArrayElements(input, 0); 1156 if (!*jarr) 1157 return 0; 1158 *carr = new jlong[sz]; 1159 if (!*carr) { 1160 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1161 return 0; 1162 } 1163 for (i=0; i<sz; i++) 1164 (*carr)[i] = (jlong)(*jarr)[i]; 1165 return 1; 1166 } 1167 1168 static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input) { 1169 int i; 1170 jsize sz = jenv->GetArrayLength(input); 1171 for (i=0; i<sz; i++) 1172 jarr[i] = (jlong)carr[i]; 1173 jenv->ReleaseLongArrayElements(input, jarr, 0); 1174 } 1175 1176 static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz) { 1177 jlong *arr; 1178 int i; 1179 jlongArray jresult = jenv->NewLongArray(sz); 1180 if (!jresult) 1181 return NULL; 1182 arr = jenv->GetLongArrayElements(jresult, 0); 1183 if (!arr) 1184 return NULL; 1185 for (i=0; i<sz; i++) 1186 arr[i] = (jlong)result[i]; 1187 jenv->ReleaseLongArrayElements(jresult, arr, 0); 1188 return jresult; 1189 } 1190 1191 1192 /* float[] support */ 1193 static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input) { 1194 int i; 1195 jsize sz; 1196 if (!input) { 1197 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1198 return 0; 1199 } 1200 sz = jenv->GetArrayLength(input); 1201 *jarr = jenv->GetFloatArrayElements(input, 0); 1202 if (!*jarr) 1203 return 0; 1204 *carr = new float[sz]; 1205 if (!*carr) { 1206 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1207 return 0; 1208 } 1209 for (i=0; i<sz; i++) 1210 (*carr)[i] = (float)(*jarr)[i]; 1211 return 1; 1212 } 1213 1214 static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input) { 1215 int i; 1216 jsize sz = jenv->GetArrayLength(input); 1217 for (i=0; i<sz; i++) 1218 jarr[i] = (jfloat)carr[i]; 1219 jenv->ReleaseFloatArrayElements(input, jarr, 0); 1220 } 1221 1222 static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz) { 1223 jfloat *arr; 1224 int i; 1225 jfloatArray jresult = jenv->NewFloatArray(sz); 1226 if (!jresult) 1227 return NULL; 1228 arr = jenv->GetFloatArrayElements(jresult, 0); 1229 if (!arr) 1230 return NULL; 1231 for (i=0; i<sz; i++) 1232 arr[i] = (jfloat)result[i]; 1233 jenv->ReleaseFloatArrayElements(jresult, arr, 0); 1234 return jresult; 1235 } 1236 1237 1238 /* double[] support */ 1239 static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input) { 1240 int i; 1241 jsize sz; 1242 if (!input) { 1243 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); 1244 return 0; 1245 } 1246 sz = jenv->GetArrayLength(input); 1247 *jarr = jenv->GetDoubleArrayElements(input, 0); 1248 if (!*jarr) 1249 return 0; 1250 *carr = new double[sz]; 1251 if (!*carr) { 1252 SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); 1253 return 0; 1254 } 1255 for (i=0; i<sz; i++) 1256 (*carr)[i] = (double)(*jarr)[i]; 1257 return 1; 1258 } 1259 1260 static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input) { 1261 int i; 1262 jsize sz = jenv->GetArrayLength(input); 1263 for (i=0; i<sz; i++) 1264 jarr[i] = (jdouble)carr[i]; 1265 jenv->ReleaseDoubleArrayElements(input, jarr, 0); 1266 } 1267 1268 static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz) { 1269 jdouble *arr; 1270 int i; 1271 jdoubleArray jresult = jenv->NewDoubleArray(sz); 1272 if (!jresult) 1273 return NULL; 1274 arr = jenv->GetDoubleArrayElements(jresult, 0); 1275 if (!arr) 1276 return NULL; 1277 for (i=0; i<sz; i++) 1278 arr[i] = (jdouble)result[i]; 1279 jenv->ReleaseDoubleArrayElements(jresult, arr, 0); 1280 return jresult; 1281 } 1282 1283 1284 #endif 1285 1286 1287 #include <gdx/common/jniHelpers.h> 1288 1289 1290 #include <stdint.h> 1291 1292 1293 #include <gdx/linearmath/mathtypes.h> 1294 #include <LinearMath/btVector3.h> 1295 #include <LinearMath/btQuaternion.h> 1296 #include <LinearMath/btMatrix3x3.h> 1297 #include <LinearMath/btTransform.h> 1298 1299 1300 #include <BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h> 1301 1302 1303 1304 /* Gets a global ref to the temp class. Do not release this. */ 1305 SWIGINTERN inline jclass gdx_getTempClassVector3(JNIEnv * jenv) { 1306 static jclass cls = NULL; 1307 if (cls == NULL) { 1308 cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); 1309 } 1310 return cls; 1311 } 1312 1313 SWIGINTERN inline jobject gdx_takePoolObjectVector3(JNIEnv * jenv, const char * poolName) { 1314 jclass tempClass = gdx_getTempClassVector3(jenv); 1315 1316 static jfieldID poolField = NULL; 1317 if (poolField == NULL) { 1318 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1319 } 1320 1321 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1322 jclass poolClass = jenv->GetObjectClass(poolObject); 1323 1324 static jmethodID obtainMethod = NULL; 1325 if (obtainMethod == NULL) { 1326 obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); 1327 } 1328 1329 jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); 1330 1331 jenv->DeleteLocalRef(poolObject); 1332 jenv->DeleteLocalRef(poolClass); 1333 1334 return ret; 1335 } 1336 1337 SWIGINTERN inline void gdx_releasePoolObjectVector3(JNIEnv * jenv, const char * poolName, jobject obj) { 1338 jclass tempClass = gdx_getTempClassVector3(jenv); 1339 1340 static jfieldID poolField = NULL; 1341 if (poolField == NULL) { 1342 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1343 } 1344 1345 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1346 jclass poolClass = jenv->GetObjectClass(poolObject); 1347 1348 static jmethodID freeMethod = NULL; 1349 if (freeMethod == NULL) { 1350 freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); 1351 } 1352 1353 jenv->CallVoidMethod(poolObject, freeMethod, obj); 1354 1355 jenv->DeleteLocalRef(poolObject); 1356 jenv->DeleteLocalRef(poolClass); 1357 jenv->DeleteLocalRef(obj); 1358 } 1359 1360 /* 1361 * A simple RAII wrapper to release jobjects we obtain from pools in 1362 * directorin typemaps. SWIG doesn't have hooks to release them after 1363 * they're used. 1364 */ 1365 class gdxPoolAutoReleaseVector3 { 1366 private: 1367 JNIEnv * jenv; 1368 const char * poolName; 1369 jobject obj; 1370 public: 1371 gdxPoolAutoReleaseVector3(JNIEnv * jenv, const char * poolName, jobject obj) : 1372 jenv(jenv), poolName(poolName), obj(obj) { }; 1373 virtual ~gdxPoolAutoReleaseVector3() { 1374 gdx_releasePoolObjectVector3(this->jenv, this->poolName, this->obj); 1375 }; 1376 }; 1377 1378 1379 1380 // Workaround for some strange swig behaviour 1381 1382 1383 /* Gets a global ref to the temp class's Return Vector3. Do not release this. */ 1384 SWIGINTERN inline jobject gdx_getReturnVector3(JNIEnv * jenv) { 1385 static jobject ret = NULL; 1386 if (ret == NULL) { 1387 jclass tempClass = gdx_getTempClassVector3(jenv); 1388 jfieldID field = jenv->GetStaticFieldID(tempClass, "staticVector3", "Lcom/badlogic/gdx/math/Vector3;"); 1389 ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); 1390 } 1391 return ret; 1392 } 1393 1394 /* Sets the data in the Bullet type from the Gdx type. */ 1395 SWIGINTERN inline void gdx_setbtVector3FromVector3(JNIEnv * jenv, btVector3 & target, jobject source) { 1396 Vector3_to_btVector3(jenv, target, source); 1397 } 1398 1399 SWIGINTERN inline void gdx_setbtVector3FromVector3(JNIEnv * jenv, btVector3 * target, jobject source) { 1400 gdx_setbtVector3FromVector3(jenv, *target, source); 1401 } 1402 1403 /* Sets the data in the Gdx type from the Bullet type. */ 1404 SWIGINTERN inline void gdx_setVector3FrombtVector3(JNIEnv * jenv, jobject target, const btVector3 & source) { 1405 btVector3_to_Vector3(jenv, target, source); 1406 } 1407 1408 SWIGINTERN inline void gdx_setVector3FrombtVector3(JNIEnv * jenv, jobject target, const btVector3 * source) { 1409 gdx_setVector3FrombtVector3(jenv, target, *source); 1410 } 1411 1412 /* 1413 * RAII wrapper to commit changes made to a local btVector3 back to Vector3 1414 */ 1415 class gdxAutoCommitVector3 { 1416 private: 1417 JNIEnv * jenv; 1418 jobject jVector3; 1419 btVector3 & cbtVector3; 1420 public: 1421 gdxAutoCommitVector3(JNIEnv * jenv, jobject jVector3, btVector3 & cbtVector3) : 1422 jenv(jenv), jVector3(jVector3), cbtVector3(cbtVector3) { }; 1423 gdxAutoCommitVector3(JNIEnv * jenv, jobject jVector3, btVector3 * cbtVector3) : 1424 jenv(jenv), jVector3(jVector3), cbtVector3(*cbtVector3) { }; 1425 virtual ~gdxAutoCommitVector3() { 1426 gdx_setVector3FrombtVector3(this->jenv, this->jVector3, this->cbtVector3); 1427 }; 1428 }; 1429 1430 class gdxAutoCommitbtVector3AndReleaseVector3 { 1431 private: 1432 JNIEnv * jenv; 1433 jobject jVector3; 1434 btVector3 & cbtVector3; 1435 const char * poolName; 1436 public: 1437 gdxAutoCommitbtVector3AndReleaseVector3(JNIEnv * jenv, jobject jVector3, btVector3 & cbtVector3, const char *poolName) : 1438 jenv(jenv), jVector3(jVector3), cbtVector3(cbtVector3), poolName(poolName) { }; 1439 gdxAutoCommitbtVector3AndReleaseVector3(JNIEnv * jenv, jobject jVector3, btVector3 * cbtVector3, const char *poolName) : 1440 jenv(jenv), jVector3(jVector3), cbtVector3(*cbtVector3), poolName(poolName) { }; 1441 virtual ~gdxAutoCommitbtVector3AndReleaseVector3() { 1442 gdx_setbtVector3FromVector3(this->jenv, this->cbtVector3, this->jVector3); 1443 gdx_releasePoolObjectVector3(this->jenv, this->poolName, this->jVector3); 1444 }; 1445 }; 1446 1447 1448 #include <BulletCollision/BroadphaseCollision/btBroadphaseProxy.h> 1449 1450 1451 #include <BulletCollision/BroadphaseCollision/btBroadphaseInterface.h> 1452 1453 1454 #include <BulletCollision/BroadphaseCollision/btQuantizedBvh.h> 1455 1456 1457 #include <BulletCollision/BroadphaseCollision/btSimpleBroadphase.h> 1458 1459 1460 #include <BulletCollision/BroadphaseCollision/btMultiSapBroadphase.h> 1461 void btMultiSapBroadphase::quicksort(btBroadphasePairArray& a, int lo, int hi) 1462 { 1463 } 1464 1465 1466 #include <BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h> 1467 1468 1469 #include <BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h> 1470 1471 1472 #include <BulletCollision/BroadphaseCollision/btAxisSweep3.h> 1473 1474 1475 #include <BulletCollision/BroadphaseCollision/btDispatcher.h> 1476 1477 1478 #include <BulletCollision/BroadphaseCollision/btOverlappingPairCache.h> 1479 1480 1481 // Inline (cached) method to retrieve the type's jclass 1482 SWIGINTERN inline jclass &gdx_getClassbtBroadphasePair(JNIEnv * const &jenv) { 1483 static jclass cls = NULL; 1484 if (cls == NULL) 1485 cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btBroadphasePair")); 1486 return cls; 1487 } 1488 1489 // Inline method to get the termporary instance 1490 SWIGINTERN inline jobject gdx_getTempbtBroadphasePair(JNIEnv * jenv, void *cPtr, bool ownMem) { 1491 static jobject ret = NULL; 1492 jclass &clazz = gdx_getClassbtBroadphasePair(jenv); 1493 if (ret == NULL) { 1494 jfieldID field = jenv->GetStaticFieldID(clazz, "temp", "Lcom/badlogic/gdx/physics/bullet/collision/btBroadphasePair;"); 1495 ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(clazz, field)); 1496 } 1497 1498 static jmethodID reuseMethod = NULL; 1499 if (reuseMethod == NULL) 1500 reuseMethod = (jmethodID) jenv->GetMethodID(clazz, "reset", "(JZ)V"); 1501 1502 long ptr; 1503 *(const void **)&ptr = cPtr; 1504 jenv->CallVoidMethod(ret, reuseMethod, ptr, (jboolean)ownMem); 1505 return ret; 1506 } 1507 1508 // Inline method to obtain an instance from the pool 1509 SWIGINTERN inline jobject gdx_obtainbtBroadphasePair(JNIEnv * jenv, jclass clazz, void *cPtr, bool ownMem) { 1510 static jmethodID obtainMethod = NULL; 1511 if (obtainMethod == NULL) 1512 obtainMethod = (jmethodID) jenv->GetStaticMethodID(clazz, "obtain", "(JZ)Lcom/badlogic/gdx/physics/bullet/collision/btBroadphasePair;"); 1513 1514 long ptr; 1515 *(const void **)&ptr = cPtr; 1516 jobject ret = jenv->CallStaticObjectMethod(clazz, obtainMethod, ptr, (jboolean)ownMem); 1517 1518 return ret; 1519 } 1520 1521 // Inline method to free an instance from the pool 1522 SWIGINTERN inline void gdx_freebtBroadphasePair(JNIEnv * jenv, const jclass clazz, const jobject obj) { 1523 static jmethodID freeMethod = NULL; 1524 if (freeMethod == NULL) 1525 freeMethod = (jmethodID) jenv->GetStaticMethodID(clazz, "free", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphasePair;)V"); 1526 1527 jenv->CallStaticVoidMethod(clazz, freeMethod, obj); 1528 1529 jenv->DeleteLocalRef(obj); 1530 } 1531 1532 // Simple raii class to auto free the instance from the pool 1533 class gdxAutoFreebtBroadphasePair { 1534 private: 1535 JNIEnv * jenv; 1536 jobject jbtBroadphasePair; 1537 jclass jclazz; 1538 public: 1539 gdxAutoFreebtBroadphasePair(JNIEnv * jenv, jclass jclazz, jobject jbtBroadphasePair) : 1540 jenv(jenv), jbtBroadphasePair(jbtBroadphasePair), jclazz(jclazz) { } 1541 virtual ~gdxAutoFreebtBroadphasePair() { 1542 gdx_freebtBroadphasePair(this->jenv, this->jclazz, this->jbtBroadphasePair); 1543 } 1544 }; 1545 1546 1547 #include <BulletCollision/CollisionShapes/btCollisionShape.h> 1548 1549 1550 1551 /* Gets a global ref to the temp class. Do not release this. */ 1552 SWIGINTERN inline jclass gdx_getTempClassMatrix4(JNIEnv * jenv) { 1553 static jclass cls = NULL; 1554 if (cls == NULL) { 1555 cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); 1556 } 1557 return cls; 1558 } 1559 1560 SWIGINTERN inline jobject gdx_takePoolObjectMatrix4(JNIEnv * jenv, const char * poolName) { 1561 jclass tempClass = gdx_getTempClassMatrix4(jenv); 1562 1563 static jfieldID poolField = NULL; 1564 if (poolField == NULL) { 1565 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1566 } 1567 1568 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1569 jclass poolClass = jenv->GetObjectClass(poolObject); 1570 1571 static jmethodID obtainMethod = NULL; 1572 if (obtainMethod == NULL) { 1573 obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); 1574 } 1575 1576 jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); 1577 1578 jenv->DeleteLocalRef(poolObject); 1579 jenv->DeleteLocalRef(poolClass); 1580 1581 return ret; 1582 } 1583 1584 SWIGINTERN inline void gdx_releasePoolObjectMatrix4(JNIEnv * jenv, const char * poolName, jobject obj) { 1585 jclass tempClass = gdx_getTempClassMatrix4(jenv); 1586 1587 static jfieldID poolField = NULL; 1588 if (poolField == NULL) { 1589 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1590 } 1591 1592 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1593 jclass poolClass = jenv->GetObjectClass(poolObject); 1594 1595 static jmethodID freeMethod = NULL; 1596 if (freeMethod == NULL) { 1597 freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); 1598 } 1599 1600 jenv->CallVoidMethod(poolObject, freeMethod, obj); 1601 1602 jenv->DeleteLocalRef(poolObject); 1603 jenv->DeleteLocalRef(poolClass); 1604 jenv->DeleteLocalRef(obj); 1605 } 1606 1607 /* 1608 * A simple RAII wrapper to release jobjects we obtain from pools in 1609 * directorin typemaps. SWIG doesn't have hooks to release them after 1610 * they're used. 1611 */ 1612 class gdxPoolAutoReleaseMatrix4 { 1613 private: 1614 JNIEnv * jenv; 1615 const char * poolName; 1616 jobject obj; 1617 public: 1618 gdxPoolAutoReleaseMatrix4(JNIEnv * jenv, const char * poolName, jobject obj) : 1619 jenv(jenv), poolName(poolName), obj(obj) { }; 1620 virtual ~gdxPoolAutoReleaseMatrix4() { 1621 gdx_releasePoolObjectMatrix4(this->jenv, this->poolName, this->obj); 1622 }; 1623 }; 1624 1625 1626 1627 // Workaround for some strange swig behaviour 1628 1629 1630 /* Gets a global ref to the temp class's Return Matrix4. Do not release this. */ 1631 SWIGINTERN inline jobject gdx_getReturnMatrix4(JNIEnv * jenv) { 1632 static jobject ret = NULL; 1633 if (ret == NULL) { 1634 jclass tempClass = gdx_getTempClassMatrix4(jenv); 1635 jfieldID field = jenv->GetStaticFieldID(tempClass, "staticMatrix4", "Lcom/badlogic/gdx/math/Matrix4;"); 1636 ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); 1637 } 1638 return ret; 1639 } 1640 1641 /* Sets the data in the Bullet type from the Gdx type. */ 1642 SWIGINTERN inline void gdx_setbtTransformFromMatrix4(JNIEnv * jenv, btTransform & target, jobject source) { 1643 Matrix4_to_btTransform(jenv, target, source); 1644 } 1645 1646 SWIGINTERN inline void gdx_setbtTransformFromMatrix4(JNIEnv * jenv, btTransform * target, jobject source) { 1647 gdx_setbtTransformFromMatrix4(jenv, *target, source); 1648 } 1649 1650 /* Sets the data in the Gdx type from the Bullet type. */ 1651 SWIGINTERN inline void gdx_setMatrix4FrombtTransform(JNIEnv * jenv, jobject target, const btTransform & source) { 1652 btTransform_to_Matrix4(jenv, target, source); 1653 } 1654 1655 SWIGINTERN inline void gdx_setMatrix4FrombtTransform(JNIEnv * jenv, jobject target, const btTransform * source) { 1656 gdx_setMatrix4FrombtTransform(jenv, target, *source); 1657 } 1658 1659 /* 1660 * RAII wrapper to commit changes made to a local btTransform back to Matrix4 1661 */ 1662 class gdxAutoCommitMatrix4 { 1663 private: 1664 JNIEnv * jenv; 1665 jobject jMatrix4; 1666 btTransform & cbtTransform; 1667 public: 1668 gdxAutoCommitMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform & cbtTransform) : 1669 jenv(jenv), jMatrix4(jMatrix4), cbtTransform(cbtTransform) { }; 1670 gdxAutoCommitMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform * cbtTransform) : 1671 jenv(jenv), jMatrix4(jMatrix4), cbtTransform(*cbtTransform) { }; 1672 virtual ~gdxAutoCommitMatrix4() { 1673 gdx_setMatrix4FrombtTransform(this->jenv, this->jMatrix4, this->cbtTransform); 1674 }; 1675 }; 1676 1677 class gdxAutoCommitbtTransformAndReleaseMatrix4 { 1678 private: 1679 JNIEnv * jenv; 1680 jobject jMatrix4; 1681 btTransform & cbtTransform; 1682 const char * poolName; 1683 public: 1684 gdxAutoCommitbtTransformAndReleaseMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform & cbtTransform, const char *poolName) : 1685 jenv(jenv), jMatrix4(jMatrix4), cbtTransform(cbtTransform), poolName(poolName) { }; 1686 gdxAutoCommitbtTransformAndReleaseMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform * cbtTransform, const char *poolName) : 1687 jenv(jenv), jMatrix4(jMatrix4), cbtTransform(*cbtTransform), poolName(poolName) { }; 1688 virtual ~gdxAutoCommitbtTransformAndReleaseMatrix4() { 1689 gdx_setbtTransformFromMatrix4(this->jenv, this->cbtTransform, this->jMatrix4); 1690 gdx_releasePoolObjectMatrix4(this->jenv, this->poolName, this->jMatrix4); 1691 }; 1692 }; 1693 1694 1695 #include <BulletCollision/CollisionShapes/btConvexShape.h> 1696 1697 1698 #include <BulletCollision/CollisionShapes/btConvexInternalShape.h> 1699 1700 1701 #include <BulletCollision/CollisionShapes/btPolyhedralConvexShape.h> 1702 1703 1704 #include <BulletCollision/CollisionShapes/btConcaveShape.h> 1705 1706 1707 #include <BulletCollision/CollisionShapes/btTriangleCallback.h> 1708 1709 1710 #include <BulletCollision/CollisionShapes/btTriangleInfoMap.h> 1711 1712 1713 #include <BulletCollision/CollisionShapes/btStaticPlaneShape.h> 1714 1715 1716 #include <BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h> 1717 1718 SWIGINTERN btHeightfieldTerrainShape *new_btHeightfieldTerrainShape__SWIG_0(int heightStickWidth,int heightStickLength,float const *heightfieldData,btScalar heightScale,btScalar minHeight,btScalar maxHeight,int upAxis,bool flipQuadEdges){ 1719 return new btHeightfieldTerrainShape(heightStickWidth, heightStickLength, (void *)heightfieldData, heightScale, minHeight, maxHeight, upAxis, PHY_FLOAT, flipQuadEdges); 1720 } 1721 SWIGINTERN btHeightfieldTerrainShape *new_btHeightfieldTerrainShape__SWIG_1(int heightStickWidth,int heightStickLength,short const *heightfieldData,btScalar heightScale,btScalar minHeight,btScalar maxHeight,int upAxis,bool flipQuadEdges){ 1722 return new btHeightfieldTerrainShape(heightStickWidth, heightStickLength, (void *)heightfieldData, heightScale, minHeight, maxHeight, upAxis, PHY_SHORT, flipQuadEdges); 1723 } 1724 1725 #include <BulletCollision/CollisionShapes/btTriangleMeshShape.h> 1726 1727 1728 #include <BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h> 1729 1730 SWIGINTERN btBvhTriangleMeshShape *new_btBvhTriangleMeshShape__SWIG_0(bool dummy,btStridingMeshInterface *meshInterface,bool useQuantizedAabbCompression,bool buildBvh=true){ 1731 return new btBvhTriangleMeshShape(meshInterface, useQuantizedAabbCompression, buildBvh); 1732 } 1733 SWIGINTERN btBvhTriangleMeshShape *new_btBvhTriangleMeshShape__SWIG_2(bool dummy,btStridingMeshInterface *meshInterface,bool useQuantizedAabbCompression,btVector3 const &bvhAabbMin,btVector3 const &bvhAabbMax,bool buildBvh=true){ 1734 return new btBvhTriangleMeshShape(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax, buildBvh); 1735 } 1736 1737 #include <BulletCollision/CollisionShapes/btBoxShape.h> 1738 1739 1740 #include <BulletCollision/CollisionShapes/btCapsuleShape.h> 1741 1742 1743 #include <BulletCollision/CollisionShapes/btBox2dShape.h> 1744 1745 1746 #include <BulletCollision/CollisionShapes/btCollisionMargin.h> 1747 1748 1749 #include <BulletCollision/CollisionShapes/btTriangleShape.h> 1750 1751 1752 #include <BulletCollision/CollisionShapes/btSphereShape.h> 1753 1754 1755 #include <BulletCollision/CollisionShapes/btStridingMeshInterface.h> 1756 1757 1758 #include <BulletCollision/CollisionShapes/btMinkowskiSumShape.h> 1759 1760 1761 #include <BulletCollision/CollisionShapes/btConvexPolyhedron.h> 1762 1763 1764 #include <BulletCollision/CollisionShapes/btOptimizedBvh.h> 1765 1766 1767 #include <BulletCollision/CollisionShapes/btTriangleBuffer.h> 1768 1769 1770 #include <BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h> 1771 1772 SWIGINTERN void btIndexedMesh_setTriangleIndexBase(btIndexedMesh *self,short *data){ 1773 self->m_triangleIndexBase = (unsigned char*)data; 1774 } 1775 SWIGINTERN void btIndexedMesh_setVertexBase(btIndexedMesh *self,float *data){ 1776 self->m_vertexBase = (unsigned char*)data; 1777 } 1778 SWIGINTERN void btIndexedMesh_setVertices(btIndexedMesh *self,float *vertices,int sizeInBytesOfEachVertex,int vertexCount,int positionOffsetInBytes){ 1779 unsigned char *data = (unsigned char *)vertices; 1780 self->m_vertexBase = &(data[positionOffsetInBytes]); 1781 self->m_vertexStride = sizeInBytesOfEachVertex; 1782 self->m_numVertices = vertexCount; 1783 self->m_vertexType = PHY_FLOAT; 1784 } 1785 SWIGINTERN void btIndexedMesh_setIndices(btIndexedMesh *self,short *indices,int indexOffset,int indexCount){ 1786 self->m_triangleIndexBase = (unsigned char*)&(indices[indexOffset]); 1787 self->m_triangleIndexStride = 3 * sizeof(short); 1788 self->m_numTriangles = indexCount / 3; 1789 self->m_indexType = PHY_SHORT; 1790 } 1791 1792 #include <BulletCollision/CollisionShapes/btMaterial.h> 1793 1794 1795 #include <BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h> 1796 1797 1798 #include <BulletCollision/CollisionShapes/btShapeHull.h> 1799 1800 1801 #include <BulletCollision/CollisionShapes/btConvexHullShape.h> 1802 1803 SWIGINTERN btConvexHullShape *new_btConvexHullShape__SWIG_4(btShapeHull const *hull){ 1804 btConvexHullShape *result = new btConvexHullShape(); 1805 for (int i = 0; i < hull->numVertices(); i++) { 1806 result->addPoint(hull->getVertexPointer()[i]); 1807 } 1808 return result; 1809 } 1810 1811 #include <BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h> 1812 1813 1814 #include <BulletCollision/CollisionShapes/btCylinderShape.h> 1815 1816 1817 #include <BulletCollision/CollisionShapes/btTriangleMesh.h> 1818 1819 1820 #include <BulletCollision/CollisionShapes/btConeShape.h> 1821 1822 1823 #include <BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h> 1824 1825 1826 #include <BulletCollision/CollisionShapes/btEmptyShape.h> 1827 1828 1829 #include <BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h> 1830 1831 1832 #include <BulletCollision/CollisionShapes/btTetrahedronShape.h> 1833 1834 1835 #include <BulletCollision/CollisionShapes/btUniformScalingShape.h> 1836 1837 1838 #include <BulletCollision/CollisionShapes/btConvexPointCloudShape.h> 1839 1840 1841 #include <BulletCollision/CollisionShapes/btConvex2dShape.h> 1842 1843 1844 #include <BulletCollision/CollisionDispatch/btCollisionObject.h> 1845 #include <gdx/collision/GdxCollisionObjectBridge.h> 1846 1847 SWIGINTERN void btCollisionObject_internalSetGdxBridge(btCollisionObject *self,GdxCollisionObjectBridge *bridge){ 1848 self->setUserPointer(bridge); 1849 } 1850 SWIGINTERN GdxCollisionObjectBridge *btCollisionObject_internalGetGdxBridge(btCollisionObject *self){ 1851 return (GdxCollisionObjectBridge *)(self->getUserPointer()); 1852 } 1853 SWIGINTERN void btCollisionObject_getAnisotropicFriction__SWIG_1(btCollisionObject *self,btVector3 &out){ 1854 out = self->getAnisotropicFriction(); 1855 } 1856 SWIGINTERN void btCollisionObject_getWorldTransform__SWIG_2(btCollisionObject *self,btTransform &out){ 1857 out = self->getWorldTransform(); 1858 } 1859 SWIGINTERN void btCollisionObject_getInterpolationWorldTransform__SWIG_2(btCollisionObject *self,btTransform &out){ 1860 out = self->getInterpolationWorldTransform(); 1861 } 1862 SWIGINTERN void btCollisionObject_getInterpolationLinearVelocity__SWIG_1(btCollisionObject *self,btVector3 &out){ 1863 out = self->getInterpolationLinearVelocity(); 1864 } 1865 SWIGINTERN void btCollisionObject_getInterpolationAngularVelocity__SWIG_1(btCollisionObject *self,btVector3 &out){ 1866 out = self->getInterpolationAngularVelocity(); 1867 } 1868 1869 #include <BulletCollision/BroadphaseCollision/btDbvt.h> 1870 1871 SWIGINTERN btDbvtNode *btDbvtNode_getChild(btDbvtNode *self,int const &index){ 1872 return self->childs[index]; 1873 } 1874 SWIGINTERN btDbvtNode *btDbvtNode_getChild0(btDbvtNode *self){ 1875 return self->childs[0]; 1876 } 1877 SWIGINTERN btDbvtNode *btDbvtNode_getChild1(btDbvtNode *self){ 1878 return self->childs[1]; 1879 } 1880 SWIGINTERN btBroadphaseProxy *btDbvtNode_getDataAsProxy(btDbvtNode *self){ 1881 return (btBroadphaseProxy*)self->data; 1882 } 1883 SWIGINTERN btCollisionObject *btDbvtNode_getDataAsProxyClientObject(btDbvtNode *self){ 1884 return (self->isleaf()) ? (btCollisionObject*)((btBroadphaseProxy*)self->data)->m_clientObject : NULL; 1885 } 1886 SWIGINTERN void btDbvt_collideKDOP__SWIG_1(btDbvtNode const *root,btScalar const *normals,btScalar const *offsets,int count,btDbvt::ICollide &policy){ 1887 btDbvt::collideKDOP(root, (btVector3*)normals, offsets, count, policy); 1888 } 1889 SWIGINTERN void btDbvt_collideOCL__SWIG_2(btDbvtNode const *root,btScalar const *normals,btScalar const *offsets,btVector3 const &sortaxis,int count,btDbvt::ICollide &policy,bool fullsort=true){ 1890 btDbvt::collideOCL(root, (btVector3*)normals, offsets, sortaxis, count, policy, fullsort); 1891 } 1892 1893 #include <BulletCollision/BroadphaseCollision/btDbvtBroadphase.h> 1894 1895 SWIGINTERN btDbvt *btDbvtBroadphase_getSet(btDbvtBroadphase *self,int const &index){ 1896 return &(self->m_sets[index]); 1897 } 1898 SWIGINTERN btDbvt *btDbvtBroadphase_getSet0(btDbvtBroadphase *self){ 1899 return &(self->m_sets[0]); 1900 } 1901 SWIGINTERN btDbvt *btDbvtBroadphase_getSet1(btDbvtBroadphase *self){ 1902 return &(self->m_sets[1]); 1903 } 1904 1905 #include <BulletCollision/CollisionShapes/btCompoundShape.h> 1906 1907 1908 #include <BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h> 1909 #include <gdx/collision/CollisionObjectWrapper.h> 1910 1911 1912 #include <BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h> 1913 1914 1915 #include <BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h> 1916 1917 1918 #include <BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h> 1919 1920 1921 #include <BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h> 1922 1923 1924 1925 /* Gets a global ref to the temp class. Do not release this. */ 1926 SWIGINTERN inline jclass gdx_getTempClassQuaternion(JNIEnv * jenv) { 1927 static jclass cls = NULL; 1928 if (cls == NULL) { 1929 cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); 1930 } 1931 return cls; 1932 } 1933 1934 SWIGINTERN inline jobject gdx_takePoolObjectQuaternion(JNIEnv * jenv, const char * poolName) { 1935 jclass tempClass = gdx_getTempClassQuaternion(jenv); 1936 1937 static jfieldID poolField = NULL; 1938 if (poolField == NULL) { 1939 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1940 } 1941 1942 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1943 jclass poolClass = jenv->GetObjectClass(poolObject); 1944 1945 static jmethodID obtainMethod = NULL; 1946 if (obtainMethod == NULL) { 1947 obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); 1948 } 1949 1950 jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); 1951 1952 jenv->DeleteLocalRef(poolObject); 1953 jenv->DeleteLocalRef(poolClass); 1954 1955 return ret; 1956 } 1957 1958 SWIGINTERN inline void gdx_releasePoolObjectQuaternion(JNIEnv * jenv, const char * poolName, jobject obj) { 1959 jclass tempClass = gdx_getTempClassQuaternion(jenv); 1960 1961 static jfieldID poolField = NULL; 1962 if (poolField == NULL) { 1963 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 1964 } 1965 1966 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 1967 jclass poolClass = jenv->GetObjectClass(poolObject); 1968 1969 static jmethodID freeMethod = NULL; 1970 if (freeMethod == NULL) { 1971 freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); 1972 } 1973 1974 jenv->CallVoidMethod(poolObject, freeMethod, obj); 1975 1976 jenv->DeleteLocalRef(poolObject); 1977 jenv->DeleteLocalRef(poolClass); 1978 jenv->DeleteLocalRef(obj); 1979 } 1980 1981 /* 1982 * A simple RAII wrapper to release jobjects we obtain from pools in 1983 * directorin typemaps. SWIG doesn't have hooks to release them after 1984 * they're used. 1985 */ 1986 class gdxPoolAutoReleaseQuaternion { 1987 private: 1988 JNIEnv * jenv; 1989 const char * poolName; 1990 jobject obj; 1991 public: 1992 gdxPoolAutoReleaseQuaternion(JNIEnv * jenv, const char * poolName, jobject obj) : 1993 jenv(jenv), poolName(poolName), obj(obj) { }; 1994 virtual ~gdxPoolAutoReleaseQuaternion() { 1995 gdx_releasePoolObjectQuaternion(this->jenv, this->poolName, this->obj); 1996 }; 1997 }; 1998 1999 2000 2001 // Workaround for some strange swig behaviour 2002 2003 2004 /* Gets a global ref to the temp class's Return Quaternion. Do not release this. */ 2005 SWIGINTERN inline jobject gdx_getReturnQuaternion(JNIEnv * jenv) { 2006 static jobject ret = NULL; 2007 if (ret == NULL) { 2008 jclass tempClass = gdx_getTempClassQuaternion(jenv); 2009 jfieldID field = jenv->GetStaticFieldID(tempClass, "staticQuaternion", "Lcom/badlogic/gdx/math/Quaternion;"); 2010 ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); 2011 } 2012 return ret; 2013 } 2014 2015 /* Sets the data in the Bullet type from the Gdx type. */ 2016 SWIGINTERN inline void gdx_setbtQuaternionFromQuaternion(JNIEnv * jenv, btQuaternion & target, jobject source) { 2017 Quaternion_to_btQuaternion(jenv, target, source); 2018 } 2019 2020 SWIGINTERN inline void gdx_setbtQuaternionFromQuaternion(JNIEnv * jenv, btQuaternion * target, jobject source) { 2021 gdx_setbtQuaternionFromQuaternion(jenv, *target, source); 2022 } 2023 2024 /* Sets the data in the Gdx type from the Bullet type. */ 2025 SWIGINTERN inline void gdx_setQuaternionFrombtQuaternion(JNIEnv * jenv, jobject target, const btQuaternion & source) { 2026 btQuaternion_to_Quaternion(jenv, target, source); 2027 } 2028 2029 SWIGINTERN inline void gdx_setQuaternionFrombtQuaternion(JNIEnv * jenv, jobject target, const btQuaternion * source) { 2030 gdx_setQuaternionFrombtQuaternion(jenv, target, *source); 2031 } 2032 2033 /* 2034 * RAII wrapper to commit changes made to a local btQuaternion back to Quaternion 2035 */ 2036 class gdxAutoCommitQuaternion { 2037 private: 2038 JNIEnv * jenv; 2039 jobject jQuaternion; 2040 btQuaternion & cbtQuaternion; 2041 public: 2042 gdxAutoCommitQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion & cbtQuaternion) : 2043 jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(cbtQuaternion) { }; 2044 gdxAutoCommitQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion * cbtQuaternion) : 2045 jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(*cbtQuaternion) { }; 2046 virtual ~gdxAutoCommitQuaternion() { 2047 gdx_setQuaternionFrombtQuaternion(this->jenv, this->jQuaternion, this->cbtQuaternion); 2048 }; 2049 }; 2050 2051 class gdxAutoCommitbtQuaternionAndReleaseQuaternion { 2052 private: 2053 JNIEnv * jenv; 2054 jobject jQuaternion; 2055 btQuaternion & cbtQuaternion; 2056 const char * poolName; 2057 public: 2058 gdxAutoCommitbtQuaternionAndReleaseQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion & cbtQuaternion, const char *poolName) : 2059 jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(cbtQuaternion), poolName(poolName) { }; 2060 gdxAutoCommitbtQuaternionAndReleaseQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion * cbtQuaternion, const char *poolName) : 2061 jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(*cbtQuaternion), poolName(poolName) { }; 2062 virtual ~gdxAutoCommitbtQuaternionAndReleaseQuaternion() { 2063 gdx_setbtQuaternionFromQuaternion(this->jenv, this->cbtQuaternion, this->jQuaternion); 2064 gdx_releasePoolObjectQuaternion(this->jenv, this->poolName, this->jQuaternion); 2065 }; 2066 }; 2067 2068 2069 #include <BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h> 2070 2071 2072 #include <BulletCollision/CollisionDispatch/btCollisionConfiguration.h> 2073 2074 2075 #include <BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h> 2076 2077 2078 #include <BulletCollision/CollisionDispatch/btManifoldResult.h> 2079 2080 2081 #include <BulletCollision/CollisionDispatch/btHashedSimplePairCache.h> 2082 2083 2084 #include <BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h> 2085 2086 2087 #include <BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h> 2088 2089 2090 #include <BulletCollision/CollisionDispatch/btCollisionCreateFunc.h> 2091 2092 2093 #include <BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h> 2094 2095 2096 #include <BulletCollision/CollisionDispatch/btUnionFind.h> 2097 2098 2099 #include <BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h> 2100 2101 2102 #include <BulletCollision/CollisionDispatch/btSimulationIslandManager.h> 2103 2104 2105 #include <BulletCollision/CollisionDispatch/btGhostObject.h> 2106 2107 2108 #include <BulletCollision/CollisionDispatch/btCollisionWorld.h> 2109 2110 SWIGINTERN void btCollisionWorld_ClosestRayResultCallback_getRayFromWorld(btCollisionWorld::ClosestRayResultCallback *self,btVector3 &out){ 2111 out = self->m_rayFromWorld; 2112 } 2113 SWIGINTERN void btCollisionWorld_ClosestRayResultCallback_setRayFromWorld(btCollisionWorld::ClosestRayResultCallback *self,btVector3 const &value){ 2114 self->m_rayFromWorld = value; 2115 } 2116 SWIGINTERN void btCollisionWorld_ClosestRayResultCallback_getRayToWorld(btCollisionWorld::ClosestRayResultCallback *self,btVector3 &out){ 2117 out = self->m_rayToWorld; 2118 } 2119 SWIGINTERN void btCollisionWorld_ClosestRayResultCallback_setRayToWorld(btCollisionWorld::ClosestRayResultCallback *self,btVector3 const &value){ 2120 self->m_rayToWorld = value; 2121 } 2122 SWIGINTERN void btCollisionWorld_ClosestRayResultCallback_getHitNormalWorld(btCollisionWorld::ClosestRayResultCallback *self,btVector3 &out){ 2123 out = self->m_hitNormalWorld; 2124 } 2125 SWIGINTERN void btCollisionWorld_ClosestRayResultCallback_setHitNormalWorld(btCollisionWorld::ClosestRayResultCallback *self,btVector3 const &value){ 2126 self->m_hitNormalWorld = value; 2127 } 2128 SWIGINTERN void btCollisionWorld_ClosestRayResultCallback_getHitPointWorld(btCollisionWorld::ClosestRayResultCallback *self,btVector3 &out){ 2129 out = self->m_hitPointWorld; 2130 } 2131 SWIGINTERN void btCollisionWorld_ClosestRayResultCallback_setHitPointWorld(btCollisionWorld::ClosestRayResultCallback *self,btVector3 const &value){ 2132 self->m_hitPointWorld = value; 2133 } 2134 SWIGINTERN void btCollisionWorld_AllHitsRayResultCallback_getRayFromWorld(btCollisionWorld::AllHitsRayResultCallback *self,btVector3 &out){ 2135 out = self->m_rayFromWorld; 2136 } 2137 SWIGINTERN void btCollisionWorld_AllHitsRayResultCallback_setRayFromWorld(btCollisionWorld::AllHitsRayResultCallback *self,btVector3 const &value){ 2138 self->m_rayFromWorld = value; 2139 } 2140 SWIGINTERN void btCollisionWorld_AllHitsRayResultCallback_getRayToWorld(btCollisionWorld::AllHitsRayResultCallback *self,btVector3 &out){ 2141 out = self->m_rayToWorld; 2142 } 2143 SWIGINTERN void btCollisionWorld_AllHitsRayResultCallback_setRayToWorld(btCollisionWorld::AllHitsRayResultCallback *self,btVector3 const &value){ 2144 self->m_rayToWorld = value; 2145 } 2146 SWIGINTERN void btCollisionWorld_LocalConvexResult_getHitNormalLocal(btCollisionWorld::LocalConvexResult *self,btVector3 &out){ 2147 out = self->m_hitNormalLocal; 2148 } 2149 SWIGINTERN void btCollisionWorld_LocalConvexResult_setHitNormalLocal(btCollisionWorld::LocalConvexResult *self,btVector3 const &value){ 2150 self->m_hitNormalLocal = value; 2151 } 2152 SWIGINTERN void btCollisionWorld_LocalConvexResult_getHitPointLocal(btCollisionWorld::LocalConvexResult *self,btVector3 &out){ 2153 out = self->m_hitPointLocal; 2154 } 2155 SWIGINTERN void btCollisionWorld_LocalConvexResult_setHitPointLocal(btCollisionWorld::LocalConvexResult *self,btVector3 const &value){ 2156 self->m_hitPointLocal = value; 2157 } 2158 SWIGINTERN void btCollisionWorld_ClosestConvexResultCallback_getConvexFromWorld(btCollisionWorld::ClosestConvexResultCallback *self,btVector3 &out){ 2159 out = self->m_convexFromWorld; 2160 } 2161 SWIGINTERN void btCollisionWorld_ClosestConvexResultCallback_setRayFromWorld(btCollisionWorld::ClosestConvexResultCallback *self,btVector3 const &value){ 2162 self->m_convexFromWorld = value; 2163 } 2164 SWIGINTERN void btCollisionWorld_ClosestConvexResultCallback_getConvexToWorld(btCollisionWorld::ClosestConvexResultCallback *self,btVector3 &out){ 2165 out = self->m_convexToWorld; 2166 } 2167 SWIGINTERN void btCollisionWorld_ClosestConvexResultCallback_setConvexToWorld(btCollisionWorld::ClosestConvexResultCallback *self,btVector3 const &value){ 2168 self->m_convexToWorld = value; 2169 } 2170 SWIGINTERN void btCollisionWorld_ClosestConvexResultCallback_getHitNormalWorld(btCollisionWorld::ClosestConvexResultCallback *self,btVector3 &out){ 2171 out = self->m_hitNormalWorld; 2172 } 2173 SWIGINTERN void btCollisionWorld_ClosestConvexResultCallback_setHitNormalWorld(btCollisionWorld::ClosestConvexResultCallback *self,btVector3 const &value){ 2174 self->m_hitNormalWorld = value; 2175 } 2176 SWIGINTERN void btCollisionWorld_ClosestConvexResultCallback_getHitPointWorld(btCollisionWorld::ClosestConvexResultCallback *self,btVector3 &out){ 2177 out = self->m_hitPointWorld; 2178 } 2179 SWIGINTERN void btCollisionWorld_ClosestConvexResultCallback_setHitPointWorld(btCollisionWorld::ClosestConvexResultCallback *self,btVector3 const &value){ 2180 self->m_hitPointWorld = value; 2181 } 2182 2183 #include <gdx/collision/ClosestNotMeConvexResultCallback.h> 2184 2185 2186 #include <gdx/collision/ClosestNotMeRayResultCallback.h> 2187 2188 2189 #include <BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h> 2190 2191 2192 #include <BulletCollision/CollisionDispatch/btBoxBoxDetector.h> 2193 2194 2195 #include <BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h> 2196 2197 2198 #include <BulletCollision/CollisionDispatch/btCollisionDispatcher.h> 2199 2200 2201 #include <BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h> 2202 2203 2204 #include <BulletCollision/CollisionDispatch/SphereTriangleDetector.h> 2205 2206 2207 #include <BulletCollision/CollisionDispatch/btInternalEdgeUtility.h> 2208 2209 2210 #include <BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h> 2211 2212 2213 #include <BulletCollision/NarrowPhaseCollision/btConvexCast.h> 2214 2215 2216 #include <BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h> 2217 2218 2219 #include <BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h> 2220 2221 2222 #include <BulletCollision/NarrowPhaseCollision/btPersistentManifold.h> 2223 2224 2225 #include <BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h> 2226 2227 2228 #include <BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h> 2229 2230 2231 #include <BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h> 2232 2233 2234 #include <BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h> 2235 2236 2237 #include <BulletCollision/NarrowPhaseCollision/btManifoldPoint.h> 2238 2239 SWIGINTERN int btManifoldPoint_getUserValue(btManifoldPoint *self){ 2240 int result; 2241 *(const void **)&result = self->m_userPersistentData; 2242 return result; 2243 } 2244 SWIGINTERN void btManifoldPoint_setUserValue(btManifoldPoint *self,int value){ 2245 self->m_userPersistentData = (void*)value; 2246 } 2247 SWIGINTERN void btManifoldPoint_getLocalPointA(btManifoldPoint *self,btVector3 &out){ 2248 out = self->m_localPointA; 2249 } 2250 SWIGINTERN void btManifoldPoint_setLocalPointA(btManifoldPoint *self,btVector3 const &value){ 2251 self->m_localPointA = value; 2252 } 2253 SWIGINTERN void btManifoldPoint_getLocalPointB(btManifoldPoint *self,btVector3 &out){ 2254 out = self->m_localPointB; 2255 } 2256 SWIGINTERN void btManifoldPoint_setLocalPointB(btManifoldPoint *self,btVector3 const &value){ 2257 self->m_localPointB = value; 2258 } 2259 SWIGINTERN void btManifoldPoint_getPositionWorldOnA(btManifoldPoint *self,btVector3 &out){ 2260 out = self->m_positionWorldOnA; 2261 } 2262 SWIGINTERN void btManifoldPoint_setPositionWorldOnA(btManifoldPoint *self,btVector3 const &value){ 2263 self->m_positionWorldOnA = value; 2264 } 2265 SWIGINTERN void btManifoldPoint_getPositionWorldOnB(btManifoldPoint *self,btVector3 &out){ 2266 out = self->m_positionWorldOnB; 2267 } 2268 SWIGINTERN void btManifoldPoint_setPositionWorldOnB(btManifoldPoint *self,btVector3 const &value){ 2269 self->m_positionWorldOnB = value; 2270 } 2271 SWIGINTERN void btManifoldPoint_getNormalWorldOnB(btManifoldPoint *self,btVector3 &out){ 2272 out = self->m_normalWorldOnB; 2273 } 2274 SWIGINTERN void btManifoldPoint_setNormalWorldOnB(btManifoldPoint *self,btVector3 const &value){ 2275 self->m_normalWorldOnB = value; 2276 } 2277 SWIGINTERN void btManifoldPoint_getLateralFrictionDir1(btManifoldPoint *self,btVector3 &out){ 2278 out = self->m_lateralFrictionDir1; 2279 } 2280 SWIGINTERN void btManifoldPoint_setLateralFrictionDir1(btManifoldPoint *self,btVector3 const &value){ 2281 self->m_lateralFrictionDir1 = value; 2282 } 2283 SWIGINTERN void btManifoldPoint_getLateralFrictionDir2(btManifoldPoint *self,btVector3 &out){ 2284 out = self->m_lateralFrictionDir2; 2285 } 2286 SWIGINTERN void btManifoldPoint_setLateralFrictionDir2(btManifoldPoint *self,btVector3 const &value){ 2287 self->m_lateralFrictionDir2 = value; 2288 } 2289 2290 #include <BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h> 2291 2292 2293 #include <BulletCollision/NarrowPhaseCollision/btRaycastCallback.h> 2294 2295 2296 #include <BulletCollision/NarrowPhaseCollision/btGjkEpa2.h> 2297 2298 2299 #include <BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h> 2300 2301 2302 #include <BulletCollision/NarrowPhaseCollision/btPointCollector.h> 2303 2304 2305 #include <BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h> 2306 2307 2308 #include <BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h> 2309 2310 2311 #include <BulletCollision/CollisionShapes/btMultiSphereShape.h> 2312 2313 2314 btVector3* Vector3ArrayToBtVector3Array(JNIEnv * jenv, jobjectArray source) { 2315 static jfieldID xField = NULL, yField = NULL, zField = NULL; 2316 jint len = jenv->GetArrayLength(source); 2317 if (len <= 0) 2318 return NULL; 2319 2320 btVector3* result = new btVector3[len]; 2321 2322 if (xField == NULL) { 2323 jobject vec = jenv->GetObjectArrayElement(source, 0); 2324 jclass sc = jenv->GetObjectClass(vec); 2325 xField = jenv->GetFieldID(sc, "x", "F"); 2326 yField = jenv->GetFieldID(sc, "y", "F"); 2327 zField = jenv->GetFieldID(sc, "z", "F"); 2328 jenv->DeleteLocalRef(sc); 2329 } 2330 2331 for (int i = 0; i < len; i++) { 2332 jobject vec = jenv->GetObjectArrayElement(source, i); 2333 result[i].setValue(jenv->GetFloatField(vec, xField), jenv->GetFloatField(vec, yField), jenv->GetFloatField(vec, zField)); 2334 } 2335 return result; 2336 } 2337 2338 class gdxAutoDeleteBtVector3Array { 2339 private: 2340 btVector3* array; 2341 public: 2342 gdxAutoDeleteBtVector3Array(btVector3* arr) : 2343 array(arr) { } 2344 virtual ~gdxAutoDeleteBtVector3Array() { 2345 if (array != NULL) 2346 delete[] array; 2347 } 2348 }; 2349 2350 2351 #include <gdx/collision/CustomCollisionDispatcher.h> 2352 2353 2354 #include <gdx/collision/ContactListener.h> 2355 bool custom_ContactListener_setEvents(ContactListener *listener); 2356 2357 SWIGINTERN bool ContactListener_setEvents(ContactListener *self){ 2358 return custom_ContactListener_setEvents(self); 2359 } 2360 2361 #include <gdx/collision/ContactCache.h> 2362 2363 /*SWIG_JavaArrayArgout##Bool(jenv, jarr$argnum, (bool *)$1, $input);*/ 2364 /*SWIG_JavaArrayArgout##Schar(jenv, jarr$argnum, (signed char *)$1, $input);*/ 2365 /*SWIG_JavaArrayArgout##Uchar(jenv, jarr$argnum, (unsigned char *)$1, $input);*/ 2366 /*SWIG_JavaArrayArgout##Short(jenv, jarr$argnum, (short *)$1, $input);*/ 2367 /*SWIG_JavaArrayArgout##Ushort(jenv, jarr$argnum, (unsigned short *)$1, $input);*/ 2368 /*SWIG_JavaArrayArgout##Int(jenv, jarr$argnum, (int *)$1, $input);*/ 2369 /*SWIG_JavaArrayArgout##Uint(jenv, jarr$argnum, (unsigned int *)$1, $input);*/ 2370 /*SWIG_JavaArrayArgout##Long(jenv, jarr$argnum, (long *)$1, $input);*/ 2371 /*SWIG_JavaArrayArgout##Ulong(jenv, jarr$argnum, (unsigned long *)$1, $input);*/ 2372 /*SWIG_JavaArrayArgout##Longlong(jenv, jarr$argnum, (long long *)$1, $input);*/ 2373 /*SWIG_JavaArrayArgout##Float(jenv, jarr$argnum, (float *)$1, $input);*/ 2374 /*SWIG_JavaArrayArgout##Double(jenv, jarr$argnum, (double *)$1, $input);*/ 2375 SWIGINTERN btBroadphasePair *btAlignedObjectArray_Sl_btBroadphasePair_Sg__at(btAlignedObjectArray< btBroadphasePair > *self,int n){ 2376 return &(self->at(n)); 2377 } 2378 SWIGINTERN int btAlignedObjectArray_Sl_btBroadphasePair_Sg__getCollisionObjects(btAlignedObjectArray< btBroadphasePair > *self,int result[],int max,int other){ 2379 static btManifoldArray marr; 2380 const int n = self->size(); 2381 int count = 0; 2382 int obj0, obj1; 2383 for (int i = 0; i < n; i++) { 2384 const btBroadphasePair& collisionPair = (*self)[i]; 2385 if (collisionPair.m_algorithm) { 2386 marr.resize(0); 2387 collisionPair.m_algorithm->getAllContactManifolds(marr); 2388 const int s = marr.size(); 2389 for (int j = 0; j < s; j++) { 2390 btPersistentManifold *manifold = marr[j]; 2391 if (manifold->getNumContacts() > 0) { 2392 *(const btCollisionObject **)&obj0 = manifold->getBody0(); 2393 *(const btCollisionObject **)&obj1 = manifold->getBody1(); 2394 if (obj0 == other) 2395 result[count++] = obj1; 2396 else if (obj1 == other) 2397 result[count++] = obj0; 2398 else continue; 2399 if (count >= max) 2400 return count; 2401 } 2402 } 2403 } 2404 } 2405 return count; 2406 } 2407 SWIGINTERN int btAlignedObjectArray_Sl_btBroadphasePair_Sg__getCollisionObjectsValue(btAlignedObjectArray< btBroadphasePair > *self,int result[],int max,int other){ 2408 static btManifoldArray marr; 2409 const int n = self->size(); 2410 int count = 0; 2411 int obj0, obj1; 2412 for (int i = 0; i < n; i++) { 2413 const btBroadphasePair& collisionPair = (*self)[i]; 2414 if (collisionPair.m_algorithm) { 2415 marr.resize(0); 2416 collisionPair.m_algorithm->getAllContactManifolds(marr); 2417 const int s = marr.size(); 2418 for (int j = 0; j < s; j++) { 2419 btPersistentManifold *manifold = marr[j]; 2420 if (manifold->getNumContacts() > 0) { 2421 *(const btCollisionObject **)&obj0 = manifold->getBody0(); 2422 *(const btCollisionObject **)&obj1 = manifold->getBody1(); 2423 if (obj0 == other) 2424 result[count++] = ((GdxCollisionObjectBridge*)manifold->getBody1()->getUserPointer())->userValue; 2425 else if (obj1 == other) 2426 result[count++] = ((GdxCollisionObjectBridge*)manifold->getBody0()->getUserPointer())->userValue; 2427 else continue; 2428 if (count >= max) 2429 return count; 2430 } 2431 } 2432 } 2433 } 2434 return count; 2435 } 2436 2437 #include <BulletCollision/Gimpact/btQuantization.h> 2438 2439 2440 #include <BulletCollision/Gimpact/btBoxCollision.h> 2441 2442 2443 2444 /* Gets a global ref to the temp class. Do not release this. */ 2445 SWIGINTERN inline jclass gdx_getTempClassMatrix3(JNIEnv * jenv) { 2446 static jclass cls = NULL; 2447 if (cls == NULL) { 2448 cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); 2449 } 2450 return cls; 2451 } 2452 2453 SWIGINTERN inline jobject gdx_takePoolObjectMatrix3(JNIEnv * jenv, const char * poolName) { 2454 jclass tempClass = gdx_getTempClassMatrix3(jenv); 2455 2456 static jfieldID poolField = NULL; 2457 if (poolField == NULL) { 2458 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 2459 } 2460 2461 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 2462 jclass poolClass = jenv->GetObjectClass(poolObject); 2463 2464 static jmethodID obtainMethod = NULL; 2465 if (obtainMethod == NULL) { 2466 obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); 2467 } 2468 2469 jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); 2470 2471 jenv->DeleteLocalRef(poolObject); 2472 jenv->DeleteLocalRef(poolClass); 2473 2474 return ret; 2475 } 2476 2477 SWIGINTERN inline void gdx_releasePoolObjectMatrix3(JNIEnv * jenv, const char * poolName, jobject obj) { 2478 jclass tempClass = gdx_getTempClassMatrix3(jenv); 2479 2480 static jfieldID poolField = NULL; 2481 if (poolField == NULL) { 2482 poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); 2483 } 2484 2485 jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); 2486 jclass poolClass = jenv->GetObjectClass(poolObject); 2487 2488 static jmethodID freeMethod = NULL; 2489 if (freeMethod == NULL) { 2490 freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); 2491 } 2492 2493 jenv->CallVoidMethod(poolObject, freeMethod, obj); 2494 2495 jenv->DeleteLocalRef(poolObject); 2496 jenv->DeleteLocalRef(poolClass); 2497 jenv->DeleteLocalRef(obj); 2498 } 2499 2500 /* 2501 * A simple RAII wrapper to release jobjects we obtain from pools in 2502 * directorin typemaps. SWIG doesn't have hooks to release them after 2503 * they're used. 2504 */ 2505 class gdxPoolAutoReleaseMatrix3 { 2506 private: 2507 JNIEnv * jenv; 2508 const char * poolName; 2509 jobject obj; 2510 public: 2511 gdxPoolAutoReleaseMatrix3(JNIEnv * jenv, const char * poolName, jobject obj) : 2512 jenv(jenv), poolName(poolName), obj(obj) { }; 2513 virtual ~gdxPoolAutoReleaseMatrix3() { 2514 gdx_releasePoolObjectMatrix3(this->jenv, this->poolName, this->obj); 2515 }; 2516 }; 2517 2518 2519 2520 // Workaround for some strange swig behaviour 2521 2522 2523 /* Gets a global ref to the temp class's Return Matrix3. Do not release this. */ 2524 SWIGINTERN inline jobject gdx_getReturnMatrix3(JNIEnv * jenv) { 2525 static jobject ret = NULL; 2526 if (ret == NULL) { 2527 jclass tempClass = gdx_getTempClassMatrix3(jenv); 2528 jfieldID field = jenv->GetStaticFieldID(tempClass, "staticMatrix3", "Lcom/badlogic/gdx/math/Matrix3;"); 2529 ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); 2530 } 2531 return ret; 2532 } 2533 2534 /* Sets the data in the Bullet type from the Gdx type. */ 2535 SWIGINTERN inline void gdx_setbtMatrix3x3FromMatrix3(JNIEnv * jenv, btMatrix3x3 & target, jobject source) { 2536 Matrix3_to_btMatrix3(jenv, target, source); 2537 } 2538 2539 SWIGINTERN inline void gdx_setbtMatrix3x3FromMatrix3(JNIEnv * jenv, btMatrix3x3 * target, jobject source) { 2540 gdx_setbtMatrix3x3FromMatrix3(jenv, *target, source); 2541 } 2542 2543 /* Sets the data in the Gdx type from the Bullet type. */ 2544 SWIGINTERN inline void gdx_setMatrix3FrombtMatrix3x3(JNIEnv * jenv, jobject target, const btMatrix3x3 & source) { 2545 btMatrix3_to_Matrix3(jenv, target, source); 2546 } 2547 2548 SWIGINTERN inline void gdx_setMatrix3FrombtMatrix3x3(JNIEnv * jenv, jobject target, const btMatrix3x3 * source) { 2549 gdx_setMatrix3FrombtMatrix3x3(jenv, target, *source); 2550 } 2551 2552 /* 2553 * RAII wrapper to commit changes made to a local btMatrix3x3 back to Matrix3 2554 */ 2555 class gdxAutoCommitMatrix3 { 2556 private: 2557 JNIEnv * jenv; 2558 jobject jMatrix3; 2559 btMatrix3x3 & cbtMatrix3x3; 2560 public: 2561 gdxAutoCommitMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 & cbtMatrix3x3) : 2562 jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(cbtMatrix3x3) { }; 2563 gdxAutoCommitMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 * cbtMatrix3x3) : 2564 jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(*cbtMatrix3x3) { }; 2565 virtual ~gdxAutoCommitMatrix3() { 2566 gdx_setMatrix3FrombtMatrix3x3(this->jenv, this->jMatrix3, this->cbtMatrix3x3); 2567 }; 2568 }; 2569 2570 class gdxAutoCommitbtMatrix3x3AndReleaseMatrix3 { 2571 private: 2572 JNIEnv * jenv; 2573 jobject jMatrix3; 2574 btMatrix3x3 & cbtMatrix3x3; 2575 const char * poolName; 2576 public: 2577 gdxAutoCommitbtMatrix3x3AndReleaseMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 & cbtMatrix3x3, const char *poolName) : 2578 jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(cbtMatrix3x3), poolName(poolName) { }; 2579 gdxAutoCommitbtMatrix3x3AndReleaseMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 * cbtMatrix3x3, const char *poolName) : 2580 jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(*cbtMatrix3x3), poolName(poolName) { }; 2581 virtual ~gdxAutoCommitbtMatrix3x3AndReleaseMatrix3() { 2582 gdx_setbtMatrix3x3FromMatrix3(this->jenv, this->cbtMatrix3x3, this->jMatrix3); 2583 gdx_releasePoolObjectMatrix3(this->jenv, this->poolName, this->jMatrix3); 2584 }; 2585 }; 2586 2587 2588 #include <BulletCollision/Gimpact/btClipPolygon.h> 2589 2590 2591 #include <BulletCollision/Gimpact/btGeometryOperations.h> 2592 2593 2594 #include <BulletCollision/Gimpact/btTriangleShapeEx.h> 2595 2596 2597 #include <BulletCollision/Gimpact/btGImpactBvh.h> 2598 2599 2600 #include <BulletCollision/Gimpact/btGImpactQuantizedBvh.h> 2601 2602 2603 #include <BulletCollision/Gimpact/btGImpactShape.h> 2604 2605 2606 #include <BulletCollision/Gimpact/btContactProcessing.h> 2607 2608 2609 #include <BulletCollision/Gimpact/btGenericPoolAllocator.h> 2610 2611 2612 #include <BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h> 2613 2614 2615 #include <BulletCollision/Gimpact/btGImpactMassUtil.h> 2616 2617 2618 #include <BulletCollision/Gimpact/btGImpactMassUtil.h> 2619 2620 2621 2622 /* --------------------------------------------------- 2623 * C++ director class methods 2624 * --------------------------------------------------- */ 2625 2626 #include "collision_wrap.h" 2627 2628 SwigDirector_btBroadphaseAabbCallback::SwigDirector_btBroadphaseAabbCallback(JNIEnv *jenv) : btBroadphaseAabbCallback(), Swig::Director(jenv) { 2629 } 2630 2631 SwigDirector_btBroadphaseAabbCallback::~SwigDirector_btBroadphaseAabbCallback() { 2632 swig_disconnect_director_self("swigDirectorDisconnect"); 2633 } 2634 2635 2636 bool SwigDirector_btBroadphaseAabbCallback::process(btBroadphaseProxy const *proxy) { 2637 bool c_result = SwigValueInit< bool >() ; 2638 jboolean jresult = 0 ; 2639 JNIEnvWrapper swigjnienv(this) ; 2640 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2641 jobject swigjobj = (jobject) NULL ; 2642 jlong jproxy = 0 ; 2643 2644 if (!swig_override[0]) { 2645 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btBroadphaseAabbCallback::process."); 2646 return c_result; 2647 } 2648 swigjobj = swig_get_self(jenv); 2649 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2650 *((btBroadphaseProxy **)&jproxy) = (btBroadphaseProxy *) proxy; 2651 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[0], swigjobj, jproxy); 2652 jthrowable swigerror = jenv->ExceptionOccurred(); 2653 if (swigerror) { 2654 jenv->ExceptionClear(); 2655 throw Swig::DirectorException(jenv, swigerror); 2656 } 2657 2658 c_result = jresult ? true : false; 2659 } else { 2660 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btBroadphaseAabbCallback::process "); 2661 } 2662 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2663 return c_result; 2664 } 2665 2666 void SwigDirector_btBroadphaseAabbCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 2667 static struct { 2668 const char *mname; 2669 const char *mdesc; 2670 jmethodID base_methid; 2671 } methods[] = { 2672 { 2673 "process", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Z", NULL 2674 } 2675 }; 2676 2677 static jclass baseclass = 0 ; 2678 2679 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 2680 if (!baseclass) { 2681 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btBroadphaseAabbCallback"); 2682 if (!baseclass) return; 2683 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 2684 } 2685 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 2686 for (int i = 0; i < 1; ++i) { 2687 if (!methods[i].base_methid) { 2688 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 2689 if (!methods[i].base_methid) return; 2690 } 2691 swig_override[i] = false; 2692 if (derived) { 2693 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 2694 swig_override[i] = (methid != methods[i].base_methid); 2695 jenv->ExceptionClear(); 2696 } 2697 } 2698 } 2699 } 2700 2701 2702 SwigDirector_btBroadphaseRayCallback::SwigDirector_btBroadphaseRayCallback(JNIEnv *jenv) : btBroadphaseRayCallback(), Swig::Director(jenv) { 2703 } 2704 2705 SwigDirector_btBroadphaseRayCallback::~SwigDirector_btBroadphaseRayCallback() { 2706 swig_disconnect_director_self("swigDirectorDisconnect"); 2707 } 2708 2709 2710 bool SwigDirector_btBroadphaseRayCallback::process(btBroadphaseProxy const *proxy) { 2711 bool c_result = SwigValueInit< bool >() ; 2712 jboolean jresult = 0 ; 2713 JNIEnvWrapper swigjnienv(this) ; 2714 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2715 jobject swigjobj = (jobject) NULL ; 2716 jlong jproxy = 0 ; 2717 2718 if (!swig_override[0]) { 2719 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btBroadphaseRayCallback::process."); 2720 return c_result; 2721 } 2722 swigjobj = swig_get_self(jenv); 2723 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2724 *((btBroadphaseProxy **)&jproxy) = (btBroadphaseProxy *) proxy; 2725 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[1], swigjobj, jproxy); 2726 jthrowable swigerror = jenv->ExceptionOccurred(); 2727 if (swigerror) { 2728 jenv->ExceptionClear(); 2729 throw Swig::DirectorException(jenv, swigerror); 2730 } 2731 2732 c_result = jresult ? true : false; 2733 } else { 2734 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btBroadphaseRayCallback::process "); 2735 } 2736 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2737 return c_result; 2738 } 2739 2740 void SwigDirector_btBroadphaseRayCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 2741 static struct { 2742 const char *mname; 2743 const char *mdesc; 2744 jmethodID base_methid; 2745 } methods[] = { 2746 { 2747 "process", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Z", NULL 2748 } 2749 }; 2750 2751 static jclass baseclass = 0 ; 2752 2753 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 2754 if (!baseclass) { 2755 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btBroadphaseRayCallback"); 2756 if (!baseclass) return; 2757 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 2758 } 2759 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 2760 for (int i = 0; i < 1; ++i) { 2761 if (!methods[i].base_methid) { 2762 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 2763 if (!methods[i].base_methid) return; 2764 } 2765 swig_override[i] = false; 2766 if (derived) { 2767 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 2768 swig_override[i] = (methid != methods[i].base_methid); 2769 jenv->ExceptionClear(); 2770 } 2771 } 2772 } 2773 } 2774 2775 2776 SwigDirector_btNodeOverlapCallback::SwigDirector_btNodeOverlapCallback(JNIEnv *jenv) : btNodeOverlapCallback(), Swig::Director(jenv) { 2777 } 2778 2779 SwigDirector_btNodeOverlapCallback::~SwigDirector_btNodeOverlapCallback() { 2780 swig_disconnect_director_self("swigDirectorDisconnect"); 2781 } 2782 2783 2784 void SwigDirector_btNodeOverlapCallback::processNode(int subPart, int triangleIndex) { 2785 JNIEnvWrapper swigjnienv(this) ; 2786 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2787 jobject swigjobj = (jobject) NULL ; 2788 jint jsubPart ; 2789 jint jtriangleIndex ; 2790 2791 if (!swig_override[0]) { 2792 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btNodeOverlapCallback::processNode."); 2793 return; 2794 } 2795 swigjobj = swig_get_self(jenv); 2796 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2797 jsubPart = (jint) subPart; 2798 jtriangleIndex = (jint) triangleIndex; 2799 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[2], swigjobj, jsubPart, jtriangleIndex); 2800 jthrowable swigerror = jenv->ExceptionOccurred(); 2801 if (swigerror) { 2802 jenv->ExceptionClear(); 2803 throw Swig::DirectorException(jenv, swigerror); 2804 } 2805 2806 } else { 2807 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btNodeOverlapCallback::processNode "); 2808 } 2809 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2810 } 2811 2812 void SwigDirector_btNodeOverlapCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 2813 static struct { 2814 const char *mname; 2815 const char *mdesc; 2816 jmethodID base_methid; 2817 } methods[] = { 2818 { 2819 "processNode", "(II)V", NULL 2820 } 2821 }; 2822 2823 static jclass baseclass = 0 ; 2824 2825 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 2826 if (!baseclass) { 2827 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btNodeOverlapCallback"); 2828 if (!baseclass) return; 2829 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 2830 } 2831 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 2832 for (int i = 0; i < 1; ++i) { 2833 if (!methods[i].base_methid) { 2834 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 2835 if (!methods[i].base_methid) return; 2836 } 2837 swig_override[i] = false; 2838 if (derived) { 2839 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 2840 swig_override[i] = (methid != methods[i].base_methid); 2841 jenv->ExceptionClear(); 2842 } 2843 } 2844 } 2845 } 2846 2847 2848 SwigDirector_btOverlappingPairCallback::SwigDirector_btOverlappingPairCallback(JNIEnv *jenv) : btOverlappingPairCallback(), Swig::Director(jenv) { 2849 } 2850 2851 SwigDirector_btOverlappingPairCallback::~SwigDirector_btOverlappingPairCallback() { 2852 swig_disconnect_director_self("swigDirectorDisconnect"); 2853 } 2854 2855 2856 btBroadphasePair *SwigDirector_btOverlappingPairCallback::addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) { 2857 btBroadphasePair *c_result = 0 ; 2858 jlong jresult = 0 ; 2859 JNIEnvWrapper swigjnienv(this) ; 2860 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2861 jobject swigjobj = (jobject) NULL ; 2862 jlong jproxy0 = 0 ; 2863 jlong jproxy1 = 0 ; 2864 2865 if (!swig_override[0]) { 2866 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btOverlappingPairCallback::addOverlappingPair."); 2867 return c_result; 2868 } 2869 swigjobj = swig_get_self(jenv); 2870 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2871 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 2872 *((btBroadphaseProxy **)&jproxy1) = (btBroadphaseProxy *) proxy1; 2873 jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[3], swigjobj, jproxy0, jproxy1); 2874 jthrowable swigerror = jenv->ExceptionOccurred(); 2875 if (swigerror) { 2876 jenv->ExceptionClear(); 2877 throw Swig::DirectorException(jenv, swigerror); 2878 } 2879 2880 c_result = *(btBroadphasePair **)&jresult; 2881 } else { 2882 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btOverlappingPairCallback::addOverlappingPair "); 2883 } 2884 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2885 return c_result; 2886 } 2887 2888 void *SwigDirector_btOverlappingPairCallback::removeOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, btDispatcher *dispatcher) { 2889 void *c_result = 0 ; 2890 jlong jresult = 0 ; 2891 JNIEnvWrapper swigjnienv(this) ; 2892 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2893 jobject swigjobj = (jobject) NULL ; 2894 jlong jproxy0 = 0 ; 2895 jlong jproxy1 = 0 ; 2896 jlong jdispatcher = 0 ; 2897 2898 if (!swig_override[1]) { 2899 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btOverlappingPairCallback::removeOverlappingPair."); 2900 return c_result; 2901 } 2902 swigjobj = swig_get_self(jenv); 2903 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2904 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 2905 *((btBroadphaseProxy **)&jproxy1) = (btBroadphaseProxy *) proxy1; 2906 *((btDispatcher **)&jdispatcher) = (btDispatcher *) dispatcher; 2907 jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[4], swigjobj, jproxy0, jproxy1, jdispatcher); 2908 jthrowable swigerror = jenv->ExceptionOccurred(); 2909 if (swigerror) { 2910 jenv->ExceptionClear(); 2911 throw Swig::DirectorException(jenv, swigerror); 2912 } 2913 2914 c_result = (void *)jresult; 2915 } else { 2916 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btOverlappingPairCallback::removeOverlappingPair "); 2917 } 2918 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2919 return c_result; 2920 } 2921 2922 void SwigDirector_btOverlappingPairCallback::removeOverlappingPairsContainingProxy(btBroadphaseProxy *proxy0, btDispatcher *dispatcher) { 2923 JNIEnvWrapper swigjnienv(this) ; 2924 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 2925 jobject swigjobj = (jobject) NULL ; 2926 jlong jproxy0 = 0 ; 2927 jlong jdispatcher = 0 ; 2928 2929 if (!swig_override[2]) { 2930 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btOverlappingPairCallback::removeOverlappingPairsContainingProxy."); 2931 return; 2932 } 2933 swigjobj = swig_get_self(jenv); 2934 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 2935 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 2936 *((btDispatcher **)&jdispatcher) = (btDispatcher *) dispatcher; 2937 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[5], swigjobj, jproxy0, jdispatcher); 2938 jthrowable swigerror = jenv->ExceptionOccurred(); 2939 if (swigerror) { 2940 jenv->ExceptionClear(); 2941 throw Swig::DirectorException(jenv, swigerror); 2942 } 2943 2944 } else { 2945 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btOverlappingPairCallback::removeOverlappingPairsContainingProxy "); 2946 } 2947 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 2948 } 2949 2950 void SwigDirector_btOverlappingPairCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 2951 static struct { 2952 const char *mname; 2953 const char *mdesc; 2954 jmethodID base_methid; 2955 } methods[] = { 2956 { 2957 "addOverlappingPair", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Lcom/badlogic/gdx/physics/bullet/collision/btBroadphasePair;", NULL 2958 }, 2959 { 2960 "removeOverlappingPair", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;Lcom/badlogic/gdx/physics/bullet/collision/btDispatcher;)J", NULL 2961 }, 2962 { 2963 "removeOverlappingPairsContainingProxy", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;Lcom/badlogic/gdx/physics/bullet/collision/btDispatcher;)V", NULL 2964 } 2965 }; 2966 2967 static jclass baseclass = 0 ; 2968 2969 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 2970 if (!baseclass) { 2971 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btOverlappingPairCallback"); 2972 if (!baseclass) return; 2973 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 2974 } 2975 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 2976 for (int i = 0; i < 3; ++i) { 2977 if (!methods[i].base_methid) { 2978 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 2979 if (!methods[i].base_methid) return; 2980 } 2981 swig_override[i] = false; 2982 if (derived) { 2983 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 2984 swig_override[i] = (methid != methods[i].base_methid); 2985 jenv->ExceptionClear(); 2986 } 2987 } 2988 } 2989 } 2990 2991 2992 SwigDirector_btOverlapCallback::SwigDirector_btOverlapCallback(JNIEnv *jenv) : btOverlapCallback(), Swig::Director(jenv) { 2993 } 2994 2995 SwigDirector_btOverlapCallback::~SwigDirector_btOverlapCallback() { 2996 swig_disconnect_director_self("swigDirectorDisconnect"); 2997 } 2998 2999 3000 bool SwigDirector_btOverlapCallback::processOverlap(btBroadphasePair &pair) { 3001 bool c_result = SwigValueInit< bool >() ; 3002 jboolean jresult = 0 ; 3003 JNIEnvWrapper swigjnienv(this) ; 3004 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3005 jobject swigjobj = (jobject) NULL ; 3006 jobject jpair = 0 ; 3007 3008 if (!swig_override[0]) { 3009 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btOverlapCallback::processOverlap."); 3010 return c_result; 3011 } 3012 swigjobj = swig_get_self(jenv); 3013 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3014 jclass jcpair = gdx_getClassbtBroadphasePair(jenv); 3015 jpair = gdx_obtainbtBroadphasePair(jenv, jcpair, (void*)&pair, false); 3016 gdxAutoFreebtBroadphasePair autoRelease_jpair(jenv, jcpair, jpair); 3017 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[6], swigjobj, jpair); 3018 jthrowable swigerror = jenv->ExceptionOccurred(); 3019 if (swigerror) { 3020 jenv->ExceptionClear(); 3021 throw Swig::DirectorException(jenv, swigerror); 3022 } 3023 3024 c_result = jresult ? true : false; 3025 } else { 3026 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btOverlapCallback::processOverlap "); 3027 } 3028 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3029 return c_result; 3030 } 3031 3032 void SwigDirector_btOverlapCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3033 static struct { 3034 const char *mname; 3035 const char *mdesc; 3036 jmethodID base_methid; 3037 } methods[] = { 3038 { 3039 "processOverlap", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphasePair;)Z", NULL 3040 } 3041 }; 3042 3043 static jclass baseclass = 0 ; 3044 3045 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 3046 if (!baseclass) { 3047 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btOverlapCallback"); 3048 if (!baseclass) return; 3049 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 3050 } 3051 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 3052 for (int i = 0; i < 1; ++i) { 3053 if (!methods[i].base_methid) { 3054 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 3055 if (!methods[i].base_methid) return; 3056 } 3057 swig_override[i] = false; 3058 if (derived) { 3059 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 3060 swig_override[i] = (methid != methods[i].base_methid); 3061 jenv->ExceptionClear(); 3062 } 3063 } 3064 } 3065 } 3066 3067 3068 SwigDirector_btOverlapFilterCallback::SwigDirector_btOverlapFilterCallback(JNIEnv *jenv) : btOverlapFilterCallback(), Swig::Director(jenv) { 3069 } 3070 3071 SwigDirector_btOverlapFilterCallback::~SwigDirector_btOverlapFilterCallback() { 3072 swig_disconnect_director_self("swigDirectorDisconnect"); 3073 } 3074 3075 3076 bool SwigDirector_btOverlapFilterCallback::needBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const { 3077 bool c_result = SwigValueInit< bool >() ; 3078 jboolean jresult = 0 ; 3079 JNIEnvWrapper swigjnienv(this) ; 3080 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3081 jobject swigjobj = (jobject) NULL ; 3082 jlong jproxy0 = 0 ; 3083 jlong jproxy1 = 0 ; 3084 3085 if (!swig_override[0]) { 3086 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btOverlapFilterCallback::needBroadphaseCollision."); 3087 return c_result; 3088 } 3089 swigjobj = swig_get_self(jenv); 3090 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3091 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 3092 *((btBroadphaseProxy **)&jproxy1) = (btBroadphaseProxy *) proxy1; 3093 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[7], swigjobj, jproxy0, jproxy1); 3094 jthrowable swigerror = jenv->ExceptionOccurred(); 3095 if (swigerror) { 3096 jenv->ExceptionClear(); 3097 throw Swig::DirectorException(jenv, swigerror); 3098 } 3099 3100 c_result = jresult ? true : false; 3101 } else { 3102 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btOverlapFilterCallback::needBroadphaseCollision "); 3103 } 3104 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3105 return c_result; 3106 } 3107 3108 void SwigDirector_btOverlapFilterCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3109 static struct { 3110 const char *mname; 3111 const char *mdesc; 3112 jmethodID base_methid; 3113 } methods[] = { 3114 { 3115 "needBroadphaseCollision", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Z", NULL 3116 } 3117 }; 3118 3119 static jclass baseclass = 0 ; 3120 3121 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 3122 if (!baseclass) { 3123 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btOverlapFilterCallback"); 3124 if (!baseclass) return; 3125 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 3126 } 3127 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 3128 for (int i = 0; i < 1; ++i) { 3129 if (!methods[i].base_methid) { 3130 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 3131 if (!methods[i].base_methid) return; 3132 } 3133 swig_override[i] = false; 3134 if (derived) { 3135 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 3136 swig_override[i] = (methid != methods[i].base_methid); 3137 jenv->ExceptionClear(); 3138 } 3139 } 3140 } 3141 } 3142 3143 3144 SwigDirector_btTriangleCallback::SwigDirector_btTriangleCallback(JNIEnv *jenv) : btTriangleCallback(), Swig::Director(jenv) { 3145 } 3146 3147 SwigDirector_btTriangleCallback::~SwigDirector_btTriangleCallback() { 3148 swig_disconnect_director_self("swigDirectorDisconnect"); 3149 } 3150 3151 3152 void SwigDirector_btTriangleCallback::processTriangle(btVector3 *triangle, int partId, int triangleIndex) { 3153 JNIEnvWrapper swigjnienv(this) ; 3154 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3155 jobject swigjobj = (jobject) NULL ; 3156 jlong jtriangle = 0 ; 3157 jint jpartId ; 3158 jint jtriangleIndex ; 3159 3160 if (!swig_override[0]) { 3161 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btTriangleCallback::processTriangle."); 3162 return; 3163 } 3164 swigjobj = swig_get_self(jenv); 3165 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3166 *((btVector3 **)&jtriangle) = (btVector3 *) triangle; 3167 jpartId = (jint) partId; 3168 jtriangleIndex = (jint) triangleIndex; 3169 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[8], swigjobj, jtriangle, jpartId, jtriangleIndex); 3170 jthrowable swigerror = jenv->ExceptionOccurred(); 3171 if (swigerror) { 3172 jenv->ExceptionClear(); 3173 throw Swig::DirectorException(jenv, swigerror); 3174 } 3175 3176 } else { 3177 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btTriangleCallback::processTriangle "); 3178 } 3179 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3180 } 3181 3182 void SwigDirector_btTriangleCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3183 static struct { 3184 const char *mname; 3185 const char *mdesc; 3186 jmethodID base_methid; 3187 } methods[] = { 3188 { 3189 "processTriangle", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btVector3;II)V", NULL 3190 } 3191 }; 3192 3193 static jclass baseclass = 0 ; 3194 3195 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 3196 if (!baseclass) { 3197 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btTriangleCallback"); 3198 if (!baseclass) return; 3199 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 3200 } 3201 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 3202 for (int i = 0; i < 1; ++i) { 3203 if (!methods[i].base_methid) { 3204 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 3205 if (!methods[i].base_methid) return; 3206 } 3207 swig_override[i] = false; 3208 if (derived) { 3209 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 3210 swig_override[i] = (methid != methods[i].base_methid); 3211 jenv->ExceptionClear(); 3212 } 3213 } 3214 } 3215 } 3216 3217 3218 SwigDirector_btInternalTriangleIndexCallback::SwigDirector_btInternalTriangleIndexCallback(JNIEnv *jenv) : btInternalTriangleIndexCallback(), Swig::Director(jenv) { 3219 } 3220 3221 SwigDirector_btInternalTriangleIndexCallback::~SwigDirector_btInternalTriangleIndexCallback() { 3222 swig_disconnect_director_self("swigDirectorDisconnect"); 3223 } 3224 3225 3226 void SwigDirector_btInternalTriangleIndexCallback::internalProcessTriangleIndex(btVector3 *triangle, int partId, int triangleIndex) { 3227 JNIEnvWrapper swigjnienv(this) ; 3228 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3229 jobject swigjobj = (jobject) NULL ; 3230 jlong jtriangle = 0 ; 3231 jint jpartId ; 3232 jint jtriangleIndex ; 3233 3234 if (!swig_override[0]) { 3235 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btInternalTriangleIndexCallback::internalProcessTriangleIndex."); 3236 return; 3237 } 3238 swigjobj = swig_get_self(jenv); 3239 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3240 *((btVector3 **)&jtriangle) = (btVector3 *) triangle; 3241 jpartId = (jint) partId; 3242 jtriangleIndex = (jint) triangleIndex; 3243 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[9], swigjobj, jtriangle, jpartId, jtriangleIndex); 3244 jthrowable swigerror = jenv->ExceptionOccurred(); 3245 if (swigerror) { 3246 jenv->ExceptionClear(); 3247 throw Swig::DirectorException(jenv, swigerror); 3248 } 3249 3250 } else { 3251 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btInternalTriangleIndexCallback::internalProcessTriangleIndex "); 3252 } 3253 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3254 } 3255 3256 void SwigDirector_btInternalTriangleIndexCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3257 static struct { 3258 const char *mname; 3259 const char *mdesc; 3260 jmethodID base_methid; 3261 } methods[] = { 3262 { 3263 "internalProcessTriangleIndex", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btVector3;II)V", NULL 3264 } 3265 }; 3266 3267 static jclass baseclass = 0 ; 3268 3269 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 3270 if (!baseclass) { 3271 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btInternalTriangleIndexCallback"); 3272 if (!baseclass) return; 3273 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 3274 } 3275 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 3276 for (int i = 0; i < 1; ++i) { 3277 if (!methods[i].base_methid) { 3278 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 3279 if (!methods[i].base_methid) return; 3280 } 3281 swig_override[i] = false; 3282 if (derived) { 3283 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 3284 swig_override[i] = (methid != methods[i].base_methid); 3285 jenv->ExceptionClear(); 3286 } 3287 } 3288 } 3289 } 3290 3291 3292 SwigDirector_ICollide::SwigDirector_ICollide(JNIEnv *jenv) : btDbvt::ICollide(), Swig::Director(jenv) { 3293 } 3294 3295 SwigDirector_ICollide::~SwigDirector_ICollide() { 3296 swig_disconnect_director_self("swigDirectorDisconnect"); 3297 } 3298 3299 3300 void SwigDirector_ICollide::Process(btDbvtNode const *arg0, btDbvtNode const *arg1) { 3301 JNIEnvWrapper swigjnienv(this) ; 3302 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3303 jobject swigjobj = (jobject) NULL ; 3304 jlong jarg0 = 0 ; 3305 jlong jarg1 = 0 ; 3306 3307 if (!swig_override[0]) { 3308 btDbvt::ICollide::Process(arg0,arg1); 3309 return; 3310 } 3311 swigjobj = swig_get_self(jenv); 3312 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3313 *((btDbvtNode **)&jarg0) = (btDbvtNode *) arg0; 3314 *((btDbvtNode **)&jarg1) = (btDbvtNode *) arg1; 3315 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[10], swigjobj, jarg0, jarg1); 3316 jthrowable swigerror = jenv->ExceptionOccurred(); 3317 if (swigerror) { 3318 jenv->ExceptionClear(); 3319 throw Swig::DirectorException(jenv, swigerror); 3320 } 3321 3322 } else { 3323 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btDbvt::ICollide::Process "); 3324 } 3325 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3326 } 3327 3328 void SwigDirector_ICollide::Process(btDbvtNode const *arg0) { 3329 JNIEnvWrapper swigjnienv(this) ; 3330 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3331 jobject swigjobj = (jobject) NULL ; 3332 jlong jarg0 = 0 ; 3333 3334 if (!swig_override[1]) { 3335 btDbvt::ICollide::Process(arg0); 3336 return; 3337 } 3338 swigjobj = swig_get_self(jenv); 3339 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3340 *((btDbvtNode **)&jarg0) = (btDbvtNode *) arg0; 3341 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[11], swigjobj, jarg0); 3342 jthrowable swigerror = jenv->ExceptionOccurred(); 3343 if (swigerror) { 3344 jenv->ExceptionClear(); 3345 throw Swig::DirectorException(jenv, swigerror); 3346 } 3347 3348 } else { 3349 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btDbvt::ICollide::Process "); 3350 } 3351 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3352 } 3353 3354 void SwigDirector_ICollide::Process(btDbvtNode const *n, btScalar arg1) { 3355 JNIEnvWrapper swigjnienv(this) ; 3356 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3357 jobject swigjobj = (jobject) NULL ; 3358 jlong jn = 0 ; 3359 jfloat jarg1 ; 3360 3361 if (!swig_override[2]) { 3362 btDbvt::ICollide::Process(n,arg1); 3363 return; 3364 } 3365 swigjobj = swig_get_self(jenv); 3366 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3367 *((btDbvtNode **)&jn) = (btDbvtNode *) n; 3368 jarg1 = (jfloat) arg1; 3369 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[12], swigjobj, jn, jarg1); 3370 jthrowable swigerror = jenv->ExceptionOccurred(); 3371 if (swigerror) { 3372 jenv->ExceptionClear(); 3373 throw Swig::DirectorException(jenv, swigerror); 3374 } 3375 3376 } else { 3377 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btDbvt::ICollide::Process "); 3378 } 3379 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3380 } 3381 3382 bool SwigDirector_ICollide::Descent(btDbvtNode const *arg0) { 3383 bool c_result = SwigValueInit< bool >() ; 3384 jboolean jresult = 0 ; 3385 JNIEnvWrapper swigjnienv(this) ; 3386 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3387 jobject swigjobj = (jobject) NULL ; 3388 jlong jarg0 = 0 ; 3389 3390 if (!swig_override[3]) { 3391 return btDbvt::ICollide::Descent(arg0); 3392 } 3393 swigjobj = swig_get_self(jenv); 3394 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3395 *((btDbvtNode **)&jarg0) = (btDbvtNode *) arg0; 3396 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[13], swigjobj, jarg0); 3397 jthrowable swigerror = jenv->ExceptionOccurred(); 3398 if (swigerror) { 3399 jenv->ExceptionClear(); 3400 throw Swig::DirectorException(jenv, swigerror); 3401 } 3402 3403 c_result = jresult ? true : false; 3404 } else { 3405 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btDbvt::ICollide::Descent "); 3406 } 3407 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3408 return c_result; 3409 } 3410 3411 bool SwigDirector_ICollide::AllLeaves(btDbvtNode const *arg0) { 3412 bool c_result = SwigValueInit< bool >() ; 3413 jboolean jresult = 0 ; 3414 JNIEnvWrapper swigjnienv(this) ; 3415 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3416 jobject swigjobj = (jobject) NULL ; 3417 jlong jarg0 = 0 ; 3418 3419 if (!swig_override[4]) { 3420 return btDbvt::ICollide::AllLeaves(arg0); 3421 } 3422 swigjobj = swig_get_self(jenv); 3423 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3424 *((btDbvtNode **)&jarg0) = (btDbvtNode *) arg0; 3425 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[14], swigjobj, jarg0); 3426 jthrowable swigerror = jenv->ExceptionOccurred(); 3427 if (swigerror) { 3428 jenv->ExceptionClear(); 3429 throw Swig::DirectorException(jenv, swigerror); 3430 } 3431 3432 c_result = jresult ? true : false; 3433 } else { 3434 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btDbvt::ICollide::AllLeaves "); 3435 } 3436 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3437 return c_result; 3438 } 3439 3440 void SwigDirector_ICollide::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3441 static struct { 3442 const char *mname; 3443 const char *mdesc; 3444 jmethodID base_methid; 3445 } methods[] = { 3446 { 3447 "Process", "(Lcom/badlogic/gdx/physics/bullet/collision/btDbvtNode;Lcom/badlogic/gdx/physics/bullet/collision/btDbvtNode;)V", NULL 3448 }, 3449 { 3450 "Process", "(Lcom/badlogic/gdx/physics/bullet/collision/btDbvtNode;)V", NULL 3451 }, 3452 { 3453 "Process", "(Lcom/badlogic/gdx/physics/bullet/collision/btDbvtNode;F)V", NULL 3454 }, 3455 { 3456 "Descent", "(Lcom/badlogic/gdx/physics/bullet/collision/btDbvtNode;)Z", NULL 3457 }, 3458 { 3459 "AllLeaves", "(Lcom/badlogic/gdx/physics/bullet/collision/btDbvtNode;)Z", NULL 3460 } 3461 }; 3462 3463 static jclass baseclass = 0 ; 3464 3465 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 3466 if (!baseclass) { 3467 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/ICollide"); 3468 if (!baseclass) return; 3469 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 3470 } 3471 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 3472 for (int i = 0; i < 5; ++i) { 3473 if (!methods[i].base_methid) { 3474 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 3475 if (!methods[i].base_methid) return; 3476 } 3477 swig_override[i] = false; 3478 if (derived) { 3479 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 3480 swig_override[i] = (methid != methods[i].base_methid); 3481 jenv->ExceptionClear(); 3482 } 3483 } 3484 } 3485 } 3486 3487 3488 SwigDirector_btConvexTriangleCallback::SwigDirector_btConvexTriangleCallback(JNIEnv *jenv, btDispatcher *dispatcher, btCollisionObjectWrapper const *body0Wrap, btCollisionObjectWrapper const *body1Wrap, bool isSwapped) : btConvexTriangleCallback(dispatcher, body0Wrap, body1Wrap, isSwapped), Swig::Director(jenv) { 3489 } 3490 3491 SwigDirector_btConvexTriangleCallback::~SwigDirector_btConvexTriangleCallback() { 3492 swig_disconnect_director_self("swigDirectorDisconnect"); 3493 } 3494 3495 3496 void SwigDirector_btConvexTriangleCallback::processTriangle(btVector3 *triangle, int partId, int triangleIndex) { 3497 JNIEnvWrapper swigjnienv(this) ; 3498 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3499 jobject swigjobj = (jobject) NULL ; 3500 jlong jtriangle = 0 ; 3501 jint jpartId ; 3502 jint jtriangleIndex ; 3503 3504 if (!swig_override[0]) { 3505 btConvexTriangleCallback::processTriangle(triangle,partId,triangleIndex); 3506 return; 3507 } 3508 swigjobj = swig_get_self(jenv); 3509 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3510 *((btVector3 **)&jtriangle) = (btVector3 *) triangle; 3511 jpartId = (jint) partId; 3512 jtriangleIndex = (jint) triangleIndex; 3513 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[15], swigjobj, jtriangle, jpartId, jtriangleIndex); 3514 jthrowable swigerror = jenv->ExceptionOccurred(); 3515 if (swigerror) { 3516 jenv->ExceptionClear(); 3517 throw Swig::DirectorException(jenv, swigerror); 3518 } 3519 3520 } else { 3521 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btConvexTriangleCallback::processTriangle "); 3522 } 3523 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3524 } 3525 3526 void SwigDirector_btConvexTriangleCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3527 static struct { 3528 const char *mname; 3529 const char *mdesc; 3530 jmethodID base_methid; 3531 } methods[] = { 3532 { 3533 "processTriangle", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btVector3;II)V", NULL 3534 } 3535 }; 3536 3537 static jclass baseclass = 0 ; 3538 3539 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 3540 if (!baseclass) { 3541 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btConvexTriangleCallback"); 3542 if (!baseclass) return; 3543 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 3544 } 3545 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 3546 for (int i = 0; i < 1; ++i) { 3547 if (!methods[i].base_methid) { 3548 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 3549 if (!methods[i].base_methid) return; 3550 } 3551 swig_override[i] = false; 3552 if (derived) { 3553 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 3554 swig_override[i] = (methid != methods[i].base_methid); 3555 jenv->ExceptionClear(); 3556 } 3557 } 3558 } 3559 } 3560 3561 3562 SwigDirector_btGhostPairCallback::SwigDirector_btGhostPairCallback(JNIEnv *jenv) : btGhostPairCallback(), Swig::Director(jenv) { 3563 } 3564 3565 SwigDirector_btGhostPairCallback::~SwigDirector_btGhostPairCallback() { 3566 swig_disconnect_director_self("swigDirectorDisconnect"); 3567 } 3568 3569 3570 btBroadphasePair *SwigDirector_btGhostPairCallback::addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) { 3571 btBroadphasePair *c_result = 0 ; 3572 jlong jresult = 0 ; 3573 JNIEnvWrapper swigjnienv(this) ; 3574 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3575 jobject swigjobj = (jobject) NULL ; 3576 jlong jproxy0 = 0 ; 3577 jlong jproxy1 = 0 ; 3578 3579 if (!swig_override[0]) { 3580 return btGhostPairCallback::addOverlappingPair(proxy0,proxy1); 3581 } 3582 swigjobj = swig_get_self(jenv); 3583 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3584 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 3585 *((btBroadphaseProxy **)&jproxy1) = (btBroadphaseProxy *) proxy1; 3586 jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[16], swigjobj, jproxy0, jproxy1); 3587 jthrowable swigerror = jenv->ExceptionOccurred(); 3588 if (swigerror) { 3589 jenv->ExceptionClear(); 3590 throw Swig::DirectorException(jenv, swigerror); 3591 } 3592 3593 c_result = *(btBroadphasePair **)&jresult; 3594 } else { 3595 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btGhostPairCallback::addOverlappingPair "); 3596 } 3597 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3598 return c_result; 3599 } 3600 3601 void *SwigDirector_btGhostPairCallback::removeOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, btDispatcher *dispatcher) { 3602 void *c_result = 0 ; 3603 jlong jresult = 0 ; 3604 JNIEnvWrapper swigjnienv(this) ; 3605 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3606 jobject swigjobj = (jobject) NULL ; 3607 jlong jproxy0 = 0 ; 3608 jlong jproxy1 = 0 ; 3609 jlong jdispatcher = 0 ; 3610 3611 if (!swig_override[1]) { 3612 return btGhostPairCallback::removeOverlappingPair(proxy0,proxy1,dispatcher); 3613 } 3614 swigjobj = swig_get_self(jenv); 3615 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3616 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 3617 *((btBroadphaseProxy **)&jproxy1) = (btBroadphaseProxy *) proxy1; 3618 *((btDispatcher **)&jdispatcher) = (btDispatcher *) dispatcher; 3619 jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[17], swigjobj, jproxy0, jproxy1, jdispatcher); 3620 jthrowable swigerror = jenv->ExceptionOccurred(); 3621 if (swigerror) { 3622 jenv->ExceptionClear(); 3623 throw Swig::DirectorException(jenv, swigerror); 3624 } 3625 3626 c_result = (void *)jresult; 3627 } else { 3628 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btGhostPairCallback::removeOverlappingPair "); 3629 } 3630 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3631 return c_result; 3632 } 3633 3634 void SwigDirector_btGhostPairCallback::removeOverlappingPairsContainingProxy(btBroadphaseProxy *arg0, btDispatcher *arg1) { 3635 JNIEnvWrapper swigjnienv(this) ; 3636 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3637 jobject swigjobj = (jobject) NULL ; 3638 jlong jarg0 = 0 ; 3639 jlong jarg1 = 0 ; 3640 3641 if (!swig_override[2]) { 3642 btGhostPairCallback::removeOverlappingPairsContainingProxy(arg0,arg1); 3643 return; 3644 } 3645 swigjobj = swig_get_self(jenv); 3646 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3647 *((btBroadphaseProxy **)&jarg0) = (btBroadphaseProxy *) arg0; 3648 *((btDispatcher **)&jarg1) = (btDispatcher *) arg1; 3649 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[18], swigjobj, jarg0, jarg1); 3650 jthrowable swigerror = jenv->ExceptionOccurred(); 3651 if (swigerror) { 3652 jenv->ExceptionClear(); 3653 throw Swig::DirectorException(jenv, swigerror); 3654 } 3655 3656 } else { 3657 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btGhostPairCallback::removeOverlappingPairsContainingProxy "); 3658 } 3659 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3660 } 3661 3662 void SwigDirector_btGhostPairCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3663 static struct { 3664 const char *mname; 3665 const char *mdesc; 3666 jmethodID base_methid; 3667 } methods[] = { 3668 { 3669 "addOverlappingPair", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Lcom/badlogic/gdx/physics/bullet/collision/btBroadphasePair;", NULL 3670 }, 3671 { 3672 "removeOverlappingPair", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;Lcom/badlogic/gdx/physics/bullet/collision/btDispatcher;)J", NULL 3673 }, 3674 { 3675 "removeOverlappingPairsContainingProxy", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;Lcom/badlogic/gdx/physics/bullet/collision/btDispatcher;)V", NULL 3676 } 3677 }; 3678 3679 static jclass baseclass = 0 ; 3680 3681 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 3682 if (!baseclass) { 3683 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btGhostPairCallback"); 3684 if (!baseclass) return; 3685 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 3686 } 3687 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 3688 for (int i = 0; i < 3; ++i) { 3689 if (!methods[i].base_methid) { 3690 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 3691 if (!methods[i].base_methid) return; 3692 } 3693 swig_override[i] = false; 3694 if (derived) { 3695 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 3696 swig_override[i] = (methid != methods[i].base_methid); 3697 jenv->ExceptionClear(); 3698 } 3699 } 3700 } 3701 } 3702 3703 3704 SwigDirector_RayResultCallback::SwigDirector_RayResultCallback(JNIEnv *jenv) : btCollisionWorld::RayResultCallback(), Swig::Director(jenv) { 3705 } 3706 3707 SwigDirector_RayResultCallback::~SwigDirector_RayResultCallback() { 3708 swig_disconnect_director_self("swigDirectorDisconnect"); 3709 } 3710 3711 3712 bool SwigDirector_RayResultCallback::needsCollision(btBroadphaseProxy *proxy0) const { 3713 bool c_result = SwigValueInit< bool >() ; 3714 jboolean jresult = 0 ; 3715 JNIEnvWrapper swigjnienv(this) ; 3716 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3717 jobject swigjobj = (jobject) NULL ; 3718 jlong jproxy0 = 0 ; 3719 3720 if (!swig_override[0]) { 3721 return btCollisionWorld::RayResultCallback::needsCollision(proxy0); 3722 } 3723 swigjobj = swig_get_self(jenv); 3724 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3725 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 3726 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[19], swigjobj, jproxy0); 3727 jthrowable swigerror = jenv->ExceptionOccurred(); 3728 if (swigerror) { 3729 jenv->ExceptionClear(); 3730 throw Swig::DirectorException(jenv, swigerror); 3731 } 3732 3733 c_result = jresult ? true : false; 3734 } else { 3735 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::RayResultCallback::needsCollision "); 3736 } 3737 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3738 return c_result; 3739 } 3740 3741 btScalar SwigDirector_RayResultCallback::addSingleResult(btCollisionWorld::LocalRayResult &rayResult, bool normalInWorldSpace) { 3742 btScalar c_result = SwigValueInit< btScalar >() ; 3743 jfloat jresult = 0 ; 3744 JNIEnvWrapper swigjnienv(this) ; 3745 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3746 jobject swigjobj = (jobject) NULL ; 3747 jlong jrayResult = 0 ; 3748 jboolean jnormalInWorldSpace ; 3749 3750 if (!swig_override[1]) { 3751 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btCollisionWorld::RayResultCallback::addSingleResult."); 3752 return c_result; 3753 } 3754 swigjobj = swig_get_self(jenv); 3755 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3756 *(btCollisionWorld::LocalRayResult **)&jrayResult = (btCollisionWorld::LocalRayResult *) &rayResult; 3757 jnormalInWorldSpace = (jboolean) normalInWorldSpace; 3758 jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[20], swigjobj, jrayResult, jnormalInWorldSpace); 3759 jthrowable swigerror = jenv->ExceptionOccurred(); 3760 if (swigerror) { 3761 jenv->ExceptionClear(); 3762 throw Swig::DirectorException(jenv, swigerror); 3763 } 3764 3765 c_result = (btScalar)jresult; 3766 } else { 3767 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::RayResultCallback::addSingleResult "); 3768 } 3769 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3770 return c_result; 3771 } 3772 3773 void SwigDirector_RayResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3774 static struct { 3775 const char *mname; 3776 const char *mdesc; 3777 jmethodID base_methid; 3778 } methods[] = { 3779 { 3780 "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Z", NULL 3781 }, 3782 { 3783 "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/collision/LocalRayResult;Z)F", NULL 3784 } 3785 }; 3786 3787 static jclass baseclass = 0 ; 3788 3789 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 3790 if (!baseclass) { 3791 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/RayResultCallback"); 3792 if (!baseclass) return; 3793 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 3794 } 3795 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 3796 for (int i = 0; i < 2; ++i) { 3797 if (!methods[i].base_methid) { 3798 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 3799 if (!methods[i].base_methid) return; 3800 } 3801 swig_override[i] = false; 3802 if (derived) { 3803 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 3804 swig_override[i] = (methid != methods[i].base_methid); 3805 jenv->ExceptionClear(); 3806 } 3807 } 3808 } 3809 } 3810 3811 3812 SwigDirector_ClosestRayResultCallback::SwigDirector_ClosestRayResultCallback(JNIEnv *jenv, btVector3 const &rayFromWorld, btVector3 const &rayToWorld) : btCollisionWorld::ClosestRayResultCallback(rayFromWorld, rayToWorld), Swig::Director(jenv) { 3813 } 3814 3815 SwigDirector_ClosestRayResultCallback::~SwigDirector_ClosestRayResultCallback() { 3816 swig_disconnect_director_self("swigDirectorDisconnect"); 3817 } 3818 3819 3820 bool SwigDirector_ClosestRayResultCallback::needsCollision(btBroadphaseProxy *proxy0) const { 3821 bool c_result = SwigValueInit< bool >() ; 3822 jboolean jresult = 0 ; 3823 JNIEnvWrapper swigjnienv(this) ; 3824 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3825 jobject swigjobj = (jobject) NULL ; 3826 jlong jproxy0 = 0 ; 3827 3828 if (!swig_override[0]) { 3829 return btCollisionWorld::RayResultCallback::needsCollision(proxy0); 3830 } 3831 swigjobj = swig_get_self(jenv); 3832 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3833 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 3834 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[21], swigjobj, jproxy0); 3835 jthrowable swigerror = jenv->ExceptionOccurred(); 3836 if (swigerror) { 3837 jenv->ExceptionClear(); 3838 throw Swig::DirectorException(jenv, swigerror); 3839 } 3840 3841 c_result = jresult ? true : false; 3842 } else { 3843 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::ClosestRayResultCallback::needsCollision "); 3844 } 3845 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3846 return c_result; 3847 } 3848 3849 btScalar SwigDirector_ClosestRayResultCallback::addSingleResult(btCollisionWorld::LocalRayResult &rayResult, bool normalInWorldSpace) { 3850 btScalar c_result = SwigValueInit< btScalar >() ; 3851 jfloat jresult = 0 ; 3852 JNIEnvWrapper swigjnienv(this) ; 3853 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3854 jobject swigjobj = (jobject) NULL ; 3855 jlong jrayResult = 0 ; 3856 jboolean jnormalInWorldSpace ; 3857 3858 if (!swig_override[1]) { 3859 return btCollisionWorld::ClosestRayResultCallback::addSingleResult(rayResult,normalInWorldSpace); 3860 } 3861 swigjobj = swig_get_self(jenv); 3862 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3863 *(btCollisionWorld::LocalRayResult **)&jrayResult = (btCollisionWorld::LocalRayResult *) &rayResult; 3864 jnormalInWorldSpace = (jboolean) normalInWorldSpace; 3865 jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[22], swigjobj, jrayResult, jnormalInWorldSpace); 3866 jthrowable swigerror = jenv->ExceptionOccurred(); 3867 if (swigerror) { 3868 jenv->ExceptionClear(); 3869 throw Swig::DirectorException(jenv, swigerror); 3870 } 3871 3872 c_result = (btScalar)jresult; 3873 } else { 3874 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::ClosestRayResultCallback::addSingleResult "); 3875 } 3876 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3877 return c_result; 3878 } 3879 3880 void SwigDirector_ClosestRayResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3881 static struct { 3882 const char *mname; 3883 const char *mdesc; 3884 jmethodID base_methid; 3885 } methods[] = { 3886 { 3887 "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Z", NULL 3888 }, 3889 { 3890 "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/collision/LocalRayResult;Z)F", NULL 3891 } 3892 }; 3893 3894 static jclass baseclass = 0 ; 3895 3896 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 3897 if (!baseclass) { 3898 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/ClosestRayResultCallback"); 3899 if (!baseclass) return; 3900 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 3901 } 3902 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 3903 for (int i = 0; i < 2; ++i) { 3904 if (!methods[i].base_methid) { 3905 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 3906 if (!methods[i].base_methid) return; 3907 } 3908 swig_override[i] = false; 3909 if (derived) { 3910 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 3911 swig_override[i] = (methid != methods[i].base_methid); 3912 jenv->ExceptionClear(); 3913 } 3914 } 3915 } 3916 } 3917 3918 3919 SwigDirector_AllHitsRayResultCallback::SwigDirector_AllHitsRayResultCallback(JNIEnv *jenv, btVector3 const &rayFromWorld, btVector3 const &rayToWorld) : btCollisionWorld::AllHitsRayResultCallback(rayFromWorld, rayToWorld), Swig::Director(jenv) { 3920 } 3921 3922 SwigDirector_AllHitsRayResultCallback::~SwigDirector_AllHitsRayResultCallback() { 3923 swig_disconnect_director_self("swigDirectorDisconnect"); 3924 } 3925 3926 3927 bool SwigDirector_AllHitsRayResultCallback::needsCollision(btBroadphaseProxy *proxy0) const { 3928 bool c_result = SwigValueInit< bool >() ; 3929 jboolean jresult = 0 ; 3930 JNIEnvWrapper swigjnienv(this) ; 3931 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3932 jobject swigjobj = (jobject) NULL ; 3933 jlong jproxy0 = 0 ; 3934 3935 if (!swig_override[0]) { 3936 return btCollisionWorld::RayResultCallback::needsCollision(proxy0); 3937 } 3938 swigjobj = swig_get_self(jenv); 3939 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3940 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 3941 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[23], swigjobj, jproxy0); 3942 jthrowable swigerror = jenv->ExceptionOccurred(); 3943 if (swigerror) { 3944 jenv->ExceptionClear(); 3945 throw Swig::DirectorException(jenv, swigerror); 3946 } 3947 3948 c_result = jresult ? true : false; 3949 } else { 3950 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::AllHitsRayResultCallback::needsCollision "); 3951 } 3952 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3953 return c_result; 3954 } 3955 3956 btScalar SwigDirector_AllHitsRayResultCallback::addSingleResult(btCollisionWorld::LocalRayResult &rayResult, bool normalInWorldSpace) { 3957 btScalar c_result = SwigValueInit< btScalar >() ; 3958 jfloat jresult = 0 ; 3959 JNIEnvWrapper swigjnienv(this) ; 3960 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 3961 jobject swigjobj = (jobject) NULL ; 3962 jlong jrayResult = 0 ; 3963 jboolean jnormalInWorldSpace ; 3964 3965 if (!swig_override[1]) { 3966 return btCollisionWorld::AllHitsRayResultCallback::addSingleResult(rayResult,normalInWorldSpace); 3967 } 3968 swigjobj = swig_get_self(jenv); 3969 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 3970 *(btCollisionWorld::LocalRayResult **)&jrayResult = (btCollisionWorld::LocalRayResult *) &rayResult; 3971 jnormalInWorldSpace = (jboolean) normalInWorldSpace; 3972 jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[24], swigjobj, jrayResult, jnormalInWorldSpace); 3973 jthrowable swigerror = jenv->ExceptionOccurred(); 3974 if (swigerror) { 3975 jenv->ExceptionClear(); 3976 throw Swig::DirectorException(jenv, swigerror); 3977 } 3978 3979 c_result = (btScalar)jresult; 3980 } else { 3981 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::AllHitsRayResultCallback::addSingleResult "); 3982 } 3983 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 3984 return c_result; 3985 } 3986 3987 void SwigDirector_AllHitsRayResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 3988 static struct { 3989 const char *mname; 3990 const char *mdesc; 3991 jmethodID base_methid; 3992 } methods[] = { 3993 { 3994 "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Z", NULL 3995 }, 3996 { 3997 "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/collision/LocalRayResult;Z)F", NULL 3998 } 3999 }; 4000 4001 static jclass baseclass = 0 ; 4002 4003 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 4004 if (!baseclass) { 4005 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/AllHitsRayResultCallback"); 4006 if (!baseclass) return; 4007 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 4008 } 4009 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 4010 for (int i = 0; i < 2; ++i) { 4011 if (!methods[i].base_methid) { 4012 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 4013 if (!methods[i].base_methid) return; 4014 } 4015 swig_override[i] = false; 4016 if (derived) { 4017 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 4018 swig_override[i] = (methid != methods[i].base_methid); 4019 jenv->ExceptionClear(); 4020 } 4021 } 4022 } 4023 } 4024 4025 4026 SwigDirector_ConvexResultCallback::SwigDirector_ConvexResultCallback(JNIEnv *jenv) : btCollisionWorld::ConvexResultCallback(), Swig::Director(jenv) { 4027 } 4028 4029 SwigDirector_ConvexResultCallback::~SwigDirector_ConvexResultCallback() { 4030 swig_disconnect_director_self("swigDirectorDisconnect"); 4031 } 4032 4033 4034 bool SwigDirector_ConvexResultCallback::needsCollision(btBroadphaseProxy *proxy0) const { 4035 bool c_result = SwigValueInit< bool >() ; 4036 jboolean jresult = 0 ; 4037 JNIEnvWrapper swigjnienv(this) ; 4038 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4039 jobject swigjobj = (jobject) NULL ; 4040 jlong jproxy0 = 0 ; 4041 4042 if (!swig_override[0]) { 4043 return btCollisionWorld::ConvexResultCallback::needsCollision(proxy0); 4044 } 4045 swigjobj = swig_get_self(jenv); 4046 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4047 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 4048 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[25], swigjobj, jproxy0); 4049 jthrowable swigerror = jenv->ExceptionOccurred(); 4050 if (swigerror) { 4051 jenv->ExceptionClear(); 4052 throw Swig::DirectorException(jenv, swigerror); 4053 } 4054 4055 c_result = jresult ? true : false; 4056 } else { 4057 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::ConvexResultCallback::needsCollision "); 4058 } 4059 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4060 return c_result; 4061 } 4062 4063 btScalar SwigDirector_ConvexResultCallback::addSingleResult(btCollisionWorld::LocalConvexResult &convexResult, bool normalInWorldSpace) { 4064 btScalar c_result = SwigValueInit< btScalar >() ; 4065 jfloat jresult = 0 ; 4066 JNIEnvWrapper swigjnienv(this) ; 4067 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4068 jobject swigjobj = (jobject) NULL ; 4069 jlong jconvexResult = 0 ; 4070 jboolean jnormalInWorldSpace ; 4071 4072 if (!swig_override[1]) { 4073 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btCollisionWorld::ConvexResultCallback::addSingleResult."); 4074 return c_result; 4075 } 4076 swigjobj = swig_get_self(jenv); 4077 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4078 *(btCollisionWorld::LocalConvexResult **)&jconvexResult = (btCollisionWorld::LocalConvexResult *) &convexResult; 4079 jnormalInWorldSpace = (jboolean) normalInWorldSpace; 4080 jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[26], swigjobj, jconvexResult, jnormalInWorldSpace); 4081 jthrowable swigerror = jenv->ExceptionOccurred(); 4082 if (swigerror) { 4083 jenv->ExceptionClear(); 4084 throw Swig::DirectorException(jenv, swigerror); 4085 } 4086 4087 c_result = (btScalar)jresult; 4088 } else { 4089 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::ConvexResultCallback::addSingleResult "); 4090 } 4091 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4092 return c_result; 4093 } 4094 4095 void SwigDirector_ConvexResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 4096 static struct { 4097 const char *mname; 4098 const char *mdesc; 4099 jmethodID base_methid; 4100 } methods[] = { 4101 { 4102 "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Z", NULL 4103 }, 4104 { 4105 "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/collision/LocalConvexResult;Z)F", NULL 4106 } 4107 }; 4108 4109 static jclass baseclass = 0 ; 4110 4111 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 4112 if (!baseclass) { 4113 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/ConvexResultCallback"); 4114 if (!baseclass) return; 4115 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 4116 } 4117 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 4118 for (int i = 0; i < 2; ++i) { 4119 if (!methods[i].base_methid) { 4120 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 4121 if (!methods[i].base_methid) return; 4122 } 4123 swig_override[i] = false; 4124 if (derived) { 4125 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 4126 swig_override[i] = (methid != methods[i].base_methid); 4127 jenv->ExceptionClear(); 4128 } 4129 } 4130 } 4131 } 4132 4133 4134 SwigDirector_ClosestConvexResultCallback::SwigDirector_ClosestConvexResultCallback(JNIEnv *jenv, btVector3 const &convexFromWorld, btVector3 const &convexToWorld) : btCollisionWorld::ClosestConvexResultCallback(convexFromWorld, convexToWorld), Swig::Director(jenv) { 4135 } 4136 4137 SwigDirector_ClosestConvexResultCallback::~SwigDirector_ClosestConvexResultCallback() { 4138 swig_disconnect_director_self("swigDirectorDisconnect"); 4139 } 4140 4141 4142 bool SwigDirector_ClosestConvexResultCallback::needsCollision(btBroadphaseProxy *proxy0) const { 4143 bool c_result = SwigValueInit< bool >() ; 4144 jboolean jresult = 0 ; 4145 JNIEnvWrapper swigjnienv(this) ; 4146 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4147 jobject swigjobj = (jobject) NULL ; 4148 jlong jproxy0 = 0 ; 4149 4150 if (!swig_override[0]) { 4151 return btCollisionWorld::ConvexResultCallback::needsCollision(proxy0); 4152 } 4153 swigjobj = swig_get_self(jenv); 4154 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4155 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 4156 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[27], swigjobj, jproxy0); 4157 jthrowable swigerror = jenv->ExceptionOccurred(); 4158 if (swigerror) { 4159 jenv->ExceptionClear(); 4160 throw Swig::DirectorException(jenv, swigerror); 4161 } 4162 4163 c_result = jresult ? true : false; 4164 } else { 4165 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::ClosestConvexResultCallback::needsCollision "); 4166 } 4167 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4168 return c_result; 4169 } 4170 4171 btScalar SwigDirector_ClosestConvexResultCallback::addSingleResult(btCollisionWorld::LocalConvexResult &convexResult, bool normalInWorldSpace) { 4172 btScalar c_result = SwigValueInit< btScalar >() ; 4173 jfloat jresult = 0 ; 4174 JNIEnvWrapper swigjnienv(this) ; 4175 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4176 jobject swigjobj = (jobject) NULL ; 4177 jlong jconvexResult = 0 ; 4178 jboolean jnormalInWorldSpace ; 4179 4180 if (!swig_override[1]) { 4181 return btCollisionWorld::ClosestConvexResultCallback::addSingleResult(convexResult,normalInWorldSpace); 4182 } 4183 swigjobj = swig_get_self(jenv); 4184 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4185 *(btCollisionWorld::LocalConvexResult **)&jconvexResult = (btCollisionWorld::LocalConvexResult *) &convexResult; 4186 jnormalInWorldSpace = (jboolean) normalInWorldSpace; 4187 jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[28], swigjobj, jconvexResult, jnormalInWorldSpace); 4188 jthrowable swigerror = jenv->ExceptionOccurred(); 4189 if (swigerror) { 4190 jenv->ExceptionClear(); 4191 throw Swig::DirectorException(jenv, swigerror); 4192 } 4193 4194 c_result = (btScalar)jresult; 4195 } else { 4196 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::ClosestConvexResultCallback::addSingleResult "); 4197 } 4198 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4199 return c_result; 4200 } 4201 4202 void SwigDirector_ClosestConvexResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 4203 static struct { 4204 const char *mname; 4205 const char *mdesc; 4206 jmethodID base_methid; 4207 } methods[] = { 4208 { 4209 "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Z", NULL 4210 }, 4211 { 4212 "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/collision/LocalConvexResult;Z)F", NULL 4213 } 4214 }; 4215 4216 static jclass baseclass = 0 ; 4217 4218 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 4219 if (!baseclass) { 4220 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/ClosestConvexResultCallback"); 4221 if (!baseclass) return; 4222 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 4223 } 4224 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 4225 for (int i = 0; i < 2; ++i) { 4226 if (!methods[i].base_methid) { 4227 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 4228 if (!methods[i].base_methid) return; 4229 } 4230 swig_override[i] = false; 4231 if (derived) { 4232 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 4233 swig_override[i] = (methid != methods[i].base_methid); 4234 jenv->ExceptionClear(); 4235 } 4236 } 4237 } 4238 } 4239 4240 4241 SwigDirector_ContactResultCallback::SwigDirector_ContactResultCallback(JNIEnv *jenv) : btCollisionWorld::ContactResultCallback(), Swig::Director(jenv) { 4242 } 4243 4244 SwigDirector_ContactResultCallback::~SwigDirector_ContactResultCallback() { 4245 swig_disconnect_director_self("swigDirectorDisconnect"); 4246 } 4247 4248 4249 bool SwigDirector_ContactResultCallback::needsCollision(btBroadphaseProxy *proxy0) const { 4250 bool c_result = SwigValueInit< bool >() ; 4251 jboolean jresult = 0 ; 4252 JNIEnvWrapper swigjnienv(this) ; 4253 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4254 jobject swigjobj = (jobject) NULL ; 4255 jlong jproxy0 = 0 ; 4256 4257 if (!swig_override[0]) { 4258 return btCollisionWorld::ContactResultCallback::needsCollision(proxy0); 4259 } 4260 swigjobj = swig_get_self(jenv); 4261 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4262 *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; 4263 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[29], swigjobj, jproxy0); 4264 jthrowable swigerror = jenv->ExceptionOccurred(); 4265 if (swigerror) { 4266 jenv->ExceptionClear(); 4267 throw Swig::DirectorException(jenv, swigerror); 4268 } 4269 4270 c_result = jresult ? true : false; 4271 } else { 4272 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::ContactResultCallback::needsCollision "); 4273 } 4274 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4275 return c_result; 4276 } 4277 4278 btScalar SwigDirector_ContactResultCallback::addSingleResult(btManifoldPoint &cp, btCollisionObjectWrapper const *colObj0Wrap, int partId0, int index0, btCollisionObjectWrapper const *colObj1Wrap, int partId1, int index1) { 4279 btScalar c_result = SwigValueInit< btScalar >() ; 4280 jfloat jresult = 0 ; 4281 JNIEnvWrapper swigjnienv(this) ; 4282 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4283 jobject swigjobj = (jobject) NULL ; 4284 jlong jcp = 0 ; 4285 jlong jcolObj0Wrap = 0 ; 4286 jint jpartId0 ; 4287 jint jindex0 ; 4288 jlong jcolObj1Wrap = 0 ; 4289 jint jpartId1 ; 4290 jint jindex1 ; 4291 4292 if (!swig_override[1]) { 4293 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btCollisionWorld::ContactResultCallback::addSingleResult."); 4294 return c_result; 4295 } 4296 swigjobj = swig_get_self(jenv); 4297 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4298 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 4299 *((btCollisionObjectWrapper **)&jcolObj0Wrap) = (btCollisionObjectWrapper *) colObj0Wrap; 4300 jpartId0 = (jint) partId0; 4301 jindex0 = (jint) index0; 4302 *((btCollisionObjectWrapper **)&jcolObj1Wrap) = (btCollisionObjectWrapper *) colObj1Wrap; 4303 jpartId1 = (jint) partId1; 4304 jindex1 = (jint) index1; 4305 jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[30], swigjobj, jcp, jcolObj0Wrap, jpartId0, jindex0, jcolObj1Wrap, jpartId1, jindex1); 4306 jthrowable swigerror = jenv->ExceptionOccurred(); 4307 if (swigerror) { 4308 jenv->ExceptionClear(); 4309 throw Swig::DirectorException(jenv, swigerror); 4310 } 4311 4312 c_result = (btScalar)jresult; 4313 } else { 4314 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btCollisionWorld::ContactResultCallback::addSingleResult "); 4315 } 4316 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4317 return c_result; 4318 } 4319 4320 void SwigDirector_ContactResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 4321 static struct { 4322 const char *mname; 4323 const char *mdesc; 4324 jmethodID base_methid; 4325 } methods[] = { 4326 { 4327 "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/collision/btBroadphaseProxy;)Z", NULL 4328 }, 4329 { 4330 "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObjectWrapper;IILcom/badlogic/gdx/physics/bullet/collision/btCollisionObjectWrapper;II)F", NULL 4331 } 4332 }; 4333 4334 static jclass baseclass = 0 ; 4335 4336 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 4337 if (!baseclass) { 4338 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/ContactResultCallback"); 4339 if (!baseclass) return; 4340 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 4341 } 4342 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 4343 for (int i = 0; i < 2; ++i) { 4344 if (!methods[i].base_methid) { 4345 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 4346 if (!methods[i].base_methid) return; 4347 } 4348 swig_override[i] = false; 4349 if (derived) { 4350 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 4351 swig_override[i] = (methid != methods[i].base_methid); 4352 jenv->ExceptionClear(); 4353 } 4354 } 4355 } 4356 } 4357 4358 4359 SwigDirector_btTriangleRaycastCallback::SwigDirector_btTriangleRaycastCallback(JNIEnv *jenv, btVector3 const &from, btVector3 const &to, unsigned int flags) : btTriangleRaycastCallback(from, to, flags), Swig::Director(jenv) { 4360 } 4361 4362 SwigDirector_btTriangleRaycastCallback::~SwigDirector_btTriangleRaycastCallback() { 4363 swig_disconnect_director_self("swigDirectorDisconnect"); 4364 } 4365 4366 4367 void SwigDirector_btTriangleRaycastCallback::processTriangle(btVector3 *triangle, int partId, int triangleIndex) { 4368 JNIEnvWrapper swigjnienv(this) ; 4369 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4370 jobject swigjobj = (jobject) NULL ; 4371 jlong jtriangle = 0 ; 4372 jint jpartId ; 4373 jint jtriangleIndex ; 4374 4375 if (!swig_override[0]) { 4376 btTriangleRaycastCallback::processTriangle(triangle,partId,triangleIndex); 4377 return; 4378 } 4379 swigjobj = swig_get_self(jenv); 4380 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4381 *((btVector3 **)&jtriangle) = (btVector3 *) triangle; 4382 jpartId = (jint) partId; 4383 jtriangleIndex = (jint) triangleIndex; 4384 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[31], swigjobj, jtriangle, jpartId, jtriangleIndex); 4385 jthrowable swigerror = jenv->ExceptionOccurred(); 4386 if (swigerror) { 4387 jenv->ExceptionClear(); 4388 throw Swig::DirectorException(jenv, swigerror); 4389 } 4390 4391 } else { 4392 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btTriangleRaycastCallback::processTriangle "); 4393 } 4394 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4395 } 4396 4397 btScalar SwigDirector_btTriangleRaycastCallback::reportHit(btVector3 const &hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex) { 4398 btScalar c_result = SwigValueInit< btScalar >() ; 4399 jfloat jresult = 0 ; 4400 JNIEnvWrapper swigjnienv(this) ; 4401 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4402 jobject swigjobj = (jobject) NULL ; 4403 jobject jhitNormalLocal = 0 ; 4404 jfloat jhitFraction ; 4405 jint jpartId ; 4406 jint jtriangleIndex ; 4407 4408 if (!swig_override[1]) { 4409 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btTriangleRaycastCallback::reportHit."); 4410 return c_result; 4411 } 4412 swigjobj = swig_get_self(jenv); 4413 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4414 jhitNormalLocal = gdx_takePoolObjectVector3(jenv, "poolVector3"); 4415 gdx_setVector3FrombtVector3(jenv, jhitNormalLocal, hitNormalLocal); 4416 gdxPoolAutoReleaseVector3 autoRelease_jhitNormalLocal(jenv, "poolVector3", jhitNormalLocal); 4417 jhitFraction = (jfloat) hitFraction; 4418 jpartId = (jint) partId; 4419 jtriangleIndex = (jint) triangleIndex; 4420 jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[32], swigjobj, jhitNormalLocal, jhitFraction, jpartId, jtriangleIndex); 4421 jthrowable swigerror = jenv->ExceptionOccurred(); 4422 if (swigerror) { 4423 jenv->ExceptionClear(); 4424 throw Swig::DirectorException(jenv, swigerror); 4425 } 4426 4427 c_result = (btScalar)jresult; 4428 } else { 4429 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btTriangleRaycastCallback::reportHit "); 4430 } 4431 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4432 return c_result; 4433 } 4434 4435 void SwigDirector_btTriangleRaycastCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 4436 static struct { 4437 const char *mname; 4438 const char *mdesc; 4439 jmethodID base_methid; 4440 } methods[] = { 4441 { 4442 "processTriangle", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btVector3;II)V", NULL 4443 }, 4444 { 4445 "reportHit", "(Lcom/badlogic/gdx/math/Vector3;FII)F", NULL 4446 } 4447 }; 4448 4449 static jclass baseclass = 0 ; 4450 4451 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 4452 if (!baseclass) { 4453 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btTriangleRaycastCallback"); 4454 if (!baseclass) return; 4455 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 4456 } 4457 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 4458 for (int i = 0; i < 2; ++i) { 4459 if (!methods[i].base_methid) { 4460 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 4461 if (!methods[i].base_methid) return; 4462 } 4463 swig_override[i] = false; 4464 if (derived) { 4465 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 4466 swig_override[i] = (methid != methods[i].base_methid); 4467 jenv->ExceptionClear(); 4468 } 4469 } 4470 } 4471 } 4472 4473 4474 SwigDirector_btTriangleConvexcastCallback::SwigDirector_btTriangleConvexcastCallback(JNIEnv *jenv, btConvexShape const *convexShape, btTransform const &convexShapeFrom, btTransform const &convexShapeTo, btTransform const &triangleToWorld, btScalar const triangleCollisionMargin) : btTriangleConvexcastCallback(convexShape, convexShapeFrom, convexShapeTo, triangleToWorld, triangleCollisionMargin), Swig::Director(jenv) { 4475 } 4476 4477 SwigDirector_btTriangleConvexcastCallback::~SwigDirector_btTriangleConvexcastCallback() { 4478 swig_disconnect_director_self("swigDirectorDisconnect"); 4479 } 4480 4481 4482 void SwigDirector_btTriangleConvexcastCallback::processTriangle(btVector3 *triangle, int partId, int triangleIndex) { 4483 JNIEnvWrapper swigjnienv(this) ; 4484 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4485 jobject swigjobj = (jobject) NULL ; 4486 jlong jtriangle = 0 ; 4487 jint jpartId ; 4488 jint jtriangleIndex ; 4489 4490 if (!swig_override[0]) { 4491 btTriangleConvexcastCallback::processTriangle(triangle,partId,triangleIndex); 4492 return; 4493 } 4494 swigjobj = swig_get_self(jenv); 4495 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4496 *((btVector3 **)&jtriangle) = (btVector3 *) triangle; 4497 jpartId = (jint) partId; 4498 jtriangleIndex = (jint) triangleIndex; 4499 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[33], swigjobj, jtriangle, jpartId, jtriangleIndex); 4500 jthrowable swigerror = jenv->ExceptionOccurred(); 4501 if (swigerror) { 4502 jenv->ExceptionClear(); 4503 throw Swig::DirectorException(jenv, swigerror); 4504 } 4505 4506 } else { 4507 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btTriangleConvexcastCallback::processTriangle "); 4508 } 4509 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4510 } 4511 4512 btScalar SwigDirector_btTriangleConvexcastCallback::reportHit(btVector3 const &hitNormalLocal, btVector3 const &hitPointLocal, btScalar hitFraction, int partId, int triangleIndex) { 4513 btScalar c_result = SwigValueInit< btScalar >() ; 4514 jfloat jresult = 0 ; 4515 JNIEnvWrapper swigjnienv(this) ; 4516 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4517 jobject swigjobj = (jobject) NULL ; 4518 jobject jhitNormalLocal = 0 ; 4519 jobject jhitPointLocal = 0 ; 4520 jfloat jhitFraction ; 4521 jint jpartId ; 4522 jint jtriangleIndex ; 4523 4524 if (!swig_override[1]) { 4525 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btTriangleConvexcastCallback::reportHit."); 4526 return c_result; 4527 } 4528 swigjobj = swig_get_self(jenv); 4529 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4530 jhitNormalLocal = gdx_takePoolObjectVector3(jenv, "poolVector3"); 4531 gdx_setVector3FrombtVector3(jenv, jhitNormalLocal, hitNormalLocal); 4532 gdxPoolAutoReleaseVector3 autoRelease_jhitNormalLocal(jenv, "poolVector3", jhitNormalLocal); 4533 jhitPointLocal = gdx_takePoolObjectVector3(jenv, "poolVector3"); 4534 gdx_setVector3FrombtVector3(jenv, jhitPointLocal, hitPointLocal); 4535 gdxPoolAutoReleaseVector3 autoRelease_jhitPointLocal(jenv, "poolVector3", jhitPointLocal); 4536 jhitFraction = (jfloat) hitFraction; 4537 jpartId = (jint) partId; 4538 jtriangleIndex = (jint) triangleIndex; 4539 jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[34], swigjobj, jhitNormalLocal, jhitPointLocal, jhitFraction, jpartId, jtriangleIndex); 4540 jthrowable swigerror = jenv->ExceptionOccurred(); 4541 if (swigerror) { 4542 jenv->ExceptionClear(); 4543 throw Swig::DirectorException(jenv, swigerror); 4544 } 4545 4546 c_result = (btScalar)jresult; 4547 } else { 4548 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btTriangleConvexcastCallback::reportHit "); 4549 } 4550 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4551 return c_result; 4552 } 4553 4554 void SwigDirector_btTriangleConvexcastCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 4555 static struct { 4556 const char *mname; 4557 const char *mdesc; 4558 jmethodID base_methid; 4559 } methods[] = { 4560 { 4561 "processTriangle", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btVector3;II)V", NULL 4562 }, 4563 { 4564 "reportHit", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FII)F", NULL 4565 } 4566 }; 4567 4568 static jclass baseclass = 0 ; 4569 4570 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 4571 if (!baseclass) { 4572 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/btTriangleConvexcastCallback"); 4573 if (!baseclass) return; 4574 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 4575 } 4576 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 4577 for (int i = 0; i < 2; ++i) { 4578 if (!methods[i].base_methid) { 4579 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 4580 if (!methods[i].base_methid) return; 4581 } 4582 swig_override[i] = false; 4583 if (derived) { 4584 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 4585 swig_override[i] = (methid != methods[i].base_methid); 4586 jenv->ExceptionClear(); 4587 } 4588 } 4589 } 4590 } 4591 4592 4593 SwigDirector_CustomCollisionDispatcher::SwigDirector_CustomCollisionDispatcher(JNIEnv *jenv, btCollisionConfiguration *collisionConfiguration) : CustomCollisionDispatcher(collisionConfiguration), Swig::Director(jenv) { 4594 } 4595 4596 SwigDirector_CustomCollisionDispatcher::~SwigDirector_CustomCollisionDispatcher() { 4597 swig_disconnect_director_self("swigDirectorDisconnect"); 4598 } 4599 4600 4601 btPersistentManifold *SwigDirector_CustomCollisionDispatcher::getNewManifold(btCollisionObject const *b0, btCollisionObject const *b1) { 4602 return btCollisionDispatcher::getNewManifold(b0,b1); 4603 } 4604 4605 void SwigDirector_CustomCollisionDispatcher::releaseManifold(btPersistentManifold *manifold) { 4606 btCollisionDispatcher::releaseManifold(manifold); 4607 } 4608 4609 void SwigDirector_CustomCollisionDispatcher::clearManifold(btPersistentManifold *manifold) { 4610 btCollisionDispatcher::clearManifold(manifold); 4611 } 4612 4613 bool SwigDirector_CustomCollisionDispatcher::needsCollision(btCollisionObject const *body0, btCollisionObject const *body1) { 4614 bool c_result = SwigValueInit< bool >() ; 4615 jboolean jresult = 0 ; 4616 JNIEnvWrapper swigjnienv(this) ; 4617 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4618 jobject swigjobj = (jobject) NULL ; 4619 jlong jbody0 = 0 ; 4620 jlong jbody1 = 0 ; 4621 4622 if (!swig_override[0]) { 4623 return CustomCollisionDispatcher::needsCollision(body0,body1); 4624 } 4625 swigjobj = swig_get_self(jenv); 4626 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4627 *((btCollisionObject **)&jbody0) = (btCollisionObject *) body0; 4628 *((btCollisionObject **)&jbody1) = (btCollisionObject *) body1; 4629 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[35], swigjobj, jbody0, jbody1); 4630 jthrowable swigerror = jenv->ExceptionOccurred(); 4631 if (swigerror) { 4632 jenv->ExceptionClear(); 4633 throw Swig::DirectorException(jenv, swigerror); 4634 } 4635 4636 c_result = jresult ? true : false; 4637 } else { 4638 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in CustomCollisionDispatcher::needsCollision "); 4639 } 4640 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4641 return c_result; 4642 } 4643 4644 bool SwigDirector_CustomCollisionDispatcher::needsResponse(btCollisionObject const *body0, btCollisionObject const *body1) { 4645 bool c_result = SwigValueInit< bool >() ; 4646 jboolean jresult = 0 ; 4647 JNIEnvWrapper swigjnienv(this) ; 4648 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4649 jobject swigjobj = (jobject) NULL ; 4650 jlong jbody0 = 0 ; 4651 jlong jbody1 = 0 ; 4652 4653 if (!swig_override[1]) { 4654 return CustomCollisionDispatcher::needsResponse(body0,body1); 4655 } 4656 swigjobj = swig_get_self(jenv); 4657 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4658 *((btCollisionObject **)&jbody0) = (btCollisionObject *) body0; 4659 *((btCollisionObject **)&jbody1) = (btCollisionObject *) body1; 4660 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[36], swigjobj, jbody0, jbody1); 4661 jthrowable swigerror = jenv->ExceptionOccurred(); 4662 if (swigerror) { 4663 jenv->ExceptionClear(); 4664 throw Swig::DirectorException(jenv, swigerror); 4665 } 4666 4667 c_result = jresult ? true : false; 4668 } else { 4669 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in CustomCollisionDispatcher::needsResponse "); 4670 } 4671 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4672 return c_result; 4673 } 4674 4675 void SwigDirector_CustomCollisionDispatcher::dispatchAllCollisionPairs(btOverlappingPairCache *pairCache, btDispatcherInfo const &dispatchInfo, btDispatcher *dispatcher) { 4676 btCollisionDispatcher::dispatchAllCollisionPairs(pairCache,dispatchInfo,dispatcher); 4677 } 4678 4679 int SwigDirector_CustomCollisionDispatcher::getNumManifolds() const { 4680 return btCollisionDispatcher::getNumManifolds(); 4681 } 4682 4683 btPersistentManifold **SwigDirector_CustomCollisionDispatcher::getInternalManifoldPointer() { 4684 return btCollisionDispatcher::getInternalManifoldPointer(); 4685 } 4686 4687 void *SwigDirector_CustomCollisionDispatcher::allocateCollisionAlgorithm(int size) { 4688 return btCollisionDispatcher::allocateCollisionAlgorithm(size); 4689 } 4690 4691 void SwigDirector_CustomCollisionDispatcher::freeCollisionAlgorithm(void *ptr) { 4692 btCollisionDispatcher::freeCollisionAlgorithm(ptr); 4693 } 4694 4695 void SwigDirector_CustomCollisionDispatcher::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 4696 static struct { 4697 const char *mname; 4698 const char *mdesc; 4699 jmethodID base_methid; 4700 } methods[] = { 4701 { 4702 "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;)Z", NULL 4703 }, 4704 { 4705 "needsResponse", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;)Z", NULL 4706 } 4707 }; 4708 4709 static jclass baseclass = 0 ; 4710 4711 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 4712 if (!baseclass) { 4713 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/CustomCollisionDispatcher"); 4714 if (!baseclass) return; 4715 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 4716 } 4717 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 4718 for (int i = 0; i < 2; ++i) { 4719 if (!methods[i].base_methid) { 4720 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 4721 if (!methods[i].base_methid) return; 4722 } 4723 swig_override[i] = false; 4724 if (derived) { 4725 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 4726 swig_override[i] = (methid != methods[i].base_methid); 4727 jenv->ExceptionClear(); 4728 } 4729 } 4730 } 4731 } 4732 4733 4734 SwigDirector_ContactListener::SwigDirector_ContactListener(JNIEnv *jenv, bool dummy) : ContactListener(dummy), Swig::Director(jenv) { 4735 } 4736 4737 SwigDirector_ContactListener::~SwigDirector_ContactListener() { 4738 swig_disconnect_director_self("swigDirectorDisconnect"); 4739 } 4740 4741 4742 bool SwigDirector_ContactListener::onContactAdded(btManifoldPoint &cp, btCollisionObjectWrapper const &colObj0Wrap, int partId0, int index0, btCollisionObjectWrapper const &colObj1Wrap, int partId1, int index1) { 4743 bool c_result = SwigValueInit< bool >() ; 4744 jboolean jresult = 0 ; 4745 JNIEnvWrapper swigjnienv(this) ; 4746 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4747 jobject swigjobj = (jobject) NULL ; 4748 jlong jcp = 0 ; 4749 jlong jcolObj0Wrap = 0 ; 4750 jint jpartId0 ; 4751 jint jindex0 ; 4752 jlong jcolObj1Wrap = 0 ; 4753 jint jpartId1 ; 4754 jint jindex1 ; 4755 4756 if (!swig_override[0]) { 4757 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 4758 return c_result; 4759 } 4760 swigjobj = swig_get_self(jenv); 4761 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4762 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 4763 *(btCollisionObjectWrapper **)&jcolObj0Wrap = (btCollisionObjectWrapper *) &colObj0Wrap; 4764 jpartId0 = (jint) partId0; 4765 jindex0 = (jint) index0; 4766 *(btCollisionObjectWrapper **)&jcolObj1Wrap = (btCollisionObjectWrapper *) &colObj1Wrap; 4767 jpartId1 = (jint) partId1; 4768 jindex1 = (jint) index1; 4769 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[37], swigjobj, jcp, jcolObj0Wrap, jpartId0, jindex0, jcolObj1Wrap, jpartId1, jindex1); 4770 jthrowable swigerror = jenv->ExceptionOccurred(); 4771 if (swigerror) { 4772 jenv->ExceptionClear(); 4773 throw Swig::DirectorException(jenv, swigerror); 4774 } 4775 4776 c_result = jresult ? true : false; 4777 } else { 4778 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 4779 } 4780 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4781 return c_result; 4782 } 4783 4784 bool SwigDirector_ContactListener::onContactAdded(btManifoldPoint &cp, btCollisionObject const *colObj0, int partId0, int index0, btCollisionObject const *colObj1, int partId1, int index1) { 4785 bool c_result = SwigValueInit< bool >() ; 4786 jboolean jresult = 0 ; 4787 JNIEnvWrapper swigjnienv(this) ; 4788 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4789 jobject swigjobj = (jobject) NULL ; 4790 jlong jcp = 0 ; 4791 jlong jcolObj0 = 0 ; 4792 jint jpartId0 ; 4793 jint jindex0 ; 4794 jlong jcolObj1 = 0 ; 4795 jint jpartId1 ; 4796 jint jindex1 ; 4797 4798 if (!swig_override[1]) { 4799 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 4800 return c_result; 4801 } 4802 swigjobj = swig_get_self(jenv); 4803 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4804 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 4805 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 4806 jpartId0 = (jint) partId0; 4807 jindex0 = (jint) index0; 4808 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 4809 jpartId1 = (jint) partId1; 4810 jindex1 = (jint) index1; 4811 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[38], swigjobj, jcp, jcolObj0, jpartId0, jindex0, jcolObj1, jpartId1, jindex1); 4812 jthrowable swigerror = jenv->ExceptionOccurred(); 4813 if (swigerror) { 4814 jenv->ExceptionClear(); 4815 throw Swig::DirectorException(jenv, swigerror); 4816 } 4817 4818 c_result = jresult ? true : false; 4819 } else { 4820 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 4821 } 4822 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4823 return c_result; 4824 } 4825 4826 bool SwigDirector_ContactListener::onContactAdded(btManifoldPoint &cp, int userValue0, int partId0, int index0, int userValue1, int partId1, int index1) { 4827 bool c_result = SwigValueInit< bool >() ; 4828 jboolean jresult = 0 ; 4829 JNIEnvWrapper swigjnienv(this) ; 4830 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4831 jobject swigjobj = (jobject) NULL ; 4832 jlong jcp = 0 ; 4833 jint juserValue0 ; 4834 jint jpartId0 ; 4835 jint jindex0 ; 4836 jint juserValue1 ; 4837 jint jpartId1 ; 4838 jint jindex1 ; 4839 4840 if (!swig_override[2]) { 4841 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 4842 return c_result; 4843 } 4844 swigjobj = swig_get_self(jenv); 4845 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4846 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 4847 juserValue0 = (jint) userValue0; 4848 jpartId0 = (jint) partId0; 4849 jindex0 = (jint) index0; 4850 juserValue1 = (jint) userValue1; 4851 jpartId1 = (jint) partId1; 4852 jindex1 = (jint) index1; 4853 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[39], swigjobj, jcp, juserValue0, jpartId0, jindex0, juserValue1, jpartId1, jindex1); 4854 jthrowable swigerror = jenv->ExceptionOccurred(); 4855 if (swigerror) { 4856 jenv->ExceptionClear(); 4857 throw Swig::DirectorException(jenv, swigerror); 4858 } 4859 4860 c_result = jresult ? true : false; 4861 } else { 4862 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 4863 } 4864 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4865 return c_result; 4866 } 4867 4868 bool SwigDirector_ContactListener::onContactAdded(btManifoldPoint &cp, btCollisionObjectWrapper const &colObj0Wrap, int partId0, int index0, bool match0, btCollisionObjectWrapper const &colObj1Wrap, int partId1, int index1, bool match1) { 4869 bool c_result = SwigValueInit< bool >() ; 4870 jboolean jresult = 0 ; 4871 JNIEnvWrapper swigjnienv(this) ; 4872 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4873 jobject swigjobj = (jobject) NULL ; 4874 jlong jcp = 0 ; 4875 jlong jcolObj0Wrap = 0 ; 4876 jint jpartId0 ; 4877 jint jindex0 ; 4878 jboolean jmatch0 ; 4879 jlong jcolObj1Wrap = 0 ; 4880 jint jpartId1 ; 4881 jint jindex1 ; 4882 jboolean jmatch1 ; 4883 4884 if (!swig_override[3]) { 4885 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 4886 return c_result; 4887 } 4888 swigjobj = swig_get_self(jenv); 4889 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4890 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 4891 *(btCollisionObjectWrapper **)&jcolObj0Wrap = (btCollisionObjectWrapper *) &colObj0Wrap; 4892 jpartId0 = (jint) partId0; 4893 jindex0 = (jint) index0; 4894 jmatch0 = (jboolean) match0; 4895 *(btCollisionObjectWrapper **)&jcolObj1Wrap = (btCollisionObjectWrapper *) &colObj1Wrap; 4896 jpartId1 = (jint) partId1; 4897 jindex1 = (jint) index1; 4898 jmatch1 = (jboolean) match1; 4899 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[40], swigjobj, jcp, jcolObj0Wrap, jpartId0, jindex0, jmatch0, jcolObj1Wrap, jpartId1, jindex1, jmatch1); 4900 jthrowable swigerror = jenv->ExceptionOccurred(); 4901 if (swigerror) { 4902 jenv->ExceptionClear(); 4903 throw Swig::DirectorException(jenv, swigerror); 4904 } 4905 4906 c_result = jresult ? true : false; 4907 } else { 4908 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 4909 } 4910 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4911 return c_result; 4912 } 4913 4914 bool SwigDirector_ContactListener::onContactAdded(btManifoldPoint &cp, btCollisionObject const *colObj0, int partId0, int index0, bool match0, btCollisionObject const *colObj1, int partId1, int index1, bool match1) { 4915 bool c_result = SwigValueInit< bool >() ; 4916 jboolean jresult = 0 ; 4917 JNIEnvWrapper swigjnienv(this) ; 4918 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4919 jobject swigjobj = (jobject) NULL ; 4920 jlong jcp = 0 ; 4921 jlong jcolObj0 = 0 ; 4922 jint jpartId0 ; 4923 jint jindex0 ; 4924 jboolean jmatch0 ; 4925 jlong jcolObj1 = 0 ; 4926 jint jpartId1 ; 4927 jint jindex1 ; 4928 jboolean jmatch1 ; 4929 4930 if (!swig_override[4]) { 4931 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 4932 return c_result; 4933 } 4934 swigjobj = swig_get_self(jenv); 4935 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4936 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 4937 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 4938 jpartId0 = (jint) partId0; 4939 jindex0 = (jint) index0; 4940 jmatch0 = (jboolean) match0; 4941 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 4942 jpartId1 = (jint) partId1; 4943 jindex1 = (jint) index1; 4944 jmatch1 = (jboolean) match1; 4945 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[41], swigjobj, jcp, jcolObj0, jpartId0, jindex0, jmatch0, jcolObj1, jpartId1, jindex1, jmatch1); 4946 jthrowable swigerror = jenv->ExceptionOccurred(); 4947 if (swigerror) { 4948 jenv->ExceptionClear(); 4949 throw Swig::DirectorException(jenv, swigerror); 4950 } 4951 4952 c_result = jresult ? true : false; 4953 } else { 4954 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 4955 } 4956 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 4957 return c_result; 4958 } 4959 4960 bool SwigDirector_ContactListener::onContactAdded(btManifoldPoint &cp, int userValue0, int partId0, int index0, bool match0, int userValue1, int partId1, int index1, bool match1) { 4961 bool c_result = SwigValueInit< bool >() ; 4962 jboolean jresult = 0 ; 4963 JNIEnvWrapper swigjnienv(this) ; 4964 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 4965 jobject swigjobj = (jobject) NULL ; 4966 jlong jcp = 0 ; 4967 jint juserValue0 ; 4968 jint jpartId0 ; 4969 jint jindex0 ; 4970 jboolean jmatch0 ; 4971 jint juserValue1 ; 4972 jint jpartId1 ; 4973 jint jindex1 ; 4974 jboolean jmatch1 ; 4975 4976 if (!swig_override[5]) { 4977 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 4978 return c_result; 4979 } 4980 swigjobj = swig_get_self(jenv); 4981 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 4982 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 4983 juserValue0 = (jint) userValue0; 4984 jpartId0 = (jint) partId0; 4985 jindex0 = (jint) index0; 4986 jmatch0 = (jboolean) match0; 4987 juserValue1 = (jint) userValue1; 4988 jpartId1 = (jint) partId1; 4989 jindex1 = (jint) index1; 4990 jmatch1 = (jboolean) match1; 4991 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[42], swigjobj, jcp, juserValue0, jpartId0, jindex0, jmatch0, juserValue1, jpartId1, jindex1, jmatch1); 4992 jthrowable swigerror = jenv->ExceptionOccurred(); 4993 if (swigerror) { 4994 jenv->ExceptionClear(); 4995 throw Swig::DirectorException(jenv, swigerror); 4996 } 4997 4998 c_result = jresult ? true : false; 4999 } else { 5000 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 5001 } 5002 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5003 return c_result; 5004 } 5005 5006 bool SwigDirector_ContactListener::onContactAdded(btCollisionObjectWrapper const &colObj0Wrap, int partId0, int index0, btCollisionObjectWrapper const &colObj1Wrap, int partId1, int index1) { 5007 bool c_result = SwigValueInit< bool >() ; 5008 jboolean jresult = 0 ; 5009 JNIEnvWrapper swigjnienv(this) ; 5010 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5011 jobject swigjobj = (jobject) NULL ; 5012 jlong jcolObj0Wrap = 0 ; 5013 jint jpartId0 ; 5014 jint jindex0 ; 5015 jlong jcolObj1Wrap = 0 ; 5016 jint jpartId1 ; 5017 jint jindex1 ; 5018 5019 if (!swig_override[6]) { 5020 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 5021 return c_result; 5022 } 5023 swigjobj = swig_get_self(jenv); 5024 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5025 *(btCollisionObjectWrapper **)&jcolObj0Wrap = (btCollisionObjectWrapper *) &colObj0Wrap; 5026 jpartId0 = (jint) partId0; 5027 jindex0 = (jint) index0; 5028 *(btCollisionObjectWrapper **)&jcolObj1Wrap = (btCollisionObjectWrapper *) &colObj1Wrap; 5029 jpartId1 = (jint) partId1; 5030 jindex1 = (jint) index1; 5031 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[43], swigjobj, jcolObj0Wrap, jpartId0, jindex0, jcolObj1Wrap, jpartId1, jindex1); 5032 jthrowable swigerror = jenv->ExceptionOccurred(); 5033 if (swigerror) { 5034 jenv->ExceptionClear(); 5035 throw Swig::DirectorException(jenv, swigerror); 5036 } 5037 5038 c_result = jresult ? true : false; 5039 } else { 5040 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 5041 } 5042 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5043 return c_result; 5044 } 5045 5046 bool SwigDirector_ContactListener::onContactAdded(btCollisionObject const *colObj0, int partId0, int index0, btCollisionObject const *colObj1, int partId1, int index1) { 5047 bool c_result = SwigValueInit< bool >() ; 5048 jboolean jresult = 0 ; 5049 JNIEnvWrapper swigjnienv(this) ; 5050 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5051 jobject swigjobj = (jobject) NULL ; 5052 jlong jcolObj0 = 0 ; 5053 jint jpartId0 ; 5054 jint jindex0 ; 5055 jlong jcolObj1 = 0 ; 5056 jint jpartId1 ; 5057 jint jindex1 ; 5058 5059 if (!swig_override[7]) { 5060 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 5061 return c_result; 5062 } 5063 swigjobj = swig_get_self(jenv); 5064 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5065 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 5066 jpartId0 = (jint) partId0; 5067 jindex0 = (jint) index0; 5068 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 5069 jpartId1 = (jint) partId1; 5070 jindex1 = (jint) index1; 5071 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[44], swigjobj, jcolObj0, jpartId0, jindex0, jcolObj1, jpartId1, jindex1); 5072 jthrowable swigerror = jenv->ExceptionOccurred(); 5073 if (swigerror) { 5074 jenv->ExceptionClear(); 5075 throw Swig::DirectorException(jenv, swigerror); 5076 } 5077 5078 c_result = jresult ? true : false; 5079 } else { 5080 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 5081 } 5082 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5083 return c_result; 5084 } 5085 5086 bool SwigDirector_ContactListener::onContactAdded(int userValue0, int partId0, int index0, int userValue1, int partId1, int index1) { 5087 bool c_result = SwigValueInit< bool >() ; 5088 jboolean jresult = 0 ; 5089 JNIEnvWrapper swigjnienv(this) ; 5090 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5091 jobject swigjobj = (jobject) NULL ; 5092 jint juserValue0 ; 5093 jint jpartId0 ; 5094 jint jindex0 ; 5095 jint juserValue1 ; 5096 jint jpartId1 ; 5097 jint jindex1 ; 5098 5099 if (!swig_override[8]) { 5100 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 5101 return c_result; 5102 } 5103 swigjobj = swig_get_self(jenv); 5104 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5105 juserValue0 = (jint) userValue0; 5106 jpartId0 = (jint) partId0; 5107 jindex0 = (jint) index0; 5108 juserValue1 = (jint) userValue1; 5109 jpartId1 = (jint) partId1; 5110 jindex1 = (jint) index1; 5111 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[45], swigjobj, juserValue0, jpartId0, jindex0, juserValue1, jpartId1, jindex1); 5112 jthrowable swigerror = jenv->ExceptionOccurred(); 5113 if (swigerror) { 5114 jenv->ExceptionClear(); 5115 throw Swig::DirectorException(jenv, swigerror); 5116 } 5117 5118 c_result = jresult ? true : false; 5119 } else { 5120 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 5121 } 5122 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5123 return c_result; 5124 } 5125 5126 bool SwigDirector_ContactListener::onContactAdded(btCollisionObjectWrapper const &colObj0Wrap, int partId0, int index0, bool match0, btCollisionObjectWrapper const &colObj1Wrap, int partId1, int index1, bool match1) { 5127 bool c_result = SwigValueInit< bool >() ; 5128 jboolean jresult = 0 ; 5129 JNIEnvWrapper swigjnienv(this) ; 5130 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5131 jobject swigjobj = (jobject) NULL ; 5132 jlong jcolObj0Wrap = 0 ; 5133 jint jpartId0 ; 5134 jint jindex0 ; 5135 jboolean jmatch0 ; 5136 jlong jcolObj1Wrap = 0 ; 5137 jint jpartId1 ; 5138 jint jindex1 ; 5139 jboolean jmatch1 ; 5140 5141 if (!swig_override[9]) { 5142 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 5143 return c_result; 5144 } 5145 swigjobj = swig_get_self(jenv); 5146 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5147 *(btCollisionObjectWrapper **)&jcolObj0Wrap = (btCollisionObjectWrapper *) &colObj0Wrap; 5148 jpartId0 = (jint) partId0; 5149 jindex0 = (jint) index0; 5150 jmatch0 = (jboolean) match0; 5151 *(btCollisionObjectWrapper **)&jcolObj1Wrap = (btCollisionObjectWrapper *) &colObj1Wrap; 5152 jpartId1 = (jint) partId1; 5153 jindex1 = (jint) index1; 5154 jmatch1 = (jboolean) match1; 5155 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[46], swigjobj, jcolObj0Wrap, jpartId0, jindex0, jmatch0, jcolObj1Wrap, jpartId1, jindex1, jmatch1); 5156 jthrowable swigerror = jenv->ExceptionOccurred(); 5157 if (swigerror) { 5158 jenv->ExceptionClear(); 5159 throw Swig::DirectorException(jenv, swigerror); 5160 } 5161 5162 c_result = jresult ? true : false; 5163 } else { 5164 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 5165 } 5166 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5167 return c_result; 5168 } 5169 5170 bool SwigDirector_ContactListener::onContactAdded(btCollisionObject const *colObj0, int partId0, int index0, bool match0, btCollisionObject const *colObj1, int partId1, int index1, bool match1) { 5171 bool c_result = SwigValueInit< bool >() ; 5172 jboolean jresult = 0 ; 5173 JNIEnvWrapper swigjnienv(this) ; 5174 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5175 jobject swigjobj = (jobject) NULL ; 5176 jlong jcolObj0 = 0 ; 5177 jint jpartId0 ; 5178 jint jindex0 ; 5179 jboolean jmatch0 ; 5180 jlong jcolObj1 = 0 ; 5181 jint jpartId1 ; 5182 jint jindex1 ; 5183 jboolean jmatch1 ; 5184 5185 if (!swig_override[10]) { 5186 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 5187 return c_result; 5188 } 5189 swigjobj = swig_get_self(jenv); 5190 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5191 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 5192 jpartId0 = (jint) partId0; 5193 jindex0 = (jint) index0; 5194 jmatch0 = (jboolean) match0; 5195 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 5196 jpartId1 = (jint) partId1; 5197 jindex1 = (jint) index1; 5198 jmatch1 = (jboolean) match1; 5199 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[47], swigjobj, jcolObj0, jpartId0, jindex0, jmatch0, jcolObj1, jpartId1, jindex1, jmatch1); 5200 jthrowable swigerror = jenv->ExceptionOccurred(); 5201 if (swigerror) { 5202 jenv->ExceptionClear(); 5203 throw Swig::DirectorException(jenv, swigerror); 5204 } 5205 5206 c_result = jresult ? true : false; 5207 } else { 5208 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 5209 } 5210 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5211 return c_result; 5212 } 5213 5214 bool SwigDirector_ContactListener::onContactAdded(int userValue0, int partId0, int index0, bool match0, int userValue1, int partId1, int index1, bool match1) { 5215 bool c_result = SwigValueInit< bool >() ; 5216 jboolean jresult = 0 ; 5217 JNIEnvWrapper swigjnienv(this) ; 5218 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5219 jobject swigjobj = (jobject) NULL ; 5220 jint juserValue0 ; 5221 jint jpartId0 ; 5222 jint jindex0 ; 5223 jboolean jmatch0 ; 5224 jint juserValue1 ; 5225 jint jpartId1 ; 5226 jint jindex1 ; 5227 jboolean jmatch1 ; 5228 5229 if (!swig_override[11]) { 5230 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactAdded."); 5231 return c_result; 5232 } 5233 swigjobj = swig_get_self(jenv); 5234 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5235 juserValue0 = (jint) userValue0; 5236 jpartId0 = (jint) partId0; 5237 jindex0 = (jint) index0; 5238 jmatch0 = (jboolean) match0; 5239 juserValue1 = (jint) userValue1; 5240 jpartId1 = (jint) partId1; 5241 jindex1 = (jint) index1; 5242 jmatch1 = (jboolean) match1; 5243 jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[48], swigjobj, juserValue0, jpartId0, jindex0, jmatch0, juserValue1, jpartId1, jindex1, jmatch1); 5244 jthrowable swigerror = jenv->ExceptionOccurred(); 5245 if (swigerror) { 5246 jenv->ExceptionClear(); 5247 throw Swig::DirectorException(jenv, swigerror); 5248 } 5249 5250 c_result = jresult ? true : false; 5251 } else { 5252 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactAdded "); 5253 } 5254 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5255 return c_result; 5256 } 5257 5258 void SwigDirector_ContactListener::onContactProcessed(btManifoldPoint &cp, btCollisionObject const *colObj0, btCollisionObject const *colObj1) { 5259 JNIEnvWrapper swigjnienv(this) ; 5260 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5261 jobject swigjobj = (jobject) NULL ; 5262 jlong jcp = 0 ; 5263 jlong jcolObj0 = 0 ; 5264 jlong jcolObj1 = 0 ; 5265 5266 if (!swig_override[12]) { 5267 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactProcessed."); 5268 return; 5269 } 5270 swigjobj = swig_get_self(jenv); 5271 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5272 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 5273 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 5274 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 5275 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[49], swigjobj, jcp, jcolObj0, jcolObj1); 5276 jthrowable swigerror = jenv->ExceptionOccurred(); 5277 if (swigerror) { 5278 jenv->ExceptionClear(); 5279 throw Swig::DirectorException(jenv, swigerror); 5280 } 5281 5282 } else { 5283 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactProcessed "); 5284 } 5285 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5286 } 5287 5288 void SwigDirector_ContactListener::onContactProcessed(btManifoldPoint &cp, int userValue0, int userValue1) { 5289 JNIEnvWrapper swigjnienv(this) ; 5290 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5291 jobject swigjobj = (jobject) NULL ; 5292 jlong jcp = 0 ; 5293 jint juserValue0 ; 5294 jint juserValue1 ; 5295 5296 if (!swig_override[13]) { 5297 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactProcessed."); 5298 return; 5299 } 5300 swigjobj = swig_get_self(jenv); 5301 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5302 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 5303 juserValue0 = (jint) userValue0; 5304 juserValue1 = (jint) userValue1; 5305 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[50], swigjobj, jcp, juserValue0, juserValue1); 5306 jthrowable swigerror = jenv->ExceptionOccurred(); 5307 if (swigerror) { 5308 jenv->ExceptionClear(); 5309 throw Swig::DirectorException(jenv, swigerror); 5310 } 5311 5312 } else { 5313 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactProcessed "); 5314 } 5315 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5316 } 5317 5318 void SwigDirector_ContactListener::onContactProcessed(btManifoldPoint &cp, btCollisionObject const *colObj0, bool match0, btCollisionObject const *colObj1, bool match1) { 5319 JNIEnvWrapper swigjnienv(this) ; 5320 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5321 jobject swigjobj = (jobject) NULL ; 5322 jlong jcp = 0 ; 5323 jlong jcolObj0 = 0 ; 5324 jboolean jmatch0 ; 5325 jlong jcolObj1 = 0 ; 5326 jboolean jmatch1 ; 5327 5328 if (!swig_override[14]) { 5329 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactProcessed."); 5330 return; 5331 } 5332 swigjobj = swig_get_self(jenv); 5333 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5334 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 5335 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 5336 jmatch0 = (jboolean) match0; 5337 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 5338 jmatch1 = (jboolean) match1; 5339 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[51], swigjobj, jcp, jcolObj0, jmatch0, jcolObj1, jmatch1); 5340 jthrowable swigerror = jenv->ExceptionOccurred(); 5341 if (swigerror) { 5342 jenv->ExceptionClear(); 5343 throw Swig::DirectorException(jenv, swigerror); 5344 } 5345 5346 } else { 5347 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactProcessed "); 5348 } 5349 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5350 } 5351 5352 void SwigDirector_ContactListener::onContactProcessed(btManifoldPoint &cp, int userValue0, bool match0, int userValue1, bool match1) { 5353 JNIEnvWrapper swigjnienv(this) ; 5354 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5355 jobject swigjobj = (jobject) NULL ; 5356 jlong jcp = 0 ; 5357 jint juserValue0 ; 5358 jboolean jmatch0 ; 5359 jint juserValue1 ; 5360 jboolean jmatch1 ; 5361 5362 if (!swig_override[15]) { 5363 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactProcessed."); 5364 return; 5365 } 5366 swigjobj = swig_get_self(jenv); 5367 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5368 *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; 5369 juserValue0 = (jint) userValue0; 5370 jmatch0 = (jboolean) match0; 5371 juserValue1 = (jint) userValue1; 5372 jmatch1 = (jboolean) match1; 5373 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[52], swigjobj, jcp, juserValue0, jmatch0, juserValue1, jmatch1); 5374 jthrowable swigerror = jenv->ExceptionOccurred(); 5375 if (swigerror) { 5376 jenv->ExceptionClear(); 5377 throw Swig::DirectorException(jenv, swigerror); 5378 } 5379 5380 } else { 5381 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactProcessed "); 5382 } 5383 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5384 } 5385 5386 void SwigDirector_ContactListener::onContactProcessed(btCollisionObject const *colObj0, btCollisionObject const *colObj1) { 5387 JNIEnvWrapper swigjnienv(this) ; 5388 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5389 jobject swigjobj = (jobject) NULL ; 5390 jlong jcolObj0 = 0 ; 5391 jlong jcolObj1 = 0 ; 5392 5393 if (!swig_override[16]) { 5394 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactProcessed."); 5395 return; 5396 } 5397 swigjobj = swig_get_self(jenv); 5398 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5399 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 5400 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 5401 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[53], swigjobj, jcolObj0, jcolObj1); 5402 jthrowable swigerror = jenv->ExceptionOccurred(); 5403 if (swigerror) { 5404 jenv->ExceptionClear(); 5405 throw Swig::DirectorException(jenv, swigerror); 5406 } 5407 5408 } else { 5409 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactProcessed "); 5410 } 5411 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5412 } 5413 5414 void SwigDirector_ContactListener::onContactProcessed(int userValue0, int userValue1) { 5415 JNIEnvWrapper swigjnienv(this) ; 5416 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5417 jobject swigjobj = (jobject) NULL ; 5418 jint juserValue0 ; 5419 jint juserValue1 ; 5420 5421 if (!swig_override[17]) { 5422 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactProcessed."); 5423 return; 5424 } 5425 swigjobj = swig_get_self(jenv); 5426 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5427 juserValue0 = (jint) userValue0; 5428 juserValue1 = (jint) userValue1; 5429 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[54], swigjobj, juserValue0, juserValue1); 5430 jthrowable swigerror = jenv->ExceptionOccurred(); 5431 if (swigerror) { 5432 jenv->ExceptionClear(); 5433 throw Swig::DirectorException(jenv, swigerror); 5434 } 5435 5436 } else { 5437 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactProcessed "); 5438 } 5439 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5440 } 5441 5442 void SwigDirector_ContactListener::onContactProcessed(btCollisionObject const *colObj0, bool match0, btCollisionObject const *colObj1, bool match1) { 5443 JNIEnvWrapper swigjnienv(this) ; 5444 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5445 jobject swigjobj = (jobject) NULL ; 5446 jlong jcolObj0 = 0 ; 5447 jboolean jmatch0 ; 5448 jlong jcolObj1 = 0 ; 5449 jboolean jmatch1 ; 5450 5451 if (!swig_override[18]) { 5452 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactProcessed."); 5453 return; 5454 } 5455 swigjobj = swig_get_self(jenv); 5456 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5457 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 5458 jmatch0 = (jboolean) match0; 5459 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 5460 jmatch1 = (jboolean) match1; 5461 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[55], swigjobj, jcolObj0, jmatch0, jcolObj1, jmatch1); 5462 jthrowable swigerror = jenv->ExceptionOccurred(); 5463 if (swigerror) { 5464 jenv->ExceptionClear(); 5465 throw Swig::DirectorException(jenv, swigerror); 5466 } 5467 5468 } else { 5469 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactProcessed "); 5470 } 5471 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5472 } 5473 5474 void SwigDirector_ContactListener::onContactProcessed(int userValue0, bool match0, int userValue1, bool match1) { 5475 JNIEnvWrapper swigjnienv(this) ; 5476 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5477 jobject swigjobj = (jobject) NULL ; 5478 jint juserValue0 ; 5479 jboolean jmatch0 ; 5480 jint juserValue1 ; 5481 jboolean jmatch1 ; 5482 5483 if (!swig_override[19]) { 5484 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactProcessed."); 5485 return; 5486 } 5487 swigjobj = swig_get_self(jenv); 5488 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5489 juserValue0 = (jint) userValue0; 5490 jmatch0 = (jboolean) match0; 5491 juserValue1 = (jint) userValue1; 5492 jmatch1 = (jboolean) match1; 5493 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[56], swigjobj, juserValue0, jmatch0, juserValue1, jmatch1); 5494 jthrowable swigerror = jenv->ExceptionOccurred(); 5495 if (swigerror) { 5496 jenv->ExceptionClear(); 5497 throw Swig::DirectorException(jenv, swigerror); 5498 } 5499 5500 } else { 5501 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactProcessed "); 5502 } 5503 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5504 } 5505 5506 void SwigDirector_ContactListener::onContactDestroyed(int manifoldPointUserValue) { 5507 JNIEnvWrapper swigjnienv(this) ; 5508 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5509 jobject swigjobj = (jobject) NULL ; 5510 jint jmanifoldPointUserValue ; 5511 5512 if (!swig_override[20]) { 5513 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactDestroyed."); 5514 return; 5515 } 5516 swigjobj = swig_get_self(jenv); 5517 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5518 jmanifoldPointUserValue = (jint) manifoldPointUserValue; 5519 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[57], swigjobj, jmanifoldPointUserValue); 5520 jthrowable swigerror = jenv->ExceptionOccurred(); 5521 if (swigerror) { 5522 jenv->ExceptionClear(); 5523 throw Swig::DirectorException(jenv, swigerror); 5524 } 5525 5526 } else { 5527 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactDestroyed "); 5528 } 5529 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5530 } 5531 5532 void SwigDirector_ContactListener::onContactStarted(btPersistentManifold *manifold) { 5533 JNIEnvWrapper swigjnienv(this) ; 5534 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5535 jobject swigjobj = (jobject) NULL ; 5536 jlong jmanifold = 0 ; 5537 5538 if (!swig_override[21]) { 5539 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactStarted."); 5540 return; 5541 } 5542 swigjobj = swig_get_self(jenv); 5543 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5544 *((btPersistentManifold **)&jmanifold) = (btPersistentManifold *) manifold; 5545 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[58], swigjobj, jmanifold); 5546 jthrowable swigerror = jenv->ExceptionOccurred(); 5547 if (swigerror) { 5548 jenv->ExceptionClear(); 5549 throw Swig::DirectorException(jenv, swigerror); 5550 } 5551 5552 } else { 5553 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactStarted "); 5554 } 5555 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5556 } 5557 5558 void SwigDirector_ContactListener::onContactStarted(btCollisionObject const *colObj0, btCollisionObject const *colObj1) { 5559 JNIEnvWrapper swigjnienv(this) ; 5560 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5561 jobject swigjobj = (jobject) NULL ; 5562 jlong jcolObj0 = 0 ; 5563 jlong jcolObj1 = 0 ; 5564 5565 if (!swig_override[22]) { 5566 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactStarted."); 5567 return; 5568 } 5569 swigjobj = swig_get_self(jenv); 5570 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5571 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 5572 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 5573 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[59], swigjobj, jcolObj0, jcolObj1); 5574 jthrowable swigerror = jenv->ExceptionOccurred(); 5575 if (swigerror) { 5576 jenv->ExceptionClear(); 5577 throw Swig::DirectorException(jenv, swigerror); 5578 } 5579 5580 } else { 5581 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactStarted "); 5582 } 5583 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5584 } 5585 5586 void SwigDirector_ContactListener::onContactStarted(int const &userValue0, int const &userValue1) { 5587 JNIEnvWrapper swigjnienv(this) ; 5588 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5589 jobject swigjobj = (jobject) NULL ; 5590 jint juserValue0 = 0 ; 5591 jint juserValue1 = 0 ; 5592 5593 if (!swig_override[23]) { 5594 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactStarted."); 5595 return; 5596 } 5597 swigjobj = swig_get_self(jenv); 5598 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5599 juserValue0 = (jint)userValue0; 5600 juserValue1 = (jint)userValue1; 5601 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[60], swigjobj, juserValue0, juserValue1); 5602 jthrowable swigerror = jenv->ExceptionOccurred(); 5603 if (swigerror) { 5604 jenv->ExceptionClear(); 5605 throw Swig::DirectorException(jenv, swigerror); 5606 } 5607 5608 } else { 5609 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactStarted "); 5610 } 5611 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5612 } 5613 5614 void SwigDirector_ContactListener::onContactStarted(btPersistentManifold *manifold, bool const &match0, bool const &match1) { 5615 JNIEnvWrapper swigjnienv(this) ; 5616 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5617 jobject swigjobj = (jobject) NULL ; 5618 jlong jmanifold = 0 ; 5619 jboolean jmatch0 = 0 ; 5620 jboolean jmatch1 = 0 ; 5621 5622 if (!swig_override[24]) { 5623 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactStarted."); 5624 return; 5625 } 5626 swigjobj = swig_get_self(jenv); 5627 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5628 *((btPersistentManifold **)&jmanifold) = (btPersistentManifold *) manifold; 5629 jmatch0 = (jboolean)match0; 5630 jmatch1 = (jboolean)match1; 5631 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[61], swigjobj, jmanifold, jmatch0, jmatch1); 5632 jthrowable swigerror = jenv->ExceptionOccurred(); 5633 if (swigerror) { 5634 jenv->ExceptionClear(); 5635 throw Swig::DirectorException(jenv, swigerror); 5636 } 5637 5638 } else { 5639 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactStarted "); 5640 } 5641 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5642 } 5643 5644 void SwigDirector_ContactListener::onContactStarted(btCollisionObject const *colObj0, bool const &match0, btCollisionObject const *colObj1, bool const &match1) { 5645 JNIEnvWrapper swigjnienv(this) ; 5646 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5647 jobject swigjobj = (jobject) NULL ; 5648 jlong jcolObj0 = 0 ; 5649 jboolean jmatch0 = 0 ; 5650 jlong jcolObj1 = 0 ; 5651 jboolean jmatch1 = 0 ; 5652 5653 if (!swig_override[25]) { 5654 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactStarted."); 5655 return; 5656 } 5657 swigjobj = swig_get_self(jenv); 5658 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5659 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 5660 jmatch0 = (jboolean)match0; 5661 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 5662 jmatch1 = (jboolean)match1; 5663 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[62], swigjobj, jcolObj0, jmatch0, jcolObj1, jmatch1); 5664 jthrowable swigerror = jenv->ExceptionOccurred(); 5665 if (swigerror) { 5666 jenv->ExceptionClear(); 5667 throw Swig::DirectorException(jenv, swigerror); 5668 } 5669 5670 } else { 5671 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactStarted "); 5672 } 5673 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5674 } 5675 5676 void SwigDirector_ContactListener::onContactStarted(int const &userValue0, bool const &match0, int const &userValue1, bool const &match1) { 5677 JNIEnvWrapper swigjnienv(this) ; 5678 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5679 jobject swigjobj = (jobject) NULL ; 5680 jint juserValue0 = 0 ; 5681 jboolean jmatch0 = 0 ; 5682 jint juserValue1 = 0 ; 5683 jboolean jmatch1 = 0 ; 5684 5685 if (!swig_override[26]) { 5686 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactStarted."); 5687 return; 5688 } 5689 swigjobj = swig_get_self(jenv); 5690 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5691 juserValue0 = (jint)userValue0; 5692 jmatch0 = (jboolean)match0; 5693 juserValue1 = (jint)userValue1; 5694 jmatch1 = (jboolean)match1; 5695 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[63], swigjobj, juserValue0, jmatch0, juserValue1, jmatch1); 5696 jthrowable swigerror = jenv->ExceptionOccurred(); 5697 if (swigerror) { 5698 jenv->ExceptionClear(); 5699 throw Swig::DirectorException(jenv, swigerror); 5700 } 5701 5702 } else { 5703 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactStarted "); 5704 } 5705 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5706 } 5707 5708 void SwigDirector_ContactListener::onContactEnded(btPersistentManifold *manifold) { 5709 JNIEnvWrapper swigjnienv(this) ; 5710 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5711 jobject swigjobj = (jobject) NULL ; 5712 jlong jmanifold = 0 ; 5713 5714 if (!swig_override[27]) { 5715 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactEnded."); 5716 return; 5717 } 5718 swigjobj = swig_get_self(jenv); 5719 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5720 *((btPersistentManifold **)&jmanifold) = (btPersistentManifold *) manifold; 5721 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[64], swigjobj, jmanifold); 5722 jthrowable swigerror = jenv->ExceptionOccurred(); 5723 if (swigerror) { 5724 jenv->ExceptionClear(); 5725 throw Swig::DirectorException(jenv, swigerror); 5726 } 5727 5728 } else { 5729 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactEnded "); 5730 } 5731 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5732 } 5733 5734 void SwigDirector_ContactListener::onContactEnded(btCollisionObject const *colObj0, btCollisionObject const *colObj1) { 5735 JNIEnvWrapper swigjnienv(this) ; 5736 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5737 jobject swigjobj = (jobject) NULL ; 5738 jlong jcolObj0 = 0 ; 5739 jlong jcolObj1 = 0 ; 5740 5741 if (!swig_override[28]) { 5742 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactEnded."); 5743 return; 5744 } 5745 swigjobj = swig_get_self(jenv); 5746 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5747 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 5748 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 5749 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[65], swigjobj, jcolObj0, jcolObj1); 5750 jthrowable swigerror = jenv->ExceptionOccurred(); 5751 if (swigerror) { 5752 jenv->ExceptionClear(); 5753 throw Swig::DirectorException(jenv, swigerror); 5754 } 5755 5756 } else { 5757 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactEnded "); 5758 } 5759 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5760 } 5761 5762 void SwigDirector_ContactListener::onContactEnded(int const &userValue0, int const &userValue1) { 5763 JNIEnvWrapper swigjnienv(this) ; 5764 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5765 jobject swigjobj = (jobject) NULL ; 5766 jint juserValue0 = 0 ; 5767 jint juserValue1 = 0 ; 5768 5769 if (!swig_override[29]) { 5770 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactEnded."); 5771 return; 5772 } 5773 swigjobj = swig_get_self(jenv); 5774 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5775 juserValue0 = (jint)userValue0; 5776 juserValue1 = (jint)userValue1; 5777 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[66], swigjobj, juserValue0, juserValue1); 5778 jthrowable swigerror = jenv->ExceptionOccurred(); 5779 if (swigerror) { 5780 jenv->ExceptionClear(); 5781 throw Swig::DirectorException(jenv, swigerror); 5782 } 5783 5784 } else { 5785 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactEnded "); 5786 } 5787 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5788 } 5789 5790 void SwigDirector_ContactListener::onContactEnded(btPersistentManifold *manifold, bool const &match0, bool const &match1) { 5791 JNIEnvWrapper swigjnienv(this) ; 5792 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5793 jobject swigjobj = (jobject) NULL ; 5794 jlong jmanifold = 0 ; 5795 jboolean jmatch0 = 0 ; 5796 jboolean jmatch1 = 0 ; 5797 5798 if (!swig_override[30]) { 5799 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactEnded."); 5800 return; 5801 } 5802 swigjobj = swig_get_self(jenv); 5803 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5804 *((btPersistentManifold **)&jmanifold) = (btPersistentManifold *) manifold; 5805 jmatch0 = (jboolean)match0; 5806 jmatch1 = (jboolean)match1; 5807 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[67], swigjobj, jmanifold, jmatch0, jmatch1); 5808 jthrowable swigerror = jenv->ExceptionOccurred(); 5809 if (swigerror) { 5810 jenv->ExceptionClear(); 5811 throw Swig::DirectorException(jenv, swigerror); 5812 } 5813 5814 } else { 5815 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactEnded "); 5816 } 5817 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5818 } 5819 5820 void SwigDirector_ContactListener::onContactEnded(btCollisionObject const *colObj0, bool const &match0, btCollisionObject const *colObj1, bool const &match1) { 5821 JNIEnvWrapper swigjnienv(this) ; 5822 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5823 jobject swigjobj = (jobject) NULL ; 5824 jlong jcolObj0 = 0 ; 5825 jboolean jmatch0 = 0 ; 5826 jlong jcolObj1 = 0 ; 5827 jboolean jmatch1 = 0 ; 5828 5829 if (!swig_override[31]) { 5830 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactEnded."); 5831 return; 5832 } 5833 swigjobj = swig_get_self(jenv); 5834 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5835 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 5836 jmatch0 = (jboolean)match0; 5837 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 5838 jmatch1 = (jboolean)match1; 5839 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[68], swigjobj, jcolObj0, jmatch0, jcolObj1, jmatch1); 5840 jthrowable swigerror = jenv->ExceptionOccurred(); 5841 if (swigerror) { 5842 jenv->ExceptionClear(); 5843 throw Swig::DirectorException(jenv, swigerror); 5844 } 5845 5846 } else { 5847 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactEnded "); 5848 } 5849 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5850 } 5851 5852 void SwigDirector_ContactListener::onContactEnded(int const &userValue0, bool const &match0, int const &userValue1, bool const &match1) { 5853 JNIEnvWrapper swigjnienv(this) ; 5854 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 5855 jobject swigjobj = (jobject) NULL ; 5856 jint juserValue0 = 0 ; 5857 jboolean jmatch0 = 0 ; 5858 jint juserValue1 = 0 ; 5859 jboolean jmatch1 = 0 ; 5860 5861 if (!swig_override[32]) { 5862 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactListener::onContactEnded."); 5863 return; 5864 } 5865 swigjobj = swig_get_self(jenv); 5866 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 5867 juserValue0 = (jint)userValue0; 5868 jmatch0 = (jboolean)match0; 5869 juserValue1 = (jint)userValue1; 5870 jmatch1 = (jboolean)match1; 5871 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[69], swigjobj, juserValue0, jmatch0, juserValue1, jmatch1); 5872 jthrowable swigerror = jenv->ExceptionOccurred(); 5873 if (swigerror) { 5874 jenv->ExceptionClear(); 5875 throw Swig::DirectorException(jenv, swigerror); 5876 } 5877 5878 } else { 5879 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactListener::onContactEnded "); 5880 } 5881 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 5882 } 5883 5884 void SwigDirector_ContactListener::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 5885 static struct { 5886 const char *mname; 5887 const char *mdesc; 5888 jmethodID base_methid; 5889 } methods[] = { 5890 { 5891 "onContactAdded", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObjectWrapper;IILcom/badlogic/gdx/physics/bullet/collision/btCollisionObjectWrapper;II)Z", NULL 5892 }, 5893 { 5894 "onContactAdded", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;IILcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;II)Z", NULL 5895 }, 5896 { 5897 "onContactAdded", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;IIIIII)Z", NULL 5898 }, 5899 { 5900 "onContactAdded", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObjectWrapper;IIZLcom/badlogic/gdx/physics/bullet/collision/btCollisionObjectWrapper;IIZ)Z", NULL 5901 }, 5902 { 5903 "onContactAdded", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;IIZLcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;IIZ)Z", NULL 5904 }, 5905 { 5906 "onContactAdded", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;IIIZIIIZ)Z", NULL 5907 }, 5908 { 5909 "onContactAdded", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObjectWrapper;IILcom/badlogic/gdx/physics/bullet/collision/btCollisionObjectWrapper;II)Z", NULL 5910 }, 5911 { 5912 "onContactAdded", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;IILcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;II)Z", NULL 5913 }, 5914 { 5915 "onContactAdded", "(IIIIII)Z", NULL 5916 }, 5917 { 5918 "onContactAdded", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObjectWrapper;IIZLcom/badlogic/gdx/physics/bullet/collision/btCollisionObjectWrapper;IIZ)Z", NULL 5919 }, 5920 { 5921 "onContactAdded", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;IIZLcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;IIZ)Z", NULL 5922 }, 5923 { 5924 "onContactAdded", "(IIIZIIIZ)Z", NULL 5925 }, 5926 { 5927 "onContactProcessed", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;)V", NULL 5928 }, 5929 { 5930 "onContactProcessed", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;II)V", NULL 5931 }, 5932 { 5933 "onContactProcessed", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;ZLcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Z)V", NULL 5934 }, 5935 { 5936 "onContactProcessed", "(Lcom/badlogic/gdx/physics/bullet/collision/btManifoldPoint;IZIZ)V", NULL 5937 }, 5938 { 5939 "onContactProcessed", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;)V", NULL 5940 }, 5941 { 5942 "onContactProcessed", "(II)V", NULL 5943 }, 5944 { 5945 "onContactProcessed", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;ZLcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Z)V", NULL 5946 }, 5947 { 5948 "onContactProcessed", "(IZIZ)V", NULL 5949 }, 5950 { 5951 "onContactDestroyed", "(I)V", NULL 5952 }, 5953 { 5954 "onContactStarted", "(Lcom/badlogic/gdx/physics/bullet/collision/btPersistentManifold;)V", NULL 5955 }, 5956 { 5957 "onContactStarted", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;)V", NULL 5958 }, 5959 { 5960 "onContactStarted", "(II)V", NULL 5961 }, 5962 { 5963 "onContactStarted", "(Lcom/badlogic/gdx/physics/bullet/collision/btPersistentManifold;ZZ)V", NULL 5964 }, 5965 { 5966 "onContactStarted", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;ZLcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Z)V", NULL 5967 }, 5968 { 5969 "onContactStarted", "(IZIZ)V", NULL 5970 }, 5971 { 5972 "onContactEnded", "(Lcom/badlogic/gdx/physics/bullet/collision/btPersistentManifold;)V", NULL 5973 }, 5974 { 5975 "onContactEnded", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;)V", NULL 5976 }, 5977 { 5978 "onContactEnded", "(II)V", NULL 5979 }, 5980 { 5981 "onContactEnded", "(Lcom/badlogic/gdx/physics/bullet/collision/btPersistentManifold;ZZ)V", NULL 5982 }, 5983 { 5984 "onContactEnded", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;ZLcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Z)V", NULL 5985 }, 5986 { 5987 "onContactEnded", "(IZIZ)V", NULL 5988 } 5989 }; 5990 5991 static jclass baseclass = 0 ; 5992 5993 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 5994 if (!baseclass) { 5995 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/ContactListener"); 5996 if (!baseclass) return; 5997 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 5998 } 5999 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 6000 for (int i = 0; i < 33; ++i) { 6001 if (!methods[i].base_methid) { 6002 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 6003 if (!methods[i].base_methid) return; 6004 } 6005 swig_override[i] = false; 6006 if (derived) { 6007 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 6008 swig_override[i] = (methid != methods[i].base_methid); 6009 jenv->ExceptionClear(); 6010 } 6011 } 6012 } 6013 } 6014 6015 6016 SwigDirector_ContactCache::SwigDirector_ContactCache(JNIEnv *jenv, bool dummy) : ContactCache(dummy), Swig::Director(jenv) { 6017 } 6018 6019 SwigDirector_ContactCache::~SwigDirector_ContactCache() { 6020 swig_disconnect_director_self("swigDirectorDisconnect"); 6021 } 6022 6023 6024 void SwigDirector_ContactCache::onContactStarted(btPersistentManifold *manifold, bool const &match0, bool const &match1) { 6025 JNIEnvWrapper swigjnienv(this) ; 6026 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 6027 jobject swigjobj = (jobject) NULL ; 6028 jlong jmanifold = 0 ; 6029 jboolean jmatch0 = 0 ; 6030 jboolean jmatch1 = 0 ; 6031 6032 if (!swig_override[0]) { 6033 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactCache::onContactStarted."); 6034 return; 6035 } 6036 swigjobj = swig_get_self(jenv); 6037 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 6038 *((btPersistentManifold **)&jmanifold) = (btPersistentManifold *) manifold; 6039 jmatch0 = (jboolean)match0; 6040 jmatch1 = (jboolean)match1; 6041 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[70], swigjobj, jmanifold, jmatch0, jmatch1); 6042 jthrowable swigerror = jenv->ExceptionOccurred(); 6043 if (swigerror) { 6044 jenv->ExceptionClear(); 6045 throw Swig::DirectorException(jenv, swigerror); 6046 } 6047 6048 } else { 6049 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactCache::onContactStarted "); 6050 } 6051 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 6052 } 6053 6054 void SwigDirector_ContactCache::onContactEnded(btCollisionObject const *colObj0, bool const &match0, btCollisionObject const *colObj1, bool const &match1) { 6055 JNIEnvWrapper swigjnienv(this) ; 6056 JNIEnv * jenv = swigjnienv.getJNIEnv() ; 6057 jobject swigjobj = (jobject) NULL ; 6058 jlong jcolObj0 = 0 ; 6059 jboolean jmatch0 = 0 ; 6060 jlong jcolObj1 = 0 ; 6061 jboolean jmatch1 = 0 ; 6062 6063 if (!swig_override[1]) { 6064 SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactCache::onContactEnded."); 6065 return; 6066 } 6067 swigjobj = swig_get_self(jenv); 6068 if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { 6069 *((btCollisionObject **)&jcolObj0) = (btCollisionObject *) colObj0; 6070 jmatch0 = (jboolean)match0; 6071 *((btCollisionObject **)&jcolObj1) = (btCollisionObject *) colObj1; 6072 jmatch1 = (jboolean)match1; 6073 jenv->CallStaticVoidMethod(Swig::jclass_CollisionJNI, Swig::director_method_ids[71], swigjobj, jcolObj0, jmatch0, jcolObj1, jmatch1); 6074 jthrowable swigerror = jenv->ExceptionOccurred(); 6075 if (swigerror) { 6076 jenv->ExceptionClear(); 6077 throw Swig::DirectorException(jenv, swigerror); 6078 } 6079 6080 } else { 6081 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in ContactCache::onContactEnded "); 6082 } 6083 if (swigjobj) jenv->DeleteLocalRef(swigjobj); 6084 } 6085 6086 void SwigDirector_ContactCache::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { 6087 static struct { 6088 const char *mname; 6089 const char *mdesc; 6090 jmethodID base_methid; 6091 } methods[] = { 6092 { 6093 "onContactStarted", "(Lcom/badlogic/gdx/physics/bullet/collision/btPersistentManifold;ZZ)V", NULL 6094 }, 6095 { 6096 "onContactEnded", "(Lcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;ZLcom/badlogic/gdx/physics/bullet/collision/btCollisionObject;Z)V", NULL 6097 } 6098 }; 6099 6100 static jclass baseclass = 0 ; 6101 6102 if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { 6103 if (!baseclass) { 6104 baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/collision/ContactCache"); 6105 if (!baseclass) return; 6106 baseclass = (jclass) jenv->NewGlobalRef(baseclass); 6107 } 6108 bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); 6109 for (int i = 0; i < 2; ++i) { 6110 if (!methods[i].base_methid) { 6111 methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); 6112 if (!methods[i].base_methid) return; 6113 } 6114 swig_override[i] = false; 6115 if (derived) { 6116 jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); 6117 swig_override[i] = (methid != methods[i].base_methid); 6118 jenv->ExceptionClear(); 6119 } 6120 } 6121 } 6122 } 6123 6124 6125 6126 #ifdef __cplusplus 6127 extern "C" { 6128 #endif 6129 6130 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btDiscreteCollisionDetectorInterface_1Result(JNIEnv *jenv, jclass jcls, jlong jarg1) { 6131 btDiscreteCollisionDetectorInterface::Result *arg1 = (btDiscreteCollisionDetectorInterface::Result *) 0 ; 6132 6133 (void)jenv; 6134 (void)jcls; 6135 arg1 = *(btDiscreteCollisionDetectorInterface::Result **)&jarg1; 6136 delete arg1; 6137 } 6138 6139 6140 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1Result_1setShapeIdentifiersA(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { 6141 btDiscreteCollisionDetectorInterface::Result *arg1 = (btDiscreteCollisionDetectorInterface::Result *) 0 ; 6142 int arg2 ; 6143 int arg3 ; 6144 6145 (void)jenv; 6146 (void)jcls; 6147 (void)jarg1_; 6148 arg1 = *(btDiscreteCollisionDetectorInterface::Result **)&jarg1; 6149 arg2 = (int)jarg2; 6150 arg3 = (int)jarg3; 6151 (arg1)->setShapeIdentifiersA(arg2,arg3); 6152 } 6153 6154 6155 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1Result_1setShapeIdentifiersB(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { 6156 btDiscreteCollisionDetectorInterface::Result *arg1 = (btDiscreteCollisionDetectorInterface::Result *) 0 ; 6157 int arg2 ; 6158 int arg3 ; 6159 6160 (void)jenv; 6161 (void)jcls; 6162 (void)jarg1_; 6163 arg1 = *(btDiscreteCollisionDetectorInterface::Result **)&jarg1; 6164 arg2 = (int)jarg2; 6165 arg3 = (int)jarg3; 6166 (arg1)->setShapeIdentifiersB(arg2,arg3); 6167 } 6168 6169 6170 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1Result_1addContactPoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jfloat jarg4) { 6171 btDiscreteCollisionDetectorInterface::Result *arg1 = (btDiscreteCollisionDetectorInterface::Result *) 0 ; 6172 btVector3 *arg2 = 0 ; 6173 btVector3 *arg3 = 0 ; 6174 btScalar arg4 ; 6175 6176 (void)jenv; 6177 (void)jcls; 6178 (void)jarg1_; 6179 arg1 = *(btDiscreteCollisionDetectorInterface::Result **)&jarg1; 6180 btVector3 local_arg2; 6181 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6182 arg2 = &local_arg2; 6183 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6184 btVector3 local_arg3; 6185 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 6186 arg3 = &local_arg3; 6187 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 6188 arg4 = (btScalar)jarg4; 6189 (arg1)->addContactPoint((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); 6190 } 6191 6192 6193 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btDiscreteCollisionDetectorInterface_1ClosestPointInput(JNIEnv *jenv, jclass jcls) { 6194 jlong jresult = 0 ; 6195 btDiscreteCollisionDetectorInterface::ClosestPointInput *result = 0 ; 6196 6197 (void)jenv; 6198 (void)jcls; 6199 result = (btDiscreteCollisionDetectorInterface::ClosestPointInput *)new btDiscreteCollisionDetectorInterface::ClosestPointInput(); 6200 *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&jresult = result; 6201 return jresult; 6202 } 6203 6204 6205 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1ClosestPointInput_1transformA_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6206 btDiscreteCollisionDetectorInterface::ClosestPointInput *arg1 = (btDiscreteCollisionDetectorInterface::ClosestPointInput *) 0 ; 6207 btTransform *arg2 = (btTransform *) 0 ; 6208 6209 (void)jenv; 6210 (void)jcls; 6211 (void)jarg1_; 6212 (void)jarg2_; 6213 arg1 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&jarg1; 6214 arg2 = *(btTransform **)&jarg2; 6215 if (arg1) (arg1)->m_transformA = *arg2; 6216 } 6217 6218 6219 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1ClosestPointInput_1transformA_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6220 jlong jresult = 0 ; 6221 btDiscreteCollisionDetectorInterface::ClosestPointInput *arg1 = (btDiscreteCollisionDetectorInterface::ClosestPointInput *) 0 ; 6222 btTransform *result = 0 ; 6223 6224 (void)jenv; 6225 (void)jcls; 6226 (void)jarg1_; 6227 arg1 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&jarg1; 6228 result = (btTransform *)& ((arg1)->m_transformA); 6229 *(btTransform **)&jresult = result; 6230 return jresult; 6231 } 6232 6233 6234 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1ClosestPointInput_1transformB_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6235 btDiscreteCollisionDetectorInterface::ClosestPointInput *arg1 = (btDiscreteCollisionDetectorInterface::ClosestPointInput *) 0 ; 6236 btTransform *arg2 = (btTransform *) 0 ; 6237 6238 (void)jenv; 6239 (void)jcls; 6240 (void)jarg1_; 6241 (void)jarg2_; 6242 arg1 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&jarg1; 6243 arg2 = *(btTransform **)&jarg2; 6244 if (arg1) (arg1)->m_transformB = *arg2; 6245 } 6246 6247 6248 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1ClosestPointInput_1transformB_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6249 jlong jresult = 0 ; 6250 btDiscreteCollisionDetectorInterface::ClosestPointInput *arg1 = (btDiscreteCollisionDetectorInterface::ClosestPointInput *) 0 ; 6251 btTransform *result = 0 ; 6252 6253 (void)jenv; 6254 (void)jcls; 6255 (void)jarg1_; 6256 arg1 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&jarg1; 6257 result = (btTransform *)& ((arg1)->m_transformB); 6258 *(btTransform **)&jresult = result; 6259 return jresult; 6260 } 6261 6262 6263 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1ClosestPointInput_1maximumDistanceSquared_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 6264 btDiscreteCollisionDetectorInterface::ClosestPointInput *arg1 = (btDiscreteCollisionDetectorInterface::ClosestPointInput *) 0 ; 6265 btScalar arg2 ; 6266 6267 (void)jenv; 6268 (void)jcls; 6269 (void)jarg1_; 6270 arg1 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&jarg1; 6271 arg2 = (btScalar)jarg2; 6272 if (arg1) (arg1)->m_maximumDistanceSquared = arg2; 6273 } 6274 6275 6276 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1ClosestPointInput_1maximumDistanceSquared_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6277 jfloat jresult = 0 ; 6278 btDiscreteCollisionDetectorInterface::ClosestPointInput *arg1 = (btDiscreteCollisionDetectorInterface::ClosestPointInput *) 0 ; 6279 btScalar result; 6280 6281 (void)jenv; 6282 (void)jcls; 6283 (void)jarg1_; 6284 arg1 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&jarg1; 6285 result = (btScalar) ((arg1)->m_maximumDistanceSquared); 6286 jresult = (jfloat)result; 6287 return jresult; 6288 } 6289 6290 6291 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btDiscreteCollisionDetectorInterface_1ClosestPointInput(JNIEnv *jenv, jclass jcls, jlong jarg1) { 6292 btDiscreteCollisionDetectorInterface::ClosestPointInput *arg1 = (btDiscreteCollisionDetectorInterface::ClosestPointInput *) 0 ; 6293 6294 (void)jenv; 6295 (void)jcls; 6296 arg1 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&jarg1; 6297 delete arg1; 6298 } 6299 6300 6301 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btDiscreteCollisionDetectorInterface(JNIEnv *jenv, jclass jcls, jlong jarg1) { 6302 btDiscreteCollisionDetectorInterface *arg1 = (btDiscreteCollisionDetectorInterface *) 0 ; 6303 6304 (void)jenv; 6305 (void)jcls; 6306 arg1 = *(btDiscreteCollisionDetectorInterface **)&jarg1; 6307 delete arg1; 6308 } 6309 6310 6311 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1getClosestPoints_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jboolean jarg5) { 6312 btDiscreteCollisionDetectorInterface *arg1 = (btDiscreteCollisionDetectorInterface *) 0 ; 6313 btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; 6314 btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; 6315 btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; 6316 bool arg5 ; 6317 6318 (void)jenv; 6319 (void)jcls; 6320 (void)jarg1_; 6321 (void)jarg2_; 6322 (void)jarg3_; 6323 (void)jarg4_; 6324 arg1 = *(btDiscreteCollisionDetectorInterface **)&jarg1; 6325 arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&jarg2; 6326 if (!arg2) { 6327 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btDiscreteCollisionDetectorInterface::ClosestPointInput const & reference is null"); 6328 return ; 6329 } 6330 arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&jarg3; 6331 if (!arg3) { 6332 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btDiscreteCollisionDetectorInterface::Result & reference is null"); 6333 return ; 6334 } 6335 arg4 = *(btIDebugDraw **)&jarg4; 6336 arg5 = jarg5 ? true : false; 6337 (arg1)->getClosestPoints((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4,arg5); 6338 } 6339 6340 6341 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btDiscreteCollisionDetectorInterface_1getClosestPoints_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) { 6342 btDiscreteCollisionDetectorInterface *arg1 = (btDiscreteCollisionDetectorInterface *) 0 ; 6343 btDiscreteCollisionDetectorInterface::ClosestPointInput *arg2 = 0 ; 6344 btDiscreteCollisionDetectorInterface::Result *arg3 = 0 ; 6345 btIDebugDraw *arg4 = (btIDebugDraw *) 0 ; 6346 6347 (void)jenv; 6348 (void)jcls; 6349 (void)jarg1_; 6350 (void)jarg2_; 6351 (void)jarg3_; 6352 (void)jarg4_; 6353 arg1 = *(btDiscreteCollisionDetectorInterface **)&jarg1; 6354 arg2 = *(btDiscreteCollisionDetectorInterface::ClosestPointInput **)&jarg2; 6355 if (!arg2) { 6356 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btDiscreteCollisionDetectorInterface::ClosestPointInput const & reference is null"); 6357 return ; 6358 } 6359 arg3 = *(btDiscreteCollisionDetectorInterface::Result **)&jarg3; 6360 if (!arg3) { 6361 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btDiscreteCollisionDetectorInterface::Result & reference is null"); 6362 return ; 6363 } 6364 arg4 = *(btIDebugDraw **)&jarg4; 6365 (arg1)->getClosestPoints((btDiscreteCollisionDetectorInterface::ClosestPointInput const &)*arg2,*arg3,arg4); 6366 } 6367 6368 6369 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btStorageResult_1normalOnSurfaceB_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6370 btStorageResult *arg1 = (btStorageResult *) 0 ; 6371 btVector3 *arg2 = (btVector3 *) 0 ; 6372 6373 (void)jenv; 6374 (void)jcls; 6375 (void)jarg1_; 6376 (void)jarg2_; 6377 arg1 = *(btStorageResult **)&jarg1; 6378 arg2 = *(btVector3 **)&jarg2; 6379 if (arg1) (arg1)->m_normalOnSurfaceB = *arg2; 6380 } 6381 6382 6383 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btStorageResult_1normalOnSurfaceB_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6384 jlong jresult = 0 ; 6385 btStorageResult *arg1 = (btStorageResult *) 0 ; 6386 btVector3 *result = 0 ; 6387 6388 (void)jenv; 6389 (void)jcls; 6390 (void)jarg1_; 6391 arg1 = *(btStorageResult **)&jarg1; 6392 result = (btVector3 *)& ((arg1)->m_normalOnSurfaceB); 6393 *(btVector3 **)&jresult = result; 6394 return jresult; 6395 } 6396 6397 6398 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btStorageResult_1closestPointInB_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6399 btStorageResult *arg1 = (btStorageResult *) 0 ; 6400 btVector3 *arg2 = (btVector3 *) 0 ; 6401 6402 (void)jenv; 6403 (void)jcls; 6404 (void)jarg1_; 6405 (void)jarg2_; 6406 arg1 = *(btStorageResult **)&jarg1; 6407 arg2 = *(btVector3 **)&jarg2; 6408 if (arg1) (arg1)->m_closestPointInB = *arg2; 6409 } 6410 6411 6412 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btStorageResult_1closestPointInB_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6413 jlong jresult = 0 ; 6414 btStorageResult *arg1 = (btStorageResult *) 0 ; 6415 btVector3 *result = 0 ; 6416 6417 (void)jenv; 6418 (void)jcls; 6419 (void)jarg1_; 6420 arg1 = *(btStorageResult **)&jarg1; 6421 result = (btVector3 *)& ((arg1)->m_closestPointInB); 6422 *(btVector3 **)&jresult = result; 6423 return jresult; 6424 } 6425 6426 6427 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btStorageResult_1distance_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 6428 btStorageResult *arg1 = (btStorageResult *) 0 ; 6429 btScalar arg2 ; 6430 6431 (void)jenv; 6432 (void)jcls; 6433 (void)jarg1_; 6434 arg1 = *(btStorageResult **)&jarg1; 6435 arg2 = (btScalar)jarg2; 6436 if (arg1) (arg1)->m_distance = arg2; 6437 } 6438 6439 6440 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btStorageResult_1distance_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6441 jfloat jresult = 0 ; 6442 btStorageResult *arg1 = (btStorageResult *) 0 ; 6443 btScalar result; 6444 6445 (void)jenv; 6446 (void)jcls; 6447 (void)jarg1_; 6448 arg1 = *(btStorageResult **)&jarg1; 6449 result = (btScalar) ((arg1)->m_distance); 6450 jresult = (jfloat)result; 6451 return jresult; 6452 } 6453 6454 6455 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btStorageResult(JNIEnv *jenv, jclass jcls, jlong jarg1) { 6456 btStorageResult *arg1 = (btStorageResult *) 0 ; 6457 6458 (void)jenv; 6459 (void)jcls; 6460 arg1 = *(btStorageResult **)&jarg1; 6461 delete arg1; 6462 } 6463 6464 6465 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1clientObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 6466 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6467 void *arg2 = (void *) 0 ; 6468 6469 (void)jenv; 6470 (void)jcls; 6471 (void)jarg1_; 6472 arg1 = *(btBroadphaseProxy **)&jarg1; 6473 arg2 = (void *)jarg2; 6474 if (arg1) (arg1)->m_clientObject = arg2; 6475 } 6476 6477 6478 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1clientObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6479 jlong jresult = 0 ; 6480 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6481 void *result = 0 ; 6482 6483 (void)jenv; 6484 (void)jcls; 6485 (void)jarg1_; 6486 arg1 = *(btBroadphaseProxy **)&jarg1; 6487 result = (void *) ((arg1)->m_clientObject); 6488 jresult = (jlong)result; 6489 return jresult; 6490 } 6491 6492 6493 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1collisionFilterGroup_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { 6494 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6495 short arg2 ; 6496 6497 (void)jenv; 6498 (void)jcls; 6499 (void)jarg1_; 6500 arg1 = *(btBroadphaseProxy **)&jarg1; 6501 arg2 = (short)jarg2; 6502 if (arg1) (arg1)->m_collisionFilterGroup = arg2; 6503 } 6504 6505 6506 SWIGEXPORT jshort JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1collisionFilterGroup_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6507 jshort jresult = 0 ; 6508 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6509 short result; 6510 6511 (void)jenv; 6512 (void)jcls; 6513 (void)jarg1_; 6514 arg1 = *(btBroadphaseProxy **)&jarg1; 6515 result = (short) ((arg1)->m_collisionFilterGroup); 6516 jresult = (jshort)result; 6517 return jresult; 6518 } 6519 6520 6521 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1collisionFilterMask_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { 6522 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6523 short arg2 ; 6524 6525 (void)jenv; 6526 (void)jcls; 6527 (void)jarg1_; 6528 arg1 = *(btBroadphaseProxy **)&jarg1; 6529 arg2 = (short)jarg2; 6530 if (arg1) (arg1)->m_collisionFilterMask = arg2; 6531 } 6532 6533 6534 SWIGEXPORT jshort JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1collisionFilterMask_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6535 jshort jresult = 0 ; 6536 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6537 short result; 6538 6539 (void)jenv; 6540 (void)jcls; 6541 (void)jarg1_; 6542 arg1 = *(btBroadphaseProxy **)&jarg1; 6543 result = (short) ((arg1)->m_collisionFilterMask); 6544 jresult = (jshort)result; 6545 return jresult; 6546 } 6547 6548 6549 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1multiSapParentProxy_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 6550 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6551 void *arg2 = (void *) 0 ; 6552 6553 (void)jenv; 6554 (void)jcls; 6555 (void)jarg1_; 6556 arg1 = *(btBroadphaseProxy **)&jarg1; 6557 arg2 = (void *)jarg2; 6558 if (arg1) (arg1)->m_multiSapParentProxy = arg2; 6559 } 6560 6561 6562 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1multiSapParentProxy_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6563 jlong jresult = 0 ; 6564 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6565 void *result = 0 ; 6566 6567 (void)jenv; 6568 (void)jcls; 6569 (void)jarg1_; 6570 arg1 = *(btBroadphaseProxy **)&jarg1; 6571 result = (void *) ((arg1)->m_multiSapParentProxy); 6572 jresult = (jlong)result; 6573 return jresult; 6574 } 6575 6576 6577 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1uniqueId_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 6578 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6579 int arg2 ; 6580 6581 (void)jenv; 6582 (void)jcls; 6583 (void)jarg1_; 6584 arg1 = *(btBroadphaseProxy **)&jarg1; 6585 arg2 = (int)jarg2; 6586 if (arg1) (arg1)->m_uniqueId = arg2; 6587 } 6588 6589 6590 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1uniqueId_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6591 jint jresult = 0 ; 6592 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6593 int result; 6594 6595 (void)jenv; 6596 (void)jcls; 6597 (void)jarg1_; 6598 arg1 = *(btBroadphaseProxy **)&jarg1; 6599 result = (int) ((arg1)->m_uniqueId); 6600 jresult = (jint)result; 6601 return jresult; 6602 } 6603 6604 6605 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1aabbMin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6606 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6607 btVector3 *arg2 = (btVector3 *) 0 ; 6608 6609 (void)jenv; 6610 (void)jcls; 6611 (void)jarg1_; 6612 (void)jarg2_; 6613 arg1 = *(btBroadphaseProxy **)&jarg1; 6614 arg2 = *(btVector3 **)&jarg2; 6615 if (arg1) (arg1)->m_aabbMin = *arg2; 6616 } 6617 6618 6619 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1aabbMin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6620 jlong jresult = 0 ; 6621 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6622 btVector3 *result = 0 ; 6623 6624 (void)jenv; 6625 (void)jcls; 6626 (void)jarg1_; 6627 arg1 = *(btBroadphaseProxy **)&jarg1; 6628 result = (btVector3 *)& ((arg1)->m_aabbMin); 6629 *(btVector3 **)&jresult = result; 6630 return jresult; 6631 } 6632 6633 6634 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1aabbMax_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6635 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6636 btVector3 *arg2 = (btVector3 *) 0 ; 6637 6638 (void)jenv; 6639 (void)jcls; 6640 (void)jarg1_; 6641 (void)jarg2_; 6642 arg1 = *(btBroadphaseProxy **)&jarg1; 6643 arg2 = *(btVector3 **)&jarg2; 6644 if (arg1) (arg1)->m_aabbMax = *arg2; 6645 } 6646 6647 6648 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1aabbMax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6649 jlong jresult = 0 ; 6650 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6651 btVector3 *result = 0 ; 6652 6653 (void)jenv; 6654 (void)jcls; 6655 (void)jarg1_; 6656 arg1 = *(btBroadphaseProxy **)&jarg1; 6657 result = (btVector3 *)& ((arg1)->m_aabbMax); 6658 *(btVector3 **)&jresult = result; 6659 return jresult; 6660 } 6661 6662 6663 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1getUid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6664 jint jresult = 0 ; 6665 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6666 int result; 6667 6668 (void)jenv; 6669 (void)jcls; 6670 (void)jarg1_; 6671 arg1 = *(btBroadphaseProxy **)&jarg1; 6672 result = (int)((btBroadphaseProxy const *)arg1)->getUid(); 6673 jresult = (jint)result; 6674 return jresult; 6675 } 6676 6677 6678 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBroadphaseProxy_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 6679 jlong jresult = 0 ; 6680 btBroadphaseProxy *result = 0 ; 6681 6682 (void)jenv; 6683 (void)jcls; 6684 result = (btBroadphaseProxy *)new btBroadphaseProxy(); 6685 *(btBroadphaseProxy **)&jresult = result; 6686 return jresult; 6687 } 6688 6689 6690 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBroadphaseProxy_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3, jshort jarg4, jshort jarg5, jlong jarg6) { 6691 jlong jresult = 0 ; 6692 btVector3 *arg1 = 0 ; 6693 btVector3 *arg2 = 0 ; 6694 void *arg3 = (void *) 0 ; 6695 short arg4 ; 6696 short arg5 ; 6697 void *arg6 = (void *) 0 ; 6698 btBroadphaseProxy *result = 0 ; 6699 6700 (void)jenv; 6701 (void)jcls; 6702 btVector3 local_arg1; 6703 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6704 arg1 = &local_arg1; 6705 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6706 btVector3 local_arg2; 6707 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6708 arg2 = &local_arg2; 6709 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6710 arg3 = (void *)jarg3; 6711 arg4 = (short)jarg4; 6712 arg5 = (short)jarg5; 6713 arg6 = (void *)jarg6; 6714 result = (btBroadphaseProxy *)new btBroadphaseProxy((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5,arg6); 6715 *(btBroadphaseProxy **)&jresult = result; 6716 return jresult; 6717 } 6718 6719 6720 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBroadphaseProxy_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3, jshort jarg4, jshort jarg5) { 6721 jlong jresult = 0 ; 6722 btVector3 *arg1 = 0 ; 6723 btVector3 *arg2 = 0 ; 6724 void *arg3 = (void *) 0 ; 6725 short arg4 ; 6726 short arg5 ; 6727 btBroadphaseProxy *result = 0 ; 6728 6729 (void)jenv; 6730 (void)jcls; 6731 btVector3 local_arg1; 6732 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 6733 arg1 = &local_arg1; 6734 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 6735 btVector3 local_arg2; 6736 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 6737 arg2 = &local_arg2; 6738 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 6739 arg3 = (void *)jarg3; 6740 arg4 = (short)jarg4; 6741 arg5 = (short)jarg5; 6742 result = (btBroadphaseProxy *)new btBroadphaseProxy((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5); 6743 *(btBroadphaseProxy **)&jresult = result; 6744 return jresult; 6745 } 6746 6747 6748 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1isPolyhedral(JNIEnv *jenv, jclass jcls, jint jarg1) { 6749 jboolean jresult = 0 ; 6750 int arg1 ; 6751 bool result; 6752 6753 (void)jenv; 6754 (void)jcls; 6755 arg1 = (int)jarg1; 6756 result = (bool)btBroadphaseProxy::isPolyhedral(arg1); 6757 jresult = (jboolean)result; 6758 return jresult; 6759 } 6760 6761 6762 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1isConvex(JNIEnv *jenv, jclass jcls, jint jarg1) { 6763 jboolean jresult = 0 ; 6764 int arg1 ; 6765 bool result; 6766 6767 (void)jenv; 6768 (void)jcls; 6769 arg1 = (int)jarg1; 6770 result = (bool)btBroadphaseProxy::isConvex(arg1); 6771 jresult = (jboolean)result; 6772 return jresult; 6773 } 6774 6775 6776 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1isNonMoving(JNIEnv *jenv, jclass jcls, jint jarg1) { 6777 jboolean jresult = 0 ; 6778 int arg1 ; 6779 bool result; 6780 6781 (void)jenv; 6782 (void)jcls; 6783 arg1 = (int)jarg1; 6784 result = (bool)btBroadphaseProxy::isNonMoving(arg1); 6785 jresult = (jboolean)result; 6786 return jresult; 6787 } 6788 6789 6790 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1isConcave(JNIEnv *jenv, jclass jcls, jint jarg1) { 6791 jboolean jresult = 0 ; 6792 int arg1 ; 6793 bool result; 6794 6795 (void)jenv; 6796 (void)jcls; 6797 arg1 = (int)jarg1; 6798 result = (bool)btBroadphaseProxy::isConcave(arg1); 6799 jresult = (jboolean)result; 6800 return jresult; 6801 } 6802 6803 6804 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1isCompound(JNIEnv *jenv, jclass jcls, jint jarg1) { 6805 jboolean jresult = 0 ; 6806 int arg1 ; 6807 bool result; 6808 6809 (void)jenv; 6810 (void)jcls; 6811 arg1 = (int)jarg1; 6812 result = (bool)btBroadphaseProxy::isCompound(arg1); 6813 jresult = (jboolean)result; 6814 return jresult; 6815 } 6816 6817 6818 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1isSoftBody(JNIEnv *jenv, jclass jcls, jint jarg1) { 6819 jboolean jresult = 0 ; 6820 int arg1 ; 6821 bool result; 6822 6823 (void)jenv; 6824 (void)jcls; 6825 arg1 = (int)jarg1; 6826 result = (bool)btBroadphaseProxy::isSoftBody(arg1); 6827 jresult = (jboolean)result; 6828 return jresult; 6829 } 6830 6831 6832 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1isInfinite(JNIEnv *jenv, jclass jcls, jint jarg1) { 6833 jboolean jresult = 0 ; 6834 int arg1 ; 6835 bool result; 6836 6837 (void)jenv; 6838 (void)jcls; 6839 arg1 = (int)jarg1; 6840 result = (bool)btBroadphaseProxy::isInfinite(arg1); 6841 jresult = (jboolean)result; 6842 return jresult; 6843 } 6844 6845 6846 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseProxy_1isConvex2d(JNIEnv *jenv, jclass jcls, jint jarg1) { 6847 jboolean jresult = 0 ; 6848 int arg1 ; 6849 bool result; 6850 6851 (void)jenv; 6852 (void)jcls; 6853 arg1 = (int)jarg1; 6854 result = (bool)btBroadphaseProxy::isConvex2d(arg1); 6855 jresult = (jboolean)result; 6856 return jresult; 6857 } 6858 6859 6860 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btBroadphaseProxy(JNIEnv *jenv, jclass jcls, jlong jarg1) { 6861 btBroadphaseProxy *arg1 = (btBroadphaseProxy *) 0 ; 6862 6863 (void)jenv; 6864 (void)jcls; 6865 arg1 = *(btBroadphaseProxy **)&jarg1; 6866 delete arg1; 6867 } 6868 6869 6870 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBroadphasePair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 6871 jlong jresult = 0 ; 6872 btBroadphasePair *result = 0 ; 6873 6874 (void)jenv; 6875 (void)jcls; 6876 result = (btBroadphasePair *)new btBroadphasePair(); 6877 *(btBroadphasePair **)&jresult = result; 6878 return jresult; 6879 } 6880 6881 6882 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBroadphasePair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1) { 6883 jlong jresult = 0 ; 6884 btBroadphasePair *arg1 = 0 ; 6885 btBroadphasePair *result = 0 ; 6886 6887 (void)jenv; 6888 (void)jcls; 6889 arg1 = *(btBroadphasePair **)&jarg1; 6890 if (!arg1) { 6891 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphasePair const & reference is null"); 6892 return 0; 6893 } 6894 result = (btBroadphasePair *)new btBroadphasePair((btBroadphasePair const &)*arg1); 6895 *(btBroadphasePair **)&jresult = result; 6896 return jresult; 6897 } 6898 6899 6900 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBroadphasePair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 6901 jlong jresult = 0 ; 6902 btBroadphaseProxy *arg1 = 0 ; 6903 btBroadphaseProxy *arg2 = 0 ; 6904 btBroadphasePair *result = 0 ; 6905 6906 (void)jenv; 6907 (void)jcls; 6908 arg1 = *(btBroadphaseProxy **)&jarg1; 6909 if (!arg1) { 6910 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseProxy & reference is null"); 6911 return 0; 6912 } 6913 arg2 = *(btBroadphaseProxy **)&jarg2; 6914 if (!arg2) { 6915 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseProxy & reference is null"); 6916 return 0; 6917 } 6918 result = (btBroadphasePair *)new btBroadphasePair(*arg1,*arg2); 6919 *(btBroadphasePair **)&jresult = result; 6920 return jresult; 6921 } 6922 6923 6924 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphasePair_1pProxy0_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6925 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 6926 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 6927 6928 (void)jenv; 6929 (void)jcls; 6930 (void)jarg1_; 6931 (void)jarg2_; 6932 arg1 = *(btBroadphasePair **)&jarg1; 6933 arg2 = *(btBroadphaseProxy **)&jarg2; 6934 if (arg1) (arg1)->m_pProxy0 = arg2; 6935 } 6936 6937 6938 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphasePair_1pProxy0_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6939 jlong jresult = 0 ; 6940 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 6941 btBroadphaseProxy *result = 0 ; 6942 6943 (void)jenv; 6944 (void)jcls; 6945 (void)jarg1_; 6946 arg1 = *(btBroadphasePair **)&jarg1; 6947 result = (btBroadphaseProxy *) ((arg1)->m_pProxy0); 6948 *(btBroadphaseProxy **)&jresult = result; 6949 return jresult; 6950 } 6951 6952 6953 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphasePair_1pProxy1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6954 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 6955 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 6956 6957 (void)jenv; 6958 (void)jcls; 6959 (void)jarg1_; 6960 (void)jarg2_; 6961 arg1 = *(btBroadphasePair **)&jarg1; 6962 arg2 = *(btBroadphaseProxy **)&jarg2; 6963 if (arg1) (arg1)->m_pProxy1 = arg2; 6964 } 6965 6966 6967 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphasePair_1pProxy1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6968 jlong jresult = 0 ; 6969 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 6970 btBroadphaseProxy *result = 0 ; 6971 6972 (void)jenv; 6973 (void)jcls; 6974 (void)jarg1_; 6975 arg1 = *(btBroadphasePair **)&jarg1; 6976 result = (btBroadphaseProxy *) ((arg1)->m_pProxy1); 6977 *(btBroadphaseProxy **)&jresult = result; 6978 return jresult; 6979 } 6980 6981 6982 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphasePair_1algorithm_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 6983 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 6984 btCollisionAlgorithm *arg2 = (btCollisionAlgorithm *) 0 ; 6985 6986 (void)jenv; 6987 (void)jcls; 6988 (void)jarg1_; 6989 (void)jarg2_; 6990 arg1 = *(btBroadphasePair **)&jarg1; 6991 arg2 = *(btCollisionAlgorithm **)&jarg2; 6992 if (arg1) (arg1)->m_algorithm = arg2; 6993 } 6994 6995 6996 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphasePair_1algorithm_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6997 jlong jresult = 0 ; 6998 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 6999 btCollisionAlgorithm *result = 0 ; 7000 7001 (void)jenv; 7002 (void)jcls; 7003 (void)jarg1_; 7004 arg1 = *(btBroadphasePair **)&jarg1; 7005 result = (btCollisionAlgorithm *) ((arg1)->m_algorithm); 7006 *(btCollisionAlgorithm **)&jresult = result; 7007 return jresult; 7008 } 7009 7010 7011 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphasePair_1internalInfo1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 7012 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 7013 void *arg2 = (void *) 0 ; 7014 7015 (void)jenv; 7016 (void)jcls; 7017 (void)jarg1_; 7018 arg1 = *(btBroadphasePair **)&jarg1; 7019 arg2 = (void *)jarg2; 7020 if (arg1) (arg1)->m_internalInfo1 = arg2; 7021 } 7022 7023 7024 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphasePair_1internalInfo1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7025 jlong jresult = 0 ; 7026 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 7027 void *result = 0 ; 7028 7029 (void)jenv; 7030 (void)jcls; 7031 (void)jarg1_; 7032 arg1 = *(btBroadphasePair **)&jarg1; 7033 result = (void *) ((arg1)->m_internalInfo1); 7034 jresult = (jlong)result; 7035 return jresult; 7036 } 7037 7038 7039 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphasePair_1internalTmpValue_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 7040 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 7041 int arg2 ; 7042 7043 (void)jenv; 7044 (void)jcls; 7045 (void)jarg1_; 7046 arg1 = *(btBroadphasePair **)&jarg1; 7047 arg2 = (int)jarg2; 7048 if (arg1) (arg1)->m_internalTmpValue = arg2; 7049 } 7050 7051 7052 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphasePair_1internalTmpValue_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7053 jint jresult = 0 ; 7054 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 7055 int result; 7056 7057 (void)jenv; 7058 (void)jcls; 7059 (void)jarg1_; 7060 arg1 = *(btBroadphasePair **)&jarg1; 7061 result = (int) ((arg1)->m_internalTmpValue); 7062 jresult = (jint)result; 7063 return jresult; 7064 } 7065 7066 7067 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btBroadphasePair(JNIEnv *jenv, jclass jcls, jlong jarg1) { 7068 btBroadphasePair *arg1 = (btBroadphasePair *) 0 ; 7069 7070 (void)jenv; 7071 (void)jcls; 7072 arg1 = *(btBroadphasePair **)&jarg1; 7073 delete arg1; 7074 } 7075 7076 7077 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBroadphasePairSortPredicate(JNIEnv *jenv, jclass jcls) { 7078 jlong jresult = 0 ; 7079 btBroadphasePairSortPredicate *result = 0 ; 7080 7081 (void)jenv; 7082 (void)jcls; 7083 result = (btBroadphasePairSortPredicate *)new btBroadphasePairSortPredicate(); 7084 *(btBroadphasePairSortPredicate **)&jresult = result; 7085 return jresult; 7086 } 7087 7088 7089 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btBroadphasePairSortPredicate(JNIEnv *jenv, jclass jcls, jlong jarg1) { 7090 btBroadphasePairSortPredicate *arg1 = (btBroadphasePairSortPredicate *) 0 ; 7091 7092 (void)jenv; 7093 (void)jcls; 7094 arg1 = *(btBroadphasePairSortPredicate **)&jarg1; 7095 delete arg1; 7096 } 7097 7098 7099 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btBroadphaseAabbCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) { 7100 btBroadphaseAabbCallback *arg1 = (btBroadphaseAabbCallback *) 0 ; 7101 7102 (void)jenv; 7103 (void)jcls; 7104 arg1 = *(btBroadphaseAabbCallback **)&jarg1; 7105 delete arg1; 7106 } 7107 7108 7109 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseAabbCallback_1process(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 7110 jboolean jresult = 0 ; 7111 btBroadphaseAabbCallback *arg1 = (btBroadphaseAabbCallback *) 0 ; 7112 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 7113 bool result; 7114 7115 (void)jenv; 7116 (void)jcls; 7117 (void)jarg1_; 7118 (void)jarg2_; 7119 arg1 = *(btBroadphaseAabbCallback **)&jarg1; 7120 arg2 = *(btBroadphaseProxy **)&jarg2; 7121 result = (bool)(arg1)->process((btBroadphaseProxy const *)arg2); 7122 jresult = (jboolean)result; 7123 return jresult; 7124 } 7125 7126 7127 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBroadphaseAabbCallback(JNIEnv *jenv, jclass jcls) { 7128 jlong jresult = 0 ; 7129 btBroadphaseAabbCallback *result = 0 ; 7130 7131 (void)jenv; 7132 (void)jcls; 7133 result = (btBroadphaseAabbCallback *)new SwigDirector_btBroadphaseAabbCallback(jenv); 7134 *(btBroadphaseAabbCallback **)&jresult = result; 7135 return jresult; 7136 } 7137 7138 7139 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseAabbCallback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { 7140 btBroadphaseAabbCallback *obj = *((btBroadphaseAabbCallback **)&objarg); 7141 (void)jcls; 7142 SwigDirector_btBroadphaseAabbCallback *director = (SwigDirector_btBroadphaseAabbCallback *)(obj); 7143 if (director) { 7144 director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); 7145 } 7146 } 7147 7148 7149 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseAabbCallback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { 7150 btBroadphaseAabbCallback *obj = *((btBroadphaseAabbCallback **)&objarg); 7151 SwigDirector_btBroadphaseAabbCallback *director = (SwigDirector_btBroadphaseAabbCallback *)(obj); 7152 (void)jcls; 7153 if (director) { 7154 director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); 7155 } 7156 } 7157 7158 7159 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseRayCallback_1rayDirectionInverse_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 7160 btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; 7161 btVector3 *arg2 = (btVector3 *) 0 ; 7162 7163 (void)jenv; 7164 (void)jcls; 7165 (void)jarg1_; 7166 (void)jarg2_; 7167 arg1 = *(btBroadphaseRayCallback **)&jarg1; 7168 arg2 = *(btVector3 **)&jarg2; 7169 if (arg1) (arg1)->m_rayDirectionInverse = *arg2; 7170 } 7171 7172 7173 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseRayCallback_1rayDirectionInverse_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7174 jlong jresult = 0 ; 7175 btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; 7176 btVector3 *result = 0 ; 7177 7178 (void)jenv; 7179 (void)jcls; 7180 (void)jarg1_; 7181 arg1 = *(btBroadphaseRayCallback **)&jarg1; 7182 result = (btVector3 *)& ((arg1)->m_rayDirectionInverse); 7183 *(btVector3 **)&jresult = result; 7184 return jresult; 7185 } 7186 7187 7188 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseRayCallback_1signs_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2) { 7189 btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; 7190 unsigned int *arg2 ; 7191 jlong *jarr2 ; 7192 7193 (void)jenv; 7194 (void)jcls; 7195 (void)jarg1_; 7196 arg1 = *(btBroadphaseRayCallback **)&jarg1; 7197 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 7198 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 7199 return ; 7200 } 7201 if (!SWIG_JavaArrayInUint(jenv, &jarr2, (unsigned int **)&arg2, jarg2)) return ; 7202 { 7203 size_t ii; 7204 unsigned int *b = (unsigned int *) arg1->m_signs; 7205 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned int *) arg2 + ii); 7206 } 7207 SWIG_JavaArrayArgoutUint(jenv, jarr2, (unsigned int *)arg2, jarg2); 7208 delete [] arg2; 7209 } 7210 7211 7212 SWIGEXPORT jlongArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseRayCallback_1signs_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7213 jlongArray jresult = 0 ; 7214 btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; 7215 unsigned int *result = 0 ; 7216 7217 (void)jenv; 7218 (void)jcls; 7219 (void)jarg1_; 7220 arg1 = *(btBroadphaseRayCallback **)&jarg1; 7221 result = (unsigned int *)(unsigned int *) ((arg1)->m_signs); 7222 jresult = SWIG_JavaArrayOutUint(jenv, (unsigned int *)result, 3); 7223 return jresult; 7224 } 7225 7226 7227 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseRayCallback_1lambda_1max_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { 7228 btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; 7229 btScalar arg2 ; 7230 7231 (void)jenv; 7232 (void)jcls; 7233 (void)jarg1_; 7234 arg1 = *(btBroadphaseRayCallback **)&jarg1; 7235 arg2 = (btScalar)jarg2; 7236 if (arg1) (arg1)->m_lambda_max = arg2; 7237 } 7238 7239 7240 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseRayCallback_1lambda_1max_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7241 jfloat jresult = 0 ; 7242 btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; 7243 btScalar result; 7244 7245 (void)jenv; 7246 (void)jcls; 7247 (void)jarg1_; 7248 arg1 = *(btBroadphaseRayCallback **)&jarg1; 7249 result = (btScalar) ((arg1)->m_lambda_max); 7250 jresult = (jfloat)result; 7251 return jresult; 7252 } 7253 7254 7255 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btBroadphaseRayCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) { 7256 btBroadphaseRayCallback *arg1 = (btBroadphaseRayCallback *) 0 ; 7257 7258 (void)jenv; 7259 (void)jcls; 7260 arg1 = *(btBroadphaseRayCallback **)&jarg1; 7261 delete arg1; 7262 } 7263 7264 7265 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBroadphaseRayCallback(JNIEnv *jenv, jclass jcls) { 7266 jlong jresult = 0 ; 7267 btBroadphaseRayCallback *result = 0 ; 7268 7269 (void)jenv; 7270 (void)jcls; 7271 result = (btBroadphaseRayCallback *)new SwigDirector_btBroadphaseRayCallback(jenv); 7272 *(btBroadphaseRayCallback **)&jresult = result; 7273 return jresult; 7274 } 7275 7276 7277 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseRayCallback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { 7278 btBroadphaseRayCallback *obj = *((btBroadphaseRayCallback **)&objarg); 7279 (void)jcls; 7280 SwigDirector_btBroadphaseRayCallback *director = (SwigDirector_btBroadphaseRayCallback *)(obj); 7281 if (director) { 7282 director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); 7283 } 7284 } 7285 7286 7287 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseRayCallback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { 7288 btBroadphaseRayCallback *obj = *((btBroadphaseRayCallback **)&objarg); 7289 SwigDirector_btBroadphaseRayCallback *director = (SwigDirector_btBroadphaseRayCallback *)(obj); 7290 (void)jcls; 7291 if (director) { 7292 director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); 7293 } 7294 } 7295 7296 7297 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btBroadphaseInterface(JNIEnv *jenv, jclass jcls, jlong jarg1) { 7298 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7299 7300 (void)jenv; 7301 (void)jcls; 7302 arg1 = *(btBroadphaseInterface **)&jarg1; 7303 delete arg1; 7304 } 7305 7306 7307 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1createProxy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jint jarg4, jlong jarg5, jshort jarg6, jshort jarg7, jlong jarg8, jobject jarg8_, jlong jarg9) { 7308 jlong jresult = 0 ; 7309 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7310 btVector3 *arg2 = 0 ; 7311 btVector3 *arg3 = 0 ; 7312 int arg4 ; 7313 void *arg5 = (void *) 0 ; 7314 short arg6 ; 7315 short arg7 ; 7316 btDispatcher *arg8 = (btDispatcher *) 0 ; 7317 void *arg9 = (void *) 0 ; 7318 btBroadphaseProxy *result = 0 ; 7319 7320 (void)jenv; 7321 (void)jcls; 7322 (void)jarg1_; 7323 (void)jarg8_; 7324 arg1 = *(btBroadphaseInterface **)&jarg1; 7325 btVector3 local_arg2; 7326 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7327 arg2 = &local_arg2; 7328 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7329 btVector3 local_arg3; 7330 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7331 arg3 = &local_arg3; 7332 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7333 arg4 = (int)jarg4; 7334 arg5 = (void *)jarg5; 7335 arg6 = (short)jarg6; 7336 arg7 = (short)jarg7; 7337 arg8 = *(btDispatcher **)&jarg8; 7338 arg9 = (void *)jarg9; 7339 result = (btBroadphaseProxy *)(arg1)->createProxy((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9); 7340 *(btBroadphaseProxy **)&jresult = result; 7341 return jresult; 7342 } 7343 7344 7345 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1destroyProxy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) { 7346 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7347 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 7348 btDispatcher *arg3 = (btDispatcher *) 0 ; 7349 7350 (void)jenv; 7351 (void)jcls; 7352 (void)jarg1_; 7353 (void)jarg2_; 7354 (void)jarg3_; 7355 arg1 = *(btBroadphaseInterface **)&jarg1; 7356 arg2 = *(btBroadphaseProxy **)&jarg2; 7357 arg3 = *(btDispatcher **)&jarg3; 7358 (arg1)->destroyProxy(arg2,arg3); 7359 } 7360 7361 7362 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1setAabb(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4, jlong jarg5, jobject jarg5_) { 7363 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7364 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 7365 btVector3 *arg3 = 0 ; 7366 btVector3 *arg4 = 0 ; 7367 btDispatcher *arg5 = (btDispatcher *) 0 ; 7368 7369 (void)jenv; 7370 (void)jcls; 7371 (void)jarg1_; 7372 (void)jarg2_; 7373 (void)jarg5_; 7374 arg1 = *(btBroadphaseInterface **)&jarg1; 7375 arg2 = *(btBroadphaseProxy **)&jarg2; 7376 btVector3 local_arg3; 7377 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7378 arg3 = &local_arg3; 7379 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7380 btVector3 local_arg4; 7381 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7382 arg4 = &local_arg4; 7383 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7384 arg5 = *(btDispatcher **)&jarg5; 7385 (arg1)->setAabb(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5); 7386 } 7387 7388 7389 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1getAabb(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4) { 7390 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7391 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 7392 btVector3 *arg3 = 0 ; 7393 btVector3 *arg4 = 0 ; 7394 7395 (void)jenv; 7396 (void)jcls; 7397 (void)jarg1_; 7398 (void)jarg2_; 7399 arg1 = *(btBroadphaseInterface **)&jarg1; 7400 arg2 = *(btBroadphaseProxy **)&jarg2; 7401 btVector3 local_arg3; 7402 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7403 arg3 = &local_arg3; 7404 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7405 btVector3 local_arg4; 7406 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 7407 arg4 = &local_arg4; 7408 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 7409 ((btBroadphaseInterface const *)arg1)->getAabb(arg2,*arg3,*arg4); 7410 } 7411 7412 7413 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1rayTest_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jobject jarg5, jobject jarg6) { 7414 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7415 btVector3 *arg2 = 0 ; 7416 btVector3 *arg3 = 0 ; 7417 btBroadphaseRayCallback *arg4 = 0 ; 7418 btVector3 *arg5 = 0 ; 7419 btVector3 *arg6 = 0 ; 7420 7421 (void)jenv; 7422 (void)jcls; 7423 (void)jarg1_; 7424 (void)jarg4_; 7425 arg1 = *(btBroadphaseInterface **)&jarg1; 7426 btVector3 local_arg2; 7427 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7428 arg2 = &local_arg2; 7429 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7430 btVector3 local_arg3; 7431 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7432 arg3 = &local_arg3; 7433 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7434 arg4 = *(btBroadphaseRayCallback **)&jarg4; 7435 if (!arg4) { 7436 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 7437 return ; 7438 } 7439 btVector3 local_arg5; 7440 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 7441 arg5 = &local_arg5; 7442 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 7443 btVector3 local_arg6; 7444 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 7445 arg6 = &local_arg6; 7446 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 7447 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); 7448 } 7449 7450 7451 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1rayTest_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jobject jarg5) { 7452 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7453 btVector3 *arg2 = 0 ; 7454 btVector3 *arg3 = 0 ; 7455 btBroadphaseRayCallback *arg4 = 0 ; 7456 btVector3 *arg5 = 0 ; 7457 7458 (void)jenv; 7459 (void)jcls; 7460 (void)jarg1_; 7461 (void)jarg4_; 7462 arg1 = *(btBroadphaseInterface **)&jarg1; 7463 btVector3 local_arg2; 7464 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7465 arg2 = &local_arg2; 7466 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7467 btVector3 local_arg3; 7468 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7469 arg3 = &local_arg3; 7470 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7471 arg4 = *(btBroadphaseRayCallback **)&jarg4; 7472 if (!arg4) { 7473 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 7474 return ; 7475 } 7476 btVector3 local_arg5; 7477 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 7478 arg5 = &local_arg5; 7479 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 7480 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5); 7481 } 7482 7483 7484 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1rayTest_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_) { 7485 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7486 btVector3 *arg2 = 0 ; 7487 btVector3 *arg3 = 0 ; 7488 btBroadphaseRayCallback *arg4 = 0 ; 7489 7490 (void)jenv; 7491 (void)jcls; 7492 (void)jarg1_; 7493 (void)jarg4_; 7494 arg1 = *(btBroadphaseInterface **)&jarg1; 7495 btVector3 local_arg2; 7496 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7497 arg2 = &local_arg2; 7498 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7499 btVector3 local_arg3; 7500 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7501 arg3 = &local_arg3; 7502 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7503 arg4 = *(btBroadphaseRayCallback **)&jarg4; 7504 if (!arg4) { 7505 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 7506 return ; 7507 } 7508 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); 7509 } 7510 7511 7512 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1aabbTest(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_) { 7513 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7514 btVector3 *arg2 = 0 ; 7515 btVector3 *arg3 = 0 ; 7516 btBroadphaseAabbCallback *arg4 = 0 ; 7517 7518 (void)jenv; 7519 (void)jcls; 7520 (void)jarg1_; 7521 (void)jarg4_; 7522 arg1 = *(btBroadphaseInterface **)&jarg1; 7523 btVector3 local_arg2; 7524 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7525 arg2 = &local_arg2; 7526 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7527 btVector3 local_arg3; 7528 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7529 arg3 = &local_arg3; 7530 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7531 arg4 = *(btBroadphaseAabbCallback **)&jarg4; 7532 if (!arg4) { 7533 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseAabbCallback & reference is null"); 7534 return ; 7535 } 7536 (arg1)->aabbTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); 7537 } 7538 7539 7540 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1calculateOverlappingPairs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 7541 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7542 btDispatcher *arg2 = (btDispatcher *) 0 ; 7543 7544 (void)jenv; 7545 (void)jcls; 7546 (void)jarg1_; 7547 (void)jarg2_; 7548 arg1 = *(btBroadphaseInterface **)&jarg1; 7549 arg2 = *(btDispatcher **)&jarg2; 7550 (arg1)->calculateOverlappingPairs(arg2); 7551 } 7552 7553 7554 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1getOverlappingPairCache_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7555 jlong jresult = 0 ; 7556 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7557 btOverlappingPairCache *result = 0 ; 7558 7559 (void)jenv; 7560 (void)jcls; 7561 (void)jarg1_; 7562 arg1 = *(btBroadphaseInterface **)&jarg1; 7563 result = (btOverlappingPairCache *)(arg1)->getOverlappingPairCache(); 7564 *(btOverlappingPairCache **)&jresult = result; 7565 return jresult; 7566 } 7567 7568 7569 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1getBroadphaseAabb(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { 7570 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7571 btVector3 *arg2 = 0 ; 7572 btVector3 *arg3 = 0 ; 7573 7574 (void)jenv; 7575 (void)jcls; 7576 (void)jarg1_; 7577 arg1 = *(btBroadphaseInterface **)&jarg1; 7578 btVector3 local_arg2; 7579 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 7580 arg2 = &local_arg2; 7581 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 7582 btVector3 local_arg3; 7583 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 7584 arg3 = &local_arg3; 7585 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 7586 ((btBroadphaseInterface const *)arg1)->getBroadphaseAabb(*arg2,*arg3); 7587 } 7588 7589 7590 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1resetPool(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 7591 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7592 btDispatcher *arg2 = (btDispatcher *) 0 ; 7593 7594 (void)jenv; 7595 (void)jcls; 7596 (void)jarg1_; 7597 (void)jarg2_; 7598 arg1 = *(btBroadphaseInterface **)&jarg1; 7599 arg2 = *(btDispatcher **)&jarg2; 7600 (arg1)->resetPool(arg2); 7601 } 7602 7603 7604 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBroadphaseInterface_1printStats(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7605 btBroadphaseInterface *arg1 = (btBroadphaseInterface *) 0 ; 7606 7607 (void)jenv; 7608 (void)jcls; 7609 (void)jarg1_; 7610 arg1 = *(btBroadphaseInterface **)&jarg1; 7611 (arg1)->printStats(); 7612 } 7613 7614 7615 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNode_1quantizedAabbMin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 7616 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7617 unsigned short *arg2 ; 7618 jint *jarr2 ; 7619 7620 (void)jenv; 7621 (void)jcls; 7622 (void)jarg1_; 7623 arg1 = *(btQuantizedBvhNode **)&jarg1; 7624 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 7625 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 7626 return ; 7627 } 7628 if (!SWIG_JavaArrayInUshort(jenv, &jarr2, (unsigned short **)&arg2, jarg2)) return ; 7629 { 7630 size_t ii; 7631 unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMin; 7632 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); 7633 } 7634 SWIG_JavaArrayArgoutUshort(jenv, jarr2, (unsigned short *)arg2, jarg2); 7635 delete [] arg2; 7636 } 7637 7638 7639 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNode_1quantizedAabbMin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7640 jintArray jresult = 0 ; 7641 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7642 unsigned short *result = 0 ; 7643 7644 (void)jenv; 7645 (void)jcls; 7646 (void)jarg1_; 7647 arg1 = *(btQuantizedBvhNode **)&jarg1; 7648 result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMin); 7649 jresult = SWIG_JavaArrayOutUshort(jenv, (unsigned short *)result, 3); 7650 return jresult; 7651 } 7652 7653 7654 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNode_1quantizedAabbMax_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 7655 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7656 unsigned short *arg2 ; 7657 jint *jarr2 ; 7658 7659 (void)jenv; 7660 (void)jcls; 7661 (void)jarg1_; 7662 arg1 = *(btQuantizedBvhNode **)&jarg1; 7663 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 7664 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 7665 return ; 7666 } 7667 if (!SWIG_JavaArrayInUshort(jenv, &jarr2, (unsigned short **)&arg2, jarg2)) return ; 7668 { 7669 size_t ii; 7670 unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMax; 7671 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); 7672 } 7673 SWIG_JavaArrayArgoutUshort(jenv, jarr2, (unsigned short *)arg2, jarg2); 7674 delete [] arg2; 7675 } 7676 7677 7678 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNode_1quantizedAabbMax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7679 jintArray jresult = 0 ; 7680 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7681 unsigned short *result = 0 ; 7682 7683 (void)jenv; 7684 (void)jcls; 7685 (void)jarg1_; 7686 arg1 = *(btQuantizedBvhNode **)&jarg1; 7687 result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMax); 7688 jresult = SWIG_JavaArrayOutUshort(jenv, (unsigned short *)result, 3); 7689 return jresult; 7690 } 7691 7692 7693 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNode_1escapeIndexOrTriangleIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 7694 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7695 int arg2 ; 7696 7697 (void)jenv; 7698 (void)jcls; 7699 (void)jarg1_; 7700 arg1 = *(btQuantizedBvhNode **)&jarg1; 7701 arg2 = (int)jarg2; 7702 if (arg1) (arg1)->m_escapeIndexOrTriangleIndex = arg2; 7703 } 7704 7705 7706 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNode_1escapeIndexOrTriangleIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7707 jint jresult = 0 ; 7708 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7709 int result; 7710 7711 (void)jenv; 7712 (void)jcls; 7713 (void)jarg1_; 7714 arg1 = *(btQuantizedBvhNode **)&jarg1; 7715 result = (int) ((arg1)->m_escapeIndexOrTriangleIndex); 7716 jresult = (jint)result; 7717 return jresult; 7718 } 7719 7720 7721 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNode_1isLeafNode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7722 jboolean jresult = 0 ; 7723 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7724 bool result; 7725 7726 (void)jenv; 7727 (void)jcls; 7728 (void)jarg1_; 7729 arg1 = *(btQuantizedBvhNode **)&jarg1; 7730 result = (bool)((btQuantizedBvhNode const *)arg1)->isLeafNode(); 7731 jresult = (jboolean)result; 7732 return jresult; 7733 } 7734 7735 7736 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNode_1getEscapeIndex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7737 jint jresult = 0 ; 7738 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7739 int result; 7740 7741 (void)jenv; 7742 (void)jcls; 7743 (void)jarg1_; 7744 arg1 = *(btQuantizedBvhNode **)&jarg1; 7745 result = (int)((btQuantizedBvhNode const *)arg1)->getEscapeIndex(); 7746 jresult = (jint)result; 7747 return jresult; 7748 } 7749 7750 7751 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNode_1getTriangleIndex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7752 jint jresult = 0 ; 7753 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7754 int result; 7755 7756 (void)jenv; 7757 (void)jcls; 7758 (void)jarg1_; 7759 arg1 = *(btQuantizedBvhNode **)&jarg1; 7760 result = (int)((btQuantizedBvhNode const *)arg1)->getTriangleIndex(); 7761 jresult = (jint)result; 7762 return jresult; 7763 } 7764 7765 7766 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNode_1getPartId(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7767 jint jresult = 0 ; 7768 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7769 int result; 7770 7771 (void)jenv; 7772 (void)jcls; 7773 (void)jarg1_; 7774 arg1 = *(btQuantizedBvhNode **)&jarg1; 7775 result = (int)((btQuantizedBvhNode const *)arg1)->getPartId(); 7776 jresult = (jint)result; 7777 return jresult; 7778 } 7779 7780 7781 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btQuantizedBvhNode(JNIEnv *jenv, jclass jcls) { 7782 jlong jresult = 0 ; 7783 btQuantizedBvhNode *result = 0 ; 7784 7785 (void)jenv; 7786 (void)jcls; 7787 result = (btQuantizedBvhNode *)new btQuantizedBvhNode(); 7788 *(btQuantizedBvhNode **)&jresult = result; 7789 return jresult; 7790 } 7791 7792 7793 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btQuantizedBvhNode(JNIEnv *jenv, jclass jcls, jlong jarg1) { 7794 btQuantizedBvhNode *arg1 = (btQuantizedBvhNode *) 0 ; 7795 7796 (void)jenv; 7797 (void)jcls; 7798 arg1 = *(btQuantizedBvhNode **)&jarg1; 7799 delete arg1; 7800 } 7801 7802 7803 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1aabbMinOrg_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 7804 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7805 btVector3 *arg2 = (btVector3 *) 0 ; 7806 7807 (void)jenv; 7808 (void)jcls; 7809 (void)jarg1_; 7810 (void)jarg2_; 7811 arg1 = *(btOptimizedBvhNode **)&jarg1; 7812 arg2 = *(btVector3 **)&jarg2; 7813 if (arg1) (arg1)->m_aabbMinOrg = *arg2; 7814 } 7815 7816 7817 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1aabbMinOrg_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7818 jlong jresult = 0 ; 7819 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7820 btVector3 *result = 0 ; 7821 7822 (void)jenv; 7823 (void)jcls; 7824 (void)jarg1_; 7825 arg1 = *(btOptimizedBvhNode **)&jarg1; 7826 result = (btVector3 *)& ((arg1)->m_aabbMinOrg); 7827 *(btVector3 **)&jresult = result; 7828 return jresult; 7829 } 7830 7831 7832 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1aabbMaxOrg_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 7833 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7834 btVector3 *arg2 = (btVector3 *) 0 ; 7835 7836 (void)jenv; 7837 (void)jcls; 7838 (void)jarg1_; 7839 (void)jarg2_; 7840 arg1 = *(btOptimizedBvhNode **)&jarg1; 7841 arg2 = *(btVector3 **)&jarg2; 7842 if (arg1) (arg1)->m_aabbMaxOrg = *arg2; 7843 } 7844 7845 7846 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1aabbMaxOrg_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7847 jlong jresult = 0 ; 7848 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7849 btVector3 *result = 0 ; 7850 7851 (void)jenv; 7852 (void)jcls; 7853 (void)jarg1_; 7854 arg1 = *(btOptimizedBvhNode **)&jarg1; 7855 result = (btVector3 *)& ((arg1)->m_aabbMaxOrg); 7856 *(btVector3 **)&jresult = result; 7857 return jresult; 7858 } 7859 7860 7861 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1escapeIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 7862 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7863 int arg2 ; 7864 7865 (void)jenv; 7866 (void)jcls; 7867 (void)jarg1_; 7868 arg1 = *(btOptimizedBvhNode **)&jarg1; 7869 arg2 = (int)jarg2; 7870 if (arg1) (arg1)->m_escapeIndex = arg2; 7871 } 7872 7873 7874 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1escapeIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7875 jint jresult = 0 ; 7876 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7877 int result; 7878 7879 (void)jenv; 7880 (void)jcls; 7881 (void)jarg1_; 7882 arg1 = *(btOptimizedBvhNode **)&jarg1; 7883 result = (int) ((arg1)->m_escapeIndex); 7884 jresult = (jint)result; 7885 return jresult; 7886 } 7887 7888 7889 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1subPart_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 7890 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7891 int arg2 ; 7892 7893 (void)jenv; 7894 (void)jcls; 7895 (void)jarg1_; 7896 arg1 = *(btOptimizedBvhNode **)&jarg1; 7897 arg2 = (int)jarg2; 7898 if (arg1) (arg1)->m_subPart = arg2; 7899 } 7900 7901 7902 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1subPart_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7903 jint jresult = 0 ; 7904 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7905 int result; 7906 7907 (void)jenv; 7908 (void)jcls; 7909 (void)jarg1_; 7910 arg1 = *(btOptimizedBvhNode **)&jarg1; 7911 result = (int) ((arg1)->m_subPart); 7912 jresult = (jint)result; 7913 return jresult; 7914 } 7915 7916 7917 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1triangleIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 7918 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7919 int arg2 ; 7920 7921 (void)jenv; 7922 (void)jcls; 7923 (void)jarg1_; 7924 arg1 = *(btOptimizedBvhNode **)&jarg1; 7925 arg2 = (int)jarg2; 7926 if (arg1) (arg1)->m_triangleIndex = arg2; 7927 } 7928 7929 7930 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1triangleIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7931 jint jresult = 0 ; 7932 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7933 int result; 7934 7935 (void)jenv; 7936 (void)jcls; 7937 (void)jarg1_; 7938 arg1 = *(btOptimizedBvhNode **)&jarg1; 7939 result = (int) ((arg1)->m_triangleIndex); 7940 jresult = (jint)result; 7941 return jresult; 7942 } 7943 7944 7945 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1padding_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 7946 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7947 char *arg2 ; 7948 7949 (void)jenv; 7950 (void)jcls; 7951 (void)jarg1_; 7952 arg1 = *(btOptimizedBvhNode **)&jarg1; 7953 arg2 = 0; 7954 if (jarg2) { 7955 arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); 7956 if (!arg2) return ; 7957 } 7958 { 7959 if(arg2) { 7960 strncpy((char*)arg1->m_padding, (const char *)arg2, 20-1); 7961 arg1->m_padding[20-1] = 0; 7962 } else { 7963 arg1->m_padding[0] = 0; 7964 } 7965 } 7966 7967 if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); 7968 } 7969 7970 7971 SWIGEXPORT jstring JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNode_1padding_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7972 jstring jresult = 0 ; 7973 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 7974 char *result = 0 ; 7975 7976 (void)jenv; 7977 (void)jcls; 7978 (void)jarg1_; 7979 arg1 = *(btOptimizedBvhNode **)&jarg1; 7980 result = (char *)(char *) ((arg1)->m_padding); 7981 if (result) jresult = jenv->NewStringUTF((const char *)result); 7982 return jresult; 7983 } 7984 7985 7986 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btOptimizedBvhNode(JNIEnv *jenv, jclass jcls) { 7987 jlong jresult = 0 ; 7988 btOptimizedBvhNode *result = 0 ; 7989 7990 (void)jenv; 7991 (void)jcls; 7992 result = (btOptimizedBvhNode *)new btOptimizedBvhNode(); 7993 *(btOptimizedBvhNode **)&jresult = result; 7994 return jresult; 7995 } 7996 7997 7998 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btOptimizedBvhNode(JNIEnv *jenv, jclass jcls, jlong jarg1) { 7999 btOptimizedBvhNode *arg1 = (btOptimizedBvhNode *) 0 ; 8000 8001 (void)jenv; 8002 (void)jcls; 8003 arg1 = *(btOptimizedBvhNode **)&jarg1; 8004 delete arg1; 8005 } 8006 8007 8008 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1quantizedAabbMin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 8009 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8010 unsigned short *arg2 ; 8011 jint *jarr2 ; 8012 8013 (void)jenv; 8014 (void)jcls; 8015 (void)jarg1_; 8016 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8017 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 8018 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 8019 return ; 8020 } 8021 if (!SWIG_JavaArrayInUshort(jenv, &jarr2, (unsigned short **)&arg2, jarg2)) return ; 8022 { 8023 size_t ii; 8024 unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMin; 8025 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); 8026 } 8027 SWIG_JavaArrayArgoutUshort(jenv, jarr2, (unsigned short *)arg2, jarg2); 8028 delete [] arg2; 8029 } 8030 8031 8032 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1quantizedAabbMin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8033 jintArray jresult = 0 ; 8034 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8035 unsigned short *result = 0 ; 8036 8037 (void)jenv; 8038 (void)jcls; 8039 (void)jarg1_; 8040 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8041 result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMin); 8042 jresult = SWIG_JavaArrayOutUshort(jenv, (unsigned short *)result, 3); 8043 return jresult; 8044 } 8045 8046 8047 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1quantizedAabbMax_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 8048 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8049 unsigned short *arg2 ; 8050 jint *jarr2 ; 8051 8052 (void)jenv; 8053 (void)jcls; 8054 (void)jarg1_; 8055 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8056 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 8057 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 8058 return ; 8059 } 8060 if (!SWIG_JavaArrayInUshort(jenv, &jarr2, (unsigned short **)&arg2, jarg2)) return ; 8061 { 8062 size_t ii; 8063 unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMax; 8064 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); 8065 } 8066 SWIG_JavaArrayArgoutUshort(jenv, jarr2, (unsigned short *)arg2, jarg2); 8067 delete [] arg2; 8068 } 8069 8070 8071 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1quantizedAabbMax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8072 jintArray jresult = 0 ; 8073 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8074 unsigned short *result = 0 ; 8075 8076 (void)jenv; 8077 (void)jcls; 8078 (void)jarg1_; 8079 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8080 result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMax); 8081 jresult = SWIG_JavaArrayOutUshort(jenv, (unsigned short *)result, 3); 8082 return jresult; 8083 } 8084 8085 8086 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1rootNodeIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8087 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8088 int arg2 ; 8089 8090 (void)jenv; 8091 (void)jcls; 8092 (void)jarg1_; 8093 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8094 arg2 = (int)jarg2; 8095 if (arg1) (arg1)->m_rootNodeIndex = arg2; 8096 } 8097 8098 8099 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1rootNodeIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8100 jint jresult = 0 ; 8101 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8102 int result; 8103 8104 (void)jenv; 8105 (void)jcls; 8106 (void)jarg1_; 8107 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8108 result = (int) ((arg1)->m_rootNodeIndex); 8109 jresult = (jint)result; 8110 return jresult; 8111 } 8112 8113 8114 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1subtreeSize_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8115 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8116 int arg2 ; 8117 8118 (void)jenv; 8119 (void)jcls; 8120 (void)jarg1_; 8121 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8122 arg2 = (int)jarg2; 8123 if (arg1) (arg1)->m_subtreeSize = arg2; 8124 } 8125 8126 8127 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1subtreeSize_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8128 jint jresult = 0 ; 8129 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8130 int result; 8131 8132 (void)jenv; 8133 (void)jcls; 8134 (void)jarg1_; 8135 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8136 result = (int) ((arg1)->m_subtreeSize); 8137 jresult = (jint)result; 8138 return jresult; 8139 } 8140 8141 8142 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1padding_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 8143 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8144 int *arg2 ; 8145 jint *jarr2 ; 8146 8147 (void)jenv; 8148 (void)jcls; 8149 (void)jarg1_; 8150 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8151 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 8152 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 8153 return ; 8154 } 8155 if (!SWIG_JavaArrayInInt(jenv, &jarr2, (int **)&arg2, jarg2)) return ; 8156 { 8157 size_t ii; 8158 int *b = (int *) arg1->m_padding; 8159 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((int *) arg2 + ii); 8160 } 8161 SWIG_JavaArrayArgoutInt(jenv, jarr2, (int *)arg2, jarg2); 8162 delete [] arg2; 8163 } 8164 8165 8166 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1padding_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8167 jintArray jresult = 0 ; 8168 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8169 int *result = 0 ; 8170 8171 (void)jenv; 8172 (void)jcls; 8173 (void)jarg1_; 8174 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8175 result = (int *)(int *) ((arg1)->m_padding); 8176 jresult = SWIG_JavaArrayOutInt(jenv, (int *)result, 3); 8177 return jresult; 8178 } 8179 8180 8181 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBvhSubtreeInfo(JNIEnv *jenv, jclass jcls) { 8182 jlong jresult = 0 ; 8183 btBvhSubtreeInfo *result = 0 ; 8184 8185 (void)jenv; 8186 (void)jcls; 8187 result = (btBvhSubtreeInfo *)new btBvhSubtreeInfo(); 8188 *(btBvhSubtreeInfo **)&jresult = result; 8189 return jresult; 8190 } 8191 8192 8193 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfo_1setAabbFromQuantizeNode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 8194 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8195 btQuantizedBvhNode *arg2 = 0 ; 8196 8197 (void)jenv; 8198 (void)jcls; 8199 (void)jarg1_; 8200 (void)jarg2_; 8201 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8202 arg2 = *(btQuantizedBvhNode **)&jarg2; 8203 if (!arg2) { 8204 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuantizedBvhNode const & reference is null"); 8205 return ; 8206 } 8207 (arg1)->setAabbFromQuantizeNode((btQuantizedBvhNode const &)*arg2); 8208 } 8209 8210 8211 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btBvhSubtreeInfo(JNIEnv *jenv, jclass jcls, jlong jarg1) { 8212 btBvhSubtreeInfo *arg1 = (btBvhSubtreeInfo *) 0 ; 8213 8214 (void)jenv; 8215 (void)jcls; 8216 arg1 = *(btBvhSubtreeInfo **)&jarg1; 8217 delete arg1; 8218 } 8219 8220 8221 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btNodeOverlapCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) { 8222 btNodeOverlapCallback *arg1 = (btNodeOverlapCallback *) 0 ; 8223 8224 (void)jenv; 8225 (void)jcls; 8226 arg1 = *(btNodeOverlapCallback **)&jarg1; 8227 delete arg1; 8228 } 8229 8230 8231 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btNodeOverlapCallback_1processNode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { 8232 btNodeOverlapCallback *arg1 = (btNodeOverlapCallback *) 0 ; 8233 int arg2 ; 8234 int arg3 ; 8235 8236 (void)jenv; 8237 (void)jcls; 8238 (void)jarg1_; 8239 arg1 = *(btNodeOverlapCallback **)&jarg1; 8240 arg2 = (int)jarg2; 8241 arg3 = (int)jarg3; 8242 (arg1)->processNode(arg2,arg3); 8243 } 8244 8245 8246 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btNodeOverlapCallback(JNIEnv *jenv, jclass jcls) { 8247 jlong jresult = 0 ; 8248 btNodeOverlapCallback *result = 0 ; 8249 8250 (void)jenv; 8251 (void)jcls; 8252 result = (btNodeOverlapCallback *)new SwigDirector_btNodeOverlapCallback(jenv); 8253 *(btNodeOverlapCallback **)&jresult = result; 8254 return jresult; 8255 } 8256 8257 8258 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btNodeOverlapCallback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { 8259 btNodeOverlapCallback *obj = *((btNodeOverlapCallback **)&objarg); 8260 (void)jcls; 8261 SwigDirector_btNodeOverlapCallback *director = (SwigDirector_btNodeOverlapCallback *)(obj); 8262 if (director) { 8263 director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); 8264 } 8265 } 8266 8267 8268 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btNodeOverlapCallback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { 8269 btNodeOverlapCallback *obj = *((btNodeOverlapCallback **)&objarg); 8270 SwigDirector_btNodeOverlapCallback *director = (SwigDirector_btNodeOverlapCallback *)(obj); 8271 (void)jcls; 8272 if (director) { 8273 director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); 8274 } 8275 } 8276 8277 8278 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btQuantizedBvh(JNIEnv *jenv, jclass jcls) { 8279 jlong jresult = 0 ; 8280 btQuantizedBvh *result = 0 ; 8281 8282 (void)jenv; 8283 (void)jcls; 8284 result = (btQuantizedBvh *)new btQuantizedBvh(); 8285 *(btQuantizedBvh **)&jresult = result; 8286 return jresult; 8287 } 8288 8289 8290 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btQuantizedBvh(JNIEnv *jenv, jclass jcls, jlong jarg1) { 8291 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8292 8293 (void)jenv; 8294 (void)jcls; 8295 arg1 = *(btQuantizedBvh **)&jarg1; 8296 delete arg1; 8297 } 8298 8299 8300 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1setQuantizationValues_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jfloat jarg4) { 8301 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8302 btVector3 *arg2 = 0 ; 8303 btVector3 *arg3 = 0 ; 8304 btScalar arg4 ; 8305 8306 (void)jenv; 8307 (void)jcls; 8308 (void)jarg1_; 8309 arg1 = *(btQuantizedBvh **)&jarg1; 8310 btVector3 local_arg2; 8311 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8312 arg2 = &local_arg2; 8313 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8314 btVector3 local_arg3; 8315 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8316 arg3 = &local_arg3; 8317 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8318 arg4 = (btScalar)jarg4; 8319 (arg1)->setQuantizationValues((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); 8320 } 8321 8322 8323 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1setQuantizationValues_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { 8324 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8325 btVector3 *arg2 = 0 ; 8326 btVector3 *arg3 = 0 ; 8327 8328 (void)jenv; 8329 (void)jcls; 8330 (void)jarg1_; 8331 arg1 = *(btQuantizedBvh **)&jarg1; 8332 btVector3 local_arg2; 8333 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 8334 arg2 = &local_arg2; 8335 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 8336 btVector3 local_arg3; 8337 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8338 arg3 = &local_arg3; 8339 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8340 (arg1)->setQuantizationValues((btVector3 const &)*arg2,(btVector3 const &)*arg3); 8341 } 8342 8343 8344 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1getLeafNodeArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8345 jlong jresult = 0 ; 8346 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8347 QuantizedNodeArray *result = 0 ; 8348 8349 (void)jenv; 8350 (void)jcls; 8351 (void)jarg1_; 8352 arg1 = *(btQuantizedBvh **)&jarg1; 8353 result = (QuantizedNodeArray *) &(arg1)->getLeafNodeArray(); 8354 *(QuantizedNodeArray **)&jresult = result; 8355 return jresult; 8356 } 8357 8358 8359 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1buildInternal(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8360 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8361 8362 (void)jenv; 8363 (void)jcls; 8364 (void)jarg1_; 8365 arg1 = *(btQuantizedBvh **)&jarg1; 8366 (arg1)->buildInternal(); 8367 } 8368 8369 8370 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1reportAabbOverlappingNodex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4) { 8371 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8372 btNodeOverlapCallback *arg2 = (btNodeOverlapCallback *) 0 ; 8373 btVector3 *arg3 = 0 ; 8374 btVector3 *arg4 = 0 ; 8375 8376 (void)jenv; 8377 (void)jcls; 8378 (void)jarg1_; 8379 (void)jarg2_; 8380 arg1 = *(btQuantizedBvh **)&jarg1; 8381 arg2 = *(btNodeOverlapCallback **)&jarg2; 8382 btVector3 local_arg3; 8383 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8384 arg3 = &local_arg3; 8385 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8386 btVector3 local_arg4; 8387 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 8388 arg4 = &local_arg4; 8389 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 8390 ((btQuantizedBvh const *)arg1)->reportAabbOverlappingNodex(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); 8391 } 8392 8393 8394 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1reportRayOverlappingNodex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4) { 8395 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8396 btNodeOverlapCallback *arg2 = (btNodeOverlapCallback *) 0 ; 8397 btVector3 *arg3 = 0 ; 8398 btVector3 *arg4 = 0 ; 8399 8400 (void)jenv; 8401 (void)jcls; 8402 (void)jarg1_; 8403 (void)jarg2_; 8404 arg1 = *(btQuantizedBvh **)&jarg1; 8405 arg2 = *(btNodeOverlapCallback **)&jarg2; 8406 btVector3 local_arg3; 8407 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8408 arg3 = &local_arg3; 8409 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8410 btVector3 local_arg4; 8411 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 8412 arg4 = &local_arg4; 8413 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 8414 ((btQuantizedBvh const *)arg1)->reportRayOverlappingNodex(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); 8415 } 8416 8417 8418 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1reportBoxCastOverlappingNodex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4, jobject jarg5, jobject jarg6) { 8419 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8420 btNodeOverlapCallback *arg2 = (btNodeOverlapCallback *) 0 ; 8421 btVector3 *arg3 = 0 ; 8422 btVector3 *arg4 = 0 ; 8423 btVector3 *arg5 = 0 ; 8424 btVector3 *arg6 = 0 ; 8425 8426 (void)jenv; 8427 (void)jcls; 8428 (void)jarg1_; 8429 (void)jarg2_; 8430 arg1 = *(btQuantizedBvh **)&jarg1; 8431 arg2 = *(btNodeOverlapCallback **)&jarg2; 8432 btVector3 local_arg3; 8433 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8434 arg3 = &local_arg3; 8435 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8436 btVector3 local_arg4; 8437 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 8438 arg4 = &local_arg4; 8439 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 8440 btVector3 local_arg5; 8441 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 8442 arg5 = &local_arg5; 8443 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 8444 btVector3 local_arg6; 8445 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 8446 arg6 = &local_arg6; 8447 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 8448 ((btQuantizedBvh const *)arg1)->reportBoxCastOverlappingNodex(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); 8449 } 8450 8451 8452 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1quantize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jint jarg4) { 8453 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8454 unsigned short *arg2 = (unsigned short *) 0 ; 8455 btVector3 *arg3 = 0 ; 8456 int arg4 ; 8457 8458 (void)jenv; 8459 (void)jcls; 8460 (void)jarg1_; 8461 arg1 = *(btQuantizedBvh **)&jarg1; 8462 { 8463 arg2 = (unsigned short*)jenv->GetDirectBufferAddress(jarg2); 8464 if (arg2 == NULL) { 8465 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 8466 } 8467 } 8468 btVector3 local_arg3; 8469 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8470 arg3 = &local_arg3; 8471 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8472 arg4 = (int)jarg4; 8473 ((btQuantizedBvh const *)arg1)->quantize(arg2,(btVector3 const &)*arg3,arg4); 8474 8475 } 8476 8477 8478 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1quantizeWithClamp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jint jarg4) { 8479 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8480 unsigned short *arg2 = (unsigned short *) 0 ; 8481 btVector3 *arg3 = 0 ; 8482 int arg4 ; 8483 8484 (void)jenv; 8485 (void)jcls; 8486 (void)jarg1_; 8487 arg1 = *(btQuantizedBvh **)&jarg1; 8488 { 8489 arg2 = (unsigned short*)jenv->GetDirectBufferAddress(jarg2); 8490 if (arg2 == NULL) { 8491 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 8492 } 8493 } 8494 btVector3 local_arg3; 8495 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 8496 arg3 = &local_arg3; 8497 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 8498 arg4 = (int)jarg4; 8499 ((btQuantizedBvh const *)arg1)->quantizeWithClamp(arg2,(btVector3 const &)*arg3,arg4); 8500 8501 } 8502 8503 8504 SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1unQuantize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 8505 jobject jresult = 0 ; 8506 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8507 unsigned short *arg2 = (unsigned short *) 0 ; 8508 btVector3 result; 8509 8510 (void)jenv; 8511 (void)jcls; 8512 (void)jarg1_; 8513 arg1 = *(btQuantizedBvh **)&jarg1; 8514 { 8515 arg2 = (unsigned short*)jenv->GetDirectBufferAddress(jarg2); 8516 if (arg2 == NULL) { 8517 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 8518 } 8519 } 8520 result = ((btQuantizedBvh const *)arg1)->unQuantize((unsigned short const *)arg2); 8521 jresult = gdx_getReturnVector3(jenv); 8522 gdx_setVector3FrombtVector3(jenv, jresult, result); 8523 8524 return jresult; 8525 } 8526 8527 8528 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1setTraversalMode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8529 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8530 btQuantizedBvh::btTraversalMode arg2 ; 8531 8532 (void)jenv; 8533 (void)jcls; 8534 (void)jarg1_; 8535 arg1 = *(btQuantizedBvh **)&jarg1; 8536 arg2 = (btQuantizedBvh::btTraversalMode)jarg2; 8537 (arg1)->setTraversalMode(arg2); 8538 } 8539 8540 8541 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1getQuantizedNodeArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8542 jlong jresult = 0 ; 8543 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8544 QuantizedNodeArray *result = 0 ; 8545 8546 (void)jenv; 8547 (void)jcls; 8548 (void)jarg1_; 8549 arg1 = *(btQuantizedBvh **)&jarg1; 8550 result = (QuantizedNodeArray *) &(arg1)->getQuantizedNodeArray(); 8551 *(QuantizedNodeArray **)&jresult = result; 8552 return jresult; 8553 } 8554 8555 8556 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1getSubtreeInfoArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8557 jlong jresult = 0 ; 8558 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8559 BvhSubtreeInfoArray *result = 0 ; 8560 8561 (void)jenv; 8562 (void)jcls; 8563 (void)jarg1_; 8564 arg1 = *(btQuantizedBvh **)&jarg1; 8565 result = (BvhSubtreeInfoArray *) &(arg1)->getSubtreeInfoArray(); 8566 *(BvhSubtreeInfoArray **)&jresult = result; 8567 return jresult; 8568 } 8569 8570 8571 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1calculateSerializeBufferSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8572 jlong jresult = 0 ; 8573 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8574 unsigned int result; 8575 8576 (void)jenv; 8577 (void)jcls; 8578 (void)jarg1_; 8579 arg1 = *(btQuantizedBvh **)&jarg1; 8580 result = (unsigned int)((btQuantizedBvh const *)arg1)->calculateSerializeBufferSize(); 8581 jresult = (jlong)result; 8582 return jresult; 8583 } 8584 8585 8586 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1serialize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jboolean jarg4) { 8587 jboolean jresult = 0 ; 8588 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8589 void *arg2 = (void *) 0 ; 8590 unsigned int arg3 ; 8591 bool arg4 ; 8592 bool result; 8593 8594 (void)jenv; 8595 (void)jcls; 8596 (void)jarg1_; 8597 arg1 = *(btQuantizedBvh **)&jarg1; 8598 arg2 = (void *)jarg2; 8599 arg3 = (unsigned int)jarg3; 8600 arg4 = jarg4 ? true : false; 8601 result = (bool)((btQuantizedBvh const *)arg1)->serialize(arg2,arg3,arg4); 8602 jresult = (jboolean)result; 8603 return jresult; 8604 } 8605 8606 8607 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1deSerializeInPlace(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jboolean jarg3) { 8608 jlong jresult = 0 ; 8609 void *arg1 = (void *) 0 ; 8610 unsigned int arg2 ; 8611 bool arg3 ; 8612 btQuantizedBvh *result = 0 ; 8613 8614 (void)jenv; 8615 (void)jcls; 8616 arg1 = (void *)jarg1; 8617 arg2 = (unsigned int)jarg2; 8618 arg3 = jarg3 ? true : false; 8619 result = (btQuantizedBvh *)btQuantizedBvh::deSerializeInPlace(arg1,arg2,arg3); 8620 *(btQuantizedBvh **)&jresult = result; 8621 return jresult; 8622 } 8623 8624 8625 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1getAlignmentSerializationPadding(JNIEnv *jenv, jclass jcls) { 8626 jlong jresult = 0 ; 8627 unsigned int result; 8628 8629 (void)jenv; 8630 (void)jcls; 8631 result = (unsigned int)btQuantizedBvh::getAlignmentSerializationPadding(); 8632 jresult = (jlong)result; 8633 return jresult; 8634 } 8635 8636 8637 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1calculateSerializeBufferSizeNew(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8638 jint jresult = 0 ; 8639 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8640 int result; 8641 8642 (void)jenv; 8643 (void)jcls; 8644 (void)jarg1_; 8645 arg1 = *(btQuantizedBvh **)&jarg1; 8646 result = (int)((btQuantizedBvh const *)arg1)->calculateSerializeBufferSizeNew(); 8647 jresult = (jint)result; 8648 return jresult; 8649 } 8650 8651 8652 SWIGEXPORT jstring JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1serialize_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { 8653 jstring jresult = 0 ; 8654 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8655 void *arg2 = (void *) 0 ; 8656 btSerializer *arg3 = (btSerializer *) 0 ; 8657 char *result = 0 ; 8658 8659 (void)jenv; 8660 (void)jcls; 8661 (void)jarg1_; 8662 arg1 = *(btQuantizedBvh **)&jarg1; 8663 arg2 = (void *)jarg2; 8664 arg3 = *(btSerializer **)&jarg3; 8665 result = (char *)((btQuantizedBvh const *)arg1)->serialize(arg2,arg3); 8666 if (result) jresult = jenv->NewStringUTF((const char *)result); 8667 return jresult; 8668 } 8669 8670 8671 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1deSerializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 8672 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8673 btQuantizedBvhFloatData *arg2 = 0 ; 8674 8675 (void)jenv; 8676 (void)jcls; 8677 (void)jarg1_; 8678 (void)jarg2_; 8679 arg1 = *(btQuantizedBvh **)&jarg1; 8680 arg2 = *(btQuantizedBvhFloatData **)&jarg2; 8681 if (!arg2) { 8682 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuantizedBvhFloatData & reference is null"); 8683 return ; 8684 } 8685 (arg1)->deSerializeFloat(*arg2); 8686 } 8687 8688 8689 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1deSerializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 8690 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8691 btQuantizedBvhDoubleData *arg2 = 0 ; 8692 8693 (void)jenv; 8694 (void)jcls; 8695 (void)jarg1_; 8696 (void)jarg2_; 8697 arg1 = *(btQuantizedBvh **)&jarg1; 8698 arg2 = *(btQuantizedBvhDoubleData **)&jarg2; 8699 if (!arg2) { 8700 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuantizedBvhDoubleData & reference is null"); 8701 return ; 8702 } 8703 (arg1)->deSerializeDouble(*arg2); 8704 } 8705 8706 8707 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvh_1isQuantized(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8708 jboolean jresult = 0 ; 8709 btQuantizedBvh *arg1 = (btQuantizedBvh *) 0 ; 8710 bool result; 8711 8712 (void)jenv; 8713 (void)jcls; 8714 (void)jarg1_; 8715 arg1 = *(btQuantizedBvh **)&jarg1; 8716 result = (bool)(arg1)->isQuantized(); 8717 jresult = (jboolean)result; 8718 return jresult; 8719 } 8720 8721 8722 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfoData_1rootNodeIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8723 btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; 8724 int arg2 ; 8725 8726 (void)jenv; 8727 (void)jcls; 8728 (void)jarg1_; 8729 arg1 = *(btBvhSubtreeInfoData **)&jarg1; 8730 arg2 = (int)jarg2; 8731 if (arg1) (arg1)->m_rootNodeIndex = arg2; 8732 } 8733 8734 8735 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfoData_1rootNodeIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8736 jint jresult = 0 ; 8737 btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; 8738 int result; 8739 8740 (void)jenv; 8741 (void)jcls; 8742 (void)jarg1_; 8743 arg1 = *(btBvhSubtreeInfoData **)&jarg1; 8744 result = (int) ((arg1)->m_rootNodeIndex); 8745 jresult = (jint)result; 8746 return jresult; 8747 } 8748 8749 8750 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfoData_1subtreeSize_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8751 btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; 8752 int arg2 ; 8753 8754 (void)jenv; 8755 (void)jcls; 8756 (void)jarg1_; 8757 arg1 = *(btBvhSubtreeInfoData **)&jarg1; 8758 arg2 = (int)jarg2; 8759 if (arg1) (arg1)->m_subtreeSize = arg2; 8760 } 8761 8762 8763 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfoData_1subtreeSize_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8764 jint jresult = 0 ; 8765 btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; 8766 int result; 8767 8768 (void)jenv; 8769 (void)jcls; 8770 (void)jarg1_; 8771 arg1 = *(btBvhSubtreeInfoData **)&jarg1; 8772 result = (int) ((arg1)->m_subtreeSize); 8773 jresult = (jint)result; 8774 return jresult; 8775 } 8776 8777 8778 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfoData_1quantizedAabbMin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 8779 btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; 8780 unsigned short *arg2 ; 8781 jint *jarr2 ; 8782 8783 (void)jenv; 8784 (void)jcls; 8785 (void)jarg1_; 8786 arg1 = *(btBvhSubtreeInfoData **)&jarg1; 8787 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 8788 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 8789 return ; 8790 } 8791 if (!SWIG_JavaArrayInUshort(jenv, &jarr2, (unsigned short **)&arg2, jarg2)) return ; 8792 { 8793 size_t ii; 8794 unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMin; 8795 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); 8796 } 8797 SWIG_JavaArrayArgoutUshort(jenv, jarr2, (unsigned short *)arg2, jarg2); 8798 delete [] arg2; 8799 } 8800 8801 8802 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfoData_1quantizedAabbMin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8803 jintArray jresult = 0 ; 8804 btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; 8805 unsigned short *result = 0 ; 8806 8807 (void)jenv; 8808 (void)jcls; 8809 (void)jarg1_; 8810 arg1 = *(btBvhSubtreeInfoData **)&jarg1; 8811 result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMin); 8812 jresult = SWIG_JavaArrayOutUshort(jenv, (unsigned short *)result, 3); 8813 return jresult; 8814 } 8815 8816 8817 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfoData_1quantizedAabbMax_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 8818 btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; 8819 unsigned short *arg2 ; 8820 jint *jarr2 ; 8821 8822 (void)jenv; 8823 (void)jcls; 8824 (void)jarg1_; 8825 arg1 = *(btBvhSubtreeInfoData **)&jarg1; 8826 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 8827 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 8828 return ; 8829 } 8830 if (!SWIG_JavaArrayInUshort(jenv, &jarr2, (unsigned short **)&arg2, jarg2)) return ; 8831 { 8832 size_t ii; 8833 unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMax; 8834 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); 8835 } 8836 SWIG_JavaArrayArgoutUshort(jenv, jarr2, (unsigned short *)arg2, jarg2); 8837 delete [] arg2; 8838 } 8839 8840 8841 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btBvhSubtreeInfoData_1quantizedAabbMax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8842 jintArray jresult = 0 ; 8843 btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; 8844 unsigned short *result = 0 ; 8845 8846 (void)jenv; 8847 (void)jcls; 8848 (void)jarg1_; 8849 arg1 = *(btBvhSubtreeInfoData **)&jarg1; 8850 result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMax); 8851 jresult = SWIG_JavaArrayOutUshort(jenv, (unsigned short *)result, 3); 8852 return jresult; 8853 } 8854 8855 8856 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btBvhSubtreeInfoData(JNIEnv *jenv, jclass jcls) { 8857 jlong jresult = 0 ; 8858 btBvhSubtreeInfoData *result = 0 ; 8859 8860 (void)jenv; 8861 (void)jcls; 8862 result = (btBvhSubtreeInfoData *)new btBvhSubtreeInfoData(); 8863 *(btBvhSubtreeInfoData **)&jresult = result; 8864 return jresult; 8865 } 8866 8867 8868 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btBvhSubtreeInfoData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 8869 btBvhSubtreeInfoData *arg1 = (btBvhSubtreeInfoData *) 0 ; 8870 8871 (void)jenv; 8872 (void)jcls; 8873 arg1 = *(btBvhSubtreeInfoData **)&jarg1; 8874 delete arg1; 8875 } 8876 8877 8878 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1aabbMinOrg_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 8879 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 8880 btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; 8881 8882 (void)jenv; 8883 (void)jcls; 8884 (void)jarg1_; 8885 (void)jarg2_; 8886 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 8887 arg2 = *(btVector3FloatData **)&jarg2; 8888 if (arg1) (arg1)->m_aabbMinOrg = *arg2; 8889 } 8890 8891 8892 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1aabbMinOrg_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8893 jlong jresult = 0 ; 8894 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 8895 btVector3FloatData *result = 0 ; 8896 8897 (void)jenv; 8898 (void)jcls; 8899 (void)jarg1_; 8900 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 8901 result = (btVector3FloatData *)& ((arg1)->m_aabbMinOrg); 8902 *(btVector3FloatData **)&jresult = result; 8903 return jresult; 8904 } 8905 8906 8907 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1aabbMaxOrg_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 8908 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 8909 btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; 8910 8911 (void)jenv; 8912 (void)jcls; 8913 (void)jarg1_; 8914 (void)jarg2_; 8915 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 8916 arg2 = *(btVector3FloatData **)&jarg2; 8917 if (arg1) (arg1)->m_aabbMaxOrg = *arg2; 8918 } 8919 8920 8921 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1aabbMaxOrg_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8922 jlong jresult = 0 ; 8923 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 8924 btVector3FloatData *result = 0 ; 8925 8926 (void)jenv; 8927 (void)jcls; 8928 (void)jarg1_; 8929 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 8930 result = (btVector3FloatData *)& ((arg1)->m_aabbMaxOrg); 8931 *(btVector3FloatData **)&jresult = result; 8932 return jresult; 8933 } 8934 8935 8936 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1escapeIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8937 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 8938 int arg2 ; 8939 8940 (void)jenv; 8941 (void)jcls; 8942 (void)jarg1_; 8943 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 8944 arg2 = (int)jarg2; 8945 if (arg1) (arg1)->m_escapeIndex = arg2; 8946 } 8947 8948 8949 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1escapeIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8950 jint jresult = 0 ; 8951 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 8952 int result; 8953 8954 (void)jenv; 8955 (void)jcls; 8956 (void)jarg1_; 8957 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 8958 result = (int) ((arg1)->m_escapeIndex); 8959 jresult = (jint)result; 8960 return jresult; 8961 } 8962 8963 8964 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1subPart_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8965 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 8966 int arg2 ; 8967 8968 (void)jenv; 8969 (void)jcls; 8970 (void)jarg1_; 8971 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 8972 arg2 = (int)jarg2; 8973 if (arg1) (arg1)->m_subPart = arg2; 8974 } 8975 8976 8977 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1subPart_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8978 jint jresult = 0 ; 8979 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 8980 int result; 8981 8982 (void)jenv; 8983 (void)jcls; 8984 (void)jarg1_; 8985 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 8986 result = (int) ((arg1)->m_subPart); 8987 jresult = (jint)result; 8988 return jresult; 8989 } 8990 8991 8992 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1triangleIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8993 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 8994 int arg2 ; 8995 8996 (void)jenv; 8997 (void)jcls; 8998 (void)jarg1_; 8999 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 9000 arg2 = (int)jarg2; 9001 if (arg1) (arg1)->m_triangleIndex = arg2; 9002 } 9003 9004 9005 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1triangleIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9006 jint jresult = 0 ; 9007 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 9008 int result; 9009 9010 (void)jenv; 9011 (void)jcls; 9012 (void)jarg1_; 9013 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 9014 result = (int) ((arg1)->m_triangleIndex); 9015 jresult = (jint)result; 9016 return jresult; 9017 } 9018 9019 9020 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1pad_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 9021 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 9022 char *arg2 ; 9023 9024 (void)jenv; 9025 (void)jcls; 9026 (void)jarg1_; 9027 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 9028 arg2 = 0; 9029 if (jarg2) { 9030 arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); 9031 if (!arg2) return ; 9032 } 9033 { 9034 if(arg2) { 9035 strncpy((char*)arg1->m_pad, (const char *)arg2, 4-1); 9036 arg1->m_pad[4-1] = 0; 9037 } else { 9038 arg1->m_pad[0] = 0; 9039 } 9040 } 9041 9042 if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); 9043 } 9044 9045 9046 SWIGEXPORT jstring JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeFloatData_1pad_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9047 jstring jresult = 0 ; 9048 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 9049 char *result = 0 ; 9050 9051 (void)jenv; 9052 (void)jcls; 9053 (void)jarg1_; 9054 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 9055 result = (char *)(char *) ((arg1)->m_pad); 9056 if (result) jresult = jenv->NewStringUTF((const char *)result); 9057 return jresult; 9058 } 9059 9060 9061 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btOptimizedBvhNodeFloatData(JNIEnv *jenv, jclass jcls) { 9062 jlong jresult = 0 ; 9063 btOptimizedBvhNodeFloatData *result = 0 ; 9064 9065 (void)jenv; 9066 (void)jcls; 9067 result = (btOptimizedBvhNodeFloatData *)new btOptimizedBvhNodeFloatData(); 9068 *(btOptimizedBvhNodeFloatData **)&jresult = result; 9069 return jresult; 9070 } 9071 9072 9073 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btOptimizedBvhNodeFloatData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 9074 btOptimizedBvhNodeFloatData *arg1 = (btOptimizedBvhNodeFloatData *) 0 ; 9075 9076 (void)jenv; 9077 (void)jcls; 9078 arg1 = *(btOptimizedBvhNodeFloatData **)&jarg1; 9079 delete arg1; 9080 } 9081 9082 9083 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1aabbMinOrg_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9084 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9085 btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; 9086 9087 (void)jenv; 9088 (void)jcls; 9089 (void)jarg1_; 9090 (void)jarg2_; 9091 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9092 arg2 = *(btVector3DoubleData **)&jarg2; 9093 if (arg1) (arg1)->m_aabbMinOrg = *arg2; 9094 } 9095 9096 9097 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1aabbMinOrg_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9098 jlong jresult = 0 ; 9099 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9100 btVector3DoubleData *result = 0 ; 9101 9102 (void)jenv; 9103 (void)jcls; 9104 (void)jarg1_; 9105 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9106 result = (btVector3DoubleData *)& ((arg1)->m_aabbMinOrg); 9107 *(btVector3DoubleData **)&jresult = result; 9108 return jresult; 9109 } 9110 9111 9112 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1aabbMaxOrg_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9113 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9114 btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; 9115 9116 (void)jenv; 9117 (void)jcls; 9118 (void)jarg1_; 9119 (void)jarg2_; 9120 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9121 arg2 = *(btVector3DoubleData **)&jarg2; 9122 if (arg1) (arg1)->m_aabbMaxOrg = *arg2; 9123 } 9124 9125 9126 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1aabbMaxOrg_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9127 jlong jresult = 0 ; 9128 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9129 btVector3DoubleData *result = 0 ; 9130 9131 (void)jenv; 9132 (void)jcls; 9133 (void)jarg1_; 9134 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9135 result = (btVector3DoubleData *)& ((arg1)->m_aabbMaxOrg); 9136 *(btVector3DoubleData **)&jresult = result; 9137 return jresult; 9138 } 9139 9140 9141 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1escapeIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9142 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9143 int arg2 ; 9144 9145 (void)jenv; 9146 (void)jcls; 9147 (void)jarg1_; 9148 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9149 arg2 = (int)jarg2; 9150 if (arg1) (arg1)->m_escapeIndex = arg2; 9151 } 9152 9153 9154 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1escapeIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9155 jint jresult = 0 ; 9156 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9157 int result; 9158 9159 (void)jenv; 9160 (void)jcls; 9161 (void)jarg1_; 9162 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9163 result = (int) ((arg1)->m_escapeIndex); 9164 jresult = (jint)result; 9165 return jresult; 9166 } 9167 9168 9169 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1subPart_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9170 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9171 int arg2 ; 9172 9173 (void)jenv; 9174 (void)jcls; 9175 (void)jarg1_; 9176 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9177 arg2 = (int)jarg2; 9178 if (arg1) (arg1)->m_subPart = arg2; 9179 } 9180 9181 9182 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1subPart_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9183 jint jresult = 0 ; 9184 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9185 int result; 9186 9187 (void)jenv; 9188 (void)jcls; 9189 (void)jarg1_; 9190 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9191 result = (int) ((arg1)->m_subPart); 9192 jresult = (jint)result; 9193 return jresult; 9194 } 9195 9196 9197 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1triangleIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9198 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9199 int arg2 ; 9200 9201 (void)jenv; 9202 (void)jcls; 9203 (void)jarg1_; 9204 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9205 arg2 = (int)jarg2; 9206 if (arg1) (arg1)->m_triangleIndex = arg2; 9207 } 9208 9209 9210 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1triangleIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9211 jint jresult = 0 ; 9212 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9213 int result; 9214 9215 (void)jenv; 9216 (void)jcls; 9217 (void)jarg1_; 9218 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9219 result = (int) ((arg1)->m_triangleIndex); 9220 jresult = (jint)result; 9221 return jresult; 9222 } 9223 9224 9225 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1pad_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 9226 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9227 char *arg2 ; 9228 9229 (void)jenv; 9230 (void)jcls; 9231 (void)jarg1_; 9232 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9233 arg2 = 0; 9234 if (jarg2) { 9235 arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); 9236 if (!arg2) return ; 9237 } 9238 { 9239 if(arg2) { 9240 strncpy((char*)arg1->m_pad, (const char *)arg2, 4-1); 9241 arg1->m_pad[4-1] = 0; 9242 } else { 9243 arg1->m_pad[0] = 0; 9244 } 9245 } 9246 9247 if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); 9248 } 9249 9250 9251 SWIGEXPORT jstring JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOptimizedBvhNodeDoubleData_1pad_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9252 jstring jresult = 0 ; 9253 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9254 char *result = 0 ; 9255 9256 (void)jenv; 9257 (void)jcls; 9258 (void)jarg1_; 9259 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9260 result = (char *)(char *) ((arg1)->m_pad); 9261 if (result) jresult = jenv->NewStringUTF((const char *)result); 9262 return jresult; 9263 } 9264 9265 9266 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btOptimizedBvhNodeDoubleData(JNIEnv *jenv, jclass jcls) { 9267 jlong jresult = 0 ; 9268 btOptimizedBvhNodeDoubleData *result = 0 ; 9269 9270 (void)jenv; 9271 (void)jcls; 9272 result = (btOptimizedBvhNodeDoubleData *)new btOptimizedBvhNodeDoubleData(); 9273 *(btOptimizedBvhNodeDoubleData **)&jresult = result; 9274 return jresult; 9275 } 9276 9277 9278 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btOptimizedBvhNodeDoubleData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 9279 btOptimizedBvhNodeDoubleData *arg1 = (btOptimizedBvhNodeDoubleData *) 0 ; 9280 9281 (void)jenv; 9282 (void)jcls; 9283 arg1 = *(btOptimizedBvhNodeDoubleData **)&jarg1; 9284 delete arg1; 9285 } 9286 9287 9288 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNodeData_1quantizedAabbMin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 9289 btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; 9290 unsigned short *arg2 ; 9291 jint *jarr2 ; 9292 9293 (void)jenv; 9294 (void)jcls; 9295 (void)jarg1_; 9296 arg1 = *(btQuantizedBvhNodeData **)&jarg1; 9297 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 9298 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 9299 return ; 9300 } 9301 if (!SWIG_JavaArrayInUshort(jenv, &jarr2, (unsigned short **)&arg2, jarg2)) return ; 9302 { 9303 size_t ii; 9304 unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMin; 9305 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); 9306 } 9307 SWIG_JavaArrayArgoutUshort(jenv, jarr2, (unsigned short *)arg2, jarg2); 9308 delete [] arg2; 9309 } 9310 9311 9312 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNodeData_1quantizedAabbMin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9313 jintArray jresult = 0 ; 9314 btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; 9315 unsigned short *result = 0 ; 9316 9317 (void)jenv; 9318 (void)jcls; 9319 (void)jarg1_; 9320 arg1 = *(btQuantizedBvhNodeData **)&jarg1; 9321 result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMin); 9322 jresult = SWIG_JavaArrayOutUshort(jenv, (unsigned short *)result, 3); 9323 return jresult; 9324 } 9325 9326 9327 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNodeData_1quantizedAabbMax_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 9328 btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; 9329 unsigned short *arg2 ; 9330 jint *jarr2 ; 9331 9332 (void)jenv; 9333 (void)jcls; 9334 (void)jarg1_; 9335 arg1 = *(btQuantizedBvhNodeData **)&jarg1; 9336 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 9337 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 9338 return ; 9339 } 9340 if (!SWIG_JavaArrayInUshort(jenv, &jarr2, (unsigned short **)&arg2, jarg2)) return ; 9341 { 9342 size_t ii; 9343 unsigned short *b = (unsigned short *) arg1->m_quantizedAabbMax; 9344 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); 9345 } 9346 SWIG_JavaArrayArgoutUshort(jenv, jarr2, (unsigned short *)arg2, jarg2); 9347 delete [] arg2; 9348 } 9349 9350 9351 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNodeData_1quantizedAabbMax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9352 jintArray jresult = 0 ; 9353 btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; 9354 unsigned short *result = 0 ; 9355 9356 (void)jenv; 9357 (void)jcls; 9358 (void)jarg1_; 9359 arg1 = *(btQuantizedBvhNodeData **)&jarg1; 9360 result = (unsigned short *)(unsigned short *) ((arg1)->m_quantizedAabbMax); 9361 jresult = SWIG_JavaArrayOutUshort(jenv, (unsigned short *)result, 3); 9362 return jresult; 9363 } 9364 9365 9366 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNodeData_1escapeIndexOrTriangleIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9367 btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; 9368 int arg2 ; 9369 9370 (void)jenv; 9371 (void)jcls; 9372 (void)jarg1_; 9373 arg1 = *(btQuantizedBvhNodeData **)&jarg1; 9374 arg2 = (int)jarg2; 9375 if (arg1) (arg1)->m_escapeIndexOrTriangleIndex = arg2; 9376 } 9377 9378 9379 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhNodeData_1escapeIndexOrTriangleIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9380 jint jresult = 0 ; 9381 btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; 9382 int result; 9383 9384 (void)jenv; 9385 (void)jcls; 9386 (void)jarg1_; 9387 arg1 = *(btQuantizedBvhNodeData **)&jarg1; 9388 result = (int) ((arg1)->m_escapeIndexOrTriangleIndex); 9389 jresult = (jint)result; 9390 return jresult; 9391 } 9392 9393 9394 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btQuantizedBvhNodeData(JNIEnv *jenv, jclass jcls) { 9395 jlong jresult = 0 ; 9396 btQuantizedBvhNodeData *result = 0 ; 9397 9398 (void)jenv; 9399 (void)jcls; 9400 result = (btQuantizedBvhNodeData *)new btQuantizedBvhNodeData(); 9401 *(btQuantizedBvhNodeData **)&jresult = result; 9402 return jresult; 9403 } 9404 9405 9406 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btQuantizedBvhNodeData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 9407 btQuantizedBvhNodeData *arg1 = (btQuantizedBvhNodeData *) 0 ; 9408 9409 (void)jenv; 9410 (void)jcls; 9411 arg1 = *(btQuantizedBvhNodeData **)&jarg1; 9412 delete arg1; 9413 } 9414 9415 9416 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1bvhAabbMin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9417 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9418 btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; 9419 9420 (void)jenv; 9421 (void)jcls; 9422 (void)jarg1_; 9423 (void)jarg2_; 9424 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9425 arg2 = *(btVector3FloatData **)&jarg2; 9426 if (arg1) (arg1)->m_bvhAabbMin = *arg2; 9427 } 9428 9429 9430 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1bvhAabbMin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9431 jlong jresult = 0 ; 9432 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9433 btVector3FloatData *result = 0 ; 9434 9435 (void)jenv; 9436 (void)jcls; 9437 (void)jarg1_; 9438 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9439 result = (btVector3FloatData *)& ((arg1)->m_bvhAabbMin); 9440 *(btVector3FloatData **)&jresult = result; 9441 return jresult; 9442 } 9443 9444 9445 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1bvhAabbMax_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9446 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9447 btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; 9448 9449 (void)jenv; 9450 (void)jcls; 9451 (void)jarg1_; 9452 (void)jarg2_; 9453 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9454 arg2 = *(btVector3FloatData **)&jarg2; 9455 if (arg1) (arg1)->m_bvhAabbMax = *arg2; 9456 } 9457 9458 9459 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1bvhAabbMax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9460 jlong jresult = 0 ; 9461 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9462 btVector3FloatData *result = 0 ; 9463 9464 (void)jenv; 9465 (void)jcls; 9466 (void)jarg1_; 9467 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9468 result = (btVector3FloatData *)& ((arg1)->m_bvhAabbMax); 9469 *(btVector3FloatData **)&jresult = result; 9470 return jresult; 9471 } 9472 9473 9474 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1bvhQuantization_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9475 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9476 btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; 9477 9478 (void)jenv; 9479 (void)jcls; 9480 (void)jarg1_; 9481 (void)jarg2_; 9482 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9483 arg2 = *(btVector3FloatData **)&jarg2; 9484 if (arg1) (arg1)->m_bvhQuantization = *arg2; 9485 } 9486 9487 9488 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1bvhQuantization_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9489 jlong jresult = 0 ; 9490 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9491 btVector3FloatData *result = 0 ; 9492 9493 (void)jenv; 9494 (void)jcls; 9495 (void)jarg1_; 9496 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9497 result = (btVector3FloatData *)& ((arg1)->m_bvhQuantization); 9498 *(btVector3FloatData **)&jresult = result; 9499 return jresult; 9500 } 9501 9502 9503 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1curNodeIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9504 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9505 int arg2 ; 9506 9507 (void)jenv; 9508 (void)jcls; 9509 (void)jarg1_; 9510 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9511 arg2 = (int)jarg2; 9512 if (arg1) (arg1)->m_curNodeIndex = arg2; 9513 } 9514 9515 9516 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1curNodeIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9517 jint jresult = 0 ; 9518 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9519 int result; 9520 9521 (void)jenv; 9522 (void)jcls; 9523 (void)jarg1_; 9524 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9525 result = (int) ((arg1)->m_curNodeIndex); 9526 jresult = (jint)result; 9527 return jresult; 9528 } 9529 9530 9531 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1useQuantization_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9532 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9533 int arg2 ; 9534 9535 (void)jenv; 9536 (void)jcls; 9537 (void)jarg1_; 9538 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9539 arg2 = (int)jarg2; 9540 if (arg1) (arg1)->m_useQuantization = arg2; 9541 } 9542 9543 9544 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1useQuantization_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9545 jint jresult = 0 ; 9546 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9547 int result; 9548 9549 (void)jenv; 9550 (void)jcls; 9551 (void)jarg1_; 9552 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9553 result = (int) ((arg1)->m_useQuantization); 9554 jresult = (jint)result; 9555 return jresult; 9556 } 9557 9558 9559 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1numContiguousLeafNodes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9560 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9561 int arg2 ; 9562 9563 (void)jenv; 9564 (void)jcls; 9565 (void)jarg1_; 9566 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9567 arg2 = (int)jarg2; 9568 if (arg1) (arg1)->m_numContiguousLeafNodes = arg2; 9569 } 9570 9571 9572 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1numContiguousLeafNodes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9573 jint jresult = 0 ; 9574 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9575 int result; 9576 9577 (void)jenv; 9578 (void)jcls; 9579 (void)jarg1_; 9580 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9581 result = (int) ((arg1)->m_numContiguousLeafNodes); 9582 jresult = (jint)result; 9583 return jresult; 9584 } 9585 9586 9587 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1numQuantizedContiguousNodes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9588 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9589 int arg2 ; 9590 9591 (void)jenv; 9592 (void)jcls; 9593 (void)jarg1_; 9594 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9595 arg2 = (int)jarg2; 9596 if (arg1) (arg1)->m_numQuantizedContiguousNodes = arg2; 9597 } 9598 9599 9600 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1numQuantizedContiguousNodes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9601 jint jresult = 0 ; 9602 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9603 int result; 9604 9605 (void)jenv; 9606 (void)jcls; 9607 (void)jarg1_; 9608 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9609 result = (int) ((arg1)->m_numQuantizedContiguousNodes); 9610 jresult = (jint)result; 9611 return jresult; 9612 } 9613 9614 9615 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1contiguousNodesPtr_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9616 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9617 btOptimizedBvhNodeFloatData *arg2 = (btOptimizedBvhNodeFloatData *) 0 ; 9618 9619 (void)jenv; 9620 (void)jcls; 9621 (void)jarg1_; 9622 (void)jarg2_; 9623 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9624 arg2 = *(btOptimizedBvhNodeFloatData **)&jarg2; 9625 if (arg1) (arg1)->m_contiguousNodesPtr = arg2; 9626 } 9627 9628 9629 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1contiguousNodesPtr_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9630 jlong jresult = 0 ; 9631 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9632 btOptimizedBvhNodeFloatData *result = 0 ; 9633 9634 (void)jenv; 9635 (void)jcls; 9636 (void)jarg1_; 9637 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9638 result = (btOptimizedBvhNodeFloatData *) ((arg1)->m_contiguousNodesPtr); 9639 *(btOptimizedBvhNodeFloatData **)&jresult = result; 9640 return jresult; 9641 } 9642 9643 9644 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1quantizedContiguousNodesPtr_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9645 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9646 btQuantizedBvhNodeData *arg2 = (btQuantizedBvhNodeData *) 0 ; 9647 9648 (void)jenv; 9649 (void)jcls; 9650 (void)jarg1_; 9651 (void)jarg2_; 9652 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9653 arg2 = *(btQuantizedBvhNodeData **)&jarg2; 9654 if (arg1) (arg1)->m_quantizedContiguousNodesPtr = arg2; 9655 } 9656 9657 9658 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1quantizedContiguousNodesPtr_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9659 jlong jresult = 0 ; 9660 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9661 btQuantizedBvhNodeData *result = 0 ; 9662 9663 (void)jenv; 9664 (void)jcls; 9665 (void)jarg1_; 9666 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9667 result = (btQuantizedBvhNodeData *) ((arg1)->m_quantizedContiguousNodesPtr); 9668 *(btQuantizedBvhNodeData **)&jresult = result; 9669 return jresult; 9670 } 9671 9672 9673 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1subTreeInfoPtr_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9674 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9675 btBvhSubtreeInfoData *arg2 = (btBvhSubtreeInfoData *) 0 ; 9676 9677 (void)jenv; 9678 (void)jcls; 9679 (void)jarg1_; 9680 (void)jarg2_; 9681 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9682 arg2 = *(btBvhSubtreeInfoData **)&jarg2; 9683 if (arg1) (arg1)->m_subTreeInfoPtr = arg2; 9684 } 9685 9686 9687 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1subTreeInfoPtr_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9688 jlong jresult = 0 ; 9689 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9690 btBvhSubtreeInfoData *result = 0 ; 9691 9692 (void)jenv; 9693 (void)jcls; 9694 (void)jarg1_; 9695 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9696 result = (btBvhSubtreeInfoData *) ((arg1)->m_subTreeInfoPtr); 9697 *(btBvhSubtreeInfoData **)&jresult = result; 9698 return jresult; 9699 } 9700 9701 9702 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1traversalMode_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9703 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9704 int arg2 ; 9705 9706 (void)jenv; 9707 (void)jcls; 9708 (void)jarg1_; 9709 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9710 arg2 = (int)jarg2; 9711 if (arg1) (arg1)->m_traversalMode = arg2; 9712 } 9713 9714 9715 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1traversalMode_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9716 jint jresult = 0 ; 9717 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9718 int result; 9719 9720 (void)jenv; 9721 (void)jcls; 9722 (void)jarg1_; 9723 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9724 result = (int) ((arg1)->m_traversalMode); 9725 jresult = (jint)result; 9726 return jresult; 9727 } 9728 9729 9730 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1numSubtreeHeaders_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9731 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9732 int arg2 ; 9733 9734 (void)jenv; 9735 (void)jcls; 9736 (void)jarg1_; 9737 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9738 arg2 = (int)jarg2; 9739 if (arg1) (arg1)->m_numSubtreeHeaders = arg2; 9740 } 9741 9742 9743 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhFloatData_1numSubtreeHeaders_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9744 jint jresult = 0 ; 9745 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9746 int result; 9747 9748 (void)jenv; 9749 (void)jcls; 9750 (void)jarg1_; 9751 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9752 result = (int) ((arg1)->m_numSubtreeHeaders); 9753 jresult = (jint)result; 9754 return jresult; 9755 } 9756 9757 9758 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btQuantizedBvhFloatData(JNIEnv *jenv, jclass jcls) { 9759 jlong jresult = 0 ; 9760 btQuantizedBvhFloatData *result = 0 ; 9761 9762 (void)jenv; 9763 (void)jcls; 9764 result = (btQuantizedBvhFloatData *)new btQuantizedBvhFloatData(); 9765 *(btQuantizedBvhFloatData **)&jresult = result; 9766 return jresult; 9767 } 9768 9769 9770 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btQuantizedBvhFloatData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 9771 btQuantizedBvhFloatData *arg1 = (btQuantizedBvhFloatData *) 0 ; 9772 9773 (void)jenv; 9774 (void)jcls; 9775 arg1 = *(btQuantizedBvhFloatData **)&jarg1; 9776 delete arg1; 9777 } 9778 9779 9780 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1bvhAabbMin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9781 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9782 btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; 9783 9784 (void)jenv; 9785 (void)jcls; 9786 (void)jarg1_; 9787 (void)jarg2_; 9788 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9789 arg2 = *(btVector3DoubleData **)&jarg2; 9790 if (arg1) (arg1)->m_bvhAabbMin = *arg2; 9791 } 9792 9793 9794 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1bvhAabbMin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9795 jlong jresult = 0 ; 9796 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9797 btVector3DoubleData *result = 0 ; 9798 9799 (void)jenv; 9800 (void)jcls; 9801 (void)jarg1_; 9802 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9803 result = (btVector3DoubleData *)& ((arg1)->m_bvhAabbMin); 9804 *(btVector3DoubleData **)&jresult = result; 9805 return jresult; 9806 } 9807 9808 9809 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1bvhAabbMax_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9810 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9811 btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; 9812 9813 (void)jenv; 9814 (void)jcls; 9815 (void)jarg1_; 9816 (void)jarg2_; 9817 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9818 arg2 = *(btVector3DoubleData **)&jarg2; 9819 if (arg1) (arg1)->m_bvhAabbMax = *arg2; 9820 } 9821 9822 9823 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1bvhAabbMax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9824 jlong jresult = 0 ; 9825 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9826 btVector3DoubleData *result = 0 ; 9827 9828 (void)jenv; 9829 (void)jcls; 9830 (void)jarg1_; 9831 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9832 result = (btVector3DoubleData *)& ((arg1)->m_bvhAabbMax); 9833 *(btVector3DoubleData **)&jresult = result; 9834 return jresult; 9835 } 9836 9837 9838 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1bvhQuantization_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9839 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9840 btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; 9841 9842 (void)jenv; 9843 (void)jcls; 9844 (void)jarg1_; 9845 (void)jarg2_; 9846 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9847 arg2 = *(btVector3DoubleData **)&jarg2; 9848 if (arg1) (arg1)->m_bvhQuantization = *arg2; 9849 } 9850 9851 9852 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1bvhQuantization_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9853 jlong jresult = 0 ; 9854 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9855 btVector3DoubleData *result = 0 ; 9856 9857 (void)jenv; 9858 (void)jcls; 9859 (void)jarg1_; 9860 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9861 result = (btVector3DoubleData *)& ((arg1)->m_bvhQuantization); 9862 *(btVector3DoubleData **)&jresult = result; 9863 return jresult; 9864 } 9865 9866 9867 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1curNodeIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9868 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9869 int arg2 ; 9870 9871 (void)jenv; 9872 (void)jcls; 9873 (void)jarg1_; 9874 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9875 arg2 = (int)jarg2; 9876 if (arg1) (arg1)->m_curNodeIndex = arg2; 9877 } 9878 9879 9880 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1curNodeIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9881 jint jresult = 0 ; 9882 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9883 int result; 9884 9885 (void)jenv; 9886 (void)jcls; 9887 (void)jarg1_; 9888 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9889 result = (int) ((arg1)->m_curNodeIndex); 9890 jresult = (jint)result; 9891 return jresult; 9892 } 9893 9894 9895 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1useQuantization_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9896 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9897 int arg2 ; 9898 9899 (void)jenv; 9900 (void)jcls; 9901 (void)jarg1_; 9902 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9903 arg2 = (int)jarg2; 9904 if (arg1) (arg1)->m_useQuantization = arg2; 9905 } 9906 9907 9908 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1useQuantization_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9909 jint jresult = 0 ; 9910 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9911 int result; 9912 9913 (void)jenv; 9914 (void)jcls; 9915 (void)jarg1_; 9916 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9917 result = (int) ((arg1)->m_useQuantization); 9918 jresult = (jint)result; 9919 return jresult; 9920 } 9921 9922 9923 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1numContiguousLeafNodes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9924 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9925 int arg2 ; 9926 9927 (void)jenv; 9928 (void)jcls; 9929 (void)jarg1_; 9930 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9931 arg2 = (int)jarg2; 9932 if (arg1) (arg1)->m_numContiguousLeafNodes = arg2; 9933 } 9934 9935 9936 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1numContiguousLeafNodes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9937 jint jresult = 0 ; 9938 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9939 int result; 9940 9941 (void)jenv; 9942 (void)jcls; 9943 (void)jarg1_; 9944 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9945 result = (int) ((arg1)->m_numContiguousLeafNodes); 9946 jresult = (jint)result; 9947 return jresult; 9948 } 9949 9950 9951 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1numQuantizedContiguousNodes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9952 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9953 int arg2 ; 9954 9955 (void)jenv; 9956 (void)jcls; 9957 (void)jarg1_; 9958 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9959 arg2 = (int)jarg2; 9960 if (arg1) (arg1)->m_numQuantizedContiguousNodes = arg2; 9961 } 9962 9963 9964 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1numQuantizedContiguousNodes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9965 jint jresult = 0 ; 9966 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9967 int result; 9968 9969 (void)jenv; 9970 (void)jcls; 9971 (void)jarg1_; 9972 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9973 result = (int) ((arg1)->m_numQuantizedContiguousNodes); 9974 jresult = (jint)result; 9975 return jresult; 9976 } 9977 9978 9979 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1contiguousNodesPtr_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 9980 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9981 btOptimizedBvhNodeDoubleData *arg2 = (btOptimizedBvhNodeDoubleData *) 0 ; 9982 9983 (void)jenv; 9984 (void)jcls; 9985 (void)jarg1_; 9986 (void)jarg2_; 9987 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 9988 arg2 = *(btOptimizedBvhNodeDoubleData **)&jarg2; 9989 if (arg1) (arg1)->m_contiguousNodesPtr = arg2; 9990 } 9991 9992 9993 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1contiguousNodesPtr_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9994 jlong jresult = 0 ; 9995 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 9996 btOptimizedBvhNodeDoubleData *result = 0 ; 9997 9998 (void)jenv; 9999 (void)jcls; 10000 (void)jarg1_; 10001 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 10002 result = (btOptimizedBvhNodeDoubleData *) ((arg1)->m_contiguousNodesPtr); 10003 *(btOptimizedBvhNodeDoubleData **)&jresult = result; 10004 return jresult; 10005 } 10006 10007 10008 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1quantizedContiguousNodesPtr_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10009 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 10010 btQuantizedBvhNodeData *arg2 = (btQuantizedBvhNodeData *) 0 ; 10011 10012 (void)jenv; 10013 (void)jcls; 10014 (void)jarg1_; 10015 (void)jarg2_; 10016 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 10017 arg2 = *(btQuantizedBvhNodeData **)&jarg2; 10018 if (arg1) (arg1)->m_quantizedContiguousNodesPtr = arg2; 10019 } 10020 10021 10022 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1quantizedContiguousNodesPtr_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10023 jlong jresult = 0 ; 10024 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 10025 btQuantizedBvhNodeData *result = 0 ; 10026 10027 (void)jenv; 10028 (void)jcls; 10029 (void)jarg1_; 10030 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 10031 result = (btQuantizedBvhNodeData *) ((arg1)->m_quantizedContiguousNodesPtr); 10032 *(btQuantizedBvhNodeData **)&jresult = result; 10033 return jresult; 10034 } 10035 10036 10037 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1traversalMode_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10038 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 10039 int arg2 ; 10040 10041 (void)jenv; 10042 (void)jcls; 10043 (void)jarg1_; 10044 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 10045 arg2 = (int)jarg2; 10046 if (arg1) (arg1)->m_traversalMode = arg2; 10047 } 10048 10049 10050 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1traversalMode_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10051 jint jresult = 0 ; 10052 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 10053 int result; 10054 10055 (void)jenv; 10056 (void)jcls; 10057 (void)jarg1_; 10058 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 10059 result = (int) ((arg1)->m_traversalMode); 10060 jresult = (jint)result; 10061 return jresult; 10062 } 10063 10064 10065 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1numSubtreeHeaders_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10066 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 10067 int arg2 ; 10068 10069 (void)jenv; 10070 (void)jcls; 10071 (void)jarg1_; 10072 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 10073 arg2 = (int)jarg2; 10074 if (arg1) (arg1)->m_numSubtreeHeaders = arg2; 10075 } 10076 10077 10078 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1numSubtreeHeaders_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10079 jint jresult = 0 ; 10080 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 10081 int result; 10082 10083 (void)jenv; 10084 (void)jcls; 10085 (void)jarg1_; 10086 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 10087 result = (int) ((arg1)->m_numSubtreeHeaders); 10088 jresult = (jint)result; 10089 return jresult; 10090 } 10091 10092 10093 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1subTreeInfoPtr_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10094 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 10095 btBvhSubtreeInfoData *arg2 = (btBvhSubtreeInfoData *) 0 ; 10096 10097 (void)jenv; 10098 (void)jcls; 10099 (void)jarg1_; 10100 (void)jarg2_; 10101 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 10102 arg2 = *(btBvhSubtreeInfoData **)&jarg2; 10103 if (arg1) (arg1)->m_subTreeInfoPtr = arg2; 10104 } 10105 10106 10107 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btQuantizedBvhDoubleData_1subTreeInfoPtr_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10108 jlong jresult = 0 ; 10109 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 10110 btBvhSubtreeInfoData *result = 0 ; 10111 10112 (void)jenv; 10113 (void)jcls; 10114 (void)jarg1_; 10115 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 10116 result = (btBvhSubtreeInfoData *) ((arg1)->m_subTreeInfoPtr); 10117 *(btBvhSubtreeInfoData **)&jresult = result; 10118 return jresult; 10119 } 10120 10121 10122 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btQuantizedBvhDoubleData(JNIEnv *jenv, jclass jcls) { 10123 jlong jresult = 0 ; 10124 btQuantizedBvhDoubleData *result = 0 ; 10125 10126 (void)jenv; 10127 (void)jcls; 10128 result = (btQuantizedBvhDoubleData *)new btQuantizedBvhDoubleData(); 10129 *(btQuantizedBvhDoubleData **)&jresult = result; 10130 return jresult; 10131 } 10132 10133 10134 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btQuantizedBvhDoubleData(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10135 btQuantizedBvhDoubleData *arg1 = (btQuantizedBvhDoubleData *) 0 ; 10136 10137 (void)jenv; 10138 (void)jcls; 10139 arg1 = *(btQuantizedBvhDoubleData **)&jarg1; 10140 delete arg1; 10141 } 10142 10143 10144 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btSimpleBroadphaseProxy_1nextFree_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10145 btSimpleBroadphaseProxy *arg1 = (btSimpleBroadphaseProxy *) 0 ; 10146 int arg2 ; 10147 10148 (void)jenv; 10149 (void)jcls; 10150 (void)jarg1_; 10151 arg1 = *(btSimpleBroadphaseProxy **)&jarg1; 10152 arg2 = (int)jarg2; 10153 if (arg1) (arg1)->m_nextFree = arg2; 10154 } 10155 10156 10157 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btSimpleBroadphaseProxy_1nextFree_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10158 jint jresult = 0 ; 10159 btSimpleBroadphaseProxy *arg1 = (btSimpleBroadphaseProxy *) 0 ; 10160 int result; 10161 10162 (void)jenv; 10163 (void)jcls; 10164 (void)jarg1_; 10165 arg1 = *(btSimpleBroadphaseProxy **)&jarg1; 10166 result = (int) ((arg1)->m_nextFree); 10167 jresult = (jint)result; 10168 return jresult; 10169 } 10170 10171 10172 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btSimpleBroadphaseProxy_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 10173 jlong jresult = 0 ; 10174 btSimpleBroadphaseProxy *result = 0 ; 10175 10176 (void)jenv; 10177 (void)jcls; 10178 result = (btSimpleBroadphaseProxy *)new btSimpleBroadphaseProxy(); 10179 *(btSimpleBroadphaseProxy **)&jresult = result; 10180 return jresult; 10181 } 10182 10183 10184 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btSimpleBroadphaseProxy_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3, jlong jarg4, jshort jarg5, jshort jarg6, jlong jarg7) { 10185 jlong jresult = 0 ; 10186 btVector3 *arg1 = 0 ; 10187 btVector3 *arg2 = 0 ; 10188 int arg3 ; 10189 void *arg4 = (void *) 0 ; 10190 short arg5 ; 10191 short arg6 ; 10192 void *arg7 = (void *) 0 ; 10193 btSimpleBroadphaseProxy *result = 0 ; 10194 10195 (void)jenv; 10196 (void)jcls; 10197 btVector3 local_arg1; 10198 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 10199 arg1 = &local_arg1; 10200 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 10201 btVector3 local_arg2; 10202 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 10203 arg2 = &local_arg2; 10204 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 10205 arg3 = (int)jarg3; 10206 arg4 = (void *)jarg4; 10207 arg5 = (short)jarg5; 10208 arg6 = (short)jarg6; 10209 arg7 = (void *)jarg7; 10210 result = (btSimpleBroadphaseProxy *)new btSimpleBroadphaseProxy((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); 10211 *(btSimpleBroadphaseProxy **)&jresult = result; 10212 return jresult; 10213 } 10214 10215 10216 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btSimpleBroadphaseProxy_1SetNextFree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10217 btSimpleBroadphaseProxy *arg1 = (btSimpleBroadphaseProxy *) 0 ; 10218 int arg2 ; 10219 10220 (void)jenv; 10221 (void)jcls; 10222 (void)jarg1_; 10223 arg1 = *(btSimpleBroadphaseProxy **)&jarg1; 10224 arg2 = (int)jarg2; 10225 (arg1)->SetNextFree(arg2); 10226 } 10227 10228 10229 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btSimpleBroadphaseProxy_1GetNextFree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10230 jint jresult = 0 ; 10231 btSimpleBroadphaseProxy *arg1 = (btSimpleBroadphaseProxy *) 0 ; 10232 int result; 10233 10234 (void)jenv; 10235 (void)jcls; 10236 (void)jarg1_; 10237 arg1 = *(btSimpleBroadphaseProxy **)&jarg1; 10238 result = (int)((btSimpleBroadphaseProxy const *)arg1)->GetNextFree(); 10239 jresult = (jint)result; 10240 return jresult; 10241 } 10242 10243 10244 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btSimpleBroadphaseProxy(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10245 btSimpleBroadphaseProxy *arg1 = (btSimpleBroadphaseProxy *) 0 ; 10246 10247 (void)jenv; 10248 (void)jcls; 10249 arg1 = *(btSimpleBroadphaseProxy **)&jarg1; 10250 delete arg1; 10251 } 10252 10253 10254 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btSimpleBroadphase_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) { 10255 jlong jresult = 0 ; 10256 int arg1 ; 10257 btOverlappingPairCache *arg2 = (btOverlappingPairCache *) 0 ; 10258 btSimpleBroadphase *result = 0 ; 10259 10260 (void)jenv; 10261 (void)jcls; 10262 (void)jarg2_; 10263 arg1 = (int)jarg1; 10264 arg2 = *(btOverlappingPairCache **)&jarg2; 10265 result = (btSimpleBroadphase *)new btSimpleBroadphase(arg1,arg2); 10266 *(btSimpleBroadphase **)&jresult = result; 10267 return jresult; 10268 } 10269 10270 10271 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btSimpleBroadphase_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1) { 10272 jlong jresult = 0 ; 10273 int arg1 ; 10274 btSimpleBroadphase *result = 0 ; 10275 10276 (void)jenv; 10277 (void)jcls; 10278 arg1 = (int)jarg1; 10279 result = (btSimpleBroadphase *)new btSimpleBroadphase(arg1); 10280 *(btSimpleBroadphase **)&jresult = result; 10281 return jresult; 10282 } 10283 10284 10285 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btSimpleBroadphase_1_1SWIG_12(JNIEnv *jenv, jclass jcls) { 10286 jlong jresult = 0 ; 10287 btSimpleBroadphase *result = 0 ; 10288 10289 (void)jenv; 10290 (void)jcls; 10291 result = (btSimpleBroadphase *)new btSimpleBroadphase(); 10292 *(btSimpleBroadphase **)&jresult = result; 10293 return jresult; 10294 } 10295 10296 10297 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btSimpleBroadphase(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10298 btSimpleBroadphase *arg1 = (btSimpleBroadphase *) 0 ; 10299 10300 (void)jenv; 10301 (void)jcls; 10302 arg1 = *(btSimpleBroadphase **)&jarg1; 10303 delete arg1; 10304 } 10305 10306 10307 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btSimpleBroadphase_1aabbOverlap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10308 jboolean jresult = 0 ; 10309 btSimpleBroadphaseProxy *arg1 = (btSimpleBroadphaseProxy *) 0 ; 10310 btSimpleBroadphaseProxy *arg2 = (btSimpleBroadphaseProxy *) 0 ; 10311 bool result; 10312 10313 (void)jenv; 10314 (void)jcls; 10315 (void)jarg1_; 10316 (void)jarg2_; 10317 arg1 = *(btSimpleBroadphaseProxy **)&jarg1; 10318 arg2 = *(btSimpleBroadphaseProxy **)&jarg2; 10319 result = (bool)btSimpleBroadphase::aabbOverlap(arg1,arg2); 10320 jresult = (jboolean)result; 10321 return jresult; 10322 } 10323 10324 10325 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btSimpleBroadphase_1rayTest_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jobject jarg5, jobject jarg6) { 10326 btSimpleBroadphase *arg1 = (btSimpleBroadphase *) 0 ; 10327 btVector3 *arg2 = 0 ; 10328 btVector3 *arg3 = 0 ; 10329 btBroadphaseRayCallback *arg4 = 0 ; 10330 btVector3 *arg5 = 0 ; 10331 btVector3 *arg6 = 0 ; 10332 10333 (void)jenv; 10334 (void)jcls; 10335 (void)jarg1_; 10336 (void)jarg4_; 10337 arg1 = *(btSimpleBroadphase **)&jarg1; 10338 btVector3 local_arg2; 10339 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 10340 arg2 = &local_arg2; 10341 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 10342 btVector3 local_arg3; 10343 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 10344 arg3 = &local_arg3; 10345 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 10346 arg4 = *(btBroadphaseRayCallback **)&jarg4; 10347 if (!arg4) { 10348 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 10349 return ; 10350 } 10351 btVector3 local_arg5; 10352 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 10353 arg5 = &local_arg5; 10354 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 10355 btVector3 local_arg6; 10356 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 10357 arg6 = &local_arg6; 10358 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 10359 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); 10360 } 10361 10362 10363 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btSimpleBroadphase_1rayTest_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jobject jarg5) { 10364 btSimpleBroadphase *arg1 = (btSimpleBroadphase *) 0 ; 10365 btVector3 *arg2 = 0 ; 10366 btVector3 *arg3 = 0 ; 10367 btBroadphaseRayCallback *arg4 = 0 ; 10368 btVector3 *arg5 = 0 ; 10369 10370 (void)jenv; 10371 (void)jcls; 10372 (void)jarg1_; 10373 (void)jarg4_; 10374 arg1 = *(btSimpleBroadphase **)&jarg1; 10375 btVector3 local_arg2; 10376 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 10377 arg2 = &local_arg2; 10378 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 10379 btVector3 local_arg3; 10380 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 10381 arg3 = &local_arg3; 10382 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 10383 arg4 = *(btBroadphaseRayCallback **)&jarg4; 10384 if (!arg4) { 10385 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 10386 return ; 10387 } 10388 btVector3 local_arg5; 10389 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 10390 arg5 = &local_arg5; 10391 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 10392 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5); 10393 } 10394 10395 10396 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btSimpleBroadphase_1rayTest_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_) { 10397 btSimpleBroadphase *arg1 = (btSimpleBroadphase *) 0 ; 10398 btVector3 *arg2 = 0 ; 10399 btVector3 *arg3 = 0 ; 10400 btBroadphaseRayCallback *arg4 = 0 ; 10401 10402 (void)jenv; 10403 (void)jcls; 10404 (void)jarg1_; 10405 (void)jarg4_; 10406 arg1 = *(btSimpleBroadphase **)&jarg1; 10407 btVector3 local_arg2; 10408 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 10409 arg2 = &local_arg2; 10410 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 10411 btVector3 local_arg3; 10412 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 10413 arg3 = &local_arg3; 10414 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 10415 arg4 = *(btBroadphaseRayCallback **)&jarg4; 10416 if (!arg4) { 10417 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 10418 return ; 10419 } 10420 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); 10421 } 10422 10423 10424 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btSimpleBroadphase_1getOverlappingPairCache_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10425 jlong jresult = 0 ; 10426 btSimpleBroadphase *arg1 = (btSimpleBroadphase *) 0 ; 10427 btOverlappingPairCache *result = 0 ; 10428 10429 (void)jenv; 10430 (void)jcls; 10431 (void)jarg1_; 10432 arg1 = *(btSimpleBroadphase **)&jarg1; 10433 result = (btOverlappingPairCache *)(arg1)->getOverlappingPairCache(); 10434 *(btOverlappingPairCache **)&jresult = result; 10435 return jresult; 10436 } 10437 10438 10439 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btSimpleBroadphase_1testAabbOverlap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) { 10440 jboolean jresult = 0 ; 10441 btSimpleBroadphase *arg1 = (btSimpleBroadphase *) 0 ; 10442 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 10443 btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; 10444 bool result; 10445 10446 (void)jenv; 10447 (void)jcls; 10448 (void)jarg1_; 10449 (void)jarg2_; 10450 (void)jarg3_; 10451 arg1 = *(btSimpleBroadphase **)&jarg1; 10452 arg2 = *(btBroadphaseProxy **)&jarg2; 10453 arg3 = *(btBroadphaseProxy **)&jarg3; 10454 result = (bool)(arg1)->testAabbOverlap(arg2,arg3); 10455 jresult = (jboolean)result; 10456 return jresult; 10457 } 10458 10459 10460 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1btMultiSapProxy_1aabbMin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10461 btMultiSapBroadphase::btMultiSapProxy *arg1 = (btMultiSapBroadphase::btMultiSapProxy *) 0 ; 10462 btVector3 *arg2 = (btVector3 *) 0 ; 10463 10464 (void)jenv; 10465 (void)jcls; 10466 (void)jarg1_; 10467 (void)jarg2_; 10468 arg1 = *(btMultiSapBroadphase::btMultiSapProxy **)&jarg1; 10469 arg2 = *(btVector3 **)&jarg2; 10470 if (arg1) (arg1)->m_aabbMin = *arg2; 10471 } 10472 10473 10474 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1btMultiSapProxy_1aabbMin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10475 jlong jresult = 0 ; 10476 btMultiSapBroadphase::btMultiSapProxy *arg1 = (btMultiSapBroadphase::btMultiSapProxy *) 0 ; 10477 btVector3 *result = 0 ; 10478 10479 (void)jenv; 10480 (void)jcls; 10481 (void)jarg1_; 10482 arg1 = *(btMultiSapBroadphase::btMultiSapProxy **)&jarg1; 10483 result = (btVector3 *)& ((arg1)->m_aabbMin); 10484 *(btVector3 **)&jresult = result; 10485 return jresult; 10486 } 10487 10488 10489 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1btMultiSapProxy_1aabbMax_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10490 btMultiSapBroadphase::btMultiSapProxy *arg1 = (btMultiSapBroadphase::btMultiSapProxy *) 0 ; 10491 btVector3 *arg2 = (btVector3 *) 0 ; 10492 10493 (void)jenv; 10494 (void)jcls; 10495 (void)jarg1_; 10496 (void)jarg2_; 10497 arg1 = *(btMultiSapBroadphase::btMultiSapProxy **)&jarg1; 10498 arg2 = *(btVector3 **)&jarg2; 10499 if (arg1) (arg1)->m_aabbMax = *arg2; 10500 } 10501 10502 10503 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1btMultiSapProxy_1aabbMax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10504 jlong jresult = 0 ; 10505 btMultiSapBroadphase::btMultiSapProxy *arg1 = (btMultiSapBroadphase::btMultiSapProxy *) 0 ; 10506 btVector3 *result = 0 ; 10507 10508 (void)jenv; 10509 (void)jcls; 10510 (void)jarg1_; 10511 arg1 = *(btMultiSapBroadphase::btMultiSapProxy **)&jarg1; 10512 result = (btVector3 *)& ((arg1)->m_aabbMax); 10513 *(btVector3 **)&jresult = result; 10514 return jresult; 10515 } 10516 10517 10518 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1btMultiSapProxy_1shapeType_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10519 btMultiSapBroadphase::btMultiSapProxy *arg1 = (btMultiSapBroadphase::btMultiSapProxy *) 0 ; 10520 int arg2 ; 10521 10522 (void)jenv; 10523 (void)jcls; 10524 (void)jarg1_; 10525 arg1 = *(btMultiSapBroadphase::btMultiSapProxy **)&jarg1; 10526 arg2 = (int)jarg2; 10527 if (arg1) (arg1)->m_shapeType = arg2; 10528 } 10529 10530 10531 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1btMultiSapProxy_1shapeType_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10532 jint jresult = 0 ; 10533 btMultiSapBroadphase::btMultiSapProxy *arg1 = (btMultiSapBroadphase::btMultiSapProxy *) 0 ; 10534 int result; 10535 10536 (void)jenv; 10537 (void)jcls; 10538 (void)jarg1_; 10539 arg1 = *(btMultiSapBroadphase::btMultiSapProxy **)&jarg1; 10540 result = (int) ((arg1)->m_shapeType); 10541 jresult = (jint)result; 10542 return jresult; 10543 } 10544 10545 10546 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btMultiSapBroadphase_1btMultiSapProxy(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3, jlong jarg4, jshort jarg5, jshort jarg6) { 10547 jlong jresult = 0 ; 10548 btVector3 *arg1 = 0 ; 10549 btVector3 *arg2 = 0 ; 10550 int arg3 ; 10551 void *arg4 = (void *) 0 ; 10552 short arg5 ; 10553 short arg6 ; 10554 btMultiSapBroadphase::btMultiSapProxy *result = 0 ; 10555 10556 (void)jenv; 10557 (void)jcls; 10558 btVector3 local_arg1; 10559 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 10560 arg1 = &local_arg1; 10561 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 10562 btVector3 local_arg2; 10563 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 10564 arg2 = &local_arg2; 10565 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 10566 arg3 = (int)jarg3; 10567 arg4 = (void *)jarg4; 10568 arg5 = (short)jarg5; 10569 arg6 = (short)jarg6; 10570 result = (btMultiSapBroadphase::btMultiSapProxy *)new btMultiSapBroadphase::btMultiSapProxy((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5,arg6); 10571 *(btMultiSapBroadphase::btMultiSapProxy **)&jresult = result; 10572 return jresult; 10573 } 10574 10575 10576 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btMultiSapBroadphase_1btMultiSapProxy(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10577 btMultiSapBroadphase::btMultiSapProxy *arg1 = (btMultiSapBroadphase::btMultiSapProxy *) 0 ; 10578 10579 (void)jenv; 10580 (void)jcls; 10581 arg1 = *(btMultiSapBroadphase::btMultiSapProxy **)&jarg1; 10582 delete arg1; 10583 } 10584 10585 10586 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1getBroadphaseArray_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10587 jlong jresult = 0 ; 10588 btMultiSapBroadphase *arg1 = (btMultiSapBroadphase *) 0 ; 10589 btSapBroadphaseArray *result = 0 ; 10590 10591 (void)jenv; 10592 (void)jcls; 10593 (void)jarg1_; 10594 arg1 = *(btMultiSapBroadphase **)&jarg1; 10595 result = (btSapBroadphaseArray *) &(arg1)->getBroadphaseArray(); 10596 *(btSapBroadphaseArray **)&jresult = result; 10597 return jresult; 10598 } 10599 10600 10601 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btMultiSapBroadphase(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10602 btMultiSapBroadphase *arg1 = (btMultiSapBroadphase *) 0 ; 10603 10604 (void)jenv; 10605 (void)jcls; 10606 arg1 = *(btMultiSapBroadphase **)&jarg1; 10607 delete arg1; 10608 } 10609 10610 10611 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1rayTest_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jobject jarg5, jobject jarg6) { 10612 btMultiSapBroadphase *arg1 = (btMultiSapBroadphase *) 0 ; 10613 btVector3 *arg2 = 0 ; 10614 btVector3 *arg3 = 0 ; 10615 btBroadphaseRayCallback *arg4 = 0 ; 10616 btVector3 *arg5 = 0 ; 10617 btVector3 *arg6 = 0 ; 10618 10619 (void)jenv; 10620 (void)jcls; 10621 (void)jarg1_; 10622 (void)jarg4_; 10623 arg1 = *(btMultiSapBroadphase **)&jarg1; 10624 btVector3 local_arg2; 10625 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 10626 arg2 = &local_arg2; 10627 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 10628 btVector3 local_arg3; 10629 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 10630 arg3 = &local_arg3; 10631 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 10632 arg4 = *(btBroadphaseRayCallback **)&jarg4; 10633 if (!arg4) { 10634 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 10635 return ; 10636 } 10637 btVector3 local_arg5; 10638 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 10639 arg5 = &local_arg5; 10640 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 10641 btVector3 local_arg6; 10642 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 10643 arg6 = &local_arg6; 10644 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 10645 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); 10646 } 10647 10648 10649 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1rayTest_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jobject jarg5) { 10650 btMultiSapBroadphase *arg1 = (btMultiSapBroadphase *) 0 ; 10651 btVector3 *arg2 = 0 ; 10652 btVector3 *arg3 = 0 ; 10653 btBroadphaseRayCallback *arg4 = 0 ; 10654 btVector3 *arg5 = 0 ; 10655 10656 (void)jenv; 10657 (void)jcls; 10658 (void)jarg1_; 10659 (void)jarg4_; 10660 arg1 = *(btMultiSapBroadphase **)&jarg1; 10661 btVector3 local_arg2; 10662 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 10663 arg2 = &local_arg2; 10664 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 10665 btVector3 local_arg3; 10666 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 10667 arg3 = &local_arg3; 10668 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 10669 arg4 = *(btBroadphaseRayCallback **)&jarg4; 10670 if (!arg4) { 10671 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 10672 return ; 10673 } 10674 btVector3 local_arg5; 10675 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 10676 arg5 = &local_arg5; 10677 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 10678 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5); 10679 } 10680 10681 10682 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1rayTest_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_) { 10683 btMultiSapBroadphase *arg1 = (btMultiSapBroadphase *) 0 ; 10684 btVector3 *arg2 = 0 ; 10685 btVector3 *arg3 = 0 ; 10686 btBroadphaseRayCallback *arg4 = 0 ; 10687 10688 (void)jenv; 10689 (void)jcls; 10690 (void)jarg1_; 10691 (void)jarg4_; 10692 arg1 = *(btMultiSapBroadphase **)&jarg1; 10693 btVector3 local_arg2; 10694 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 10695 arg2 = &local_arg2; 10696 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 10697 btVector3 local_arg3; 10698 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 10699 arg3 = &local_arg3; 10700 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 10701 arg4 = *(btBroadphaseRayCallback **)&jarg4; 10702 if (!arg4) { 10703 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 10704 return ; 10705 } 10706 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); 10707 } 10708 10709 10710 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1addToChildBroadphase(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) { 10711 btMultiSapBroadphase *arg1 = (btMultiSapBroadphase *) 0 ; 10712 btMultiSapBroadphase::btMultiSapProxy *arg2 = (btMultiSapBroadphase::btMultiSapProxy *) 0 ; 10713 btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; 10714 btBroadphaseInterface *arg4 = (btBroadphaseInterface *) 0 ; 10715 10716 (void)jenv; 10717 (void)jcls; 10718 (void)jarg1_; 10719 (void)jarg2_; 10720 (void)jarg3_; 10721 (void)jarg4_; 10722 arg1 = *(btMultiSapBroadphase **)&jarg1; 10723 arg2 = *(btMultiSapBroadphase::btMultiSapProxy **)&jarg2; 10724 arg3 = *(btBroadphaseProxy **)&jarg3; 10725 arg4 = *(btBroadphaseInterface **)&jarg4; 10726 (arg1)->addToChildBroadphase(arg2,arg3,arg4); 10727 } 10728 10729 10730 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1testAabbOverlap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) { 10731 jboolean jresult = 0 ; 10732 btMultiSapBroadphase *arg1 = (btMultiSapBroadphase *) 0 ; 10733 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 10734 btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; 10735 bool result; 10736 10737 (void)jenv; 10738 (void)jcls; 10739 (void)jarg1_; 10740 (void)jarg2_; 10741 (void)jarg3_; 10742 arg1 = *(btMultiSapBroadphase **)&jarg1; 10743 arg2 = *(btBroadphaseProxy **)&jarg2; 10744 arg3 = *(btBroadphaseProxy **)&jarg3; 10745 result = (bool)(arg1)->testAabbOverlap(arg2,arg3); 10746 jresult = (jboolean)result; 10747 return jresult; 10748 } 10749 10750 10751 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1getOverlappingPairCache_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10752 jlong jresult = 0 ; 10753 btMultiSapBroadphase *arg1 = (btMultiSapBroadphase *) 0 ; 10754 btOverlappingPairCache *result = 0 ; 10755 10756 (void)jenv; 10757 (void)jcls; 10758 (void)jarg1_; 10759 arg1 = *(btMultiSapBroadphase **)&jarg1; 10760 result = (btOverlappingPairCache *)(arg1)->getOverlappingPairCache(); 10761 *(btOverlappingPairCache **)&jresult = result; 10762 return jresult; 10763 } 10764 10765 10766 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1buildTree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { 10767 btMultiSapBroadphase *arg1 = (btMultiSapBroadphase *) 0 ; 10768 btVector3 *arg2 = 0 ; 10769 btVector3 *arg3 = 0 ; 10770 10771 (void)jenv; 10772 (void)jcls; 10773 (void)jarg1_; 10774 arg1 = *(btMultiSapBroadphase **)&jarg1; 10775 btVector3 local_arg2; 10776 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 10777 arg2 = &local_arg2; 10778 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 10779 btVector3 local_arg3; 10780 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 10781 arg3 = &local_arg3; 10782 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 10783 (arg1)->buildTree((btVector3 const &)*arg2,(btVector3 const &)*arg3); 10784 } 10785 10786 10787 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btMultiSapBroadphase_1quicksort(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) { 10788 btMultiSapBroadphase *arg1 = (btMultiSapBroadphase *) 0 ; 10789 btBroadphasePairArray *arg2 = 0 ; 10790 int arg3 ; 10791 int arg4 ; 10792 10793 (void)jenv; 10794 (void)jcls; 10795 (void)jarg1_; 10796 (void)jarg2_; 10797 arg1 = *(btMultiSapBroadphase **)&jarg1; 10798 arg2 = *(btBroadphasePairArray **)&jarg2; 10799 if (!arg2) { 10800 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphasePairArray & reference is null"); 10801 return ; 10802 } 10803 arg3 = (int)jarg3; 10804 arg4 = (int)jarg4; 10805 (arg1)->quicksort(*arg2,arg3,arg4); 10806 } 10807 10808 10809 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btCollisionAlgorithmConstructionInfo_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { 10810 jlong jresult = 0 ; 10811 btCollisionAlgorithmConstructionInfo *result = 0 ; 10812 10813 (void)jenv; 10814 (void)jcls; 10815 result = (btCollisionAlgorithmConstructionInfo *)new btCollisionAlgorithmConstructionInfo(); 10816 *(btCollisionAlgorithmConstructionInfo **)&jresult = result; 10817 return jresult; 10818 } 10819 10820 10821 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btCollisionAlgorithmConstructionInfo_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10822 jlong jresult = 0 ; 10823 btDispatcher *arg1 = (btDispatcher *) 0 ; 10824 int arg2 ; 10825 btCollisionAlgorithmConstructionInfo *result = 0 ; 10826 10827 (void)jenv; 10828 (void)jcls; 10829 (void)jarg1_; 10830 arg1 = *(btDispatcher **)&jarg1; 10831 arg2 = (int)jarg2; 10832 result = (btCollisionAlgorithmConstructionInfo *)new btCollisionAlgorithmConstructionInfo(arg1,arg2); 10833 *(btCollisionAlgorithmConstructionInfo **)&jresult = result; 10834 return jresult; 10835 } 10836 10837 10838 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btCollisionAlgorithmConstructionInfo_1dispatcher1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10839 btCollisionAlgorithmConstructionInfo *arg1 = (btCollisionAlgorithmConstructionInfo *) 0 ; 10840 btDispatcher *arg2 = (btDispatcher *) 0 ; 10841 10842 (void)jenv; 10843 (void)jcls; 10844 (void)jarg1_; 10845 (void)jarg2_; 10846 arg1 = *(btCollisionAlgorithmConstructionInfo **)&jarg1; 10847 arg2 = *(btDispatcher **)&jarg2; 10848 if (arg1) (arg1)->m_dispatcher1 = arg2; 10849 } 10850 10851 10852 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btCollisionAlgorithmConstructionInfo_1dispatcher1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10853 jlong jresult = 0 ; 10854 btCollisionAlgorithmConstructionInfo *arg1 = (btCollisionAlgorithmConstructionInfo *) 0 ; 10855 btDispatcher *result = 0 ; 10856 10857 (void)jenv; 10858 (void)jcls; 10859 (void)jarg1_; 10860 arg1 = *(btCollisionAlgorithmConstructionInfo **)&jarg1; 10861 result = (btDispatcher *) ((arg1)->m_dispatcher1); 10862 *(btDispatcher **)&jresult = result; 10863 return jresult; 10864 } 10865 10866 10867 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btCollisionAlgorithmConstructionInfo_1manifold_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10868 btCollisionAlgorithmConstructionInfo *arg1 = (btCollisionAlgorithmConstructionInfo *) 0 ; 10869 btPersistentManifold *arg2 = (btPersistentManifold *) 0 ; 10870 10871 (void)jenv; 10872 (void)jcls; 10873 (void)jarg1_; 10874 (void)jarg2_; 10875 arg1 = *(btCollisionAlgorithmConstructionInfo **)&jarg1; 10876 arg2 = *(btPersistentManifold **)&jarg2; 10877 if (arg1) (arg1)->m_manifold = arg2; 10878 } 10879 10880 10881 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btCollisionAlgorithmConstructionInfo_1manifold_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10882 jlong jresult = 0 ; 10883 btCollisionAlgorithmConstructionInfo *arg1 = (btCollisionAlgorithmConstructionInfo *) 0 ; 10884 btPersistentManifold *result = 0 ; 10885 10886 (void)jenv; 10887 (void)jcls; 10888 (void)jarg1_; 10889 arg1 = *(btCollisionAlgorithmConstructionInfo **)&jarg1; 10890 result = (btPersistentManifold *) ((arg1)->m_manifold); 10891 *(btPersistentManifold **)&jresult = result; 10892 return jresult; 10893 } 10894 10895 10896 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btCollisionAlgorithmConstructionInfo(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10897 btCollisionAlgorithmConstructionInfo *arg1 = (btCollisionAlgorithmConstructionInfo *) 0 ; 10898 10899 (void)jenv; 10900 (void)jcls; 10901 arg1 = *(btCollisionAlgorithmConstructionInfo **)&jarg1; 10902 delete arg1; 10903 } 10904 10905 10906 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10907 btCollisionAlgorithm *arg1 = (btCollisionAlgorithm *) 0 ; 10908 10909 (void)jenv; 10910 (void)jcls; 10911 arg1 = *(btCollisionAlgorithm **)&jarg1; 10912 delete arg1; 10913 } 10914 10915 10916 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btCollisionAlgorithm_1processCollision(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) { 10917 btCollisionAlgorithm *arg1 = (btCollisionAlgorithm *) 0 ; 10918 btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ; 10919 btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ; 10920 btDispatcherInfo *arg4 = 0 ; 10921 btManifoldResult *arg5 = (btManifoldResult *) 0 ; 10922 10923 (void)jenv; 10924 (void)jcls; 10925 (void)jarg1_; 10926 (void)jarg2_; 10927 (void)jarg3_; 10928 (void)jarg4_; 10929 (void)jarg5_; 10930 arg1 = *(btCollisionAlgorithm **)&jarg1; 10931 arg2 = *(btCollisionObjectWrapper **)&jarg2; 10932 arg3 = *(btCollisionObjectWrapper **)&jarg3; 10933 arg4 = *(btDispatcherInfo **)&jarg4; 10934 if (!arg4) { 10935 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btDispatcherInfo const & reference is null"); 10936 return ; 10937 } 10938 arg5 = *(btManifoldResult **)&jarg5; 10939 (arg1)->processCollision((btCollisionObjectWrapper const *)arg2,(btCollisionObjectWrapper const *)arg3,(btDispatcherInfo const &)*arg4,arg5); 10940 } 10941 10942 10943 SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btCollisionAlgorithm_1calculateTimeOfImpact(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) { 10944 jfloat jresult = 0 ; 10945 btCollisionAlgorithm *arg1 = (btCollisionAlgorithm *) 0 ; 10946 btCollisionObject *arg2 = (btCollisionObject *) 0 ; 10947 btCollisionObject *arg3 = (btCollisionObject *) 0 ; 10948 btDispatcherInfo *arg4 = 0 ; 10949 btManifoldResult *arg5 = (btManifoldResult *) 0 ; 10950 btScalar result; 10951 10952 (void)jenv; 10953 (void)jcls; 10954 (void)jarg1_; 10955 (void)jarg2_; 10956 (void)jarg3_; 10957 (void)jarg4_; 10958 (void)jarg5_; 10959 arg1 = *(btCollisionAlgorithm **)&jarg1; 10960 arg2 = *(btCollisionObject **)&jarg2; 10961 arg3 = *(btCollisionObject **)&jarg3; 10962 arg4 = *(btDispatcherInfo **)&jarg4; 10963 if (!arg4) { 10964 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btDispatcherInfo const & reference is null"); 10965 return 0; 10966 } 10967 arg5 = *(btManifoldResult **)&jarg5; 10968 result = (btScalar)(arg1)->calculateTimeOfImpact(arg2,arg3,(btDispatcherInfo const &)*arg4,arg5); 10969 jresult = (jfloat)result; 10970 return jresult; 10971 } 10972 10973 10974 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btCollisionAlgorithm_1getAllContactManifolds(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 10975 btCollisionAlgorithm *arg1 = (btCollisionAlgorithm *) 0 ; 10976 btManifoldArray *arg2 = 0 ; 10977 10978 (void)jenv; 10979 (void)jcls; 10980 (void)jarg1_; 10981 (void)jarg2_; 10982 arg1 = *(btCollisionAlgorithm **)&jarg1; 10983 arg2 = *(btManifoldArray **)&jarg2; 10984 if (!arg2) { 10985 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btManifoldArray & reference is null"); 10986 return ; 10987 } 10988 (arg1)->getAllContactManifolds(*arg2); 10989 } 10990 10991 10992 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btOverlappingPairCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10993 btOverlappingPairCallback *arg1 = (btOverlappingPairCallback *) 0 ; 10994 10995 (void)jenv; 10996 (void)jcls; 10997 arg1 = *(btOverlappingPairCallback **)&jarg1; 10998 delete arg1; 10999 } 11000 11001 11002 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOverlappingPairCallback_1addOverlappingPair(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) { 11003 jlong jresult = 0 ; 11004 btOverlappingPairCallback *arg1 = (btOverlappingPairCallback *) 0 ; 11005 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 11006 btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; 11007 btBroadphasePair *result = 0 ; 11008 11009 (void)jenv; 11010 (void)jcls; 11011 (void)jarg1_; 11012 (void)jarg2_; 11013 (void)jarg3_; 11014 arg1 = *(btOverlappingPairCallback **)&jarg1; 11015 arg2 = *(btBroadphaseProxy **)&jarg2; 11016 arg3 = *(btBroadphaseProxy **)&jarg3; 11017 result = (btBroadphasePair *)(arg1)->addOverlappingPair(arg2,arg3); 11018 *(btBroadphasePair **)&jresult = result; 11019 return jresult; 11020 } 11021 11022 11023 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOverlappingPairCallback_1removeOverlappingPair(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) { 11024 jlong jresult = 0 ; 11025 btOverlappingPairCallback *arg1 = (btOverlappingPairCallback *) 0 ; 11026 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 11027 btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; 11028 btDispatcher *arg4 = (btDispatcher *) 0 ; 11029 void *result = 0 ; 11030 11031 (void)jenv; 11032 (void)jcls; 11033 (void)jarg1_; 11034 (void)jarg2_; 11035 (void)jarg3_; 11036 (void)jarg4_; 11037 arg1 = *(btOverlappingPairCallback **)&jarg1; 11038 arg2 = *(btBroadphaseProxy **)&jarg2; 11039 arg3 = *(btBroadphaseProxy **)&jarg3; 11040 arg4 = *(btDispatcher **)&jarg4; 11041 result = (void *)(arg1)->removeOverlappingPair(arg2,arg3,arg4); 11042 jresult = (jlong)result; 11043 return jresult; 11044 } 11045 11046 11047 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOverlappingPairCallback_1removeOverlappingPairsContainingProxy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) { 11048 btOverlappingPairCallback *arg1 = (btOverlappingPairCallback *) 0 ; 11049 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 11050 btDispatcher *arg3 = (btDispatcher *) 0 ; 11051 11052 (void)jenv; 11053 (void)jcls; 11054 (void)jarg1_; 11055 (void)jarg2_; 11056 (void)jarg3_; 11057 arg1 = *(btOverlappingPairCallback **)&jarg1; 11058 arg2 = *(btBroadphaseProxy **)&jarg2; 11059 arg3 = *(btDispatcher **)&jarg3; 11060 (arg1)->removeOverlappingPairsContainingProxy(arg2,arg3); 11061 } 11062 11063 11064 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btOverlappingPairCallback(JNIEnv *jenv, jclass jcls) { 11065 jlong jresult = 0 ; 11066 btOverlappingPairCallback *result = 0 ; 11067 11068 (void)jenv; 11069 (void)jcls; 11070 result = (btOverlappingPairCallback *)new SwigDirector_btOverlappingPairCallback(jenv); 11071 *(btOverlappingPairCallback **)&jresult = result; 11072 return jresult; 11073 } 11074 11075 11076 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOverlappingPairCallback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { 11077 btOverlappingPairCallback *obj = *((btOverlappingPairCallback **)&objarg); 11078 (void)jcls; 11079 SwigDirector_btOverlappingPairCallback *director = (SwigDirector_btOverlappingPairCallback *)(obj); 11080 if (director) { 11081 director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); 11082 } 11083 } 11084 11085 11086 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btOverlappingPairCallback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { 11087 btOverlappingPairCallback *obj = *((btOverlappingPairCallback **)&objarg); 11088 SwigDirector_btOverlappingPairCallback *director = (SwigDirector_btOverlappingPairCallback *)(obj); 11089 (void)jcls; 11090 if (director) { 11091 director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); 11092 } 11093 } 11094 11095 11096 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_gOverlappingPairs_1set(JNIEnv *jenv, jclass jcls, jint jarg1) { 11097 int arg1 ; 11098 11099 (void)jenv; 11100 (void)jcls; 11101 arg1 = (int)jarg1; 11102 gOverlappingPairs = arg1; 11103 } 11104 11105 11106 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_gOverlappingPairs_1get(JNIEnv *jenv, jclass jcls) { 11107 jint jresult = 0 ; 11108 int result; 11109 11110 (void)jenv; 11111 (void)jcls; 11112 result = (int)gOverlappingPairs; 11113 jresult = (jint)result; 11114 return jresult; 11115 } 11116 11117 11118 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Edge_1pos_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11119 btAxisSweep3Internal< unsigned short >::Edge *arg1 = (btAxisSweep3Internal< unsigned short >::Edge *) 0 ; 11120 unsigned short arg2 ; 11121 11122 (void)jenv; 11123 (void)jcls; 11124 (void)jarg1_; 11125 arg1 = *(btAxisSweep3Internal< unsigned short >::Edge **)&jarg1; 11126 arg2 = (unsigned short)jarg2; 11127 if (arg1) (arg1)->m_pos = arg2; 11128 } 11129 11130 11131 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Edge_1pos_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11132 jint jresult = 0 ; 11133 btAxisSweep3Internal< unsigned short >::Edge *arg1 = (btAxisSweep3Internal< unsigned short >::Edge *) 0 ; 11134 unsigned short result; 11135 11136 (void)jenv; 11137 (void)jcls; 11138 (void)jarg1_; 11139 arg1 = *(btAxisSweep3Internal< unsigned short >::Edge **)&jarg1; 11140 result = (unsigned short) ((arg1)->m_pos); 11141 jresult = (jint)result; 11142 return jresult; 11143 } 11144 11145 11146 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Edge_1handle_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11147 btAxisSweep3Internal< unsigned short >::Edge *arg1 = (btAxisSweep3Internal< unsigned short >::Edge *) 0 ; 11148 unsigned short arg2 ; 11149 11150 (void)jenv; 11151 (void)jcls; 11152 (void)jarg1_; 11153 arg1 = *(btAxisSweep3Internal< unsigned short >::Edge **)&jarg1; 11154 arg2 = (unsigned short)jarg2; 11155 if (arg1) (arg1)->m_handle = arg2; 11156 } 11157 11158 11159 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Edge_1handle_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11160 jint jresult = 0 ; 11161 btAxisSweep3Internal< unsigned short >::Edge *arg1 = (btAxisSweep3Internal< unsigned short >::Edge *) 0 ; 11162 unsigned short result; 11163 11164 (void)jenv; 11165 (void)jcls; 11166 (void)jarg1_; 11167 arg1 = *(btAxisSweep3Internal< unsigned short >::Edge **)&jarg1; 11168 result = (unsigned short) ((arg1)->m_handle); 11169 jresult = (jint)result; 11170 return jresult; 11171 } 11172 11173 11174 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Edge_1IsMax(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11175 jint jresult = 0 ; 11176 btAxisSweep3Internal< unsigned short >::Edge *arg1 = (btAxisSweep3Internal< unsigned short >::Edge *) 0 ; 11177 unsigned short result; 11178 11179 (void)jenv; 11180 (void)jcls; 11181 (void)jarg1_; 11182 arg1 = *(btAxisSweep3Internal< unsigned short >::Edge **)&jarg1; 11183 result = (unsigned short)((btAxisSweep3Internal< unsigned short >::Edge const *)arg1)->IsMax(); 11184 jresult = (jint)result; 11185 return jresult; 11186 } 11187 11188 11189 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalShort_1Edge(JNIEnv *jenv, jclass jcls) { 11190 jlong jresult = 0 ; 11191 btAxisSweep3Internal< unsigned short >::Edge *result = 0 ; 11192 11193 (void)jenv; 11194 (void)jcls; 11195 result = (btAxisSweep3Internal< unsigned short >::Edge *)new btAxisSweep3Internal< unsigned short >::Edge(); 11196 *(btAxisSweep3Internal< unsigned short >::Edge **)&jresult = result; 11197 return jresult; 11198 } 11199 11200 11201 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btAxisSweep3InternalShort_1Edge(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11202 btAxisSweep3Internal< unsigned short >::Edge *arg1 = (btAxisSweep3Internal< unsigned short >::Edge *) 0 ; 11203 11204 (void)jenv; 11205 (void)jcls; 11206 arg1 = *(btAxisSweep3Internal< unsigned short >::Edge **)&jarg1; 11207 delete arg1; 11208 } 11209 11210 11211 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Handle_1minEdges_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 11212 btAxisSweep3Internal< unsigned short >::Handle *arg1 = (btAxisSweep3Internal< unsigned short >::Handle *) 0 ; 11213 unsigned short *arg2 ; 11214 jint *jarr2 ; 11215 11216 (void)jenv; 11217 (void)jcls; 11218 (void)jarg1_; 11219 arg1 = *(btAxisSweep3Internal< unsigned short >::Handle **)&jarg1; 11220 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 11221 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 11222 return ; 11223 } 11224 if (!SWIG_JavaArrayInUshort(jenv, &jarr2, (unsigned short **)&arg2, jarg2)) return ; 11225 { 11226 size_t ii; 11227 unsigned short *b = (unsigned short *) arg1->m_minEdges; 11228 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); 11229 } 11230 SWIG_JavaArrayArgoutUshort(jenv, jarr2, (unsigned short *)arg2, jarg2); 11231 delete [] arg2; 11232 } 11233 11234 11235 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Handle_1minEdges_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11236 jintArray jresult = 0 ; 11237 btAxisSweep3Internal< unsigned short >::Handle *arg1 = (btAxisSweep3Internal< unsigned short >::Handle *) 0 ; 11238 unsigned short *result = 0 ; 11239 11240 (void)jenv; 11241 (void)jcls; 11242 (void)jarg1_; 11243 arg1 = *(btAxisSweep3Internal< unsigned short >::Handle **)&jarg1; 11244 result = (unsigned short *)(unsigned short *) ((arg1)->m_minEdges); 11245 jresult = SWIG_JavaArrayOutUshort(jenv, (unsigned short *)result, 3); 11246 return jresult; 11247 } 11248 11249 11250 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Handle_1maxEdges_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) { 11251 btAxisSweep3Internal< unsigned short >::Handle *arg1 = (btAxisSweep3Internal< unsigned short >::Handle *) 0 ; 11252 unsigned short *arg2 ; 11253 jint *jarr2 ; 11254 11255 (void)jenv; 11256 (void)jcls; 11257 (void)jarg1_; 11258 arg1 = *(btAxisSweep3Internal< unsigned short >::Handle **)&jarg1; 11259 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 11260 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 11261 return ; 11262 } 11263 if (!SWIG_JavaArrayInUshort(jenv, &jarr2, (unsigned short **)&arg2, jarg2)) return ; 11264 { 11265 size_t ii; 11266 unsigned short *b = (unsigned short *) arg1->m_maxEdges; 11267 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned short *) arg2 + ii); 11268 } 11269 SWIG_JavaArrayArgoutUshort(jenv, jarr2, (unsigned short *)arg2, jarg2); 11270 delete [] arg2; 11271 } 11272 11273 11274 SWIGEXPORT jintArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Handle_1maxEdges_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11275 jintArray jresult = 0 ; 11276 btAxisSweep3Internal< unsigned short >::Handle *arg1 = (btAxisSweep3Internal< unsigned short >::Handle *) 0 ; 11277 unsigned short *result = 0 ; 11278 11279 (void)jenv; 11280 (void)jcls; 11281 (void)jarg1_; 11282 arg1 = *(btAxisSweep3Internal< unsigned short >::Handle **)&jarg1; 11283 result = (unsigned short *)(unsigned short *) ((arg1)->m_maxEdges); 11284 jresult = SWIG_JavaArrayOutUshort(jenv, (unsigned short *)result, 3); 11285 return jresult; 11286 } 11287 11288 11289 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Handle_1dbvtProxy_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11290 btAxisSweep3Internal< unsigned short >::Handle *arg1 = (btAxisSweep3Internal< unsigned short >::Handle *) 0 ; 11291 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 11292 11293 (void)jenv; 11294 (void)jcls; 11295 (void)jarg1_; 11296 (void)jarg2_; 11297 arg1 = *(btAxisSweep3Internal< unsigned short >::Handle **)&jarg1; 11298 arg2 = *(btBroadphaseProxy **)&jarg2; 11299 if (arg1) (arg1)->m_dbvtProxy = arg2; 11300 } 11301 11302 11303 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Handle_1dbvtProxy_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11304 jlong jresult = 0 ; 11305 btAxisSweep3Internal< unsigned short >::Handle *arg1 = (btAxisSweep3Internal< unsigned short >::Handle *) 0 ; 11306 btBroadphaseProxy *result = 0 ; 11307 11308 (void)jenv; 11309 (void)jcls; 11310 (void)jarg1_; 11311 arg1 = *(btAxisSweep3Internal< unsigned short >::Handle **)&jarg1; 11312 result = (btBroadphaseProxy *) ((arg1)->m_dbvtProxy); 11313 *(btBroadphaseProxy **)&jresult = result; 11314 return jresult; 11315 } 11316 11317 11318 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Handle_1SetNextFree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11319 btAxisSweep3Internal< unsigned short >::Handle *arg1 = (btAxisSweep3Internal< unsigned short >::Handle *) 0 ; 11320 unsigned short arg2 ; 11321 11322 (void)jenv; 11323 (void)jcls; 11324 (void)jarg1_; 11325 arg1 = *(btAxisSweep3Internal< unsigned short >::Handle **)&jarg1; 11326 arg2 = (unsigned short)jarg2; 11327 (arg1)->SetNextFree(arg2); 11328 } 11329 11330 11331 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1Handle_1GetNextFree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11332 jint jresult = 0 ; 11333 btAxisSweep3Internal< unsigned short >::Handle *arg1 = (btAxisSweep3Internal< unsigned short >::Handle *) 0 ; 11334 unsigned short result; 11335 11336 (void)jenv; 11337 (void)jcls; 11338 (void)jarg1_; 11339 arg1 = *(btAxisSweep3Internal< unsigned short >::Handle **)&jarg1; 11340 result = (unsigned short)((btAxisSweep3Internal< unsigned short >::Handle const *)arg1)->GetNextFree(); 11341 jresult = (jint)result; 11342 return jresult; 11343 } 11344 11345 11346 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalShort_1Handle(JNIEnv *jenv, jclass jcls) { 11347 jlong jresult = 0 ; 11348 btAxisSweep3Internal< unsigned short >::Handle *result = 0 ; 11349 11350 (void)jenv; 11351 (void)jcls; 11352 result = (btAxisSweep3Internal< unsigned short >::Handle *)new btAxisSweep3Internal< unsigned short >::Handle(); 11353 *(btAxisSweep3Internal< unsigned short >::Handle **)&jresult = result; 11354 return jresult; 11355 } 11356 11357 11358 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btAxisSweep3InternalShort_1Handle(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11359 btAxisSweep3Internal< unsigned short >::Handle *arg1 = (btAxisSweep3Internal< unsigned short >::Handle *) 0 ; 11360 11361 (void)jenv; 11362 (void)jcls; 11363 arg1 = *(btAxisSweep3Internal< unsigned short >::Handle **)&jarg1; 11364 delete arg1; 11365 } 11366 11367 11368 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalShort_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6, jobject jarg6_, jboolean jarg7) { 11369 jlong jresult = 0 ; 11370 btVector3 *arg1 = 0 ; 11371 btVector3 *arg2 = 0 ; 11372 unsigned short arg3 ; 11373 unsigned short arg4 ; 11374 unsigned short arg5 ; 11375 btOverlappingPairCache *arg6 = (btOverlappingPairCache *) 0 ; 11376 bool arg7 ; 11377 btAxisSweep3Internal< unsigned short > *result = 0 ; 11378 11379 (void)jenv; 11380 (void)jcls; 11381 (void)jarg6_; 11382 btVector3 local_arg1; 11383 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 11384 arg1 = &local_arg1; 11385 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 11386 btVector3 local_arg2; 11387 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 11388 arg2 = &local_arg2; 11389 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 11390 arg3 = (unsigned short)jarg3; 11391 arg4 = (unsigned short)jarg4; 11392 arg5 = (unsigned short)jarg5; 11393 arg6 = *(btOverlappingPairCache **)&jarg6; 11394 arg7 = jarg7 ? true : false; 11395 result = (btAxisSweep3Internal< unsigned short > *)new btAxisSweep3Internal< unsigned short >((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); 11396 *(btAxisSweep3Internal< unsigned short > **)&jresult = result; 11397 return jresult; 11398 } 11399 11400 11401 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalShort_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6, jobject jarg6_) { 11402 jlong jresult = 0 ; 11403 btVector3 *arg1 = 0 ; 11404 btVector3 *arg2 = 0 ; 11405 unsigned short arg3 ; 11406 unsigned short arg4 ; 11407 unsigned short arg5 ; 11408 btOverlappingPairCache *arg6 = (btOverlappingPairCache *) 0 ; 11409 btAxisSweep3Internal< unsigned short > *result = 0 ; 11410 11411 (void)jenv; 11412 (void)jcls; 11413 (void)jarg6_; 11414 btVector3 local_arg1; 11415 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 11416 arg1 = &local_arg1; 11417 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 11418 btVector3 local_arg2; 11419 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 11420 arg2 = &local_arg2; 11421 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 11422 arg3 = (unsigned short)jarg3; 11423 arg4 = (unsigned short)jarg4; 11424 arg5 = (unsigned short)jarg5; 11425 arg6 = *(btOverlappingPairCache **)&jarg6; 11426 result = (btAxisSweep3Internal< unsigned short > *)new btAxisSweep3Internal< unsigned short >((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5,arg6); 11427 *(btAxisSweep3Internal< unsigned short > **)&jresult = result; 11428 return jresult; 11429 } 11430 11431 11432 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalShort_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3, jint jarg4, jint jarg5) { 11433 jlong jresult = 0 ; 11434 btVector3 *arg1 = 0 ; 11435 btVector3 *arg2 = 0 ; 11436 unsigned short arg3 ; 11437 unsigned short arg4 ; 11438 unsigned short arg5 ; 11439 btAxisSweep3Internal< unsigned short > *result = 0 ; 11440 11441 (void)jenv; 11442 (void)jcls; 11443 btVector3 local_arg1; 11444 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 11445 arg1 = &local_arg1; 11446 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 11447 btVector3 local_arg2; 11448 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 11449 arg2 = &local_arg2; 11450 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 11451 arg3 = (unsigned short)jarg3; 11452 arg4 = (unsigned short)jarg4; 11453 arg5 = (unsigned short)jarg5; 11454 result = (btAxisSweep3Internal< unsigned short > *)new btAxisSweep3Internal< unsigned short >((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5); 11455 *(btAxisSweep3Internal< unsigned short > **)&jresult = result; 11456 return jresult; 11457 } 11458 11459 11460 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalShort_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3, jint jarg4) { 11461 jlong jresult = 0 ; 11462 btVector3 *arg1 = 0 ; 11463 btVector3 *arg2 = 0 ; 11464 unsigned short arg3 ; 11465 unsigned short arg4 ; 11466 btAxisSweep3Internal< unsigned short > *result = 0 ; 11467 11468 (void)jenv; 11469 (void)jcls; 11470 btVector3 local_arg1; 11471 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 11472 arg1 = &local_arg1; 11473 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 11474 btVector3 local_arg2; 11475 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 11476 arg2 = &local_arg2; 11477 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 11478 arg3 = (unsigned short)jarg3; 11479 arg4 = (unsigned short)jarg4; 11480 result = (btAxisSweep3Internal< unsigned short > *)new btAxisSweep3Internal< unsigned short >((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4); 11481 *(btAxisSweep3Internal< unsigned short > **)&jresult = result; 11482 return jresult; 11483 } 11484 11485 11486 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btAxisSweep3InternalShort(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11487 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11488 11489 (void)jenv; 11490 (void)jcls; 11491 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11492 delete arg1; 11493 } 11494 11495 11496 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1getNumHandles(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11497 jint jresult = 0 ; 11498 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11499 unsigned short result; 11500 11501 (void)jenv; 11502 (void)jcls; 11503 (void)jarg1_; 11504 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11505 result = (unsigned short)((btAxisSweep3Internal< unsigned short > const *)arg1)->getNumHandles(); 11506 jresult = (jint)result; 11507 return jresult; 11508 } 11509 11510 11511 SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1addHandle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jshort jarg5, jshort jarg6, jlong jarg7, jobject jarg7_, jlong jarg8) { 11512 jint jresult = 0 ; 11513 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11514 btVector3 *arg2 = 0 ; 11515 btVector3 *arg3 = 0 ; 11516 void *arg4 = (void *) 0 ; 11517 short arg5 ; 11518 short arg6 ; 11519 btDispatcher *arg7 = (btDispatcher *) 0 ; 11520 void *arg8 = (void *) 0 ; 11521 unsigned short result; 11522 11523 (void)jenv; 11524 (void)jcls; 11525 (void)jarg1_; 11526 (void)jarg7_; 11527 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11528 btVector3 local_arg2; 11529 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 11530 arg2 = &local_arg2; 11531 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 11532 btVector3 local_arg3; 11533 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 11534 arg3 = &local_arg3; 11535 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 11536 arg4 = (void *)jarg4; 11537 arg5 = (short)jarg5; 11538 arg6 = (short)jarg6; 11539 arg7 = *(btDispatcher **)&jarg7; 11540 arg8 = (void *)jarg8; 11541 result = (unsigned short)(arg1)->addHandle((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5,arg6,arg7,arg8); 11542 jresult = (jint)result; 11543 return jresult; 11544 } 11545 11546 11547 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1removeHandle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) { 11548 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11549 unsigned short arg2 ; 11550 btDispatcher *arg3 = (btDispatcher *) 0 ; 11551 11552 (void)jenv; 11553 (void)jcls; 11554 (void)jarg1_; 11555 (void)jarg3_; 11556 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11557 arg2 = (unsigned short)jarg2; 11558 arg3 = *(btDispatcher **)&jarg3; 11559 (arg1)->removeHandle(arg2,arg3); 11560 } 11561 11562 11563 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1updateHandle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jobject jarg3, jobject jarg4, jlong jarg5, jobject jarg5_) { 11564 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11565 unsigned short arg2 ; 11566 btVector3 *arg3 = 0 ; 11567 btVector3 *arg4 = 0 ; 11568 btDispatcher *arg5 = (btDispatcher *) 0 ; 11569 11570 (void)jenv; 11571 (void)jcls; 11572 (void)jarg1_; 11573 (void)jarg5_; 11574 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11575 arg2 = (unsigned short)jarg2; 11576 btVector3 local_arg3; 11577 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 11578 arg3 = &local_arg3; 11579 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 11580 btVector3 local_arg4; 11581 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 11582 arg4 = &local_arg4; 11583 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 11584 arg5 = *(btDispatcher **)&jarg5; 11585 (arg1)->updateHandle(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5); 11586 } 11587 11588 11589 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1getHandle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11590 jlong jresult = 0 ; 11591 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11592 unsigned short arg2 ; 11593 btAxisSweep3Internal< unsigned short >::Handle *result = 0 ; 11594 11595 (void)jenv; 11596 (void)jcls; 11597 (void)jarg1_; 11598 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11599 arg2 = (unsigned short)jarg2; 11600 result = (btAxisSweep3Internal< unsigned short >::Handle *)((btAxisSweep3Internal< unsigned short > const *)arg1)->getHandle(arg2); 11601 *(btAxisSweep3Internal< unsigned short >::Handle **)&jresult = result; 11602 return jresult; 11603 } 11604 11605 11606 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1rayTest_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jobject jarg5, jobject jarg6) { 11607 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11608 btVector3 *arg2 = 0 ; 11609 btVector3 *arg3 = 0 ; 11610 btBroadphaseRayCallback *arg4 = 0 ; 11611 btVector3 *arg5 = 0 ; 11612 btVector3 *arg6 = 0 ; 11613 11614 (void)jenv; 11615 (void)jcls; 11616 (void)jarg1_; 11617 (void)jarg4_; 11618 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11619 btVector3 local_arg2; 11620 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 11621 arg2 = &local_arg2; 11622 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 11623 btVector3 local_arg3; 11624 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 11625 arg3 = &local_arg3; 11626 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 11627 arg4 = *(btBroadphaseRayCallback **)&jarg4; 11628 if (!arg4) { 11629 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 11630 return ; 11631 } 11632 btVector3 local_arg5; 11633 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 11634 arg5 = &local_arg5; 11635 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 11636 btVector3 local_arg6; 11637 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 11638 arg6 = &local_arg6; 11639 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 11640 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); 11641 } 11642 11643 11644 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1rayTest_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jobject jarg5) { 11645 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11646 btVector3 *arg2 = 0 ; 11647 btVector3 *arg3 = 0 ; 11648 btBroadphaseRayCallback *arg4 = 0 ; 11649 btVector3 *arg5 = 0 ; 11650 11651 (void)jenv; 11652 (void)jcls; 11653 (void)jarg1_; 11654 (void)jarg4_; 11655 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11656 btVector3 local_arg2; 11657 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 11658 arg2 = &local_arg2; 11659 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 11660 btVector3 local_arg3; 11661 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 11662 arg3 = &local_arg3; 11663 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 11664 arg4 = *(btBroadphaseRayCallback **)&jarg4; 11665 if (!arg4) { 11666 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 11667 return ; 11668 } 11669 btVector3 local_arg5; 11670 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 11671 arg5 = &local_arg5; 11672 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 11673 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5); 11674 } 11675 11676 11677 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1rayTest_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_) { 11678 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11679 btVector3 *arg2 = 0 ; 11680 btVector3 *arg3 = 0 ; 11681 btBroadphaseRayCallback *arg4 = 0 ; 11682 11683 (void)jenv; 11684 (void)jcls; 11685 (void)jarg1_; 11686 (void)jarg4_; 11687 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11688 btVector3 local_arg2; 11689 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 11690 arg2 = &local_arg2; 11691 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 11692 btVector3 local_arg3; 11693 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 11694 arg3 = &local_arg3; 11695 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 11696 arg4 = *(btBroadphaseRayCallback **)&jarg4; 11697 if (!arg4) { 11698 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 11699 return ; 11700 } 11701 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); 11702 } 11703 11704 11705 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1quantize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jint jarg4) { 11706 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11707 unsigned short *arg2 = (unsigned short *) 0 ; 11708 btVector3 *arg3 = 0 ; 11709 int arg4 ; 11710 11711 (void)jenv; 11712 (void)jcls; 11713 (void)jarg1_; 11714 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11715 { 11716 arg2 = (unsigned short*)jenv->GetDirectBufferAddress(jarg2); 11717 if (arg2 == NULL) { 11718 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 11719 } 11720 } 11721 btVector3 local_arg3; 11722 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 11723 arg3 = &local_arg3; 11724 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 11725 arg4 = (int)jarg4; 11726 ((btAxisSweep3Internal< unsigned short > const *)arg1)->quantize(arg2,(btVector3 const &)*arg3,arg4); 11727 11728 } 11729 11730 11731 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1unQuantize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4) { 11732 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11733 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 11734 btVector3 *arg3 = 0 ; 11735 btVector3 *arg4 = 0 ; 11736 11737 (void)jenv; 11738 (void)jcls; 11739 (void)jarg1_; 11740 (void)jarg2_; 11741 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11742 arg2 = *(btBroadphaseProxy **)&jarg2; 11743 btVector3 local_arg3; 11744 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 11745 arg3 = &local_arg3; 11746 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 11747 btVector3 local_arg4; 11748 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 11749 arg4 = &local_arg4; 11750 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 11751 ((btAxisSweep3Internal< unsigned short > const *)arg1)->unQuantize(arg2,*arg3,*arg4); 11752 } 11753 11754 11755 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1testAabbOverlap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) { 11756 jboolean jresult = 0 ; 11757 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11758 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 11759 btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; 11760 bool result; 11761 11762 (void)jenv; 11763 (void)jcls; 11764 (void)jarg1_; 11765 (void)jarg2_; 11766 (void)jarg3_; 11767 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11768 arg2 = *(btBroadphaseProxy **)&jarg2; 11769 arg3 = *(btBroadphaseProxy **)&jarg3; 11770 result = (bool)(arg1)->testAabbOverlap(arg2,arg3); 11771 jresult = (jboolean)result; 11772 return jresult; 11773 } 11774 11775 11776 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1getOverlappingPairCache_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11777 jlong jresult = 0 ; 11778 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11779 btOverlappingPairCache *result = 0 ; 11780 11781 (void)jenv; 11782 (void)jcls; 11783 (void)jarg1_; 11784 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11785 result = (btOverlappingPairCache *)(arg1)->getOverlappingPairCache(); 11786 *(btOverlappingPairCache **)&jresult = result; 11787 return jresult; 11788 } 11789 11790 11791 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1setOverlappingPairUserCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11792 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11793 btOverlappingPairCallback *arg2 = (btOverlappingPairCallback *) 0 ; 11794 11795 (void)jenv; 11796 (void)jcls; 11797 (void)jarg1_; 11798 (void)jarg2_; 11799 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11800 arg2 = *(btOverlappingPairCallback **)&jarg2; 11801 (arg1)->setOverlappingPairUserCallback(arg2); 11802 } 11803 11804 11805 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalShort_1getOverlappingPairUserCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11806 jlong jresult = 0 ; 11807 btAxisSweep3Internal< unsigned short > *arg1 = (btAxisSweep3Internal< unsigned short > *) 0 ; 11808 btOverlappingPairCallback *result = 0 ; 11809 11810 (void)jenv; 11811 (void)jcls; 11812 (void)jarg1_; 11813 arg1 = *(btAxisSweep3Internal< unsigned short > **)&jarg1; 11814 result = (btOverlappingPairCallback *)((btAxisSweep3Internal< unsigned short > const *)arg1)->getOverlappingPairUserCallback(); 11815 *(btOverlappingPairCallback **)&jresult = result; 11816 return jresult; 11817 } 11818 11819 11820 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Edge_1pos_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 11821 btAxisSweep3Internal< unsigned int >::Edge *arg1 = (btAxisSweep3Internal< unsigned int >::Edge *) 0 ; 11822 unsigned int arg2 ; 11823 11824 (void)jenv; 11825 (void)jcls; 11826 (void)jarg1_; 11827 arg1 = *(btAxisSweep3Internal< unsigned int >::Edge **)&jarg1; 11828 arg2 = (unsigned int)jarg2; 11829 if (arg1) (arg1)->m_pos = arg2; 11830 } 11831 11832 11833 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Edge_1pos_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11834 jlong jresult = 0 ; 11835 btAxisSweep3Internal< unsigned int >::Edge *arg1 = (btAxisSweep3Internal< unsigned int >::Edge *) 0 ; 11836 unsigned int result; 11837 11838 (void)jenv; 11839 (void)jcls; 11840 (void)jarg1_; 11841 arg1 = *(btAxisSweep3Internal< unsigned int >::Edge **)&jarg1; 11842 result = (unsigned int) ((arg1)->m_pos); 11843 jresult = (jlong)result; 11844 return jresult; 11845 } 11846 11847 11848 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Edge_1handle_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 11849 btAxisSweep3Internal< unsigned int >::Edge *arg1 = (btAxisSweep3Internal< unsigned int >::Edge *) 0 ; 11850 unsigned int arg2 ; 11851 11852 (void)jenv; 11853 (void)jcls; 11854 (void)jarg1_; 11855 arg1 = *(btAxisSweep3Internal< unsigned int >::Edge **)&jarg1; 11856 arg2 = (unsigned int)jarg2; 11857 if (arg1) (arg1)->m_handle = arg2; 11858 } 11859 11860 11861 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Edge_1handle_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11862 jlong jresult = 0 ; 11863 btAxisSweep3Internal< unsigned int >::Edge *arg1 = (btAxisSweep3Internal< unsigned int >::Edge *) 0 ; 11864 unsigned int result; 11865 11866 (void)jenv; 11867 (void)jcls; 11868 (void)jarg1_; 11869 arg1 = *(btAxisSweep3Internal< unsigned int >::Edge **)&jarg1; 11870 result = (unsigned int) ((arg1)->m_handle); 11871 jresult = (jlong)result; 11872 return jresult; 11873 } 11874 11875 11876 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Edge_1IsMax(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11877 jlong jresult = 0 ; 11878 btAxisSweep3Internal< unsigned int >::Edge *arg1 = (btAxisSweep3Internal< unsigned int >::Edge *) 0 ; 11879 unsigned int result; 11880 11881 (void)jenv; 11882 (void)jcls; 11883 (void)jarg1_; 11884 arg1 = *(btAxisSweep3Internal< unsigned int >::Edge **)&jarg1; 11885 result = (unsigned int)((btAxisSweep3Internal< unsigned int >::Edge const *)arg1)->IsMax(); 11886 jresult = (jlong)result; 11887 return jresult; 11888 } 11889 11890 11891 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalInt_1Edge(JNIEnv *jenv, jclass jcls) { 11892 jlong jresult = 0 ; 11893 btAxisSweep3Internal< unsigned int >::Edge *result = 0 ; 11894 11895 (void)jenv; 11896 (void)jcls; 11897 result = (btAxisSweep3Internal< unsigned int >::Edge *)new btAxisSweep3Internal< unsigned int >::Edge(); 11898 *(btAxisSweep3Internal< unsigned int >::Edge **)&jresult = result; 11899 return jresult; 11900 } 11901 11902 11903 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btAxisSweep3InternalInt_1Edge(JNIEnv *jenv, jclass jcls, jlong jarg1) { 11904 btAxisSweep3Internal< unsigned int >::Edge *arg1 = (btAxisSweep3Internal< unsigned int >::Edge *) 0 ; 11905 11906 (void)jenv; 11907 (void)jcls; 11908 arg1 = *(btAxisSweep3Internal< unsigned int >::Edge **)&jarg1; 11909 delete arg1; 11910 } 11911 11912 11913 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Handle_1minEdges_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2) { 11914 btAxisSweep3Internal< unsigned int >::Handle *arg1 = (btAxisSweep3Internal< unsigned int >::Handle *) 0 ; 11915 unsigned int *arg2 ; 11916 jlong *jarr2 ; 11917 11918 (void)jenv; 11919 (void)jcls; 11920 (void)jarg1_; 11921 arg1 = *(btAxisSweep3Internal< unsigned int >::Handle **)&jarg1; 11922 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 11923 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 11924 return ; 11925 } 11926 if (!SWIG_JavaArrayInUint(jenv, &jarr2, (unsigned int **)&arg2, jarg2)) return ; 11927 { 11928 size_t ii; 11929 unsigned int *b = (unsigned int *) arg1->m_minEdges; 11930 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned int *) arg2 + ii); 11931 } 11932 SWIG_JavaArrayArgoutUint(jenv, jarr2, (unsigned int *)arg2, jarg2); 11933 delete [] arg2; 11934 } 11935 11936 11937 SWIGEXPORT jlongArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Handle_1minEdges_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11938 jlongArray jresult = 0 ; 11939 btAxisSweep3Internal< unsigned int >::Handle *arg1 = (btAxisSweep3Internal< unsigned int >::Handle *) 0 ; 11940 unsigned int *result = 0 ; 11941 11942 (void)jenv; 11943 (void)jcls; 11944 (void)jarg1_; 11945 arg1 = *(btAxisSweep3Internal< unsigned int >::Handle **)&jarg1; 11946 result = (unsigned int *)(unsigned int *) ((arg1)->m_minEdges); 11947 jresult = SWIG_JavaArrayOutUint(jenv, (unsigned int *)result, 3); 11948 return jresult; 11949 } 11950 11951 11952 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Handle_1maxEdges_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2) { 11953 btAxisSweep3Internal< unsigned int >::Handle *arg1 = (btAxisSweep3Internal< unsigned int >::Handle *) 0 ; 11954 unsigned int *arg2 ; 11955 jlong *jarr2 ; 11956 11957 (void)jenv; 11958 (void)jcls; 11959 (void)jarg1_; 11960 arg1 = *(btAxisSweep3Internal< unsigned int >::Handle **)&jarg1; 11961 if (jarg2 && jenv->GetArrayLength(jarg2) != 3) { 11962 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); 11963 return ; 11964 } 11965 if (!SWIG_JavaArrayInUint(jenv, &jarr2, (unsigned int **)&arg2, jarg2)) return ; 11966 { 11967 size_t ii; 11968 unsigned int *b = (unsigned int *) arg1->m_maxEdges; 11969 for (ii = 0; ii < (size_t)3; ii++) b[ii] = *((unsigned int *) arg2 + ii); 11970 } 11971 SWIG_JavaArrayArgoutUint(jenv, jarr2, (unsigned int *)arg2, jarg2); 11972 delete [] arg2; 11973 } 11974 11975 11976 SWIGEXPORT jlongArray JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Handle_1maxEdges_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11977 jlongArray jresult = 0 ; 11978 btAxisSweep3Internal< unsigned int >::Handle *arg1 = (btAxisSweep3Internal< unsigned int >::Handle *) 0 ; 11979 unsigned int *result = 0 ; 11980 11981 (void)jenv; 11982 (void)jcls; 11983 (void)jarg1_; 11984 arg1 = *(btAxisSweep3Internal< unsigned int >::Handle **)&jarg1; 11985 result = (unsigned int *)(unsigned int *) ((arg1)->m_maxEdges); 11986 jresult = SWIG_JavaArrayOutUint(jenv, (unsigned int *)result, 3); 11987 return jresult; 11988 } 11989 11990 11991 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Handle_1dbvtProxy_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 11992 btAxisSweep3Internal< unsigned int >::Handle *arg1 = (btAxisSweep3Internal< unsigned int >::Handle *) 0 ; 11993 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 11994 11995 (void)jenv; 11996 (void)jcls; 11997 (void)jarg1_; 11998 (void)jarg2_; 11999 arg1 = *(btAxisSweep3Internal< unsigned int >::Handle **)&jarg1; 12000 arg2 = *(btBroadphaseProxy **)&jarg2; 12001 if (arg1) (arg1)->m_dbvtProxy = arg2; 12002 } 12003 12004 12005 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Handle_1dbvtProxy_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12006 jlong jresult = 0 ; 12007 btAxisSweep3Internal< unsigned int >::Handle *arg1 = (btAxisSweep3Internal< unsigned int >::Handle *) 0 ; 12008 btBroadphaseProxy *result = 0 ; 12009 12010 (void)jenv; 12011 (void)jcls; 12012 (void)jarg1_; 12013 arg1 = *(btAxisSweep3Internal< unsigned int >::Handle **)&jarg1; 12014 result = (btBroadphaseProxy *) ((arg1)->m_dbvtProxy); 12015 *(btBroadphaseProxy **)&jresult = result; 12016 return jresult; 12017 } 12018 12019 12020 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Handle_1SetNextFree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 12021 btAxisSweep3Internal< unsigned int >::Handle *arg1 = (btAxisSweep3Internal< unsigned int >::Handle *) 0 ; 12022 unsigned int arg2 ; 12023 12024 (void)jenv; 12025 (void)jcls; 12026 (void)jarg1_; 12027 arg1 = *(btAxisSweep3Internal< unsigned int >::Handle **)&jarg1; 12028 arg2 = (unsigned int)jarg2; 12029 (arg1)->SetNextFree(arg2); 12030 } 12031 12032 12033 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1Handle_1GetNextFree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12034 jlong jresult = 0 ; 12035 btAxisSweep3Internal< unsigned int >::Handle *arg1 = (btAxisSweep3Internal< unsigned int >::Handle *) 0 ; 12036 unsigned int result; 12037 12038 (void)jenv; 12039 (void)jcls; 12040 (void)jarg1_; 12041 arg1 = *(btAxisSweep3Internal< unsigned int >::Handle **)&jarg1; 12042 result = (unsigned int)((btAxisSweep3Internal< unsigned int >::Handle const *)arg1)->GetNextFree(); 12043 jresult = (jlong)result; 12044 return jresult; 12045 } 12046 12047 12048 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalInt_1Handle(JNIEnv *jenv, jclass jcls) { 12049 jlong jresult = 0 ; 12050 btAxisSweep3Internal< unsigned int >::Handle *result = 0 ; 12051 12052 (void)jenv; 12053 (void)jcls; 12054 result = (btAxisSweep3Internal< unsigned int >::Handle *)new btAxisSweep3Internal< unsigned int >::Handle(); 12055 *(btAxisSweep3Internal< unsigned int >::Handle **)&jresult = result; 12056 return jresult; 12057 } 12058 12059 12060 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btAxisSweep3InternalInt_1Handle(JNIEnv *jenv, jclass jcls, jlong jarg1) { 12061 btAxisSweep3Internal< unsigned int >::Handle *arg1 = (btAxisSweep3Internal< unsigned int >::Handle *) 0 ; 12062 12063 (void)jenv; 12064 (void)jcls; 12065 arg1 = *(btAxisSweep3Internal< unsigned int >::Handle **)&jarg1; 12066 delete arg1; 12067 } 12068 12069 12070 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalInt_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6, jobject jarg6_, jboolean jarg7) { 12071 jlong jresult = 0 ; 12072 btVector3 *arg1 = 0 ; 12073 btVector3 *arg2 = 0 ; 12074 unsigned int arg3 ; 12075 unsigned int arg4 ; 12076 unsigned int arg5 ; 12077 btOverlappingPairCache *arg6 = (btOverlappingPairCache *) 0 ; 12078 bool arg7 ; 12079 btAxisSweep3Internal< unsigned int > *result = 0 ; 12080 12081 (void)jenv; 12082 (void)jcls; 12083 (void)jarg6_; 12084 btVector3 local_arg1; 12085 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12086 arg1 = &local_arg1; 12087 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12088 btVector3 local_arg2; 12089 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12090 arg2 = &local_arg2; 12091 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12092 arg3 = (unsigned int)jarg3; 12093 arg4 = (unsigned int)jarg4; 12094 arg5 = (unsigned int)jarg5; 12095 arg6 = *(btOverlappingPairCache **)&jarg6; 12096 arg7 = jarg7 ? true : false; 12097 result = (btAxisSweep3Internal< unsigned int > *)new btAxisSweep3Internal< unsigned int >((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); 12098 *(btAxisSweep3Internal< unsigned int > **)&jresult = result; 12099 return jresult; 12100 } 12101 12102 12103 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalInt_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6, jobject jarg6_) { 12104 jlong jresult = 0 ; 12105 btVector3 *arg1 = 0 ; 12106 btVector3 *arg2 = 0 ; 12107 unsigned int arg3 ; 12108 unsigned int arg4 ; 12109 unsigned int arg5 ; 12110 btOverlappingPairCache *arg6 = (btOverlappingPairCache *) 0 ; 12111 btAxisSweep3Internal< unsigned int > *result = 0 ; 12112 12113 (void)jenv; 12114 (void)jcls; 12115 (void)jarg6_; 12116 btVector3 local_arg1; 12117 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12118 arg1 = &local_arg1; 12119 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12120 btVector3 local_arg2; 12121 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12122 arg2 = &local_arg2; 12123 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12124 arg3 = (unsigned int)jarg3; 12125 arg4 = (unsigned int)jarg4; 12126 arg5 = (unsigned int)jarg5; 12127 arg6 = *(btOverlappingPairCache **)&jarg6; 12128 result = (btAxisSweep3Internal< unsigned int > *)new btAxisSweep3Internal< unsigned int >((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5,arg6); 12129 *(btAxisSweep3Internal< unsigned int > **)&jresult = result; 12130 return jresult; 12131 } 12132 12133 12134 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalInt_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { 12135 jlong jresult = 0 ; 12136 btVector3 *arg1 = 0 ; 12137 btVector3 *arg2 = 0 ; 12138 unsigned int arg3 ; 12139 unsigned int arg4 ; 12140 unsigned int arg5 ; 12141 btAxisSweep3Internal< unsigned int > *result = 0 ; 12142 12143 (void)jenv; 12144 (void)jcls; 12145 btVector3 local_arg1; 12146 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12147 arg1 = &local_arg1; 12148 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12149 btVector3 local_arg2; 12150 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12151 arg2 = &local_arg2; 12152 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12153 arg3 = (unsigned int)jarg3; 12154 arg4 = (unsigned int)jarg4; 12155 arg5 = (unsigned int)jarg5; 12156 result = (btAxisSweep3Internal< unsigned int > *)new btAxisSweep3Internal< unsigned int >((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5); 12157 *(btAxisSweep3Internal< unsigned int > **)&jresult = result; 12158 return jresult; 12159 } 12160 12161 12162 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3InternalInt_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3, jlong jarg4) { 12163 jlong jresult = 0 ; 12164 btVector3 *arg1 = 0 ; 12165 btVector3 *arg2 = 0 ; 12166 unsigned int arg3 ; 12167 unsigned int arg4 ; 12168 btAxisSweep3Internal< unsigned int > *result = 0 ; 12169 12170 (void)jenv; 12171 (void)jcls; 12172 btVector3 local_arg1; 12173 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12174 arg1 = &local_arg1; 12175 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12176 btVector3 local_arg2; 12177 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12178 arg2 = &local_arg2; 12179 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12180 arg3 = (unsigned int)jarg3; 12181 arg4 = (unsigned int)jarg4; 12182 result = (btAxisSweep3Internal< unsigned int > *)new btAxisSweep3Internal< unsigned int >((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4); 12183 *(btAxisSweep3Internal< unsigned int > **)&jresult = result; 12184 return jresult; 12185 } 12186 12187 12188 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btAxisSweep3InternalInt(JNIEnv *jenv, jclass jcls, jlong jarg1) { 12189 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12190 12191 (void)jenv; 12192 (void)jcls; 12193 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12194 delete arg1; 12195 } 12196 12197 12198 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1getNumHandles(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12199 jlong jresult = 0 ; 12200 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12201 unsigned int result; 12202 12203 (void)jenv; 12204 (void)jcls; 12205 (void)jarg1_; 12206 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12207 result = (unsigned int)((btAxisSweep3Internal< unsigned int > const *)arg1)->getNumHandles(); 12208 jresult = (jlong)result; 12209 return jresult; 12210 } 12211 12212 12213 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1addHandle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jshort jarg5, jshort jarg6, jlong jarg7, jobject jarg7_, jlong jarg8) { 12214 jlong jresult = 0 ; 12215 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12216 btVector3 *arg2 = 0 ; 12217 btVector3 *arg3 = 0 ; 12218 void *arg4 = (void *) 0 ; 12219 short arg5 ; 12220 short arg6 ; 12221 btDispatcher *arg7 = (btDispatcher *) 0 ; 12222 void *arg8 = (void *) 0 ; 12223 unsigned int result; 12224 12225 (void)jenv; 12226 (void)jcls; 12227 (void)jarg1_; 12228 (void)jarg7_; 12229 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12230 btVector3 local_arg2; 12231 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12232 arg2 = &local_arg2; 12233 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12234 btVector3 local_arg3; 12235 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 12236 arg3 = &local_arg3; 12237 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 12238 arg4 = (void *)jarg4; 12239 arg5 = (short)jarg5; 12240 arg6 = (short)jarg6; 12241 arg7 = *(btDispatcher **)&jarg7; 12242 arg8 = (void *)jarg8; 12243 result = (unsigned int)(arg1)->addHandle((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5,arg6,arg7,arg8); 12244 jresult = (jlong)result; 12245 return jresult; 12246 } 12247 12248 12249 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1removeHandle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_) { 12250 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12251 unsigned int arg2 ; 12252 btDispatcher *arg3 = (btDispatcher *) 0 ; 12253 12254 (void)jenv; 12255 (void)jcls; 12256 (void)jarg1_; 12257 (void)jarg3_; 12258 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12259 arg2 = (unsigned int)jarg2; 12260 arg3 = *(btDispatcher **)&jarg3; 12261 (arg1)->removeHandle(arg2,arg3); 12262 } 12263 12264 12265 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1updateHandle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg3, jobject jarg4, jlong jarg5, jobject jarg5_) { 12266 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12267 unsigned int arg2 ; 12268 btVector3 *arg3 = 0 ; 12269 btVector3 *arg4 = 0 ; 12270 btDispatcher *arg5 = (btDispatcher *) 0 ; 12271 12272 (void)jenv; 12273 (void)jcls; 12274 (void)jarg1_; 12275 (void)jarg5_; 12276 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12277 arg2 = (unsigned int)jarg2; 12278 btVector3 local_arg3; 12279 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 12280 arg3 = &local_arg3; 12281 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 12282 btVector3 local_arg4; 12283 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 12284 arg4 = &local_arg4; 12285 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 12286 arg5 = *(btDispatcher **)&jarg5; 12287 (arg1)->updateHandle(arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5); 12288 } 12289 12290 12291 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1getHandle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 12292 jlong jresult = 0 ; 12293 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12294 unsigned int arg2 ; 12295 btAxisSweep3Internal< unsigned int >::Handle *result = 0 ; 12296 12297 (void)jenv; 12298 (void)jcls; 12299 (void)jarg1_; 12300 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12301 arg2 = (unsigned int)jarg2; 12302 result = (btAxisSweep3Internal< unsigned int >::Handle *)((btAxisSweep3Internal< unsigned int > const *)arg1)->getHandle(arg2); 12303 *(btAxisSweep3Internal< unsigned int >::Handle **)&jresult = result; 12304 return jresult; 12305 } 12306 12307 12308 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1rayTest_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jobject jarg5, jobject jarg6) { 12309 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12310 btVector3 *arg2 = 0 ; 12311 btVector3 *arg3 = 0 ; 12312 btBroadphaseRayCallback *arg4 = 0 ; 12313 btVector3 *arg5 = 0 ; 12314 btVector3 *arg6 = 0 ; 12315 12316 (void)jenv; 12317 (void)jcls; 12318 (void)jarg1_; 12319 (void)jarg4_; 12320 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12321 btVector3 local_arg2; 12322 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12323 arg2 = &local_arg2; 12324 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12325 btVector3 local_arg3; 12326 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 12327 arg3 = &local_arg3; 12328 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 12329 arg4 = *(btBroadphaseRayCallback **)&jarg4; 12330 if (!arg4) { 12331 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 12332 return ; 12333 } 12334 btVector3 local_arg5; 12335 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 12336 arg5 = &local_arg5; 12337 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 12338 btVector3 local_arg6; 12339 gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); 12340 arg6 = &local_arg6; 12341 gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); 12342 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6); 12343 } 12344 12345 12346 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1rayTest_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jobject jarg5) { 12347 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12348 btVector3 *arg2 = 0 ; 12349 btVector3 *arg3 = 0 ; 12350 btBroadphaseRayCallback *arg4 = 0 ; 12351 btVector3 *arg5 = 0 ; 12352 12353 (void)jenv; 12354 (void)jcls; 12355 (void)jarg1_; 12356 (void)jarg4_; 12357 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12358 btVector3 local_arg2; 12359 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12360 arg2 = &local_arg2; 12361 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12362 btVector3 local_arg3; 12363 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 12364 arg3 = &local_arg3; 12365 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 12366 arg4 = *(btBroadphaseRayCallback **)&jarg4; 12367 if (!arg4) { 12368 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 12369 return ; 12370 } 12371 btVector3 local_arg5; 12372 gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); 12373 arg5 = &local_arg5; 12374 gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); 12375 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4,(btVector3 const &)*arg5); 12376 } 12377 12378 12379 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1rayTest_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_) { 12380 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12381 btVector3 *arg2 = 0 ; 12382 btVector3 *arg3 = 0 ; 12383 btBroadphaseRayCallback *arg4 = 0 ; 12384 12385 (void)jenv; 12386 (void)jcls; 12387 (void)jarg1_; 12388 (void)jarg4_; 12389 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12390 btVector3 local_arg2; 12391 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12392 arg2 = &local_arg2; 12393 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12394 btVector3 local_arg3; 12395 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 12396 arg3 = &local_arg3; 12397 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 12398 arg4 = *(btBroadphaseRayCallback **)&jarg4; 12399 if (!arg4) { 12400 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btBroadphaseRayCallback & reference is null"); 12401 return ; 12402 } 12403 (arg1)->rayTest((btVector3 const &)*arg2,(btVector3 const &)*arg3,*arg4); 12404 } 12405 12406 12407 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1quantize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jint jarg4) { 12408 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12409 unsigned int *arg2 = (unsigned int *) 0 ; 12410 btVector3 *arg3 = 0 ; 12411 int arg4 ; 12412 12413 (void)jenv; 12414 (void)jcls; 12415 (void)jarg1_; 12416 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12417 { 12418 arg2 = (unsigned int*)jenv->GetDirectBufferAddress(jarg2); 12419 if (arg2 == NULL) { 12420 SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); 12421 } 12422 } 12423 btVector3 local_arg3; 12424 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 12425 arg3 = &local_arg3; 12426 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 12427 arg4 = (int)jarg4; 12428 ((btAxisSweep3Internal< unsigned int > const *)arg1)->quantize(arg2,(btVector3 const &)*arg3,arg4); 12429 12430 } 12431 12432 12433 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1unQuantize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4) { 12434 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12435 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 12436 btVector3 *arg3 = 0 ; 12437 btVector3 *arg4 = 0 ; 12438 12439 (void)jenv; 12440 (void)jcls; 12441 (void)jarg1_; 12442 (void)jarg2_; 12443 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12444 arg2 = *(btBroadphaseProxy **)&jarg2; 12445 btVector3 local_arg3; 12446 gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); 12447 arg3 = &local_arg3; 12448 gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); 12449 btVector3 local_arg4; 12450 gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); 12451 arg4 = &local_arg4; 12452 gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); 12453 ((btAxisSweep3Internal< unsigned int > const *)arg1)->unQuantize(arg2,*arg3,*arg4); 12454 } 12455 12456 12457 SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1testAabbOverlap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) { 12458 jboolean jresult = 0 ; 12459 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12460 btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ; 12461 btBroadphaseProxy *arg3 = (btBroadphaseProxy *) 0 ; 12462 bool result; 12463 12464 (void)jenv; 12465 (void)jcls; 12466 (void)jarg1_; 12467 (void)jarg2_; 12468 (void)jarg3_; 12469 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12470 arg2 = *(btBroadphaseProxy **)&jarg2; 12471 arg3 = *(btBroadphaseProxy **)&jarg3; 12472 result = (bool)(arg1)->testAabbOverlap(arg2,arg3); 12473 jresult = (jboolean)result; 12474 return jresult; 12475 } 12476 12477 12478 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1getOverlappingPairCache_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12479 jlong jresult = 0 ; 12480 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12481 btOverlappingPairCache *result = 0 ; 12482 12483 (void)jenv; 12484 (void)jcls; 12485 (void)jarg1_; 12486 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12487 result = (btOverlappingPairCache *)(arg1)->getOverlappingPairCache(); 12488 *(btOverlappingPairCache **)&jresult = result; 12489 return jresult; 12490 } 12491 12492 12493 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1setOverlappingPairUserCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 12494 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12495 btOverlappingPairCallback *arg2 = (btOverlappingPairCallback *) 0 ; 12496 12497 (void)jenv; 12498 (void)jcls; 12499 (void)jarg1_; 12500 (void)jarg2_; 12501 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12502 arg2 = *(btOverlappingPairCallback **)&jarg2; 12503 (arg1)->setOverlappingPairUserCallback(arg2); 12504 } 12505 12506 12507 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_btAxisSweep3InternalInt_1getOverlappingPairUserCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 12508 jlong jresult = 0 ; 12509 btAxisSweep3Internal< unsigned int > *arg1 = (btAxisSweep3Internal< unsigned int > *) 0 ; 12510 btOverlappingPairCallback *result = 0 ; 12511 12512 (void)jenv; 12513 (void)jcls; 12514 (void)jarg1_; 12515 arg1 = *(btAxisSweep3Internal< unsigned int > **)&jarg1; 12516 result = (btOverlappingPairCallback *)((btAxisSweep3Internal< unsigned int > const *)arg1)->getOverlappingPairUserCallback(); 12517 *(btOverlappingPairCallback **)&jresult = result; 12518 return jresult; 12519 } 12520 12521 12522 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3, jlong jarg4, jobject jarg4_, jboolean jarg5) { 12523 jlong jresult = 0 ; 12524 btVector3 *arg1 = 0 ; 12525 btVector3 *arg2 = 0 ; 12526 unsigned short arg3 ; 12527 btOverlappingPairCache *arg4 = (btOverlappingPairCache *) 0 ; 12528 bool arg5 ; 12529 btAxisSweep3 *result = 0 ; 12530 12531 (void)jenv; 12532 (void)jcls; 12533 (void)jarg4_; 12534 btVector3 local_arg1; 12535 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12536 arg1 = &local_arg1; 12537 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12538 btVector3 local_arg2; 12539 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12540 arg2 = &local_arg2; 12541 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12542 arg3 = (unsigned short)jarg3; 12543 arg4 = *(btOverlappingPairCache **)&jarg4; 12544 arg5 = jarg5 ? true : false; 12545 result = (btAxisSweep3 *)new btAxisSweep3((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5); 12546 *(btAxisSweep3 **)&jresult = result; 12547 return jresult; 12548 } 12549 12550 12551 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3, jlong jarg4, jobject jarg4_) { 12552 jlong jresult = 0 ; 12553 btVector3 *arg1 = 0 ; 12554 btVector3 *arg2 = 0 ; 12555 unsigned short arg3 ; 12556 btOverlappingPairCache *arg4 = (btOverlappingPairCache *) 0 ; 12557 btAxisSweep3 *result = 0 ; 12558 12559 (void)jenv; 12560 (void)jcls; 12561 (void)jarg4_; 12562 btVector3 local_arg1; 12563 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12564 arg1 = &local_arg1; 12565 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12566 btVector3 local_arg2; 12567 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12568 arg2 = &local_arg2; 12569 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12570 arg3 = (unsigned short)jarg3; 12571 arg4 = *(btOverlappingPairCache **)&jarg4; 12572 result = (btAxisSweep3 *)new btAxisSweep3((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4); 12573 *(btAxisSweep3 **)&jresult = result; 12574 return jresult; 12575 } 12576 12577 12578 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3) { 12579 jlong jresult = 0 ; 12580 btVector3 *arg1 = 0 ; 12581 btVector3 *arg2 = 0 ; 12582 unsigned short arg3 ; 12583 btAxisSweep3 *result = 0 ; 12584 12585 (void)jenv; 12586 (void)jcls; 12587 btVector3 local_arg1; 12588 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12589 arg1 = &local_arg1; 12590 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12591 btVector3 local_arg2; 12592 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12593 arg2 = &local_arg2; 12594 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12595 arg3 = (unsigned short)jarg3; 12596 result = (btAxisSweep3 *)new btAxisSweep3((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3); 12597 *(btAxisSweep3 **)&jresult = result; 12598 return jresult; 12599 } 12600 12601 12602 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1btAxisSweep3_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 12603 jlong jresult = 0 ; 12604 btVector3 *arg1 = 0 ; 12605 btVector3 *arg2 = 0 ; 12606 btAxisSweep3 *result = 0 ; 12607 12608 (void)jenv; 12609 (void)jcls; 12610 btVector3 local_arg1; 12611 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12612 arg1 = &local_arg1; 12613 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12614 btVector3 local_arg2; 12615 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12616 arg2 = &local_arg2; 12617 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12618 result = (btAxisSweep3 *)new btAxisSweep3((btVector3 const &)*arg1,(btVector3 const &)*arg2); 12619 *(btAxisSweep3 **)&jresult = result; 12620 return jresult; 12621 } 12622 12623 12624 SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_delete_1btAxisSweep3(JNIEnv *jenv, jclass jcls, jlong jarg1) { 12625 btAxisSweep3 *arg1 = (btAxisSweep3 *) 0 ; 12626 12627 (void)jenv; 12628 (void)jcls; 12629 arg1 = *(btAxisSweep3 **)&jarg1; 12630 delete arg1; 12631 } 12632 12633 12634 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1bt32BitAxisSweep3_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jboolean jarg5) { 12635 jlong jresult = 0 ; 12636 btVector3 *arg1 = 0 ; 12637 btVector3 *arg2 = 0 ; 12638 unsigned int arg3 ; 12639 btOverlappingPairCache *arg4 = (btOverlappingPairCache *) 0 ; 12640 bool arg5 ; 12641 bt32BitAxisSweep3 *result = 0 ; 12642 12643 (void)jenv; 12644 (void)jcls; 12645 (void)jarg4_; 12646 btVector3 local_arg1; 12647 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12648 arg1 = &local_arg1; 12649 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12650 btVector3 local_arg2; 12651 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12652 arg2 = &local_arg2; 12653 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12654 arg3 = (unsigned int)jarg3; 12655 arg4 = *(btOverlappingPairCache **)&jarg4; 12656 arg5 = jarg5 ? true : false; 12657 result = (bt32BitAxisSweep3 *)new bt32BitAxisSweep3((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4,arg5); 12658 *(bt32BitAxisSweep3 **)&jresult = result; 12659 return jresult; 12660 } 12661 12662 12663 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1bt32BitAxisSweep3_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3, jlong jarg4, jobject jarg4_) { 12664 jlong jresult = 0 ; 12665 btVector3 *arg1 = 0 ; 12666 btVector3 *arg2 = 0 ; 12667 unsigned int arg3 ; 12668 btOverlappingPairCache *arg4 = (btOverlappingPairCache *) 0 ; 12669 bt32BitAxisSweep3 *result = 0 ; 12670 12671 (void)jenv; 12672 (void)jcls; 12673 (void)jarg4_; 12674 btVector3 local_arg1; 12675 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12676 arg1 = &local_arg1; 12677 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12678 btVector3 local_arg2; 12679 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12680 arg2 = &local_arg2; 12681 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12682 arg3 = (unsigned int)jarg3; 12683 arg4 = *(btOverlappingPairCache **)&jarg4; 12684 result = (bt32BitAxisSweep3 *)new bt32BitAxisSweep3((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,arg4); 12685 *(bt32BitAxisSweep3 **)&jresult = result; 12686 return jresult; 12687 } 12688 12689 12690 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1bt32BitAxisSweep3_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3) { 12691 jlong jresult = 0 ; 12692 btVector3 *arg1 = 0 ; 12693 btVector3 *arg2 = 0 ; 12694 unsigned int arg3 ; 12695 bt32BitAxisSweep3 *result = 0 ; 12696 12697 (void)jenv; 12698 (void)jcls; 12699 btVector3 local_arg1; 12700 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12701 arg1 = &local_arg1; 12702 gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); 12703 btVector3 local_arg2; 12704 gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); 12705 arg2 = &local_arg2; 12706 gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); 12707 arg3 = (unsigned int)jarg3; 12708 result = (bt32BitAxisSweep3 *)new bt32BitAxisSweep3((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3); 12709 *(bt32BitAxisSweep3 **)&jresult = result; 12710 return jresult; 12711 } 12712 12713 12714 SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_collision_CollisionJNI_new_1bt32BitAxisSweep3_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 12715 jlong jresult = 0 ; 12716 btVector3 *arg1 = 0 ; 12717 btVector3 *arg2 = 0 ; 12718 bt32BitAxisSweep3 *result = 0 ; 12719 12720 (void)jenv; 12721 (void)jcls; 12722 btVector3 local_arg1; 12723 gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); 12724 arg1 = &