/* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). * Version 3.0.8 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make * changes to this file unless you know what you are doing--modify the SWIG * interface file instead. * ----------------------------------------------------------------------------- */ #ifndef SWIGJAVA #define SWIGJAVA #endif #define SWIG_DIRECTORS #ifdef __cplusplus /* SwigValueWrapper is described in swig.swg */ template class SwigValueWrapper { struct SwigMovePointer { T *ptr; SwigMovePointer(T *p) : ptr(p) { } ~SwigMovePointer() { delete ptr; } SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } } pointer; SwigValueWrapper& operator=(const SwigValueWrapper& rhs); SwigValueWrapper(const SwigValueWrapper& rhs); public: SwigValueWrapper() : pointer(0) { } SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } operator T&() const { return *pointer.ptr; } T *operator&() { return pointer.ptr; } }; template T SwigValueInit() { return T(); } #endif /* ----------------------------------------------------------------------------- * This section contains generic SWIG labels for method/variable * declarations/attributes, and other compiler dependent labels. * ----------------------------------------------------------------------------- */ /* template workaround for compilers that cannot correctly implement the C++ standard */ #ifndef SWIGTEMPLATEDISAMBIGUATOR # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) # define SWIGTEMPLATEDISAMBIGUATOR template # elif defined(__HP_aCC) /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ # define SWIGTEMPLATEDISAMBIGUATOR template # else # define SWIGTEMPLATEDISAMBIGUATOR # endif #endif /* inline attribute */ #ifndef SWIGINLINE # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) # define SWIGINLINE inline # else # define SWIGINLINE # endif #endif /* attribute recognised by some compilers to avoid 'unused' warnings */ #ifndef SWIGUNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define SWIGUNUSED __attribute__ ((__unused__)) # else # define SWIGUNUSED # endif # elif defined(__ICC) # define SWIGUNUSED __attribute__ ((__unused__)) # else # define SWIGUNUSED # endif #endif #ifndef SWIG_MSC_UNSUPPRESS_4505 # if defined(_MSC_VER) # pragma warning(disable : 4505) /* unreferenced local function has been removed */ # endif #endif #ifndef SWIGUNUSEDPARM # ifdef __cplusplus # define SWIGUNUSEDPARM(p) # else # define SWIGUNUSEDPARM(p) p SWIGUNUSED # endif #endif /* internal SWIG method */ #ifndef SWIGINTERN # define SWIGINTERN static SWIGUNUSED #endif /* internal inline SWIG method */ #ifndef SWIGINTERNINLINE # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE #endif /* exporting methods */ #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) # ifndef GCC_HASCLASSVISIBILITY # define GCC_HASCLASSVISIBILITY # endif #endif #ifndef SWIGEXPORT # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # if defined(STATIC_LINKED) # define SWIGEXPORT # else # define SWIGEXPORT __declspec(dllexport) # endif # else # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) # define SWIGEXPORT __attribute__ ((visibility("default"))) # else # define SWIGEXPORT # endif # endif #endif /* calling conventions for Windows */ #ifndef SWIGSTDCALL # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # define SWIGSTDCALL __stdcall # else # define SWIGSTDCALL # endif #endif /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) # define _CRT_SECURE_NO_DEPRECATE #endif /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) # define _SCL_SECURE_NO_DEPRECATE #endif /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 #endif /* Intel's compiler complains if a variable which was never initialised is * cast to void, which is a common idiom which we use to indicate that we * are aware a variable isn't used. So we just silence that warning. * See: https://github.com/swig/swig/issues/192 for more discussion. */ #ifdef __INTEL_COMPILER # pragma warning disable 592 #endif /* Fix for jlong on some versions of gcc on Windows */ #if defined(__GNUC__) && !defined(__INTEL_COMPILER) typedef long long __int64; #endif /* Fix for jlong on 64-bit x86 Solaris */ #if defined(__x86_64) # ifdef _LP64 # undef _LP64 # endif #endif #include #include #include /* Support for throwing Java exceptions */ typedef enum { SWIG_JavaOutOfMemoryError = 1, SWIG_JavaIOException, SWIG_JavaRuntimeException, SWIG_JavaIndexOutOfBoundsException, SWIG_JavaArithmeticException, SWIG_JavaIllegalArgumentException, SWIG_JavaNullPointerException, SWIG_JavaDirectorPureVirtual, SWIG_JavaUnknownError } SWIG_JavaExceptionCodes; typedef struct { SWIG_JavaExceptionCodes code; const char *java_exception; } SWIG_JavaExceptions_t; static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) { jclass excep; static const SWIG_JavaExceptions_t java_exceptions[] = { { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" }, { SWIG_JavaIOException, "java/io/IOException" }, { SWIG_JavaRuntimeException, "java/lang/RuntimeException" }, { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" }, { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" }, { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" }, { SWIG_JavaNullPointerException, "java/lang/NullPointerException" }, { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" }, { SWIG_JavaUnknownError, "java/lang/UnknownError" }, { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" } }; const SWIG_JavaExceptions_t *except_ptr = java_exceptions; while (except_ptr->code != code && except_ptr->code) except_ptr++; jenv->ExceptionClear(); excep = jenv->FindClass(except_ptr->java_exception); if (excep) jenv->ThrowNew(excep, msg); } /* Contract support */ #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else /* ----------------------------------------------------------------------------- * director_common.swg * * This file contains support for director classes which is common between * languages. * ----------------------------------------------------------------------------- */ /* Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the 'Swig' namespace. This could be useful for multi-modules projects. */ #ifdef SWIG_DIRECTOR_STATIC /* Force anonymous (static) namespace */ #define Swig #endif /* ----------------------------------------------------------------------------- * director.swg * * This file contains support for director classes so that Java proxy * methods can be called from C++. * ----------------------------------------------------------------------------- */ #if defined(DEBUG_DIRECTOR_OWNED) || defined(DEBUG_DIRECTOR_EXCEPTION) #include #endif #include namespace Swig { /* Java object wrapper */ class JObjectWrapper { public: JObjectWrapper() : jthis_(NULL), weak_global_(true) { } ~JObjectWrapper() { jthis_ = NULL; weak_global_ = true; } bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) { if (!jthis_) { weak_global_ = !mem_own; // hold as weak global if explicitly requested or not owned if (jobj) jthis_ = weak_global_ ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj); #if defined(DEBUG_DIRECTOR_OWNED) std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl; #endif return true; } else { #if defined(DEBUG_DIRECTOR_OWNED) std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl; #endif return false; } } jobject get(JNIEnv *jenv) const { #if defined(DEBUG_DIRECTOR_OWNED) std::cout << "JObjectWrapper::get("; if (jthis_) std::cout << jthis_; else std::cout << "null"; std::cout << ") -> return new local ref" << std::endl; #endif return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_); } void release(JNIEnv *jenv) { #if defined(DEBUG_DIRECTOR_OWNED) std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl; #endif if (jthis_) { if (weak_global_) { if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE) jenv->DeleteWeakGlobalRef((jweak)jthis_); } else jenv->DeleteGlobalRef(jthis_); } jthis_ = NULL; weak_global_ = true; } /* Only call peek if you know what you are doing wrt to weak/global references */ jobject peek() { return jthis_; } /* Java proxy releases ownership of C++ object, C++ object is now responsible for destruction (creates NewGlobalRef to pin Java proxy) */ void java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) { if (take_or_release) { /* Java takes ownership of C++ object's lifetime. */ if (!weak_global_) { jenv->DeleteGlobalRef(jthis_); jthis_ = jenv->NewWeakGlobalRef(jself); weak_global_ = true; } } else { /* Java releases ownership of C++ object's lifetime */ if (weak_global_) { jenv->DeleteWeakGlobalRef((jweak)jthis_); jthis_ = jenv->NewGlobalRef(jself); weak_global_ = false; } } } private: /* pointer to Java object */ jobject jthis_; /* Local or global reference flag */ bool weak_global_; }; /* Local JNI reference deleter */ class LocalRefGuard { JNIEnv *jenv_; jobject jobj_; // non-copyable LocalRefGuard(const LocalRefGuard &); LocalRefGuard &operator=(const LocalRefGuard &); public: LocalRefGuard(JNIEnv *jenv, jobject jobj): jenv_(jenv), jobj_(jobj) {} ~LocalRefGuard() { if (jobj_) jenv_->DeleteLocalRef(jobj_); } }; /* director base class */ class Director { /* pointer to Java virtual machine */ JavaVM *swig_jvm_; protected: #if defined (_MSC_VER) && (_MSC_VER<1300) class JNIEnvWrapper; friend class JNIEnvWrapper; #endif /* Utility class for managing the JNI environment */ class JNIEnvWrapper { const Director *director_; JNIEnv *jenv_; int env_status; public: JNIEnvWrapper(const Director *director) : director_(director), jenv_(0), env_status(0) { #if defined(__ANDROID__) JNIEnv **jenv = &jenv_; #else void **jenv = (void **)&jenv_; #endif env_status = director_->swig_jvm_->GetEnv((void **)&jenv_, JNI_VERSION_1_2); #if defined(SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON) // Attach a daemon thread to the JVM. Useful when the JVM should not wait for // the thread to exit upon shutdown. Only for jdk-1.4 and later. director_->swig_jvm_->AttachCurrentThreadAsDaemon(jenv, NULL); #else director_->swig_jvm_->AttachCurrentThread(jenv, NULL); #endif } ~JNIEnvWrapper() { #if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD) // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call. // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak. if (env_status == JNI_EDETACHED) director_->swig_jvm_->DetachCurrentThread(); #endif } JNIEnv *getJNIEnv() const { return jenv_; } }; /* Java object wrapper */ JObjectWrapper swig_self_; /* Disconnect director from Java object */ void swig_disconnect_director_self(const char *disconn_method) { JNIEnvWrapper jnienv(this) ; JNIEnv *jenv = jnienv.getJNIEnv() ; jobject jobj = swig_self_.get(jenv); LocalRefGuard ref_deleter(jenv, jobj); #if defined(DEBUG_DIRECTOR_OWNED) std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl; #endif if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) { jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V"); if (disconn_meth) { #if defined(DEBUG_DIRECTOR_OWNED) std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl; #endif jenv->CallVoidMethod(jobj, disconn_meth); } } } public: Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() { /* Acquire the Java VM pointer */ jenv->GetJavaVM(&swig_jvm_); } virtual ~Director() { JNIEnvWrapper jnienv(this) ; JNIEnv *jenv = jnienv.getJNIEnv() ; swig_self_.release(jenv); } bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) { return swig_self_.set(jenv, jself, mem_own, weak_global); } jobject swig_get_self(JNIEnv *jenv) const { return swig_self_.get(jenv); } // Change C++ object's ownership, relative to Java void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) { swig_self_.java_change_ownership(jenv, jself, take_or_release); } }; // Zero initialized bool array template class BoolArray { bool array_[N]; public: BoolArray() { memset(array_, 0, sizeof(array_)); } bool& operator[](size_t n) { return array_[n]; } bool operator[](size_t n) const { return array_[n]; } }; // Utility classes and functions for exception handling. // Simple holder for a Java string during exception handling, providing access to a c-style string class JavaString { public: JavaString(JNIEnv *jenv, jstring jstr) : jenv_(jenv), jstr_(jstr), cstr_(0) { if (jenv_ && jstr_) cstr_ = (const char *) jenv_->GetStringUTFChars(jstr_, NULL); } ~JavaString() { if (jenv_ && jstr_ && cstr_) jenv_->ReleaseStringUTFChars(jstr_, cstr_); } const char *c_str(const char *null_string = "null JavaString") const { return cstr_ ? cstr_ : null_string; } private: // non-copyable JavaString(const JavaString &); JavaString &operator=(const JavaString &); JNIEnv *jenv_; jstring jstr_; const char *cstr_; }; // Helper class to extract the exception message from a Java throwable class JavaExceptionMessage { public: JavaExceptionMessage(JNIEnv *jenv, jthrowable throwable) : message_(jenv, exceptionMessageFromThrowable(jenv, throwable)) { } const char *message() const { return message_.c_str("Could not get exception message in JavaExceptionMessage"); } private: // non-copyable JavaExceptionMessage(const JavaExceptionMessage &); JavaExceptionMessage &operator=(const JavaExceptionMessage &); // Get exception message by calling Java method Throwable.getMessage() static jstring exceptionMessageFromThrowable(JNIEnv *jenv, jthrowable throwable) { jstring jmsg = NULL; if (jenv && throwable) { jenv->ExceptionClear(); // Cannot invoke methods with any pending exceptions jclass throwclz = jenv->GetObjectClass(throwable); if (throwclz) { // All Throwable classes have a getMessage() method, so call it to extract the exception message jmethodID getMessageMethodID = jenv->GetMethodID(throwclz, "getMessage", "()Ljava/lang/String;"); if (getMessageMethodID) jmsg = (jstring)jenv->CallObjectMethod(throwable, getMessageMethodID); } if (jmsg == NULL && jenv->ExceptionCheck()) jenv->ExceptionClear(); } return jmsg; } JavaString message_; }; // C++ Exception class for handling Java exceptions thrown during a director method Java upcall class DirectorException : public std::exception { public: // Construct exception from a Java throwable DirectorException(JNIEnv *jenv, jthrowable throwable) : classname_(0), msg_(0) { // Call Java method Object.getClass().getName() to obtain the throwable's class name (delimited by '/') if (throwable) { jclass throwclz = jenv->GetObjectClass(throwable); if (throwclz) { jclass clzclz = jenv->GetObjectClass(throwclz); if (clzclz) { jmethodID getNameMethodID = jenv->GetMethodID(clzclz, "getName", "()Ljava/lang/String;"); if (getNameMethodID) { jstring jstr_classname = (jstring)(jenv->CallObjectMethod(throwclz, getNameMethodID)); // Copy strings, since there is no guarantee that jenv will be active when handled if (jstr_classname) { JavaString jsclassname(jenv, jstr_classname); const char *classname = jsclassname.c_str(0); if (classname) classname_ = copypath(classname); } } } } } JavaExceptionMessage exceptionmsg(jenv, throwable); msg_ = copystr(exceptionmsg.message()); } // More general constructor for handling as a java.lang.RuntimeException DirectorException(const char *msg) : classname_(0), msg_(copystr(msg ? msg : "Unspecified DirectorException message")) { } ~DirectorException() throw() { delete[] classname_; delete[] msg_; } const char *what() const throw() { return msg_; } // Reconstruct and raise/throw the Java Exception that caused the DirectorException // Note that any error in the JNI exception handling results in a Java RuntimeException void raiseJavaException(JNIEnv *jenv) const { if (jenv) { jenv->ExceptionClear(); jmethodID ctorMethodID = 0; jclass throwableclass = 0; if (classname_) { throwableclass = jenv->FindClass(classname_); if (throwableclass) ctorMethodID = jenv->GetMethodID(throwableclass, "", "(Ljava/lang/String;)V"); } if (ctorMethodID) { jenv->ThrowNew(throwableclass, what()); } else { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, what()); } } } private: static char *copypath(const char *srcmsg) { char *target = copystr(srcmsg); for (char *c=target; *c; ++c) { if ('.' == *c) *c = '/'; } return target; } static char *copystr(const char *srcmsg) { char *target = 0; if (srcmsg) { size_t msglen = strlen(srcmsg) + 1; target = new char[msglen]; strncpy(target, srcmsg, msglen); } return target; } const char *classname_; const char *msg_; }; // Helper method to determine if a Java throwable matches a particular Java class type SWIGINTERN inline bool ExceptionMatches(JNIEnv *jenv, jthrowable throwable, const char *classname) { bool matches = false; if (throwable && jenv && classname) { // Exceptions need to be cleared for correct behavior. // The caller of ExceptionMatches should restore pending exceptions if desired - // the caller already has the throwable. jenv->ExceptionClear(); jclass clz = jenv->FindClass(classname); if (clz) { jclass classclz = jenv->GetObjectClass(clz); jmethodID isInstanceMethodID = jenv->GetMethodID(classclz, "isInstance", "(Ljava/lang/Object;)Z"); if (isInstanceMethodID) { matches = jenv->CallBooleanMethod(clz, isInstanceMethodID, throwable) != 0; } } #if defined(DEBUG_DIRECTOR_EXCEPTION) if (jenv->ExceptionCheck()) { // Typically occurs when an invalid classname argument is passed resulting in a ClassNotFoundException JavaExceptionMessage exc(jenv, jenv->ExceptionOccurred()); std::cout << "Error: ExceptionMatches: class '" << classname << "' : " << exc.message() << std::endl; } #endif } return matches; } } namespace Swig { namespace { jclass jclass_LinearMathJNI = NULL; jmethodID director_method_ids[29]; } } #ifndef BT_INFINITY static int btInfinityMask = 0x7F800000; #define BT_INFINITY (*(float*)&btInfinityMask) #endif #include #if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS) static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input); static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input); static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz); static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input); static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input); static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz); static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input); static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input); static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz); static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input); static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input); static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz); static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input); static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input); static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz); static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input); static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input); static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz); static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input); static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input); static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz); static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input); static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input); static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz); static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input); static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input); static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz); static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input); static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input); static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz); static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input); static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input); static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz); static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input); static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input); static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz); #else /* bool[] support */ static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetBooleanArrayElements(input, 0); if (!*jarr) return 0; *carr = new bool[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseBooleanArrayElements(input, jarr, 0); } static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz) { jboolean *arr; int i; jbooleanArray jresult = jenv->NewBooleanArray(sz); if (!jresult) return NULL; arr = jenv->GetBooleanArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseBooleanArrayElements(jresult, arr, 0); return jresult; } /* signed char[] support */ static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetByteArrayElements(input, 0); if (!*jarr) return 0; *carr = new signed char[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseByteArrayElements(input, jarr, 0); } static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz) { jbyte *arr; int i; jbyteArray jresult = jenv->NewByteArray(sz); if (!jresult) return NULL; arr = jenv->GetByteArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseByteArrayElements(jresult, arr, 0); return jresult; } /* unsigned char[] support */ static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetShortArrayElements(input, 0); if (!*jarr) return 0; *carr = new unsigned char[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseShortArrayElements(input, jarr, 0); } static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz) { jshort *arr; int i; jshortArray jresult = jenv->NewShortArray(sz); if (!jresult) return NULL; arr = jenv->GetShortArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseShortArrayElements(jresult, arr, 0); return jresult; } /* short[] support */ static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetShortArrayElements(input, 0); if (!*jarr) return 0; *carr = new short[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseShortArrayElements(input, jarr, 0); } static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz) { jshort *arr; int i; jshortArray jresult = jenv->NewShortArray(sz); if (!jresult) return NULL; arr = jenv->GetShortArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseShortArrayElements(jresult, arr, 0); return jresult; } /* unsigned short[] support */ static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetIntArrayElements(input, 0); if (!*jarr) return 0; *carr = new unsigned short[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseIntArrayElements(input, jarr, 0); } static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz) { jint *arr; int i; jintArray jresult = jenv->NewIntArray(sz); if (!jresult) return NULL; arr = jenv->GetIntArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseIntArrayElements(jresult, arr, 0); return jresult; } /* int[] support */ static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetIntArrayElements(input, 0); if (!*jarr) return 0; *carr = new int[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseIntArrayElements(input, jarr, 0); } static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz) { jint *arr; int i; jintArray jresult = jenv->NewIntArray(sz); if (!jresult) return NULL; arr = jenv->GetIntArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseIntArrayElements(jresult, arr, 0); return jresult; } /* unsigned int[] support */ static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetLongArrayElements(input, 0); if (!*jarr) return 0; *carr = new unsigned int[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseLongArrayElements(input, jarr, 0); } static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz) { jlong *arr; int i; jlongArray jresult = jenv->NewLongArray(sz); if (!jresult) return NULL; arr = jenv->GetLongArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseLongArrayElements(jresult, arr, 0); return jresult; } /* long[] support */ static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetIntArrayElements(input, 0); if (!*jarr) return 0; *carr = new long[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseIntArrayElements(input, jarr, 0); } static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz) { jint *arr; int i; jintArray jresult = jenv->NewIntArray(sz); if (!jresult) return NULL; arr = jenv->GetIntArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseIntArrayElements(jresult, arr, 0); return jresult; } /* unsigned long[] support */ static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetLongArrayElements(input, 0); if (!*jarr) return 0; *carr = new unsigned long[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseLongArrayElements(input, jarr, 0); } static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz) { jlong *arr; int i; jlongArray jresult = jenv->NewLongArray(sz); if (!jresult) return NULL; arr = jenv->GetLongArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseLongArrayElements(jresult, arr, 0); return jresult; } /* jlong[] support */ static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetLongArrayElements(input, 0); if (!*jarr) return 0; *carr = new jlong[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseLongArrayElements(input, jarr, 0); } static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz) { jlong *arr; int i; jlongArray jresult = jenv->NewLongArray(sz); if (!jresult) return NULL; arr = jenv->GetLongArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseLongArrayElements(jresult, arr, 0); return jresult; } /* float[] support */ static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetFloatArrayElements(input, 0); if (!*jarr) return 0; *carr = new float[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseFloatArrayElements(input, jarr, 0); } static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz) { jfloat *arr; int i; jfloatArray jresult = jenv->NewFloatArray(sz); if (!jresult) return NULL; arr = jenv->GetFloatArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseFloatArrayElements(jresult, arr, 0); return jresult; } /* double[] support */ static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input) { int i; jsize sz; if (!input) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array"); return 0; } sz = jenv->GetArrayLength(input); *jarr = jenv->GetDoubleArrayElements(input, 0); if (!*jarr) return 0; *carr = new double[sz]; if (!*carr) { SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed"); return 0; } for (i=0; iGetArrayLength(input); for (i=0; iReleaseDoubleArrayElements(input, jarr, 0); } static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz) { jdouble *arr; int i; jdoubleArray jresult = jenv->NewDoubleArray(sz); if (!jresult) return NULL; arr = jenv->GetDoubleArrayElements(jresult, 0); if (!arr) return NULL; for (i=0; iReleaseDoubleArrayElements(jresult, arr, 0); return jresult; } #endif #include #include #include #include #include #include #include /* Gets a global ref to the temp class. Do not release this. */ SWIGINTERN inline jclass gdx_getTempClassQuaternion(JNIEnv * jenv) { static jclass cls = NULL; if (cls == NULL) { cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); } return cls; } SWIGINTERN inline jobject gdx_takePoolObjectQuaternion(JNIEnv * jenv, const char * poolName) { jclass tempClass = gdx_getTempClassQuaternion(jenv); static jfieldID poolField = NULL; if (poolField == NULL) { poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); } jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); jclass poolClass = jenv->GetObjectClass(poolObject); static jmethodID obtainMethod = NULL; if (obtainMethod == NULL) { obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); } jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); jenv->DeleteLocalRef(poolObject); jenv->DeleteLocalRef(poolClass); return ret; } SWIGINTERN inline void gdx_releasePoolObjectQuaternion(JNIEnv * jenv, const char * poolName, jobject obj) { jclass tempClass = gdx_getTempClassQuaternion(jenv); static jfieldID poolField = NULL; if (poolField == NULL) { poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); } jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); jclass poolClass = jenv->GetObjectClass(poolObject); static jmethodID freeMethod = NULL; if (freeMethod == NULL) { freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); } jenv->CallVoidMethod(poolObject, freeMethod, obj); jenv->DeleteLocalRef(poolObject); jenv->DeleteLocalRef(poolClass); jenv->DeleteLocalRef(obj); } /* * A simple RAII wrapper to release jobjects we obtain from pools in * directorin typemaps. SWIG doesn't have hooks to release them after * they're used. */ class gdxPoolAutoReleaseQuaternion { private: JNIEnv * jenv; const char * poolName; jobject obj; public: gdxPoolAutoReleaseQuaternion(JNIEnv * jenv, const char * poolName, jobject obj) : jenv(jenv), poolName(poolName), obj(obj) { }; virtual ~gdxPoolAutoReleaseQuaternion() { gdx_releasePoolObjectQuaternion(this->jenv, this->poolName, this->obj); }; }; // Workaround for some strange swig behaviour /* Gets a global ref to the temp class's Return Quaternion. Do not release this. */ SWIGINTERN inline jobject gdx_getReturnQuaternion(JNIEnv * jenv) { static jobject ret = NULL; if (ret == NULL) { jclass tempClass = gdx_getTempClassQuaternion(jenv); jfieldID field = jenv->GetStaticFieldID(tempClass, "staticQuaternion", "Lcom/badlogic/gdx/math/Quaternion;"); ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); } return ret; } /* Sets the data in the Bullet type from the Gdx type. */ SWIGINTERN inline void gdx_setbtQuaternionFromQuaternion(JNIEnv * jenv, btQuaternion & target, jobject source) { Quaternion_to_btQuaternion(jenv, target, source); } SWIGINTERN inline void gdx_setbtQuaternionFromQuaternion(JNIEnv * jenv, btQuaternion * target, jobject source) { gdx_setbtQuaternionFromQuaternion(jenv, *target, source); } /* Sets the data in the Gdx type from the Bullet type. */ SWIGINTERN inline void gdx_setQuaternionFrombtQuaternion(JNIEnv * jenv, jobject target, const btQuaternion & source) { btQuaternion_to_Quaternion(jenv, target, source); } SWIGINTERN inline void gdx_setQuaternionFrombtQuaternion(JNIEnv * jenv, jobject target, const btQuaternion * source) { gdx_setQuaternionFrombtQuaternion(jenv, target, *source); } /* * RAII wrapper to commit changes made to a local btQuaternion back to Quaternion */ class gdxAutoCommitQuaternion { private: JNIEnv * jenv; jobject jQuaternion; btQuaternion & cbtQuaternion; public: gdxAutoCommitQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion & cbtQuaternion) : jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(cbtQuaternion) { }; gdxAutoCommitQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion * cbtQuaternion) : jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(*cbtQuaternion) { }; virtual ~gdxAutoCommitQuaternion() { gdx_setQuaternionFrombtQuaternion(this->jenv, this->jQuaternion, this->cbtQuaternion); }; }; class gdxAutoCommitbtQuaternionAndReleaseQuaternion { private: JNIEnv * jenv; jobject jQuaternion; btQuaternion & cbtQuaternion; const char * poolName; public: gdxAutoCommitbtQuaternionAndReleaseQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion & cbtQuaternion, const char *poolName) : jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(cbtQuaternion), poolName(poolName) { }; gdxAutoCommitbtQuaternionAndReleaseQuaternion(JNIEnv * jenv, jobject jQuaternion, btQuaternion * cbtQuaternion, const char *poolName) : jenv(jenv), jQuaternion(jQuaternion), cbtQuaternion(*cbtQuaternion), poolName(poolName) { }; virtual ~gdxAutoCommitbtQuaternionAndReleaseQuaternion() { gdx_setbtQuaternionFromQuaternion(this->jenv, this->cbtQuaternion, this->jQuaternion); gdx_releasePoolObjectQuaternion(this->jenv, this->poolName, this->jQuaternion); }; }; /* Gets a global ref to the temp class. Do not release this. */ SWIGINTERN inline jclass gdx_getTempClassVector3(JNIEnv * jenv) { static jclass cls = NULL; if (cls == NULL) { cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); } return cls; } SWIGINTERN inline jobject gdx_takePoolObjectVector3(JNIEnv * jenv, const char * poolName) { jclass tempClass = gdx_getTempClassVector3(jenv); static jfieldID poolField = NULL; if (poolField == NULL) { poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); } jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); jclass poolClass = jenv->GetObjectClass(poolObject); static jmethodID obtainMethod = NULL; if (obtainMethod == NULL) { obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); } jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); jenv->DeleteLocalRef(poolObject); jenv->DeleteLocalRef(poolClass); return ret; } SWIGINTERN inline void gdx_releasePoolObjectVector3(JNIEnv * jenv, const char * poolName, jobject obj) { jclass tempClass = gdx_getTempClassVector3(jenv); static jfieldID poolField = NULL; if (poolField == NULL) { poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); } jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); jclass poolClass = jenv->GetObjectClass(poolObject); static jmethodID freeMethod = NULL; if (freeMethod == NULL) { freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); } jenv->CallVoidMethod(poolObject, freeMethod, obj); jenv->DeleteLocalRef(poolObject); jenv->DeleteLocalRef(poolClass); jenv->DeleteLocalRef(obj); } /* * A simple RAII wrapper to release jobjects we obtain from pools in * directorin typemaps. SWIG doesn't have hooks to release them after * they're used. */ class gdxPoolAutoReleaseVector3 { private: JNIEnv * jenv; const char * poolName; jobject obj; public: gdxPoolAutoReleaseVector3(JNIEnv * jenv, const char * poolName, jobject obj) : jenv(jenv), poolName(poolName), obj(obj) { }; virtual ~gdxPoolAutoReleaseVector3() { gdx_releasePoolObjectVector3(this->jenv, this->poolName, this->obj); }; }; // Workaround for some strange swig behaviour /* Gets a global ref to the temp class's Return Vector3. Do not release this. */ SWIGINTERN inline jobject gdx_getReturnVector3(JNIEnv * jenv) { static jobject ret = NULL; if (ret == NULL) { jclass tempClass = gdx_getTempClassVector3(jenv); jfieldID field = jenv->GetStaticFieldID(tempClass, "staticVector3", "Lcom/badlogic/gdx/math/Vector3;"); ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); } return ret; } /* Sets the data in the Bullet type from the Gdx type. */ SWIGINTERN inline void gdx_setbtVector3FromVector3(JNIEnv * jenv, btVector3 & target, jobject source) { Vector3_to_btVector3(jenv, target, source); } SWIGINTERN inline void gdx_setbtVector3FromVector3(JNIEnv * jenv, btVector3 * target, jobject source) { gdx_setbtVector3FromVector3(jenv, *target, source); } /* Sets the data in the Gdx type from the Bullet type. */ SWIGINTERN inline void gdx_setVector3FrombtVector3(JNIEnv * jenv, jobject target, const btVector3 & source) { btVector3_to_Vector3(jenv, target, source); } SWIGINTERN inline void gdx_setVector3FrombtVector3(JNIEnv * jenv, jobject target, const btVector3 * source) { gdx_setVector3FrombtVector3(jenv, target, *source); } /* * RAII wrapper to commit changes made to a local btVector3 back to Vector3 */ class gdxAutoCommitVector3 { private: JNIEnv * jenv; jobject jVector3; btVector3 & cbtVector3; public: gdxAutoCommitVector3(JNIEnv * jenv, jobject jVector3, btVector3 & cbtVector3) : jenv(jenv), jVector3(jVector3), cbtVector3(cbtVector3) { }; gdxAutoCommitVector3(JNIEnv * jenv, jobject jVector3, btVector3 * cbtVector3) : jenv(jenv), jVector3(jVector3), cbtVector3(*cbtVector3) { }; virtual ~gdxAutoCommitVector3() { gdx_setVector3FrombtVector3(this->jenv, this->jVector3, this->cbtVector3); }; }; class gdxAutoCommitbtVector3AndReleaseVector3 { private: JNIEnv * jenv; jobject jVector3; btVector3 & cbtVector3; const char * poolName; public: gdxAutoCommitbtVector3AndReleaseVector3(JNIEnv * jenv, jobject jVector3, btVector3 & cbtVector3, const char *poolName) : jenv(jenv), jVector3(jVector3), cbtVector3(cbtVector3), poolName(poolName) { }; gdxAutoCommitbtVector3AndReleaseVector3(JNIEnv * jenv, jobject jVector3, btVector3 * cbtVector3, const char *poolName) : jenv(jenv), jVector3(jVector3), cbtVector3(*cbtVector3), poolName(poolName) { }; virtual ~gdxAutoCommitbtVector3AndReleaseVector3() { gdx_setbtVector3FromVector3(this->jenv, this->cbtVector3, this->jVector3); gdx_releasePoolObjectVector3(this->jenv, this->poolName, this->jVector3); }; }; /* Gets a global ref to the temp class. Do not release this. */ SWIGINTERN inline jclass gdx_getTempClassMatrix3(JNIEnv * jenv) { static jclass cls = NULL; if (cls == NULL) { cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); } return cls; } SWIGINTERN inline jobject gdx_takePoolObjectMatrix3(JNIEnv * jenv, const char * poolName) { jclass tempClass = gdx_getTempClassMatrix3(jenv); static jfieldID poolField = NULL; if (poolField == NULL) { poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); } jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); jclass poolClass = jenv->GetObjectClass(poolObject); static jmethodID obtainMethod = NULL; if (obtainMethod == NULL) { obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); } jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); jenv->DeleteLocalRef(poolObject); jenv->DeleteLocalRef(poolClass); return ret; } SWIGINTERN inline void gdx_releasePoolObjectMatrix3(JNIEnv * jenv, const char * poolName, jobject obj) { jclass tempClass = gdx_getTempClassMatrix3(jenv); static jfieldID poolField = NULL; if (poolField == NULL) { poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); } jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); jclass poolClass = jenv->GetObjectClass(poolObject); static jmethodID freeMethod = NULL; if (freeMethod == NULL) { freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); } jenv->CallVoidMethod(poolObject, freeMethod, obj); jenv->DeleteLocalRef(poolObject); jenv->DeleteLocalRef(poolClass); jenv->DeleteLocalRef(obj); } /* * A simple RAII wrapper to release jobjects we obtain from pools in * directorin typemaps. SWIG doesn't have hooks to release them after * they're used. */ class gdxPoolAutoReleaseMatrix3 { private: JNIEnv * jenv; const char * poolName; jobject obj; public: gdxPoolAutoReleaseMatrix3(JNIEnv * jenv, const char * poolName, jobject obj) : jenv(jenv), poolName(poolName), obj(obj) { }; virtual ~gdxPoolAutoReleaseMatrix3() { gdx_releasePoolObjectMatrix3(this->jenv, this->poolName, this->obj); }; }; // Workaround for some strange swig behaviour /* Gets a global ref to the temp class's Return Matrix3. Do not release this. */ SWIGINTERN inline jobject gdx_getReturnMatrix3(JNIEnv * jenv) { static jobject ret = NULL; if (ret == NULL) { jclass tempClass = gdx_getTempClassMatrix3(jenv); jfieldID field = jenv->GetStaticFieldID(tempClass, "staticMatrix3", "Lcom/badlogic/gdx/math/Matrix3;"); ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); } return ret; } /* Sets the data in the Bullet type from the Gdx type. */ SWIGINTERN inline void gdx_setbtMatrix3x3FromMatrix3(JNIEnv * jenv, btMatrix3x3 & target, jobject source) { Matrix3_to_btMatrix3(jenv, target, source); } SWIGINTERN inline void gdx_setbtMatrix3x3FromMatrix3(JNIEnv * jenv, btMatrix3x3 * target, jobject source) { gdx_setbtMatrix3x3FromMatrix3(jenv, *target, source); } /* Sets the data in the Gdx type from the Bullet type. */ SWIGINTERN inline void gdx_setMatrix3FrombtMatrix3x3(JNIEnv * jenv, jobject target, const btMatrix3x3 & source) { btMatrix3_to_Matrix3(jenv, target, source); } SWIGINTERN inline void gdx_setMatrix3FrombtMatrix3x3(JNIEnv * jenv, jobject target, const btMatrix3x3 * source) { gdx_setMatrix3FrombtMatrix3x3(jenv, target, *source); } /* * RAII wrapper to commit changes made to a local btMatrix3x3 back to Matrix3 */ class gdxAutoCommitMatrix3 { private: JNIEnv * jenv; jobject jMatrix3; btMatrix3x3 & cbtMatrix3x3; public: gdxAutoCommitMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 & cbtMatrix3x3) : jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(cbtMatrix3x3) { }; gdxAutoCommitMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 * cbtMatrix3x3) : jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(*cbtMatrix3x3) { }; virtual ~gdxAutoCommitMatrix3() { gdx_setMatrix3FrombtMatrix3x3(this->jenv, this->jMatrix3, this->cbtMatrix3x3); }; }; class gdxAutoCommitbtMatrix3x3AndReleaseMatrix3 { private: JNIEnv * jenv; jobject jMatrix3; btMatrix3x3 & cbtMatrix3x3; const char * poolName; public: gdxAutoCommitbtMatrix3x3AndReleaseMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 & cbtMatrix3x3, const char *poolName) : jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(cbtMatrix3x3), poolName(poolName) { }; gdxAutoCommitbtMatrix3x3AndReleaseMatrix3(JNIEnv * jenv, jobject jMatrix3, btMatrix3x3 * cbtMatrix3x3, const char *poolName) : jenv(jenv), jMatrix3(jMatrix3), cbtMatrix3x3(*cbtMatrix3x3), poolName(poolName) { }; virtual ~gdxAutoCommitbtMatrix3x3AndReleaseMatrix3() { gdx_setbtMatrix3x3FromMatrix3(this->jenv, this->cbtMatrix3x3, this->jMatrix3); gdx_releasePoolObjectMatrix3(this->jenv, this->poolName, this->jMatrix3); }; }; /* Gets a global ref to the temp class. Do not release this. */ SWIGINTERN inline jclass gdx_getTempClassMatrix4(JNIEnv * jenv) { static jclass cls = NULL; if (cls == NULL) { cls = (jclass) jenv->NewGlobalRef(jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/LinearMath")); } return cls; } SWIGINTERN inline jobject gdx_takePoolObjectMatrix4(JNIEnv * jenv, const char * poolName) { jclass tempClass = gdx_getTempClassMatrix4(jenv); static jfieldID poolField = NULL; if (poolField == NULL) { poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); } jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); jclass poolClass = jenv->GetObjectClass(poolObject); static jmethodID obtainMethod = NULL; if (obtainMethod == NULL) { obtainMethod = (jmethodID) jenv->GetMethodID(poolClass, "obtain", "()Ljava/lang/Object;"); } jobject ret = jenv->CallObjectMethod(poolObject, obtainMethod); jenv->DeleteLocalRef(poolObject); jenv->DeleteLocalRef(poolClass); return ret; } SWIGINTERN inline void gdx_releasePoolObjectMatrix4(JNIEnv * jenv, const char * poolName, jobject obj) { jclass tempClass = gdx_getTempClassMatrix4(jenv); static jfieldID poolField = NULL; if (poolField == NULL) { poolField = jenv->GetStaticFieldID(tempClass, poolName, "Lcom/badlogic/gdx/utils/Pool;"); } jobject poolObject = jenv->GetStaticObjectField(tempClass, poolField); jclass poolClass = jenv->GetObjectClass(poolObject); static jmethodID freeMethod = NULL; if (freeMethod == NULL) { freeMethod = (jmethodID) jenv->GetMethodID(poolClass, "free", "(Ljava/lang/Object;)V"); } jenv->CallVoidMethod(poolObject, freeMethod, obj); jenv->DeleteLocalRef(poolObject); jenv->DeleteLocalRef(poolClass); jenv->DeleteLocalRef(obj); } /* * A simple RAII wrapper to release jobjects we obtain from pools in * directorin typemaps. SWIG doesn't have hooks to release them after * they're used. */ class gdxPoolAutoReleaseMatrix4 { private: JNIEnv * jenv; const char * poolName; jobject obj; public: gdxPoolAutoReleaseMatrix4(JNIEnv * jenv, const char * poolName, jobject obj) : jenv(jenv), poolName(poolName), obj(obj) { }; virtual ~gdxPoolAutoReleaseMatrix4() { gdx_releasePoolObjectMatrix4(this->jenv, this->poolName, this->obj); }; }; // Workaround for some strange swig behaviour /* Gets a global ref to the temp class's Return Matrix4. Do not release this. */ SWIGINTERN inline jobject gdx_getReturnMatrix4(JNIEnv * jenv) { static jobject ret = NULL; if (ret == NULL) { jclass tempClass = gdx_getTempClassMatrix4(jenv); jfieldID field = jenv->GetStaticFieldID(tempClass, "staticMatrix4", "Lcom/badlogic/gdx/math/Matrix4;"); ret = jenv->NewGlobalRef(jenv->GetStaticObjectField(tempClass, field)); } return ret; } /* Sets the data in the Bullet type from the Gdx type. */ SWIGINTERN inline void gdx_setbtTransformFromMatrix4(JNIEnv * jenv, btTransform & target, jobject source) { Matrix4_to_btTransform(jenv, target, source); } SWIGINTERN inline void gdx_setbtTransformFromMatrix4(JNIEnv * jenv, btTransform * target, jobject source) { gdx_setbtTransformFromMatrix4(jenv, *target, source); } /* Sets the data in the Gdx type from the Bullet type. */ SWIGINTERN inline void gdx_setMatrix4FrombtTransform(JNIEnv * jenv, jobject target, const btTransform & source) { btTransform_to_Matrix4(jenv, target, source); } SWIGINTERN inline void gdx_setMatrix4FrombtTransform(JNIEnv * jenv, jobject target, const btTransform * source) { gdx_setMatrix4FrombtTransform(jenv, target, *source); } /* * RAII wrapper to commit changes made to a local btTransform back to Matrix4 */ class gdxAutoCommitMatrix4 { private: JNIEnv * jenv; jobject jMatrix4; btTransform & cbtTransform; public: gdxAutoCommitMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform & cbtTransform) : jenv(jenv), jMatrix4(jMatrix4), cbtTransform(cbtTransform) { }; gdxAutoCommitMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform * cbtTransform) : jenv(jenv), jMatrix4(jMatrix4), cbtTransform(*cbtTransform) { }; virtual ~gdxAutoCommitMatrix4() { gdx_setMatrix4FrombtTransform(this->jenv, this->jMatrix4, this->cbtTransform); }; }; class gdxAutoCommitbtTransformAndReleaseMatrix4 { private: JNIEnv * jenv; jobject jMatrix4; btTransform & cbtTransform; const char * poolName; public: gdxAutoCommitbtTransformAndReleaseMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform & cbtTransform, const char *poolName) : jenv(jenv), jMatrix4(jMatrix4), cbtTransform(cbtTransform), poolName(poolName) { }; gdxAutoCommitbtTransformAndReleaseMatrix4(JNIEnv * jenv, jobject jMatrix4, btTransform * cbtTransform, const char *poolName) : jenv(jenv), jMatrix4(jMatrix4), cbtTransform(*cbtTransform), poolName(poolName) { }; virtual ~gdxAutoCommitbtTransformAndReleaseMatrix4() { gdx_setbtTransformFromMatrix4(this->jenv, this->cbtTransform, this->jMatrix4); gdx_releasePoolObjectMatrix4(this->jenv, this->poolName, this->jMatrix4); }; }; #include #include #include #include #include #include #include bool btGeometryUtil::isInside(btAlignedObjectArray const&, btVector3 const&, float) { return false; } #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include SWIGINTERN void btDefaultMotionState_getGraphicsWorldTrans(btDefaultMotionState *self,btTransform &out){ out = self->m_graphicsWorldTrans; } SWIGINTERN void btDefaultMotionState_getCenterOfMassOffset(btDefaultMotionState *self,btTransform &out){ out = self->m_centerOfMassOffset; } SWIGINTERN void btDefaultMotionState_getStartWorldTrans(btDefaultMotionState *self,btTransform &out){ out = self->m_startWorldTrans; } /* --------------------------------------------------- * C++ director class methods * --------------------------------------------------- */ #include "linearmath_wrap.h" SwigDirector_btIDebugDraw::SwigDirector_btIDebugDraw(JNIEnv *jenv) : btIDebugDraw(), Swig::Director(jenv) { } SwigDirector_btIDebugDraw::~SwigDirector_btIDebugDraw() { swig_disconnect_director_self("swigDirectorDisconnect"); } btIDebugDraw::DefaultColors SwigDirector_btIDebugDraw::getDefaultColors() const { btIDebugDraw::DefaultColors c_result ; jlong jresult = 0 ; JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; btIDebugDraw::DefaultColors *argp ; if (!swig_override[0]) { return btIDebugDraw::getDefaultColors(); } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[0], swigjobj); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } argp = *(btIDebugDraw::DefaultColors **)&jresult; if (!argp) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type btIDebugDraw::DefaultColors"); return c_result; } c_result = *argp; } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::getDefaultColors "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); return c_result; } void SwigDirector_btIDebugDraw::setDefaultColors(btIDebugDraw::DefaultColors const &arg0) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jlong jarg0 = 0 ; if (!swig_override[1]) { btIDebugDraw::setDefaultColors(arg0); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { *(btIDebugDraw::DefaultColors **)&jarg0 = (btIDebugDraw::DefaultColors *) &arg0; jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[1], swigjobj, jarg0); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::setDefaultColors "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawLine(btVector3 const &from, btVector3 const &to, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jfrom = 0 ; jobject jto = 0 ; jobject jcolor = 0 ; if (!swig_override[2]) { SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::drawLine."); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jfrom = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jfrom, from); gdxPoolAutoReleaseVector3 autoRelease_jfrom(jenv, "poolVector3", jfrom); jto = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jto, to); gdxPoolAutoReleaseVector3 autoRelease_jto(jenv, "poolVector3", jto); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[2], swigjobj, jfrom, jto, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawLine "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawLine(btVector3 const &from, btVector3 const &to, btVector3 const &fromColor, btVector3 const &toColor) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jfrom = 0 ; jobject jto = 0 ; jobject jfromColor = 0 ; jobject jtoColor = 0 ; if (!swig_override[3]) { btIDebugDraw::drawLine(from,to,fromColor,toColor); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jfrom = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jfrom, from); gdxPoolAutoReleaseVector3 autoRelease_jfrom(jenv, "poolVector3", jfrom); jto = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jto, to); gdxPoolAutoReleaseVector3 autoRelease_jto(jenv, "poolVector3", jto); jfromColor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jfromColor, fromColor); gdxPoolAutoReleaseVector3 autoRelease_jfromColor(jenv, "poolVector3", jfromColor); jtoColor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jtoColor, toColor); gdxPoolAutoReleaseVector3 autoRelease_jtoColor(jenv, "poolVector3", jtoColor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[3], swigjobj, jfrom, jto, jfromColor, jtoColor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawLine "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawSphere(btScalar radius, btTransform const &transform, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jfloat jradius ; jobject jtransform = 0 ; jobject jcolor = 0 ; if (!swig_override[4]) { btIDebugDraw::drawSphere(radius,transform,color); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jradius = (jfloat) radius; jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[4], swigjobj, jradius, jtransform, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawSphere "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawSphere(btVector3 const &p, btScalar radius, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jp = 0 ; jfloat jradius ; jobject jcolor = 0 ; if (!swig_override[5]) { btIDebugDraw::drawSphere(p,radius,color); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jp = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jp, p); gdxPoolAutoReleaseVector3 autoRelease_jp(jenv, "poolVector3", jp); jradius = (jfloat) radius; jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[5], swigjobj, jp, jradius, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawSphere "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawTriangle(btVector3 const &v0, btVector3 const &v1, btVector3 const &v2, btVector3 const &arg3, btVector3 const &arg4, btVector3 const &arg5, btVector3 const &color, btScalar alpha) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jv0 = 0 ; jobject jv1 = 0 ; jobject jv2 = 0 ; jobject jarg3 = 0 ; jobject jarg4 = 0 ; jobject jarg5 = 0 ; jobject jcolor = 0 ; jfloat jalpha ; if (!swig_override[6]) { btIDebugDraw::drawTriangle(v0,v1,v2,arg3,arg4,arg5,color,alpha); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jv0 = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jv0, v0); gdxPoolAutoReleaseVector3 autoRelease_jv0(jenv, "poolVector3", jv0); jv1 = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jv1, v1); gdxPoolAutoReleaseVector3 autoRelease_jv1(jenv, "poolVector3", jv1); jv2 = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jv2, v2); gdxPoolAutoReleaseVector3 autoRelease_jv2(jenv, "poolVector3", jv2); jarg3 = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jarg3, arg3); gdxPoolAutoReleaseVector3 autoRelease_jarg3(jenv, "poolVector3", jarg3); jarg4 = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jarg4, arg4); gdxPoolAutoReleaseVector3 autoRelease_jarg4(jenv, "poolVector3", jarg4); jarg5 = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jarg5, arg5); gdxPoolAutoReleaseVector3 autoRelease_jarg5(jenv, "poolVector3", jarg5); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jalpha = (jfloat) alpha; jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[6], swigjobj, jv0, jv1, jv2, jarg3, jarg4, jarg5, jcolor, jalpha); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawTriangle "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawTriangle(btVector3 const &v0, btVector3 const &v1, btVector3 const &v2, btVector3 const &color, btScalar arg4) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jv0 = 0 ; jobject jv1 = 0 ; jobject jv2 = 0 ; jobject jcolor = 0 ; jfloat jarg4 ; if (!swig_override[7]) { btIDebugDraw::drawTriangle(v0,v1,v2,color,arg4); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jv0 = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jv0, v0); gdxPoolAutoReleaseVector3 autoRelease_jv0(jenv, "poolVector3", jv0); jv1 = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jv1, v1); gdxPoolAutoReleaseVector3 autoRelease_jv1(jenv, "poolVector3", jv1); jv2 = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jv2, v2); gdxPoolAutoReleaseVector3 autoRelease_jv2(jenv, "poolVector3", jv2); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jarg4 = (jfloat) arg4; jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[7], swigjobj, jv0, jv1, jv2, jcolor, jarg4); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawTriangle "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawContactPoint(btVector3 const &PointOnB, btVector3 const &normalOnB, btScalar distance, int lifeTime, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jPointOnB = 0 ; jobject jnormalOnB = 0 ; jfloat jdistance ; jint jlifeTime ; jobject jcolor = 0 ; if (!swig_override[8]) { SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::drawContactPoint."); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jPointOnB = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jPointOnB, PointOnB); gdxPoolAutoReleaseVector3 autoRelease_jPointOnB(jenv, "poolVector3", jPointOnB); jnormalOnB = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jnormalOnB, normalOnB); gdxPoolAutoReleaseVector3 autoRelease_jnormalOnB(jenv, "poolVector3", jnormalOnB); jdistance = (jfloat) distance; jlifeTime = (jint) lifeTime; jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[8], swigjobj, jPointOnB, jnormalOnB, jdistance, jlifeTime, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawContactPoint "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::reportErrorWarning(char const *warningString) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jstring jwarningString = 0 ; if (!swig_override[9]) { SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::reportErrorWarning."); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jwarningString = 0; if (warningString) { jwarningString = jenv->NewStringUTF((const char *)warningString); if (!jwarningString) return ; } Swig::LocalRefGuard warningString_refguard(jenv, jwarningString); // boohoo jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[9], swigjobj, jwarningString); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::reportErrorWarning "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::draw3dText(btVector3 const &location, char const *textString) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jlocation = 0 ; jstring jtextString = 0 ; if (!swig_override[10]) { SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::draw3dText."); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jlocation = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jlocation, location); gdxPoolAutoReleaseVector3 autoRelease_jlocation(jenv, "poolVector3", jlocation); jtextString = 0; if (textString) { jtextString = jenv->NewStringUTF((const char *)textString); if (!jtextString) return ; } Swig::LocalRefGuard textString_refguard(jenv, jtextString); // boohoo jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[10], swigjobj, jlocation, jtextString); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::draw3dText "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::setDebugMode(int debugMode) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jint jdebugMode ; if (!swig_override[11]) { SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::setDebugMode."); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jdebugMode = (jint) debugMode; jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[11], swigjobj, jdebugMode); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::setDebugMode "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } int SwigDirector_btIDebugDraw::getDebugMode() const { int c_result = SwigValueInit< int >() ; jint jresult = 0 ; JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; if (!swig_override[12]) { SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btIDebugDraw::getDebugMode."); return c_result; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[12], swigjobj); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } c_result = (int)jresult; } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::getDebugMode "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); return c_result; } void SwigDirector_btIDebugDraw::drawAabb(btVector3 const &from, btVector3 const &to, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jfrom = 0 ; jobject jto = 0 ; jobject jcolor = 0 ; if (!swig_override[13]) { btIDebugDraw::drawAabb(from,to,color); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jfrom = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jfrom, from); gdxPoolAutoReleaseVector3 autoRelease_jfrom(jenv, "poolVector3", jfrom); jto = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jto, to); gdxPoolAutoReleaseVector3 autoRelease_jto(jenv, "poolVector3", jto); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[13], swigjobj, jfrom, jto, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawAabb "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawTransform(btTransform const &transform, btScalar orthoLen) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jtransform = 0 ; jfloat jorthoLen ; if (!swig_override[14]) { btIDebugDraw::drawTransform(transform,orthoLen); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); jorthoLen = (jfloat) orthoLen; jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[14], swigjobj, jtransform, jorthoLen); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawTransform "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawArc(btVector3 const ¢er, btVector3 const &normal, btVector3 const &axis, btScalar radiusA, btScalar radiusB, btScalar minAngle, btScalar maxAngle, btVector3 const &color, bool drawSect, btScalar stepDegrees) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jcenter = 0 ; jobject jnormal = 0 ; jobject jaxis = 0 ; jfloat jradiusA ; jfloat jradiusB ; jfloat jminAngle ; jfloat jmaxAngle ; jobject jcolor = 0 ; jboolean jdrawSect ; jfloat jstepDegrees ; if (!swig_override[15]) { btIDebugDraw::drawArc(center,normal,axis,radiusA,radiusB,minAngle,maxAngle,color,drawSect,stepDegrees); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jcenter = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcenter, center); gdxPoolAutoReleaseVector3 autoRelease_jcenter(jenv, "poolVector3", jcenter); jnormal = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jnormal, normal); gdxPoolAutoReleaseVector3 autoRelease_jnormal(jenv, "poolVector3", jnormal); jaxis = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jaxis, axis); gdxPoolAutoReleaseVector3 autoRelease_jaxis(jenv, "poolVector3", jaxis); jradiusA = (jfloat) radiusA; jradiusB = (jfloat) radiusB; jminAngle = (jfloat) minAngle; jmaxAngle = (jfloat) maxAngle; jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jdrawSect = (jboolean) drawSect; jstepDegrees = (jfloat) stepDegrees; jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[15], swigjobj, jcenter, jnormal, jaxis, jradiusA, jradiusB, jminAngle, jmaxAngle, jcolor, jdrawSect, jstepDegrees); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawArc "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawSpherePatch(btVector3 const ¢er, btVector3 const &up, btVector3 const &axis, btScalar radius, btScalar minTh, btScalar maxTh, btScalar minPs, btScalar maxPs, btVector3 const &color, btScalar stepDegrees, bool drawCenter) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jcenter = 0 ; jobject jup = 0 ; jobject jaxis = 0 ; jfloat jradius ; jfloat jminTh ; jfloat jmaxTh ; jfloat jminPs ; jfloat jmaxPs ; jobject jcolor = 0 ; jfloat jstepDegrees ; jboolean jdrawCenter ; if (!swig_override[17]) { btIDebugDraw::drawSpherePatch(center,up,axis,radius,minTh,maxTh,minPs,maxPs,color,stepDegrees,drawCenter); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jcenter = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcenter, center); gdxPoolAutoReleaseVector3 autoRelease_jcenter(jenv, "poolVector3", jcenter); jup = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jup, up); gdxPoolAutoReleaseVector3 autoRelease_jup(jenv, "poolVector3", jup); jaxis = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jaxis, axis); gdxPoolAutoReleaseVector3 autoRelease_jaxis(jenv, "poolVector3", jaxis); jradius = (jfloat) radius; jminTh = (jfloat) minTh; jmaxTh = (jfloat) maxTh; jminPs = (jfloat) minPs; jmaxPs = (jfloat) maxPs; jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jstepDegrees = (jfloat) stepDegrees; jdrawCenter = (jboolean) drawCenter; jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[17], swigjobj, jcenter, jup, jaxis, jradius, jminTh, jmaxTh, jminPs, jmaxPs, jcolor, jstepDegrees, jdrawCenter); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawSpherePatch "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawBox(btVector3 const &bbMin, btVector3 const &bbMax, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jbbMin = 0 ; jobject jbbMax = 0 ; jobject jcolor = 0 ; if (!swig_override[20]) { btIDebugDraw::drawBox(bbMin,bbMax,color); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jbbMin = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jbbMin, bbMin); gdxPoolAutoReleaseVector3 autoRelease_jbbMin(jenv, "poolVector3", jbbMin); jbbMax = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jbbMax, bbMax); gdxPoolAutoReleaseVector3 autoRelease_jbbMax(jenv, "poolVector3", jbbMax); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[20], swigjobj, jbbMin, jbbMax, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawBox "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawBox(btVector3 const &bbMin, btVector3 const &bbMax, btTransform const &trans, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jbbMin = 0 ; jobject jbbMax = 0 ; jobject jtrans = 0 ; jobject jcolor = 0 ; if (!swig_override[21]) { btIDebugDraw::drawBox(bbMin,bbMax,trans,color); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jbbMin = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jbbMin, bbMin); gdxPoolAutoReleaseVector3 autoRelease_jbbMin(jenv, "poolVector3", jbbMin); jbbMax = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jbbMax, bbMax); gdxPoolAutoReleaseVector3 autoRelease_jbbMax(jenv, "poolVector3", jbbMax); jtrans = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); gdx_setMatrix4FrombtTransform(jenv, jtrans, trans); gdxPoolAutoReleaseMatrix4 autoRelease_jtrans(jenv, "poolMatrix4", jtrans); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[21], swigjobj, jbbMin, jbbMax, jtrans, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawBox "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawCapsule(btScalar radius, btScalar halfHeight, int upAxis, btTransform const &transform, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jfloat jradius ; jfloat jhalfHeight ; jint jupAxis ; jobject jtransform = 0 ; jobject jcolor = 0 ; if (!swig_override[22]) { btIDebugDraw::drawCapsule(radius,halfHeight,upAxis,transform,color); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jradius = (jfloat) radius; jhalfHeight = (jfloat) halfHeight; jupAxis = (jint) upAxis; jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[22], swigjobj, jradius, jhalfHeight, jupAxis, jtransform, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawCapsule "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, btTransform const &transform, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jfloat jradius ; jfloat jhalfHeight ; jint jupAxis ; jobject jtransform = 0 ; jobject jcolor = 0 ; if (!swig_override[23]) { btIDebugDraw::drawCylinder(radius,halfHeight,upAxis,transform,color); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jradius = (jfloat) radius; jhalfHeight = (jfloat) halfHeight; jupAxis = (jint) upAxis; jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[23], swigjobj, jradius, jhalfHeight, jupAxis, jtransform, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawCylinder "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawCone(btScalar radius, btScalar height, int upAxis, btTransform const &transform, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jfloat jradius ; jfloat jheight ; jint jupAxis ; jobject jtransform = 0 ; jobject jcolor = 0 ; if (!swig_override[24]) { btIDebugDraw::drawCone(radius,height,upAxis,transform,color); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jradius = (jfloat) radius; jheight = (jfloat) height; jupAxis = (jint) upAxis; jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[24], swigjobj, jradius, jheight, jupAxis, jtransform, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawCone "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::drawPlane(btVector3 const &planeNormal, btScalar planeConst, btTransform const &transform, btVector3 const &color) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jplaneNormal = 0 ; jfloat jplaneConst ; jobject jtransform = 0 ; jobject jcolor = 0 ; if (!swig_override[25]) { btIDebugDraw::drawPlane(planeNormal,planeConst,transform,color); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jplaneNormal = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jplaneNormal, planeNormal); gdxPoolAutoReleaseVector3 autoRelease_jplaneNormal(jenv, "poolVector3", jplaneNormal); jplaneConst = (jfloat) planeConst; jtransform = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); gdx_setMatrix4FrombtTransform(jenv, jtransform, transform); gdxPoolAutoReleaseMatrix4 autoRelease_jtransform(jenv, "poolMatrix4", jtransform); jcolor = gdx_takePoolObjectVector3(jenv, "poolVector3"); gdx_setVector3FrombtVector3(jenv, jcolor, color); gdxPoolAutoReleaseVector3 autoRelease_jcolor(jenv, "poolVector3", jcolor); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[25], swigjobj, jplaneNormal, jplaneConst, jtransform, jcolor); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::drawPlane "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::flushLines() { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; if (!swig_override[26]) { btIDebugDraw::flushLines(); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[26], swigjobj); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btIDebugDraw::flushLines "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btIDebugDraw::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { static struct { const char *mname; const char *mdesc; jmethodID base_methid; } methods[] = { { "getDefaultColors", "()Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw$DefaultColors;", NULL }, { "setDefaultColors", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw$DefaultColors;)V", NULL }, { "drawLine", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawLine", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawSphere", "(FLcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawSphere", "(Lcom/badlogic/gdx/math/Vector3;FLcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawTriangle", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;F)V", NULL }, { "drawTriangle", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;F)V", NULL }, { "drawContactPoint", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FILcom/badlogic/gdx/math/Vector3;)V", NULL }, { "reportErrorWarning", "(Ljava/lang/String;)V", NULL }, { "draw3dText", "(Lcom/badlogic/gdx/math/Vector3;Ljava/lang/String;)V", NULL }, { "setDebugMode", "(I)V", NULL }, { "getDebugMode", "()I", NULL }, { "drawAabb", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawTransform", "(Lcom/badlogic/gdx/math/Matrix4;F)V", NULL }, { "drawArc", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFLcom/badlogic/gdx/math/Vector3;ZF)V", NULL }, { "drawArc", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFLcom/badlogic/gdx/math/Vector3;Z)V", NULL }, { "drawSpherePatch", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;FZ)V", NULL }, { "drawSpherePatch", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;F)V", NULL }, { "drawSpherePatch", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawBox", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawBox", "(Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawCapsule", "(FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawCylinder", "(FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawCone", "(FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL }, { "drawPlane", "(Lcom/badlogic/gdx/math/Vector3;FLcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V", NULL }, { "flushLines", "()V", NULL } }; static jclass baseclass = 0 ; if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { if (!baseclass) { baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw"); if (!baseclass) return; baseclass = (jclass) jenv->NewGlobalRef(baseclass); } bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); for (int i = 0; i < 27; ++i) { if (!methods[i].base_methid) { methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); if (!methods[i].base_methid) return; } swig_override[i] = false; if (derived) { jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); swig_override[i] = (methid != methods[i].base_methid); jenv->ExceptionClear(); } } } } SwigDirector_btMotionState::SwigDirector_btMotionState(JNIEnv *jenv) : btMotionState(), Swig::Director(jenv) { } SwigDirector_btMotionState::~SwigDirector_btMotionState() { swig_disconnect_director_self("swigDirectorDisconnect"); } void SwigDirector_btMotionState::getWorldTransform(btTransform &worldTrans) const { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jworldTrans = 0 ; if (!swig_override[0]) { SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btMotionState::getWorldTransform."); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jworldTrans = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); gdx_setMatrix4FrombtTransform(jenv, jworldTrans, worldTrans); gdxAutoCommitbtTransformAndReleaseMatrix4 auto_commit_worldTrans(jenv, jworldTrans, &worldTrans, "poolMatrix4"); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[27], swigjobj, jworldTrans); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btMotionState::getWorldTransform "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btMotionState::setWorldTransform(btTransform const &worldTrans) { JNIEnvWrapper swigjnienv(this) ; JNIEnv * jenv = swigjnienv.getJNIEnv() ; jobject swigjobj = (jobject) NULL ; jobject jworldTrans = 0 ; if (!swig_override[1]) { SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method btMotionState::setWorldTransform."); return; } swigjobj = swig_get_self(jenv); if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) { jworldTrans = gdx_takePoolObjectMatrix4(jenv, "poolMatrix4"); gdx_setMatrix4FrombtTransform(jenv, jworldTrans, worldTrans); gdxPoolAutoReleaseMatrix4 autoRelease_jworldTrans(jenv, "poolMatrix4", jworldTrans); jenv->CallStaticVoidMethod(Swig::jclass_LinearMathJNI, Swig::director_method_ids[28], swigjobj, jworldTrans); jthrowable swigerror = jenv->ExceptionOccurred(); if (swigerror) { jenv->ExceptionClear(); throw Swig::DirectorException(jenv, swigerror); } } else { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in btMotionState::setWorldTransform "); } if (swigjobj) jenv->DeleteLocalRef(swigjobj); } void SwigDirector_btMotionState::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) { static struct { const char *mname; const char *mdesc; jmethodID base_methid; } methods[] = { { "getWorldTransform", "(Lcom/badlogic/gdx/math/Matrix4;)V", NULL }, { "setWorldTransform", "(Lcom/badlogic/gdx/math/Matrix4;)V", NULL } }; static jclass baseclass = 0 ; if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) { if (!baseclass) { baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/linearmath/btMotionState"); if (!baseclass) return; baseclass = (jclass) jenv->NewGlobalRef(baseclass); } bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true); for (int i = 0; i < 2; ++i) { if (!methods[i].base_methid) { methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc); if (!methods[i].base_methid) return; } swig_override[i] = false; if (derived) { jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc); swig_override[i] = (methid != methods[i].base_methid); jenv->ExceptionClear(); } } } } #ifdef __cplusplus extern "C" { #endif SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGetVersion(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; int result; (void)jenv; (void)jcls; result = (int)btGetVersion(); jresult = (jint)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSqrt(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btSqrt(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btFabs(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btFabs(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btCos(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btCos(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSin(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btSin(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTan(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btTan(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAcos(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btAcos(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAsin(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btAsin(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAtan(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btAtan(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAtan2(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { jfloat jresult = 0 ; btScalar arg1 ; btScalar arg2 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; arg2 = (btScalar)jarg2; result = (btScalar)btAtan2(arg1,arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btExp(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btExp(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btLog(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btLog(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPow(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { jfloat jresult = 0 ; btScalar arg1 ; btScalar arg2 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; arg2 = (btScalar)jarg2; result = (btScalar)btPow(arg1,arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btFmod(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { jfloat jresult = 0 ; btScalar arg1 ; btScalar arg2 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; arg2 = (btScalar)jarg2; result = (btScalar)btFmod(arg1,arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAtan2Fast(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { jfloat jresult = 0 ; btScalar arg1 ; btScalar arg2 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; arg2 = (btScalar)jarg2; result = (btScalar)btAtan2Fast(arg1,arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btFuzzyZero(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jboolean jresult = 0 ; btScalar arg1 ; bool result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (bool)btFuzzyZero(arg1); jresult = (jboolean)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btEqual(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { jboolean jresult = 0 ; btScalar arg1 ; btScalar arg2 ; bool result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; arg2 = (btScalar)jarg2; result = (bool)btEqual(arg1,arg2); jresult = (jboolean)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGreaterEqual(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { jboolean jresult = 0 ; btScalar arg1 ; btScalar arg2 ; bool result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; arg2 = (btScalar)jarg2; result = (bool)btGreaterEqual(arg1,arg2); jresult = (jboolean)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIsNegative(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jint jresult = 0 ; btScalar arg1 ; int result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (int)btIsNegative(arg1); jresult = (jint)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btRadians(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btRadians(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDegrees(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btDegrees(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btFsel(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2, jfloat jarg3) { jfloat jresult = 0 ; btScalar arg1 ; btScalar arg2 ; btScalar arg3 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; arg2 = (btScalar)jarg2; arg3 = (btScalar)jarg3; result = (btScalar)btFsel(arg1,arg2,arg3); jresult = (jfloat)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btMachineIsLittleEndian(JNIEnv *jenv, jclass jcls) { jboolean jresult = 0 ; bool result; (void)jenv; (void)jcls; result = (bool)btMachineIsLittleEndian(); jresult = (jboolean)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSelect_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { jlong jresult = 0 ; unsigned int arg1 ; unsigned int arg2 ; unsigned int arg3 ; unsigned int result; (void)jenv; (void)jcls; arg1 = (unsigned int)jarg1; arg2 = (unsigned int)jarg2; arg3 = (unsigned int)jarg3; result = (unsigned int)btSelect(arg1,arg2,arg3); jresult = (jlong)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSelect_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jint jarg3) { jint jresult = 0 ; unsigned int arg1 ; int arg2 ; int arg3 ; int result; (void)jenv; (void)jcls; arg1 = (unsigned int)jarg1; arg2 = (int)jarg2; arg3 = (int)jarg3; result = (int)btSelect(arg1,arg2,arg3); jresult = (jint)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSelect_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jfloat jarg2, jfloat jarg3) { jfloat jresult = 0 ; unsigned int arg1 ; float arg2 ; float arg3 ; float result; (void)jenv; (void)jcls; arg1 = (unsigned int)jarg1; arg2 = (float)jarg2; arg3 = (float)jarg3; result = (float)btSelect(arg1,arg2,arg3); jresult = (jfloat)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapEndian_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1) { jlong jresult = 0 ; unsigned int arg1 ; unsigned int result; (void)jenv; (void)jcls; arg1 = (unsigned int)jarg1; result = (unsigned int)btSwapEndian(arg1); jresult = (jlong)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapEndian_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1) { jint jresult = 0 ; unsigned short arg1 ; unsigned short result; (void)jenv; (void)jcls; arg1 = (unsigned short)jarg1; result = (unsigned short)btSwapEndian(arg1); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapEndian_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jshort jarg1) { jint jresult = 0 ; short arg1 ; unsigned short result; (void)jenv; (void)jcls; arg1 = (short)jarg1; result = (unsigned short)btSwapEndian(arg1); jresult = (jint)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapEndianFloat(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jlong jresult = 0 ; float arg1 ; unsigned int result; (void)jenv; (void)jcls; arg1 = (float)jarg1; result = (unsigned int)btSwapEndianFloat(arg1); jresult = (jlong)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btUnswapEndianFloat(JNIEnv *jenv, jclass jcls, jlong jarg1) { jfloat jresult = 0 ; unsigned int arg1 ; float result; (void)jenv; (void)jcls; arg1 = (unsigned int)jarg1; result = (float)btUnswapEndianFloat(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapEndianDouble(JNIEnv *jenv, jclass jcls, jdouble jarg1, jobject jarg2) { double arg1 ; unsigned char *arg2 = (unsigned char *) 0 ; (void)jenv; (void)jcls; arg1 = (double)jarg1; { arg2 = (unsigned char*)jenv->GetDirectBufferAddress(jarg2); if (arg2 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } btSwapEndianDouble(arg1,arg2); } SWIGEXPORT jdouble JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btUnswapEndianDouble(JNIEnv *jenv, jclass jcls, jobject jarg1) { jdouble jresult = 0 ; unsigned char *arg1 = (unsigned char *) 0 ; double result; (void)jenv; (void)jcls; { arg1 = (unsigned char*)jenv->GetDirectBufferAddress(jarg1); if (arg1 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } result = (double)btUnswapEndianDouble((unsigned char const *)arg1); jresult = (jdouble)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btLargeDot(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jint jarg3) { jfloat jresult = 0 ; btScalar *arg1 = (btScalar *) 0 ; btScalar *arg2 = (btScalar *) 0 ; int arg3 ; btScalar result; (void)jenv; (void)jcls; { arg1 = (btScalar*)jenv->GetDirectBufferAddress(jarg1); if (arg1 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } { arg2 = (btScalar*)jenv->GetDirectBufferAddress(jarg2); if (arg2 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } arg3 = (int)jarg3; result = (btScalar)btLargeDot((float const *)arg1,(float const *)arg2,arg3); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btNormalizeAngle(JNIEnv *jenv, jclass jcls, jfloat jarg1) { jfloat jresult = 0 ; btScalar arg1 ; btScalar result; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; result = (btScalar)btNormalizeAngle(arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTypedObject(JNIEnv *jenv, jclass jcls, jint jarg1) { jlong jresult = 0 ; int arg1 ; btTypedObject *result = 0 ; (void)jenv; (void)jcls; arg1 = (int)jarg1; result = (btTypedObject *)new btTypedObject(arg1); *(btTypedObject **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTypedObject_1objectType_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { btTypedObject *arg1 = (btTypedObject *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTypedObject **)&jarg1; arg2 = (int)jarg2; if (arg1) (arg1)->m_objectType = arg2; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTypedObject_1objectType_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btTypedObject *arg1 = (btTypedObject *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTypedObject **)&jarg1; result = (int) ((arg1)->m_objectType); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btTypedObject(JNIEnv *jenv, jclass jcls, jlong jarg1) { btTypedObject *arg1 = (btTypedObject *) 0 ; (void)jenv; (void)jcls; arg1 = *(btTypedObject **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btTransform *result = 0 ; (void)jenv; (void)jcls; result = (btTransform *)new btTransform(); *(btTransform **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jlong jresult = 0 ; btQuaternion *arg1 = 0 ; btVector3 *arg2 = 0 ; btTransform *result = 0 ; (void)jenv; (void)jcls; btQuaternion local_arg1; gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btTransform *)new btTransform((btQuaternion const &)*arg1,(btVector3 const &)*arg2); *(btTransform **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jobject jarg1) { jlong jresult = 0 ; btQuaternion *arg1 = 0 ; btTransform *result = 0 ; (void)jenv; (void)jcls; btQuaternion local_arg1; gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); result = (btTransform *)new btTransform((btQuaternion const &)*arg1); *(btTransform **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jlong jresult = 0 ; btMatrix3x3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btTransform *result = 0 ; (void)jenv; (void)jcls; btMatrix3x3 local_arg1; gdx_setbtMatrix3x3FromMatrix3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitMatrix3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btTransform *)new btTransform((btMatrix3x3 const &)*arg1,(btVector3 const &)*arg2); *(btTransform **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jobject jarg1) { jlong jresult = 0 ; btMatrix3x3 *arg1 = 0 ; btTransform *result = 0 ; (void)jenv; (void)jcls; btMatrix3x3 local_arg1; gdx_setbtMatrix3x3FromMatrix3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitMatrix3 auto_commit_arg1(jenv, jarg1, &local_arg1); result = (btTransform *)new btTransform((btMatrix3x3 const &)*arg1); *(btTransform **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransform_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jobject jarg1) { jlong jresult = 0 ; btTransform *arg1 = 0 ; btTransform *result = 0 ; (void)jenv; (void)jcls; btTransform local_arg1; gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); result = (btTransform *)new btTransform((btTransform const &)*arg1); *(btTransform **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1mult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { btTransform *arg1 = (btTransform *) 0 ; btTransform *arg2 = 0 ; btTransform *arg3 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); btTransform local_arg3; gdx_setbtTransformFromMatrix4(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitMatrix4 auto_commit_arg3(jenv, jarg3, &local_arg3); (arg1)->mult((btTransform const &)*arg2,(btTransform const &)*arg3); } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1getBasis_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btTransform *arg1 = (btTransform *) 0 ; btMatrix3x3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; result = (btMatrix3x3 *) &(arg1)->getBasis(); jresult = gdx_getReturnMatrix3(jenv); gdx_setMatrix3FrombtMatrix3x3(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1getOrigin_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btTransform *arg1 = (btTransform *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; result = (btVector3 *) &(arg1)->getOrigin(); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1getRotation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btTransform *arg1 = (btTransform *) 0 ; btQuaternion result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; result = ((btTransform const *)arg1)->getRotation(); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1setFromOpenGLMatrix(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloatArray jarg2) { btTransform *arg1 = (btTransform *) 0 ; btScalar *arg2 = (btScalar *) 0 ; jfloat *jarr2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; if (!SWIG_JavaArrayInFloat(jenv, &jarr2, (float **)&arg2, jarg2)) return ; (arg1)->setFromOpenGLMatrix((btScalar const *)arg2); SWIG_JavaArrayArgoutFloat(jenv, jarr2, (float *)arg2, jarg2); delete [] arg2; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1getOpenGLMatrix(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloatArray jarg2) { btTransform *arg1 = (btTransform *) 0 ; btScalar *arg2 = (btScalar *) 0 ; jfloat *jarr2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; if (!SWIG_JavaArrayInFloat(jenv, &jarr2, (float **)&arg2, jarg2)) return ; ((btTransform const *)arg1)->getOpenGLMatrix(arg2); SWIG_JavaArrayArgoutFloat(jenv, jarr2, (float *)arg2, jarg2); delete [] arg2; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1setOrigin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btTransform *arg1 = (btTransform *) 0 ; btVector3 *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); (arg1)->setOrigin((btVector3 const &)*arg2); } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1invXform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jobject jresult = 0 ; btTransform *arg1 = (btTransform *) 0 ; btVector3 *arg2 = 0 ; btVector3 result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = ((btTransform const *)arg1)->invXform((btVector3 const &)*arg2); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1setBasis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btTransform *arg1 = (btTransform *) 0 ; btMatrix3x3 *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; btMatrix3x3 local_arg2; gdx_setbtMatrix3x3FromMatrix3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix3 auto_commit_arg2(jenv, jarg2, &local_arg2); (arg1)->setBasis((btMatrix3x3 const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1setRotation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btTransform *arg1 = (btTransform *) 0 ; btQuaternion *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); (arg1)->setRotation((btQuaternion const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1setIdentity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { btTransform *arg1 = (btTransform *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; (arg1)->setIdentity(); } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1inverse(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btTransform *arg1 = (btTransform *) 0 ; btTransform result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; result = ((btTransform const *)arg1)->inverse(); jresult = gdx_getReturnMatrix4(jenv); gdx_setMatrix4FrombtTransform(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1inverseTimes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jobject jresult = 0 ; btTransform *arg1 = (btTransform *) 0 ; btTransform *arg2 = 0 ; btTransform result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransform **)&jarg1; btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); result = ((btTransform const *)arg1)->inverseTimes((btTransform const &)*arg2); jresult = gdx_getReturnMatrix4(jenv); gdx_setMatrix4FrombtTransform(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1getIdentity(JNIEnv *jenv, jclass jcls) { jobject jresult = 0 ; btTransform *result = 0 ; (void)jenv; (void)jcls; result = (btTransform *) &btTransform::getIdentity(); jresult = gdx_getReturnMatrix4(jenv); gdx_setMatrix4FrombtTransform(jenv, jresult, result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1serialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btTransform *arg1 = (btTransform *) 0 ; btTransformFloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btTransform **)&jarg1; arg2 = *(btTransformFloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btTransformFloatData & reference is null"); return ; } ((btTransform const *)arg1)->serialize(*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1serializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btTransform *arg1 = (btTransform *) 0 ; btTransformFloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btTransform **)&jarg1; arg2 = *(btTransformFloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btTransformFloatData & reference is null"); return ; } ((btTransform const *)arg1)->serializeFloat(*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1deSerialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btTransform *arg1 = (btTransform *) 0 ; btTransformFloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btTransform **)&jarg1; arg2 = *(btTransformFloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btTransformFloatData const & reference is null"); return ; } (arg1)->deSerialize((btTransformFloatData const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1deSerializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btTransform *arg1 = (btTransform *) 0 ; btTransformDoubleData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btTransform **)&jarg1; arg2 = *(btTransformDoubleData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btTransformDoubleData const & reference is null"); return ; } (arg1)->deSerializeDouble((btTransformDoubleData const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransform_1deSerializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btTransform *arg1 = (btTransform *) 0 ; btTransformFloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btTransform **)&jarg1; arg2 = *(btTransformFloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btTransformFloatData const & reference is null"); return ; } (arg1)->deSerializeFloat((btTransformFloatData const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btTransform(JNIEnv *jenv, jclass jcls, jlong jarg1) { btTransform *arg1 = (btTransform *) 0 ; (void)jenv; (void)jcls; arg1 = *(btTransform **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformFloatData_1basis_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; btMatrix3x3FloatData arg2 ; btMatrix3x3FloatData *argp2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransformFloatData **)&jarg1; argp2 = *(btMatrix3x3FloatData **)&jarg2; if (!argp2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null btMatrix3x3FloatData"); return ; } arg2 = *argp2; if (arg1) (arg1)->m_basis = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformFloatData_1basis_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; btMatrix3x3FloatData result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransformFloatData **)&jarg1; result = ((arg1)->m_basis); *(btMatrix3x3FloatData **)&jresult = new btMatrix3x3FloatData((const btMatrix3x3FloatData &)result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformFloatData_1origin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; btVector3FloatData *arg2 = (btVector3FloatData *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btTransformFloatData **)&jarg1; arg2 = *(btVector3FloatData **)&jarg2; if (arg1) (arg1)->m_origin = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformFloatData_1origin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; btVector3FloatData *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransformFloatData **)&jarg1; result = (btVector3FloatData *)& ((arg1)->m_origin); *(btVector3FloatData **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransformFloatData(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btTransformFloatData *result = 0 ; (void)jenv; (void)jcls; result = (btTransformFloatData *)new btTransformFloatData(); *(btTransformFloatData **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btTransformFloatData(JNIEnv *jenv, jclass jcls, jlong jarg1) { btTransformFloatData *arg1 = (btTransformFloatData *) 0 ; (void)jenv; (void)jcls; arg1 = *(btTransformFloatData **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformDoubleData_1basis_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; btMatrix3x3DoubleData arg2 ; btMatrix3x3DoubleData *argp2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransformDoubleData **)&jarg1; argp2 = *(btMatrix3x3DoubleData **)&jarg2; if (!argp2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null btMatrix3x3DoubleData"); return ; } arg2 = *argp2; if (arg1) (arg1)->m_basis = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformDoubleData_1basis_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; btMatrix3x3DoubleData result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransformDoubleData **)&jarg1; result = ((arg1)->m_basis); *(btMatrix3x3DoubleData **)&jresult = new btMatrix3x3DoubleData((const btMatrix3x3DoubleData &)result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformDoubleData_1origin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; btVector3DoubleData *arg2 = (btVector3DoubleData *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btTransformDoubleData **)&jarg1; arg2 = *(btVector3DoubleData **)&jarg2; if (arg1) (arg1)->m_origin = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformDoubleData_1origin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; btVector3DoubleData *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btTransformDoubleData **)&jarg1; result = (btVector3DoubleData *)& ((arg1)->m_origin); *(btVector3DoubleData **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransformDoubleData(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btTransformDoubleData *result = 0 ; (void)jenv; (void)jcls; result = (btTransformDoubleData *)new btTransformDoubleData(); *(btTransformDoubleData **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btTransformDoubleData(JNIEnv *jenv, jclass jcls, jlong jarg1) { btTransformDoubleData *arg1 = (btTransformDoubleData *) 0 ; (void)jenv; (void)jcls; arg1 = *(btTransformDoubleData **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1floats_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloatArray jarg2) { btVector3 *arg1 = (btVector3 *) 0 ; btScalar *arg2 ; jfloat *jarr2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; if (jarg2 && jenv->GetArrayLength(jarg2) != 4) { SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); return ; } if (!SWIG_JavaArrayInFloat(jenv, &jarr2, (float **)&arg2, jarg2)) return ; { size_t ii; btScalar *b = (btScalar *) arg1->m_floats; for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((btScalar *) arg2 + ii); } SWIG_JavaArrayArgoutFloat(jenv, jarr2, (float *)arg2, jarg2); delete [] arg2; } SWIGEXPORT jfloatArray JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1floats_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloatArray jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar *)(btScalar *) ((arg1)->m_floats); jresult = SWIG_JavaArrayOutFloat(jenv, (float *)result, 4); return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; result = (btVector3 *)new btVector3(); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2, jfloat jarg3) { jlong jresult = 0 ; btScalar *arg1 = 0 ; btScalar *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar temp1 ; btScalar temp2 ; btScalar temp3 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; temp1 = (btScalar)jarg1; arg1 = &temp1; temp2 = (btScalar)jarg2; arg2 = &temp2; temp3 = (btScalar)jarg3; arg3 = &temp3; result = (btVector3 *)new btVector3((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1dot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)((btVector3 const *)arg1)->dot((btVector3 const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1length2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar)((btVector3 const *)arg1)->length2(); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1length(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar)((btVector3 const *)arg1)->length(); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1norm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar)((btVector3 const *)arg1)->norm(); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1distance2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)((btVector3 const *)arg1)->distance2((btVector3 const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1distance(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)((btVector3 const *)arg1)->distance((btVector3 const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1safeNormalize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btVector3 *) &(arg1)->safeNormalize(); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1normalize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btVector3 *) &(arg1)->normalize(); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1normalized(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = ((btVector3 const *)arg1)->normalized(); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1rotate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { jobject jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btScalar arg3 ; btVector3 result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; result = ((btVector3 const *)arg1)->rotate((btVector3 const &)*arg2,arg3); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1angle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)((btVector3 const *)arg1)->angle((btVector3 const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1absolute(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = ((btVector3 const *)arg1)->absolute(); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1cross(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jobject jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btVector3 result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = ((btVector3 const *)arg1)->cross((btVector3 const &)*arg2); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1triple(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); result = (btScalar)((btVector3 const *)arg1)->triple((btVector3 const &)*arg2,(btVector3 const &)*arg3); jresult = (jfloat)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1minAxis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (int)((btVector3 const *)arg1)->minAxis(); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1maxAxis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (int)((btVector3 const *)arg1)->maxAxis(); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1furthestAxis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (int)((btVector3 const *)arg1)->furthestAxis(); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1closestAxis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (int)((btVector3 const *)arg1)->closestAxis(); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setInterpolate3(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jfloat jarg4) { btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btScalar arg4 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); arg4 = (btScalar)jarg4; (arg1)->setInterpolate3((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4); } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1lerp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { jobject jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar temp3 ; btVector3 result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); temp3 = (btScalar)jarg3; arg3 = &temp3; result = ((btVector3 const *)arg1)->lerp((btVector3 const &)*arg2,(btScalar const &)*arg3); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1getX(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar *) &((btVector3 const *)arg1)->getX(); jresult = (jfloat)*result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1getY(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar *) &((btVector3 const *)arg1)->getY(); jresult = (jfloat)*result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1getZ(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar *) &((btVector3 const *)arg1)->getZ(); jresult = (jfloat)*result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setX(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { btVector3 *arg1 = (btVector3 *) 0 ; btScalar arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; arg2 = (btScalar)jarg2; (arg1)->setX(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setY(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { btVector3 *arg1 = (btVector3 *) 0 ; btScalar arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; arg2 = (btScalar)jarg2; (arg1)->setY(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setZ(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { btVector3 *arg1 = (btVector3 *) 0 ; btScalar arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; arg2 = (btScalar)jarg2; (arg1)->setZ(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setW(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { btVector3 *arg1 = (btVector3 *) 0 ; btScalar arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; arg2 = (btScalar)jarg2; (arg1)->setW(arg2); } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1x(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar *) &((btVector3 const *)arg1)->x(); jresult = (jfloat)*result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1y(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar *) &((btVector3 const *)arg1)->y(); jresult = (jfloat)*result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1z(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar *) &((btVector3 const *)arg1)->z(); jresult = (jfloat)*result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1w(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btScalar *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (btScalar *) &((btVector3 const *)arg1)->w(); jresult = (jfloat)*result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setMax(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); (arg1)->setMax((btVector3 const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setMin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); (arg1)->setMin((btVector3 const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jfloat jarg4) { btVector3 *arg1 = (btVector3 *) 0 ; btScalar *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar *arg4 = 0 ; btScalar temp2 ; btScalar temp3 ; btScalar temp4 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; temp2 = (btScalar)jarg2; arg2 = &temp2; temp3 = (btScalar)jarg3; arg3 = &temp3; temp4 = (btScalar)jarg4; arg4 = &temp4; (arg1)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1getSkewSymmetricMatrix(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) { btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; btVector3 *arg3 = (btVector3 *) 0 ; btVector3 *arg4 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; (void)jarg3_; (void)jarg4_; arg1 = *(btVector3 **)&jarg1; arg2 = *(btVector3 **)&jarg2; arg3 = *(btVector3 **)&jarg3; arg4 = *(btVector3 **)&jarg4; ((btVector3 const *)arg1)->getSkewSymmetricMatrix(arg2,arg3,arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1setZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { btVector3 *arg1 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; (arg1)->setZero(); } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1isZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jboolean jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (bool)((btVector3 const *)arg1)->isZero(); jresult = (jboolean)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1fuzzyZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jboolean jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; result = (bool)((btVector3 const *)arg1)->fuzzyZero(); jresult = (jboolean)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1serialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btVector3 *arg1 = (btVector3 *) 0 ; btVector3FloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btVector3 **)&jarg1; arg2 = *(btVector3FloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3FloatData & reference is null"); return ; } ((btVector3 const *)arg1)->serialize(*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1deSerialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btVector3 *arg1 = (btVector3 *) 0 ; btVector3FloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btVector3 **)&jarg1; arg2 = *(btVector3FloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3FloatData const & reference is null"); return ; } (arg1)->deSerialize((btVector3FloatData const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1serializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btVector3 *arg1 = (btVector3 *) 0 ; btVector3FloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btVector3 **)&jarg1; arg2 = *(btVector3FloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3FloatData & reference is null"); return ; } ((btVector3 const *)arg1)->serializeFloat(*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1deSerializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btVector3 *arg1 = (btVector3 *) 0 ; btVector3FloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btVector3 **)&jarg1; arg2 = *(btVector3FloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3FloatData const & reference is null"); return ; } (arg1)->deSerializeFloat((btVector3FloatData const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1serializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btVector3 *arg1 = (btVector3 *) 0 ; btVector3DoubleData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btVector3 **)&jarg1; arg2 = *(btVector3DoubleData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3DoubleData & reference is null"); return ; } ((btVector3 const *)arg1)->serializeDouble(*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1deSerializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btVector3 *arg1 = (btVector3 *) 0 ; btVector3DoubleData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btVector3 **)&jarg1; arg2 = *(btVector3DoubleData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btVector3DoubleData const & reference is null"); return ; } (arg1)->deSerializeDouble((btVector3DoubleData const &)*arg2); } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1maxDot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jlong jarg4) { jint jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; long arg3 ; btScalar *arg4 = 0 ; long result; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btVector3 **)&jarg1; arg2 = *(btVector3 **)&jarg2; arg3 = (long)jarg3; arg4 = *(btScalar **)&jarg4; if (!arg4) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); return 0; } result = (long)((btVector3 const *)arg1)->maxDot((btVector3 const *)arg2,arg3,*arg4); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1minDot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jlong jarg4) { jint jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; long arg3 ; btScalar *arg4 = 0 ; long result; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btVector3 **)&jarg1; arg2 = *(btVector3 **)&jarg2; arg3 = (long)jarg3; arg4 = *(btScalar **)&jarg4; if (!arg4) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); return 0; } result = (long)((btVector3 const *)arg1)->minDot((btVector3 const *)arg2,arg3,*arg4); jresult = (jint)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3_1dot3(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { jobject jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btVector3 result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); result = ((btVector3 const *)arg1)->dot3((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector3(JNIEnv *jenv, jclass jcls, jlong jarg1) { btVector3 *arg1 = (btVector3 *) 0 ; (void)jenv; (void)jcls; arg1 = *(btVector3 **)&jarg1; delete arg1; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDot(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jfloat jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)btDot((btVector3 const &)*arg1,(btVector3 const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDistance2(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jfloat jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)btDistance2((btVector3 const &)*arg1,(btVector3 const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDistance(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jfloat jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)btDistance((btVector3 const &)*arg1,(btVector3 const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAngle_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jfloat jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)btAngle((btVector3 const &)*arg1,(btVector3 const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btCross(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jobject jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btVector3 result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = btCross((btVector3 const &)*arg1,(btVector3 const &)*arg2); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTriple(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3) { jfloat jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btScalar result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); result = (btScalar)btTriple((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); jresult = (jfloat)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_lerp(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jfloat jarg3) { jobject jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar temp3 ; btVector3 result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); temp3 = (btScalar)jarg3; arg3 = &temp3; result = lerp((btVector3 const &)*arg1,(btVector3 const &)*arg2,(float const &)*arg3); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector4_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btVector4 *result = 0 ; (void)jenv; (void)jcls; result = (btVector4 *)new btVector4(); *(btVector4 **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector4_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2, jfloat jarg3, jfloat jarg4) { jlong jresult = 0 ; btScalar *arg1 = 0 ; btScalar *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar *arg4 = 0 ; btScalar temp1 ; btScalar temp2 ; btScalar temp3 ; btScalar temp4 ; btVector4 *result = 0 ; (void)jenv; (void)jcls; temp1 = (btScalar)jarg1; arg1 = &temp1; temp2 = (btScalar)jarg2; arg2 = &temp2; temp3 = (btScalar)jarg3; arg3 = &temp3; temp4 = (btScalar)jarg4; arg4 = &temp4; result = (btVector4 *)new btVector4((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); *(btVector4 **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1absolute4(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btVector4 *arg1 = (btVector4 *) 0 ; btVector4 result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector4 **)&jarg1; result = ((btVector4 const *)arg1)->absolute4(); *(btVector4 **)&jresult = new btVector4((const btVector4 &)result); return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1getW(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btVector4 *arg1 = (btVector4 *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector4 **)&jarg1; result = (btScalar)((btVector4 const *)arg1)->getW(); jresult = (jfloat)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1maxAxis4(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btVector4 *arg1 = (btVector4 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector4 **)&jarg1; result = (int)((btVector4 const *)arg1)->maxAxis4(); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1minAxis4(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btVector4 *arg1 = (btVector4 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector4 **)&jarg1; result = (int)((btVector4 const *)arg1)->minAxis4(); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1closestAxis4(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btVector4 *arg1 = (btVector4 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector4 **)&jarg1; result = (int)((btVector4 const *)arg1)->closestAxis4(); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jfloat jarg4, jfloat jarg5) { btVector4 *arg1 = (btVector4 *) 0 ; btScalar *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar *arg4 = 0 ; btScalar *arg5 = 0 ; btScalar temp2 ; btScalar temp3 ; btScalar temp4 ; btScalar temp5 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector4 **)&jarg1; temp2 = (btScalar)jarg2; arg2 = &temp2; temp3 = (btScalar)jarg3; arg3 = &temp3; temp4 = (btScalar)jarg4; arg4 = &temp4; temp5 = (btScalar)jarg5; arg5 = &temp5; (arg1)->setValue((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4,(btScalar const &)*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector4(JNIEnv *jenv, jclass jcls, jlong jarg1) { btVector4 *arg1 = (btVector4 *) 0 ; (void)jenv; (void)jcls; arg1 = *(btVector4 **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapScalarEndian(JNIEnv *jenv, jclass jcls, jfloat jarg1, jlong jarg2) { btScalar *arg1 = 0 ; btScalar *arg2 = 0 ; btScalar temp1 ; (void)jenv; (void)jcls; temp1 = (btScalar)jarg1; arg1 = &temp1; arg2 = *(btScalar **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); return ; } btSwapScalarEndian((float const &)*arg1,*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btSwapVector3Endian(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btSwapVector3Endian((btVector3 const &)*arg1,*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btUnSwapVector3Endian(JNIEnv *jenv, jclass jcls, jobject jarg1) { btVector3 *arg1 = 0 ; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btUnSwapVector3Endian(*arg1); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3FloatData_1floats_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloatArray jarg2) { btVector3FloatData *arg1 = (btVector3FloatData *) 0 ; float *arg2 ; jfloat *jarr2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3FloatData **)&jarg1; if (jarg2 && jenv->GetArrayLength(jarg2) != 4) { SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); return ; } if (!SWIG_JavaArrayInFloat(jenv, &jarr2, (float **)&arg2, jarg2)) return ; { size_t ii; float *b = (float *) arg1->m_floats; for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); } SWIG_JavaArrayArgoutFloat(jenv, jarr2, (float *)arg2, jarg2); delete [] arg2; } SWIGEXPORT jfloatArray JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3FloatData_1floats_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloatArray jresult = 0 ; btVector3FloatData *arg1 = (btVector3FloatData *) 0 ; float *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3FloatData **)&jarg1; result = (float *)(float *) ((arg1)->m_floats); jresult = SWIG_JavaArrayOutFloat(jenv, (float *)result, 4); return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3FloatData(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btVector3FloatData *result = 0 ; (void)jenv; (void)jcls; result = (btVector3FloatData *)new btVector3FloatData(); *(btVector3FloatData **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector3FloatData(JNIEnv *jenv, jclass jcls, jlong jarg1) { btVector3FloatData *arg1 = (btVector3FloatData *) 0 ; (void)jenv; (void)jcls; arg1 = *(btVector3FloatData **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3DoubleData_1floats_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2) { btVector3DoubleData *arg1 = (btVector3DoubleData *) 0 ; double *arg2 ; jdouble *jarr2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3DoubleData **)&jarg1; if (jarg2 && jenv->GetArrayLength(jarg2) != 4) { SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); return ; } if (!SWIG_JavaArrayInDouble(jenv, &jarr2, (double **)&arg2, jarg2)) return ; { size_t ii; double *b = (double *) arg1->m_floats; for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); } SWIG_JavaArrayArgoutDouble(jenv, jarr2, (double *)arg2, jarg2); delete [] arg2; } SWIGEXPORT jdoubleArray JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3DoubleData_1floats_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jdoubleArray jresult = 0 ; btVector3DoubleData *arg1 = (btVector3DoubleData *) 0 ; double *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3DoubleData **)&jarg1; result = (double *)(double *) ((arg1)->m_floats); jresult = SWIG_JavaArrayOutDouble(jenv, (double *)result, 4); return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3DoubleData(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btVector3DoubleData *result = 0 ; (void)jenv; (void)jcls; result = (btVector3DoubleData *)new btVector3DoubleData(); *(btVector3DoubleData **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector3DoubleData(JNIEnv *jenv, jclass jcls, jlong jarg1) { btVector3DoubleData *arg1 = (btVector3DoubleData *) 0 ; (void)jenv; (void)jcls; arg1 = *(btVector3DoubleData **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternion_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btQuaternion *result = 0 ; (void)jenv; (void)jcls; result = (btQuaternion *)new btQuaternion(); *(btQuaternion **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternion_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2, jfloat jarg3, jfloat jarg4) { jlong jresult = 0 ; btScalar *arg1 = 0 ; btScalar *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar *arg4 = 0 ; btScalar temp1 ; btScalar temp2 ; btScalar temp3 ; btScalar temp4 ; btQuaternion *result = 0 ; (void)jenv; (void)jcls; temp1 = (btScalar)jarg1; arg1 = &temp1; temp2 = (btScalar)jarg2; arg2 = &temp2; temp3 = (btScalar)jarg3; arg3 = &temp3; temp4 = (btScalar)jarg4; arg4 = &temp4; result = (btQuaternion *)new btQuaternion((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); *(btQuaternion **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternion_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jobject jarg1, jfloat jarg2) { jlong jresult = 0 ; btVector3 *arg1 = 0 ; btScalar *arg2 = 0 ; btScalar temp2 ; btQuaternion *result = 0 ; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); temp2 = (btScalar)jarg2; arg2 = &temp2; result = (btQuaternion *)new btQuaternion((btVector3 const &)*arg1,(btScalar const &)*arg2); *(btQuaternion **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternion_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2, jfloat jarg3) { jlong jresult = 0 ; btScalar *arg1 = 0 ; btScalar *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar temp1 ; btScalar temp2 ; btScalar temp3 ; btQuaternion *result = 0 ; (void)jenv; (void)jcls; temp1 = (btScalar)jarg1; arg1 = &temp1; temp2 = (btScalar)jarg2; arg2 = &temp2; temp3 = (btScalar)jarg3; arg3 = &temp3; result = (btQuaternion *)new btQuaternion((btScalar const &)*arg1,(btScalar const &)*arg2,(btScalar const &)*arg3); *(btQuaternion **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1setRotation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { btQuaternion *arg1 = (btQuaternion *) 0 ; btVector3 *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar temp3 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); temp3 = (btScalar)jarg3; arg3 = &temp3; (arg1)->setRotation((btVector3 const &)*arg2,(btScalar const &)*arg3); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1setEuler(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jfloat jarg4) { btQuaternion *arg1 = (btQuaternion *) 0 ; btScalar *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar *arg4 = 0 ; btScalar temp2 ; btScalar temp3 ; btScalar temp4 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; temp2 = (btScalar)jarg2; arg2 = &temp2; temp3 = (btScalar)jarg3; arg3 = &temp3; temp4 = (btScalar)jarg4; arg4 = &temp4; (arg1)->setEuler((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1setEulerZYX(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jfloat jarg4) { btQuaternion *arg1 = (btQuaternion *) 0 ; btScalar *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar *arg4 = 0 ; btScalar temp2 ; btScalar temp3 ; btScalar temp4 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; temp2 = (btScalar)jarg2; arg2 = &temp2; temp3 = (btScalar)jarg3; arg3 = &temp3; temp4 = (btScalar)jarg4; arg4 = &temp4; (arg1)->setEulerZYX((btScalar const &)*arg2,(btScalar const &)*arg3,(btScalar const &)*arg4); } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1dot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jfloat jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternion *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)((btQuaternion const *)arg1)->dot((btQuaternion const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1length2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; result = (btScalar)((btQuaternion const *)arg1)->length2(); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1length(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; result = (btScalar)((btQuaternion const *)arg1)->length(); jresult = (jfloat)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1normalize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternion *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; result = (btQuaternion *) &(arg1)->normalize(); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1normalized(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternion result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; result = ((btQuaternion const *)arg1)->normalized(); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1angle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jfloat jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternion *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)((btQuaternion const *)arg1)->angle((btQuaternion const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1angleShortestPath(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jfloat jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternion *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)((btQuaternion const *)arg1)->angleShortestPath((btQuaternion const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1getAngle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; result = (btScalar)((btQuaternion const *)arg1)->getAngle(); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1getAngleShortestPath(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; result = (btScalar)((btQuaternion const *)arg1)->getAngleShortestPath(); jresult = (jfloat)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1getAxis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btVector3 result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; result = ((btQuaternion const *)arg1)->getAxis(); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1inverse(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternion result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; result = ((btQuaternion const *)arg1)->inverse(); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1farthest(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jobject jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternion *arg2 = 0 ; btQuaternion result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); result = ((btQuaternion const *)arg1)->farthest((btQuaternion const &)*arg2); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1nearest(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jobject jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternion *arg2 = 0 ; btQuaternion result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); result = ((btQuaternion const *)arg1)->nearest((btQuaternion const &)*arg2); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1slerp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { jobject jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternion *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar temp3 ; btQuaternion result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); temp3 = (btScalar)jarg3; arg3 = &temp3; result = ((btQuaternion const *)arg1)->slerp((btQuaternion const &)*arg2,(btScalar const &)*arg3); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1getIdentity(JNIEnv *jenv, jclass jcls) { jobject jresult = 0 ; btQuaternion *result = 0 ; (void)jenv; (void)jcls; result = (btQuaternion *) &btQuaternion::getIdentity(); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1getW(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btQuaternion *arg1 = (btQuaternion *) 0 ; btScalar *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternion **)&jarg1; result = (btScalar *) &((btQuaternion const *)arg1)->getW(); jresult = (jfloat)*result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1serialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternionFloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btQuaternion **)&jarg1; arg2 = *(btQuaternionFloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionFloatData & reference is null"); return ; } ((btQuaternion const *)arg1)->serialize(*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1deSerialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternionFloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btQuaternion **)&jarg1; arg2 = *(btQuaternionFloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionFloatData const & reference is null"); return ; } (arg1)->deSerialize((btQuaternionFloatData const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1serializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternionFloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btQuaternion **)&jarg1; arg2 = *(btQuaternionFloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionFloatData & reference is null"); return ; } ((btQuaternion const *)arg1)->serializeFloat(*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1deSerializeFloat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternionFloatData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btQuaternion **)&jarg1; arg2 = *(btQuaternionFloatData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionFloatData const & reference is null"); return ; } (arg1)->deSerializeFloat((btQuaternionFloatData const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1serializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternionDoubleData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btQuaternion **)&jarg1; arg2 = *(btQuaternionDoubleData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionDoubleData & reference is null"); return ; } ((btQuaternion const *)arg1)->serializeDouble(*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternion_1deSerializeDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btQuaternion *arg1 = (btQuaternion *) 0 ; btQuaternionDoubleData *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btQuaternion **)&jarg1; arg2 = *(btQuaternionDoubleData **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btQuaternionDoubleData const & reference is null"); return ; } (arg1)->deSerializeDouble((btQuaternionDoubleData const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btQuaternion(JNIEnv *jenv, jclass jcls, jlong jarg1) { btQuaternion *arg1 = (btQuaternion *) 0 ; (void)jenv; (void)jcls; arg1 = *(btQuaternion **)&jarg1; delete arg1; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_dot(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jfloat jresult = 0 ; btQuaternion *arg1 = 0 ; btQuaternion *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; btQuaternion local_arg1; gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)dot((btQuaternion const &)*arg1,(btQuaternion const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_length(JNIEnv *jenv, jclass jcls, jobject jarg1) { jfloat jresult = 0 ; btQuaternion *arg1 = 0 ; btScalar result; (void)jenv; (void)jcls; btQuaternion local_arg1; gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); result = (btScalar)length((btQuaternion const &)*arg1); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAngle_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jfloat jresult = 0 ; btQuaternion *arg1 = 0 ; btQuaternion *arg2 = 0 ; btScalar result; (void)jenv; (void)jcls; btQuaternion local_arg1; gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btScalar)btAngle((btQuaternion const &)*arg1,(btQuaternion const &)*arg2); jresult = (jfloat)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_inverse(JNIEnv *jenv, jclass jcls, jobject jarg1) { jobject jresult = 0 ; btQuaternion *arg1 = 0 ; btQuaternion result; (void)jenv; (void)jcls; btQuaternion local_arg1; gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); result = inverse((btQuaternion const &)*arg1); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_slerp(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jfloat jarg3) { jobject jresult = 0 ; btQuaternion *arg1 = 0 ; btQuaternion *arg2 = 0 ; btScalar *arg3 = 0 ; btScalar temp3 ; btQuaternion result; (void)jenv; (void)jcls; btQuaternion local_arg1; gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); temp3 = (btScalar)jarg3; arg3 = &temp3; result = slerp((btQuaternion const &)*arg1,(btQuaternion const &)*arg2,(float const &)*arg3); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_quatRotate(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jobject jresult = 0 ; btQuaternion *arg1 = 0 ; btVector3 *arg2 = 0 ; btVector3 result; (void)jenv; (void)jcls; btQuaternion local_arg1; gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = quatRotate((btQuaternion const &)*arg1,(btVector3 const &)*arg2); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_shortestArcQuat(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jobject jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btQuaternion result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = shortestArcQuat((btVector3 const &)*arg1,(btVector3 const &)*arg2); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_shortestArcQuatNormalize2(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jobject jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btQuaternion result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = shortestArcQuatNormalize2(*arg1,*arg2); jresult = gdx_getReturnQuaternion(jenv); gdx_setQuaternionFrombtQuaternion(jenv, jresult, result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternionFloatData_1floats_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloatArray jarg2) { btQuaternionFloatData *arg1 = (btQuaternionFloatData *) 0 ; float *arg2 ; jfloat *jarr2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternionFloatData **)&jarg1; if (jarg2 && jenv->GetArrayLength(jarg2) != 4) { SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); return ; } if (!SWIG_JavaArrayInFloat(jenv, &jarr2, (float **)&arg2, jarg2)) return ; { size_t ii; float *b = (float *) arg1->m_floats; for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((float *) arg2 + ii); } SWIG_JavaArrayArgoutFloat(jenv, jarr2, (float *)arg2, jarg2); delete [] arg2; } SWIGEXPORT jfloatArray JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternionFloatData_1floats_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloatArray jresult = 0 ; btQuaternionFloatData *arg1 = (btQuaternionFloatData *) 0 ; float *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternionFloatData **)&jarg1; result = (float *)(float *) ((arg1)->m_floats); jresult = SWIG_JavaArrayOutFloat(jenv, (float *)result, 4); return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternionFloatData(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btQuaternionFloatData *result = 0 ; (void)jenv; (void)jcls; result = (btQuaternionFloatData *)new btQuaternionFloatData(); *(btQuaternionFloatData **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btQuaternionFloatData(JNIEnv *jenv, jclass jcls, jlong jarg1) { btQuaternionFloatData *arg1 = (btQuaternionFloatData *) 0 ; (void)jenv; (void)jcls; arg1 = *(btQuaternionFloatData **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternionDoubleData_1floats_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2) { btQuaternionDoubleData *arg1 = (btQuaternionDoubleData *) 0 ; double *arg2 ; jdouble *jarr2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternionDoubleData **)&jarg1; if (jarg2 && jenv->GetArrayLength(jarg2) != 4) { SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); return ; } if (!SWIG_JavaArrayInDouble(jenv, &jarr2, (double **)&arg2, jarg2)) return ; { size_t ii; double *b = (double *) arg1->m_floats; for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((double *) arg2 + ii); } SWIG_JavaArrayArgoutDouble(jenv, jarr2, (double *)arg2, jarg2); delete [] arg2; } SWIGEXPORT jdoubleArray JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btQuaternionDoubleData_1floats_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jdoubleArray jresult = 0 ; btQuaternionDoubleData *arg1 = (btQuaternionDoubleData *) 0 ; double *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btQuaternionDoubleData **)&jarg1; result = (double *)(double *) ((arg1)->m_floats); jresult = SWIG_JavaArrayOutDouble(jenv, (double *)result, 4); return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btQuaternionDoubleData(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btQuaternionDoubleData *result = 0 ; (void)jenv; (void)jcls; result = (btQuaternionDoubleData *)new btQuaternionDoubleData(); *(btQuaternionDoubleData **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btQuaternionDoubleData(JNIEnv *jenv, jclass jcls, jlong jarg1) { btQuaternionDoubleData *arg1 = (btQuaternionDoubleData *) 0 ; (void)jenv; (void)jcls; arg1 = *(btQuaternionDoubleData **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_AabbExpand(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jobject jarg4) { btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); AabbExpand(*arg1,*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_TestPointAgainstAabb2(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3) { jboolean jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; bool result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); result = (bool)TestPointAgainstAabb2((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); jresult = (jboolean)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_TestAabbAgainstAabb2(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jobject jarg4) { jboolean jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; bool result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); result = (bool)TestAabbAgainstAabb2((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); jresult = (jboolean)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_TestTriangleAgainstAabb2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { jboolean jresult = 0 ; btVector3 *arg1 = (btVector3 *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btVector3 **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); result = (bool)TestTriangleAgainstAabb2((btVector3 const *)arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3); jresult = (jboolean)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btOutcode(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jint jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; int result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (int)btOutcode((btVector3 const &)*arg1,(btVector3 const &)*arg2); jresult = (jint)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btRayAabb2(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlongArray jarg3, jlong jarg4, jobject jarg4_, jlong jarg5, jfloat jarg6, jfloat jarg7) { jboolean jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; unsigned int *arg3 ; btVector3 *arg4 ; btScalar *arg5 = 0 ; btScalar arg6 ; btScalar arg7 ; jlong *jarr3 ; bool result; (void)jenv; (void)jcls; (void)jarg4_; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); if (jarg3 && jenv->GetArrayLength(jarg3) != 3) { SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size"); return 0; } if (!SWIG_JavaArrayInUint(jenv, &jarr3, (unsigned int **)&arg3, jarg3)) return 0; arg4 = *(btVector3 **)&jarg4; arg5 = *(btScalar **)&jarg5; if (!arg5) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); return 0; } arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; result = (bool)btRayAabb2((btVector3 const &)*arg1,(btVector3 const &)*arg2,(unsigned int const (*))arg3,(btVector3 const (*))arg4,*arg5,arg6,arg7); jresult = (jboolean)result; SWIG_JavaArrayArgoutUint(jenv, jarr3, (unsigned int *)arg3, jarg3); delete [] arg3; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btRayAabb(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jobject jarg4, jlong jarg5, jobject jarg6) { jboolean jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar *arg5 = 0 ; btVector3 *arg6 = 0 ; bool result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = *(btScalar **)&jarg5; if (!arg5) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); return 0; } btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); result = (bool)btRayAabb((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,*arg5,*arg6); jresult = (jboolean)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformAabb_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jfloat jarg2, jobject jarg3, jobject jarg4, jobject jarg5) { btVector3 *arg1 = 0 ; btScalar arg2 ; btTransform *arg3 = 0 ; btVector3 *arg4 = 0 ; btVector3 *arg5 = 0 ; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); arg2 = (btScalar)jarg2; btTransform local_arg3; gdx_setbtTransformFromMatrix4(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitMatrix4 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); btTransformAabb((btVector3 const &)*arg1,arg2,(btTransform const &)*arg3,*arg4,*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformAabb_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jfloat jarg3, jobject jarg4, jobject jarg5, jobject jarg6) { btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btScalar arg3 ; btTransform *arg4 = 0 ; btVector3 *arg5 = 0 ; btVector3 *arg6 = 0 ; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; btTransform local_arg4; gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); btTransformAabb((btVector3 const &)*arg1,(btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,*arg5,*arg6); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_testQuantizedAabbAgainstQuantizedAabb(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jobject jarg4) { jlong jresult = 0 ; unsigned short *arg1 = (unsigned short *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; unsigned short *arg3 = (unsigned short *) 0 ; unsigned short *arg4 = (unsigned short *) 0 ; unsigned int result; (void)jenv; (void)jcls; { arg1 = (unsigned short*)jenv->GetDirectBufferAddress(jarg1); if (arg1 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } { arg2 = (unsigned short*)jenv->GetDirectBufferAddress(jarg2); if (arg2 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } { arg3 = (unsigned short*)jenv->GetDirectBufferAddress(jarg3); if (arg3 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } { arg4 = (unsigned short*)jenv->GetDirectBufferAddress(jarg4); if (arg4 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } result = (unsigned int)testQuantizedAabbAgainstQuantizedAabb((unsigned short const *)arg1,(unsigned short const *)arg2,(unsigned short const *)arg3,(unsigned short const *)arg4); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1activeObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->m_activeObject = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1activeObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; result = (btVector3 *)& ((arg1)->m_activeObject); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1deactivatedObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->m_deactivatedObject = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1deactivatedObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; result = (btVector3 *)& ((arg1)->m_deactivatedObject); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1wantsDeactivationObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->m_wantsDeactivationObject = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1wantsDeactivationObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; result = (btVector3 *)& ((arg1)->m_wantsDeactivationObject); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1disabledDeactivationObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->m_disabledDeactivationObject = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1disabledDeactivationObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; result = (btVector3 *)& ((arg1)->m_disabledDeactivationObject); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1disabledSimulationObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->m_disabledSimulationObject = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1disabledSimulationObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; result = (btVector3 *)& ((arg1)->m_disabledSimulationObject); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1aabb_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->m_aabb = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1aabb_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; result = (btVector3 *)& ((arg1)->m_aabb); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1contactPoint_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->m_contactPoint = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1DefaultColors_1contactPoint_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; result = (btVector3 *)& ((arg1)->m_contactPoint); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btIDebugDraw_1DefaultColors(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btIDebugDraw::DefaultColors *result = 0 ; (void)jenv; (void)jcls; result = (btIDebugDraw::DefaultColors *)new btIDebugDraw::DefaultColors(); *(btIDebugDraw::DefaultColors **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btIDebugDraw_1DefaultColors(JNIEnv *jenv, jclass jcls, jlong jarg1) { btIDebugDraw::DefaultColors *arg1 = (btIDebugDraw::DefaultColors *) 0 ; (void)jenv; (void)jcls; arg1 = *(btIDebugDraw::DefaultColors **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; (void)jenv; (void)jcls; arg1 = *(btIDebugDraw **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1getDefaultColors(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btIDebugDraw::DefaultColors result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; result = ((btIDebugDraw const *)arg1)->getDefaultColors(); *(btIDebugDraw::DefaultColors **)&jresult = new btIDebugDraw::DefaultColors((const btIDebugDraw::DefaultColors &)result); return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1getDefaultColorsSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btIDebugDraw::DefaultColors result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; result = ((btIDebugDraw const *)arg1)->btIDebugDraw::getDefaultColors(); *(btIDebugDraw::DefaultColors **)&jresult = new btIDebugDraw::DefaultColors((const btIDebugDraw::DefaultColors &)result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1setDefaultColors(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btIDebugDraw::DefaultColors *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = *(btIDebugDraw::DefaultColors **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btIDebugDraw::DefaultColors const & reference is null"); return ; } (arg1)->setDefaultColors((btIDebugDraw::DefaultColors const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1setDefaultColorsSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btIDebugDraw::DefaultColors *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = *(btIDebugDraw::DefaultColors **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btIDebugDraw::DefaultColors const & reference is null"); return ; } (arg1)->btIDebugDraw::setDefaultColors((btIDebugDraw::DefaultColors const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawLine_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); (arg1)->drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawLine_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btVector3 *arg5 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); (arg1)->drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawLineSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btVector3 *arg5 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); (arg1)->btIDebugDraw::drawLine((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSphere_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jobject jarg3, jobject jarg4) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btScalar arg2 ; btTransform *arg3 = 0 ; btVector3 *arg4 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = (btScalar)jarg2; btTransform local_arg3; gdx_setbtTransformFromMatrix4(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitMatrix4 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); (arg1)->drawSphere(arg2,(btTransform const &)*arg3,(btVector3 const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSphereSwigExplicitbtIDebugDraw_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jobject jarg3, jobject jarg4) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btScalar arg2 ; btTransform *arg3 = 0 ; btVector3 *arg4 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = (btScalar)jarg2; btTransform local_arg3; gdx_setbtTransformFromMatrix4(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitMatrix4 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); (arg1)->btIDebugDraw::drawSphere(arg2,(btTransform const &)*arg3,(btVector3 const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSphere_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3, jobject jarg4) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btScalar arg3 ; btVector3 *arg4 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); (arg1)->drawSphere((btVector3 const &)*arg2,arg3,(btVector3 const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSphereSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3, jobject jarg4) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btScalar arg3 ; btVector3 *arg4 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); (arg1)->btIDebugDraw::drawSphere((btVector3 const &)*arg2,arg3,(btVector3 const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTriangle_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5, jobject jarg6, jobject jarg7, jobject jarg8, jfloat jarg9) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btVector3 *arg5 = 0 ; btVector3 *arg6 = 0 ; btVector3 *arg7 = 0 ; btVector3 *arg8 = 0 ; btScalar arg9 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); btVector3 local_arg7; gdx_setbtVector3FromVector3(jenv, local_arg7, jarg7); arg7 = &local_arg7; gdxAutoCommitVector3 auto_commit_arg7(jenv, jarg7, &local_arg7); btVector3 local_arg8; gdx_setbtVector3FromVector3(jenv, local_arg8, jarg8); arg8 = &local_arg8; gdxAutoCommitVector3 auto_commit_arg8(jenv, jarg8, &local_arg8); arg9 = (btScalar)jarg9; (arg1)->drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8,arg9); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTriangleSwigExplicitbtIDebugDraw_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5, jobject jarg6, jobject jarg7, jobject jarg8, jfloat jarg9) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btVector3 *arg5 = 0 ; btVector3 *arg6 = 0 ; btVector3 *arg7 = 0 ; btVector3 *arg8 = 0 ; btScalar arg9 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); btVector3 local_arg7; gdx_setbtVector3FromVector3(jenv, local_arg7, jarg7); arg7 = &local_arg7; gdxAutoCommitVector3 auto_commit_arg7(jenv, jarg7, &local_arg7); btVector3 local_arg8; gdx_setbtVector3FromVector3(jenv, local_arg8, jarg8); arg8 = &local_arg8; gdxAutoCommitVector3 auto_commit_arg8(jenv, jarg8, &local_arg8); arg9 = (btScalar)jarg9; (arg1)->btIDebugDraw::drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,(btVector3 const &)*arg6,(btVector3 const &)*arg7,(btVector3 const &)*arg8,arg9); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTriangle_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5, jfloat jarg6) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btVector3 *arg5 = 0 ; btScalar arg6 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); arg6 = (btScalar)jarg6; (arg1)->drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,arg6); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTriangleSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5, jfloat jarg6) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btVector3 *arg5 = 0 ; btScalar arg6 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); arg6 = (btScalar)jarg6; (arg1)->btIDebugDraw::drawTriangle((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,(btVector3 const &)*arg5,arg6); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawContactPoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jfloat jarg4, jint jarg5, jobject jarg6) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btScalar arg4 ; int arg5 ; btVector3 *arg6 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); arg4 = (btScalar)jarg4; arg5 = (int)jarg5; btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); (arg1)->drawContactPoint((btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,arg5,(btVector3 const &)*arg6); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1reportErrorWarning(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; char *arg2 = (char *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = 0; if (jarg2) { arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); if (!arg2) return ; } (arg1)->reportErrorWarning((char const *)arg2); if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1draw3dText(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jstring jarg3) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; char *arg3 = (char *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = 0; if (jarg3) { arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); if (!arg3) return ; } (arg1)->draw3dText((btVector3 const &)*arg2,(char const *)arg3); if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1setDebugMode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = (int)jarg2; (arg1)->setDebugMode(arg2); } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1getDebugMode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; result = (int)((btIDebugDraw const *)arg1)->getDebugMode(); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawAabb(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); (arg1)->drawAabb((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawAabbSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); (arg1)->btIDebugDraw::drawAabb((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTransform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btTransform *arg2 = 0 ; btScalar arg3 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; (arg1)->drawTransform((btTransform const &)*arg2,arg3); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawTransformSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btTransform *arg2 = 0 ; btScalar arg3 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; (arg1)->btIDebugDraw::drawTransform((btTransform const &)*arg2,arg3); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawArc_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jobject jarg9, jboolean jarg10, jfloat jarg11) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar arg5 ; btScalar arg6 ; btScalar arg7 ; btScalar arg8 ; btVector3 *arg9 = 0 ; bool arg10 ; btScalar arg11 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; arg8 = (btScalar)jarg8; btVector3 local_arg9; gdx_setbtVector3FromVector3(jenv, local_arg9, jarg9); arg9 = &local_arg9; gdxAutoCommitVector3 auto_commit_arg9(jenv, jarg9, &local_arg9); arg10 = jarg10 ? true : false; arg11 = (btScalar)jarg11; (arg1)->drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10,arg11); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawArcSwigExplicitbtIDebugDraw_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jobject jarg9, jboolean jarg10, jfloat jarg11) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar arg5 ; btScalar arg6 ; btScalar arg7 ; btScalar arg8 ; btVector3 *arg9 = 0 ; bool arg10 ; btScalar arg11 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; arg8 = (btScalar)jarg8; btVector3 local_arg9; gdx_setbtVector3FromVector3(jenv, local_arg9, jarg9); arg9 = &local_arg9; gdxAutoCommitVector3 auto_commit_arg9(jenv, jarg9, &local_arg9); arg10 = jarg10 ? true : false; arg11 = (btScalar)jarg11; (arg1)->btIDebugDraw::drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10,arg11); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawArc_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jobject jarg9, jboolean jarg10) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar arg5 ; btScalar arg6 ; btScalar arg7 ; btScalar arg8 ; btVector3 *arg9 = 0 ; bool arg10 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; arg8 = (btScalar)jarg8; btVector3 local_arg9; gdx_setbtVector3FromVector3(jenv, local_arg9, jarg9); arg9 = &local_arg9; gdxAutoCommitVector3 auto_commit_arg9(jenv, jarg9, &local_arg9); arg10 = jarg10 ? true : false; (arg1)->drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawArcSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jobject jarg9, jboolean jarg10) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar arg5 ; btScalar arg6 ; btScalar arg7 ; btScalar arg8 ; btVector3 *arg9 = 0 ; bool arg10 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; arg8 = (btScalar)jarg8; btVector3 local_arg9; gdx_setbtVector3FromVector3(jenv, local_arg9, jarg9); arg9 = &local_arg9; gdxAutoCommitVector3 auto_commit_arg9(jenv, jarg9, &local_arg9); arg10 = jarg10 ? true : false; (arg1)->btIDebugDraw::drawArc((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,(btVector3 const &)*arg9,arg10); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatch_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10, jfloat jarg11, jboolean jarg12) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar arg5 ; btScalar arg6 ; btScalar arg7 ; btScalar arg8 ; btScalar arg9 ; btVector3 *arg10 = 0 ; btScalar arg11 ; bool arg12 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; arg8 = (btScalar)jarg8; arg9 = (btScalar)jarg9; btVector3 local_arg10; gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); arg10 = &local_arg10; gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); arg11 = (btScalar)jarg11; arg12 = jarg12 ? true : false; (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11,arg12); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatchSwigExplicitbtIDebugDraw_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10, jfloat jarg11, jboolean jarg12) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar arg5 ; btScalar arg6 ; btScalar arg7 ; btScalar arg8 ; btScalar arg9 ; btVector3 *arg10 = 0 ; btScalar arg11 ; bool arg12 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; arg8 = (btScalar)jarg8; arg9 = (btScalar)jarg9; btVector3 local_arg10; gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); arg10 = &local_arg10; gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); arg11 = (btScalar)jarg11; arg12 = jarg12 ? true : false; (arg1)->btIDebugDraw::drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11,arg12); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatch_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10, jfloat jarg11) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar arg5 ; btScalar arg6 ; btScalar arg7 ; btScalar arg8 ; btScalar arg9 ; btVector3 *arg10 = 0 ; btScalar arg11 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; arg8 = (btScalar)jarg8; arg9 = (btScalar)jarg9; btVector3 local_arg10; gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); arg10 = &local_arg10; gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); arg11 = (btScalar)jarg11; (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatchSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10, jfloat jarg11) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar arg5 ; btScalar arg6 ; btScalar arg7 ; btScalar arg8 ; btScalar arg9 ; btVector3 *arg10 = 0 ; btScalar arg11 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; arg8 = (btScalar)jarg8; arg9 = (btScalar)jarg9; btVector3 local_arg10; gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); arg10 = &local_arg10; gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); arg11 = (btScalar)jarg11; (arg1)->btIDebugDraw::drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10,arg11); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatch_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar arg5 ; btScalar arg6 ; btScalar arg7 ; btScalar arg8 ; btScalar arg9 ; btVector3 *arg10 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; arg8 = (btScalar)jarg8; arg9 = (btScalar)jarg9; btVector3 local_arg10; gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); arg10 = &local_arg10; gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); (arg1)->drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawSpherePatchSwigExplicitbtIDebugDraw_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jfloat jarg6, jfloat jarg7, jfloat jarg8, jfloat jarg9, jobject jarg10) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; btScalar arg5 ; btScalar arg6 ; btScalar arg7 ; btScalar arg8 ; btScalar arg9 ; btVector3 *arg10 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; arg7 = (btScalar)jarg7; arg8 = (btScalar)jarg8; arg9 = (btScalar)jarg9; btVector3 local_arg10; gdx_setbtVector3FromVector3(jenv, local_arg10, jarg10); arg10 = &local_arg10; gdxAutoCommitVector3 auto_commit_arg10(jenv, jarg10, &local_arg10); (arg1)->btIDebugDraw::drawSpherePatch((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4,arg5,arg6,arg7,arg8,arg9,(btVector3 const &)*arg10); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawBox_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); (arg1)->drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawBoxSwigExplicitbtIDebugDraw_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btVector3 *arg4 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); (arg1)->btIDebugDraw::drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btVector3 const &)*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawBox_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btTransform *arg4 = 0 ; btVector3 *arg5 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btTransform local_arg4; gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); (arg1)->drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawBoxSwigExplicitbtIDebugDraw_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jobject jarg5) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btTransform *arg4 = 0 ; btVector3 *arg5 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); btTransform local_arg4; gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); (arg1)->btIDebugDraw::drawBox((btVector3 const &)*arg2,(btVector3 const &)*arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawCapsule(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btScalar arg2 ; btScalar arg3 ; int arg4 ; btTransform *arg5 = 0 ; btVector3 *arg6 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = (btScalar)jarg2; arg3 = (btScalar)jarg3; arg4 = (int)jarg4; btTransform local_arg5; gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); (arg1)->drawCapsule(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawCapsuleSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btScalar arg2 ; btScalar arg3 ; int arg4 ; btTransform *arg5 = 0 ; btVector3 *arg6 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = (btScalar)jarg2; arg3 = (btScalar)jarg3; arg4 = (int)jarg4; btTransform local_arg5; gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); (arg1)->btIDebugDraw::drawCapsule(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawCylinder(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btScalar arg2 ; btScalar arg3 ; int arg4 ; btTransform *arg5 = 0 ; btVector3 *arg6 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = (btScalar)jarg2; arg3 = (btScalar)jarg3; arg4 = (int)jarg4; btTransform local_arg5; gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); (arg1)->drawCylinder(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawCylinderSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btScalar arg2 ; btScalar arg3 ; int arg4 ; btTransform *arg5 = 0 ; btVector3 *arg6 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = (btScalar)jarg2; arg3 = (btScalar)jarg3; arg4 = (int)jarg4; btTransform local_arg5; gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); (arg1)->btIDebugDraw::drawCylinder(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawCone(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btScalar arg2 ; btScalar arg3 ; int arg4 ; btTransform *arg5 = 0 ; btVector3 *arg6 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = (btScalar)jarg2; arg3 = (btScalar)jarg3; arg4 = (int)jarg4; btTransform local_arg5; gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); (arg1)->drawCone(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawConeSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3, jint jarg4, jobject jarg5, jobject jarg6) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btScalar arg2 ; btScalar arg3 ; int arg4 ; btTransform *arg5 = 0 ; btVector3 *arg6 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; arg2 = (btScalar)jarg2; arg3 = (btScalar)jarg3; arg4 = (int)jarg4; btTransform local_arg5; gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); (arg1)->btIDebugDraw::drawCone(arg2,arg3,arg4,(btTransform const &)*arg5,(btVector3 const &)*arg6); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawPlane(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3, jobject jarg4, jobject jarg5) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btScalar arg3 ; btTransform *arg4 = 0 ; btVector3 *arg5 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; btTransform local_arg4; gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); (arg1)->drawPlane((btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1drawPlaneSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3, jobject jarg4, jobject jarg5) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; btVector3 *arg2 = 0 ; btScalar arg3 ; btTransform *arg4 = 0 ; btVector3 *arg5 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; btTransform local_arg4; gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); (arg1)->btIDebugDraw::drawPlane((btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,(btVector3 const &)*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1flushLines(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; (arg1)->flushLines(); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1flushLinesSwigExplicitbtIDebugDraw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { btIDebugDraw *arg1 = (btIDebugDraw *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btIDebugDraw **)&jarg1; (arg1)->btIDebugDraw::flushLines(); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btIDebugDraw(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btIDebugDraw *result = 0 ; (void)jenv; (void)jcls; result = (btIDebugDraw *)new SwigDirector_btIDebugDraw(jenv); *(btIDebugDraw **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { btIDebugDraw *obj = *((btIDebugDraw **)&objarg); (void)jcls; SwigDirector_btIDebugDraw *director = (SwigDirector_btIDebugDraw *)(obj); if (director) { director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); } } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btIDebugDraw_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { btIDebugDraw *obj = *((btIDebugDraw **)&objarg); SwigDirector_btIDebugDraw *director = (SwigDirector_btIDebugDraw *)(obj); (void)jcls; if (director) { director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); } } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGeometryUtil_1getPlaneEquationsFromVertices(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btAlignedObjectArray< btVector3 > *arg1 = 0 ; btAlignedObjectArray< btVector3 > *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; if (!arg1) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > & reference is null"); return ; } arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > & reference is null"); return ; } btGeometryUtil::getPlaneEquationsFromVertices(*arg1,*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGeometryUtil_1getVerticesFromPlaneEquations(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btAlignedObjectArray< btVector3 > *arg1 = 0 ; btAlignedObjectArray< btVector3 > *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; if (!arg1) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); return ; } arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > & reference is null"); return ; } btGeometryUtil::getVerticesFromPlaneEquations((btAlignedObjectArray< btVector3 > const &)*arg1,*arg2); } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGeometryUtil_1isInside(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { jboolean jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = 0 ; btVector3 *arg2 = 0 ; btScalar arg3 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; if (!arg1) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); return 0; } btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; result = (bool)btGeometryUtil::isInside((btAlignedObjectArray< btVector3 > const &)*arg1,(btVector3 const &)*arg2,arg3); jresult = (jboolean)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGeometryUtil_1isPointInsidePlanes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3) { jboolean jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = 0 ; btVector3 *arg2 = 0 ; btScalar arg3 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; if (!arg1) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); return 0; } btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; result = (bool)btGeometryUtil::isPointInsidePlanes((btAlignedObjectArray< btVector3 > const &)*arg1,(btVector3 const &)*arg2,arg3); jresult = (jboolean)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGeometryUtil_1areVerticesBehindPlane(JNIEnv *jenv, jclass jcls, jobject jarg1, jlong jarg2, jobject jarg2_, jfloat jarg3) { jboolean jresult = 0 ; btVector3 *arg1 = 0 ; btAlignedObjectArray< btVector3 > *arg2 = 0 ; btScalar arg3 ; bool result; (void)jenv; (void)jcls; (void)jarg2_; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); return 0; } arg3 = (btScalar)jarg3; result = (bool)btGeometryUtil::areVerticesBehindPlane((btVector3 const &)*arg1,(btAlignedObjectArray< btVector3 > const &)*arg2,arg3); jresult = (jboolean)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btGeometryUtil(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btGeometryUtil *result = 0 ; (void)jenv; (void)jcls; result = (btGeometryUtil *)new btGeometryUtil(); *(btGeometryUtil **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btGeometryUtil(JNIEnv *jenv, jclass jcls, jlong jarg1) { btGeometryUtil *arg1 = (btGeometryUtil *) 0 ; (void)jenv; (void)jcls; arg1 = *(btGeometryUtil **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GEN_1srand(JNIEnv *jenv, jclass jcls, jlong jarg1) { unsigned int arg1 ; (void)jenv; (void)jcls; arg1 = (unsigned int)jarg1; GEN_srand(arg1); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GEN_1rand(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; unsigned int result; (void)jenv; (void)jcls; result = (unsigned int)GEN_rand(); jresult = (jlong)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAabbSupport(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jobject jresult = 0 ; btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btVector3 result; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = btAabbSupport((btVector3 const &)*arg1,(btVector3 const &)*arg2); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformUtil_1integrateTransform(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jfloat jarg4, jobject jarg5) { btTransform *arg1 = 0 ; btVector3 *arg2 = 0 ; btVector3 *arg3 = 0 ; btScalar arg4 ; btTransform *arg5 = 0 ; (void)jenv; (void)jcls; btTransform local_arg1; gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); arg4 = (btScalar)jarg4; btTransform local_arg5; gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); btTransformUtil::integrateTransform((btTransform const &)*arg1,(btVector3 const &)*arg2,(btVector3 const &)*arg3,arg4,*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformUtil_1calculateVelocityQuaternion(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jobject jarg4, jfloat jarg5, jobject jarg6, jobject jarg7) { btVector3 *arg1 = 0 ; btVector3 *arg2 = 0 ; btQuaternion *arg3 = 0 ; btQuaternion *arg4 = 0 ; btScalar arg5 ; btVector3 *arg6 = 0 ; btVector3 *arg7 = 0 ; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); btQuaternion local_arg3; gdx_setbtQuaternionFromQuaternion(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitQuaternion auto_commit_arg3(jenv, jarg3, &local_arg3); btQuaternion local_arg4; gdx_setbtQuaternionFromQuaternion(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitQuaternion auto_commit_arg4(jenv, jarg4, &local_arg4); arg5 = (btScalar)jarg5; btVector3 local_arg6; gdx_setbtVector3FromVector3(jenv, local_arg6, jarg6); arg6 = &local_arg6; gdxAutoCommitVector3 auto_commit_arg6(jenv, jarg6, &local_arg6); btVector3 local_arg7; gdx_setbtVector3FromVector3(jenv, local_arg7, jarg7); arg7 = &local_arg7; gdxAutoCommitVector3 auto_commit_arg7(jenv, jarg7, &local_arg7); btTransformUtil::calculateVelocityQuaternion((btVector3 const &)*arg1,(btVector3 const &)*arg2,(btQuaternion const &)*arg3,(btQuaternion const &)*arg4,arg5,*arg6,*arg7); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformUtil_1calculateDiffAxisAngleQuaternion(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jlong jarg4) { btQuaternion *arg1 = 0 ; btQuaternion *arg2 = 0 ; btVector3 *arg3 = 0 ; btScalar *arg4 = 0 ; (void)jenv; (void)jcls; btQuaternion local_arg1; gdx_setbtQuaternionFromQuaternion(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitQuaternion auto_commit_arg1(jenv, jarg1, &local_arg1); btQuaternion local_arg2; gdx_setbtQuaternionFromQuaternion(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitQuaternion auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); arg4 = *(btScalar **)&jarg4; if (!arg4) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); return ; } btTransformUtil::calculateDiffAxisAngleQuaternion((btQuaternion const &)*arg1,(btQuaternion const &)*arg2,*arg3,*arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformUtil_1calculateVelocity(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jfloat jarg3, jobject jarg4, jobject jarg5) { btTransform *arg1 = 0 ; btTransform *arg2 = 0 ; btScalar arg3 ; btVector3 *arg4 = 0 ; btVector3 *arg5 = 0 ; (void)jenv; (void)jcls; btTransform local_arg1; gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; btVector3 local_arg4; gdx_setbtVector3FromVector3(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitVector3 auto_commit_arg4(jenv, jarg4, &local_arg4); btVector3 local_arg5; gdx_setbtVector3FromVector3(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitVector3 auto_commit_arg5(jenv, jarg5, &local_arg5); btTransformUtil::calculateVelocity((btTransform const &)*arg1,(btTransform const &)*arg2,arg3,*arg4,*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btTransformUtil_1calculateDiffAxisAngle(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jobject jarg3, jlong jarg4) { btTransform *arg1 = 0 ; btTransform *arg2 = 0 ; btVector3 *arg3 = 0 ; btScalar *arg4 = 0 ; (void)jenv; (void)jcls; btTransform local_arg1; gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); arg4 = *(btScalar **)&jarg4; if (!arg4) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btScalar & reference is null"); return ; } btTransformUtil::calculateDiffAxisAngle((btTransform const &)*arg1,(btTransform const &)*arg2,*arg3,*arg4); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btTransformUtil(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btTransformUtil *result = 0 ; (void)jenv; (void)jcls; result = (btTransformUtil *)new btTransformUtil(); *(btTransformUtil **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btTransformUtil(JNIEnv *jenv, jclass jcls, jlong jarg1) { btTransformUtil *arg1 = (btTransformUtil *) 0 ; (void)jenv; (void)jcls; arg1 = *(btTransformUtil **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btConvexSeparatingDistanceUtil(JNIEnv *jenv, jclass jcls, jfloat jarg1, jfloat jarg2) { jlong jresult = 0 ; btScalar arg1 ; btScalar arg2 ; btConvexSeparatingDistanceUtil *result = 0 ; (void)jenv; (void)jcls; arg1 = (btScalar)jarg1; arg2 = (btScalar)jarg2; result = (btConvexSeparatingDistanceUtil *)new btConvexSeparatingDistanceUtil(arg1,arg2); *(btConvexSeparatingDistanceUtil **)&jresult = result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexSeparatingDistanceUtil_1getConservativeSeparatingDistance(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexSeparatingDistanceUtil **)&jarg1; result = (btScalar)(arg1)->getConservativeSeparatingDistance(); jresult = (jfloat)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexSeparatingDistanceUtil_1updateSeparatingDistance(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; btTransform *arg2 = 0 ; btTransform *arg3 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexSeparatingDistanceUtil **)&jarg1; btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); btTransform local_arg3; gdx_setbtTransformFromMatrix4(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitMatrix4 auto_commit_arg3(jenv, jarg3, &local_arg3); (arg1)->updateSeparatingDistance((btTransform const &)*arg2,(btTransform const &)*arg3); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexSeparatingDistanceUtil_1initSeparatingDistance(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jfloat jarg3, jobject jarg4, jobject jarg5) { btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; btVector3 *arg2 = 0 ; btScalar arg3 ; btTransform *arg4 = 0 ; btTransform *arg5 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexSeparatingDistanceUtil **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); arg3 = (btScalar)jarg3; btTransform local_arg4; gdx_setbtTransformFromMatrix4(jenv, local_arg4, jarg4); arg4 = &local_arg4; gdxAutoCommitMatrix4 auto_commit_arg4(jenv, jarg4, &local_arg4); btTransform local_arg5; gdx_setbtTransformFromMatrix4(jenv, local_arg5, jarg5); arg5 = &local_arg5; gdxAutoCommitMatrix4 auto_commit_arg5(jenv, jarg5, &local_arg5); (arg1)->initSeparatingDistance((btVector3 const &)*arg2,arg3,(btTransform const &)*arg4,(btTransform const &)*arg5); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btConvexSeparatingDistanceUtil(JNIEnv *jenv, jclass jcls, jlong jarg1) { btConvexSeparatingDistanceUtil *arg1 = (btConvexSeparatingDistanceUtil *) 0 ; (void)jenv; (void)jcls; arg1 = *(btConvexSeparatingDistanceUtil **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1HullResult(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; HullResult *result = 0 ; (void)jenv; (void)jcls; result = (HullResult *)new HullResult(); *(HullResult **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mPolygons_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { HullResult *arg1 = (HullResult *) 0 ; bool arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; arg2 = jarg2 ? true : false; if (arg1) (arg1)->mPolygons = arg2; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mPolygons_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jboolean jresult = 0 ; HullResult *arg1 = (HullResult *) 0 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; result = (bool) ((arg1)->mPolygons); jresult = (jboolean)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumOutputVertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { HullResult *arg1 = (HullResult *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mNumOutputVertices = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumOutputVertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullResult *arg1 = (HullResult *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; result = (unsigned int) ((arg1)->mNumOutputVertices); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1OutputVertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { HullResult *arg1 = (HullResult *) 0 ; btAlignedObjectArray< btVector3 > *arg2 = (btAlignedObjectArray< btVector3 > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(HullResult **)&jarg1; arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; if (arg1) (arg1)->m_OutputVertices = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1OutputVertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullResult *arg1 = (HullResult *) 0 ; btAlignedObjectArray< btVector3 > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; result = (btAlignedObjectArray< btVector3 > *)& ((arg1)->m_OutputVertices); *(btAlignedObjectArray< btVector3 > **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumFaces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { HullResult *arg1 = (HullResult *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mNumFaces = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumFaces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullResult *arg1 = (HullResult *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; result = (unsigned int) ((arg1)->mNumFaces); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumIndices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { HullResult *arg1 = (HullResult *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mNumIndices = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1mNumIndices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullResult *arg1 = (HullResult *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; result = (unsigned int) ((arg1)->mNumIndices); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1Indices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { HullResult *arg1 = (HullResult *) 0 ; btAlignedObjectArray< unsigned int > *arg2 = (btAlignedObjectArray< unsigned int > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; arg2 = *(btAlignedObjectArray< unsigned int > **)&jarg2; if (arg1) (arg1)->m_Indices = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullResult_1Indices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullResult *arg1 = (HullResult *) 0 ; btAlignedObjectArray< unsigned int > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullResult **)&jarg1; result = (btAlignedObjectArray< unsigned int > *)& ((arg1)->m_Indices); *(btAlignedObjectArray< unsigned int > **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1HullResult(JNIEnv *jenv, jclass jcls, jlong jarg1) { HullResult *arg1 = (HullResult *) 0 ; (void)jenv; (void)jcls; arg1 = *(HullResult **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1HullDesc_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; HullDesc *result = 0 ; (void)jenv; (void)jcls; result = (HullDesc *)new HullDesc(); *(HullDesc **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1HullDesc_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jlong jarg3, jobject jarg3_, jlong jarg4) { jlong jresult = 0 ; HullFlag arg1 ; unsigned int arg2 ; btVector3 *arg3 = (btVector3 *) 0 ; unsigned int arg4 ; HullDesc *result = 0 ; (void)jenv; (void)jcls; (void)jarg3_; arg1 = (HullFlag)jarg1; arg2 = (unsigned int)jarg2; arg3 = *(btVector3 **)&jarg3; arg4 = (unsigned int)jarg4; result = (HullDesc *)new HullDesc(arg1,arg2,(btVector3 const *)arg3,arg4); *(HullDesc **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1HullDesc_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jlong jarg3, jobject jarg3_) { jlong jresult = 0 ; HullFlag arg1 ; unsigned int arg2 ; btVector3 *arg3 = (btVector3 *) 0 ; HullDesc *result = 0 ; (void)jenv; (void)jcls; (void)jarg3_; arg1 = (HullFlag)jarg1; arg2 = (unsigned int)jarg2; arg3 = *(btVector3 **)&jarg3; result = (HullDesc *)new HullDesc(arg1,arg2,(btVector3 const *)arg3); *(HullDesc **)&jresult = result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1HasHullFlag(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { jboolean jresult = 0 ; HullDesc *arg1 = (HullDesc *) 0 ; HullFlag arg2 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; arg2 = (HullFlag)jarg2; result = (bool)((HullDesc const *)arg1)->HasHullFlag(arg2); jresult = (jboolean)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1SetHullFlag(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { HullDesc *arg1 = (HullDesc *) 0 ; HullFlag arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; arg2 = (HullFlag)jarg2; (arg1)->SetHullFlag(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1ClearHullFlag(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { HullDesc *arg1 = (HullDesc *) 0 ; HullFlag arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; arg2 = (HullFlag)jarg2; (arg1)->ClearHullFlag(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mFlags_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { HullDesc *arg1 = (HullDesc *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mFlags = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mFlags_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullDesc *arg1 = (HullDesc *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; result = (unsigned int) ((arg1)->mFlags); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVcount_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { HullDesc *arg1 = (HullDesc *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mVcount = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVcount_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullDesc *arg1 = (HullDesc *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; result = (unsigned int) ((arg1)->mVcount); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { HullDesc *arg1 = (HullDesc *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(HullDesc **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->mVertices = (btVector3 const *)arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullDesc *arg1 = (HullDesc *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; result = (btVector3 *) ((arg1)->mVertices); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVertexStride_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { HullDesc *arg1 = (HullDesc *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mVertexStride = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mVertexStride_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullDesc *arg1 = (HullDesc *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; result = (unsigned int) ((arg1)->mVertexStride); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mNormalEpsilon_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { HullDesc *arg1 = (HullDesc *) 0 ; btScalar arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; arg2 = (btScalar)jarg2; if (arg1) (arg1)->mNormalEpsilon = arg2; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mNormalEpsilon_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; HullDesc *arg1 = (HullDesc *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; result = (btScalar) ((arg1)->mNormalEpsilon); jresult = (jfloat)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mMaxVertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { HullDesc *arg1 = (HullDesc *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mMaxVertices = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mMaxVertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullDesc *arg1 = (HullDesc *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; result = (unsigned int) ((arg1)->mMaxVertices); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mMaxFaces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { HullDesc *arg1 = (HullDesc *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mMaxFaces = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullDesc_1mMaxFaces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullDesc *arg1 = (HullDesc *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullDesc **)&jarg1; result = (unsigned int) ((arg1)->mMaxFaces); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1HullDesc(JNIEnv *jenv, jclass jcls, jlong jarg1) { HullDesc *arg1 = (HullDesc *) 0 ; (void)jenv; (void)jcls; arg1 = *(HullDesc **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPlane_1normal_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btPlane *arg1 = (btPlane *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btPlane **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->normal = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPlane_1normal_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btPlane *arg1 = (btPlane *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPlane **)&jarg1; result = (btVector3 *)& ((arg1)->normal); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPlane_1dist_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { btPlane *arg1 = (btPlane *) 0 ; btScalar arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPlane **)&jarg1; arg2 = (btScalar)jarg2; if (arg1) (arg1)->dist = arg2; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPlane_1dist_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; btPlane *arg1 = (btPlane *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPlane **)&jarg1; result = (btScalar) ((arg1)->dist); jresult = (jfloat)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btPlane_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jfloat jarg2) { jlong jresult = 0 ; btVector3 *arg1 = 0 ; btScalar arg2 ; btPlane *result = 0 ; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); arg2 = (btScalar)jarg2; result = (btPlane *)new btPlane((btVector3 const &)*arg1,arg2); *(btPlane **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btPlane_1_1SWIG_11(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btPlane *result = 0 ; (void)jenv; (void)jcls; result = (btPlane *)new btPlane(); *(btPlane **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btPlane(JNIEnv *jenv, jclass jcls, jlong jarg1) { btPlane *arg1 = (btPlane *) 0 ; (void)jenv; (void)jcls; arg1 = *(btPlane **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1ea_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; short arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH::HalfEdge **)&jarg1; arg2 = (short)jarg2; if (arg1) (arg1)->ea = arg2; } SWIGEXPORT jshort JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1ea_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jshort jresult = 0 ; ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; short result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH::HalfEdge **)&jarg1; result = (short) ((arg1)->ea); jresult = (jshort)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1v_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; unsigned char arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH::HalfEdge **)&jarg1; arg2 = (unsigned char)jarg2; if (arg1) (arg1)->v = arg2; } SWIGEXPORT jshort JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1v_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jshort jresult = 0 ; ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; unsigned char result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH::HalfEdge **)&jarg1; result = (unsigned char) ((arg1)->v); jresult = (jshort)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1p_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) { ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; unsigned char arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH::HalfEdge **)&jarg1; arg2 = (unsigned char)jarg2; if (arg1) (arg1)->p = arg2; } SWIGEXPORT jshort JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1HalfEdge_1p_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jshort jresult = 0 ; ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; unsigned char result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH::HalfEdge **)&jarg1; result = (unsigned char) ((arg1)->p); jresult = (jshort)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1ConvexH_1HalfEdge_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; ConvexH::HalfEdge *result = 0 ; (void)jenv; (void)jcls; result = (ConvexH::HalfEdge *)new ConvexH::HalfEdge(); *(ConvexH::HalfEdge **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1ConvexH_1HalfEdge_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jshort jarg1, jshort jarg2, jshort jarg3) { jlong jresult = 0 ; short arg1 ; unsigned char arg2 ; unsigned char arg3 ; ConvexH::HalfEdge *result = 0 ; (void)jenv; (void)jcls; arg1 = (short)jarg1; arg2 = (unsigned char)jarg2; arg3 = (unsigned char)jarg3; result = (ConvexH::HalfEdge *)new ConvexH::HalfEdge(arg1,arg2,arg3); *(ConvexH::HalfEdge **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1ConvexH_1HalfEdge(JNIEnv *jenv, jclass jcls, jlong jarg1) { ConvexH::HalfEdge *arg1 = (ConvexH::HalfEdge *) 0 ; (void)jenv; (void)jcls; arg1 = *(ConvexH::HalfEdge **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1ConvexH_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; ConvexH *result = 0 ; (void)jenv; (void)jcls; result = (ConvexH *)new ConvexH(); *(ConvexH **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1ConvexH(JNIEnv *jenv, jclass jcls, jlong jarg1) { ConvexH *arg1 = (ConvexH *) 0 ; (void)jenv; (void)jcls; arg1 = *(ConvexH **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1vertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { ConvexH *arg1 = (ConvexH *) 0 ; btAlignedObjectArray< btVector3 > *arg2 = (btAlignedObjectArray< btVector3 > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(ConvexH **)&jarg1; arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; if (arg1) (arg1)->vertices = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1vertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; ConvexH *arg1 = (ConvexH *) 0 ; btAlignedObjectArray< btVector3 > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH **)&jarg1; result = (btAlignedObjectArray< btVector3 > *)& ((arg1)->vertices); *(btAlignedObjectArray< btVector3 > **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1edges_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { ConvexH *arg1 = (ConvexH *) 0 ; btAlignedObjectArray< ConvexH::HalfEdge > *arg2 = (btAlignedObjectArray< ConvexH::HalfEdge > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH **)&jarg1; arg2 = *(btAlignedObjectArray< ConvexH::HalfEdge > **)&jarg2; if (arg1) (arg1)->edges = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1edges_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; ConvexH *arg1 = (ConvexH *) 0 ; btAlignedObjectArray< ConvexH::HalfEdge > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH **)&jarg1; result = (btAlignedObjectArray< ConvexH::HalfEdge > *)& ((arg1)->edges); *(btAlignedObjectArray< ConvexH::HalfEdge > **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1facets_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { ConvexH *arg1 = (ConvexH *) 0 ; btAlignedObjectArray< btPlane > *arg2 = (btAlignedObjectArray< btPlane > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH **)&jarg1; arg2 = *(btAlignedObjectArray< btPlane > **)&jarg2; if (arg1) (arg1)->facets = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_ConvexH_1facets_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; ConvexH *arg1 = (ConvexH *) 0 ; btAlignedObjectArray< btPlane > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(ConvexH **)&jarg1; result = (btAlignedObjectArray< btPlane > *)& ((arg1)->facets); *(btAlignedObjectArray< btPlane > **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1ConvexH_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3) { jlong jresult = 0 ; int arg1 ; int arg2 ; int arg3 ; ConvexH *result = 0 ; (void)jenv; (void)jcls; arg1 = (int)jarg1; arg2 = (int)jarg2; arg3 = (int)jarg3; result = (ConvexH *)new ConvexH(arg1,arg2,arg3); *(ConvexH **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1x_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { int4 *arg1 = (int4 *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(int4 **)&jarg1; arg2 = (int)jarg2; if (arg1) (arg1)->x = arg2; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1x_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; int4 *arg1 = (int4 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(int4 **)&jarg1; result = (int) ((arg1)->x); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1y_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { int4 *arg1 = (int4 *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(int4 **)&jarg1; arg2 = (int)jarg2; if (arg1) (arg1)->y = arg2; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1y_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; int4 *arg1 = (int4 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(int4 **)&jarg1; result = (int) ((arg1)->y); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1z_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { int4 *arg1 = (int4 *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(int4 **)&jarg1; arg2 = (int)jarg2; if (arg1) (arg1)->z = arg2; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1z_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; int4 *arg1 = (int4 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(int4 **)&jarg1; result = (int) ((arg1)->z); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1w_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { int4 *arg1 = (int4 *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(int4 **)&jarg1; arg2 = (int)jarg2; if (arg1) (arg1)->w = arg2; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_int4_1w_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; int4 *arg1 = (int4 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(int4 **)&jarg1; result = (int) ((arg1)->w); jresult = (jint)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1int4_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; int4 *result = 0 ; (void)jenv; (void)jcls; result = (int4 *)new int4(); *(int4 **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1int4_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4) { jlong jresult = 0 ; int arg1 ; int arg2 ; int arg3 ; int arg4 ; int4 *result = 0 ; (void)jenv; (void)jcls; arg1 = (int)jarg1; arg2 = (int)jarg2; arg3 = (int)jarg3; arg4 = (int)jarg4; result = (int4 *)new int4(arg1,arg2,arg3,arg4); *(int4 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1int4(JNIEnv *jenv, jclass jcls, jlong jarg1) { int4 *arg1 = (int4 *) 0 ; (void)jenv; (void)jcls; arg1 = *(int4 **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1PHullResult(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; PHullResult *result = 0 ; (void)jenv; (void)jcls; result = (PHullResult *)new PHullResult(); *(PHullResult **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mVcount_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { PHullResult *arg1 = (PHullResult *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(PHullResult **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mVcount = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mVcount_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; PHullResult *arg1 = (PHullResult *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(PHullResult **)&jarg1; result = (unsigned int) ((arg1)->mVcount); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mIndexCount_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { PHullResult *arg1 = (PHullResult *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(PHullResult **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mIndexCount = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mIndexCount_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; PHullResult *arg1 = (PHullResult *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(PHullResult **)&jarg1; result = (unsigned int) ((arg1)->mIndexCount); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mFaceCount_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { PHullResult *arg1 = (PHullResult *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(PHullResult **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->mFaceCount = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mFaceCount_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; PHullResult *arg1 = (PHullResult *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(PHullResult **)&jarg1; result = (unsigned int) ((arg1)->mFaceCount); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mVertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { PHullResult *arg1 = (PHullResult *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(PHullResult **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->mVertices = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1mVertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; PHullResult *arg1 = (PHullResult *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(PHullResult **)&jarg1; result = (btVector3 *) ((arg1)->mVertices); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1Indices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { PHullResult *arg1 = (PHullResult *) 0 ; TUIntArray *arg2 = (TUIntArray *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(PHullResult **)&jarg1; arg2 = *(TUIntArray **)&jarg2; if (arg1) (arg1)->m_Indices = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_PHullResult_1Indices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; PHullResult *arg1 = (PHullResult *) 0 ; TUIntArray *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(PHullResult **)&jarg1; result = (TUIntArray *)& ((arg1)->m_Indices); *(TUIntArray **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1PHullResult(JNIEnv *jenv, jclass jcls, jlong jarg1) { PHullResult *arg1 = (PHullResult *) 0 ; (void)jenv; (void)jcls; arg1 = *(PHullResult **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullLibrary_1vertexIndexMapping_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { HullLibrary *arg1 = (HullLibrary *) 0 ; btAlignedObjectArray< int > *arg2 = (btAlignedObjectArray< int > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullLibrary **)&jarg1; arg2 = *(btAlignedObjectArray< int > **)&jarg2; if (arg1) (arg1)->m_vertexIndexMapping = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullLibrary_1vertexIndexMapping_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; HullLibrary *arg1 = (HullLibrary *) 0 ; btAlignedObjectArray< int > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(HullLibrary **)&jarg1; result = (btAlignedObjectArray< int > *)& ((arg1)->m_vertexIndexMapping); *(btAlignedObjectArray< int > **)&jresult = result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullLibrary_1CreateConvexHull(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) { jint jresult = 0 ; HullLibrary *arg1 = (HullLibrary *) 0 ; HullDesc *arg2 = 0 ; HullResult *arg3 = 0 ; HullError result; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; (void)jarg3_; arg1 = *(HullLibrary **)&jarg1; arg2 = *(HullDesc **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "HullDesc const & reference is null"); return 0; } arg3 = *(HullResult **)&jarg3; if (!arg3) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "HullResult & reference is null"); return 0; } result = (HullError)(arg1)->CreateConvexHull((HullDesc const &)*arg2,*arg3); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_HullLibrary_1ReleaseResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { jint jresult = 0 ; HullLibrary *arg1 = (HullLibrary *) 0 ; HullResult *arg2 = 0 ; HullError result; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(HullLibrary **)&jarg1; arg2 = *(HullResult **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "HullResult & reference is null"); return 0; } result = (HullError)(arg1)->ReleaseResult(*arg2); jresult = (jint)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1HullLibrary(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; HullLibrary *result = 0 ; (void)jenv; (void)jcls; result = (HullLibrary *)new HullLibrary(); *(HullLibrary **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1HullLibrary(JNIEnv *jenv, jclass jcls, jlong jarg1) { HullLibrary *arg1 = (HullLibrary *) 0 ; (void)jenv; (void)jcls; arg1 = *(HullLibrary **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1GrahamVector3(JNIEnv *jenv, jclass jcls, jobject jarg1, jint jarg2) { jlong jresult = 0 ; btVector3 *arg1 = 0 ; int arg2 ; GrahamVector3 *result = 0 ; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); arg2 = (int)jarg2; result = (GrahamVector3 *)new GrahamVector3((btVector3 const &)*arg1,arg2); *(GrahamVector3 **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamVector3_1angle_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; btScalar arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(GrahamVector3 **)&jarg1; arg2 = (btScalar)jarg2; if (arg1) (arg1)->m_angle = arg2; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamVector3_1angle_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jfloat jresult = 0 ; GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(GrahamVector3 **)&jarg1; result = (btScalar) ((arg1)->m_angle); jresult = (jfloat)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamVector3_1orgIndex_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(GrahamVector3 **)&jarg1; arg2 = (int)jarg2; if (arg1) (arg1)->m_orgIndex = arg2; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamVector3_1orgIndex_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(GrahamVector3 **)&jarg1; result = (int) ((arg1)->m_orgIndex); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1GrahamVector3(JNIEnv *jenv, jclass jcls, jlong jarg1) { GrahamVector3 *arg1 = (GrahamVector3 *) 0 ; (void)jenv; (void)jcls; arg1 = *(GrahamVector3 **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAngleCompareFunc_1anchor_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btAngleCompareFunc *arg1 = (btAngleCompareFunc *) 0 ; btVector3 *arg2 = (btVector3 *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btAngleCompareFunc **)&jarg1; arg2 = *(btVector3 **)&jarg2; if (arg1) (arg1)->m_anchor = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAngleCompareFunc_1anchor_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btAngleCompareFunc *arg1 = (btAngleCompareFunc *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAngleCompareFunc **)&jarg1; result = (btVector3 *)& ((arg1)->m_anchor); *(btVector3 **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btAngleCompareFunc(JNIEnv *jenv, jclass jcls, jobject jarg1) { jlong jresult = 0 ; btVector3 *arg1 = 0 ; btAngleCompareFunc *result = 0 ; (void)jenv; (void)jcls; btVector3 local_arg1; gdx_setbtVector3FromVector3(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitVector3 auto_commit_arg1(jenv, jarg1, &local_arg1); result = (btAngleCompareFunc *)new btAngleCompareFunc((btVector3 const &)*arg1); *(btAngleCompareFunc **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btAngleCompareFunc(JNIEnv *jenv, jclass jcls, jlong jarg1) { btAngleCompareFunc *arg1 = (btAngleCompareFunc *) 0 ; (void)jenv; (void)jcls; arg1 = *(btAngleCompareFunc **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamScanConvexHull2D(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jobject jarg3) { btAlignedObjectArray< GrahamVector3 > *arg1 = 0 ; btAlignedObjectArray< GrahamVector3 > *arg2 = 0 ; btVector3 *arg3 = 0 ; (void)jenv; (void)jcls; arg1 = *(btAlignedObjectArray< GrahamVector3 > **)&jarg1; if (!arg1) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< GrahamVector3 > & reference is null"); return ; } arg2 = *(btAlignedObjectArray< GrahamVector3 > **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< GrahamVector3 > & reference is null"); return ; } btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); GrahamScanConvexHull2D(*arg1,*arg2,(btVector3 const &)*arg3); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btPoolAllocator(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) { jlong jresult = 0 ; int arg1 ; int arg2 ; btPoolAllocator *result = 0 ; (void)jenv; (void)jcls; arg1 = (int)jarg1; arg2 = (int)jarg2; result = (btPoolAllocator *)new btPoolAllocator(arg1,arg2); *(btPoolAllocator **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btPoolAllocator(JNIEnv *jenv, jclass jcls, jlong jarg1) { btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; (void)jenv; (void)jcls; arg1 = *(btPoolAllocator **)&jarg1; delete arg1; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1getFreeCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPoolAllocator **)&jarg1; result = (int)((btPoolAllocator const *)arg1)->getFreeCount(); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1getUsedCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPoolAllocator **)&jarg1; result = (int)((btPoolAllocator const *)arg1)->getUsedCount(); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1getMaxCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPoolAllocator **)&jarg1; result = (int)((btPoolAllocator const *)arg1)->getMaxCount(); jresult = (jint)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1allocate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { jlong jresult = 0 ; btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; int arg2 ; void *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPoolAllocator **)&jarg1; arg2 = (int)jarg2; result = (void *)(arg1)->allocate(arg2); jresult = (jlong)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1validPtr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { jboolean jresult = 0 ; btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; void *arg2 = (void *) 0 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPoolAllocator **)&jarg1; arg2 = (void *)jarg2; result = (bool)(arg1)->validPtr(arg2); jresult = (jboolean)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1freeMemory(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; void *arg2 = (void *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPoolAllocator **)&jarg1; arg2 = (void *)jarg2; (arg1)->freeMemory(arg2); } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1getElementSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPoolAllocator **)&jarg1; result = (int)((btPoolAllocator const *)arg1)->getElementSize(); jresult = (jint)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btPoolAllocator_1getPoolAddress_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btPoolAllocator *arg1 = (btPoolAllocator *) 0 ; unsigned char *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btPoolAllocator **)&jarg1; result = (unsigned char *)(arg1)->getPoolAddress(); *(unsigned char **)&jresult = result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1Edge_1getSourceVertex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer::Edge **)&jarg1; result = (int)((btConvexHullComputer::Edge const *)arg1)->getSourceVertex(); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1Edge_1getTargetVertex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer::Edge **)&jarg1; result = (int)((btConvexHullComputer::Edge const *)arg1)->getTargetVertex(); jresult = (jint)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1Edge_1getNextEdgeOfVertex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; btConvexHullComputer::Edge *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer::Edge **)&jarg1; result = (btConvexHullComputer::Edge *)((btConvexHullComputer::Edge const *)arg1)->getNextEdgeOfVertex(); *(btConvexHullComputer::Edge **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1Edge_1getNextEdgeOfFace(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; btConvexHullComputer::Edge *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer::Edge **)&jarg1; result = (btConvexHullComputer::Edge *)((btConvexHullComputer::Edge const *)arg1)->getNextEdgeOfFace(); *(btConvexHullComputer::Edge **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1Edge_1getReverseEdge(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; btConvexHullComputer::Edge *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer::Edge **)&jarg1; result = (btConvexHullComputer::Edge *)((btConvexHullComputer::Edge const *)arg1)->getReverseEdge(); *(btConvexHullComputer::Edge **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btConvexHullComputer_1Edge(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btConvexHullComputer::Edge *result = 0 ; (void)jenv; (void)jcls; result = (btConvexHullComputer::Edge *)new btConvexHullComputer::Edge(); *(btConvexHullComputer::Edge **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btConvexHullComputer_1Edge(JNIEnv *jenv, jclass jcls, jlong jarg1) { btConvexHullComputer::Edge *arg1 = (btConvexHullComputer::Edge *) 0 ; (void)jenv; (void)jcls; arg1 = *(btConvexHullComputer::Edge **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1vertices_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; btAlignedObjectArray< btVector3 > *arg2 = (btAlignedObjectArray< btVector3 > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btConvexHullComputer **)&jarg1; arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; if (arg1) (arg1)->vertices = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1vertices_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; btAlignedObjectArray< btVector3 > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer **)&jarg1; result = (btAlignedObjectArray< btVector3 > *)& ((arg1)->vertices); *(btAlignedObjectArray< btVector3 > **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1edges_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; btAlignedObjectArray< btConvexHullComputer::Edge > *arg2 = (btAlignedObjectArray< btConvexHullComputer::Edge > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer **)&jarg1; arg2 = *(btAlignedObjectArray< btConvexHullComputer::Edge > **)&jarg2; if (arg1) (arg1)->edges = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1edges_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; btAlignedObjectArray< btConvexHullComputer::Edge > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer **)&jarg1; result = (btAlignedObjectArray< btConvexHullComputer::Edge > *)& ((arg1)->edges); *(btAlignedObjectArray< btConvexHullComputer::Edge > **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1faces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; btAlignedObjectArray< int > *arg2 = (btAlignedObjectArray< int > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer **)&jarg1; arg2 = *(btAlignedObjectArray< int > **)&jarg2; if (arg1) (arg1)->faces = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1faces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; btAlignedObjectArray< int > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer **)&jarg1; result = (btAlignedObjectArray< int > *)& ((arg1)->faces); *(btAlignedObjectArray< int > **)&jresult = result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1compute_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jint jarg3, jint jarg4, jfloat jarg5, jfloat jarg6) { jfloat jresult = 0 ; btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; btScalar arg5 ; btScalar arg6 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer **)&jarg1; { arg2 = (float*)jenv->GetDirectBufferAddress(jarg2); if (arg2 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } arg3 = (int)jarg3; arg4 = (int)jarg4; arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; result = (btScalar)(arg1)->compute((float const *)arg2,arg3,arg4,arg5,arg6); jresult = (jfloat)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btConvexHullComputer_1compute_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jint jarg3, jint jarg4, jfloat jarg5, jfloat jarg6) { jfloat jresult = 0 ; btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; double *arg2 = (double *) 0 ; int arg3 ; int arg4 ; btScalar arg5 ; btScalar arg6 ; btScalar result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btConvexHullComputer **)&jarg1; { arg2 = (double*)jenv->GetDirectBufferAddress(jarg2); if (arg2 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } arg3 = (int)jarg3; arg4 = (int)jarg4; arg5 = (btScalar)jarg5; arg6 = (btScalar)jarg6; result = (btScalar)(arg1)->compute((double const *)arg2,arg3,arg4,arg5,arg6); jresult = (jfloat)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btConvexHullComputer(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btConvexHullComputer *result = 0 ; (void)jenv; (void)jcls; result = (btConvexHullComputer *)new btConvexHullComputer(); *(btConvexHullComputer **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btConvexHullComputer(JNIEnv *jenv, jclass jcls, jlong jarg1) { btConvexHullComputer *arg1 = (btConvexHullComputer *) 0 ; (void)jenv; (void)jcls; arg1 = *(btConvexHullComputer **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btGEN_1Link_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btGEN_Link *result = 0 ; (void)jenv; (void)jcls; result = (btGEN_Link *)new btGEN_Link(); *(btGEN_Link **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btGEN_1Link_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { jlong jresult = 0 ; btGEN_Link *arg1 = (btGEN_Link *) 0 ; btGEN_Link *arg2 = (btGEN_Link *) 0 ; btGEN_Link *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btGEN_Link **)&jarg1; arg2 = *(btGEN_Link **)&jarg2; result = (btGEN_Link *)new btGEN_Link(arg1,arg2); *(btGEN_Link **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1getNext(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btGEN_Link *arg1 = (btGEN_Link *) 0 ; btGEN_Link *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btGEN_Link **)&jarg1; result = (btGEN_Link *)((btGEN_Link const *)arg1)->getNext(); *(btGEN_Link **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1getPrev(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btGEN_Link *arg1 = (btGEN_Link *) 0 ; btGEN_Link *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btGEN_Link **)&jarg1; result = (btGEN_Link *)((btGEN_Link const *)arg1)->getPrev(); *(btGEN_Link **)&jresult = result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1isHead(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jboolean jresult = 0 ; btGEN_Link *arg1 = (btGEN_Link *) 0 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btGEN_Link **)&jarg1; result = (bool)((btGEN_Link const *)arg1)->isHead(); jresult = (jboolean)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1isTail(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jboolean jresult = 0 ; btGEN_Link *arg1 = (btGEN_Link *) 0 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btGEN_Link **)&jarg1; result = (bool)((btGEN_Link const *)arg1)->isTail(); jresult = (jboolean)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1insertBefore(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btGEN_Link *arg1 = (btGEN_Link *) 0 ; btGEN_Link *arg2 = (btGEN_Link *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btGEN_Link **)&jarg1; arg2 = *(btGEN_Link **)&jarg2; (arg1)->insertBefore(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1insertAfter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btGEN_Link *arg1 = (btGEN_Link *) 0 ; btGEN_Link *arg2 = (btGEN_Link *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btGEN_Link **)&jarg1; arg2 = *(btGEN_Link **)&jarg2; (arg1)->insertAfter(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1Link_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { btGEN_Link *arg1 = (btGEN_Link *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btGEN_Link **)&jarg1; (arg1)->remove(); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btGEN_1Link(JNIEnv *jenv, jclass jcls, jlong jarg1) { btGEN_Link *arg1 = (btGEN_Link *) 0 ; (void)jenv; (void)jcls; arg1 = *(btGEN_Link **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btGEN_1List(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btGEN_List *result = 0 ; (void)jenv; (void)jcls; result = (btGEN_List *)new btGEN_List(); *(btGEN_List **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1List_1getHead(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btGEN_List *arg1 = (btGEN_List *) 0 ; btGEN_Link *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btGEN_List **)&jarg1; result = (btGEN_Link *)((btGEN_List const *)arg1)->getHead(); *(btGEN_Link **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1List_1getTail(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btGEN_List *arg1 = (btGEN_List *) 0 ; btGEN_Link *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btGEN_List **)&jarg1; result = (btGEN_Link *)((btGEN_List const *)arg1)->getTail(); *(btGEN_Link **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1List_1addHead(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btGEN_List *arg1 = (btGEN_List *) 0 ; btGEN_Link *arg2 = (btGEN_Link *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btGEN_List **)&jarg1; arg2 = *(btGEN_Link **)&jarg2; (arg1)->addHead(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btGEN_1List_1addTail(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btGEN_List *arg1 = (btGEN_List *) 0 ; btGEN_Link *arg2 = (btGEN_Link *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btGEN_List **)&jarg1; arg2 = *(btGEN_Link **)&jarg2; (arg1)->addTail(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btGEN_1List(JNIEnv *jenv, jclass jcls, jlong jarg1) { btGEN_List *arg1 = (btGEN_List *) 0 ; (void)jenv; (void)jcls; arg1 = *(btGEN_List **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAlignedAllocInternal(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { jlong jresult = 0 ; size_t arg1 ; int arg2 ; void *result = 0 ; (void)jenv; (void)jcls; arg1 = (size_t)jarg1; arg2 = (int)jarg2; result = (void *)btAlignedAllocInternal(arg1,arg2); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAlignedFreeInternal(JNIEnv *jenv, jclass jcls, jlong jarg1) { void *arg1 = (void *) 0 ; (void)jenv; (void)jcls; arg1 = (void *)jarg1; btAlignedFreeInternal(arg1); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAlignedAllocSetCustom(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { btAllocFunc *arg1 = (btAllocFunc *) 0 ; btFreeFunc *arg2 = (btFreeFunc *) 0 ; (void)jenv; (void)jcls; arg1 = *(btAllocFunc **)&jarg1; arg2 = *(btFreeFunc **)&jarg2; btAlignedAllocSetCustom(arg1,arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btAlignedAllocSetCustomAligned(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { btAlignedAllocFunc *arg1 = (btAlignedAllocFunc *) 0 ; btAlignedFreeFunc *arg2 = (btAlignedFreeFunc *) 0 ; (void)jenv; (void)jcls; arg1 = *(btAlignedAllocFunc **)&jarg1; arg2 = *(btAlignedFreeFunc **)&jarg2; btAlignedAllocSetCustomAligned(arg1,arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1string_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { btHashString *arg1 = (btHashString *) 0 ; char *arg2 = (char *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btHashString **)&jarg1; arg2 = 0; if (jarg2) { arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); if (!arg2) return ; } { if (arg2) { arg1->m_string = (char const *) (new char[strlen((const char *)arg2)+1]); strcpy((char *)arg1->m_string, (const char *)arg2); } else { arg1->m_string = 0; } } if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); } SWIGEXPORT jstring JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1string_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jstring jresult = 0 ; btHashString *arg1 = (btHashString *) 0 ; char *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btHashString **)&jarg1; result = (char *) ((arg1)->m_string); if (result) jresult = jenv->NewStringUTF((const char *)result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { btHashString *arg1 = (btHashString *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btHashString **)&jarg1; arg2 = (unsigned int)jarg2; if (arg1) (arg1)->m_hash = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btHashString *arg1 = (btHashString *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btHashString **)&jarg1; result = (unsigned int) ((arg1)->m_hash); jresult = (jlong)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btHashString(JNIEnv *jenv, jclass jcls, jstring jarg1) { jlong jresult = 0 ; char *arg1 = (char *) 0 ; btHashString *result = 0 ; (void)jenv; (void)jcls; arg1 = 0; if (jarg1) { arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0); if (!arg1) return 0; } result = (btHashString *)new btHashString((char const *)arg1); *(btHashString **)&jresult = result; if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1); return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1portableStringCompare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) { jint jresult = 0 ; btHashString *arg1 = (btHashString *) 0 ; char *arg2 = (char *) 0 ; char *arg3 = (char *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btHashString **)&jarg1; arg2 = 0; if (jarg2) { arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); if (!arg2) return 0; } arg3 = 0; if (jarg3) { arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); if (!arg3) return 0; } result = (int)((btHashString const *)arg1)->portableStringCompare((char const *)arg2,(char const *)arg3); jresult = (jint)result; if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashString_1equals(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { jboolean jresult = 0 ; btHashString *arg1 = (btHashString *) 0 ; btHashString *arg2 = 0 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btHashString **)&jarg1; arg2 = *(btHashString **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btHashString const & reference is null"); return 0; } result = (bool)((btHashString const *)arg1)->equals((btHashString const &)*arg2); jresult = (jboolean)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btHashString(JNIEnv *jenv, jclass jcls, jlong jarg1) { btHashString *arg1 = (btHashString *) 0 ; (void)jenv; (void)jcls; arg1 = *(btHashString **)&jarg1; delete arg1; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_BT_1HASH_1NULL_1get(JNIEnv *jenv, jclass jcls) { jint jresult = 0 ; int result; (void)jenv; (void)jcls; result = (int)(int)BT_HASH_NULL; jresult = (jint)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btHashInt(JNIEnv *jenv, jclass jcls, jint jarg1) { jlong jresult = 0 ; int arg1 ; btHashInt *result = 0 ; (void)jenv; (void)jcls; arg1 = (int)jarg1; result = (btHashInt *)new btHashInt(arg1); *(btHashInt **)&jresult = result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashInt_1getUid1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btHashInt *arg1 = (btHashInt *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btHashInt **)&jarg1; result = (int)((btHashInt const *)arg1)->getUid1(); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashInt_1setUid1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { btHashInt *arg1 = (btHashInt *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btHashInt **)&jarg1; arg2 = (int)jarg2; (arg1)->setUid1(arg2); } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashInt_1equals(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { jboolean jresult = 0 ; btHashInt *arg1 = (btHashInt *) 0 ; btHashInt *arg2 = 0 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btHashInt **)&jarg1; arg2 = *(btHashInt **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btHashInt const & reference is null"); return 0; } result = (bool)((btHashInt const *)arg1)->equals((btHashInt const &)*arg2); jresult = (jboolean)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashInt_1getHash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btHashInt *arg1 = (btHashInt *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btHashInt **)&jarg1; result = (unsigned int)((btHashInt const *)arg1)->getHash(); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btHashInt(JNIEnv *jenv, jclass jcls, jlong jarg1) { btHashInt *arg1 = (btHashInt *) 0 ; (void)jenv; (void)jcls; arg1 = *(btHashInt **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btHashPtr(JNIEnv *jenv, jclass jcls, jlong jarg1) { jlong jresult = 0 ; void *arg1 = (void *) 0 ; btHashPtr *result = 0 ; (void)jenv; (void)jcls; arg1 = (void *)jarg1; result = (btHashPtr *)new btHashPtr((void const *)arg1); *(btHashPtr **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashPtr_1getPointer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btHashPtr *arg1 = (btHashPtr *) 0 ; void *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btHashPtr **)&jarg1; result = (void *)((btHashPtr const *)arg1)->getPointer(); jresult = (jlong)result; return jresult; } SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashPtr_1equals(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { jboolean jresult = 0 ; btHashPtr *arg1 = (btHashPtr *) 0 ; btHashPtr *arg2 = 0 ; bool result; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btHashPtr **)&jarg1; arg2 = *(btHashPtr **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btHashPtr const & reference is null"); return 0; } result = (bool)((btHashPtr const *)arg1)->equals((btHashPtr const &)*arg2); jresult = (jboolean)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btHashPtr_1getHash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btHashPtr *arg1 = (btHashPtr *) 0 ; unsigned int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btHashPtr **)&jarg1; result = (unsigned int)((btHashPtr const *)arg1)->getHash(); jresult = (jlong)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btHashPtr(JNIEnv *jenv, jclass jcls, jlong jarg1) { btHashPtr *arg1 = (btHashPtr *) 0 ; (void)jenv; (void)jcls; arg1 = *(btHashPtr **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btBlock_1previous_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btBlock *arg1 = (btBlock *) 0 ; btBlock *arg2 = (btBlock *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btBlock **)&jarg1; arg2 = *(btBlock **)&jarg2; if (arg1) (arg1)->previous = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btBlock_1previous_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btBlock *arg1 = (btBlock *) 0 ; btBlock *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btBlock **)&jarg1; result = (btBlock *) ((arg1)->previous); *(btBlock **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btBlock_1address_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btBlock *arg1 = (btBlock *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btBlock **)&jarg1; { arg2 = (unsigned char*)jenv->GetDirectBufferAddress(jarg2); if (arg2 == NULL) { SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct."); } } { if (arg2) { arg1->address = arg2; } else { arg1->address = 0; } } } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btBlock_1address_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btBlock *arg1 = (btBlock *) 0 ; unsigned char *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btBlock **)&jarg1; result = (unsigned char *) ((arg1)->address); *(unsigned char **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btBlock(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btBlock *result = 0 ; (void)jenv; (void)jcls; result = (btBlock *)new btBlock(); *(btBlock **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btBlock(JNIEnv *jenv, jclass jcls, jlong jarg1) { btBlock *arg1 = (btBlock *) 0 ; (void)jenv; (void)jcls; arg1 = *(btBlock **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btStackAlloc(JNIEnv *jenv, jclass jcls, jlong jarg1) { jlong jresult = 0 ; unsigned int arg1 ; btStackAlloc *result = 0 ; (void)jenv; (void)jcls; arg1 = (unsigned int)jarg1; result = (btStackAlloc *)new btStackAlloc(arg1); *(btStackAlloc **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btStackAlloc(JNIEnv *jenv, jclass jcls, jlong jarg1) { btStackAlloc *arg1 = (btStackAlloc *) 0 ; (void)jenv; (void)jcls; arg1 = *(btStackAlloc **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1create(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { btStackAlloc *arg1 = (btStackAlloc *) 0 ; unsigned int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btStackAlloc **)&jarg1; arg2 = (unsigned int)jarg2; (arg1)->create(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1destroy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { btStackAlloc *arg1 = (btStackAlloc *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btStackAlloc **)&jarg1; (arg1)->destroy(); } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1getAvailableMemory(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btStackAlloc *arg1 = (btStackAlloc *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btStackAlloc **)&jarg1; result = (int)((btStackAlloc const *)arg1)->getAvailableMemory(); jresult = (jint)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1allocate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { jobject jresult = 0 ; btStackAlloc *arg1 = (btStackAlloc *) 0 ; unsigned int arg2 ; unsigned char *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btStackAlloc **)&jarg1; arg2 = (unsigned int)jarg2; result = (unsigned char *)(arg1)->allocate(arg2); *(unsigned char **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1beginBlock(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btStackAlloc *arg1 = (btStackAlloc *) 0 ; btBlock *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btStackAlloc **)&jarg1; result = (btBlock *)(arg1)->beginBlock(); *(btBlock **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btStackAlloc_1endBlock(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btStackAlloc *arg1 = (btStackAlloc *) 0 ; btBlock *arg2 = (btBlock *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btStackAlloc **)&jarg1; arg2 = *(btBlock **)&jarg2; (arg1)->endBlock(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btMotionState(JNIEnv *jenv, jclass jcls, jlong jarg1) { btMotionState *arg1 = (btMotionState *) 0 ; (void)jenv; (void)jcls; arg1 = *(btMotionState **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btMotionState_1getWorldTransform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btMotionState *arg1 = (btMotionState *) 0 ; btTransform *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btMotionState **)&jarg1; btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); ((btMotionState const *)arg1)->getWorldTransform(*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btMotionState_1setWorldTransform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btMotionState *arg1 = (btMotionState *) 0 ; btTransform *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btMotionState **)&jarg1; btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); (arg1)->setWorldTransform((btTransform const &)*arg2); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btMotionState(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btMotionState *result = 0 ; (void)jenv; (void)jcls; result = (btMotionState *)new SwigDirector_btMotionState(jenv); *(btMotionState **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btMotionState_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) { btMotionState *obj = *((btMotionState **)&objarg); (void)jcls; SwigDirector_btMotionState *director = (SwigDirector_btMotionState *)(obj); if (director) { director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE)); } } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btMotionState_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) { btMotionState *obj = *((btMotionState **)&objarg); SwigDirector_btMotionState *director = (SwigDirector_btMotionState *)(obj); (void)jcls; if (director) { director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false); } } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1graphicsWorldTrans_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; btTransform *arg2 = (btTransform *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btDefaultMotionState **)&jarg1; arg2 = *(btTransform **)&jarg2; if (arg1) (arg1)->m_graphicsWorldTrans = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1graphicsWorldTrans_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; btTransform *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btDefaultMotionState **)&jarg1; result = (btTransform *)& ((arg1)->m_graphicsWorldTrans); *(btTransform **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1centerOfMassOffset_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; btTransform *arg2 = (btTransform *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btDefaultMotionState **)&jarg1; arg2 = *(btTransform **)&jarg2; if (arg1) (arg1)->m_centerOfMassOffset = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1centerOfMassOffset_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; btTransform *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btDefaultMotionState **)&jarg1; result = (btTransform *)& ((arg1)->m_centerOfMassOffset); *(btTransform **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1startWorldTrans_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; btTransform *arg2 = (btTransform *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btDefaultMotionState **)&jarg1; arg2 = *(btTransform **)&jarg2; if (arg1) (arg1)->m_startWorldTrans = *arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1startWorldTrans_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; btTransform *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btDefaultMotionState **)&jarg1; result = (btTransform *)& ((arg1)->m_startWorldTrans); *(btTransform **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1userPointer_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; void *arg2 = (void *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btDefaultMotionState **)&jarg1; arg2 = (void *)jarg2; if (arg1) (arg1)->m_userPointer = arg2; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1userPointer_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; void *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btDefaultMotionState **)&jarg1; result = (void *) ((arg1)->m_userPointer); jresult = (jlong)result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btDefaultMotionState_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { jlong jresult = 0 ; btTransform *arg1 = 0 ; btTransform *arg2 = 0 ; btDefaultMotionState *result = 0 ; (void)jenv; (void)jcls; btTransform local_arg1; gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btDefaultMotionState *)new btDefaultMotionState((btTransform const &)*arg1,(btTransform const &)*arg2); *(btDefaultMotionState **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btDefaultMotionState_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1) { jlong jresult = 0 ; btTransform *arg1 = 0 ; btDefaultMotionState *result = 0 ; (void)jenv; (void)jcls; btTransform local_arg1; gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1); arg1 = &local_arg1; gdxAutoCommitMatrix4 auto_commit_arg1(jenv, jarg1, &local_arg1); result = (btDefaultMotionState *)new btDefaultMotionState((btTransform const &)*arg1); *(btDefaultMotionState **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btDefaultMotionState_1_1SWIG_12(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btDefaultMotionState *result = 0 ; (void)jenv; (void)jcls; result = (btDefaultMotionState *)new btDefaultMotionState(); *(btDefaultMotionState **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1getGraphicsWorldTrans(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; btTransform *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btDefaultMotionState **)&jarg1; btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); btDefaultMotionState_getGraphicsWorldTrans(arg1,*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1getCenterOfMassOffset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; btTransform *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btDefaultMotionState **)&jarg1; btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); btDefaultMotionState_getCenterOfMassOffset(arg1,*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1getStartWorldTrans(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; btTransform *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btDefaultMotionState **)&jarg1; btTransform local_arg2; gdx_setbtTransformFromMatrix4(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitMatrix4 auto_commit_arg2(jenv, jarg2, &local_arg2); btDefaultMotionState_getStartWorldTrans(arg1,*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btDefaultMotionState(JNIEnv *jenv, jclass jcls, jlong jarg1) { btDefaultMotionState *arg1 = (btDefaultMotionState *) 0 ; (void)jenv; (void)jcls; arg1 = *(btDefaultMotionState **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3Array_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btAlignedObjectArray< btVector3 > *result = 0 ; (void)jenv; (void)jcls; result = (btAlignedObjectArray< btVector3 > *)new btAlignedObjectArray< btVector3 >(); *(btAlignedObjectArray< btVector3 > **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector3Array(JNIEnv *jenv, jclass jcls, jlong jarg1) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; (void)jenv; (void)jcls; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3Array_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = 0 ; btAlignedObjectArray< btVector3 > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; if (!arg1) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); return 0; } result = (btAlignedObjectArray< btVector3 > *)new btAlignedObjectArray< btVector3 >((btAlignedObjectArray< btVector3 > const &)*arg1); *(btAlignedObjectArray< btVector3 > **)&jresult = result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; result = (int)((btAlignedObjectArray< btVector3 > const *)arg1)->size(); jresult = (jint)result; return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1at_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { jobject jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; int arg2 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; arg2 = (int)jarg2; result = (btVector3 *) &((btAlignedObjectArray< btVector3 > const *)arg1)->at(arg2); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; (arg1)->clear(); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1pop_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; (arg1)->pop_back(); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1resizeNoInitialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; arg2 = (int)jarg2; (arg1)->resizeNoInitialize(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1resize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jobject jarg3) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; int arg2 ; btVector3 *arg3 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; arg2 = (int)jarg2; btVector3 local_arg3; gdx_setbtVector3FromVector3(jenv, local_arg3, jarg3); arg3 = &local_arg3; gdxAutoCommitVector3 auto_commit_arg3(jenv, jarg3, &local_arg3); (arg1)->resize(arg2,(btVector3 const &)*arg3); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1resize_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; arg2 = (int)jarg2; (arg1)->resize(arg2); } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1expandNonInitializing(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; result = (btVector3 *) &(arg1)->expandNonInitializing(); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1expand_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jobject jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; btVector3 *arg2 = 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (btVector3 *) &(arg1)->expand((btVector3 const &)*arg2); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1expand_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jobject jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; btVector3 *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; result = (btVector3 *) &(arg1)->expand(); jresult = gdx_getReturnVector3(jenv); gdx_setVector3FrombtVector3(jenv, jresult, result); return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; btVector3 *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); (arg1)->push_back((btVector3 const &)*arg2); } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; result = (int)((btAlignedObjectArray< btVector3 > const *)arg1)->capacity(); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; arg2 = (int)jarg2; (arg1)->reserve(arg2); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btVector3Array_1less(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btAlignedObjectArray< btVector3 >::less *result = 0 ; (void)jenv; (void)jcls; result = (btAlignedObjectArray< btVector3 >::less *)new btAlignedObjectArray< btVector3 >::less(); *(btAlignedObjectArray< btVector3 >::less **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btVector3Array_1less(JNIEnv *jenv, jclass jcls, jlong jarg1) { btAlignedObjectArray< btVector3 >::less *arg1 = (btAlignedObjectArray< btVector3 >::less *) 0 ; (void)jenv; (void)jcls; arg1 = *(btAlignedObjectArray< btVector3 >::less **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1swap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; int arg2 ; int arg3 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; arg2 = (int)jarg2; arg3 = (int)jarg3; (arg1)->swap(arg2,arg3); } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1findBinarySearch(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jint jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; btVector3 *arg2 = 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (int)((btAlignedObjectArray< btVector3 > const *)arg1)->findBinarySearch((btVector3 const &)*arg2); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1findLinearSearch(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { jint jresult = 0 ; btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; btVector3 *arg2 = 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); result = (int)((btAlignedObjectArray< btVector3 > const *)arg1)->findLinearSearch((btVector3 const &)*arg2); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; btVector3 *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; btVector3 local_arg2; gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2); arg2 = &local_arg2; gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2); (arg1)->remove((btVector3 const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1initializeFromBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; void *arg2 = (void *) 0 ; int arg3 ; int arg4 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; arg2 = (void *)jarg2; arg3 = (int)jarg3; arg4 = (int)jarg4; (arg1)->initializeFromBuffer(arg2,arg3,arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector3Array_1copyFromArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btAlignedObjectArray< btVector3 > *arg1 = (btAlignedObjectArray< btVector3 > *) 0 ; btAlignedObjectArray< btVector3 > *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btAlignedObjectArray< btVector3 > **)&jarg1; arg2 = *(btAlignedObjectArray< btVector3 > **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btVector3 > const & reference is null"); return ; } (arg1)->copyFromArray((btAlignedObjectArray< btVector3 > const &)*arg2); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btScalarArray_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btAlignedObjectArray< btScalar > *result = 0 ; (void)jenv; (void)jcls; result = (btAlignedObjectArray< btScalar > *)new btAlignedObjectArray< btScalar >(); *(btAlignedObjectArray< btScalar > **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btScalarArray(JNIEnv *jenv, jclass jcls, jlong jarg1) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; (void)jenv; (void)jcls; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; delete arg1; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btScalarArray_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btAlignedObjectArray< btScalar > *arg1 = 0 ; btAlignedObjectArray< btScalar > *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; if (!arg1) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btScalar > const & reference is null"); return 0; } result = (btAlignedObjectArray< btScalar > *)new btAlignedObjectArray< btScalar >((btAlignedObjectArray< btScalar > const &)*arg1); *(btAlignedObjectArray< btScalar > **)&jresult = result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; result = (int)((btAlignedObjectArray< btScalar > const *)arg1)->size(); jresult = (jint)result; return jresult; } SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1at_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { jfloat jresult = 0 ; btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; int arg2 ; float *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; arg2 = (int)jarg2; result = (float *) &((btAlignedObjectArray< btScalar > const *)arg1)->at(arg2); jresult = (jfloat)*result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; (arg1)->clear(); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1pop_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; (arg1)->pop_back(); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1resizeNoInitialize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; arg2 = (int)jarg2; (arg1)->resizeNoInitialize(arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1resize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jfloat jarg3) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; int arg2 ; float *arg3 = 0 ; float temp3 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; arg2 = (int)jarg2; temp3 = (float)jarg3; arg3 = &temp3; (arg1)->resize(arg2,(float const &)*arg3); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1resize_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; arg2 = (int)jarg2; (arg1)->resize(arg2); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1expandNonInitializing(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; float *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; result = (float *) &(arg1)->expandNonInitializing(); *(float **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1expand_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { jlong jresult = 0 ; btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; float *arg2 = 0 ; float temp2 ; float *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; temp2 = (float)jarg2; arg2 = &temp2; result = (float *) &(arg1)->expand((float const &)*arg2); *(float **)&jresult = result; return jresult; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1expand_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; float *result = 0 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; result = (float *) &(arg1)->expand(); *(float **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; float *arg2 = 0 ; float temp2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; temp2 = (float)jarg2; arg2 = &temp2; (arg1)->push_back((float const &)*arg2); } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jint jresult = 0 ; btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; result = (int)((btAlignedObjectArray< btScalar > const *)arg1)->capacity(); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; int arg2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; arg2 = (int)jarg2; (arg1)->reserve(arg2); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_new_1btScalarArray_1less(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; btAlignedObjectArray< btScalar >::less *result = 0 ; (void)jenv; (void)jcls; result = (btAlignedObjectArray< btScalar >::less *)new btAlignedObjectArray< btScalar >::less(); *(btAlignedObjectArray< btScalar >::less **)&jresult = result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_delete_1btScalarArray_1less(JNIEnv *jenv, jclass jcls, jlong jarg1) { btAlignedObjectArray< btScalar >::less *arg1 = (btAlignedObjectArray< btScalar >::less *) 0 ; (void)jenv; (void)jcls; arg1 = *(btAlignedObjectArray< btScalar >::less **)&jarg1; delete arg1; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1swap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; int arg2 ; int arg3 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; arg2 = (int)jarg2; arg3 = (int)jarg3; (arg1)->swap(arg2,arg3); } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1findBinarySearch(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { jint jresult = 0 ; btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; float *arg2 = 0 ; float temp2 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; temp2 = (float)jarg2; arg2 = &temp2; result = (int)((btAlignedObjectArray< btScalar > const *)arg1)->findBinarySearch((float const &)*arg2); jresult = (jint)result; return jresult; } SWIGEXPORT jint JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1findLinearSearch(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { jint jresult = 0 ; btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; float *arg2 = 0 ; float temp2 ; int result; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; temp2 = (float)jarg2; arg2 = &temp2; result = (int)((btAlignedObjectArray< btScalar > const *)arg1)->findLinearSearch((float const &)*arg2); jresult = (jint)result; return jresult; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; float *arg2 = 0 ; float temp2 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; temp2 = (float)jarg2; arg2 = &temp2; (arg1)->remove((float const &)*arg2); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1initializeFromBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; void *arg2 = (void *) 0 ; int arg3 ; int arg4 ; (void)jenv; (void)jcls; (void)jarg1_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; arg2 = (void *)jarg2; arg3 = (int)jarg3; arg4 = (int)jarg4; (arg1)->initializeFromBuffer(arg2,arg3,arg4); } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btScalarArray_1copyFromArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { btAlignedObjectArray< btScalar > *arg1 = (btAlignedObjectArray< btScalar > *) 0 ; btAlignedObjectArray< btScalar > *arg2 = 0 ; (void)jenv; (void)jcls; (void)jarg1_; (void)jarg2_; arg1 = *(btAlignedObjectArray< btScalar > **)&jarg1; arg2 = *(btAlignedObjectArray< btScalar > **)&jarg2; if (!arg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btAlignedObjectArray< btScalar > const & reference is null"); return ; } (arg1)->copyFromArray((btAlignedObjectArray< btScalar > const &)*arg2); } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btVector4_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) { jlong baseptr = 0; (void)jenv; (void)jcls; *(btVector3 **)&baseptr = *(btVector4 **)&jarg1; return baseptr; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_GrahamVector3_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) { jlong baseptr = 0; (void)jenv; (void)jcls; *(btVector3 **)&baseptr = *(GrahamVector3 **)&jarg1; return baseptr; } SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_btDefaultMotionState_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) { jlong baseptr = 0; (void)jenv; (void)jcls; *(btMotionState **)&baseptr = *(btDefaultMotionState **)&jarg1; return baseptr; } SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_linearmath_LinearMathJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) { int i; static struct { const char *method; const char *signature; } methods[29] = { { "SwigDirector_btIDebugDraw_getDefaultColors", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;)J" }, { "SwigDirector_btIDebugDraw_setDefaultColors", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;J)V" }, { "SwigDirector_btIDebugDraw_drawLine__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawLine__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawSphere__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;FLcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawSphere__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;FLcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawTriangle__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;F)V" }, { "SwigDirector_btIDebugDraw_drawTriangle__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;F)V" }, { "SwigDirector_btIDebugDraw_drawContactPoint", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FILcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_reportErrorWarning", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Ljava/lang/String;)V" }, { "SwigDirector_btIDebugDraw_draw3dText", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Ljava/lang/String;)V" }, { "SwigDirector_btIDebugDraw_setDebugMode", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;I)V" }, { "SwigDirector_btIDebugDraw_getDebugMode", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;)I" }, { "SwigDirector_btIDebugDraw_drawAabb", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawTransform", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Matrix4;F)V" }, { "SwigDirector_btIDebugDraw_drawArc__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFLcom/badlogic/gdx/math/Vector3;ZF)V" }, { "SwigDirector_btIDebugDraw_drawArc__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFLcom/badlogic/gdx/math/Vector3;Z)V" }, { "SwigDirector_btIDebugDraw_drawSpherePatch__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;FZ)V" }, { "SwigDirector_btIDebugDraw_drawSpherePatch__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;F)V" }, { "SwigDirector_btIDebugDraw_drawSpherePatch__SWIG_2", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;FFFFFLcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawBox__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawBox__SWIG_1", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Vector3;Lcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawCapsule", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawCylinder", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawCone", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;FFILcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_drawPlane", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;Lcom/badlogic/gdx/math/Vector3;FLcom/badlogic/gdx/math/Matrix4;Lcom/badlogic/gdx/math/Vector3;)V" }, { "SwigDirector_btIDebugDraw_flushLines", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btIDebugDraw;)V" }, { "SwigDirector_btMotionState_getWorldTransform", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btMotionState;Lcom/badlogic/gdx/math/Matrix4;)V" }, { "SwigDirector_btMotionState_setWorldTransform", "(Lcom/badlogic/gdx/physics/bullet/linearmath/btMotionState;Lcom/badlogic/gdx/math/Matrix4;)V" } }; Swig::jclass_LinearMathJNI = (jclass) jenv->NewGlobalRef(jcls); if (!Swig::jclass_LinearMathJNI) return; for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) { Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature); if (!Swig::director_method_ids[i]) return; } } #ifdef __cplusplus } #endif