super.delete();\r
}\r
\r
+ protected void swigDirectorDisconnect() {\r
+ swigCMemOwn = false;\r
+ delete();\r
+ }\r
+\r
+ public void swigReleaseOwnership() {\r
+ swigCMemOwn = false;\r
+ gdxBulletJNI.AllHitsRayResultCallback_change_ownership(this, swigCPtr, false);\r
+ }\r
+\r
+ public void swigTakeOwnership() {\r
+ swigCMemOwn = true;\r
+ gdxBulletJNI.AllHitsRayResultCallback_change_ownership(this, swigCPtr, true);\r
+ }\r
+\r
public AllHitsRayResultCallback(Vector3 rayFromWorld, Vector3 rayToWorld) {\r
this(gdxBulletJNI.new_AllHitsRayResultCallback(rayFromWorld, rayToWorld), true);\r
+ gdxBulletJNI.AllHitsRayResultCallback_director_connect(this, swigCPtr, swigCMemOwn, true);\r
}\r
\r
public void setM_collisionObjects(SWIGTYPE_p_btAlignedObjectArrayT_btCollisionObject_const_p_t value) {\r
return (cPtr == 0) ? null : new SWIGTYPE_p_btAlignedObjectArrayT_float_t(cPtr, false);\r
}\r
\r
+ public float addSingleResult(LocalRayResult rayResult, boolean normalInWorldSpace) {\r
+ return (getClass() == AllHitsRayResultCallback.class) ? gdxBulletJNI.AllHitsRayResultCallback_addSingleResult(swigCPtr, this, LocalRayResult.getCPtr(rayResult), rayResult, normalInWorldSpace) : gdxBulletJNI.AllHitsRayResultCallback_addSingleResultSwigExplicitAllHitsRayResultCallback(swigCPtr, this, LocalRayResult.getCPtr(rayResult), rayResult, normalInWorldSpace);\r
+ }\r
+\r
}\r
super.delete();\r
}\r
\r
+ protected void swigDirectorDisconnect() {\r
+ swigCMemOwn = false;\r
+ delete();\r
+ }\r
+\r
+ public void swigReleaseOwnership() {\r
+ swigCMemOwn = false;\r
+ gdxBulletJNI.ClosestConvexResultCallback_change_ownership(this, swigCPtr, false);\r
+ }\r
+\r
+ public void swigTakeOwnership() {\r
+ swigCMemOwn = true;\r
+ gdxBulletJNI.ClosestConvexResultCallback_change_ownership(this, swigCPtr, true);\r
+ }\r
+\r
public ClosestConvexResultCallback(Vector3 convexFromWorld, Vector3 convexToWorld) {\r
this(gdxBulletJNI.new_ClosestConvexResultCallback(convexFromWorld, convexToWorld), true);\r
+ gdxBulletJNI.ClosestConvexResultCallback_director_connect(this, swigCPtr, swigCMemOwn, true);\r
}\r
\r
public void setM_convexFromWorld(btVector3 value) {\r
return (cPtr == 0) ? null : btCollisionObject.getInstance(cPtr, false);\r
}\r
\r
+ public float addSingleResult(LocalConvexResult convexResult, boolean normalInWorldSpace) {\r
+ return (getClass() == ClosestConvexResultCallback.class) ? gdxBulletJNI.ClosestConvexResultCallback_addSingleResult(swigCPtr, this, LocalConvexResult.getCPtr(convexResult), convexResult, normalInWorldSpace) : gdxBulletJNI.ClosestConvexResultCallback_addSingleResultSwigExplicitClosestConvexResultCallback(swigCPtr, this, LocalConvexResult.getCPtr(convexResult), convexResult, normalInWorldSpace);\r
+ }\r
+\r
}\r
super.delete();\r
}\r
\r
+ protected void swigDirectorDisconnect() {\r
+ swigCMemOwn = false;\r
+ delete();\r
+ }\r
+\r
+ public void swigReleaseOwnership() {\r
+ swigCMemOwn = false;\r
+ gdxBulletJNI.ClosestRayResultCallback_change_ownership(this, swigCPtr, false);\r
+ }\r
+\r
+ public void swigTakeOwnership() {\r
+ swigCMemOwn = true;\r
+ gdxBulletJNI.ClosestRayResultCallback_change_ownership(this, swigCPtr, true);\r
+ }\r
+\r
public ClosestRayResultCallback(Vector3 rayFromWorld, Vector3 rayToWorld) {\r
this(gdxBulletJNI.new_ClosestRayResultCallback(rayFromWorld, rayToWorld), true);\r
+ gdxBulletJNI.ClosestRayResultCallback_director_connect(this, swigCPtr, swigCMemOwn, true);\r
}\r
\r
public void setM_rayFromWorld(btVector3 value) {\r
return (cPtr == 0) ? null : new btVector3(cPtr, false);\r
}\r
\r
+ public float addSingleResult(LocalRayResult rayResult, boolean normalInWorldSpace) {\r
+ return (getClass() == ClosestRayResultCallback.class) ? gdxBulletJNI.ClosestRayResultCallback_addSingleResult(swigCPtr, this, LocalRayResult.getCPtr(rayResult), rayResult, normalInWorldSpace) : gdxBulletJNI.ClosestRayResultCallback_addSingleResultSwigExplicitClosestRayResultCallback(swigCPtr, this, LocalRayResult.getCPtr(rayResult), rayResult, normalInWorldSpace);\r
+ }\r
+\r
}\r
}\r
}\r
\r
+ protected void swigDirectorDisconnect() {\r
+ swigCMemOwn = false;\r
+ delete();\r
+ }\r
+\r
+ public void swigReleaseOwnership() {\r
+ swigCMemOwn = false;\r
+ gdxBulletJNI.ContactResultCallback_change_ownership(this, swigCPtr, false);\r
+ }\r
+\r
+ public void swigTakeOwnership() {\r
+ swigCMemOwn = true;\r
+ gdxBulletJNI.ContactResultCallback_change_ownership(this, swigCPtr, true);\r
+ }\r
+\r
public void setM_collisionFilterGroup(short value) {\r
gdxBulletJNI.ContactResultCallback_m_collisionFilterGroup_set(swigCPtr, this, value);\r
}\r
return gdxBulletJNI.ContactResultCallback_m_collisionFilterMask_get(swigCPtr, this);\r
}\r
\r
+ public ContactResultCallback() {\r
+ this(gdxBulletJNI.new_ContactResultCallback(), true);\r
+ gdxBulletJNI.ContactResultCallback_director_connect(this, swigCPtr, swigCMemOwn, true);\r
+ }\r
+\r
public boolean needsCollision(btBroadphaseProxy proxy0) {\r
- return gdxBulletJNI.ContactResultCallback_needsCollision(swigCPtr, this, btBroadphaseProxy.getCPtr(proxy0), proxy0);\r
+ return (getClass() == ContactResultCallback.class) ? gdxBulletJNI.ContactResultCallback_needsCollision(swigCPtr, this, btBroadphaseProxy.getCPtr(proxy0), proxy0) : gdxBulletJNI.ContactResultCallback_needsCollisionSwigExplicitContactResultCallback(swigCPtr, this, btBroadphaseProxy.getCPtr(proxy0), proxy0);\r
}\r
\r
- public float addSingleResult(btManifoldPoint cp, SWIGTYPE_p_btCollisionObjectWrapper colObj0Wrap, int partId0, int index0, SWIGTYPE_p_btCollisionObjectWrapper colObj1Wrap, int partId1, int index1) {\r
- return gdxBulletJNI.ContactResultCallback_addSingleResult(swigCPtr, this, btManifoldPoint.getCPtr(cp), cp, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(colObj0Wrap), partId0, index0, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(colObj1Wrap), partId1, index1);\r
+ public float addSingleResult(btManifoldPoint cp, btCollisionObjectWrapper colObj0Wrap, int partId0, int index0, btCollisionObjectWrapper colObj1Wrap, int partId1, int index1) {\r
+ return gdxBulletJNI.ContactResultCallback_addSingleResult(swigCPtr, this, btManifoldPoint.getCPtr(cp), cp, btCollisionObjectWrapper.getCPtr(colObj0Wrap), colObj0Wrap, partId0, index0, btCollisionObjectWrapper.getCPtr(colObj1Wrap), colObj1Wrap, partId1, index1);\r
}\r
\r
}\r
}\r
}\r
\r
+ protected void swigDirectorDisconnect() {\r
+ swigCMemOwn = false;\r
+ delete();\r
+ }\r
+\r
+ public void swigReleaseOwnership() {\r
+ swigCMemOwn = false;\r
+ gdxBulletJNI.ConvexResultCallback_change_ownership(this, swigCPtr, false);\r
+ }\r
+\r
+ public void swigTakeOwnership() {\r
+ swigCMemOwn = true;\r
+ gdxBulletJNI.ConvexResultCallback_change_ownership(this, swigCPtr, true);\r
+ }\r
+\r
public void setM_closestHitFraction(float value) {\r
gdxBulletJNI.ConvexResultCallback_m_closestHitFraction_set(swigCPtr, this, value);\r
}\r
return gdxBulletJNI.ConvexResultCallback_m_collisionFilterMask_get(swigCPtr, this);\r
}\r
\r
+ public ConvexResultCallback() {\r
+ this(gdxBulletJNI.new_ConvexResultCallback(), true);\r
+ gdxBulletJNI.ConvexResultCallback_director_connect(this, swigCPtr, swigCMemOwn, true);\r
+ }\r
+\r
public boolean hasHit() {\r
return gdxBulletJNI.ConvexResultCallback_hasHit(swigCPtr, this);\r
}\r
\r
public boolean needsCollision(btBroadphaseProxy proxy0) {\r
- return gdxBulletJNI.ConvexResultCallback_needsCollision(swigCPtr, this, btBroadphaseProxy.getCPtr(proxy0), proxy0);\r
+ return (getClass() == ConvexResultCallback.class) ? gdxBulletJNI.ConvexResultCallback_needsCollision(swigCPtr, this, btBroadphaseProxy.getCPtr(proxy0), proxy0) : gdxBulletJNI.ConvexResultCallback_needsCollisionSwigExplicitConvexResultCallback(swigCPtr, this, btBroadphaseProxy.getCPtr(proxy0), proxy0);\r
}\r
\r
public float addSingleResult(LocalConvexResult convexResult, boolean normalInWorldSpace) {\r
}\r
}\r
\r
+ protected void swigDirectorDisconnect() {\r
+ swigCMemOwn = false;\r
+ delete();\r
+ }\r
+\r
+ public void swigReleaseOwnership() {\r
+ swigCMemOwn = false;\r
+ gdxBulletJNI.RayResultCallback_change_ownership(this, swigCPtr, false);\r
+ }\r
+\r
+ public void swigTakeOwnership() {\r
+ swigCMemOwn = true;\r
+ gdxBulletJNI.RayResultCallback_change_ownership(this, swigCPtr, true);\r
+ }\r
+\r
public void setM_closestHitFraction(float value) {\r
gdxBulletJNI.RayResultCallback_m_closestHitFraction_set(swigCPtr, this, value);\r
}\r
return gdxBulletJNI.RayResultCallback_hasHit(swigCPtr, this);\r
}\r
\r
+ public RayResultCallback() {\r
+ this(gdxBulletJNI.new_RayResultCallback(), true);\r
+ gdxBulletJNI.RayResultCallback_director_connect(this, swigCPtr, swigCMemOwn, true);\r
+ }\r
+\r
public boolean needsCollision(btBroadphaseProxy proxy0) {\r
- return gdxBulletJNI.RayResultCallback_needsCollision(swigCPtr, this, btBroadphaseProxy.getCPtr(proxy0), proxy0);\r
+ return (getClass() == RayResultCallback.class) ? gdxBulletJNI.RayResultCallback_needsCollision(swigCPtr, this, btBroadphaseProxy.getCPtr(proxy0), proxy0) : gdxBulletJNI.RayResultCallback_needsCollisionSwigExplicitRayResultCallback(swigCPtr, this, btBroadphaseProxy.getCPtr(proxy0), proxy0);\r
}\r
\r
public float addSingleResult(LocalRayResult rayResult, boolean normalInWorldSpace) {\r
+++ /dev/null
-/* ----------------------------------------------------------------------------\r
- * This file was automatically generated by SWIG (http://www.swig.org).\r
- * Version 2.0.9\r
- *\r
- * Do not make changes to this file unless you know what you are doing--modify\r
- * the SWIG interface file instead.\r
- * ----------------------------------------------------------------------------- */\r
-\r
-package com.badlogic.gdx.physics.bullet;\r
-\r
-public class SWIGTYPE_p_btCollisionObjectWrapper {\r
- private long swigCPtr;\r
-\r
- protected SWIGTYPE_p_btCollisionObjectWrapper(long cPtr, boolean futureUse) {\r
- swigCPtr = cPtr;\r
- }\r
-\r
- protected SWIGTYPE_p_btCollisionObjectWrapper() {\r
- swigCPtr = 0;\r
- }\r
-\r
- public static long getCPtr(SWIGTYPE_p_btCollisionObjectWrapper obj) {\r
- return (obj == null) ? 0 : obj.swigCPtr;\r
- }\r
-}\r
-\r
this(gdxBulletJNI.new_btBox2dBox2dCollisionAlgorithm__SWIG_0(btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci), true);\r
}\r
\r
- public btBox2dBox2dCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap) {\r
- this(gdxBulletJNI.new_btBox2dBox2dCollisionAlgorithm__SWIG_1(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap)), true);\r
+ public btBox2dBox2dCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap) {\r
+ this(gdxBulletJNI.new_btBox2dBox2dCollisionAlgorithm__SWIG_1(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap), true);\r
}\r
\r
}\r
this(gdxBulletJNI.new_btBoxBoxCollisionAlgorithm__SWIG_0(btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci), true);\r
}\r
\r
- public btBoxBoxCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap) {\r
- this(gdxBulletJNI.new_btBoxBoxCollisionAlgorithm__SWIG_1(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap)), true);\r
+ public btBoxBoxCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap) {\r
+ this(gdxBulletJNI.new_btBoxBoxCollisionAlgorithm__SWIG_1(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap), true);\r
}\r
\r
}\r
}\r
}\r
\r
- public void processCollision(SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, btDispatcherInfo dispatchInfo, btManifoldResult resultOut) {\r
- gdxBulletJNI.btCollisionAlgorithm_processCollision(swigCPtr, this, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), btDispatcherInfo.getCPtr(dispatchInfo), dispatchInfo, btManifoldResult.getCPtr(resultOut), resultOut);\r
+ public void processCollision(btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, btDispatcherInfo dispatchInfo, btManifoldResult resultOut) {\r
+ gdxBulletJNI.btCollisionAlgorithm_processCollision(swigCPtr, this, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, btDispatcherInfo.getCPtr(dispatchInfo), dispatchInfo, btManifoldResult.getCPtr(resultOut), resultOut);\r
}\r
\r
public float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, btDispatcherInfo dispatchInfo, btManifoldResult resultOut) {\r
this(gdxBulletJNI.new_btCollisionAlgorithmCreateFunc(), true);\r
}\r
\r
- public btCollisionAlgorithm CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo arg0, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap) {\r
- long cPtr = gdxBulletJNI.btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm(swigCPtr, this, btCollisionAlgorithmConstructionInfo.getCPtr(arg0), arg0, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap));\r
+ public btCollisionAlgorithm CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo arg0, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap) {\r
+ long cPtr = gdxBulletJNI.btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm(swigCPtr, this, btCollisionAlgorithmConstructionInfo.getCPtr(arg0), arg0, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap);\r
return (cPtr == 0) ? null : new btCollisionAlgorithm(cPtr, false);\r
}\r
\r
this(gdxBulletJNI.new_btCollisionDispatcher(btCollisionConfiguration.getCPtr(collisionConfiguration), collisionConfiguration), true);\r
}\r
\r
- public btCollisionAlgorithm findAlgorithm(SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, btPersistentManifold sharedManifold) {\r
- long cPtr = gdxBulletJNI.btCollisionDispatcher_findAlgorithm__SWIG_0(swigCPtr, this, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), btPersistentManifold.getCPtr(sharedManifold), sharedManifold);\r
+ public btCollisionAlgorithm findAlgorithm(btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, btPersistentManifold sharedManifold) {\r
+ long cPtr = gdxBulletJNI.btCollisionDispatcher_findAlgorithm__SWIG_0(swigCPtr, this, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, btPersistentManifold.getCPtr(sharedManifold), sharedManifold);\r
return (cPtr == 0) ? null : new btCollisionAlgorithm(cPtr, false);\r
}\r
\r
- public btCollisionAlgorithm findAlgorithm(SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap) {\r
- long cPtr = gdxBulletJNI.btCollisionDispatcher_findAlgorithm__SWIG_1(swigCPtr, this, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap));\r
+ public btCollisionAlgorithm findAlgorithm(btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap) {\r
+ long cPtr = gdxBulletJNI.btCollisionDispatcher_findAlgorithm__SWIG_1(swigCPtr, this, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap);\r
return (cPtr == 0) ? null : new btCollisionAlgorithm(cPtr, false);\r
}\r
\r
private long swigCPtr;\r
protected boolean swigCMemOwn;\r
\r
+ public Object userData;\r
+ \r
protected btCollisionObject(long cPtr, boolean cMemoryOwn) {\r
swigCMemOwn = cMemoryOwn;\r
swigCPtr = cPtr;\r
--- /dev/null
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 2.0.9
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package com.badlogic.gdx.physics.bullet;
+
+import com.badlogic.gdx.math.Vector3;
+import com.badlogic.gdx.math.Quaternion;
+import com.badlogic.gdx.math.Matrix3;
+import com.badlogic.gdx.math.Matrix4;
+
+public class btCollisionObjectWrapper {
+ private long swigCPtr;
+ protected boolean swigCMemOwn;
+
+ protected btCollisionObjectWrapper(long cPtr, boolean cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = cPtr;
+ }
+
+ public static long getCPtr(btCollisionObjectWrapper obj) {
+ return (obj == null) ? 0 : obj.swigCPtr;
+ }
+
+ public synchronized void delete() {
+ if (swigCPtr != 0) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ throw new UnsupportedOperationException("C++ destructor does not have public access");
+ }
+ swigCPtr = 0;
+ }
+ }
+
+ public void setM_parent(btCollisionObjectWrapper value) {
+ gdxBulletJNI.btCollisionObjectWrapper_m_parent_set(swigCPtr, this, btCollisionObjectWrapper.getCPtr(value), value);
+ }
+
+ public btCollisionObjectWrapper getM_parent() {
+ long cPtr = gdxBulletJNI.btCollisionObjectWrapper_m_parent_get(swigCPtr, this);
+ return (cPtr == 0) ? null : new btCollisionObjectWrapper(cPtr, false);
+ }
+
+ public void setM_shape(btCollisionShape value) {
+ gdxBulletJNI.btCollisionObjectWrapper_m_shape_set(swigCPtr, this, btCollisionShape.getCPtr(value), value);
+ }
+
+ public btCollisionShape getM_shape() {
+ long cPtr = gdxBulletJNI.btCollisionObjectWrapper_m_shape_get(swigCPtr, this);
+ return (cPtr == 0) ? null : btCollisionShape.newDerivedObject(cPtr, false);
+ }
+
+ public void setM_collisionObject(btCollisionObject value) {
+ gdxBulletJNI.btCollisionObjectWrapper_m_collisionObject_set(swigCPtr, this, btCollisionObject.getCPtr(value), value);
+ }
+
+ public btCollisionObject getM_collisionObject() {
+ long cPtr = gdxBulletJNI.btCollisionObjectWrapper_m_collisionObject_get(swigCPtr, this);
+ return (cPtr == 0) ? null : btCollisionObject.getInstance(cPtr, false);
+}
+
+ public Matrix4 getM_worldTransform() {
+ return gdxBulletJNI.btCollisionObjectWrapper_m_worldTransform_get(swigCPtr, this);
+}
+
+ public Matrix4 getWorldTransform() {
+ return gdxBulletJNI.btCollisionObjectWrapper_getWorldTransform(swigCPtr, this);
+}
+
+ public btCollisionObject getCollisionObject() {
+ long cPtr = gdxBulletJNI.btCollisionObjectWrapper_getCollisionObject(swigCPtr, this);
+ return (cPtr == 0) ? null : btCollisionObject.getInstance(cPtr, false);
+}
+
+ public btCollisionShape getCollisionShape() {
+ long cPtr = gdxBulletJNI.btCollisionObjectWrapper_getCollisionShape(swigCPtr, this);
+ return (cPtr == 0) ? null : btCollisionShape.newDerivedObject(cPtr, false);
+ }
+
+}
gdxBulletJNI.btCollisionWorld_rayTestSingle(rayFromTrans, rayToTrans, btCollisionObject.getCPtr(collisionObject), collisionObject, btCollisionShape.getCPtr(collisionShape), collisionShape, colObjWorldTransform, RayResultCallback.getCPtr(resultCallback), resultCallback);\r
}\r
\r
- public static void rayTestSingleInternal(Matrix4 rayFromTrans, Matrix4 rayToTrans, SWIGTYPE_p_btCollisionObjectWrapper collisionObjectWrap, RayResultCallback resultCallback) {\r
- gdxBulletJNI.btCollisionWorld_rayTestSingleInternal(rayFromTrans, rayToTrans, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(collisionObjectWrap), RayResultCallback.getCPtr(resultCallback), resultCallback);\r
+ public static void rayTestSingleInternal(Matrix4 rayFromTrans, Matrix4 rayToTrans, btCollisionObjectWrapper collisionObjectWrap, RayResultCallback resultCallback) {\r
+ gdxBulletJNI.btCollisionWorld_rayTestSingleInternal(rayFromTrans, rayToTrans, btCollisionObjectWrapper.getCPtr(collisionObjectWrap), collisionObjectWrap, RayResultCallback.getCPtr(resultCallback), resultCallback);\r
}\r
\r
public static void objectQuerySingle(btConvexShape castShape, Matrix4 rayFromTrans, Matrix4 rayToTrans, btCollisionObject collisionObject, btCollisionShape collisionShape, Matrix4 colObjWorldTransform, ConvexResultCallback resultCallback, float allowedPenetration) {\r
gdxBulletJNI.btCollisionWorld_objectQuerySingle(btConvexShape.getCPtr(castShape), castShape, rayFromTrans, rayToTrans, btCollisionObject.getCPtr(collisionObject), collisionObject, btCollisionShape.getCPtr(collisionShape), collisionShape, colObjWorldTransform, ConvexResultCallback.getCPtr(resultCallback), resultCallback, allowedPenetration);\r
}\r
\r
- public static void objectQuerySingleInternal(btConvexShape castShape, Matrix4 convexFromTrans, Matrix4 convexToTrans, SWIGTYPE_p_btCollisionObjectWrapper colObjWrap, ConvexResultCallback resultCallback, float allowedPenetration) {\r
- gdxBulletJNI.btCollisionWorld_objectQuerySingleInternal(btConvexShape.getCPtr(castShape), castShape, convexFromTrans, convexToTrans, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(colObjWrap), ConvexResultCallback.getCPtr(resultCallback), resultCallback, allowedPenetration);\r
+ public static void objectQuerySingleInternal(btConvexShape castShape, Matrix4 convexFromTrans, Matrix4 convexToTrans, btCollisionObjectWrapper colObjWrap, ConvexResultCallback resultCallback, float allowedPenetration) {\r
+ gdxBulletJNI.btCollisionWorld_objectQuerySingleInternal(btConvexShape.getCPtr(castShape), castShape, convexFromTrans, convexToTrans, btCollisionObjectWrapper.getCPtr(colObjWrap), colObjWrap, ConvexResultCallback.getCPtr(resultCallback), resultCallback, allowedPenetration);\r
}\r
\r
public void addCollisionObject(btCollisionObject collisionObject, short collisionFilterGroup, short collisionFilterMask) {\r
super.delete();\r
}\r
\r
- public btCompoundCollisionAlgorithm(btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
- this(gdxBulletJNI.new_btCompoundCollisionAlgorithm(btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), isSwapped), true);\r
+ public btCompoundCollisionAlgorithm(btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
+ this(gdxBulletJNI.new_btCompoundCollisionAlgorithm(btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, isSwapped), true);\r
}\r
\r
}\r
super.delete();\r
}\r
\r
- public btConvex2dConvex2dAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, SWIGTYPE_p_btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold) {\r
- this(gdxBulletJNI.new_btConvex2dConvex2dAlgorithm(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), SWIGTYPE_p_btSimplexSolverInterface.getCPtr(simplexSolver), btConvexPenetrationDepthSolver.getCPtr(pdSolver), pdSolver, numPerturbationIterations, minimumPointsPerturbationThreshold), true);\r
+ public btConvex2dConvex2dAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, SWIGTYPE_p_btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold) {\r
+ this(gdxBulletJNI.new_btConvex2dConvex2dAlgorithm(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, SWIGTYPE_p_btSimplexSolverInterface.getCPtr(simplexSolver), btConvexPenetrationDepthSolver.getCPtr(pdSolver), pdSolver, numPerturbationIterations, minimumPointsPerturbationThreshold), true);\r
}\r
\r
public void setLowLevelOfDetail(boolean useLowLevel) {\r
super.delete();\r
}\r
\r
- public btConvexConcaveCollisionAlgorithm(btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
- this(gdxBulletJNI.new_btConvexConcaveCollisionAlgorithm(btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), isSwapped), true);\r
+ public btConvexConcaveCollisionAlgorithm(btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
+ this(gdxBulletJNI.new_btConvexConcaveCollisionAlgorithm(btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, isSwapped), true);\r
}\r
\r
public void clearCache() {\r
super.delete();\r
}\r
\r
- public btConvexConvexAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, SWIGTYPE_p_btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold) {\r
- this(gdxBulletJNI.new_btConvexConvexAlgorithm(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), SWIGTYPE_p_btSimplexSolverInterface.getCPtr(simplexSolver), btConvexPenetrationDepthSolver.getCPtr(pdSolver), pdSolver, numPerturbationIterations, minimumPointsPerturbationThreshold), true);\r
+ public btConvexConvexAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, SWIGTYPE_p_btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold) {\r
+ this(gdxBulletJNI.new_btConvexConvexAlgorithm(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, SWIGTYPE_p_btSimplexSolverInterface.getCPtr(simplexSolver), btConvexPenetrationDepthSolver.getCPtr(pdSolver), pdSolver, numPerturbationIterations, minimumPointsPerturbationThreshold), true);\r
}\r
\r
public void setLowLevelOfDetail(boolean useLowLevel) {\r
super.delete();\r
}\r
\r
- public btConvexPlaneCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, boolean isSwapped, int numPerturbationIterations, int minimumPointsPerturbationThreshold) {\r
- this(gdxBulletJNI.new_btConvexPlaneCollisionAlgorithm(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), isSwapped, numPerturbationIterations, minimumPointsPerturbationThreshold), true);\r
+ public btConvexPlaneCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, boolean isSwapped, int numPerturbationIterations, int minimumPointsPerturbationThreshold) {\r
+ this(gdxBulletJNI.new_btConvexPlaneCollisionAlgorithm(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, isSwapped, numPerturbationIterations, minimumPointsPerturbationThreshold), true);\r
}\r
\r
- public void collideSingleContact(Quaternion perturbeRot, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, btDispatcherInfo dispatchInfo, btManifoldResult resultOut) {\r
- gdxBulletJNI.btConvexPlaneCollisionAlgorithm_collideSingleContact(swigCPtr, this, perturbeRot, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), btDispatcherInfo.getCPtr(dispatchInfo), dispatchInfo, btManifoldResult.getCPtr(resultOut), resultOut);\r
+ public void collideSingleContact(Quaternion perturbeRot, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, btDispatcherInfo dispatchInfo, btManifoldResult resultOut) {\r
+ gdxBulletJNI.btConvexPlaneCollisionAlgorithm_collideSingleContact(swigCPtr, this, perturbeRot, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, btDispatcherInfo.getCPtr(dispatchInfo), dispatchInfo, btManifoldResult.getCPtr(resultOut), resultOut);\r
}\r
\r
}\r
return (cPtr == 0) ? null : new btPersistentManifold(cPtr, false);\r
}\r
\r
- public btConvexTriangleCallback(btDispatcher dispatcher, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
- this(gdxBulletJNI.new_btConvexTriangleCallback(btDispatcher.getCPtr(dispatcher), dispatcher, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), isSwapped), true);\r
+ public btConvexTriangleCallback(btDispatcher dispatcher, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
+ this(gdxBulletJNI.new_btConvexTriangleCallback(btDispatcher.getCPtr(dispatcher), dispatcher, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, isSwapped), true);\r
}\r
\r
- public void setTimeStepAndCounters(float collisionMarginTriangle, btDispatcherInfo dispatchInfo, SWIGTYPE_p_btCollisionObjectWrapper convexBodyWrap, SWIGTYPE_p_btCollisionObjectWrapper triBodyWrap, btManifoldResult resultOut) {\r
- gdxBulletJNI.btConvexTriangleCallback_setTimeStepAndCounters(swigCPtr, this, collisionMarginTriangle, btDispatcherInfo.getCPtr(dispatchInfo), dispatchInfo, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(convexBodyWrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(triBodyWrap), btManifoldResult.getCPtr(resultOut), resultOut);\r
+ public void setTimeStepAndCounters(float collisionMarginTriangle, btDispatcherInfo dispatchInfo, btCollisionObjectWrapper convexBodyWrap, btCollisionObjectWrapper triBodyWrap, btManifoldResult resultOut) {\r
+ gdxBulletJNI.btConvexTriangleCallback_setTimeStepAndCounters(swigCPtr, this, collisionMarginTriangle, btDispatcherInfo.getCPtr(dispatchInfo), dispatchInfo, btCollisionObjectWrapper.getCPtr(convexBodyWrap), convexBodyWrap, btCollisionObjectWrapper.getCPtr(triBodyWrap), triBodyWrap, btManifoldResult.getCPtr(resultOut), resultOut);\r
}\r
\r
public void clearWrapperData() {\r
gdxBulletJNI.btDefaultSoftBodySolver_copySoftBodyToVertexBuffer(swigCPtr, this, btSoftBody.getCPtr(softBody), softBody, btVertexBufferDescriptor.getCPtr(vertexBuffer), vertexBuffer);\r
}\r
\r
- public void processCollision(btSoftBody arg0, SWIGTYPE_p_btCollisionObjectWrapper arg1) {\r
- gdxBulletJNI.btDefaultSoftBodySolver_processCollision__SWIG_0(swigCPtr, this, btSoftBody.getCPtr(arg0), arg0, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(arg1));\r
+ public void processCollision(btSoftBody arg0, btCollisionObjectWrapper arg1) {\r
+ gdxBulletJNI.btDefaultSoftBodySolver_processCollision__SWIG_0(swigCPtr, this, btSoftBody.getCPtr(arg0), arg0, btCollisionObjectWrapper.getCPtr(arg1), arg1);\r
}\r
\r
public void processCollision(btSoftBody arg0, btSoftBody arg1) {\r
}\r
}\r
\r
- public btCollisionAlgorithm findAlgorithm(SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, btPersistentManifold sharedManifold) {\r
- long cPtr = gdxBulletJNI.btDispatcher_findAlgorithm__SWIG_0(swigCPtr, this, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), btPersistentManifold.getCPtr(sharedManifold), sharedManifold);\r
+ public btCollisionAlgorithm findAlgorithm(btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, btPersistentManifold sharedManifold) {\r
+ long cPtr = gdxBulletJNI.btDispatcher_findAlgorithm__SWIG_0(swigCPtr, this, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, btPersistentManifold.getCPtr(sharedManifold), sharedManifold);\r
return (cPtr == 0) ? null : new btCollisionAlgorithm(cPtr, false);\r
}\r
\r
- public btCollisionAlgorithm findAlgorithm(SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap) {\r
- long cPtr = gdxBulletJNI.btDispatcher_findAlgorithm__SWIG_1(swigCPtr, this, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap));\r
+ public btCollisionAlgorithm findAlgorithm(btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap) {\r
+ long cPtr = gdxBulletJNI.btDispatcher_findAlgorithm__SWIG_1(swigCPtr, this, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap);\r
return (cPtr == 0) ? null : new btCollisionAlgorithm(cPtr, false);\r
}\r
\r
this(gdxBulletJNI.new_btManifoldResult__SWIG_0(), true);\r
}\r
\r
- public btManifoldResult(SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap) {\r
- this(gdxBulletJNI.new_btManifoldResult__SWIG_1(SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap)), true);\r
+ public btManifoldResult(btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap) {\r
+ this(gdxBulletJNI.new_btManifoldResult__SWIG_1(btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap), true);\r
}\r
\r
public void setPersistentManifold(btPersistentManifold manifoldPtr) {\r
gdxBulletJNI.btManifoldResult_refreshContactPoints(swigCPtr, this);\r
}\r
\r
- public SWIGTYPE_p_btCollisionObjectWrapper getBody0Wrap() {\r
+ public btCollisionObjectWrapper getBody0Wrap() {\r
long cPtr = gdxBulletJNI.btManifoldResult_getBody0Wrap(swigCPtr, this);\r
- return (cPtr == 0) ? null : new SWIGTYPE_p_btCollisionObjectWrapper(cPtr, false);\r
+ return (cPtr == 0) ? null : new btCollisionObjectWrapper(cPtr, false);\r
}\r
\r
- public SWIGTYPE_p_btCollisionObjectWrapper getBody1Wrap() {\r
+ public btCollisionObjectWrapper getBody1Wrap() {\r
long cPtr = gdxBulletJNI.btManifoldResult_getBody1Wrap(swigCPtr, this);\r
- return (cPtr == 0) ? null : new SWIGTYPE_p_btCollisionObjectWrapper(cPtr, false);\r
+ return (cPtr == 0) ? null : new btCollisionObjectWrapper(cPtr, false);\r
}\r
\r
- public void setBody0Wrap(SWIGTYPE_p_btCollisionObjectWrapper obj0Wrap) {\r
- gdxBulletJNI.btManifoldResult_setBody0Wrap(swigCPtr, this, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(obj0Wrap));\r
+ public void setBody0Wrap(btCollisionObjectWrapper obj0Wrap) {\r
+ gdxBulletJNI.btManifoldResult_setBody0Wrap(swigCPtr, this, btCollisionObjectWrapper.getCPtr(obj0Wrap), obj0Wrap);\r
}\r
\r
- public void setBody1Wrap(SWIGTYPE_p_btCollisionObjectWrapper obj1Wrap) {\r
- gdxBulletJNI.btManifoldResult_setBody1Wrap(swigCPtr, this, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(obj1Wrap));\r
+ public void setBody1Wrap(btCollisionObjectWrapper obj1Wrap) {\r
+ gdxBulletJNI.btManifoldResult_setBody1Wrap(swigCPtr, this, btCollisionObjectWrapper.getCPtr(obj1Wrap), obj1Wrap);\r
}\r
\r
public btCollisionObject getBody0Internal() {\r
gdxBulletJNI.btSoftBody_integrateMotion(swigCPtr, this);\r
}\r
\r
- public void defaultCollisionHandler(SWIGTYPE_p_btCollisionObjectWrapper pcoWrap) {\r
- gdxBulletJNI.btSoftBody_defaultCollisionHandler__SWIG_0(swigCPtr, this, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(pcoWrap));\r
+ public void defaultCollisionHandler(btCollisionObjectWrapper pcoWrap) {\r
+ gdxBulletJNI.btSoftBody_defaultCollisionHandler__SWIG_0(swigCPtr, this, btCollisionObjectWrapper.getCPtr(pcoWrap), pcoWrap);\r
}\r
\r
public void defaultCollisionHandler(btSoftBody psb) {\r
return gdxBulletJNI.btSoftBody_evaluateCom(swigCPtr, this);\r
}\r
\r
- public boolean checkContact(SWIGTYPE_p_btCollisionObjectWrapper colObjWrap, Vector3 x, float margin, sCti cti) {\r
- return gdxBulletJNI.btSoftBody_checkContact(swigCPtr, this, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(colObjWrap), x, margin, sCti.getCPtr(cti), cti);\r
+ public boolean checkContact(btCollisionObjectWrapper colObjWrap, Vector3 x, float margin, sCti cti) {\r
+ return gdxBulletJNI.btSoftBody_checkContact(swigCPtr, this, btCollisionObjectWrapper.getCPtr(colObjWrap), colObjWrap, x, margin, sCti.getCPtr(cti), cti);\r
}\r
\r
public void updateNormals() {\r
super.delete();\r
}\r
\r
- public btSoftBodyConcaveCollisionAlgorithm(btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
- this(gdxBulletJNI.new_btSoftBodyConcaveCollisionAlgorithm(btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), isSwapped), true);\r
+ public btSoftBodyConcaveCollisionAlgorithm(btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
+ this(gdxBulletJNI.new_btSoftBodyConcaveCollisionAlgorithm(btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, isSwapped), true);\r
}\r
\r
public void clearCache() {\r
gdxBulletJNI.btSoftBodySolver_updateSoftBodies(swigCPtr, this);\r
}\r
\r
- public void processCollision(btSoftBody arg0, SWIGTYPE_p_btCollisionObjectWrapper arg1) {\r
- gdxBulletJNI.btSoftBodySolver_processCollision__SWIG_0(swigCPtr, this, btSoftBody.getCPtr(arg0), arg0, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(arg1));\r
+ public void processCollision(btSoftBody arg0, btCollisionObjectWrapper arg1) {\r
+ gdxBulletJNI.btSoftBodySolver_processCollision__SWIG_0(swigCPtr, this, btSoftBody.getCPtr(arg0), arg0, btCollisionObjectWrapper.getCPtr(arg1), arg1);\r
}\r
\r
public void processCollision(btSoftBody arg0, btSoftBody arg1) {\r
return gdxBulletJNI.btSoftBodyTriangleCallback_m_triangleCount_get(swigCPtr, this);\r
}\r
\r
- public btSoftBodyTriangleCallback(btDispatcher dispatcher, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
- this(gdxBulletJNI.new_btSoftBodyTriangleCallback(btDispatcher.getCPtr(dispatcher), dispatcher, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), isSwapped), true);\r
+ public btSoftBodyTriangleCallback(btDispatcher dispatcher, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
+ this(gdxBulletJNI.new_btSoftBodyTriangleCallback(btDispatcher.getCPtr(dispatcher), dispatcher, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, isSwapped), true);\r
}\r
\r
- public void setTimeStepAndCounters(float collisionMarginTriangle, SWIGTYPE_p_btCollisionObjectWrapper triObjWrap, btDispatcherInfo dispatchInfo, btManifoldResult resultOut) {\r
- gdxBulletJNI.btSoftBodyTriangleCallback_setTimeStepAndCounters(swigCPtr, this, collisionMarginTriangle, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(triObjWrap), btDispatcherInfo.getCPtr(dispatchInfo), dispatchInfo, btManifoldResult.getCPtr(resultOut), resultOut);\r
+ public void setTimeStepAndCounters(float collisionMarginTriangle, btCollisionObjectWrapper triObjWrap, btDispatcherInfo dispatchInfo, btManifoldResult resultOut) {\r
+ gdxBulletJNI.btSoftBodyTriangleCallback_setTimeStepAndCounters(swigCPtr, this, collisionMarginTriangle, btCollisionObjectWrapper.getCPtr(triObjWrap), triObjWrap, btDispatcherInfo.getCPtr(dispatchInfo), dispatchInfo, btManifoldResult.getCPtr(resultOut), resultOut);\r
}\r
\r
public void clearCache() {\r
super.delete();\r
}\r
\r
- public btSoftRigidCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper col0, SWIGTYPE_p_btCollisionObjectWrapper col1Wrap, boolean isSwapped) {\r
- this(gdxBulletJNI.new_btSoftRigidCollisionAlgorithm(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(col0), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(col1Wrap), isSwapped), true);\r
+ public btSoftRigidCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper col0, btCollisionObjectWrapper col1Wrap, boolean isSwapped) {\r
+ this(gdxBulletJNI.new_btSoftRigidCollisionAlgorithm(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(col0), col0, btCollisionObjectWrapper.getCPtr(col1Wrap), col1Wrap, isSwapped), true);\r
}\r
\r
}\r
this(gdxBulletJNI.new_btSoftSoftCollisionAlgorithm__SWIG_0(btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci), true);\r
}\r
\r
- public btSoftSoftCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap) {\r
- this(gdxBulletJNI.new_btSoftSoftCollisionAlgorithm__SWIG_1(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap)), true);\r
+ public btSoftSoftCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap) {\r
+ this(gdxBulletJNI.new_btSoftSoftCollisionAlgorithm__SWIG_1(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap), true);\r
}\r
\r
}\r
super.delete();\r
}\r
\r
- public btSphereBoxCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
- this(gdxBulletJNI.new_btSphereBoxCollisionAlgorithm(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), isSwapped), true);\r
+ public btSphereBoxCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, boolean isSwapped) {\r
+ this(gdxBulletJNI.new_btSphereBoxCollisionAlgorithm(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, isSwapped), true);\r
}\r
\r
- public boolean getSphereDistance(SWIGTYPE_p_btCollisionObjectWrapper boxObjWrap, Vector3 v3PointOnBox, Vector3 normal, SWIGTYPE_p_float penetrationDepth, Vector3 v3SphereCenter, float fRadius, float maxContactDistance) {\r
- return gdxBulletJNI.btSphereBoxCollisionAlgorithm_getSphereDistance(swigCPtr, this, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(boxObjWrap), v3PointOnBox, normal, SWIGTYPE_p_float.getCPtr(penetrationDepth), v3SphereCenter, fRadius, maxContactDistance);\r
+ public boolean getSphereDistance(btCollisionObjectWrapper boxObjWrap, Vector3 v3PointOnBox, Vector3 normal, SWIGTYPE_p_float penetrationDepth, Vector3 v3SphereCenter, float fRadius, float maxContactDistance) {\r
+ return gdxBulletJNI.btSphereBoxCollisionAlgorithm_getSphereDistance(swigCPtr, this, btCollisionObjectWrapper.getCPtr(boxObjWrap), boxObjWrap, v3PointOnBox, normal, SWIGTYPE_p_float.getCPtr(penetrationDepth), v3SphereCenter, fRadius, maxContactDistance);\r
}\r
\r
public float getSpherePenetration(Vector3 boxHalfExtent, Vector3 sphereRelPos, Vector3 closestPoint, Vector3 normal) {\r
super.delete();\r
}\r
\r
- public btSphereSphereCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper col0Wrap, SWIGTYPE_p_btCollisionObjectWrapper col1Wrap) {\r
- this(gdxBulletJNI.new_btSphereSphereCollisionAlgorithm__SWIG_0(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(col0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(col1Wrap)), true);\r
+ public btSphereSphereCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper col0Wrap, btCollisionObjectWrapper col1Wrap) {\r
+ this(gdxBulletJNI.new_btSphereSphereCollisionAlgorithm__SWIG_0(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(col0Wrap), col0Wrap, btCollisionObjectWrapper.getCPtr(col1Wrap), col1Wrap), true);\r
}\r
\r
public btSphereSphereCollisionAlgorithm(btCollisionAlgorithmConstructionInfo ci) {\r
super.delete();\r
}\r
\r
- public btSphereTriangleCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, SWIGTYPE_p_btCollisionObjectWrapper body0Wrap, SWIGTYPE_p_btCollisionObjectWrapper body1Wrap, boolean swapped) {\r
- this(gdxBulletJNI.new_btSphereTriangleCollisionAlgorithm__SWIG_0(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(body1Wrap), swapped), true);\r
+ public btSphereTriangleCollisionAlgorithm(btPersistentManifold mf, btCollisionAlgorithmConstructionInfo ci, btCollisionObjectWrapper body0Wrap, btCollisionObjectWrapper body1Wrap, boolean swapped) {\r
+ this(gdxBulletJNI.new_btSphereTriangleCollisionAlgorithm__SWIG_0(btPersistentManifold.getCPtr(mf), mf, btCollisionAlgorithmConstructionInfo.getCPtr(ci), ci, btCollisionObjectWrapper.getCPtr(body0Wrap), body0Wrap, btCollisionObjectWrapper.getCPtr(body1Wrap), body1Wrap, swapped), true);\r
}\r
\r
public btSphereTriangleCollisionAlgorithm(btCollisionAlgorithmConstructionInfo ci) {\r
gdxBulletJNI.btGenerateInternalEdgeInfo(btBvhTriangleMeshShape.getCPtr(trimeshShape), trimeshShape, btTriangleInfoMap.getCPtr(triangleInfoMap), triangleInfoMap);\r
}\r
\r
- public static void btAdjustInternalEdgeContacts(btManifoldPoint cp, SWIGTYPE_p_btCollisionObjectWrapper trimeshColObj0Wrap, SWIGTYPE_p_btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0, int normalAdjustFlags) {\r
- gdxBulletJNI.btAdjustInternalEdgeContacts__SWIG_0(btManifoldPoint.getCPtr(cp), cp, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(trimeshColObj0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(otherColObj1Wrap), partId0, index0, normalAdjustFlags);\r
+ public static void btAdjustInternalEdgeContacts(btManifoldPoint cp, btCollisionObjectWrapper trimeshColObj0Wrap, btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0, int normalAdjustFlags) {\r
+ gdxBulletJNI.btAdjustInternalEdgeContacts__SWIG_0(btManifoldPoint.getCPtr(cp), cp, btCollisionObjectWrapper.getCPtr(trimeshColObj0Wrap), trimeshColObj0Wrap, btCollisionObjectWrapper.getCPtr(otherColObj1Wrap), otherColObj1Wrap, partId0, index0, normalAdjustFlags);\r
}\r
\r
- public static void btAdjustInternalEdgeContacts(btManifoldPoint cp, SWIGTYPE_p_btCollisionObjectWrapper trimeshColObj0Wrap, SWIGTYPE_p_btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0) {\r
- gdxBulletJNI.btAdjustInternalEdgeContacts__SWIG_1(btManifoldPoint.getCPtr(cp), cp, SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(trimeshColObj0Wrap), SWIGTYPE_p_btCollisionObjectWrapper.getCPtr(otherColObj1Wrap), partId0, index0);\r
+ public static void btAdjustInternalEdgeContacts(btManifoldPoint cp, btCollisionObjectWrapper trimeshColObj0Wrap, btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0) {\r
+ gdxBulletJNI.btAdjustInternalEdgeContacts__SWIG_1(btManifoldPoint.getCPtr(cp), cp, btCollisionObjectWrapper.getCPtr(trimeshColObj0Wrap), trimeshColObj0Wrap, btCollisionObjectWrapper.getCPtr(otherColObj1Wrap), otherColObj1Wrap, partId0, index0);\r
}\r
\r
public static void setGContactBreakingThreshold(float value) {\r
public final static native long btCollisionAlgorithmConstructionInfo_m_manifold_get(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_);\r
public final static native void delete_btCollisionAlgorithmConstructionInfo(long jarg1);\r
public final static native void delete_btCollisionAlgorithm(long jarg1);\r
- public final static native void btCollisionAlgorithm_processCollision(long jarg1, btCollisionAlgorithm jarg1_, long jarg2, long jarg3, long jarg4, btDispatcherInfo jarg4_, long jarg5, btManifoldResult jarg5_);\r
+ public final static native void btCollisionAlgorithm_processCollision(long jarg1, btCollisionAlgorithm jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btDispatcherInfo jarg4_, long jarg5, btManifoldResult jarg5_);\r
public final static native float btCollisionAlgorithm_calculateTimeOfImpact(long jarg1, btCollisionAlgorithm jarg1_, long jarg2, btCollisionObject jarg2_, long jarg3, btCollisionObject jarg3_, long jarg4, btDispatcherInfo jarg4_, long jarg5, btManifoldResult jarg5_);\r
public final static native void btCollisionAlgorithm_getAllContactManifolds(long jarg1, btCollisionAlgorithm jarg1_, long jarg2);\r
public final static native void delete_btOverlappingPairCallback(long jarg1);\r
public final static native long btDispatcherInfo_m_stackAllocator_get(long jarg1, btDispatcherInfo jarg1_);\r
public final static native void delete_btDispatcherInfo(long jarg1);\r
public final static native void delete_btDispatcher(long jarg1);\r
- public final static native long btDispatcher_findAlgorithm__SWIG_0(long jarg1, btDispatcher jarg1_, long jarg2, long jarg3, long jarg4, btPersistentManifold jarg4_);\r
- public final static native long btDispatcher_findAlgorithm__SWIG_1(long jarg1, btDispatcher jarg1_, long jarg2, long jarg3);\r
+ public final static native long btDispatcher_findAlgorithm__SWIG_0(long jarg1, btDispatcher jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btPersistentManifold jarg4_);\r
+ public final static native long btDispatcher_findAlgorithm__SWIG_1(long jarg1, btDispatcher jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_);\r
public final static native long btDispatcher_getNewManifold(long jarg1, btDispatcher jarg1_, long jarg2, btCollisionObject jarg2_, long jarg3, btCollisionObject jarg3_);\r
public final static native void btDispatcher_releaseManifold(long jarg1, btDispatcher jarg1_, long jarg2, btPersistentManifold jarg2_);\r
public final static native void btDispatcher_clearManifold(long jarg1, btDispatcher jarg1_, long jarg2, btPersistentManifold jarg2_);\r
public final static native String btRigidBodyDoubleData_m_padding_get(long jarg1, btRigidBodyDoubleData jarg1_);\r
public final static native long new_btRigidBodyDoubleData();\r
public final static native void delete_btRigidBodyDoubleData(long jarg1);\r
+ public final static native void btCollisionObjectWrapper_m_parent_set(long jarg1, btCollisionObjectWrapper jarg1_, long jarg2, btCollisionObjectWrapper jarg2_);\r
+ public final static native long btCollisionObjectWrapper_m_parent_get(long jarg1, btCollisionObjectWrapper jarg1_);\r
+ public final static native void btCollisionObjectWrapper_m_shape_set(long jarg1, btCollisionObjectWrapper jarg1_, long jarg2, btCollisionShape jarg2_);\r
+ public final static native long btCollisionObjectWrapper_m_shape_get(long jarg1, btCollisionObjectWrapper jarg1_);\r
+ public final static native void btCollisionObjectWrapper_m_collisionObject_set(long jarg1, btCollisionObjectWrapper jarg1_, long jarg2, btCollisionObject jarg2_);\r
+ public final static native long btCollisionObjectWrapper_m_collisionObject_get(long jarg1, btCollisionObjectWrapper jarg1_);\r
+ public final static native Matrix4 btCollisionObjectWrapper_m_worldTransform_get(long jarg1, btCollisionObjectWrapper jarg1_);\r
+ public final static native Matrix4 btCollisionObjectWrapper_getWorldTransform(long jarg1, btCollisionObjectWrapper jarg1_);\r
+ public final static native long btCollisionObjectWrapper_getCollisionObject(long jarg1, btCollisionObjectWrapper jarg1_);\r
+ public final static native long btCollisionObjectWrapper_getCollisionShape(long jarg1, btCollisionObjectWrapper jarg1_);\r
public final static native long new_btEmptyAlgorithm(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_);\r
public final static native void delete_btEmptyAlgorithm(long jarg1);\r
public final static native void delete_btActivatingCollisionAlgorithm(long jarg1);\r
public final static native int btConvexTriangleCallback_m_triangleCount_get(long jarg1, btConvexTriangleCallback jarg1_);\r
public final static native void btConvexTriangleCallback_m_manifoldPtr_set(long jarg1, btConvexTriangleCallback jarg1_, long jarg2, btPersistentManifold jarg2_);\r
public final static native long btConvexTriangleCallback_m_manifoldPtr_get(long jarg1, btConvexTriangleCallback jarg1_);\r
- public final static native long new_btConvexTriangleCallback(long jarg1, btDispatcher jarg1_, long jarg2, long jarg3, boolean jarg4);\r
- public final static native void btConvexTriangleCallback_setTimeStepAndCounters(long jarg1, btConvexTriangleCallback jarg1_, float jarg2, long jarg3, btDispatcherInfo jarg3_, long jarg4, long jarg5, long jarg6, btManifoldResult jarg6_);\r
+ public final static native long new_btConvexTriangleCallback(long jarg1, btDispatcher jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, boolean jarg4);\r
+ public final static native void btConvexTriangleCallback_setTimeStepAndCounters(long jarg1, btConvexTriangleCallback jarg1_, float jarg2, long jarg3, btDispatcherInfo jarg3_, long jarg4, btCollisionObjectWrapper jarg4_, long jarg5, btCollisionObjectWrapper jarg5_, long jarg6, btManifoldResult jarg6_);\r
public final static native void btConvexTriangleCallback_clearWrapperData(long jarg1, btConvexTriangleCallback jarg1_);\r
public final static native void delete_btConvexTriangleCallback(long jarg1);\r
public final static native void btConvexTriangleCallback_clearCache(long jarg1, btConvexTriangleCallback jarg1_);\r
public final static native Vector3 btConvexTriangleCallback_getAabbMin(long jarg1, btConvexTriangleCallback jarg1_);\r
public final static native Vector3 btConvexTriangleCallback_getAabbMax(long jarg1, btConvexTriangleCallback jarg1_);\r
- public final static native long new_btConvexConcaveCollisionAlgorithm(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_, long jarg2, long jarg3, boolean jarg4);\r
+ public final static native long new_btConvexConcaveCollisionAlgorithm(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, boolean jarg4);\r
public final static native void delete_btConvexConcaveCollisionAlgorithm(long jarg1);\r
public final static native void btConvexConcaveCollisionAlgorithm_clearCache(long jarg1, btConvexConcaveCollisionAlgorithm jarg1_);\r
- public final static native long new_btConvexPlaneCollisionAlgorithm(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4, boolean jarg5, int jarg6, int jarg7);\r
+ public final static native long new_btConvexPlaneCollisionAlgorithm(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_, boolean jarg5, int jarg6, int jarg7);\r
public final static native void delete_btConvexPlaneCollisionAlgorithm(long jarg1);\r
- public final static native void btConvexPlaneCollisionAlgorithm_collideSingleContact(long jarg1, btConvexPlaneCollisionAlgorithm jarg1_, Quaternion jarg2, long jarg3, long jarg4, long jarg5, btDispatcherInfo jarg5_, long jarg6, btManifoldResult jarg6_);\r
+ public final static native void btConvexPlaneCollisionAlgorithm_collideSingleContact(long jarg1, btConvexPlaneCollisionAlgorithm jarg1_, Quaternion jarg2, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_, long jarg5, btDispatcherInfo jarg5_, long jarg6, btManifoldResult jarg6_);\r
public final static native void delete_btCollisionConfiguration(long jarg1);\r
public final static native long btCollisionConfiguration_getPersistentManifoldPool(long jarg1, btCollisionConfiguration jarg1_);\r
public final static native long btCollisionConfiguration_getCollisionAlgorithmPool(long jarg1, btCollisionConfiguration jarg1_);\r
public final static native void gContactAddedCallback_set(long jarg1);\r
public final static native long gContactAddedCallback_get();\r
public final static native long new_btManifoldResult__SWIG_0();\r
- public final static native long new_btManifoldResult__SWIG_1(long jarg1, long jarg2);\r
+ public final static native long new_btManifoldResult__SWIG_1(long jarg1, btCollisionObjectWrapper jarg1_, long jarg2, btCollisionObjectWrapper jarg2_);\r
public final static native void delete_btManifoldResult(long jarg1);\r
public final static native void btManifoldResult_setPersistentManifold(long jarg1, btManifoldResult jarg1_, long jarg2, btPersistentManifold jarg2_);\r
public final static native long btManifoldResult_getPersistentManifold__SWIG_0(long jarg1, btManifoldResult jarg1_);\r
public final static native void btManifoldResult_refreshContactPoints(long jarg1, btManifoldResult jarg1_);\r
public final static native long btManifoldResult_getBody0Wrap(long jarg1, btManifoldResult jarg1_);\r
public final static native long btManifoldResult_getBody1Wrap(long jarg1, btManifoldResult jarg1_);\r
- public final static native void btManifoldResult_setBody0Wrap(long jarg1, btManifoldResult jarg1_, long jarg2);\r
- public final static native void btManifoldResult_setBody1Wrap(long jarg1, btManifoldResult jarg1_, long jarg2);\r
+ public final static native void btManifoldResult_setBody0Wrap(long jarg1, btManifoldResult jarg1_, long jarg2, btCollisionObjectWrapper jarg2_);\r
+ public final static native void btManifoldResult_setBody1Wrap(long jarg1, btManifoldResult jarg1_, long jarg2, btCollisionObjectWrapper jarg2_);\r
public final static native long btManifoldResult_getBody0Internal(long jarg1, btManifoldResult jarg1_);\r
public final static native long btManifoldResult_getBody1Internal(long jarg1, btManifoldResult jarg1_);\r
- public final static native long new_btSphereSphereCollisionAlgorithm__SWIG_0(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4);\r
+ public final static native long new_btSphereSphereCollisionAlgorithm__SWIG_0(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_);\r
public final static native long new_btSphereSphereCollisionAlgorithm__SWIG_1(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_);\r
public final static native void delete_btSphereSphereCollisionAlgorithm(long jarg1);\r
public final static native long new_btBoxBoxCollisionAlgorithm__SWIG_0(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_);\r
- public final static native long new_btBoxBoxCollisionAlgorithm__SWIG_1(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4);\r
+ public final static native long new_btBoxBoxCollisionAlgorithm__SWIG_1(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_);\r
public final static native void delete_btBoxBoxCollisionAlgorithm(long jarg1);\r
public final static native void btCollisionAlgorithmCreateFunc_m_swapped_set(long jarg1, btCollisionAlgorithmCreateFunc jarg1_, boolean jarg2);\r
public final static native boolean btCollisionAlgorithmCreateFunc_m_swapped_get(long jarg1, btCollisionAlgorithmCreateFunc jarg1_);\r
public final static native long new_btCollisionAlgorithmCreateFunc();\r
public final static native void delete_btCollisionAlgorithmCreateFunc(long jarg1);\r
- public final static native long btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm(long jarg1, btCollisionAlgorithmCreateFunc jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4);\r
+ public final static native long btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm(long jarg1, btCollisionAlgorithmCreateFunc jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_);\r
public final static native long new_btBox2dBox2dCollisionAlgorithm__SWIG_0(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_);\r
- public final static native long new_btBox2dBox2dCollisionAlgorithm__SWIG_1(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4);\r
+ public final static native long new_btBox2dBox2dCollisionAlgorithm__SWIG_1(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_);\r
public final static native void delete_btBox2dBox2dCollisionAlgorithm(long jarg1);\r
public final static native void btElement_m_id_set(long jarg1, btElement jarg1_, int jarg2);\r
public final static native int btElement_m_id_get(long jarg1, btElement jarg1_);\r
public final static native int btUnionFind_find__SWIG_0(long jarg1, btUnionFind jarg1_, int jarg2, int jarg3);\r
public final static native void btUnionFind_unite(long jarg1, btUnionFind jarg1_, int jarg2, int jarg3);\r
public final static native int btUnionFind_find__SWIG_1(long jarg1, btUnionFind jarg1_, int jarg2);\r
- public final static native long new_btSphereTriangleCollisionAlgorithm__SWIG_0(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4, boolean jarg5);\r
+ public final static native long new_btSphereTriangleCollisionAlgorithm__SWIG_0(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_, boolean jarg5);\r
public final static native long new_btSphereTriangleCollisionAlgorithm__SWIG_1(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_);\r
public final static native void delete_btSphereTriangleCollisionAlgorithm(long jarg1);\r
public final static native long new_btSimulationIslandManager();\r
public final static native long RayResultCallback_m_flags_get(long jarg1, RayResultCallback jarg1_);\r
public final static native void delete_RayResultCallback(long jarg1);\r
public final static native boolean RayResultCallback_hasHit(long jarg1, RayResultCallback jarg1_);\r
+ public final static native long new_RayResultCallback();\r
public final static native boolean RayResultCallback_needsCollision(long jarg1, RayResultCallback jarg1_, long jarg2, btBroadphaseProxy jarg2_);\r
+ public final static native boolean RayResultCallback_needsCollisionSwigExplicitRayResultCallback(long jarg1, RayResultCallback jarg1_, long jarg2, btBroadphaseProxy jarg2_);\r
public final static native float RayResultCallback_addSingleResult(long jarg1, RayResultCallback jarg1_, long jarg2, LocalRayResult jarg2_, boolean jarg3);\r
+ public final static native void RayResultCallback_director_connect(RayResultCallback obj, long cptr, boolean mem_own, boolean weak_global);\r
+ public final static native void RayResultCallback_change_ownership(RayResultCallback obj, long cptr, boolean take_or_release);\r
public final static native long new_ClosestRayResultCallback(Vector3 jarg1, Vector3 jarg2);\r
public final static native void ClosestRayResultCallback_m_rayFromWorld_set(long jarg1, ClosestRayResultCallback jarg1_, long jarg2, btVector3 jarg2_);\r
public final static native long ClosestRayResultCallback_m_rayFromWorld_get(long jarg1, ClosestRayResultCallback jarg1_);\r
public final static native long ClosestRayResultCallback_m_hitNormalWorld_get(long jarg1, ClosestRayResultCallback jarg1_);\r
public final static native void ClosestRayResultCallback_m_hitPointWorld_set(long jarg1, ClosestRayResultCallback jarg1_, long jarg2, btVector3 jarg2_);\r
public final static native long ClosestRayResultCallback_m_hitPointWorld_get(long jarg1, ClosestRayResultCallback jarg1_);\r
+ public final static native float ClosestRayResultCallback_addSingleResult(long jarg1, ClosestRayResultCallback jarg1_, long jarg2, LocalRayResult jarg2_, boolean jarg3);\r
+ public final static native float ClosestRayResultCallback_addSingleResultSwigExplicitClosestRayResultCallback(long jarg1, ClosestRayResultCallback jarg1_, long jarg2, LocalRayResult jarg2_, boolean jarg3);\r
public final static native void delete_ClosestRayResultCallback(long jarg1);\r
+ public final static native void ClosestRayResultCallback_director_connect(ClosestRayResultCallback obj, long cptr, boolean mem_own, boolean weak_global);\r
+ public final static native void ClosestRayResultCallback_change_ownership(ClosestRayResultCallback obj, long cptr, boolean take_or_release);\r
public final static native long new_AllHitsRayResultCallback(Vector3 jarg1, Vector3 jarg2);\r
public final static native void AllHitsRayResultCallback_m_collisionObjects_set(long jarg1, AllHitsRayResultCallback jarg1_, long jarg2);\r
public final static native long AllHitsRayResultCallback_m_collisionObjects_get(long jarg1, AllHitsRayResultCallback jarg1_);\r
public final static native long AllHitsRayResultCallback_m_hitPointWorld_get(long jarg1, AllHitsRayResultCallback jarg1_);\r
public final static native void AllHitsRayResultCallback_m_hitFractions_set(long jarg1, AllHitsRayResultCallback jarg1_, long jarg2);\r
public final static native long AllHitsRayResultCallback_m_hitFractions_get(long jarg1, AllHitsRayResultCallback jarg1_);\r
+ public final static native float AllHitsRayResultCallback_addSingleResult(long jarg1, AllHitsRayResultCallback jarg1_, long jarg2, LocalRayResult jarg2_, boolean jarg3);\r
+ public final static native float AllHitsRayResultCallback_addSingleResultSwigExplicitAllHitsRayResultCallback(long jarg1, AllHitsRayResultCallback jarg1_, long jarg2, LocalRayResult jarg2_, boolean jarg3);\r
public final static native void delete_AllHitsRayResultCallback(long jarg1);\r
+ public final static native void AllHitsRayResultCallback_director_connect(AllHitsRayResultCallback obj, long cptr, boolean mem_own, boolean weak_global);\r
+ public final static native void AllHitsRayResultCallback_change_ownership(AllHitsRayResultCallback obj, long cptr, boolean take_or_release);\r
public final static native long new_LocalConvexResult(long jarg1, btCollisionObject jarg1_, long jarg2, LocalShapeInfo jarg2_, Vector3 jarg3, Vector3 jarg4, float jarg5);\r
public final static native void LocalConvexResult_m_hitCollisionObject_set(long jarg1, LocalConvexResult jarg1_, long jarg2, btCollisionObject jarg2_);\r
public final static native long LocalConvexResult_m_hitCollisionObject_get(long jarg1, LocalConvexResult jarg1_);\r
public final static native short ConvexResultCallback_m_collisionFilterGroup_get(long jarg1, ConvexResultCallback jarg1_);\r
public final static native void ConvexResultCallback_m_collisionFilterMask_set(long jarg1, ConvexResultCallback jarg1_, short jarg2);\r
public final static native short ConvexResultCallback_m_collisionFilterMask_get(long jarg1, ConvexResultCallback jarg1_);\r
+ public final static native long new_ConvexResultCallback();\r
public final static native void delete_ConvexResultCallback(long jarg1);\r
public final static native boolean ConvexResultCallback_hasHit(long jarg1, ConvexResultCallback jarg1_);\r
public final static native boolean ConvexResultCallback_needsCollision(long jarg1, ConvexResultCallback jarg1_, long jarg2, btBroadphaseProxy jarg2_);\r
+ public final static native boolean ConvexResultCallback_needsCollisionSwigExplicitConvexResultCallback(long jarg1, ConvexResultCallback jarg1_, long jarg2, btBroadphaseProxy jarg2_);\r
public final static native float ConvexResultCallback_addSingleResult(long jarg1, ConvexResultCallback jarg1_, long jarg2, LocalConvexResult jarg2_, boolean jarg3);\r
+ public final static native void ConvexResultCallback_director_connect(ConvexResultCallback obj, long cptr, boolean mem_own, boolean weak_global);\r
+ public final static native void ConvexResultCallback_change_ownership(ConvexResultCallback obj, long cptr, boolean take_or_release);\r
public final static native long new_ClosestConvexResultCallback(Vector3 jarg1, Vector3 jarg2);\r
public final static native void ClosestConvexResultCallback_m_convexFromWorld_set(long jarg1, ClosestConvexResultCallback jarg1_, long jarg2, btVector3 jarg2_);\r
public final static native long ClosestConvexResultCallback_m_convexFromWorld_get(long jarg1, ClosestConvexResultCallback jarg1_);\r
public final static native long ClosestConvexResultCallback_m_hitPointWorld_get(long jarg1, ClosestConvexResultCallback jarg1_);\r
public final static native void ClosestConvexResultCallback_m_hitCollisionObject_set(long jarg1, ClosestConvexResultCallback jarg1_, long jarg2, btCollisionObject jarg2_);\r
public final static native long ClosestConvexResultCallback_m_hitCollisionObject_get(long jarg1, ClosestConvexResultCallback jarg1_);\r
+ public final static native float ClosestConvexResultCallback_addSingleResult(long jarg1, ClosestConvexResultCallback jarg1_, long jarg2, LocalConvexResult jarg2_, boolean jarg3);\r
+ public final static native float ClosestConvexResultCallback_addSingleResultSwigExplicitClosestConvexResultCallback(long jarg1, ClosestConvexResultCallback jarg1_, long jarg2, LocalConvexResult jarg2_, boolean jarg3);\r
public final static native void delete_ClosestConvexResultCallback(long jarg1);\r
+ public final static native void ClosestConvexResultCallback_director_connect(ClosestConvexResultCallback obj, long cptr, boolean mem_own, boolean weak_global);\r
+ public final static native void ClosestConvexResultCallback_change_ownership(ClosestConvexResultCallback obj, long cptr, boolean take_or_release);\r
public final static native void ContactResultCallback_m_collisionFilterGroup_set(long jarg1, ContactResultCallback jarg1_, short jarg2);\r
public final static native short ContactResultCallback_m_collisionFilterGroup_get(long jarg1, ContactResultCallback jarg1_);\r
public final static native void ContactResultCallback_m_collisionFilterMask_set(long jarg1, ContactResultCallback jarg1_, short jarg2);\r
public final static native short ContactResultCallback_m_collisionFilterMask_get(long jarg1, ContactResultCallback jarg1_);\r
+ public final static native long new_ContactResultCallback();\r
public final static native void delete_ContactResultCallback(long jarg1);\r
public final static native boolean ContactResultCallback_needsCollision(long jarg1, ContactResultCallback jarg1_, long jarg2, btBroadphaseProxy jarg2_);\r
- public final static native float ContactResultCallback_addSingleResult(long jarg1, ContactResultCallback jarg1_, long jarg2, btManifoldPoint jarg2_, long jarg3, int jarg4, int jarg5, long jarg6, int jarg7, int jarg8);\r
+ public final static native boolean ContactResultCallback_needsCollisionSwigExplicitContactResultCallback(long jarg1, ContactResultCallback jarg1_, long jarg2, btBroadphaseProxy jarg2_);\r
+ public final static native float ContactResultCallback_addSingleResult(long jarg1, ContactResultCallback jarg1_, long jarg2, btManifoldPoint jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, int jarg4, int jarg5, long jarg6, btCollisionObjectWrapper jarg6_, int jarg7, int jarg8);\r
+ public final static native void ContactResultCallback_director_connect(ContactResultCallback obj, long cptr, boolean mem_own, boolean weak_global);\r
+ public final static native void ContactResultCallback_change_ownership(ContactResultCallback obj, long cptr, boolean take_or_release);\r
public final static native long new_btCollisionWorld(long jarg1, btDispatcher jarg1_, long jarg2, btBroadphaseInterface jarg2_, long jarg3, btCollisionConfiguration jarg3_);\r
public final static native void delete_btCollisionWorld(long jarg1);\r
public final static native void btCollisionWorld_setBroadphase(long jarg1, btCollisionWorld jarg1_, long jarg2, btBroadphaseInterface jarg2_);\r
public final static native void btCollisionWorld_contactTest(long jarg1, btCollisionWorld jarg1_, long jarg2, btCollisionObject jarg2_, long jarg3, ContactResultCallback jarg3_);\r
public final static native void btCollisionWorld_contactPairTest(long jarg1, btCollisionWorld jarg1_, long jarg2, btCollisionObject jarg2_, long jarg3, btCollisionObject jarg3_, long jarg4, ContactResultCallback jarg4_);\r
public final static native void btCollisionWorld_rayTestSingle(Matrix4 jarg1, Matrix4 jarg2, long jarg3, btCollisionObject jarg3_, long jarg4, btCollisionShape jarg4_, Matrix4 jarg5, long jarg6, RayResultCallback jarg6_);\r
- public final static native void btCollisionWorld_rayTestSingleInternal(Matrix4 jarg1, Matrix4 jarg2, long jarg3, long jarg4, RayResultCallback jarg4_);\r
+ public final static native void btCollisionWorld_rayTestSingleInternal(Matrix4 jarg1, Matrix4 jarg2, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, RayResultCallback jarg4_);\r
public final static native void btCollisionWorld_objectQuerySingle(long jarg1, btConvexShape jarg1_, Matrix4 jarg2, Matrix4 jarg3, long jarg4, btCollisionObject jarg4_, long jarg5, btCollisionShape jarg5_, Matrix4 jarg6, long jarg7, ConvexResultCallback jarg7_, float jarg8);\r
- public final static native void btCollisionWorld_objectQuerySingleInternal(long jarg1, btConvexShape jarg1_, Matrix4 jarg2, Matrix4 jarg3, long jarg4, long jarg5, ConvexResultCallback jarg5_, float jarg6);\r
+ public final static native void btCollisionWorld_objectQuerySingleInternal(long jarg1, btConvexShape jarg1_, Matrix4 jarg2, Matrix4 jarg3, long jarg4, btCollisionObjectWrapper jarg4_, long jarg5, ConvexResultCallback jarg5_, float jarg6);\r
public final static native void btCollisionWorld_addCollisionObject__SWIG_0(long jarg1, btCollisionWorld jarg1_, long jarg2, btCollisionObject jarg2_, short jarg3, short jarg4);\r
public final static native void btCollisionWorld_addCollisionObject__SWIG_1(long jarg1, btCollisionWorld jarg1_, long jarg2, btCollisionObject jarg2_, short jarg3);\r
public final static native void btCollisionWorld_addCollisionObject__SWIG_2(long jarg1, btCollisionWorld jarg1_, long jarg2, btCollisionObject jarg2_);\r
public final static native void delete_ClosestNotMeConvexResultCallback(long jarg1);\r
public final static native long new_ClosestNotMeRayResultCallback(long jarg1, btCollisionObject jarg1_);\r
public final static native void delete_ClosestNotMeRayResultCallback(long jarg1);\r
- public final static native long new_btConvex2dConvex2dAlgorithm(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4, long jarg5, long jarg6, btConvexPenetrationDepthSolver jarg6_, int jarg7, int jarg8);\r
+ public final static native long new_btConvex2dConvex2dAlgorithm(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_, long jarg5, long jarg6, btConvexPenetrationDepthSolver jarg6_, int jarg7, int jarg8);\r
public final static native void delete_btConvex2dConvex2dAlgorithm(long jarg1);\r
public final static native void btConvex2dConvex2dAlgorithm_setLowLevelOfDetail(long jarg1, btConvex2dConvex2dAlgorithm jarg1_, boolean jarg2);\r
public final static native long btConvex2dConvex2dAlgorithm_getManifold(long jarg1, btConvex2dConvex2dAlgorithm jarg1_);\r
public final static native void delete_btBoxBoxDetector(long jarg1);\r
public final static native void btBoxBoxDetector_getClosestPoints__SWIG_0(long jarg1, btBoxBoxDetector jarg1_, long jarg2, ClosestPointInput jarg2_, long jarg3, Result jarg3_, long jarg4, btIDebugDraw jarg4_, boolean jarg5);\r
public final static native void btBoxBoxDetector_getClosestPoints__SWIG_1(long jarg1, btBoxBoxDetector jarg1_, long jarg2, ClosestPointInput jarg2_, long jarg3, Result jarg3_, long jarg4, btIDebugDraw jarg4_);\r
- public final static native long new_btSphereBoxCollisionAlgorithm(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4, boolean jarg5);\r
+ public final static native long new_btSphereBoxCollisionAlgorithm(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_, boolean jarg5);\r
public final static native void delete_btSphereBoxCollisionAlgorithm(long jarg1);\r
- public final static native boolean btSphereBoxCollisionAlgorithm_getSphereDistance(long jarg1, btSphereBoxCollisionAlgorithm jarg1_, long jarg2, Vector3 jarg3, Vector3 jarg4, long jarg5, Vector3 jarg6, float jarg7, float jarg8);\r
+ public final static native boolean btSphereBoxCollisionAlgorithm_getSphereDistance(long jarg1, btSphereBoxCollisionAlgorithm jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, Vector3 jarg3, Vector3 jarg4, long jarg5, Vector3 jarg6, float jarg7, float jarg8);\r
public final static native float btSphereBoxCollisionAlgorithm_getSpherePenetration(long jarg1, btSphereBoxCollisionAlgorithm jarg1_, Vector3 jarg2, Vector3 jarg3, Vector3 jarg4, Vector3 jarg5);\r
public final static native int btCollisionDispatcher_getDispatcherFlags(long jarg1, btCollisionDispatcher jarg1_);\r
public final static native void btCollisionDispatcher_setDispatcherFlags(long jarg1, btCollisionDispatcher jarg1_, int jarg2);\r
public final static native long btCollisionDispatcher_getManifoldByIndexInternal__SWIG_0(long jarg1, btCollisionDispatcher jarg1_, int jarg2);\r
public final static native long new_btCollisionDispatcher(long jarg1, btCollisionConfiguration jarg1_);\r
public final static native void delete_btCollisionDispatcher(long jarg1);\r
- public final static native long btCollisionDispatcher_findAlgorithm__SWIG_0(long jarg1, btCollisionDispatcher jarg1_, long jarg2, long jarg3, long jarg4, btPersistentManifold jarg4_);\r
- public final static native long btCollisionDispatcher_findAlgorithm__SWIG_1(long jarg1, btCollisionDispatcher jarg1_, long jarg2, long jarg3);\r
+ public final static native long btCollisionDispatcher_findAlgorithm__SWIG_0(long jarg1, btCollisionDispatcher jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btPersistentManifold jarg4_);\r
+ public final static native long btCollisionDispatcher_findAlgorithm__SWIG_1(long jarg1, btCollisionDispatcher jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_);\r
public final static native void btCollisionDispatcher_setNearCallback(long jarg1, btCollisionDispatcher jarg1_, long jarg2);\r
public final static native long btCollisionDispatcher_getNearCallback(long jarg1, btCollisionDispatcher jarg1_);\r
public final static native void btCollisionDispatcher_defaultNearCallback(long jarg1, btBroadphasePair jarg1_, long jarg2, btCollisionDispatcher jarg2_, long jarg3, btDispatcherInfo jarg3_);\r
public final static native long btCollisionDispatcher_getCollisionConfiguration__SWIG_0(long jarg1, btCollisionDispatcher jarg1_);\r
public final static native void btCollisionDispatcher_setCollisionConfiguration(long jarg1, btCollisionDispatcher jarg1_, long jarg2, btCollisionConfiguration jarg2_);\r
public final static native long btCollisionDispatcher_getInternalManifoldPool__SWIG_0(long jarg1, btCollisionDispatcher jarg1_);\r
- public final static native long new_btConvexConvexAlgorithm(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4, long jarg5, long jarg6, btConvexPenetrationDepthSolver jarg6_, int jarg7, int jarg8);\r
+ public final static native long new_btConvexConvexAlgorithm(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_, long jarg5, long jarg6, btConvexPenetrationDepthSolver jarg6_, int jarg7, int jarg8);\r
public final static native void delete_btConvexConvexAlgorithm(long jarg1);\r
public final static native void btConvexConvexAlgorithm_setLowLevelOfDetail(long jarg1, btConvexConvexAlgorithm jarg1_, boolean jarg2);\r
public final static native long btConvexConvexAlgorithm_getManifold(long jarg1, btConvexConvexAlgorithm jarg1_);\r
public final static native void delete_SphereTriangleDetector(long jarg1);\r
public final static native boolean SphereTriangleDetector_collide(long jarg1, SphereTriangleDetector jarg1_, Vector3 jarg2, Vector3 jarg3, Vector3 jarg4, long jarg5, long jarg6, float jarg7);\r
public final static native void btGenerateInternalEdgeInfo(long jarg1, btBvhTriangleMeshShape jarg1_, long jarg2, btTriangleInfoMap jarg2_);\r
- public final static native void btAdjustInternalEdgeContacts__SWIG_0(long jarg1, btManifoldPoint jarg1_, long jarg2, long jarg3, int jarg4, int jarg5, int jarg6);\r
- public final static native void btAdjustInternalEdgeContacts__SWIG_1(long jarg1, btManifoldPoint jarg1_, long jarg2, long jarg3, int jarg4, int jarg5);\r
- public final static native long new_btCompoundCollisionAlgorithm(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_, long jarg2, long jarg3, boolean jarg4);\r
+ public final static native void btAdjustInternalEdgeContacts__SWIG_0(long jarg1, btManifoldPoint jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, int jarg4, int jarg5, int jarg6);\r
+ public final static native void btAdjustInternalEdgeContacts__SWIG_1(long jarg1, btManifoldPoint jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, int jarg4, int jarg5);\r
+ public final static native long new_btCompoundCollisionAlgorithm(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, boolean jarg4);\r
public final static native void delete_btCompoundCollisionAlgorithm(long jarg1);\r
public final static native void delete_btConvexCast(long jarg1);\r
public final static native boolean btConvexCast_calcTimeOfImpact(long jarg1, btConvexCast jarg1_, Matrix4 jarg2, Matrix4 jarg3, Matrix4 jarg4, Matrix4 jarg5, long jarg6);\r
public final static native void btSoftBodySolver_predictMotion(long jarg1, btSoftBodySolver jarg1_, float jarg2);\r
public final static native void btSoftBodySolver_solveConstraints(long jarg1, btSoftBodySolver jarg1_, float jarg2);\r
public final static native void btSoftBodySolver_updateSoftBodies(long jarg1, btSoftBodySolver jarg1_);\r
- public final static native void btSoftBodySolver_processCollision__SWIG_0(long jarg1, btSoftBodySolver jarg1_, long jarg2, btSoftBody jarg2_, long jarg3);\r
+ public final static native void btSoftBodySolver_processCollision__SWIG_0(long jarg1, btSoftBodySolver jarg1_, long jarg2, btSoftBody jarg2_, long jarg3, btCollisionObjectWrapper jarg3_);\r
public final static native void btSoftBodySolver_processCollision__SWIG_1(long jarg1, btSoftBodySolver jarg1_, long jarg2, btSoftBody jarg2_, long jarg3, btSoftBody jarg3_);\r
public final static native void btSoftBodySolver_setNumberOfPositionIterations(long jarg1, btSoftBodySolver jarg1_, int jarg2);\r
public final static native int btSoftBodySolver_getNumberOfPositionIterations(long jarg1, btSoftBodySolver jarg1_);\r
public final static native void btDefaultSoftBodySolver_copyBackToSoftBodies__SWIG_0(long jarg1, btDefaultSoftBodySolver jarg1_, boolean jarg2);\r
public final static native void btDefaultSoftBodySolver_copyBackToSoftBodies__SWIG_1(long jarg1, btDefaultSoftBodySolver jarg1_);\r
public final static native void btDefaultSoftBodySolver_copySoftBodyToVertexBuffer(long jarg1, btDefaultSoftBodySolver jarg1_, long jarg2, btSoftBody jarg2_, long jarg3, btVertexBufferDescriptor jarg3_);\r
- public final static native void btDefaultSoftBodySolver_processCollision__SWIG_0(long jarg1, btDefaultSoftBodySolver jarg1_, long jarg2, btSoftBody jarg2_, long jarg3);\r
+ public final static native void btDefaultSoftBodySolver_processCollision__SWIG_0(long jarg1, btDefaultSoftBodySolver jarg1_, long jarg2, btSoftBody jarg2_, long jarg3, btCollisionObjectWrapper jarg3_);\r
public final static native void btDefaultSoftBodySolver_processCollision__SWIG_1(long jarg1, btDefaultSoftBodySolver jarg1_, long jarg2, btSoftBody jarg2_, long jarg3, btSoftBody jarg3_);\r
public final static native void sCti_m_colObj_set(long jarg1, sCti jarg1_, long jarg2, btCollisionObject jarg2_);\r
public final static native long sCti_m_colObj_get(long jarg1, sCti jarg1_);\r
public final static native void btSoftBody_solveCommonConstraints(long jarg1, int jarg2, int jarg3);\r
public final static native void btSoftBody_solveClusters__SWIG_0(long jarg1);\r
public final static native void btSoftBody_integrateMotion(long jarg1, btSoftBody jarg1_);\r
- public final static native void btSoftBody_defaultCollisionHandler__SWIG_0(long jarg1, btSoftBody jarg1_, long jarg2);\r
+ public final static native void btSoftBody_defaultCollisionHandler__SWIG_0(long jarg1, btSoftBody jarg1_, long jarg2, btCollisionObjectWrapper jarg2_);\r
public final static native void btSoftBody_defaultCollisionHandler__SWIG_1(long jarg1, btSoftBody jarg1_, long jarg2, btSoftBody jarg2_);\r
public final static native void btSoftBody_setWindVelocity(long jarg1, btSoftBody jarg1_, Vector3 jarg2);\r
public final static native Vector3 btSoftBody_getWindVelocity(long jarg1, btSoftBody jarg1_);\r
public final static native int btSoftBody_rayTest__SWIG_1(long jarg1, btSoftBody jarg1_, Vector3 jarg2, Vector3 jarg3, long jarg4, long jarg5, long jarg6, boolean jarg7);\r
public final static native void btSoftBody_initializeFaceTree(long jarg1, btSoftBody jarg1_);\r
public final static native Vector3 btSoftBody_evaluateCom(long jarg1, btSoftBody jarg1_);\r
- public final static native boolean btSoftBody_checkContact(long jarg1, btSoftBody jarg1_, long jarg2, Vector3 jarg3, float jarg4, long jarg5, sCti jarg5_);\r
+ public final static native boolean btSoftBody_checkContact(long jarg1, btSoftBody jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, Vector3 jarg3, float jarg4, long jarg5, sCti jarg5_);\r
public final static native void btSoftBody_updateNormals(long jarg1, btSoftBody jarg1_);\r
public final static native void btSoftBody_updateBounds(long jarg1, btSoftBody jarg1_);\r
public final static native void btSoftBody_updatePose(long jarg1, btSoftBody jarg1_);\r
public final static native void delete_btTriIndex(long jarg1);\r
public final static native void btSoftBodyTriangleCallback_m_triangleCount_set(long jarg1, btSoftBodyTriangleCallback jarg1_, int jarg2);\r
public final static native int btSoftBodyTriangleCallback_m_triangleCount_get(long jarg1, btSoftBodyTriangleCallback jarg1_);\r
- public final static native long new_btSoftBodyTriangleCallback(long jarg1, btDispatcher jarg1_, long jarg2, long jarg3, boolean jarg4);\r
- public final static native void btSoftBodyTriangleCallback_setTimeStepAndCounters(long jarg1, btSoftBodyTriangleCallback jarg1_, float jarg2, long jarg3, long jarg4, btDispatcherInfo jarg4_, long jarg5, btManifoldResult jarg5_);\r
+ public final static native long new_btSoftBodyTriangleCallback(long jarg1, btDispatcher jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, boolean jarg4);\r
+ public final static native void btSoftBodyTriangleCallback_setTimeStepAndCounters(long jarg1, btSoftBodyTriangleCallback jarg1_, float jarg2, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btDispatcherInfo jarg4_, long jarg5, btManifoldResult jarg5_);\r
public final static native void delete_btSoftBodyTriangleCallback(long jarg1);\r
public final static native void btSoftBodyTriangleCallback_clearCache(long jarg1, btSoftBodyTriangleCallback jarg1_);\r
public final static native Vector3 btSoftBodyTriangleCallback_getAabbMin(long jarg1, btSoftBodyTriangleCallback jarg1_);\r
public final static native Vector3 btSoftBodyTriangleCallback_getAabbMax(long jarg1, btSoftBodyTriangleCallback jarg1_);\r
- public final static native long new_btSoftBodyConcaveCollisionAlgorithm(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_, long jarg2, long jarg3, boolean jarg4);\r
+ public final static native long new_btSoftBodyConcaveCollisionAlgorithm(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_, long jarg2, btCollisionObjectWrapper jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, boolean jarg4);\r
public final static native void delete_btSoftBodyConcaveCollisionAlgorithm(long jarg1);\r
public final static native void btSoftBodyConcaveCollisionAlgorithm_clearCache(long jarg1, btSoftBodyConcaveCollisionAlgorithm jarg1_);\r
public final static native void SoftBodyMaterialData_m_linearStiffness_set(long jarg1, SoftBodyMaterialData jarg1_, float jarg2);\r
public final static native long new_btCPUVertexBufferDescriptor__SWIG_1(java.nio.FloatBuffer jarg1, int jarg2, int jarg3, int jarg4, int jarg5);\r
public final static native void delete_btCPUVertexBufferDescriptor(long jarg1);\r
public final static native java.nio.FloatBuffer btCPUVertexBufferDescriptor_getBasePointer(long jarg1, btCPUVertexBufferDescriptor jarg1_);\r
- public final static native long new_btSoftRigidCollisionAlgorithm(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4, boolean jarg5);\r
+ public final static native long new_btSoftRigidCollisionAlgorithm(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_, boolean jarg5);\r
public final static native void delete_btSoftRigidCollisionAlgorithm(long jarg1);\r
public final static native long new_btSoftRigidDynamicsWorld__SWIG_0(long jarg1, btDispatcher jarg1_, long jarg2, btBroadphaseInterface jarg2_, long jarg3, btConstraintSolver jarg3_, long jarg4, btCollisionConfiguration jarg4_, long jarg5, btSoftBodySolver jarg5_);\r
public final static native long new_btSoftRigidDynamicsWorld__SWIG_1(long jarg1, btDispatcher jarg1_, long jarg2, btBroadphaseInterface jarg2_, long jarg3, btConstraintSolver jarg3_, long jarg4, btCollisionConfiguration jarg4_);\r
public final static native long btSoftRigidDynamicsWorld_getSoftBodyArray__SWIG_0(long jarg1, btSoftRigidDynamicsWorld jarg1_);\r
public final static native void btSoftRigidDynamicsWorld_rayTestSingle(Matrix4 jarg1, Matrix4 jarg2, long jarg3, btCollisionObject jarg3_, long jarg4, btCollisionShape jarg4_, Matrix4 jarg5, long jarg6, RayResultCallback jarg6_);\r
public final static native long new_btSoftSoftCollisionAlgorithm__SWIG_0(long jarg1, btCollisionAlgorithmConstructionInfo jarg1_);\r
- public final static native long new_btSoftSoftCollisionAlgorithm__SWIG_1(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, long jarg4);\r
+ public final static native long new_btSoftSoftCollisionAlgorithm__SWIG_1(long jarg1, btPersistentManifold jarg1_, long jarg2, btCollisionAlgorithmConstructionInfo jarg2_, long jarg3, btCollisionObjectWrapper jarg3_, long jarg4, btCollisionObjectWrapper jarg4_);\r
public final static native void delete_btSoftSoftCollisionAlgorithm(long jarg1);\r
public final static native void delete_btVehicleRaycaster(long jarg1);\r
public final static native long btVehicleRaycaster_castRay(long jarg1, btVehicleRaycaster jarg1_, Vector3 jarg2, Vector3 jarg3, long jarg4);\r
public static void SwigDirector_btMotionState_setWorldTransform(btMotionState self, Matrix4 worldTrans) {\r
self.setWorldTransform(worldTrans);\r
}\r
+ public static boolean SwigDirector_RayResultCallback_needsCollision(RayResultCallback self, long proxy0) {\r
+ return self.needsCollision((proxy0 == 0) ? null : new btBroadphaseProxy(proxy0, false));\r
+ }\r
+ public static float SwigDirector_RayResultCallback_addSingleResult(RayResultCallback self, long rayResult, boolean normalInWorldSpace) {\r
+ return self.addSingleResult(new LocalRayResult(rayResult, false), normalInWorldSpace);\r
+ }\r
+ public static boolean SwigDirector_ClosestRayResultCallback_needsCollision(ClosestRayResultCallback self, long proxy0) {\r
+ return self.needsCollision((proxy0 == 0) ? null : new btBroadphaseProxy(proxy0, false));\r
+ }\r
+ public static float SwigDirector_ClosestRayResultCallback_addSingleResult(ClosestRayResultCallback self, long rayResult, boolean normalInWorldSpace) {\r
+ return self.addSingleResult(new LocalRayResult(rayResult, false), normalInWorldSpace);\r
+ }\r
+ public static boolean SwigDirector_AllHitsRayResultCallback_needsCollision(AllHitsRayResultCallback self, long proxy0) {\r
+ return self.needsCollision((proxy0 == 0) ? null : new btBroadphaseProxy(proxy0, false));\r
+ }\r
+ public static float SwigDirector_AllHitsRayResultCallback_addSingleResult(AllHitsRayResultCallback self, long rayResult, boolean normalInWorldSpace) {\r
+ return self.addSingleResult(new LocalRayResult(rayResult, false), normalInWorldSpace);\r
+ }\r
+ public static boolean SwigDirector_ConvexResultCallback_needsCollision(ConvexResultCallback self, long proxy0) {\r
+ return self.needsCollision((proxy0 == 0) ? null : new btBroadphaseProxy(proxy0, false));\r
+ }\r
+ public static float SwigDirector_ConvexResultCallback_addSingleResult(ConvexResultCallback self, long convexResult, boolean normalInWorldSpace) {\r
+ return self.addSingleResult(new LocalConvexResult(convexResult, false), normalInWorldSpace);\r
+ }\r
+ public static boolean SwigDirector_ClosestConvexResultCallback_needsCollision(ClosestConvexResultCallback self, long proxy0) {\r
+ return self.needsCollision((proxy0 == 0) ? null : new btBroadphaseProxy(proxy0, false));\r
+ }\r
+ public static float SwigDirector_ClosestConvexResultCallback_addSingleResult(ClosestConvexResultCallback self, long convexResult, boolean normalInWorldSpace) {\r
+ return self.addSingleResult(new LocalConvexResult(convexResult, false), normalInWorldSpace);\r
+ }\r
+ public static boolean SwigDirector_ContactResultCallback_needsCollision(ContactResultCallback self, long proxy0) {\r
+ return self.needsCollision((proxy0 == 0) ? null : new btBroadphaseProxy(proxy0, false));\r
+ }\r
+ public static float SwigDirector_ContactResultCallback_addSingleResult(ContactResultCallback self, long cp, long colObj0Wrap, int partId0, int index0, long colObj1Wrap, int partId1, int index1) {\r
+ return self.addSingleResult(new btManifoldPoint(cp, false), (colObj0Wrap == 0) ? null : new btCollisionObjectWrapper(colObj0Wrap, false), partId0, index0, (colObj1Wrap == 0) ? null : new btCollisionObjectWrapper(colObj1Wrap, false), partId1, index1);\r
+ }\r
public static void SwigDirector_InternalTickCallback_onInternalTick(InternalTickCallback self, long dynamicsWorld, float timeStep) {\r
self.onInternalTick((dynamicsWorld == 0) ? null : new btDynamicsWorld(dynamicsWorld, false), timeStep);\r
}\r
namespace Swig {\r
namespace {\r
jclass jclass_gdxBulletJNI = NULL;\r
- jmethodID director_methids[26];\r
+ jmethodID director_methids[38];\r
}\r
}\r
\r
typedef btRigidBody::btRigidBodyConstructionInfo btRigidBodyConstructionInfo;\r
\r
\r
+#include <BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h>\r
+\r
+\r
#include <BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h>\r
\r
\r
}\r
\r
\r
+SwigDirector_RayResultCallback::SwigDirector_RayResultCallback(JNIEnv *jenv) : RayResultCallback(), Swig::Director(jenv) {\r
+}\r
+\r
+SwigDirector_RayResultCallback::~SwigDirector_RayResultCallback() {\r
+ swig_disconnect_director_self("swigDirectorDisconnect");\r
+}\r
+\r
+\r
+bool SwigDirector_RayResultCallback::needsCollision(btBroadphaseProxy *proxy0) const {\r
+ bool c_result = SwigValueInit< bool >() ;\r
+ jboolean jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jproxy0 = 0 ;\r
+ \r
+ if (!swig_override[0]) {\r
+ return RayResultCallback::needsCollision(proxy0);\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; \r
+ jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[25], swigjobj, jproxy0);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = jresult ? true : false; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+btScalar SwigDirector_RayResultCallback::addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace) {\r
+ btScalar c_result = SwigValueInit< btScalar >() ;\r
+ jfloat jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jrayResult = 0 ;\r
+ jboolean jnormalInWorldSpace ;\r
+ \r
+ if (!swig_override[1]) {\r
+ SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method RayResultCallback::addSingleResult.");\r
+ return c_result;\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *(LocalRayResult **)&jrayResult = (LocalRayResult *) &rayResult; \r
+ jnormalInWorldSpace = (jboolean) normalInWorldSpace;\r
+ jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[26], swigjobj, jrayResult, jnormalInWorldSpace);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = (btScalar)jresult; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+void SwigDirector_RayResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {\r
+ static struct {\r
+ const char *mname;\r
+ const char *mdesc;\r
+ jmethodID base_methid;\r
+ } methods[] = {\r
+ {\r
+ "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/btBroadphaseProxy;)Z", NULL \r
+ },\r
+ {\r
+ "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/LocalRayResult;Z)F", NULL \r
+ }\r
+ };\r
+ \r
+ static jclass baseclass = 0 ;\r
+ \r
+ if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {\r
+ if (!baseclass) {\r
+ baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/RayResultCallback");\r
+ if (!baseclass) return;\r
+ baseclass = (jclass) jenv->NewGlobalRef(baseclass);\r
+ }\r
+ bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);\r
+ for (int i = 0; i < 2; ++i) {\r
+ if (!methods[i].base_methid) {\r
+ methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);\r
+ if (!methods[i].base_methid) return;\r
+ }\r
+ swig_override[i] = false;\r
+ if (derived) {\r
+ jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);\r
+ swig_override[i] = (methid != methods[i].base_methid);\r
+ jenv->ExceptionClear();\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+\r
+SwigDirector_ClosestRayResultCallback::SwigDirector_ClosestRayResultCallback(JNIEnv *jenv, btVector3 const &rayFromWorld, btVector3 const &rayToWorld) : ClosestRayResultCallback(rayFromWorld, rayToWorld), Swig::Director(jenv) {\r
+}\r
+\r
+SwigDirector_ClosestRayResultCallback::~SwigDirector_ClosestRayResultCallback() {\r
+ swig_disconnect_director_self("swigDirectorDisconnect");\r
+}\r
+\r
+\r
+bool SwigDirector_ClosestRayResultCallback::needsCollision(btBroadphaseProxy *proxy0) const {\r
+ bool c_result = SwigValueInit< bool >() ;\r
+ jboolean jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jproxy0 = 0 ;\r
+ \r
+ if (!swig_override[0]) {\r
+ return RayResultCallback::needsCollision(proxy0);\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; \r
+ jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[27], swigjobj, jproxy0);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = jresult ? true : false; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+btScalar SwigDirector_ClosestRayResultCallback::addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace) {\r
+ btScalar c_result = SwigValueInit< btScalar >() ;\r
+ jfloat jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jrayResult = 0 ;\r
+ jboolean jnormalInWorldSpace ;\r
+ \r
+ if (!swig_override[1]) {\r
+ return ClosestRayResultCallback::addSingleResult(rayResult,normalInWorldSpace);\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *(LocalRayResult **)&jrayResult = (LocalRayResult *) &rayResult; \r
+ jnormalInWorldSpace = (jboolean) normalInWorldSpace;\r
+ jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[28], swigjobj, jrayResult, jnormalInWorldSpace);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = (btScalar)jresult; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+void SwigDirector_ClosestRayResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {\r
+ static struct {\r
+ const char *mname;\r
+ const char *mdesc;\r
+ jmethodID base_methid;\r
+ } methods[] = {\r
+ {\r
+ "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/btBroadphaseProxy;)Z", NULL \r
+ },\r
+ {\r
+ "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/LocalRayResult;Z)F", NULL \r
+ }\r
+ };\r
+ \r
+ static jclass baseclass = 0 ;\r
+ \r
+ if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {\r
+ if (!baseclass) {\r
+ baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/ClosestRayResultCallback");\r
+ if (!baseclass) return;\r
+ baseclass = (jclass) jenv->NewGlobalRef(baseclass);\r
+ }\r
+ bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);\r
+ for (int i = 0; i < 2; ++i) {\r
+ if (!methods[i].base_methid) {\r
+ methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);\r
+ if (!methods[i].base_methid) return;\r
+ }\r
+ swig_override[i] = false;\r
+ if (derived) {\r
+ jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);\r
+ swig_override[i] = (methid != methods[i].base_methid);\r
+ jenv->ExceptionClear();\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+\r
+SwigDirector_AllHitsRayResultCallback::SwigDirector_AllHitsRayResultCallback(JNIEnv *jenv, btVector3 const &rayFromWorld, btVector3 const &rayToWorld) : AllHitsRayResultCallback(rayFromWorld, rayToWorld), Swig::Director(jenv) {\r
+}\r
+\r
+SwigDirector_AllHitsRayResultCallback::~SwigDirector_AllHitsRayResultCallback() {\r
+ swig_disconnect_director_self("swigDirectorDisconnect");\r
+}\r
+\r
+\r
+bool SwigDirector_AllHitsRayResultCallback::needsCollision(btBroadphaseProxy *proxy0) const {\r
+ bool c_result = SwigValueInit< bool >() ;\r
+ jboolean jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jproxy0 = 0 ;\r
+ \r
+ if (!swig_override[0]) {\r
+ return RayResultCallback::needsCollision(proxy0);\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; \r
+ jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[29], swigjobj, jproxy0);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = jresult ? true : false; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+btScalar SwigDirector_AllHitsRayResultCallback::addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace) {\r
+ btScalar c_result = SwigValueInit< btScalar >() ;\r
+ jfloat jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jrayResult = 0 ;\r
+ jboolean jnormalInWorldSpace ;\r
+ \r
+ if (!swig_override[1]) {\r
+ return AllHitsRayResultCallback::addSingleResult(rayResult,normalInWorldSpace);\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *(LocalRayResult **)&jrayResult = (LocalRayResult *) &rayResult; \r
+ jnormalInWorldSpace = (jboolean) normalInWorldSpace;\r
+ jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[30], swigjobj, jrayResult, jnormalInWorldSpace);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = (btScalar)jresult; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+void SwigDirector_AllHitsRayResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {\r
+ static struct {\r
+ const char *mname;\r
+ const char *mdesc;\r
+ jmethodID base_methid;\r
+ } methods[] = {\r
+ {\r
+ "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/btBroadphaseProxy;)Z", NULL \r
+ },\r
+ {\r
+ "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/LocalRayResult;Z)F", NULL \r
+ }\r
+ };\r
+ \r
+ static jclass baseclass = 0 ;\r
+ \r
+ if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {\r
+ if (!baseclass) {\r
+ baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/AllHitsRayResultCallback");\r
+ if (!baseclass) return;\r
+ baseclass = (jclass) jenv->NewGlobalRef(baseclass);\r
+ }\r
+ bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);\r
+ for (int i = 0; i < 2; ++i) {\r
+ if (!methods[i].base_methid) {\r
+ methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);\r
+ if (!methods[i].base_methid) return;\r
+ }\r
+ swig_override[i] = false;\r
+ if (derived) {\r
+ jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);\r
+ swig_override[i] = (methid != methods[i].base_methid);\r
+ jenv->ExceptionClear();\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+\r
+SwigDirector_ConvexResultCallback::SwigDirector_ConvexResultCallback(JNIEnv *jenv) : ConvexResultCallback(), Swig::Director(jenv) {\r
+}\r
+\r
+SwigDirector_ConvexResultCallback::~SwigDirector_ConvexResultCallback() {\r
+ swig_disconnect_director_self("swigDirectorDisconnect");\r
+}\r
+\r
+\r
+bool SwigDirector_ConvexResultCallback::needsCollision(btBroadphaseProxy *proxy0) const {\r
+ bool c_result = SwigValueInit< bool >() ;\r
+ jboolean jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jproxy0 = 0 ;\r
+ \r
+ if (!swig_override[0]) {\r
+ return ConvexResultCallback::needsCollision(proxy0);\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; \r
+ jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[31], swigjobj, jproxy0);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = jresult ? true : false; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+btScalar SwigDirector_ConvexResultCallback::addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace) {\r
+ btScalar c_result = SwigValueInit< btScalar >() ;\r
+ jfloat jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jconvexResult = 0 ;\r
+ jboolean jnormalInWorldSpace ;\r
+ \r
+ if (!swig_override[1]) {\r
+ SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ConvexResultCallback::addSingleResult.");\r
+ return c_result;\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *(LocalConvexResult **)&jconvexResult = (LocalConvexResult *) &convexResult; \r
+ jnormalInWorldSpace = (jboolean) normalInWorldSpace;\r
+ jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[32], swigjobj, jconvexResult, jnormalInWorldSpace);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = (btScalar)jresult; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+void SwigDirector_ConvexResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {\r
+ static struct {\r
+ const char *mname;\r
+ const char *mdesc;\r
+ jmethodID base_methid;\r
+ } methods[] = {\r
+ {\r
+ "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/btBroadphaseProxy;)Z", NULL \r
+ },\r
+ {\r
+ "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/LocalConvexResult;Z)F", NULL \r
+ }\r
+ };\r
+ \r
+ static jclass baseclass = 0 ;\r
+ \r
+ if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {\r
+ if (!baseclass) {\r
+ baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/ConvexResultCallback");\r
+ if (!baseclass) return;\r
+ baseclass = (jclass) jenv->NewGlobalRef(baseclass);\r
+ }\r
+ bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);\r
+ for (int i = 0; i < 2; ++i) {\r
+ if (!methods[i].base_methid) {\r
+ methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);\r
+ if (!methods[i].base_methid) return;\r
+ }\r
+ swig_override[i] = false;\r
+ if (derived) {\r
+ jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);\r
+ swig_override[i] = (methid != methods[i].base_methid);\r
+ jenv->ExceptionClear();\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+\r
+SwigDirector_ClosestConvexResultCallback::SwigDirector_ClosestConvexResultCallback(JNIEnv *jenv, btVector3 const &convexFromWorld, btVector3 const &convexToWorld) : ClosestConvexResultCallback(convexFromWorld, convexToWorld), Swig::Director(jenv) {\r
+}\r
+\r
+SwigDirector_ClosestConvexResultCallback::~SwigDirector_ClosestConvexResultCallback() {\r
+ swig_disconnect_director_self("swigDirectorDisconnect");\r
+}\r
+\r
+\r
+bool SwigDirector_ClosestConvexResultCallback::needsCollision(btBroadphaseProxy *proxy0) const {\r
+ bool c_result = SwigValueInit< bool >() ;\r
+ jboolean jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jproxy0 = 0 ;\r
+ \r
+ if (!swig_override[0]) {\r
+ return ConvexResultCallback::needsCollision(proxy0);\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; \r
+ jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[33], swigjobj, jproxy0);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = jresult ? true : false; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+btScalar SwigDirector_ClosestConvexResultCallback::addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace) {\r
+ btScalar c_result = SwigValueInit< btScalar >() ;\r
+ jfloat jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jconvexResult = 0 ;\r
+ jboolean jnormalInWorldSpace ;\r
+ \r
+ if (!swig_override[1]) {\r
+ return ClosestConvexResultCallback::addSingleResult(convexResult,normalInWorldSpace);\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *(LocalConvexResult **)&jconvexResult = (LocalConvexResult *) &convexResult; \r
+ jnormalInWorldSpace = (jboolean) normalInWorldSpace;\r
+ jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[34], swigjobj, jconvexResult, jnormalInWorldSpace);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = (btScalar)jresult; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+void SwigDirector_ClosestConvexResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {\r
+ static struct {\r
+ const char *mname;\r
+ const char *mdesc;\r
+ jmethodID base_methid;\r
+ } methods[] = {\r
+ {\r
+ "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/btBroadphaseProxy;)Z", NULL \r
+ },\r
+ {\r
+ "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/LocalConvexResult;Z)F", NULL \r
+ }\r
+ };\r
+ \r
+ static jclass baseclass = 0 ;\r
+ \r
+ if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {\r
+ if (!baseclass) {\r
+ baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/ClosestConvexResultCallback");\r
+ if (!baseclass) return;\r
+ baseclass = (jclass) jenv->NewGlobalRef(baseclass);\r
+ }\r
+ bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);\r
+ for (int i = 0; i < 2; ++i) {\r
+ if (!methods[i].base_methid) {\r
+ methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);\r
+ if (!methods[i].base_methid) return;\r
+ }\r
+ swig_override[i] = false;\r
+ if (derived) {\r
+ jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);\r
+ swig_override[i] = (methid != methods[i].base_methid);\r
+ jenv->ExceptionClear();\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+\r
+SwigDirector_ContactResultCallback::SwigDirector_ContactResultCallback(JNIEnv *jenv) : ContactResultCallback(), Swig::Director(jenv) {\r
+}\r
+\r
+SwigDirector_ContactResultCallback::~SwigDirector_ContactResultCallback() {\r
+ swig_disconnect_director_self("swigDirectorDisconnect");\r
+}\r
+\r
+\r
+bool SwigDirector_ContactResultCallback::needsCollision(btBroadphaseProxy *proxy0) const {\r
+ bool c_result = SwigValueInit< bool >() ;\r
+ jboolean jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jproxy0 = 0 ;\r
+ \r
+ if (!swig_override[0]) {\r
+ return ContactResultCallback::needsCollision(proxy0);\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *((btBroadphaseProxy **)&jproxy0) = (btBroadphaseProxy *) proxy0; \r
+ jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[35], swigjobj, jproxy0);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = jresult ? true : false; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+btScalar SwigDirector_ContactResultCallback::addSingleResult(btManifoldPoint &cp, btCollisionObjectWrapper const *colObj0Wrap, int partId0, int index0, btCollisionObjectWrapper const *colObj1Wrap, int partId1, int index1) {\r
+ btScalar c_result = SwigValueInit< btScalar >() ;\r
+ jfloat jresult = 0 ;\r
+ JNIEnvWrapper swigjnienv(this) ;\r
+ JNIEnv * jenv = swigjnienv.getJNIEnv() ;\r
+ jobject swigjobj = (jobject) NULL ;\r
+ jlong jcp = 0 ;\r
+ jlong jcolObj0Wrap = 0 ;\r
+ jint jpartId0 ;\r
+ jint jindex0 ;\r
+ jlong jcolObj1Wrap = 0 ;\r
+ jint jpartId1 ;\r
+ jint jindex1 ;\r
+ \r
+ if (!swig_override[1]) {\r
+ SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method ContactResultCallback::addSingleResult.");\r
+ return c_result;\r
+ }\r
+ swigjobj = swig_get_self(jenv);\r
+ if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
+ *(btManifoldPoint **)&jcp = (btManifoldPoint *) &cp; \r
+ *((btCollisionObjectWrapper **)&jcolObj0Wrap) = (btCollisionObjectWrapper *) colObj0Wrap; \r
+ jpartId0 = (jint) partId0;\r
+ jindex0 = (jint) index0;\r
+ *((btCollisionObjectWrapper **)&jcolObj1Wrap) = (btCollisionObjectWrapper *) colObj1Wrap; \r
+ jpartId1 = (jint) partId1;\r
+ jindex1 = (jint) index1;\r
+ jresult = (jfloat) jenv->CallStaticFloatMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[36], swigjobj, jcp, jcolObj0Wrap, jpartId0, jindex0, jcolObj1Wrap, jpartId1, jindex1);\r
+ if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;\r
+ c_result = (btScalar)jresult; \r
+ } else {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
+ }\r
+ if (swigjobj) jenv->DeleteLocalRef(swigjobj);\r
+ return c_result;\r
+}\r
+\r
+void SwigDirector_ContactResultCallback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {\r
+ static struct {\r
+ const char *mname;\r
+ const char *mdesc;\r
+ jmethodID base_methid;\r
+ } methods[] = {\r
+ {\r
+ "needsCollision", "(Lcom/badlogic/gdx/physics/bullet/btBroadphaseProxy;)Z", NULL \r
+ },\r
+ {\r
+ "addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/btManifoldPoint;Lcom/badlogic/gdx/physics/bullet/btCollisionObjectWrapper;IILcom/badlogic/gdx/physics/bullet/btCollisionObjectWrapper;II)F", NULL \r
+ }\r
+ };\r
+ \r
+ static jclass baseclass = 0 ;\r
+ \r
+ if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {\r
+ if (!baseclass) {\r
+ baseclass = jenv->FindClass("com/badlogic/gdx/physics/bullet/ContactResultCallback");\r
+ if (!baseclass) return;\r
+ baseclass = (jclass) jenv->NewGlobalRef(baseclass);\r
+ }\r
+ bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);\r
+ for (int i = 0; i < 2; ++i) {\r
+ if (!methods[i].base_methid) {\r
+ methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);\r
+ if (!methods[i].base_methid) return;\r
+ }\r
+ swig_override[i] = false;\r
+ if (derived) {\r
+ jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);\r
+ swig_override[i] = (methid != methods[i].base_methid);\r
+ jenv->ExceptionClear();\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+\r
SwigDirector_InternalTickCallback::SwigDirector_InternalTickCallback(JNIEnv *jenv, btDynamicsWorld *dynamicsWorld, bool isPreTick) : InternalTickCallback(dynamicsWorld, isPreTick), Swig::Director(jenv) {\r
}\r
\r
if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {\r
*((btDynamicsWorld **)&jdynamicsWorld) = (btDynamicsWorld *) dynamicsWorld; \r
jtimeStep = (jfloat) timeStep;\r
- jenv->CallStaticVoidMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[25], swigjobj, jdynamicsWorld, jtimeStep);\r
+ jenv->CallStaticVoidMethod(Swig::jclass_gdxBulletJNI, Swig::director_methids[37], swigjobj, jdynamicsWorld, jtimeStep);\r
if (jenv->ExceptionCheck() == JNI_TRUE) return ;\r
} else {\r
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");\r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionAlgorithm_1processCollision(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionAlgorithm_1processCollision(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) {\r
btCollisionAlgorithm *arg1 = (btCollisionAlgorithm *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
(void)jarg4_;\r
(void)jarg5_;\r
arg1 = *(btCollisionAlgorithm **)&jarg1; \r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btDispatcher_1findAlgorithm_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btDispatcher_1findAlgorithm_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {\r
jlong jresult = 0 ;\r
btDispatcher *arg1 = (btDispatcher *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
(void)jarg4_;\r
arg1 = *(btDispatcher **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btDispatcher_1findAlgorithm_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btDispatcher_1findAlgorithm_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {\r
jlong jresult = 0 ;\r
btDispatcher *arg1 = (btDispatcher *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btDispatcher **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
arg3 = *(btCollisionObjectWrapper **)&jarg3; \r
}\r
\r
\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionObjectWrapper_1m_1parent_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
+ btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
+ btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
+ arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
+ if (arg1) (arg1)->m_parent = (btCollisionObjectWrapper const *)arg2;\r
+}\r
+\r
+\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionObjectWrapper_1m_1parent_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {\r
+ jlong jresult = 0 ;\r
+ btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
+ btCollisionObjectWrapper *result = 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
+ result = (btCollisionObjectWrapper *) ((arg1)->m_parent);\r
+ *(btCollisionObjectWrapper **)&jresult = result; \r
+ return jresult;\r
+}\r
+\r
+\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionObjectWrapper_1m_1shape_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
+ btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
+ btCollisionShape *arg2 = (btCollisionShape *) 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
+ arg2 = *(btCollisionShape **)&jarg2; \r
+ if (arg1) (arg1)->m_shape = (btCollisionShape const *)arg2;\r
+}\r
+\r
+\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionObjectWrapper_1m_1shape_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {\r
+ jlong jresult = 0 ;\r
+ btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
+ btCollisionShape *result = 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
+ result = (btCollisionShape *) ((arg1)->m_shape);\r
+ *(btCollisionShape **)&jresult = result; \r
+ return jresult;\r
+}\r
+\r
+\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionObjectWrapper_1m_1collisionObject_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
+ btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
+ btCollisionObject *arg2 = (btCollisionObject *) 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
+ arg2 = *(btCollisionObject **)&jarg2; \r
+ if (arg1) (arg1)->m_collisionObject = (btCollisionObject const *)arg2;\r
+}\r
+\r
+\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionObjectWrapper_1m_1collisionObject_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {\r
+ jlong jresult = 0 ;\r
+ btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
+ btCollisionObject *result = 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
+ result = (btCollisionObject *) ((arg1)->m_collisionObject);\r
+ *(btCollisionObject **)&jresult = result; \r
+ return jresult;\r
+}\r
+\r
+\r
+SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionObjectWrapper_1m_1worldTransform_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {\r
+ jobject jresult = 0 ;\r
+ btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
+ btTransform *result = 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
+ result = (btTransform *) &(btTransform const &) ((arg1)->m_worldTransform);\r
+ jresult = gdx_getReturnMatrix4(jenv);\r
+ gdx_setMatrix4FrombtTransform(jenv, jresult, result);\r
+ return jresult;\r
+}\r
+\r
+\r
+SWIGEXPORT jobject JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionObjectWrapper_1getWorldTransform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {\r
+ jobject jresult = 0 ;\r
+ btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
+ btTransform *result = 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
+ result = (btTransform *) &((btCollisionObjectWrapper const *)arg1)->getWorldTransform();\r
+ jresult = gdx_getReturnMatrix4(jenv);\r
+ gdx_setMatrix4FrombtTransform(jenv, jresult, result);\r
+ return jresult;\r
+}\r
+\r
+\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionObjectWrapper_1getCollisionObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {\r
+ jlong jresult = 0 ;\r
+ btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
+ btCollisionObject *result = 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
+ result = (btCollisionObject *)((btCollisionObjectWrapper const *)arg1)->getCollisionObject();\r
+ *(btCollisionObject **)&jresult = result; \r
+ return jresult;\r
+}\r
+\r
+\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionObjectWrapper_1getCollisionShape(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {\r
+ jlong jresult = 0 ;\r
+ btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
+ btCollisionShape *result = 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
+ result = (btCollisionShape *)((btCollisionObjectWrapper const *)arg1)->getCollisionShape();\r
+ *(btCollisionShape **)&jresult = result; \r
+ return jresult;\r
+}\r
+\r
+\r
SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btEmptyAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {\r
jlong jresult = 0 ;\r
btCollisionAlgorithmConstructionInfo *arg1 = 0 ;\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btConvexTriangleCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jboolean jarg4) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btConvexTriangleCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jboolean jarg4) {\r
jlong jresult = 0 ;\r
btDispatcher *arg1 = (btDispatcher *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btDispatcher **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
arg3 = *(btCollisionObjectWrapper **)&jarg3; \r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btConvexTriangleCallback_1setTimeStepAndCounters(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jlong jarg5, jlong jarg6, jobject jarg6_) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btConvexTriangleCallback_1setTimeStepAndCounters(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_, jlong jarg6, jobject jarg6_) {\r
btConvexTriangleCallback *arg1 = (btConvexTriangleCallback *) 0 ;\r
btScalar arg2 ;\r
btDispatcherInfo *arg3 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg3_;\r
+ (void)jarg4_;\r
+ (void)jarg5_;\r
(void)jarg6_;\r
arg1 = *(btConvexTriangleCallback **)&jarg1; \r
arg2 = (btScalar)jarg2; \r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btConvexConcaveCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jboolean jarg4) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btConvexConcaveCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jboolean jarg4) {\r
jlong jresult = 0 ;\r
btCollisionAlgorithmConstructionInfo *arg1 = 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btCollisionAlgorithmConstructionInfo **)&jarg1;\r
if (!arg1) {\r
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btCollisionAlgorithmConstructionInfo const & reference is null");\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btConvexPlaneCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4, jboolean jarg5, jint jarg6, jint jarg7) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btConvexPlaneCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jboolean jarg5, jint jarg6, jint jarg7) {\r
jlong jresult = 0 ;\r
btPersistentManifold *arg1 = (btPersistentManifold *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
arg1 = *(btPersistentManifold **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
if (!arg2) {\r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btConvexPlaneCollisionAlgorithm_1collideSingleContact(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jobject jarg5_, jlong jarg6, jobject jarg6_) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btConvexPlaneCollisionAlgorithm_1collideSingleContact(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_, jlong jarg6, jobject jarg6_) {\r
btConvexPlaneCollisionAlgorithm *arg1 = (btConvexPlaneCollisionAlgorithm *) 0 ;\r
btQuaternion *arg2 = 0 ;\r
btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
(void)jarg5_;\r
(void)jarg6_;\r
arg1 = *(btConvexPlaneCollisionAlgorithm **)&jarg1; \r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btManifoldResult_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btManifoldResult_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
jlong jresult = 0 ;\r
btCollisionObjectWrapper *arg1 = (btCollisionObjectWrapper *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
\r
(void)jenv;\r
(void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
arg1 = *(btCollisionObjectWrapper **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
result = (btManifoldResult *)new btManifoldResult((btCollisionObjectWrapper const *)arg1,(btCollisionObjectWrapper const *)arg2);\r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btManifoldResult_1setBody0Wrap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btManifoldResult_1setBody0Wrap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
btManifoldResult *arg1 = (btManifoldResult *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
arg1 = *(btManifoldResult **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
(arg1)->setBody0Wrap((btCollisionObjectWrapper const *)arg2);\r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btManifoldResult_1setBody1Wrap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btManifoldResult_1setBody1Wrap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
btManifoldResult *arg1 = (btManifoldResult *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
arg1 = *(btManifoldResult **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
(arg1)->setBody1Wrap((btCollisionObjectWrapper const *)arg2);\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSphereSphereCollisionAlgorithm_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSphereSphereCollisionAlgorithm_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {\r
jlong jresult = 0 ;\r
btPersistentManifold *arg1 = (btPersistentManifold *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
arg1 = *(btPersistentManifold **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
if (!arg2) {\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btBoxBoxCollisionAlgorithm_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btBoxBoxCollisionAlgorithm_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {\r
jlong jresult = 0 ;\r
btPersistentManifold *arg1 = (btPersistentManifold *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
arg1 = *(btPersistentManifold **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
if (!arg2) {\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionAlgorithmCreateFunc_1CreateCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionAlgorithmCreateFunc_1CreateCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {\r
jlong jresult = 0 ;\r
btCollisionAlgorithmCreateFunc *arg1 = (btCollisionAlgorithmCreateFunc *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
arg1 = *(btCollisionAlgorithmCreateFunc **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
if (!arg2) {\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btBox2dBox2dCollisionAlgorithm_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btBox2dBox2dCollisionAlgorithm_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {\r
jlong jresult = 0 ;\r
btPersistentManifold *arg1 = (btPersistentManifold *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
arg1 = *(btPersistentManifold **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
if (!arg2) {\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSphereTriangleCollisionAlgorithm_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4, jboolean jarg5) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSphereTriangleCollisionAlgorithm_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jboolean jarg5) {\r
jlong jresult = 0 ;\r
btPersistentManifold *arg1 = (btPersistentManifold *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
arg1 = *(btPersistentManifold **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
if (!arg2) {\r
}\r
\r
\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1RayResultCallback(JNIEnv *jenv, jclass jcls) {\r
+ jlong jresult = 0 ;\r
+ RayResultCallback *result = 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ result = (RayResultCallback *)new SwigDirector_RayResultCallback(jenv);\r
+ *(RayResultCallback **)&jresult = result; \r
+ return jresult;\r
+}\r
+\r
+\r
SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_RayResultCallback_1needsCollision(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
jboolean jresult = 0 ;\r
RayResultCallback *arg1 = (RayResultCallback *) 0 ;\r
}\r
\r
\r
+SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_RayResultCallback_1needsCollisionSwigExplicitRayResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
+ jboolean jresult = 0 ;\r
+ RayResultCallback *arg1 = (RayResultCallback *) 0 ;\r
+ btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ;\r
+ bool result;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(RayResultCallback **)&jarg1; \r
+ arg2 = *(btBroadphaseProxy **)&jarg2; \r
+ result = (bool)((RayResultCallback const *)arg1)->RayResultCallback::needsCollision(arg2);\r
+ jresult = (jboolean)result; \r
+ return jresult;\r
+}\r
+\r
+\r
SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_RayResultCallback_1addSingleResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) {\r
jfloat jresult = 0 ;\r
RayResultCallback *arg1 = (RayResultCallback *) 0 ;\r
}\r
\r
\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_RayResultCallback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {\r
+ RayResultCallback *obj = *((RayResultCallback **)&objarg);\r
+ (void)jcls;\r
+ SwigDirector_RayResultCallback *director = (SwigDirector_RayResultCallback *)(obj);\r
+ if (director) {\r
+ director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));\r
+ }\r
+}\r
+\r
+\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_RayResultCallback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {\r
+ RayResultCallback *obj = *((RayResultCallback **)&objarg);\r
+ SwigDirector_RayResultCallback *director = (SwigDirector_RayResultCallback *)(obj);\r
+ (void)jcls;\r
+ if (director) {\r
+ director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);\r
+ }\r
+}\r
+\r
+\r
SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1ClosestRayResultCallback(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) {\r
jlong jresult = 0 ;\r
btVector3 *arg1 = 0 ;\r
gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2);\r
arg2 = &local_arg2;\r
gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2);\r
- result = (ClosestRayResultCallback *)new ClosestRayResultCallback((btVector3 const &)*arg1,(btVector3 const &)*arg2);\r
+ result = (ClosestRayResultCallback *)new SwigDirector_ClosestRayResultCallback(jenv,(btVector3 const &)*arg1,(btVector3 const &)*arg2);\r
*(ClosestRayResultCallback **)&jresult = result; \r
return jresult;\r
}\r
}\r
\r
\r
+SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ClosestRayResultCallback_1addSingleResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) {\r
+ jfloat jresult = 0 ;\r
+ ClosestRayResultCallback *arg1 = (ClosestRayResultCallback *) 0 ;\r
+ LocalRayResult *arg2 = 0 ;\r
+ bool arg3 ;\r
+ btScalar result;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(ClosestRayResultCallback **)&jarg1; \r
+ arg2 = *(LocalRayResult **)&jarg2;\r
+ if (!arg2) {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "LocalRayResult & reference is null");\r
+ return 0;\r
+ } \r
+ arg3 = jarg3 ? true : false; \r
+ result = (btScalar)(arg1)->addSingleResult(*arg2,arg3);\r
+ jresult = (jfloat)result; \r
+ return jresult;\r
+}\r
+\r
+\r
+SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ClosestRayResultCallback_1addSingleResultSwigExplicitClosestRayResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) {\r
+ jfloat jresult = 0 ;\r
+ ClosestRayResultCallback *arg1 = (ClosestRayResultCallback *) 0 ;\r
+ LocalRayResult *arg2 = 0 ;\r
+ bool arg3 ;\r
+ btScalar result;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(ClosestRayResultCallback **)&jarg1; \r
+ arg2 = *(LocalRayResult **)&jarg2;\r
+ if (!arg2) {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "LocalRayResult & reference is null");\r
+ return 0;\r
+ } \r
+ arg3 = jarg3 ? true : false; \r
+ result = (btScalar)(arg1)->ClosestRayResultCallback::addSingleResult(*arg2,arg3);\r
+ jresult = (jfloat)result; \r
+ return jresult;\r
+}\r
+\r
+\r
SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_delete_1ClosestRayResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) {\r
ClosestRayResultCallback *arg1 = (ClosestRayResultCallback *) 0 ;\r
\r
}\r
\r
\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ClosestRayResultCallback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {\r
+ ClosestRayResultCallback *obj = *((ClosestRayResultCallback **)&objarg);\r
+ (void)jcls;\r
+ SwigDirector_ClosestRayResultCallback *director = (SwigDirector_ClosestRayResultCallback *)(obj);\r
+ if (director) {\r
+ director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));\r
+ }\r
+}\r
+\r
+\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ClosestRayResultCallback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {\r
+ ClosestRayResultCallback *obj = *((ClosestRayResultCallback **)&objarg);\r
+ SwigDirector_ClosestRayResultCallback *director = (SwigDirector_ClosestRayResultCallback *)(obj);\r
+ (void)jcls;\r
+ if (director) {\r
+ director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);\r
+ }\r
+}\r
+\r
+\r
SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1AllHitsRayResultCallback(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) {\r
jlong jresult = 0 ;\r
btVector3 *arg1 = 0 ;\r
gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2);\r
arg2 = &local_arg2;\r
gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2);\r
- result = (AllHitsRayResultCallback *)new AllHitsRayResultCallback((btVector3 const &)*arg1,(btVector3 const &)*arg2);\r
+ result = (AllHitsRayResultCallback *)new SwigDirector_AllHitsRayResultCallback(jenv,(btVector3 const &)*arg1,(btVector3 const &)*arg2);\r
*(AllHitsRayResultCallback **)&jresult = result; \r
return jresult;\r
}\r
}\r
\r
\r
+SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_AllHitsRayResultCallback_1addSingleResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) {\r
+ jfloat jresult = 0 ;\r
+ AllHitsRayResultCallback *arg1 = (AllHitsRayResultCallback *) 0 ;\r
+ LocalRayResult *arg2 = 0 ;\r
+ bool arg3 ;\r
+ btScalar result;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(AllHitsRayResultCallback **)&jarg1; \r
+ arg2 = *(LocalRayResult **)&jarg2;\r
+ if (!arg2) {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "LocalRayResult & reference is null");\r
+ return 0;\r
+ } \r
+ arg3 = jarg3 ? true : false; \r
+ result = (btScalar)(arg1)->addSingleResult(*arg2,arg3);\r
+ jresult = (jfloat)result; \r
+ return jresult;\r
+}\r
+\r
+\r
+SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_AllHitsRayResultCallback_1addSingleResultSwigExplicitAllHitsRayResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) {\r
+ jfloat jresult = 0 ;\r
+ AllHitsRayResultCallback *arg1 = (AllHitsRayResultCallback *) 0 ;\r
+ LocalRayResult *arg2 = 0 ;\r
+ bool arg3 ;\r
+ btScalar result;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(AllHitsRayResultCallback **)&jarg1; \r
+ arg2 = *(LocalRayResult **)&jarg2;\r
+ if (!arg2) {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "LocalRayResult & reference is null");\r
+ return 0;\r
+ } \r
+ arg3 = jarg3 ? true : false; \r
+ result = (btScalar)(arg1)->AllHitsRayResultCallback::addSingleResult(*arg2,arg3);\r
+ jresult = (jfloat)result; \r
+ return jresult;\r
+}\r
+\r
+\r
SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_delete_1AllHitsRayResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) {\r
AllHitsRayResultCallback *arg1 = (AllHitsRayResultCallback *) 0 ;\r
\r
}\r
\r
\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_AllHitsRayResultCallback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {\r
+ AllHitsRayResultCallback *obj = *((AllHitsRayResultCallback **)&objarg);\r
+ (void)jcls;\r
+ SwigDirector_AllHitsRayResultCallback *director = (SwigDirector_AllHitsRayResultCallback *)(obj);\r
+ if (director) {\r
+ director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));\r
+ }\r
+}\r
+\r
+\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_AllHitsRayResultCallback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {\r
+ AllHitsRayResultCallback *obj = *((AllHitsRayResultCallback **)&objarg);\r
+ SwigDirector_AllHitsRayResultCallback *director = (SwigDirector_AllHitsRayResultCallback *)(obj);\r
+ (void)jcls;\r
+ if (director) {\r
+ director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);\r
+ }\r
+}\r
+\r
+\r
SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1LocalConvexResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4, jfloat jarg5) {\r
jlong jresult = 0 ;\r
btCollisionObject *arg1 = (btCollisionObject *) 0 ;\r
}\r
\r
\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1ConvexResultCallback(JNIEnv *jenv, jclass jcls) {\r
+ jlong jresult = 0 ;\r
+ ConvexResultCallback *result = 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ result = (ConvexResultCallback *)new SwigDirector_ConvexResultCallback(jenv);\r
+ *(ConvexResultCallback **)&jresult = result; \r
+ return jresult;\r
+}\r
+\r
+\r
SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_delete_1ConvexResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) {\r
ConvexResultCallback *arg1 = (ConvexResultCallback *) 0 ;\r
\r
}\r
\r
\r
+SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ConvexResultCallback_1needsCollisionSwigExplicitConvexResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
+ jboolean jresult = 0 ;\r
+ ConvexResultCallback *arg1 = (ConvexResultCallback *) 0 ;\r
+ btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ;\r
+ bool result;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(ConvexResultCallback **)&jarg1; \r
+ arg2 = *(btBroadphaseProxy **)&jarg2; \r
+ result = (bool)((ConvexResultCallback const *)arg1)->ConvexResultCallback::needsCollision(arg2);\r
+ jresult = (jboolean)result; \r
+ return jresult;\r
+}\r
+\r
+\r
SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ConvexResultCallback_1addSingleResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) {\r
jfloat jresult = 0 ;\r
ConvexResultCallback *arg1 = (ConvexResultCallback *) 0 ;\r
}\r
\r
\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ConvexResultCallback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {\r
+ ConvexResultCallback *obj = *((ConvexResultCallback **)&objarg);\r
+ (void)jcls;\r
+ SwigDirector_ConvexResultCallback *director = (SwigDirector_ConvexResultCallback *)(obj);\r
+ if (director) {\r
+ director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));\r
+ }\r
+}\r
+\r
+\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ConvexResultCallback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {\r
+ ConvexResultCallback *obj = *((ConvexResultCallback **)&objarg);\r
+ SwigDirector_ConvexResultCallback *director = (SwigDirector_ConvexResultCallback *)(obj);\r
+ (void)jcls;\r
+ if (director) {\r
+ director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);\r
+ }\r
+}\r
+\r
+\r
SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1ClosestConvexResultCallback(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) {\r
jlong jresult = 0 ;\r
btVector3 *arg1 = 0 ;\r
gdx_setbtVector3FromVector3(jenv, local_arg2, jarg2);\r
arg2 = &local_arg2;\r
gdxAutoCommitVector3 auto_commit_arg2(jenv, jarg2, &local_arg2);\r
- result = (ClosestConvexResultCallback *)new ClosestConvexResultCallback((btVector3 const &)*arg1,(btVector3 const &)*arg2);\r
+ result = (ClosestConvexResultCallback *)new SwigDirector_ClosestConvexResultCallback(jenv,(btVector3 const &)*arg1,(btVector3 const &)*arg2);\r
*(ClosestConvexResultCallback **)&jresult = result; \r
return jresult;\r
}\r
}\r
\r
\r
+SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ClosestConvexResultCallback_1addSingleResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) {\r
+ jfloat jresult = 0 ;\r
+ ClosestConvexResultCallback *arg1 = (ClosestConvexResultCallback *) 0 ;\r
+ LocalConvexResult *arg2 = 0 ;\r
+ bool arg3 ;\r
+ btScalar result;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(ClosestConvexResultCallback **)&jarg1; \r
+ arg2 = *(LocalConvexResult **)&jarg2;\r
+ if (!arg2) {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "LocalConvexResult & reference is null");\r
+ return 0;\r
+ } \r
+ arg3 = jarg3 ? true : false; \r
+ result = (btScalar)(arg1)->addSingleResult(*arg2,arg3);\r
+ jresult = (jfloat)result; \r
+ return jresult;\r
+}\r
+\r
+\r
+SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ClosestConvexResultCallback_1addSingleResultSwigExplicitClosestConvexResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) {\r
+ jfloat jresult = 0 ;\r
+ ClosestConvexResultCallback *arg1 = (ClosestConvexResultCallback *) 0 ;\r
+ LocalConvexResult *arg2 = 0 ;\r
+ bool arg3 ;\r
+ btScalar result;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(ClosestConvexResultCallback **)&jarg1; \r
+ arg2 = *(LocalConvexResult **)&jarg2;\r
+ if (!arg2) {\r
+ SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "LocalConvexResult & reference is null");\r
+ return 0;\r
+ } \r
+ arg3 = jarg3 ? true : false; \r
+ result = (btScalar)(arg1)->ClosestConvexResultCallback::addSingleResult(*arg2,arg3);\r
+ jresult = (jfloat)result; \r
+ return jresult;\r
+}\r
+\r
+\r
SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_delete_1ClosestConvexResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) {\r
ClosestConvexResultCallback *arg1 = (ClosestConvexResultCallback *) 0 ;\r
\r
}\r
\r
\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ClosestConvexResultCallback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {\r
+ ClosestConvexResultCallback *obj = *((ClosestConvexResultCallback **)&objarg);\r
+ (void)jcls;\r
+ SwigDirector_ClosestConvexResultCallback *director = (SwigDirector_ClosestConvexResultCallback *)(obj);\r
+ if (director) {\r
+ director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));\r
+ }\r
+}\r
+\r
+\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ClosestConvexResultCallback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {\r
+ ClosestConvexResultCallback *obj = *((ClosestConvexResultCallback **)&objarg);\r
+ SwigDirector_ClosestConvexResultCallback *director = (SwigDirector_ClosestConvexResultCallback *)(obj);\r
+ (void)jcls;\r
+ if (director) {\r
+ director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);\r
+ }\r
+}\r
+\r
+\r
SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ContactResultCallback_1m_1collisionFilterGroup_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) {\r
ContactResultCallback *arg1 = (ContactResultCallback *) 0 ;\r
short arg2 ;\r
}\r
\r
\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1ContactResultCallback(JNIEnv *jenv, jclass jcls) {\r
+ jlong jresult = 0 ;\r
+ ContactResultCallback *result = 0 ;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ result = (ContactResultCallback *)new SwigDirector_ContactResultCallback(jenv);\r
+ *(ContactResultCallback **)&jresult = result; \r
+ return jresult;\r
+}\r
+\r
+\r
SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_delete_1ContactResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) {\r
ContactResultCallback *arg1 = (ContactResultCallback *) 0 ;\r
\r
}\r
\r
\r
-SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ContactResultCallback_1addSingleResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jint jarg4, jint jarg5, jlong jarg6, jint jarg7, jint jarg8) {\r
+SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ContactResultCallback_1needsCollisionSwigExplicitContactResultCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
+ jboolean jresult = 0 ;\r
+ ContactResultCallback *arg1 = (ContactResultCallback *) 0 ;\r
+ btBroadphaseProxy *arg2 = (btBroadphaseProxy *) 0 ;\r
+ bool result;\r
+ \r
+ (void)jenv;\r
+ (void)jcls;\r
+ (void)jarg1_;\r
+ (void)jarg2_;\r
+ arg1 = *(ContactResultCallback **)&jarg1; \r
+ arg2 = *(btBroadphaseProxy **)&jarg2; \r
+ result = (bool)((ContactResultCallback const *)arg1)->ContactResultCallback::needsCollision(arg2);\r
+ jresult = (jboolean)result; \r
+ return jresult;\r
+}\r
+\r
+\r
+SWIGEXPORT jfloat JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ContactResultCallback_1addSingleResult(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jint jarg5, jlong jarg6, jobject jarg6_, jint jarg7, jint jarg8) {\r
jfloat jresult = 0 ;\r
ContactResultCallback *arg1 = (ContactResultCallback *) 0 ;\r
btManifoldPoint *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg6_;\r
arg1 = *(ContactResultCallback **)&jarg1; \r
arg2 = *(btManifoldPoint **)&jarg2;\r
if (!arg2) {\r
}\r
\r
\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ContactResultCallback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {\r
+ ContactResultCallback *obj = *((ContactResultCallback **)&objarg);\r
+ (void)jcls;\r
+ SwigDirector_ContactResultCallback *director = (SwigDirector_ContactResultCallback *)(obj);\r
+ if (director) {\r
+ director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));\r
+ }\r
+}\r
+\r
+\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_ContactResultCallback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {\r
+ ContactResultCallback *obj = *((ContactResultCallback **)&objarg);\r
+ SwigDirector_ContactResultCallback *director = (SwigDirector_ContactResultCallback *)(obj);\r
+ (void)jcls;\r
+ if (director) {\r
+ director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);\r
+ }\r
+}\r
+\r
+\r
SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btCollisionWorld(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {\r
jlong jresult = 0 ;\r
btDispatcher *arg1 = (btDispatcher *) 0 ;\r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionWorld_1rayTestSingleInternal(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3, jlong jarg4, jobject jarg4_) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionWorld_1rayTestSingleInternal(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {\r
btTransform *arg1 = 0 ;\r
btTransform *arg2 = 0 ;\r
btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ;\r
\r
(void)jenv;\r
(void)jcls;\r
+ (void)jarg3_;\r
(void)jarg4_;\r
btTransform local_arg1;\r
gdx_setbtTransformFromMatrix4(jenv, local_arg1, jarg1);\r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionWorld_1objectQuerySingleInternal(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jlong jarg5, jobject jarg5_, jfloat jarg6) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionWorld_1objectQuerySingleInternal(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_, jfloat jarg6) {\r
btConvexShape *arg1 = (btConvexShape *) 0 ;\r
btTransform *arg2 = 0 ;\r
btTransform *arg3 = 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg4_;\r
(void)jarg5_;\r
arg1 = *(btConvexShape **)&jarg1; \r
btTransform local_arg2;\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btConvex2dConvex2dAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6, jobject jarg6_, jint jarg7, jint jarg8) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btConvex2dConvex2dAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jlong jarg6, jobject jarg6_, jint jarg7, jint jarg8) {\r
jlong jresult = 0 ;\r
btPersistentManifold *arg1 = (btPersistentManifold *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
(void)jarg6_;\r
arg1 = *(btPersistentManifold **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSphereBoxCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4, jboolean jarg5) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSphereBoxCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jboolean jarg5) {\r
jlong jresult = 0 ;\r
btPersistentManifold *arg1 = (btPersistentManifold *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
arg1 = *(btPersistentManifold **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
if (!arg2) {\r
}\r
\r
\r
-SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btSphereBoxCollisionAlgorithm_1getSphereDistance(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg3, jobject jarg4, jlong jarg5, jobject jarg6, jfloat jarg7, jfloat jarg8) {\r
+SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btSphereBoxCollisionAlgorithm_1getSphereDistance(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4, jlong jarg5, jobject jarg6, jfloat jarg7, jfloat jarg8) {\r
jboolean jresult = 0 ;\r
btSphereBoxCollisionAlgorithm *arg1 = (btSphereBoxCollisionAlgorithm *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
arg1 = *(btSphereBoxCollisionAlgorithm **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
btVector3 local_arg3;\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionDispatcher_1findAlgorithm_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionDispatcher_1findAlgorithm_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {\r
jlong jresult = 0 ;\r
btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
(void)jarg4_;\r
arg1 = *(btCollisionDispatcher **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionDispatcher_1findAlgorithm_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btCollisionDispatcher_1findAlgorithm_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {\r
jlong jresult = 0 ;\r
btCollisionDispatcher *arg1 = (btCollisionDispatcher *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btCollisionDispatcher **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
arg3 = *(btCollisionObjectWrapper **)&jarg3; \r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btConvexConvexAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6, jobject jarg6_, jint jarg7, jint jarg8) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btConvexConvexAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jlong jarg6, jobject jarg6_, jint jarg7, jint jarg8) {\r
jlong jresult = 0 ;\r
btPersistentManifold *arg1 = (btPersistentManifold *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
(void)jarg6_;\r
arg1 = *(btPersistentManifold **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btAdjustInternalEdgeContacts_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jint jarg4, jint jarg5, jint jarg6) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btAdjustInternalEdgeContacts_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jint jarg5, jint jarg6) {\r
btManifoldPoint *arg1 = 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btManifoldPoint **)&jarg1;\r
if (!arg1) {\r
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btManifoldPoint & reference is null");\r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btAdjustInternalEdgeContacts_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jint jarg4, jint jarg5) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btAdjustInternalEdgeContacts_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jint jarg5) {\r
btManifoldPoint *arg1 = 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btManifoldPoint **)&jarg1;\r
if (!arg1) {\r
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btManifoldPoint & reference is null");\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btCompoundCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jboolean jarg4) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btCompoundCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jboolean jarg4) {\r
jlong jresult = 0 ;\r
btCollisionAlgorithmConstructionInfo *arg1 = 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btCollisionAlgorithmConstructionInfo **)&jarg1;\r
if (!arg1) {\r
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btCollisionAlgorithmConstructionInfo const & reference is null");\r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btSoftBodySolver_1processCollision_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btSoftBodySolver_1processCollision_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {\r
btSoftBodySolver *arg1 = (btSoftBodySolver *) 0 ;\r
btSoftBody *arg2 = (btSoftBody *) 0 ;\r
btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btSoftBodySolver **)&jarg1; \r
arg2 = *(btSoftBody **)&jarg2; \r
arg3 = *(btCollisionObjectWrapper **)&jarg3; \r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btDefaultSoftBodySolver_1processCollision_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btDefaultSoftBodySolver_1processCollision_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {\r
btDefaultSoftBodySolver *arg1 = (btDefaultSoftBodySolver *) 0 ;\r
btSoftBody *arg2 = (btSoftBody *) 0 ;\r
btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btDefaultSoftBodySolver **)&jarg1; \r
arg2 = *(btSoftBody **)&jarg2; \r
arg3 = *(btCollisionObjectWrapper **)&jarg3; \r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btSoftBody_1defaultCollisionHandler_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btSoftBody_1defaultCollisionHandler_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {\r
btSoftBody *arg1 = (btSoftBody *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
arg1 = *(btSoftBody **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
(arg1)->defaultCollisionHandler((btCollisionObjectWrapper const *)arg2);\r
}\r
\r
\r
-SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btSoftBody_1checkContact(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg3, jfloat jarg4, jlong jarg5, jobject jarg5_) {\r
+SWIGEXPORT jboolean JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btSoftBody_1checkContact(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jfloat jarg4, jlong jarg5, jobject jarg5_) {\r
jboolean jresult = 0 ;\r
btSoftBody *arg1 = (btSoftBody *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
(void)jarg5_;\r
arg1 = *(btSoftBody **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSoftBodyTriangleCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jboolean jarg4) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSoftBodyTriangleCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jboolean jarg4) {\r
jlong jresult = 0 ;\r
btDispatcher *arg1 = (btDispatcher *) 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btDispatcher **)&jarg1; \r
arg2 = *(btCollisionObjectWrapper **)&jarg2; \r
arg3 = *(btCollisionObjectWrapper **)&jarg3; \r
}\r
\r
\r
-SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btSoftBodyTriangleCallback_1setTimeStepAndCounters(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) {\r
+SWIGEXPORT void JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_btSoftBodyTriangleCallback_1setTimeStepAndCounters(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) {\r
btSoftBodyTriangleCallback *arg1 = (btSoftBodyTriangleCallback *) 0 ;\r
btScalar arg2 ;\r
btCollisionObjectWrapper *arg3 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg3_;\r
(void)jarg4_;\r
(void)jarg5_;\r
arg1 = *(btSoftBodyTriangleCallback **)&jarg1; \r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSoftBodyConcaveCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jboolean jarg4) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSoftBodyConcaveCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jboolean jarg4) {\r
jlong jresult = 0 ;\r
btCollisionAlgorithmConstructionInfo *arg1 = 0 ;\r
btCollisionObjectWrapper *arg2 = (btCollisionObjectWrapper *) 0 ;\r
(void)jenv;\r
(void)jcls;\r
(void)jarg1_;\r
+ (void)jarg2_;\r
+ (void)jarg3_;\r
arg1 = *(btCollisionAlgorithmConstructionInfo **)&jarg1;\r
if (!arg1) {\r
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "btCollisionAlgorithmConstructionInfo const & reference is null");\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSoftRigidCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4, jboolean jarg5) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSoftRigidCollisionAlgorithm(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jboolean jarg5) {\r
jlong jresult = 0 ;\r
btPersistentManifold *arg1 = (btPersistentManifold *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
arg1 = *(btPersistentManifold **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
if (!arg2) {\r
}\r
\r
\r
-SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSoftSoftCollisionAlgorithm_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4) {\r
+SWIGEXPORT jlong JNICALL Java_com_badlogic_gdx_physics_bullet_gdxBulletJNI_new_1btSoftSoftCollisionAlgorithm_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {\r
jlong jresult = 0 ;\r
btPersistentManifold *arg1 = (btPersistentManifold *) 0 ;\r
btCollisionAlgorithmConstructionInfo *arg2 = 0 ;\r
(void)jcls;\r
(void)jarg1_;\r
(void)jarg2_;\r
+ (void)jarg3_;\r
+ (void)jarg4_;\r
arg1 = *(btPersistentManifold **)&jarg1; \r
arg2 = *(btCollisionAlgorithmConstructionInfo **)&jarg2;\r
if (!arg2) {\r
static struct {\r
const char *method;\r
const char *signature;\r
- } methods[26] = {\r
+ } methods[38] = {\r
{\r
"SwigDirector_btIDebugDraw_drawLine__SWIG_0", "(Lcom/badlogic/gdx/physics/bullet/btIDebugDraw;JJJ)V" \r
},\r
"SwigDirector_btMotionState_setWorldTransform", "(Lcom/badlogic/gdx/physics/bullet/btMotionState;Lcom/badlogic/gdx/math/Matrix4;)V" \r
},\r
{\r
+ "SwigDirector_RayResultCallback_needsCollision", "(Lcom/badlogic/gdx/physics/bullet/RayResultCallback;J)Z" \r
+ },\r
+ {\r
+ "SwigDirector_RayResultCallback_addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/RayResultCallback;JZ)F" \r
+ },\r
+ {\r
+ "SwigDirector_ClosestRayResultCallback_needsCollision", "(Lcom/badlogic/gdx/physics/bullet/ClosestRayResultCallback;J)Z" \r
+ },\r
+ {\r
+ "SwigDirector_ClosestRayResultCallback_addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/ClosestRayResultCallback;JZ)F" \r
+ },\r
+ {\r
+ "SwigDirector_AllHitsRayResultCallback_needsCollision", "(Lcom/badlogic/gdx/physics/bullet/AllHitsRayResultCallback;J)Z" \r
+ },\r
+ {\r
+ "SwigDirector_AllHitsRayResultCallback_addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/AllHitsRayResultCallback;JZ)F" \r
+ },\r
+ {\r
+ "SwigDirector_ConvexResultCallback_needsCollision", "(Lcom/badlogic/gdx/physics/bullet/ConvexResultCallback;J)Z" \r
+ },\r
+ {\r
+ "SwigDirector_ConvexResultCallback_addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/ConvexResultCallback;JZ)F" \r
+ },\r
+ {\r
+ "SwigDirector_ClosestConvexResultCallback_needsCollision", "(Lcom/badlogic/gdx/physics/bullet/ClosestConvexResultCallback;J)Z" \r
+ },\r
+ {\r
+ "SwigDirector_ClosestConvexResultCallback_addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/ClosestConvexResultCallback;JZ)F" \r
+ },\r
+ {\r
+ "SwigDirector_ContactResultCallback_needsCollision", "(Lcom/badlogic/gdx/physics/bullet/ContactResultCallback;J)Z" \r
+ },\r
+ {\r
+ "SwigDirector_ContactResultCallback_addSingleResult", "(Lcom/badlogic/gdx/physics/bullet/ContactResultCallback;JJIIJII)F" \r
+ },\r
+ {\r
"SwigDirector_InternalTickCallback_onInternalTick", "(Lcom/badlogic/gdx/physics/bullet/InternalTickCallback;JF)V" \r
}\r
};\r
bool swig_override[2];\r
};\r
\r
+struct SwigDirector_RayResultCallback : public RayResultCallback, public Swig::Director {\r
+\r
+public:\r
+ void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global);\r
+ SwigDirector_RayResultCallback(JNIEnv *jenv);\r
+ virtual ~SwigDirector_RayResultCallback();\r
+ virtual bool needsCollision(btBroadphaseProxy *proxy0) const;\r
+ virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace);\r
+public:\r
+ bool swig_overrides(int n) {\r
+ return (n < 2 ? swig_override[n] : false);\r
+ }\r
+protected:\r
+ bool swig_override[2];\r
+};\r
+\r
+struct SwigDirector_ClosestRayResultCallback : public ClosestRayResultCallback, public Swig::Director {\r
+\r
+public:\r
+ void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global);\r
+ SwigDirector_ClosestRayResultCallback(JNIEnv *jenv, btVector3 const &rayFromWorld, btVector3 const &rayToWorld);\r
+ virtual ~SwigDirector_ClosestRayResultCallback();\r
+ virtual bool needsCollision(btBroadphaseProxy *proxy0) const;\r
+ virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace);\r
+public:\r
+ bool swig_overrides(int n) {\r
+ return (n < 2 ? swig_override[n] : false);\r
+ }\r
+protected:\r
+ bool swig_override[2];\r
+};\r
+\r
+struct SwigDirector_AllHitsRayResultCallback : public AllHitsRayResultCallback, public Swig::Director {\r
+\r
+public:\r
+ void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global);\r
+ SwigDirector_AllHitsRayResultCallback(JNIEnv *jenv, btVector3 const &rayFromWorld, btVector3 const &rayToWorld);\r
+ virtual ~SwigDirector_AllHitsRayResultCallback();\r
+ virtual bool needsCollision(btBroadphaseProxy *proxy0) const;\r
+ virtual btScalar addSingleResult(LocalRayResult &rayResult, bool normalInWorldSpace);\r
+public:\r
+ bool swig_overrides(int n) {\r
+ return (n < 2 ? swig_override[n] : false);\r
+ }\r
+protected:\r
+ bool swig_override[2];\r
+};\r
+\r
+struct SwigDirector_ConvexResultCallback : public ConvexResultCallback, public Swig::Director {\r
+\r
+public:\r
+ void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global);\r
+ SwigDirector_ConvexResultCallback(JNIEnv *jenv);\r
+ virtual ~SwigDirector_ConvexResultCallback();\r
+ virtual bool needsCollision(btBroadphaseProxy *proxy0) const;\r
+ virtual btScalar addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace);\r
+public:\r
+ bool swig_overrides(int n) {\r
+ return (n < 2 ? swig_override[n] : false);\r
+ }\r
+protected:\r
+ bool swig_override[2];\r
+};\r
+\r
+struct SwigDirector_ClosestConvexResultCallback : public ClosestConvexResultCallback, public Swig::Director {\r
+\r
+public:\r
+ void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global);\r
+ SwigDirector_ClosestConvexResultCallback(JNIEnv *jenv, btVector3 const &convexFromWorld, btVector3 const &convexToWorld);\r
+ virtual ~SwigDirector_ClosestConvexResultCallback();\r
+ virtual bool needsCollision(btBroadphaseProxy *proxy0) const;\r
+ virtual btScalar addSingleResult(LocalConvexResult &convexResult, bool normalInWorldSpace);\r
+public:\r
+ bool swig_overrides(int n) {\r
+ return (n < 2 ? swig_override[n] : false);\r
+ }\r
+protected:\r
+ bool swig_override[2];\r
+};\r
+\r
+struct SwigDirector_ContactResultCallback : public ContactResultCallback, public Swig::Director {\r
+\r
+public:\r
+ void swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global);\r
+ SwigDirector_ContactResultCallback(JNIEnv *jenv);\r
+ virtual ~SwigDirector_ContactResultCallback();\r
+ virtual bool needsCollision(btBroadphaseProxy *proxy0) const;\r
+ virtual btScalar addSingleResult(btManifoldPoint &cp, btCollisionObjectWrapper const *colObj0Wrap, int partId0, int index0, btCollisionObjectWrapper const *colObj1Wrap, int partId1, int index1);\r
+public:\r
+ bool swig_overrides(int n) {\r
+ return (n < 2 ? swig_override[n] : false);\r
+ }\r
+protected:\r
+ bool swig_override[2];\r
+};\r
+\r
class SwigDirector_InternalTickCallback : public InternalTickCallback, public Swig::Director {\r
\r
public:\r
OSDN Git Service
