extensions/gdx-bullet/jni/swig-src/com/badlogic/gdx/physics/bullet/gdxBullet.java

   1 /* ----------------------------------------------------------------------------\r
   2  * This file was automatically generated by SWIG (http://www.swig.org).\r
   3  * Version 2.0.10\r
   4  *\r
   5  * Do not make changes to this file unless you know what you are doing--modify\r
   6  * the SWIG interface file instead.\r
   7  * ----------------------------------------------------------------------------- */\r
   8 \r
   9 package com.badlogic.gdx.physics.bullet;\r
  10 \r
  11 import com.badlogic.gdx.math.Vector3;\r
  12 import com.badlogic.gdx.math.Quaternion;\r
  13 import com.badlogic.gdx.math.Matrix3;\r
  14 import com.badlogic.gdx.math.Matrix4;\r
  15 \r
  16 public class gdxBullet implements gdxBulletConstants {\r
  17   public static int btGetVersion() {\r
  18     return gdxBulletJNI.btGetVersion();\r
  19   }\r
  20 \r
  21   public static float btSqrt(float y) {\r
  22     return gdxBulletJNI.btSqrt(y);\r
  23   }\r
  24 \r
  25   public static float btFabs(float x) {\r
  26     return gdxBulletJNI.btFabs(x);\r
  27   }\r
  28 \r
  29   public static float btCos(float x) {\r
  30     return gdxBulletJNI.btCos(x);\r
  31   }\r
  32 \r
  33   public static float btSin(float x) {\r
  34     return gdxBulletJNI.btSin(x);\r
  35   }\r
  36 \r
  37   public static float btTan(float x) {\r
  38     return gdxBulletJNI.btTan(x);\r
  39   }\r
  40 \r
  41   public static float btAcos(float x) {\r
  42     return gdxBulletJNI.btAcos(x);\r
  43   }\r
  44 \r
  45   public static float btAsin(float x) {\r
  46     return gdxBulletJNI.btAsin(x);\r
  47   }\r
  48 \r
  49   public static float btAtan(float x) {\r
  50     return gdxBulletJNI.btAtan(x);\r
  51   }\r
  52 \r
  53   public static float btAtan2(float x, float y) {\r
  54     return gdxBulletJNI.btAtan2(x, y);\r
  55   }\r
  56 \r
  57   public static float btExp(float x) {\r
  58     return gdxBulletJNI.btExp(x);\r
  59   }\r
  60 \r
  61   public static float btLog(float x) {\r
  62     return gdxBulletJNI.btLog(x);\r
  63   }\r
  64 \r
  65   public static float btPow(float x, float y) {\r
  66     return gdxBulletJNI.btPow(x, y);\r
  67   }\r
  68 \r
  69   public static float btFmod(float x, float y) {\r
  70     return gdxBulletJNI.btFmod(x, y);\r
  71   }\r
  72 \r
  73   public static float btAtan2Fast(float y, float x) {\r
  74     return gdxBulletJNI.btAtan2Fast(y, x);\r
  75   }\r
  76 \r
  77   public static boolean btFuzzyZero(float x) {\r
  78     return gdxBulletJNI.btFuzzyZero(x);\r
  79   }\r
  80 \r
  81   public static boolean btEqual(float a, float eps) {\r
  82     return gdxBulletJNI.btEqual(a, eps);\r
  83   }\r
  84 \r
  85   public static boolean btGreaterEqual(float a, float eps) {\r
  86     return gdxBulletJNI.btGreaterEqual(a, eps);\r
  87   }\r
  88 \r
  89   public static int btIsNegative(float x) {\r
  90     return gdxBulletJNI.btIsNegative(x);\r
  91   }\r
  92 \r
  93   public static float btRadians(float x) {\r
  94     return gdxBulletJNI.btRadians(x);\r
  95   }\r
  96 \r
  97   public static float btDegrees(float x) {\r
  98     return gdxBulletJNI.btDegrees(x);\r
  99   }\r
 100 \r
 101   public static float btFsel(float a, float b, float c) {\r
 102     return gdxBulletJNI.btFsel(a, b, c);\r
 103   }\r
 104 \r
 105   public static boolean btMachineIsLittleEndian() {\r
 106     return gdxBulletJNI.btMachineIsLittleEndian();\r
 107   }\r
 108 \r
 109   public static long btSelect(long condition, long valueIfConditionNonZero, long valueIfConditionZero) {\r
 110     return gdxBulletJNI.btSelect__SWIG_0(condition, valueIfConditionNonZero, valueIfConditionZero);\r
 111   }\r
 112 \r
 113   public static int btSelect(long condition, int valueIfConditionNonZero, int valueIfConditionZero) {\r
 114     return gdxBulletJNI.btSelect__SWIG_1(condition, valueIfConditionNonZero, valueIfConditionZero);\r
 115   }\r
 116 \r
 117   public static float btSelect(long condition, float valueIfConditionNonZero, float valueIfConditionZero) {\r
 118     return gdxBulletJNI.btSelect__SWIG_2(condition, valueIfConditionNonZero, valueIfConditionZero);\r
 119   }\r
 120 \r
 121   public static long btSwapEndian(long val) {\r
 122     return gdxBulletJNI.btSwapEndian__SWIG_0(val);\r
 123   }\r
 124 \r
 125   public static int btSwapEndian(int val) {\r
 126     return gdxBulletJNI.btSwapEndian__SWIG_1(val);\r
 127   }\r
 128 \r
 129   public static int btSwapEndian(short val) {\r
 130     return gdxBulletJNI.btSwapEndian__SWIG_3(val);\r
 131   }\r
 132 \r
 133   public static long btSwapEndianFloat(float d) {\r
 134     return gdxBulletJNI.btSwapEndianFloat(d);\r
 135   }\r
 136 \r
 137   public static float btUnswapEndianFloat(long a) {\r
 138     return gdxBulletJNI.btUnswapEndianFloat(a);\r
 139   }\r
 140 \r
 141   public static void btSwapEndianDouble(double d, java.nio.ByteBuffer dst) {\r
 142     assert dst.isDirect() : "Buffer must be allocated direct.";\r
 143     {\r
 144       gdxBulletJNI.btSwapEndianDouble(d, dst);\r
 145     }\r
 146   }\r
 147 \r
 148   public static double btUnswapEndianDouble(java.nio.ByteBuffer src) {\r
 149     assert src.isDirect() : "Buffer must be allocated direct.";\r
 150     {\r
 151       return gdxBulletJNI.btUnswapEndianDouble(src);\r
 152     }\r
 153   }\r
 154 \r
 155   public static float btNormalizeAngle(float angleInRadians) {\r
 156     return gdxBulletJNI.btNormalizeAngle(angleInRadians);\r
 157   }\r
 158 \r
 159   public static float btDot(Vector3 v1, Vector3 v2) {\r
 160     return gdxBulletJNI.btDot(v1, v2);\r
 161   }\r
 162 \r
 163   public static float btDistance2(Vector3 v1, Vector3 v2) {\r
 164     return gdxBulletJNI.btDistance2(v1, v2);\r
 165   }\r
 166 \r
 167   public static float btDistance(Vector3 v1, Vector3 v2) {\r
 168     return gdxBulletJNI.btDistance(v1, v2);\r
 169   }\r
 170 \r
 171   public static float btAngle(Vector3 v1, Vector3 v2) {\r
 172     return gdxBulletJNI.btAngle__SWIG_0(v1, v2);\r
 173   }\r
 174 \r
 175   public static Vector3 btCross(Vector3 v1, Vector3 v2) {\r
 176         return gdxBulletJNI.btCross(v1, v2);\r
 177 }\r
 178 \r
 179   public static float btTriple(Vector3 v1, Vector3 v2, Vector3 v3) {\r
 180     return gdxBulletJNI.btTriple(v1, v2, v3);\r
 181   }\r
 182 \r
 183   public static Vector3 lerp(Vector3 v1, Vector3 v2, float t) {\r
 184         return gdxBulletJNI.lerp(v1, v2, t);\r
 185 }\r
 186 \r
 187   public static void btSwapScalarEndian(float sourceVal, SWIGTYPE_p_float destVal) {\r
 188     gdxBulletJNI.btSwapScalarEndian(sourceVal, SWIGTYPE_p_float.getCPtr(destVal));\r
 189   }\r
 190 \r
 191   public static void btSwapVector3Endian(Vector3 sourceVec, Vector3 destVec) {\r
 192     gdxBulletJNI.btSwapVector3Endian(sourceVec, destVec);\r
 193   }\r
 194 \r
 195   public static void btUnSwapVector3Endian(Vector3 vector) {\r
 196     gdxBulletJNI.btUnSwapVector3Endian(vector);\r
 197   }\r
 198 \r
 199   public static float dot(Quaternion q1, Quaternion q2) {\r
 200     return gdxBulletJNI.dot(q1, q2);\r
 201   }\r
 202 \r
 203   public static float length(Quaternion q) {\r
 204     return gdxBulletJNI.length(q);\r
 205   }\r
 206 \r
 207   public static float btAngle(Quaternion q1, Quaternion q2) {\r
 208     return gdxBulletJNI.btAngle__SWIG_1(q1, q2);\r
 209   }\r
 210 \r
 211   public static Quaternion inverse(Quaternion q) {\r
 212         return gdxBulletJNI.inverse(q);\r
 213 }\r
 214 \r
 215   public static Quaternion slerp(Quaternion q1, Quaternion q2, float t) {\r
 216         return gdxBulletJNI.slerp(q1, q2, t);\r
 217 }\r
 218 \r
 219   public static Vector3 quatRotate(Quaternion rotation, Vector3 v) {\r
 220         return gdxBulletJNI.quatRotate(rotation, v);\r
 221 }\r
 222 \r
 223   public static Quaternion shortestArcQuat(Vector3 v0, Vector3 v1) {\r
 224         return gdxBulletJNI.shortestArcQuat(v0, v1);\r
 225 }\r
 226 \r
 227   public static Quaternion shortestArcQuatNormalize2(Vector3 v0, Vector3 v1) {\r
 228         return gdxBulletJNI.shortestArcQuatNormalize2(v0, v1);\r
 229 }\r
 230 \r
 231   public static void AabbExpand(Vector3 aabbMin, Vector3 aabbMax, Vector3 expansionMin, Vector3 expansionMax) {\r
 232     gdxBulletJNI.AabbExpand(aabbMin, aabbMax, expansionMin, expansionMax);\r
 233   }\r
 234 \r
 235   public static boolean TestPointAgainstAabb2(Vector3 aabbMin1, Vector3 aabbMax1, Vector3 point) {\r
 236     return gdxBulletJNI.TestPointAgainstAabb2(aabbMin1, aabbMax1, point);\r
 237   }\r
 238 \r
 239   public static boolean TestAabbAgainstAabb2(Vector3 aabbMin1, Vector3 aabbMax1, Vector3 aabbMin2, Vector3 aabbMax2) {\r
 240     return gdxBulletJNI.TestAabbAgainstAabb2(aabbMin1, aabbMax1, aabbMin2, aabbMax2);\r
 241   }\r
 242 \r
 243   public static boolean TestTriangleAgainstAabb2(btVector3 vertices, Vector3 aabbMin, Vector3 aabbMax) {\r
 244     return gdxBulletJNI.TestTriangleAgainstAabb2(btVector3.getCPtr(vertices), vertices, aabbMin, aabbMax);\r
 245   }\r
 246 \r
 247   public static int btOutcode(Vector3 p, Vector3 halfExtent) {\r
 248     return gdxBulletJNI.btOutcode(p, halfExtent);\r
 249   }\r
 250 \r
 251   public static boolean btRayAabb2(Vector3 rayFrom, Vector3 rayInvDirection, long[] raySign, btVector3 bounds, SWIGTYPE_p_float tmin, float lambda_min, float lambda_max) {\r
 252     return gdxBulletJNI.btRayAabb2(rayFrom, rayInvDirection, raySign, btVector3.getCPtr(bounds), bounds, SWIGTYPE_p_float.getCPtr(tmin), lambda_min, lambda_max);\r
 253   }\r
 254 \r
 255   public static boolean btRayAabb(Vector3 rayFrom, Vector3 rayTo, Vector3 aabbMin, Vector3 aabbMax, SWIGTYPE_p_float param, Vector3 normal) {\r
 256     return gdxBulletJNI.btRayAabb(rayFrom, rayTo, aabbMin, aabbMax, SWIGTYPE_p_float.getCPtr(param), normal);\r
 257   }\r
 258 \r
 259   public static void btTransformAabb(Vector3 halfExtents, float margin, Matrix4 t, Vector3 aabbMinOut, Vector3 aabbMaxOut) {\r
 260     gdxBulletJNI.btTransformAabb__SWIG_0(halfExtents, margin, t, aabbMinOut, aabbMaxOut);\r
 261   }\r
 262 \r
 263   public static void btTransformAabb(Vector3 localAabbMin, Vector3 localAabbMax, float margin, Matrix4 trans, Vector3 aabbMinOut, Vector3 aabbMaxOut) {\r
 264     gdxBulletJNI.btTransformAabb__SWIG_1(localAabbMin, localAabbMax, margin, trans, aabbMinOut, aabbMaxOut);\r
 265   }\r
 266 \r
 267   public static long testQuantizedAabbAgainstQuantizedAabb(java.nio.IntBuffer aabbMin1, java.nio.IntBuffer aabbMax1, java.nio.IntBuffer aabbMin2, java.nio.IntBuffer aabbMax2) {\r
 268     assert aabbMin1.isDirect() : "Buffer must be allocated direct.";\r
 269     assert aabbMax1.isDirect() : "Buffer must be allocated direct.";\r
 270     assert aabbMin2.isDirect() : "Buffer must be allocated direct.";\r
 271     assert aabbMax2.isDirect() : "Buffer must be allocated direct.";\r
 272     {\r
 273       return gdxBulletJNI.testQuantizedAabbAgainstQuantizedAabb(aabbMin1, aabbMax1, aabbMin2, aabbMax2);\r
 274     }\r
 275   }\r
 276 \r
 277   public static void GEN_srand(long seed) {\r
 278     gdxBulletJNI.GEN_srand(seed);\r
 279   }\r
 280 \r
 281   public static long GEN_rand() {\r
 282     return gdxBulletJNI.GEN_rand();\r
 283   }\r
 284 \r
 285   public static Vector3 btAabbSupport(Vector3 halfExtents, Vector3 supportDir) {\r
 286         return gdxBulletJNI.btAabbSupport(halfExtents, supportDir);\r
 287 }\r
 288 \r
 289   public static void GrahamScanConvexHull2D(SWIGTYPE_p_btAlignedObjectArrayT_GrahamVector3_t originalPoints, SWIGTYPE_p_btAlignedObjectArrayT_GrahamVector3_t hull, Vector3 normalAxis) {\r
 290     gdxBulletJNI.GrahamScanConvexHull2D(SWIGTYPE_p_btAlignedObjectArrayT_GrahamVector3_t.getCPtr(originalPoints), SWIGTYPE_p_btAlignedObjectArrayT_GrahamVector3_t.getCPtr(hull), normalAxis);\r
 291   }\r
 292 \r
 293   public static SWIGTYPE_p_void btAlignedAllocInternal(long size, int alignment) {\r
 294     long cPtr = gdxBulletJNI.btAlignedAllocInternal(size, alignment);\r
 295     return (cPtr == 0) ? null : new SWIGTYPE_p_void(cPtr, false);\r
 296   }\r
 297 \r
 298   public static void btAlignedFreeInternal(SWIGTYPE_p_void ptr) {\r
 299     gdxBulletJNI.btAlignedFreeInternal(SWIGTYPE_p_void.getCPtr(ptr));\r
 300   }\r
 301 \r
 302   public static void btAlignedAllocSetCustom(SWIGTYPE_p_f_size_t__p_void allocFunc, SWIGTYPE_p_f_p_void__void freeFunc) {\r
 303     gdxBulletJNI.btAlignedAllocSetCustom(SWIGTYPE_p_f_size_t__p_void.getCPtr(allocFunc), SWIGTYPE_p_f_p_void__void.getCPtr(freeFunc));\r
 304   }\r
 305 \r
 306   public static void btAlignedAllocSetCustomAligned(SWIGTYPE_p_f_size_t_int__p_void allocFunc, SWIGTYPE_p_f_p_void__void freeFunc) {\r
 307     gdxBulletJNI.btAlignedAllocSetCustomAligned(SWIGTYPE_p_f_size_t_int__p_void.getCPtr(allocFunc), SWIGTYPE_p_f_p_void__void.getCPtr(freeFunc));\r
 308   }\r
 309 \r
 310   public static int getBT_HASH_NULL() {\r
 311     return gdxBulletJNI.BT_HASH_NULL_get();\r
 312   }\r
 313 \r
 314   public static boolean Intersect(btDbvtAabbMm a, btDbvtAabbMm b) {\r
 315     return gdxBulletJNI.Intersect__SWIG_0(btDbvtAabbMm.getCPtr(a), a, btDbvtAabbMm.getCPtr(b), b);\r
 316   }\r
 317 \r
 318   public static boolean Intersect(btDbvtAabbMm a, Vector3 b) {\r
 319     return gdxBulletJNI.Intersect__SWIG_1(btDbvtAabbMm.getCPtr(a), a, b);\r
 320   }\r
 321 \r
 322   public static float Proximity(btDbvtAabbMm a, btDbvtAabbMm b) {\r
 323     return gdxBulletJNI.Proximity(btDbvtAabbMm.getCPtr(a), a, btDbvtAabbMm.getCPtr(b), b);\r
 324   }\r
 325 \r
 326   public static int Select(btDbvtAabbMm o, btDbvtAabbMm a, btDbvtAabbMm b) {\r
 327     return gdxBulletJNI.Select(btDbvtAabbMm.getCPtr(o), o, btDbvtAabbMm.getCPtr(a), a, btDbvtAabbMm.getCPtr(b), b);\r
 328   }\r
 329 \r
 330   public static void Merge(btDbvtAabbMm a, btDbvtAabbMm b, btDbvtAabbMm r) {\r
 331     gdxBulletJNI.Merge(btDbvtAabbMm.getCPtr(a), a, btDbvtAabbMm.getCPtr(b), b, btDbvtAabbMm.getCPtr(r), r);\r
 332   }\r
 333 \r
 334   public static boolean NotEqual(btDbvtAabbMm a, btDbvtAabbMm b) {\r
 335     return gdxBulletJNI.NotEqual(btDbvtAabbMm.getCPtr(a), a, btDbvtAabbMm.getCPtr(b), b);\r
 336   }\r
 337 \r
 338   public static void setGOverlappingPairs(int value) {\r
 339     gdxBulletJNI.gOverlappingPairs_set(value);\r
 340   }\r
 341 \r
 342   public static int getGOverlappingPairs() {\r
 343     return gdxBulletJNI.gOverlappingPairs_get();\r
 344   }\r
 345 \r
 346   public static void setGRemovePairs(int value) {\r
 347     gdxBulletJNI.gRemovePairs_set(value);\r
 348   }\r
 349 \r
 350   public static int getGRemovePairs() {\r
 351     return gdxBulletJNI.gRemovePairs_get();\r
 352   }\r
 353 \r
 354   public static void setGAddedPairs(int value) {\r
 355     gdxBulletJNI.gAddedPairs_set(value);\r
 356   }\r
 357 \r
 358   public static int getGAddedPairs() {\r
 359     return gdxBulletJNI.gAddedPairs_get();\r
 360   }\r
 361 \r
 362   public static void setGFindPairs(int value) {\r
 363     gdxBulletJNI.gFindPairs_set(value);\r
 364   }\r
 365 \r
 366   public static int getGFindPairs() {\r
 367     return gdxBulletJNI.gFindPairs_get();\r
 368   }\r
 369 \r
 370   public static int getBT_NULL_PAIR() {\r
 371     return gdxBulletJNI.BT_NULL_PAIR_get();\r
 372   }\r
 373 \r
 374   public static boolean gdxCheckFilter(int filter, int flag) {\r
 375     return gdxBulletJNI.gdxCheckFilter__SWIG_0(filter, flag);\r
 376   }\r
 377 \r
 378   public static boolean gdxCheckFilter(btCollisionObject colObj0, btCollisionObject colObj1) {\r
 379     return gdxBulletJNI.gdxCheckFilter__SWIG_1(btCollisionObject.getCPtr(colObj0), colObj0, btCollisionObject.getCPtr(colObj1), colObj1);\r
 380   }\r
 381 \r
 382   public static void setGContactAddedCallback(SWIGTYPE_p_f_r_btManifoldPoint_p_q_const__btCollisionObjectWrapper_int_int_p_q_const__btCollisionObjectWrapper_int_int__bool value) {\r
 383     gdxBulletJNI.gContactAddedCallback_set(SWIGTYPE_p_f_r_btManifoldPoint_p_q_const__btCollisionObjectWrapper_int_int_p_q_const__btCollisionObjectWrapper_int_int__bool.getCPtr(value));\r
 384   }\r
 385 \r
 386   public static SWIGTYPE_p_f_r_btManifoldPoint_p_q_const__btCollisionObjectWrapper_int_int_p_q_const__btCollisionObjectWrapper_int_int__bool getGContactAddedCallback() {\r
 387     long cPtr = gdxBulletJNI.gContactAddedCallback_get();\r
 388     return (cPtr == 0) ? null : new SWIGTYPE_p_f_r_btManifoldPoint_p_q_const__btCollisionObjectWrapper_int_int_p_q_const__btCollisionObjectWrapper_int_int__bool(cPtr, false);\r
 389   }\r
 390 \r
 391   public static void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape trimeshShape, btTriangleInfoMap triangleInfoMap) {\r
 392     gdxBulletJNI.btGenerateInternalEdgeInfo(btBvhTriangleMeshShape.getCPtr(trimeshShape), trimeshShape, btTriangleInfoMap.getCPtr(triangleInfoMap), triangleInfoMap);\r
 393   }\r
 394 \r
 395   public static void btAdjustInternalEdgeContacts(btManifoldPoint cp, btCollisionObjectWrapper trimeshColObj0Wrap, btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0, int normalAdjustFlags) {\r
 396     gdxBulletJNI.btAdjustInternalEdgeContacts__SWIG_0(btManifoldPoint.getCPtr(cp), cp, btCollisionObjectWrapper.getCPtr(trimeshColObj0Wrap), trimeshColObj0Wrap, btCollisionObjectWrapper.getCPtr(otherColObj1Wrap), otherColObj1Wrap, partId0, index0, normalAdjustFlags);\r
 397   }\r
 398 \r
 399   public static void btAdjustInternalEdgeContacts(btManifoldPoint cp, btCollisionObjectWrapper trimeshColObj0Wrap, btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0) {\r
 400     gdxBulletJNI.btAdjustInternalEdgeContacts__SWIG_1(btManifoldPoint.getCPtr(cp), cp, btCollisionObjectWrapper.getCPtr(trimeshColObj0Wrap), trimeshColObj0Wrap, btCollisionObjectWrapper.getCPtr(otherColObj1Wrap), otherColObj1Wrap, partId0, index0);\r
 401   }\r
 402 \r
 403   public static void setGContactBreakingThreshold(float value) {\r
 404     gdxBulletJNI.gContactBreakingThreshold_set(value);\r
 405   }\r
 406 \r
 407   public static float getGContactBreakingThreshold() {\r
 408     return gdxBulletJNI.gContactBreakingThreshold_get();\r
 409   }\r
 410 \r
 411   public static void setGDeactivationTime(float value) {\r
 412     gdxBulletJNI.gDeactivationTime_set(value);\r
 413   }\r
 414 \r
 415   public static float getGDeactivationTime() {\r
 416     return gdxBulletJNI.gDeactivationTime_get();\r
 417   }\r
 418 \r
 419   public static void setGDisableDeactivation(boolean value) {\r
 420     gdxBulletJNI.gDisableDeactivation_set(value);\r
 421   }\r
 422 \r
 423   public static boolean getGDisableDeactivation() {\r
 424     return gdxBulletJNI.gDisableDeactivation_get();\r
 425   }\r
 426 \r
 427   public static float btAdjustAngleToLimits(float angleInRadians, float angleLowerLimitInRadians, float angleUpperLimitInRadians) {\r
 428     return gdxBulletJNI.btAdjustAngleToLimits(angleInRadians, angleLowerLimitInRadians, angleUpperLimitInRadians);\r
 429   }\r
 430 \r
 431   public static void InternalTickCallback_CB(btDynamicsWorld world, float timeStep) {\r
 432     gdxBulletJNI.InternalTickCallback_CB(btDynamicsWorld.getCPtr(world), world, timeStep);\r
 433   }\r
 434 \r
 435   public static float resolveSingleCollision(btRigidBody body1, btCollisionObject colObj2, Vector3 contactPositionWorld, Vector3 contactNormalOnB, btContactSolverInfo solverInfo, float distance) {\r
 436     return gdxBulletJNI.resolveSingleCollision(btRigidBody.getCPtr(body1), body1, btCollisionObject.getCPtr(colObj2), colObj2, contactPositionWorld, contactNormalOnB, btContactSolverInfo.getCPtr(solverInfo), solverInfo, distance);\r
 437   }\r
 438 \r
 439   public static void resolveSingleBilateral(btRigidBody body1, Vector3 pos1, btRigidBody body2, Vector3 pos2, float distance, Vector3 normal, SWIGTYPE_p_float impulse, float timeStep) {\r
 440     gdxBulletJNI.resolveSingleBilateral(btRigidBody.getCPtr(body1), body1, pos1, btRigidBody.getCPtr(body2), body2, pos2, distance, normal, SWIGTYPE_p_float.getCPtr(impulse), timeStep);\r
 441   }\r
 442 \r
 443   public static Matrix3 Lerp(Matrix3 a, Matrix3 b, float t) {\r
 444         return gdxBulletJNI.Lerp(a, b, t);\r
 445 }\r
 446 \r
 447   public static Vector3 Clamp(Vector3 v, float maxlength) {\r
 448         return gdxBulletJNI.Clamp(v, maxlength);\r
 449 }\r
 450 \r
 451   public static float ClusterMetric(Vector3 x, Vector3 y) {\r
 452     return gdxBulletJNI.ClusterMetric(x, y);\r
 453   }\r
 454 \r
 455   public static Matrix3 ScaleAlongAxis(Vector3 a, float s) {\r
 456         return gdxBulletJNI.ScaleAlongAxis(a, s);\r
 457 }\r
 458 \r
 459   public static Matrix3 Cross(Vector3 v) {\r
 460         return gdxBulletJNI.Cross(v);\r
 461 }\r
 462 \r
 463   public static Matrix3 Diagonal(float x) {\r
 464         return gdxBulletJNI.Diagonal(x);\r
 465 }\r
 466 \r
 467   public static Matrix3 Add(Matrix3 a, Matrix3 b) {\r
 468         return gdxBulletJNI.Add(a, b);\r
 469 }\r
 470 \r
 471   public static Matrix3 Sub(Matrix3 a, Matrix3 b) {\r
 472         return gdxBulletJNI.Sub(a, b);\r
 473 }\r
 474 \r
 475   public static Matrix3 Mul(Matrix3 a, float b) {\r
 476         return gdxBulletJNI.Mul(a, b);\r
 477 }\r
 478 \r
 479   public static void Orthogonalize(Matrix3 m) {\r
 480     gdxBulletJNI.Orthogonalize(m);\r
 481   }\r
 482 \r
 483   public static Matrix3 MassMatrix(float im, Matrix3 iwi, Vector3 r) {\r
 484         return gdxBulletJNI.MassMatrix(im, iwi, r);\r
 485 }\r
 486 \r
 487   public static Matrix3 ImpulseMatrix(float dt, float ima, float imb, Matrix3 iwi, Vector3 r) {\r
 488         return gdxBulletJNI.ImpulseMatrix__SWIG_0(dt, ima, imb, iwi, r);\r
 489 }\r
 490 \r
 491   public static Matrix3 ImpulseMatrix(float ima, Matrix3 iia, Vector3 ra, float imb, Matrix3 iib, Vector3 rb) {\r
 492         return gdxBulletJNI.ImpulseMatrix__SWIG_1(ima, iia, ra, imb, iib, rb);\r
 493 }\r
 494 \r
 495   public static Matrix3 AngularImpulseMatrix(Matrix3 iia, Matrix3 iib) {\r
 496         return gdxBulletJNI.AngularImpulseMatrix(iia, iib);\r
 497 }\r
 498 \r
 499   public static Vector3 ProjectOnAxis(Vector3 v, Vector3 a) {\r
 500         return gdxBulletJNI.ProjectOnAxis(v, a);\r
 501 }\r
 502 \r
 503   public static Vector3 ProjectOnPlane(Vector3 v, Vector3 a) {\r
 504         return gdxBulletJNI.ProjectOnPlane(v, a);\r
 505 }\r
 506 \r
 507   public static void ProjectOrigin(Vector3 a, Vector3 b, Vector3 prj, SWIGTYPE_p_float sqd) {\r
 508     gdxBulletJNI.ProjectOrigin__SWIG_0(a, b, prj, SWIGTYPE_p_float.getCPtr(sqd));\r
 509   }\r
 510 \r
 511   public static void ProjectOrigin(Vector3 a, Vector3 b, Vector3 c, Vector3 prj, SWIGTYPE_p_float sqd) {\r
 512     gdxBulletJNI.ProjectOrigin__SWIG_1(a, b, c, prj, SWIGTYPE_p_float.getCPtr(sqd));\r
 513   }\r
 514 \r
 515   public static Vector3 BaryCoord(Vector3 a, Vector3 b, Vector3 c, Vector3 p) {\r
 516         return gdxBulletJNI.BaryCoord(a, b, c, p);\r
 517 }\r
 518 \r
 519   public static float ImplicitSolve(SWIGTYPE_p_btSoftBody__ImplicitFn fn, Vector3 a, Vector3 b, float accuracy, int maxiterations) {\r
 520     return gdxBulletJNI.ImplicitSolve__SWIG_0(SWIGTYPE_p_btSoftBody__ImplicitFn.getCPtr(fn), a, b, accuracy, maxiterations);\r
 521   }\r
 522 \r
 523   public static float ImplicitSolve(SWIGTYPE_p_btSoftBody__ImplicitFn fn, Vector3 a, Vector3 b, float accuracy) {\r
 524     return gdxBulletJNI.ImplicitSolve__SWIG_1(SWIGTYPE_p_btSoftBody__ImplicitFn.getCPtr(fn), a, b, accuracy);\r
 525   }\r
 526 \r
 527   public static Vector3 NormalizeAny(Vector3 v) {\r
 528         return gdxBulletJNI.NormalizeAny(v);\r
 529 }\r
 530 \r
 531   public static btDbvtAabbMm VolumeOf(Face f, float margin) {\r
 532     return new btDbvtAabbMm(gdxBulletJNI.VolumeOf__SWIG_0(Face.getCPtr(f), f, margin), true);\r
 533   }\r
 534 \r
 535   public static Vector3 CenterOf(Face f) {\r
 536         return gdxBulletJNI.CenterOf(Face.getCPtr(f), f);\r
 537 }\r
 538 \r
 539   public static float AreaOf(Vector3 x0, Vector3 x1, Vector3 x2) {\r
 540     return gdxBulletJNI.AreaOf(x0, x1, x2);\r
 541   }\r
 542 \r
 543   public static float VolumeOf(Vector3 x0, Vector3 x1, Vector3 x2, Vector3 x3) {\r
 544     return gdxBulletJNI.VolumeOf__SWIG_1(x0, x1, x2, x3);\r
 545   }\r
 546 \r
 547   public static void EvaluateMedium(btSoftBodyWorldInfo wfi, Vector3 x, sMedium medium) {\r
 548     gdxBulletJNI.EvaluateMedium(btSoftBodyWorldInfo.getCPtr(wfi), wfi, x, sMedium.getCPtr(medium), medium);\r
 549   }\r
 550 \r
 551   public static void ApplyClampedForce(Node n, Vector3 f, float dt) {\r
 552     gdxBulletJNI.ApplyClampedForce(Node.getCPtr(n), n, f, dt);\r
 553   }\r
 554 \r
 555   public static int MatchEdge(Node a, Node b, Node ma, Node mb) {\r
 556     return gdxBulletJNI.MatchEdge(Node.getCPtr(a), a, Node.getCPtr(b), b, Node.getCPtr(ma), ma, Node.getCPtr(mb), mb);\r
 557   }\r
 558 \r
 559   public static int PolarDecompose(Matrix3 m, Matrix3 q, Matrix3 s) {\r
 560     return gdxBulletJNI.PolarDecompose(m, q, s);\r
 561   }\r
 562 \r
 563 }\r