3rdparty: bullet3: remove getters/setters from btCollisionObject

Part-of: #259

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp

@@ -31,9 +31,9 @@ btBox2dBox2dCollisionAlgorithm::btBox2dBox2dCollisionAlgorithm(btPersistentManif
 	  m_ownManifold(false),
 	  m_manifoldPtr(mf)
 {
-	if (!m_manifoldPtr && m_dispatcher->needsCollision(obj0Wrap->getCollisionObject(), obj1Wrap->getCollisionObject()))
+	if (!m_manifoldPtr && m_dispatcher->needsCollision(obj0Wrap->m_collisionObject, obj1Wrap->m_collisionObject))
 	{
-		m_manifoldPtr = m_dispatcher->getNewManifold(obj0Wrap->getCollisionObject(), obj1Wrap->getCollisionObject());
+		m_manifoldPtr = m_dispatcher->getNewManifold(obj0Wrap->m_collisionObject, obj1Wrap->m_collisionObject);
 		m_ownManifold = true;
 	}
 }
@@ -55,12 +55,12 @@ void btBox2dBox2dCollisionAlgorithm::processCollision(const btCollisionObjectWra
 	if (!m_manifoldPtr)
 		return;
 
-	const btBox2dShape* box0 = (const btBox2dShape*)body0Wrap->getCollisionShape();
-	const btBox2dShape* box1 = (const btBox2dShape*)body1Wrap->getCollisionShape();
+	const btBox2dShape* box0 = (const btBox2dShape*)body0Wrap->m_collisionShape;
+	const btBox2dShape* box1 = (const btBox2dShape*)body1Wrap->m_collisionShape;
 
 	resultOut->setPersistentManifold(m_manifoldPtr);
 
-	b2CollidePolygons(resultOut, box0, body0Wrap->getWorldTransform(), box1, body1Wrap->getWorldTransform());
+	b2CollidePolygons(resultOut, box0, body0Wrap->m_worldTransform, box1, body1Wrap->m_worldTransform);
 
 	//  refreshContactPoints is only necessary when using persistent contact points. otherwise all points are newly added
 	if (m_ownManifold)

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp

@@ -26,9 +26,9 @@ btBoxBoxCollisionAlgorithm::btBoxBoxCollisionAlgorithm(btPersistentManifold* mf,
 	  m_ownManifold(false),
 	  m_manifoldPtr(mf)
 {
-	if (!m_manifoldPtr && m_dispatcher->needsCollision(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject()))
+	if (!m_manifoldPtr && m_dispatcher->needsCollision(body0Wrap->m_collisionObject, body1Wrap->m_collisionObject))
 	{
-		m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject());
+		m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->m_collisionObject, body1Wrap->m_collisionObject);
 		m_ownManifold = true;
 	}
 }
@@ -47,8 +47,8 @@ void btBoxBoxCollisionAlgorithm::processCollision(const btCollisionObjectWrapper
 	if (!m_manifoldPtr)
 		return;
 
-	const btBoxShape* box0 = (btBoxShape*)body0Wrap->getCollisionShape();
-	const btBoxShape* box1 = (btBoxShape*)body1Wrap->getCollisionShape();
+	const btBoxShape* box0 = (btBoxShape*)body0Wrap->m_collisionShape;
+	const btBoxShape* box1 = (btBoxShape*)body1Wrap->m_collisionShape;
 
 	/// report a contact. internally this will be kept persistent, and contact reduction is done
 	resultOut->setPersistentManifold(m_manifoldPtr);
@@ -58,8 +58,8 @@ void btBoxBoxCollisionAlgorithm::processCollision(const btCollisionObjectWrapper
 
 	btDiscreteCollisionDetectorInterface::ClosestPointInput input;
 	input.m_maximumDistanceSquared = BT_LARGE_FLOAT;
-	input.m_transformA = body0Wrap->getWorldTransform();
-	input.m_transformB = body1Wrap->getWorldTransform();
+	input.m_transformA = body0Wrap->m_worldTransform;
+	input.m_transformB = body1Wrap->m_worldTransform;
 
 	btBoxBoxDetector detector(box0, box1);
 	detector.getClosestPoints(input, *resultOut, dispatchInfo.m_debugDraw);

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp

@@ -71,10 +71,10 @@ btPersistentManifold* btCollisionDispatcher::getNewManifold(const btCollisionObj
 
 	//optional relative contact breaking threshold, turned on by default (use setDispatcherFlags to switch off feature for improved performance)
 
-	btScalar contactBreakingThreshold = (m_dispatcherFlags & btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD) ? btMin(body0->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold), body1->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold))
+	btScalar contactBreakingThreshold = (m_dispatcherFlags & btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD) ? btMin(body0->m_collisionShape->getContactBreakingThreshold(gContactBreakingThreshold), body1->m_collisionShape->getContactBreakingThreshold(gContactBreakingThreshold))
 																																: gContactBreakingThreshold;
 
-	btScalar contactProcessingThreshold = btMin(body0->getContactProcessingThreshold(), body1->getContactProcessingThreshold());
+	btScalar contactProcessingThreshold = btMin(body0->m_contactProcessingThreshold, body1->m_contactProcessingThreshold);
 
 	void* mem = m_persistentManifoldPoolAllocator->allocate(sizeof(btPersistentManifold));
 	if (NULL == mem)
@@ -134,11 +134,11 @@ btCollisionAlgorithm* btCollisionDispatcher::findAlgorithm(const btCollisionObje
 	btCollisionAlgorithm* algo = 0;
 	if (algoType == BT_CONTACT_POINT_ALGORITHMS)
 	{
-		algo = m_doubleDispatchContactPoints[body0Wrap->getCollisionShape()->getShapeType()][body1Wrap->getCollisionShape()->getShapeType()]->CreateCollisionAlgorithm(ci, body0Wrap, body1Wrap);
+		algo = m_doubleDispatchContactPoints[body0Wrap->m_collisionShape->getShapeType()][body1Wrap->m_collisionShape->getShapeType()]->CreateCollisionAlgorithm(ci, body0Wrap, body1Wrap);
 	}
 	else
 	{
-		algo = m_doubleDispatchClosestPoints[body0Wrap->getCollisionShape()->getShapeType()][body1Wrap->getCollisionShape()->getShapeType()]->CreateCollisionAlgorithm(ci, body0Wrap, body1Wrap);
+		algo = m_doubleDispatchClosestPoints[body0Wrap->m_collisionShape->getShapeType()][body1Wrap->m_collisionShape->getShapeType()]->CreateCollisionAlgorithm(ci, body0Wrap, body1Wrap);
 	}
 
 	return algo;
@@ -235,8 +235,8 @@ void btCollisionDispatcher::defaultNearCallback(btBroadphasePair& collisionPair,
 
 	if (dispatcher.needsCollision(colObj0, colObj1))
 	{
-		btCollisionObjectWrapper obj0Wrap(0, colObj0->getCollisionShape(), colObj0, colObj0->getWorldTransform(), -1, -1);
-		btCollisionObjectWrapper obj1Wrap(0, colObj1->getCollisionShape(), colObj1, colObj1->getWorldTransform(), -1, -1);
+		btCollisionObjectWrapper obj0Wrap(0, colObj0->m_collisionShape, colObj0, colObj0->m_worldTransform, -1, -1);
+		btCollisionObjectWrapper obj1Wrap(0, colObj1->m_collisionShape, colObj1, colObj1->m_worldTransform, -1, -1);
 
 		//dispatcher will keep algorithms persistent in the collision pair
 		if (!collisionPair.m_algorithm)

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btCollisionDispatcherMt.cpp

@@ -39,10 +39,10 @@ btPersistentManifold* btCollisionDispatcherMt::getNewManifold(const btCollisionO
 {
 	//optional relative contact breaking threshold, turned on by default (use setDispatcherFlags to switch off feature for improved performance)
 
-	btScalar contactBreakingThreshold = (m_dispatcherFlags & btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD) ? btMin(body0->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold), body1->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold))
+	btScalar contactBreakingThreshold = (m_dispatcherFlags & btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD) ? btMin(body0->m_collisionShape->getContactBreakingThreshold(gContactBreakingThreshold), body1->m_collisionShape->getContactBreakingThreshold(gContactBreakingThreshold))
 																																: gContactBreakingThreshold;
 
-	btScalar contactProcessingThreshold = btMin(body0->getContactProcessingThreshold(), body1->getContactProcessingThreshold());
+	btScalar contactProcessingThreshold = btMin(body0->m_contactProcessingThreshold, body1->m_contactProcessingThreshold);
 
 	void* mem = m_persistentManifoldPoolAllocator->allocate(sizeof(btPersistentManifold));
 	if (NULL == mem)

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btCollisionObject.h

@@ -4,8 +4,8 @@ Copyright (c) 2003-2006 Erwin Coumans  https://bulletphysics.org
 
 This software is provided 'as-is', without any express or implied warranty.
 In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
 subject to the following restrictions:
 
 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
@@ -49,7 +49,7 @@ typedef btAlignedObjectArray<class btCollisionObject*> btCollisionObjectArray;
 ATTRIBUTE_ALIGNED16(class)
 btCollisionObject
 {
-protected:
+public:
 	btTransform m_worldTransform;
 
 	///m_interpolationWorldTransform is used for CCD and interpolation
@@ -62,6 +62,8 @@ protected:
 
 	btVector3 m_anisotropicFriction;
 	int m_hasAnisotropicFriction;
+	///the constraint solver can discard solving contacts, if the distance is above this threshold. 0 by default.
+	///Note that using contacts with positive distance can improve stability. It increases, however, the chance of colliding with degerate contacts, such as 'interior' triangle edges
 	btScalar m_contactProcessingThreshold;
 
 	btBroadphaseProxy* m_broadphaseHandle;
@@ -168,10 +170,6 @@ public:
 		return ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE)) == 0);
 	}
 
-	const btVector3& getAnisotropicFriction() const
-	{
-		return m_anisotropicFriction;
-	}
 	void setAnisotropicFriction(const btVector3& anisotropicFriction, int frictionMode = CF_ANISOTROPIC_FRICTION)
 	{
 		m_anisotropicFriction = anisotropicFriction;
@@ -183,17 +181,6 @@ public:
 		return (m_hasAnisotropicFriction & frictionMode) != 0;
 	}
 
-	///the constraint solver can discard solving contacts, if the distance is above this threshold. 0 by default.
-	///Note that using contacts with positive distance can improve stability. It increases, however, the chance of colliding with degerate contacts, such as 'interior' triangle edges
-	void setContactProcessingThreshold(btScalar contactProcessingThreshold)
-	{
-		m_contactProcessingThreshold = contactProcessingThreshold;
-	}
-	btScalar getContactProcessingThreshold() const
-	{
-		return m_contactProcessingThreshold;
-	}
-
 	SIMD_FORCE_INLINE bool isStaticObject() const
 	{
 		return (m_collisionFlags & CF_STATIC_OBJECT) != 0;
@@ -225,16 +212,6 @@ public:
 		m_rootCollisionShape = collisionShape;
 	}
 
-	SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const
-	{
-		return m_collisionShape;
-	}
-
-	SIMD_FORCE_INLINE btCollisionShape* getCollisionShape()
-	{
-		return m_collisionShape;
-	}
-
 	void setIgnoreCollisionCheck(const btCollisionObject* co, bool ignoreCollisionCheck)
 	{
 		if (ignoreCollisionCheck)
@@ -273,39 +250,15 @@ public:
 		return true;
 	}
 
-	///Avoid using this internal API call, the extension pointer is used by some Bullet extensions.
-	///If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead.
-	void* internalGetExtensionPointer() const
-	{
-		return m_extensionPointer;
-	}
-	///Avoid using this internal API call, the extension pointer is used by some Bullet extensions
-	///If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead.
-	void internalSetExtensionPointer(void* pointer)
-	{
-		m_extensionPointer = pointer;
-	}
-
-	SIMD_FORCE_INLINE int getActivationState() const { return m_activationState1; }
-
 	void setActivationState(int newState) const;
 
-	void setDeactivationTime(btScalar time)
-	{
-		m_deactivationTime = time;
-	}
-	btScalar getDeactivationTime() const
-	{
-		return m_deactivationTime;
-	}
-
 	void forceActivationState(int newState) const;
 
 	void activate(bool forceActivation = false) const;
 
 	SIMD_FORCE_INLINE bool isActive() const
 	{
-		return ((getActivationState() != FIXED_BASE_MULTI_BODY) && (getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
+		return ((m_activationState1 != FIXED_BASE_MULTI_BODY) && (m_activationState1 != ISLAND_SLEEPING) && (m_activationState1 != DISABLE_SIMULATION));
 	}
 
 	void setRestitution(btScalar rest)
@@ -313,38 +266,22 @@ public:
 		m_updateRevision++;
 		m_restitution = rest;
 	}
-	btScalar getRestitution() const
-	{
-		return m_restitution;
-	}
 	void setFriction(btScalar frict)
 	{
 		m_updateRevision++;
 		m_friction = frict;
 	}
-	btScalar getFriction() const
-	{
-		return m_friction;
-	}
 
 	void setRollingFriction(btScalar frict)
 	{
 		m_updateRevision++;
 		m_rollingFriction = frict;
 	}
-	btScalar getRollingFriction() const
-	{
-		return m_rollingFriction;
-	}
 	void setSpinningFriction(btScalar frict)
 	{
 		m_updateRevision++;
 		m_spinningFriction = frict;
 	}
-	btScalar getSpinningFriction() const
-	{
-		return m_spinningFriction;
-	}
 	void setContactStiffnessAndDamping(btScalar stiffness, btScalar damping)
 	{
 		m_updateRevision++;
@@ -360,63 +297,12 @@ public:
 		}
 	}
 
-	btScalar getContactStiffness() const
-	{
-		return m_contactStiffness;
-	}
-
-	btScalar getContactDamping() const
-	{
-		return m_contactDamping;
-	}
-
-	///reserved for Bullet internal usage
-	int getInternalType() const
-	{
-		return m_internalType;
-	}
-
-	btTransform& getWorldTransform()
-	{
-		return m_worldTransform;
-	}
-
-	const btTransform& getWorldTransform() const
-	{
-		return m_worldTransform;
-	}
-
 	void setWorldTransform(const btTransform& worldTrans)
 	{
 		m_updateRevision++;
 		m_worldTransform = worldTrans;
 	}
 
-	SIMD_FORCE_INLINE btBroadphaseProxy* getBroadphaseHandle()
-	{
-		return m_broadphaseHandle;
-	}
-
-	SIMD_FORCE_INLINE const btBroadphaseProxy* getBroadphaseHandle() const
-	{
-		return m_broadphaseHandle;
-	}
-
-	void setBroadphaseHandle(btBroadphaseProxy * handle)
-	{
-		m_broadphaseHandle = handle;
-	}
-
-	const btTransform& getInterpolationWorldTransform() const
-	{
-		return m_interpolationWorldTransform;
-	}
-
-	btTransform& getInterpolationWorldTransform()
-	{
-		return m_interpolationWorldTransform;
-	}
-
 	void setInterpolationWorldTransform(const btTransform& trans)
 	{
 		m_updateRevision++;
@@ -435,143 +321,11 @@ public:
 		m_interpolationAngularVelocity = angvel;
 	}
 
-	const btVector3& getInterpolationLinearVelocity() const
-	{
-		return m_interpolationLinearVelocity;
-	}
-
-	const btVector3& getInterpolationAngularVelocity() const
-	{
-		return m_interpolationAngularVelocity;
-	}
-
-	SIMD_FORCE_INLINE int getIslandTag() const
-	{
-		return m_islandTag1;
-	}
-
-	void setIslandTag(int tag)
-	{
-		m_islandTag1 = tag;
-	}
-
-	SIMD_FORCE_INLINE int getCompanionId() const
-	{
-		return m_companionId;
-	}
-
-	void setCompanionId(int id)
-	{
-		m_companionId = id;
-	}
-
-	SIMD_FORCE_INLINE int getWorldArrayIndex() const
-	{
-		return m_worldArrayIndex;
-	}
-
-	// only should be called by CollisionWorld
-	void setWorldArrayIndex(int ix)
-	{
-		m_worldArrayIndex = ix;
-	}
-
-	SIMD_FORCE_INLINE btScalar getHitFraction() const
-	{
-		return m_hitFraction;
-	}
-
-	void setHitFraction(btScalar hitFraction)
-	{
-		m_hitFraction = hitFraction;
-	}
-
-	SIMD_FORCE_INLINE int getCollisionFlags() const
-	{
-		return m_collisionFlags;
-	}
-
-	void setCollisionFlags(int flags)
-	{
-		m_collisionFlags = flags;
-	}
-
-	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
-	btScalar getCcdSweptSphereRadius() const
-	{
-		return m_ccdSweptSphereRadius;
-	}
-
-	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
-	void setCcdSweptSphereRadius(btScalar radius)
-	{
-		m_ccdSweptSphereRadius = radius;
-	}
-
-	btScalar getCcdMotionThreshold() const
-	{
-		return m_ccdMotionThreshold;
-	}
-
 	btScalar getCcdSquareMotionThreshold() const
 	{
 		return m_ccdMotionThreshold * m_ccdMotionThreshold;
 	}
 
-	/// Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold
-	void setCcdMotionThreshold(btScalar ccdMotionThreshold)
-	{
-		m_ccdMotionThreshold = ccdMotionThreshold;
-	}
-
-	///users can point to their objects, userPointer is not used by Bullet
-	void* getUserPointer() const
-	{
-		return m_userObjectPointer;
-	}
-
-	int getUserIndex() const
-	{
-		return m_userIndex;
-	}
-
-	int getUserIndex2() const
-	{
-		return m_userIndex2;
-	}
-
-	int getUserIndex3() const
-	{
-		return m_userIndex3;
-	}
-
-	///users can point to their objects, userPointer is not used by Bullet
-	void setUserPointer(void* userPointer)
-	{
-		m_userObjectPointer = userPointer;
-	}
-
-	///users can point to their objects, userPointer is not used by Bullet
-	void setUserIndex(int index)
-	{
-		m_userIndex = index;
-	}
-
-	void setUserIndex2(int index)
-	{
-		m_userIndex2 = index;
-	}
-
-	void setUserIndex3(int index)
-	{
-		m_userIndex3 = index;
-	}
-
-	int getUpdateRevisionInternal() const
-	{
-		return m_updateRevision;
-	}
-
 	void setCustomDebugColor(const btVector3& colorRGB)
 	{
 		m_customDebugColorRGB = colorRGB;
@@ -624,14 +378,14 @@ struct	btCollisionObjectDoubleData
 	btVector3DoubleData		m_interpolationLinearVelocity;
 	btVector3DoubleData		m_interpolationAngularVelocity;
 	btVector3DoubleData		m_anisotropicFriction;
-	double					m_contactProcessingThreshold;	
+	double					m_contactProcessingThreshold;
 	double					m_deactivationTime;
 	double					m_friction;
 	double					m_rollingFriction;
 	double                  m_contactDamping;
 	double                  m_contactStiffness;
 	double					m_restitution;
-	double					m_hitFraction; 
+	double					m_hitFraction;
 	double					m_ccdSweptSphereRadius;
 	double					m_ccdMotionThreshold;
 	int						m_hasAnisotropicFriction;
@@ -659,14 +413,14 @@ struct	btCollisionObjectFloatData
 	btVector3FloatData		m_interpolationLinearVelocity;
 	btVector3FloatData		m_interpolationAngularVelocity;
 	btVector3FloatData		m_anisotropicFriction;
-	float					m_contactProcessingThreshold;	
+	float					m_contactProcessingThreshold;
 	float					m_deactivationTime;
 	float					m_friction;
 	float					m_rollingFriction;
 	float                   m_contactDamping;
     float                   m_contactStiffness;
 	float					m_restitution;
-	float					m_hitFraction; 
+	float					m_hitFraction;
 	float					m_ccdSweptSphereRadius;
 	float					m_ccdMotionThreshold;
 	int						m_hasAnisotropicFriction;

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h

@@ -24,7 +24,7 @@ private:
 
 public:
 	const btCollisionObjectWrapper* m_parent;
-	const btCollisionShape* m_shape;
+	const btCollisionShape* m_collisionShape;
 	const btCollisionObject* m_collisionObject;
 	const btTransform& m_worldTransform;
     const btTransform* m_preTransform;
@@ -32,18 +32,14 @@ public:
 	int m_index;
 
 	btCollisionObjectWrapper(const btCollisionObjectWrapper* parent, const btCollisionShape* shape, const btCollisionObject* collisionObject, const btTransform& worldTransform, int partId, int index)
-		: m_parent(parent), m_shape(shape), m_collisionObject(collisionObject), m_worldTransform(worldTransform), m_preTransform(NULL), m_partId(partId), m_index(index)
+		: m_parent(parent), m_collisionShape(shape), m_collisionObject(collisionObject), m_worldTransform(worldTransform), m_preTransform(NULL), m_partId(partId), m_index(index)
 	{
 	}
-    
+
     btCollisionObjectWrapper(const btCollisionObjectWrapper* parent, const btCollisionShape* shape, const btCollisionObject* collisionObject, const btTransform& worldTransform, const btTransform& preTransform, int partId, int index)
-    : m_parent(parent), m_shape(shape), m_collisionObject(collisionObject), m_worldTransform(worldTransform), m_preTransform(&preTransform), m_partId(partId), m_index(index)
+    : m_parent(parent), m_collisionShape(shape), m_collisionObject(collisionObject), m_worldTransform(worldTransform), m_preTransform(&preTransform), m_partId(partId), m_index(index)
     {
     }
-
-	SIMD_FORCE_INLINE const btTransform& getWorldTransform() const { return m_worldTransform; }
-	SIMD_FORCE_INLINE const btCollisionObject* getCollisionObject() const { return m_collisionObject; }
-	SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const { return m_shape; }
 };
 
 #endif  //BT_COLLISION_OBJECT_WRAPPER_H

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp

@@ -80,7 +80,7 @@ btCollisionWorld::~btCollisionWorld()
 	{
 		btCollisionObject* collisionObject = m_collisionObjects[i];
 
-		btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
+		btBroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
 		if (bp)
 		{
 			//
@@ -88,29 +88,29 @@ btCollisionWorld::~btCollisionWorld()
 			//
 			getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp, m_dispatcher1);
 			getBroadphase()->destroyProxy(bp, m_dispatcher1);
-			collisionObject->setBroadphaseHandle(0);
+			collisionObject->m_broadphaseHandle = (0);
 		}
 	}
 }
 
 void btCollisionWorld::refreshBroadphaseProxy(btCollisionObject* collisionObject)
 {
-	if (collisionObject->getBroadphaseHandle())
+	if (collisionObject->m_broadphaseHandle)
 	{
-		int collisionFilterGroup = collisionObject->getBroadphaseHandle()->m_collisionFilterGroup;
-		int collisionFilterMask = collisionObject->getBroadphaseHandle()->m_collisionFilterMask;
+		int collisionFilterGroup = collisionObject->m_broadphaseHandle->m_collisionFilterGroup;
+		int collisionFilterMask = collisionObject->m_broadphaseHandle->m_collisionFilterMask;
 
-		getBroadphase()->destroyProxy(collisionObject->getBroadphaseHandle(), getDispatcher());
+		getBroadphase()->destroyProxy(collisionObject->m_broadphaseHandle, getDispatcher());
 
 		//calculate new AABB
-		btTransform trans = collisionObject->getWorldTransform();
+		btTransform trans = collisionObject->m_worldTransform;
 
 		btVector3 minAabb;
 		btVector3 maxAabb;
-		collisionObject->getCollisionShape()->getAabb(trans, minAabb, maxAabb);
+		collisionObject->m_collisionShape->getAabb(trans, minAabb, maxAabb);
 
-		int type = collisionObject->getCollisionShape()->getShapeType();
-		collisionObject->setBroadphaseHandle(getBroadphase()->createProxy(
+		int type = collisionObject->m_collisionShape->getShapeType();
+		collisionObject->m_broadphaseHandle = (getBroadphase()->createProxy(
 			minAabb,
 			maxAabb,
 			type,
@@ -127,20 +127,20 @@ void btCollisionWorld::addCollisionObject(btCollisionObject* collisionObject, in
 
 	//check that the object isn't already added
 	btAssert(m_collisionObjects.findLinearSearch(collisionObject) == m_collisionObjects.size());
-	btAssert(collisionObject->getWorldArrayIndex() == -1);  // do not add the same object to more than one collision world
+	btAssert(collisionObject->m_worldArrayIndex == -1);  // do not add the same object to more than one collision world
 
-	collisionObject->setWorldArrayIndex(m_collisionObjects.size());
+	collisionObject->m_worldArrayIndex = (m_collisionObjects.size());
 	m_collisionObjects.push_back(collisionObject);
 
 	//calculate new AABB
-	btTransform trans = collisionObject->getWorldTransform();
+	btTransform trans = collisionObject->m_worldTransform;
 
 	btVector3 minAabb;
 	btVector3 maxAabb;
-	collisionObject->getCollisionShape()->getAabb(trans, minAabb, maxAabb);
+	collisionObject->m_collisionShape->getAabb(trans, minAabb, maxAabb);
 
-	int type = collisionObject->getCollisionShape()->getShapeType();
-	collisionObject->setBroadphaseHandle(getBroadphase()->createProxy(
+	int type = collisionObject->m_collisionShape->getShapeType();
+	collisionObject->m_broadphaseHandle = (getBroadphase()->createProxy(
 		minAabb,
 		maxAabb,
 		type,
@@ -153,16 +153,16 @@ void btCollisionWorld::addCollisionObject(btCollisionObject* collisionObject, in
 void btCollisionWorld::updateSingleAabb(btCollisionObject* colObj)
 {
 	btVector3 minAabb, maxAabb;
-	colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb, maxAabb);
+	colObj->m_collisionShape->getAabb(colObj->m_worldTransform, minAabb, maxAabb);
 	//need to increase the aabb for contact thresholds
 	btVector3 contactThreshold(gContactBreakingThreshold, gContactBreakingThreshold, gContactBreakingThreshold);
 	minAabb -= contactThreshold;
 	maxAabb += contactThreshold;
 
-	if (getDispatchInfo().m_useContinuous && colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY && !colObj->isStaticOrKinematicObject())
+	if (getDispatchInfo().m_useContinuous && colObj->m_internalType == btCollisionObject::CO_RIGID_BODY && !colObj->isStaticOrKinematicObject())
 	{
 		btVector3 minAabb2, maxAabb2;
-		colObj->getCollisionShape()->getAabb(colObj->getInterpolationWorldTransform(), minAabb2, maxAabb2);
+		colObj->m_collisionShape->getAabb(colObj->m_interpolationWorldTransform, minAabb2, maxAabb2);
 		minAabb2 -= contactThreshold;
 		maxAabb2 += contactThreshold;
 		minAabb.setMin(minAabb2);
@@ -174,7 +174,7 @@ void btCollisionWorld::updateSingleAabb(btCollisionObject* colObj)
 	//moving objects should be moderately sized, probably something wrong if not
 	if (colObj->isStaticObject() || ((maxAabb - minAabb).length2() < btScalar(1e12)))
 	{
-		bp->setAabb(colObj->getBroadphaseHandle(), minAabb, maxAabb, m_dispatcher1);
+		bp->setAabb(colObj->m_broadphaseHandle, minAabb, maxAabb, m_dispatcher1);
 	}
 	else
 	{
@@ -201,7 +201,7 @@ void btCollisionWorld::updateAabbs()
 	for (int i = 0; i < m_collisionObjects.size(); i++)
 	{
 		btCollisionObject* colObj = m_collisionObjects[i];
-		btAssert(colObj->getWorldArrayIndex() == i);
+		btAssert(colObj->m_worldArrayIndex == i);
 
 		//only update aabb of active objects
 		if (m_forceUpdateAllAabbs || colObj->isActive())
@@ -240,7 +240,7 @@ void btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject)
 	//bool removeFromBroadphase = false;
 
 	{
-		btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
+		btBroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
 		if (bp)
 		{
 			//
@@ -248,11 +248,11 @@ void btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject)
 			//
 			getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp, m_dispatcher1);
 			getBroadphase()->destroyProxy(bp, m_dispatcher1);
-			collisionObject->setBroadphaseHandle(0);
+			collisionObject->m_broadphaseHandle = (0);
 		}
 	}
 
-	int iObj = collisionObject->getWorldArrayIndex();
+	int iObj = collisionObject->m_worldArrayIndex;
 	//    btAssert(iObj >= 0 && iObj < m_collisionObjects.size()); // trying to remove an object that was never added or already removed previously?
 	if (iObj >= 0 && iObj < m_collisionObjects.size())
 	{
@@ -261,7 +261,7 @@ void btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject)
 		m_collisionObjects.pop_back();
 		if (iObj < m_collisionObjects.size())
 		{
-			m_collisionObjects[iObj]->setWorldArrayIndex(iObj);
+			m_collisionObjects[iObj]->m_worldArrayIndex = (iObj);
 		}
 	}
 	else
@@ -270,7 +270,7 @@ void btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject)
 		//swapremove
 		m_collisionObjects.remove(collisionObject);
 	}
-	collisionObject->setWorldArrayIndex(-1);
+	collisionObject->m_worldArrayIndex = (-1);
 }
 
 void btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans, const btTransform& rayToTrans,
@@ -290,8 +290,8 @@ void btCollisionWorld::rayTestSingleInternal(const btTransform& rayFromTrans, co
 	btSphereShape pointShape(btScalar(0.0));
 	pointShape.setMargin(0.f);
 	const btConvexShape* castShape = &pointShape;
-	const btCollisionShape* collisionShape = collisionObjectWrap->getCollisionShape();
-	const btTransform& colObjWorldTransform = collisionObjectWrap->getWorldTransform();
+	const btCollisionShape* collisionShape = collisionObjectWrap->m_collisionShape;
+	const btTransform& colObjWorldTransform = collisionObjectWrap->m_worldTransform;
 
 	if (collisionShape->isConvex())
 	{
@@ -331,7 +331,7 @@ void btCollisionWorld::rayTestSingleInternal(const btTransform& rayFromTrans, co
 
 					castResult.m_normal.normalize();
 					btCollisionWorld::LocalRayResult localRayResult(
-						collisionObjectWrap->getCollisionObject(),
+						collisionObjectWrap->m_collisionObject,
 						0,
 						castResult.m_normal,
 						castResult.m_fraction);
@@ -393,7 +393,7 @@ void btCollisionWorld::rayTestSingleInternal(const btTransform& rayFromTrans, co
 				///optimized version for btBvhTriangleMeshShape
 				btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape;
 
-				BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->getCollisionObject(), triangleMesh, colObjWorldTransform);
+				BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->m_collisionObject, triangleMesh, colObjWorldTransform);
 				rcb.m_hitFraction = resultCallback.m_closestHitFraction;
 				triangleMesh->performRaycast(&rcb, rayFromLocal, rayToLocal);
 			}
@@ -409,7 +409,7 @@ void btCollisionWorld::rayTestSingleInternal(const btTransform& rayFromTrans, co
 				btVector3 rayToLocalScaled = rayToLocal / scale;
 
 				//perform raycast in the underlying btBvhTriangleMeshShape
-				BridgeTriangleRaycastCallback rcb(rayFromLocalScaled, rayToLocalScaled, &resultCallback, collisionObjectWrap->getCollisionObject(), triangleMesh, colObjWorldTransform);
+				BridgeTriangleRaycastCallback rcb(rayFromLocalScaled, rayToLocalScaled, &resultCallback, collisionObjectWrap->m_collisionObject, triangleMesh, colObjWorldTransform);
 				rcb.m_hitFraction = resultCallback.m_closestHitFraction;
 				triangleMesh->performRaycast(&rcb, rayFromLocalScaled, rayToLocalScaled);
 			}
@@ -423,7 +423,7 @@ void btCollisionWorld::rayTestSingleInternal(const btTransform& rayFromTrans, co
 				btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.m_origin;
 				btVector3 rayToLocal = worldTocollisionObject * rayToTrans.m_origin;
 
-				BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->getCollisionObject(), heightField, colObjWorldTransform);
+				BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->m_collisionObject, heightField, colObjWorldTransform);
 				rcb.m_hitFraction = resultCallback.m_closestHitFraction;
 				heightField->performRaycast(&rcb, rayFromLocal, rayToLocal);
 			}
@@ -475,7 +475,7 @@ void btCollisionWorld::rayTestSingleInternal(const btTransform& rayFromTrans, co
 					}
 				};
 
-				BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->getCollisionObject(), concaveShape, colObjWorldTransform);
+				BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->m_collisionObject, concaveShape, colObjWorldTransform);
 				rcb.m_hitFraction = resultCallback.m_closestHitFraction;
 
 				btVector3 rayAabbMinLocal = rayFromLocal;
@@ -572,7 +572,7 @@ void btCollisionWorld::rayTestSingleInternal(const btTransform& rayFromTrans, co
 				const btDbvt* dbvt = compoundShape->getDynamicAabbTree();
 
 				RayTester rayCB(
-					collisionObjectWrap->getCollisionObject(),
+					collisionObjectWrap->m_collisionObject,
 					compoundShape,
 					colObjWorldTransform,
 					rayFromTrans,
@@ -612,8 +612,8 @@ void btCollisionWorld::objectQuerySingleInternal(const btConvexShape* castShape,
 												 const btCollisionObjectWrapper* colObjWrap,
 												 ConvexResultCallback& resultCallback, btScalar allowedPenetration)
 {
-	const btCollisionShape* collisionShape = colObjWrap->getCollisionShape();
-	const btTransform& colObjWorldTransform = colObjWrap->getWorldTransform();
+	const btCollisionShape* collisionShape = colObjWrap->m_collisionShape;
+	const btTransform& colObjWorldTransform = colObjWrap->m_worldTransform;
 
 	if (collisionShape->isConvex())
 	{
@@ -641,7 +641,7 @@ void btCollisionWorld::objectQuerySingleInternal(const btConvexShape* castShape,
 				{
 					castResult.m_normal.normalize();
 					btCollisionWorld::LocalConvexResult localConvexResult(
-						colObjWrap->getCollisionObject(),
+						colObjWrap->m_collisionObject,
 						0,
 						castResult.m_normal,
 						castResult.m_hitPoint,
@@ -703,7 +703,7 @@ void btCollisionWorld::objectQuerySingleInternal(const btConvexShape* castShape,
 					}
 				};
 
-				BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans, convexToTrans, &resultCallback, colObjWrap->getCollisionObject(), triangleMesh, colObjWorldTransform);
+				BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans, convexToTrans, &resultCallback, colObjWrap->m_collisionObject, triangleMesh, colObjWorldTransform);
 				tccb.m_hitFraction = resultCallback.m_closestHitFraction;
 				tccb.m_allowedPenetration = allowedPenetration;
 				btVector3 boxMinLocal, boxMaxLocal;
@@ -730,7 +730,7 @@ void btCollisionWorld::objectQuerySingleInternal(const btConvexShape* castShape,
 							{
 								castResult.m_normal.normalize();
 								btCollisionWorld::LocalConvexResult localConvexResult(
-									colObjWrap->getCollisionObject(),
+									colObjWrap->m_collisionObject,
 									0,
 									castResult.m_normal,
 									castResult.m_hitPoint,
@@ -788,7 +788,7 @@ void btCollisionWorld::objectQuerySingleInternal(const btConvexShape* castShape,
 						}
 					};
 
-					BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans, convexToTrans, &resultCallback, colObjWrap->getCollisionObject(), concaveShape, colObjWorldTransform);
+					BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans, convexToTrans, &resultCallback, colObjWrap->m_collisionObject, concaveShape, colObjWorldTransform);
 					tccb.m_hitFraction = resultCallback.m_closestHitFraction;
 					tccb.m_allowedPenetration = allowedPenetration;
 					btVector3 boxMinLocal, boxMaxLocal;
@@ -873,7 +873,7 @@ void btCollisionWorld::objectQuerySingleInternal(const btConvexShape* castShape,
 
 						LocalInfoAdder my_cb(index, &m_resultCallback);
 
-						btCollisionObjectWrapper tmpObj(m_colObjWrap, childCollisionShape, m_colObjWrap->getCollisionObject(), childWorldTrans, -1, index);
+						btCollisionObjectWrapper tmpObj(m_colObjWrap, childCollisionShape, m_colObjWrap->m_collisionObject, childWorldTrans, -1, index);
 
 						objectQuerySingleInternal(m_castShape, m_convexFromTrans, m_convexToTrans, &tmpObj, my_cb, m_allowedPenetration);
 					}
@@ -971,18 +971,18 @@ struct btSingleRayCallback : public btBroadphaseRayCallback
 		btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
 
 		//only perform raycast if filterMask matches
-		if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
+		if (m_resultCallback.needsCollision(collisionObject->m_broadphaseHandle))
 		{
 			//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
 			//btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
 #if 0
 #ifdef RECALCULATE_AABB
 			btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
-			collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
+			collisionObject->m_collisionShape->getAabb(collisionObject->m_worldTransform,collisionObjectAabbMin,collisionObjectAabbMax);
 #else
-			//getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax);
-			const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
-			const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
+			//getBroadphase()->getAabb(collisionObject->m_broadphaseHandle,collisionObjectAabbMin,collisionObjectAabbMax);
+			const btVector3& collisionObjectAabbMin = collisionObject->m_broadphaseHandle->m_aabbMin;
+			const btVector3& collisionObjectAabbMax = collisionObject->m_broadphaseHandle->m_aabbMax;
 #endif
 #endif
 			//btScalar hitLambda = m_resultCallback.m_closestHitFraction;
@@ -991,8 +991,8 @@ struct btSingleRayCallback : public btBroadphaseRayCallback
 			{
 				m_world->rayTestSingle(m_rayFromTrans, m_rayToTrans,
 									   collisionObject,
-									   collisionObject->getCollisionShape(),
-									   collisionObject->getWorldTransform(),
+									   collisionObject->m_collisionShape,
+									   collisionObject->m_worldTransform,
 									   m_resultCallback);
 			}
 		}
@@ -1012,7 +1012,7 @@ void btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& r
 #else
 	for (int i = 0; i < this->getNumCollisionObjects(); i++)
 	{
-		rayCB.process(m_collisionObjects[i]->getBroadphaseHandle());
+		rayCB.process(m_collisionObjects[i]->m_broadphaseHandle);
 	}
 #endif  //USE_BRUTEFORCE_RAYBROADPHASE
 }
@@ -1057,13 +1057,13 @@ struct btSingleSweepCallback : public btBroadphaseRayCallback
 		btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
 
 		//only perform raycast if filterMask matches
-		if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
+		if (m_resultCallback.needsCollision(collisionObject->m_broadphaseHandle))
 		{
 			//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
 			m_world->objectQuerySingle(m_castShape, m_convexFromTrans, m_convexToTrans,
 									   collisionObject,
-									   collisionObject->getCollisionShape(),
-									   collisionObject->getWorldTransform(),
+									   collisionObject->m_collisionShape,
+									   collisionObject->m_worldTransform,
 									   m_resultCallback,
 									   m_allowedCcdPenetration);
 		}
@@ -1109,11 +1109,11 @@ void btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btT
 	{
 		btCollisionObject* collisionObject = m_collisionObjects[i];
 		//only perform raycast if filterMask matches
-		if (resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
+		if (resultCallback.needsCollision(collisionObject->m_broadphaseHandle))
 		{
 			//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
 			btVector3 collisionObjectAabbMin, collisionObjectAabbMax;
-			collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(), collisionObjectAabbMin, collisionObjectAabbMax);
+			collisionObject->m_collisionShape->getAabb(collisionObject->m_worldTransform, collisionObjectAabbMin, collisionObjectAabbMax);
 			AabbExpand(collisionObjectAabbMin, collisionObjectAabbMax, castShapeAabbMin, castShapeAabbMax);
 			btScalar hitLambda = btScalar(1.);  //could use resultCallback.m_closestHitFraction, but needs testing
 			btVector3 hitNormal;
@@ -1121,8 +1121,8 @@ void btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btT
 			{
 				objectQuerySingle(castShape, convexFromTrans, convexToTrans,
 								  collisionObject,
-								  collisionObject->getCollisionShape(),
-								  collisionObject->getWorldTransform(),
+								  collisionObject->m_collisionShape,
+								  collisionObject->m_worldTransform,
 								  resultCallback,
 								  allowedCcdPenetration);
 			}
@@ -1143,19 +1143,19 @@ struct btBridgedManifoldResult : public btManifoldResult
 
 	virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth)
 	{
-		bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject();
+		bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->m_collisionObject;
 		btVector3 pointA = pointInWorld + normalOnBInWorld * depth;
 		btVector3 localA;
 		btVector3 localB;
 		if (isSwapped)
 		{
-			localA = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointA);
-			localB = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld);
+			localA = m_body1Wrap->m_collisionObject->m_worldTransform.invXform(pointA);
+			localB = m_body0Wrap->m_collisionObject->m_worldTransform.invXform(pointInWorld);
 		}
 		else
 		{
-			localA = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointA);
-			localB = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld);
+			localA = m_body0Wrap->m_collisionObject->m_worldTransform.invXform(pointA);
+			localB = m_body1Wrap->m_collisionObject->m_worldTransform.invXform(pointInWorld);
 		}
 
 		btManifoldPoint newPt(localA, localB, normalOnBInWorld, depth);
@@ -1205,10 +1205,10 @@ struct btSingleContactCallback : public btBroadphaseAabbCallback
 			return true;
 
 		//only perform raycast if filterMask matches
-		if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
+		if (m_resultCallback.needsCollision(collisionObject->m_broadphaseHandle))
 		{
-			btCollisionObjectWrapper ob0(0, m_collisionObject->getCollisionShape(), m_collisionObject, m_collisionObject->getWorldTransform(), -1, -1);
-			btCollisionObjectWrapper ob1(0, collisionObject->getCollisionShape(), collisionObject, collisionObject->getWorldTransform(), -1, -1);
+			btCollisionObjectWrapper ob0(0, m_collisionObject->m_collisionShape, m_collisionObject, m_collisionObject->m_worldTransform, -1, -1);
+			btCollisionObjectWrapper ob1(0, collisionObject->m_collisionShape, collisionObject, collisionObject->m_worldTransform, -1, -1);
 
 			btCollisionAlgorithm* algorithm = m_world->getDispatcher()->findAlgorithm(&ob0, &ob1, 0, BT_CLOSEST_POINT_ALGORITHMS);
 			if (algorithm)
@@ -1231,7 +1231,7 @@ struct btSingleContactCallback : public btBroadphaseAabbCallback
 void btCollisionWorld::contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback)
 {
 	btVector3 aabbMin, aabbMax;
-	colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), aabbMin, aabbMax);
+	colObj->m_collisionShape->getAabb(colObj->m_worldTransform, aabbMin, aabbMax);
 	btSingleContactCallback contactCB(colObj, this, resultCallback);
 
 	m_broadphasePairCache->aabbTest(aabbMin, aabbMax, contactCB);
@@ -1241,8 +1241,8 @@ void btCollisionWorld::contactTest(btCollisionObject* colObj, ContactResultCallb
 ///it reports one or more contact points (including the one with deepest penetration)
 void btCollisionWorld::contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback)
 {
-	btCollisionObjectWrapper obA(0, colObjA->getCollisionShape(), colObjA, colObjA->getWorldTransform(), -1, -1);
-	btCollisionObjectWrapper obB(0, colObjB->getCollisionShape(), colObjB, colObjB->getWorldTransform(), -1, -1);
+	btCollisionObjectWrapper obA(0, colObjA->m_collisionShape, colObjA, colObjA->m_worldTransform, -1, -1);
+	btCollisionObjectWrapper obB(0, colObjB->m_collisionShape, colObjB, colObjB->m_worldTransform, -1, -1);
 
 	btCollisionAlgorithm* algorithm = getDispatcher()->findAlgorithm(&obA, &obB, 0, BT_CLOSEST_POINT_ALGORITHMS);
 	if (algorithm)
@@ -1501,13 +1501,13 @@ void btCollisionWorld::debugDrawWorld()
 			for (i = 0; i < m_collisionObjects.size(); i++)
 			{
 				btCollisionObject* colObj = m_collisionObjects[i];
-				if ((colObj->getCollisionFlags() & btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT) == 0)
+				if ((colObj->m_collisionFlags & btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT) == 0)
 				{
 					if (getDebugDrawer() && (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawWireframe))
 					{
 						btVector3 color(btScalar(0.4), btScalar(0.4), btScalar(0.4));
 
-						switch (colObj->getActivationState())
+						switch (colObj->m_activationState1)
 						{
 							case ACTIVE_TAG:
 								color = defaultColors.m_activeObject;
@@ -1532,22 +1532,22 @@ void btCollisionWorld::debugDrawWorld()
 
 						colObj->getCustomDebugColor(color);
 
-						debugDrawObject(colObj->getWorldTransform(), colObj->getCollisionShape(), color);
+						debugDrawObject(colObj->m_worldTransform, colObj->m_collisionShape, color);
 					}
 					if (m_debugDrawer && (m_debugDrawer->getDebugMode() & btIDebugDraw::DBG_DrawAabb))
 					{
 						btVector3 minAabb, maxAabb;
 						btVector3 colorvec = defaultColors.m_aabb;
-						colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb, maxAabb);
+						colObj->m_collisionShape->getAabb(colObj->m_worldTransform, minAabb, maxAabb);
 						btVector3 contactThreshold(gContactBreakingThreshold, gContactBreakingThreshold, gContactBreakingThreshold);
 						minAabb -= contactThreshold;
 						maxAabb += contactThreshold;
 
 						btVector3 minAabb2, maxAabb2;
 
-						if (getDispatchInfo().m_useContinuous && colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY && !colObj->isStaticOrKinematicObject())
+						if (getDispatchInfo().m_useContinuous && colObj->m_internalType == btCollisionObject::CO_RIGID_BODY && !colObj->isStaticOrKinematicObject())
 						{
-							colObj->getCollisionShape()->getAabb(colObj->getInterpolationWorldTransform(), minAabb2, maxAabb2);
+							colObj->m_collisionShape->getAabb(colObj->m_interpolationWorldTransform, minAabb2, maxAabb2);
 							minAabb2 -= contactThreshold;
 							maxAabb2 += contactThreshold;
 							minAabb.setMin(minAabb2);
@@ -1572,7 +1572,7 @@ void btCollisionWorld::serializeCollisionObjects(btSerializer* serializer)
 	for (i = 0; i < m_collisionObjects.size(); i++)
 	{
 		btCollisionObject* colObj = m_collisionObjects[i];
-		btCollisionShape* shape = colObj->getCollisionShape();
+		btCollisionShape* shape = colObj->m_collisionShape;
 
 		if (!serializedShapes.find(shape))
 		{
@@ -1585,7 +1585,7 @@ void btCollisionWorld::serializeCollisionObjects(btSerializer* serializer)
 	for (i = 0; i < m_collisionObjects.size(); i++)
 	{
 		btCollisionObject* colObj = m_collisionObjects[i];
-		if (colObj->getInternalType() == btCollisionObject::CO_COLLISION_OBJECT)
+		if (colObj->m_internalType == btCollisionObject::CO_COLLISION_OBJECT)
 		{
 			colObj->serializeSingleObject(serializer);
 		}

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btCollisionWorld.h

@@ -257,7 +257,7 @@ public:
 			else
 			{
 				///need to transform normal into worldspace
-				m_hitNormalWorld = m_collisionObject->getWorldTransform().m_basis * rayResult.m_hitNormalLocal;
+				m_hitNormalWorld = m_collisionObject->m_worldTransform.m_basis * rayResult.m_hitNormalLocal;
 			}
 			m_hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction);
 			return rayResult.m_hitFraction;
@@ -293,7 +293,7 @@ public:
 			else
 			{
 				///need to transform normal into worldspace
-				hitNormalWorld = m_collisionObject->getWorldTransform().m_basis * rayResult.m_hitNormalLocal;
+				hitNormalWorld = m_collisionObject->m_worldTransform.m_basis * rayResult.m_hitNormalLocal;
 			}
 			m_hitNormalWorld.push_back(hitNormalWorld);
 			btVector3 hitPointWorld;
@@ -389,7 +389,7 @@ public:
 			else
 			{
 				///need to transform normal into worldspace
-				m_hitNormalWorld = m_hitCollisionObject->getWorldTransform().m_basis * convexResult.m_hitNormalLocal;
+				m_hitNormalWorld = m_hitCollisionObject->m_worldTransform.m_basis * convexResult.m_hitNormalLocal;
 			}
 			m_hitPointWorld = convexResult.m_hitPointLocal;
 			return convexResult.m_hitFraction;

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp

@@ -33,9 +33,9 @@ btCompoundCollisionAlgorithm::btCompoundCollisionAlgorithm(const btCollisionAlgo
 	m_ownsManifold = false;
 
 	const btCollisionObjectWrapper* colObjWrap = m_isSwapped ? body1Wrap : body0Wrap;
-	btAssert(colObjWrap->getCollisionShape()->isCompound());
+	btAssert(colObjWrap->m_collisionShape->isCompound());
 
-	const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(colObjWrap->getCollisionShape());
+	const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(colObjWrap->m_collisionShape);
 	m_compoundShapeRevision = compoundShape->getUpdateRevision();
 
 	preallocateChildAlgorithms(body0Wrap, body1Wrap);
@@ -45,9 +45,9 @@ void btCompoundCollisionAlgorithm::preallocateChildAlgorithms(const btCollisionO
 {
 	const btCollisionObjectWrapper* colObjWrap = m_isSwapped ? body1Wrap : body0Wrap;
 	const btCollisionObjectWrapper* otherObjWrap = m_isSwapped ? body0Wrap : body1Wrap;
-	btAssert(colObjWrap->getCollisionShape()->isCompound());
+	btAssert(colObjWrap->m_collisionShape->isCompound());
 
-	const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(colObjWrap->getCollisionShape());
+	const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(colObjWrap->m_collisionShape);
 
 	int numChildren = compoundShape->getNumChildShapes();
 	int i;
@@ -63,7 +63,7 @@ void btCompoundCollisionAlgorithm::preallocateChildAlgorithms(const btCollisionO
 		{
 			const btCollisionShape* childShape = compoundShape->getChildShape(i);
 
-			btCollisionObjectWrapper childWrap(colObjWrap, childShape, colObjWrap->getCollisionObject(), colObjWrap->getWorldTransform(), -1, i);  //wrong child trans, but unused (hopefully)
+			btCollisionObjectWrapper childWrap(colObjWrap, childShape, colObjWrap->m_collisionObject, colObjWrap->m_worldTransform, -1, i);  //wrong child trans, but unused (hopefully)
 			m_childCollisionAlgorithms[i] = m_dispatcher->findAlgorithm(&childWrap, otherObjWrap, m_sharedManifold, BT_CONTACT_POINT_ALGORITHMS);
 
 			btAlignedObjectArray<btCollisionAlgorithm*> m_childCollisionAlgorithmsContact;
@@ -110,17 +110,17 @@ public:
 	void ProcessChildShape(const btCollisionShape* childShape, int index)
 	{
 		btAssert(index >= 0);
-		const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(m_compoundColObjWrap->getCollisionShape());
+		const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(m_compoundColObjWrap->m_collisionShape);
 		btAssert(index < compoundShape->getNumChildShapes());
 
 		if (gCompoundChildShapePairCallback)
 		{
-			if (!gCompoundChildShapePairCallback(m_otherObjWrap->getCollisionShape(), childShape))
+			if (!gCompoundChildShapePairCallback(m_otherObjWrap->m_collisionShape, childShape))
 				return;
 		}
 
 		//backup
-		btTransform orgTrans = m_compoundColObjWrap->getWorldTransform();
+		btTransform orgTrans = m_compoundColObjWrap->m_worldTransform;
 
 		const btTransform& childTrans = compoundShape->getChildTransform(index);
 		btTransform newChildWorldTrans = orgTrans * childTrans;
@@ -134,7 +134,7 @@ public:
 		aabbMax0 += extendAabb;
 
 		btVector3 aabbMin1, aabbMax1;
-		m_otherObjWrap->getCollisionShape()->getAabb(m_otherObjWrap->getWorldTransform(), aabbMin1, aabbMax1);
+		m_otherObjWrap->m_collisionShape->getAabb(m_otherObjWrap->m_worldTransform, aabbMin1, aabbMax1);
 
 
 		if (TestAabbAgainstAabb2(aabbMin0, aabbMax0, aabbMin1, aabbMax1))
@@ -144,7 +144,7 @@ public:
 			{
 				preTransform = preTransform *(*(this->m_compoundColObjWrap->m_preTransform));
 			}
-			btCollisionObjectWrapper compoundWrap(this->m_compoundColObjWrap, childShape, m_compoundColObjWrap->getCollisionObject(), newChildWorldTrans, preTransform, -1, index);
+			btCollisionObjectWrapper compoundWrap(this->m_compoundColObjWrap, childShape, m_compoundColObjWrap->m_collisionObject, newChildWorldTrans, preTransform, -1, index);
 
 			btCollisionAlgorithm* algo = 0;
 			bool allocatedAlgorithm = false;
@@ -167,7 +167,7 @@ public:
 			const btCollisionObjectWrapper* tmpWrap = 0;
 
 			///detect swapping case
-			if (m_resultOut->getBody0Internal() == m_compoundColObjWrap->getCollisionObject())
+			if (m_resultOut->getBody0Internal() == m_compoundColObjWrap->m_collisionObject)
 			{
 				tmpWrap = m_resultOut->getBody0Wrap();
 				m_resultOut->setBody0Wrap(&compoundWrap);
@@ -191,7 +191,7 @@ public:
 			}
 #endif
 
-			if (m_resultOut->getBody0Internal() == m_compoundColObjWrap->getCollisionObject())
+			if (m_resultOut->getBody0Internal() == m_compoundColObjWrap->m_collisionObject)
 			{
 				m_resultOut->setBody0Wrap(tmpWrap);
 			}
@@ -210,14 +210,14 @@ public:
 	{
 		int index = leaf->dataAsInt;
 
-		const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(m_compoundColObjWrap->getCollisionShape());
+		const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(m_compoundColObjWrap->m_collisionShape);
 		const btCollisionShape* childShape = compoundShape->getChildShape(index);
 
 #if 0
 		if (m_dispatchInfo.m_debugDraw && (m_dispatchInfo.m_debugDraw->getDebugMode() & btIDebugDraw::DBG_DrawAabb))
 		{
 			btVector3 worldAabbMin,worldAabbMax;
-			btTransform	orgTrans = m_compoundColObjWrap->getWorldTransform();
+			btTransform	orgTrans = m_compoundColObjWrap->m_worldTransform;
 			btTransformAabb(leaf->volume.Mins(),leaf->volume.Maxs(),0.,orgTrans,worldAabbMin,worldAabbMax);
 			m_dispatchInfo.m_debugDraw->drawAabb(worldAabbMin,worldAabbMax,btVector3(1,0,0));
 		}
@@ -232,8 +232,8 @@ void btCompoundCollisionAlgorithm::processCollision(const btCollisionObjectWrapp
 	const btCollisionObjectWrapper* colObjWrap = m_isSwapped ? body1Wrap : body0Wrap;
 	const btCollisionObjectWrapper* otherObjWrap = m_isSwapped ? body0Wrap : body1Wrap;
 
-	btAssert(colObjWrap->getCollisionShape()->isCompound());
-	const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(colObjWrap->getCollisionShape());
+	btAssert(colObjWrap->m_collisionShape->isCompound());
+	const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(colObjWrap->m_collisionShape);
 
 	///btCompoundShape might have changed:
 	////make sure the internal child collision algorithm caches are still valid
@@ -282,8 +282,8 @@ void btCompoundCollisionAlgorithm::processCollision(const btCollisionObjectWrapp
 	{
 		btVector3 localAabbMin, localAabbMax;
 		btTransform otherInCompoundSpace;
-		otherInCompoundSpace = colObjWrap->getWorldTransform().inverse() * otherObjWrap->getWorldTransform();
-		otherObjWrap->getCollisionShape()->getAabb(otherInCompoundSpace, localAabbMin, localAabbMax);
+		otherInCompoundSpace = colObjWrap->m_worldTransform.inverse() * otherObjWrap->m_worldTransform;
+		otherObjWrap->m_collisionShape->getAabb(otherInCompoundSpace, localAabbMin, localAabbMax);
 		btVector3 extraExtends(resultOut->m_closestPointDistanceThreshold, resultOut->m_closestPointDistanceThreshold, resultOut->m_closestPointDistanceThreshold);
 		localAabbMin -= extraExtends;
 		localAabbMax += extraExtends;
@@ -320,14 +320,14 @@ void btCompoundCollisionAlgorithm::processCollision(const btCollisionObjectWrapp
 			{
 				childShape = compoundShape->getChildShape(i);
 				//if not longer overlapping, remove the algorithm
-				orgTrans = colObjWrap->getWorldTransform();
+				orgTrans = colObjWrap->m_worldTransform;
 
 				const btTransform& childTrans = compoundShape->getChildTransform(i);
 				newChildWorldTrans = orgTrans * childTrans;
 
 				//perform an AABB check first
 				childShape->getAabb(newChildWorldTrans, aabbMin0, aabbMax0);
-				otherObjWrap->getCollisionShape()->getAabb(otherObjWrap->getWorldTransform(), aabbMin1, aabbMax1);
+				otherObjWrap->m_collisionShape->getAabb(otherObjWrap->m_worldTransform, aabbMin1, aabbMax1);
 
 				if (!TestAabbAgainstAabb2(aabbMin0, aabbMax0, aabbMin1, aabbMax1))
 				{
@@ -347,9 +347,9 @@ btScalar btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject*
 	btCollisionObject* colObj = m_isSwapped ? body1 : body0;
 	btCollisionObject* otherObj = m_isSwapped ? body0 : body1;
 
-	btAssert(colObj->getCollisionShape()->isCompound());
+	btAssert(colObj->m_collisionShape->isCompound());
 
-	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->getCollisionShape());
+	btCompoundShape* compoundShape = static_cast<btCompoundShape*>(colObj->m_collisionShape);
 
 	//We will use the OptimizedBVH, AABB tree to cull potential child-overlaps
 	//If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals
@@ -369,13 +369,13 @@ btScalar btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject*
 		//btCollisionShape* childShape = compoundShape->getChildShape(i);
 
 		//backup
-		orgTrans = colObj->getWorldTransform();
+		orgTrans = colObj->m_worldTransform;
 
 		const btTransform& childTrans = compoundShape->getChildTransform(i);
 		//btTransform	newChildWorldTrans = orgTrans*childTrans ;
 		colObj->setWorldTransform(orgTrans * childTrans);
 
-		//btCollisionShape* tmpShape = colObj->getCollisionShape();
+		//btCollisionShape* tmpShape = colObj->m_collisionShape;
 		//colObj->internalSetTemporaryCollisionShape( childShape );
 		frac = m_childCollisionAlgorithms[i]->calculateTimeOfImpact(colObj, otherObj, dispatchInfo, resultOut);
 		if (frac < hitFraction)

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp

@@ -36,15 +36,15 @@ btCompoundCompoundCollisionAlgorithm::btCompoundCompoundCollisionAlgorithm(const
 	m_childCollisionAlgorithmCache = new (ptr) btHashedSimplePairCache();
 
 	const btCollisionObjectWrapper* col0ObjWrap = body0Wrap;
-	btAssert(col0ObjWrap->getCollisionShape()->isCompound());
+	btAssert(col0ObjWrap->m_collisionShape->isCompound());
 
 	const btCollisionObjectWrapper* col1ObjWrap = body1Wrap;
-	btAssert(col1ObjWrap->getCollisionShape()->isCompound());
+	btAssert(col1ObjWrap->m_collisionShape->isCompound());
 
-	const btCompoundShape* compoundShape0 = static_cast<const btCompoundShape*>(col0ObjWrap->getCollisionShape());
+	const btCompoundShape* compoundShape0 = static_cast<const btCompoundShape*>(col0ObjWrap->m_collisionShape);
 	m_compoundShapeRevision0 = compoundShape0->getUpdateRevision();
 
-	const btCompoundShape* compoundShape1 = static_cast<const btCompoundShape*>(col1ObjWrap->getCollisionShape());
+	const btCompoundShape* compoundShape1 = static_cast<const btCompoundShape*>(col1ObjWrap->m_collisionShape);
 	m_compoundShapeRevision1 = compoundShape1->getUpdateRevision();
 }
 
@@ -122,21 +122,21 @@ struct btCompoundCompoundLeafCallback : btDbvt::ICollide
 		btAssert(childIndex0 >= 0);
 		btAssert(childIndex1 >= 0);
 
-		const btCompoundShape* compoundShape0 = static_cast<const btCompoundShape*>(m_compound0ColObjWrap->getCollisionShape());
+		const btCompoundShape* compoundShape0 = static_cast<const btCompoundShape*>(m_compound0ColObjWrap->m_collisionShape);
 		btAssert(childIndex0 < compoundShape0->getNumChildShapes());
 
-		const btCompoundShape* compoundShape1 = static_cast<const btCompoundShape*>(m_compound1ColObjWrap->getCollisionShape());
+		const btCompoundShape* compoundShape1 = static_cast<const btCompoundShape*>(m_compound1ColObjWrap->m_collisionShape);
 		btAssert(childIndex1 < compoundShape1->getNumChildShapes());
 
 		const btCollisionShape* childShape0 = compoundShape0->getChildShape(childIndex0);
 		const btCollisionShape* childShape1 = compoundShape1->getChildShape(childIndex1);
 
 		//backup
-		btTransform orgTrans0 = m_compound0ColObjWrap->getWorldTransform();
+		btTransform orgTrans0 = m_compound0ColObjWrap->m_worldTransform;
 		const btTransform& childTrans0 = compoundShape0->getChildTransform(childIndex0);
 		btTransform newChildWorldTrans0 = orgTrans0 * childTrans0;
 
-		btTransform orgTrans1 = m_compound1ColObjWrap->getWorldTransform();
+		btTransform orgTrans1 = m_compound1ColObjWrap->m_worldTransform;
 		const btTransform& childTrans1 = compoundShape1->getChildTransform(childIndex1);
 		btTransform newChildWorldTrans1 = orgTrans1 * childTrans1;
 
@@ -158,8 +158,8 @@ struct btCompoundCompoundLeafCallback : btDbvt::ICollide
 
 		if (TestAabbAgainstAabb2(aabbMin0, aabbMax0, aabbMin1, aabbMax1))
 		{
-			btCollisionObjectWrapper compoundWrap0(this->m_compound0ColObjWrap, childShape0, m_compound0ColObjWrap->getCollisionObject(), newChildWorldTrans0, -1, childIndex0);
-			btCollisionObjectWrapper compoundWrap1(this->m_compound1ColObjWrap, childShape1, m_compound1ColObjWrap->getCollisionObject(), newChildWorldTrans1, -1, childIndex1);
+			btCollisionObjectWrapper compoundWrap0(this->m_compound0ColObjWrap, childShape0, m_compound0ColObjWrap->m_collisionObject, newChildWorldTrans0, -1, childIndex0);
+			btCollisionObjectWrapper compoundWrap1(this->m_compound1ColObjWrap, childShape1, m_compound1ColObjWrap->m_collisionObject, newChildWorldTrans1, -1, childIndex1);
 
 			btSimplePair* pair = m_childCollisionAlgorithmCache->findPair(childIndex0, childIndex1);
 			bool removePair = false;
@@ -287,10 +287,10 @@ void btCompoundCompoundCollisionAlgorithm::processCollision(const btCollisionObj
 	const btCollisionObjectWrapper* col0ObjWrap = body0Wrap;
 	const btCollisionObjectWrapper* col1ObjWrap = body1Wrap;
 
-	btAssert(col0ObjWrap->getCollisionShape()->isCompound());
-	btAssert(col1ObjWrap->getCollisionShape()->isCompound());
-	const btCompoundShape* compoundShape0 = static_cast<const btCompoundShape*>(col0ObjWrap->getCollisionShape());
-	const btCompoundShape* compoundShape1 = static_cast<const btCompoundShape*>(col1ObjWrap->getCollisionShape());
+	btAssert(col0ObjWrap->m_collisionShape->isCompound());
+	btAssert(col1ObjWrap->m_collisionShape->isCompound());
+	const btCompoundShape* compoundShape0 = static_cast<const btCompoundShape*>(col0ObjWrap->m_collisionShape);
+	const btCompoundShape* compoundShape1 = static_cast<const btCompoundShape*>(col1ObjWrap->m_collisionShape);
 
 	const btDbvt* tree0 = compoundShape0->getDynamicAabbTree();
 	const btDbvt* tree1 = compoundShape1->getDynamicAabbTree();
@@ -341,7 +341,7 @@ void btCompoundCompoundCollisionAlgorithm::processCollision(const btCollisionObj
 
 	btCompoundCompoundLeafCallback callback(col0ObjWrap, col1ObjWrap, this->m_dispatcher, dispatchInfo, resultOut, this->m_childCollisionAlgorithmCache, m_sharedManifold);
 
-	const btTransform xform = col0ObjWrap->getWorldTransform().inverse() * col1ObjWrap->getWorldTransform();
+	const btTransform xform = col0ObjWrap->m_worldTransform.inverse() * col1ObjWrap->m_worldTransform;
 	MycollideTT(tree0->m_root, tree1->m_root, xform, &callback, resultOut->m_closestPointDistanceThreshold);
 
 	//printf("#compound-compound child/leaf overlap =%d                      \r",callback.m_numOverlapPairs);
@@ -371,7 +371,7 @@ void btCompoundCompoundCollisionAlgorithm::processCollision(const btCollisionObj
 					btTransform newChildWorldTrans0;
 					childShape0 = compoundShape0->getChildShape(pairs[i].m_indexA);
 					const btTransform& childTrans0 = compoundShape0->getChildTransform(pairs[i].m_indexA);
-					newChildWorldTrans0 = col0ObjWrap->getWorldTransform() * childTrans0;
+					newChildWorldTrans0 = col0ObjWrap->m_worldTransform * childTrans0;
 					childShape0->getAabb(newChildWorldTrans0, aabbMin0, aabbMax0);
 				}
 				btVector3 thresholdVec(resultOut->m_closestPointDistanceThreshold, resultOut->m_closestPointDistanceThreshold, resultOut->m_closestPointDistanceThreshold);
@@ -383,7 +383,7 @@ void btCompoundCompoundCollisionAlgorithm::processCollision(const btCollisionObj
 
 					childShape1 = compoundShape1->getChildShape(pairs[i].m_indexB);
 					const btTransform& childTrans1 = compoundShape1->getChildTransform(pairs[i].m_indexB);
-					newChildWorldTrans1 = col1ObjWrap->getWorldTransform() * childTrans1;
+					newChildWorldTrans1 = col1ObjWrap->m_worldTransform * childTrans1;
 					childShape1->getAabb(newChildWorldTrans1, aabbMin1, aabbMax1);
 				}
 

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp

@@ -88,7 +88,7 @@ void btConvex2dConvex2dAlgorithm ::processCollision(const btCollisionObjectWrapp
 	if (!m_manifoldPtr)
 	{
 		//swapped?
-		m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject());
+		m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->m_collisionObject, body1Wrap->m_collisionObject);
 		m_ownManifold = true;
 	}
 	resultOut->setPersistentManifold(m_manifoldPtr);
@@ -96,8 +96,8 @@ void btConvex2dConvex2dAlgorithm ::processCollision(const btCollisionObjectWrapp
 	//comment-out next line to test multi-contact generation
 	//resultOut->getPersistentManifold()->clearManifold();
 
-	const btConvexShape* min0 = static_cast<const btConvexShape*>(body0Wrap->getCollisionShape());
-	const btConvexShape* min1 = static_cast<const btConvexShape*>(body1Wrap->getCollisionShape());
+	const btConvexShape* min0 = static_cast<const btConvexShape*>(body0Wrap->m_collisionShape);
+	const btConvexShape* min1 = static_cast<const btConvexShape*>(body1Wrap->m_collisionShape);
 
 	btVector3 normalOnB;
 	btVector3 pointOnBWorld;
@@ -115,8 +115,8 @@ void btConvex2dConvex2dAlgorithm ::processCollision(const btCollisionObjectWrapp
 			input.m_maximumDistanceSquared *= input.m_maximumDistanceSquared;
 		}
 
-		input.m_transformA = body0Wrap->getWorldTransform();
-		input.m_transformB = body1Wrap->getWorldTransform();
+		input.m_transformA = body0Wrap->m_worldTransform;
+		input.m_transformB = body1Wrap->m_worldTransform;
 
 		gjkPairDetector.getClosestPoints(input, *resultOut, dispatchInfo.m_debugDraw);
 
@@ -140,8 +140,8 @@ btScalar btConvex2dConvex2dAlgorithm::calculateTimeOfImpact(btCollisionObject* c
 	///col0->m_worldTransform,
 	btScalar resultFraction = btScalar(1.);
 
-	btScalar squareMot0 = (col0->getInterpolationWorldTransform().m_origin - col0->getWorldTransform().m_origin).length2();
-	btScalar squareMot1 = (col1->getInterpolationWorldTransform().m_origin - col1->getWorldTransform().m_origin).length2();
+	btScalar squareMot0 = (col0->m_interpolationWorldTransform.m_origin - col0->m_worldTransform.m_origin).length2();
+	btScalar squareMot1 = (col1->m_interpolationWorldTransform.m_origin - col1->m_worldTransform.m_origin).length2();
 
 	if (squareMot0 < col0->getCcdSquareMotionThreshold() &&
 		squareMot1 < col1->getCcdSquareMotionThreshold())
@@ -155,25 +155,25 @@ btScalar btConvex2dConvex2dAlgorithm::calculateTimeOfImpact(btCollisionObject* c
 
 	/// Convex0 against sphere for Convex1
 	{
-		btConvexShape* convex0 = static_cast<btConvexShape*>(col0->getCollisionShape());
+		btConvexShape* convex0 = static_cast<btConvexShape*>(col0->m_collisionShape);
 
-		btSphereShape sphere1(col1->getCcdSweptSphereRadius());  //todo: allow non-zero sphere sizes, for better approximation
+		btSphereShape sphere1(col1->m_ccdSweptSphereRadius);  //todo: allow non-zero sphere sizes, for better approximation
 		btConvexCast::CastResult result;
 		btVoronoiSimplexSolver voronoiSimplex;
 		//SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex);
 		///Simplification, one object is simplified as a sphere
 		btGjkConvexCast ccd1(convex0, &sphere1, &voronoiSimplex);
 		//ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0);
-		if (ccd1.calcTimeOfImpact(col0->getWorldTransform(), col0->getInterpolationWorldTransform(),
-								  col1->getWorldTransform(), col1->getInterpolationWorldTransform(), result))
+		if (ccd1.calcTimeOfImpact(col0->m_worldTransform, col0->m_interpolationWorldTransform,
+								  col1->m_worldTransform, col1->m_interpolationWorldTransform, result))
 		{
 			//store result.m_fraction in both bodies
 
-			if (col0->getHitFraction() > result.m_fraction)
-				col0->setHitFraction(result.m_fraction);
+			if (col0->m_hitFraction > result.m_fraction)
+				col0->m_hitFraction = (result.m_fraction);
 
-			if (col1->getHitFraction() > result.m_fraction)
-				col1->setHitFraction(result.m_fraction);
+			if (col1->m_hitFraction > result.m_fraction)
+				col1->m_hitFraction = (result.m_fraction);
 
 			if (resultFraction > result.m_fraction)
 				resultFraction = result.m_fraction;
@@ -182,25 +182,25 @@ btScalar btConvex2dConvex2dAlgorithm::calculateTimeOfImpact(btCollisionObject* c
 
 	/// Sphere (for convex0) against Convex1
 	{
-		btConvexShape* convex1 = static_cast<btConvexShape*>(col1->getCollisionShape());
+		btConvexShape* convex1 = static_cast<btConvexShape*>(col1->m_collisionShape);
 
-		btSphereShape sphere0(col0->getCcdSweptSphereRadius());  //todo: allow non-zero sphere sizes, for better approximation
+		btSphereShape sphere0(col0->m_ccdSweptSphereRadius);  //todo: allow non-zero sphere sizes, for better approximation
 		btConvexCast::CastResult result;
 		btVoronoiSimplexSolver voronoiSimplex;
 		//SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex);
 		///Simplification, one object is simplified as a sphere
 		btGjkConvexCast ccd1(&sphere0, convex1, &voronoiSimplex);
 		//ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0);
-		if (ccd1.calcTimeOfImpact(col0->getWorldTransform(), col0->getInterpolationWorldTransform(),
-								  col1->getWorldTransform(), col1->getInterpolationWorldTransform(), result))
+		if (ccd1.calcTimeOfImpact(col0->m_worldTransform, col0->m_interpolationWorldTransform,
+								  col1->m_worldTransform, col1->m_interpolationWorldTransform, result))
 		{
 			//store result.m_fraction in both bodies
 
-			if (col0->getHitFraction() > result.m_fraction)
-				col0->setHitFraction(result.m_fraction);
+			if (col0->m_hitFraction > result.m_fraction)
+				col0->m_hitFraction = (result.m_fraction);
 
-			if (col1->getHitFraction() > result.m_fraction)
-				col1->setHitFraction(result.m_fraction);
+			if (col1->m_hitFraction > result.m_fraction)
+				col1->m_hitFraction = (result.m_fraction);
 
 			if (resultFraction > result.m_fraction)
 				resultFraction = result.m_fraction;

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp

@@ -56,7 +56,7 @@ btConvexTriangleCallback::btConvexTriangleCallback(btDispatcher* dispatcher, con
 	//
 	// create the manifold from the dispatcher 'manifold pool'
 	//
-	m_manifoldPtr = m_dispatcher->getNewManifold(m_convexBodyWrap->getCollisionObject(), m_triBodyWrap->getCollisionObject());
+	m_manifoldPtr = m_dispatcher->getNewManifold(m_convexBodyWrap->m_collisionObject, m_triBodyWrap->m_collisionObject);
 
 	clearCache();
 }
@@ -92,33 +92,33 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle, int partId,
 	///debug drawing of the overlapping triangles
 	if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && (m_dispatchInfoPtr->m_debugDraw->getDebugMode() &btIDebugDraw::DBG_DrawWireframe ))
 	{
-		const btCollisionObject* ob = const_cast<btCollisionObject*>(m_triBodyWrap->getCollisionObject());
+		const btCollisionObject* ob = const_cast<btCollisionObject*>(m_triBodyWrap->m_collisionObject);
 		btVector3 color(1,1,0);
-		btTransform& tr = ob->getWorldTransform();
+		btTransform& tr = ob->m_worldTransform;
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(triangle[1]),color);
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(triangle[2]),color);
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(triangle[0]),color);
 	}
 #endif
 
-	if (m_convexBodyWrap->getCollisionShape()->isConvex())
+	if (m_convexBodyWrap->m_collisionShape->isConvex())
 	{
 #ifdef BT_ENABLE_CONVEX_CONCAVE_EARLY_OUT
     //todo: check this issue https://github.com/bulletphysics/bullet3/issues/4263
 		//an early out optimisation if the object is separated from the triangle
 		//projected on the triangle normal)
 		{
-			const btVector3 v0 = m_triBodyWrap->getWorldTransform()*triangle[0];
-			const btVector3 v1 = m_triBodyWrap->getWorldTransform()*triangle[1];
-			const btVector3 v2 = m_triBodyWrap->getWorldTransform()*triangle[2];
+			const btVector3 v0 = m_triBodyWrap->m_worldTransform*triangle[0];
+			const btVector3 v1 = m_triBodyWrap->m_worldTransform*triangle[1];
+			const btVector3 v2 = m_triBodyWrap->m_worldTransform*triangle[2];
 
 			btVector3 triangle_normal_world = ( v1 - v0).cross(v2 - v0);
 			triangle_normal_world.normalize();
 
-		    btConvexShape* convex = (btConvexShape*)m_convexBodyWrap->getCollisionShape();
+		    btConvexShape* convex = (btConvexShape*)m_convexBodyWrap->m_collisionShape;
 
-			btVector3 localPt = convex->localGetSupportingVertex(m_convexBodyWrap->getWorldTransform().m_basis.inverse()*triangle_normal_world);
-			btVector3 worldPt = m_convexBodyWrap->getWorldTransform()*localPt;
+			btVector3 localPt = convex->localGetSupportingVertex(m_convexBodyWrap->m_worldTransform.m_basis.inverse()*triangle_normal_world);
+			btVector3 worldPt = m_convexBodyWrap->m_worldTransform*localPt;
 			//now check if this is fully on one side of the triangle
 			btScalar proj_distPt = triangle_normal_world.dot(worldPt);
 			btScalar proj_distTr = triangle_normal_world.dot(v0);
@@ -130,8 +130,8 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle, int partId,
 			//also check the other side of the triangle
 			triangle_normal_world*=-1;
 
-			localPt = convex->localGetSupportingVertex(m_convexBodyWrap->getWorldTransform().m_basis.inverse()*triangle_normal_world);
-			worldPt = m_convexBodyWrap->getWorldTransform()*localPt;
+			localPt = convex->localGetSupportingVertex(m_convexBodyWrap->m_worldTransform.m_basis.inverse()*triangle_normal_world);
+			worldPt = m_convexBodyWrap->m_worldTransform*localPt;
 			//now check if this is fully on one side of the triangle
 			proj_distPt = triangle_normal_world.dot(worldPt);
 			proj_distTr = triangle_normal_world.dot(v0);
@@ -145,7 +145,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle, int partId,
 		btTriangleShape tm(triangle[0], triangle[1], triangle[2]);
 		tm.setMargin(m_collisionMarginTriangle);
 
-		btCollisionObjectWrapper triObWrap(m_triBodyWrap, &tm, m_triBodyWrap->getCollisionObject(), m_triBodyWrap->getWorldTransform(), partId, triangleIndex);  //correct transform?
+		btCollisionObjectWrapper triObWrap(m_triBodyWrap, &tm, m_triBodyWrap->m_collisionObject, m_triBodyWrap->m_worldTransform, partId, triangleIndex);  //correct transform?
 		btCollisionAlgorithm* colAlgo = 0;
 
 		if (m_resultOut->m_closestPointDistanceThreshold > 0)
@@ -158,7 +158,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle, int partId,
 		}
 		const btCollisionObjectWrapper* tmpWrap = 0;
 
-		if (m_resultOut->getBody0Internal() == m_triBodyWrap->getCollisionObject())
+		if (m_resultOut->getBody0Internal() == m_triBodyWrap->m_collisionObject)
 		{
 			tmpWrap = m_resultOut->getBody0Wrap();
 			m_resultOut->setBody0Wrap(&triObWrap);
@@ -176,7 +176,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle, int partId,
 			colAlgo->processCollision(m_convexBodyWrap, &triObWrap, *m_dispatchInfoPtr, m_resultOut);
 		}
 
-		if (m_resultOut->getBody0Internal() == m_triBodyWrap->getCollisionObject())
+		if (m_resultOut->getBody0Internal() == m_triBodyWrap->m_collisionObject)
 		{
 			m_resultOut->setBody0Wrap(tmpWrap);
 		}
@@ -201,8 +201,8 @@ void btConvexTriangleCallback::setTimeStepAndCounters(btScalar collisionMarginTr
 
 	//recalc aabbs
 	btTransform convexInTriangleSpace;
-	convexInTriangleSpace = m_triBodyWrap->getWorldTransform().inverse() * m_convexBodyWrap->getWorldTransform();
-	const btCollisionShape* convexShape = static_cast<const btCollisionShape*>(m_convexBodyWrap->getCollisionShape());
+	convexInTriangleSpace = m_triBodyWrap->m_worldTransform.inverse() * m_convexBodyWrap->m_worldTransform;
+	const btCollisionShape* convexShape = static_cast<const btCollisionShape*>(m_convexBodyWrap->m_collisionShape);
 	//CollisionShape* triangleShape = static_cast<btCollisionShape*>(triBody->m_collisionShape);
 	convexShape->getAabb(convexInTriangleSpace, m_aabbMin, m_aabbMax);
 	btScalar extraMargin = collisionMarginTriangle + resultOut->m_closestPointDistanceThreshold;
@@ -225,14 +225,14 @@ void btConvexConcaveCollisionAlgorithm::processCollision(const btCollisionObject
 	const btCollisionObjectWrapper* convexBodyWrap = m_isSwapped ? body1Wrap : body0Wrap;
 	const btCollisionObjectWrapper* triBodyWrap = m_isSwapped ? body0Wrap : body1Wrap;
 
-	if (triBodyWrap->getCollisionShape()->isConcave())
+	if (triBodyWrap->m_collisionShape->isConcave())
 	{
-		if (triBodyWrap->getCollisionShape()->getShapeType() == SDF_SHAPE_PROXYTYPE)
+		if (triBodyWrap->m_collisionShape->getShapeType() == SDF_SHAPE_PROXYTYPE)
 		{
-			btSdfCollisionShape* sdfShape = (btSdfCollisionShape*)triBodyWrap->getCollisionShape();
-			if (convexBodyWrap->getCollisionShape()->isConvex())
+			btSdfCollisionShape* sdfShape = (btSdfCollisionShape*)triBodyWrap->m_collisionShape;
+			if (convexBodyWrap->m_collisionShape->isConvex())
 			{
-				btConvexShape* convex = (btConvexShape*)convexBodyWrap->getCollisionShape();
+				btConvexShape* convex = (btConvexShape*)convexBodyWrap->m_collisionShape;
 				btAlignedObjectArray<btVector3> queryVertices;
 
 				if (convex->isPolyhedral())
@@ -262,8 +262,8 @@ void btConvexConcaveCollisionAlgorithm::processCollision(const btCollisionObject
 					for (int v = 0; v < queryVertices.size(); v++)
 					{
 						const btVector3& vtx = queryVertices[v];
-						btVector3 vtxWorldSpace = convexBodyWrap->getWorldTransform() * vtx;
-						btVector3 vtxInSdf = triBodyWrap->getWorldTransform().invXform(vtxWorldSpace);
+						btVector3 vtxWorldSpace = convexBodyWrap->m_worldTransform * vtx;
+						btVector3 vtxInSdf = triBodyWrap->m_worldTransform.invXform(vtxWorldSpace);
 
 						btVector3 normalLocal;
 						btScalar dist;
@@ -272,7 +272,7 @@ void btConvexConcaveCollisionAlgorithm::processCollision(const btCollisionObject
 							if (dist <= maxDist)
 							{
 								normalLocal.safeNormalize();
-								btVector3 normal = triBodyWrap->getWorldTransform().m_basis * normalLocal;
+								btVector3 normal = triBodyWrap->m_worldTransform.m_basis * normalLocal;
 
 								if (convex->getShapeType() == SPHERE_SHAPE_PROXYTYPE)
 								{
@@ -290,16 +290,16 @@ void btConvexConcaveCollisionAlgorithm::processCollision(const btCollisionObject
 		}
 		else
 		{
-			const btConcaveShape* concaveShape = static_cast<const btConcaveShape*>(triBodyWrap->getCollisionShape());
+			const btConcaveShape* concaveShape = static_cast<const btConcaveShape*>(triBodyWrap->m_collisionShape);
 
-			if (convexBodyWrap->getCollisionShape()->isConvex())
+			if (convexBodyWrap->m_collisionShape->isConvex())
 			{
 				btScalar collisionMarginTriangle = concaveShape->getMargin();
 
 				resultOut->setPersistentManifold(m_btConvexTriangleCallback.m_manifoldPtr);
 				m_btConvexTriangleCallback.setTimeStepAndCounters(collisionMarginTriangle, dispatchInfo, convexBodyWrap, triBodyWrap, resultOut);
 
-				m_btConvexTriangleCallback.m_manifoldPtr->setBodies(convexBodyWrap->getCollisionObject(), triBodyWrap->getCollisionObject());
+				m_btConvexTriangleCallback.m_manifoldPtr->setBodies(convexBodyWrap->m_collisionObject, triBodyWrap->m_collisionObject);
 
 				concaveShape->processAllTriangles(&m_btConvexTriangleCallback, m_btConvexTriangleCallback.getAabbMin(), m_btConvexTriangleCallback.getAabbMax());
 
@@ -322,7 +322,7 @@ btScalar btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObj
 
 	//only perform CCD above a certain threshold, this prevents blocking on the long run
 	//because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame...
-	btScalar squareMot0 = (convexbody->getInterpolationWorldTransform().m_origin - convexbody->getWorldTransform().m_origin).length2();
+	btScalar squareMot0 = (convexbody->m_interpolationWorldTransform.m_origin - convexbody->m_worldTransform.m_origin).length2();
 	if (squareMot0 < convexbody->getCcdSquareMotionThreshold())
 	{
 		return btScalar(1.);
@@ -332,9 +332,9 @@ btScalar btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObj
 	//btVector3 to = convexbody->m_interpolationWorldTransform.m_origin;
 	//todo: only do if the motion exceeds the 'radius'
 
-	btTransform triInv = triBody->getWorldTransform().inverse();
-	btTransform convexFromLocal = triInv * convexbody->getWorldTransform();
-	btTransform convexToLocal = triInv * convexbody->getInterpolationWorldTransform();
+	btTransform triInv = triBody->m_worldTransform.inverse();
+	btTransform convexFromLocal = triInv * convexbody->m_worldTransform;
+	btTransform convexToLocal = triInv * convexbody->m_interpolationWorldTransform;
 
 	struct LocalTriangleSphereCastCallback : public btTriangleCallback
 	{
@@ -380,34 +380,34 @@ btScalar btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObj
 		}
 	};
 
-	if (triBody->getCollisionShape()->isConcave())
+	if (triBody->m_collisionShape->isConcave())
 	{
 		btVector3 rayAabbMin = convexFromLocal.m_origin;
 		rayAabbMin.setMin(convexToLocal.m_origin);
 		btVector3 rayAabbMax = convexFromLocal.m_origin;
 		rayAabbMax.setMax(convexToLocal.m_origin);
-		btScalar ccdRadius0 = convexbody->getCcdSweptSphereRadius();
+		btScalar ccdRadius0 = convexbody->m_ccdSweptSphereRadius;
 		rayAabbMin -= btVector3(ccdRadius0, ccdRadius0, ccdRadius0);
 		rayAabbMax += btVector3(ccdRadius0, ccdRadius0, ccdRadius0);
 
 		btScalar curHitFraction = btScalar(1.);  //is this available?
 		LocalTriangleSphereCastCallback raycastCallback(convexFromLocal, convexToLocal,
-														convexbody->getCcdSweptSphereRadius(), curHitFraction);
+														convexbody->m_ccdSweptSphereRadius, curHitFraction);
 
-		raycastCallback.m_hitFraction = convexbody->getHitFraction();
+		raycastCallback.m_hitFraction = convexbody->m_hitFraction;
 
 		btCollisionObject* concavebody = triBody;
 
-		btConcaveShape* triangleMesh = (btConcaveShape*)concavebody->getCollisionShape();
+		btConcaveShape* triangleMesh = (btConcaveShape*)concavebody->m_collisionShape;
 
 		if (triangleMesh)
 		{
 			triangleMesh->processAllTriangles(&raycastCallback, rayAabbMin, rayAabbMax);
 		}
 
-		if (raycastCallback.m_hitFraction < convexbody->getHitFraction())
+		if (raycastCallback.m_hitFraction < convexbody->m_hitFraction)
 		{
-			convexbody->setHitFraction(raycastCallback.m_hitFraction);
+			convexbody->m_hitFraction = (raycastCallback.m_hitFraction);
 			return raycastCallback.m_hitFraction;
 		}
 	}

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

@@ -188,8 +188,8 @@ btConvexConvexAlgorithm::btConvexConvexAlgorithm(btPersistentManifold* mf, const
 	  m_manifoldPtr(mf),
 	  m_lowLevelOfDetail(false),
 #ifdef USE_SEPDISTANCE_UTIL2
-	  m_sepDistance((static_cast<btConvexShape*>(body0->getCollisionShape()))->getAngularMotionDisc(),
-					(static_cast<btConvexShape*>(body1->getCollisionShape()))->getAngularMotionDisc()),
+	  m_sepDistance((static_cast<btConvexShape*>(body0->m_collisionShape))->getAngularMotionDisc(),
+					(static_cast<btConvexShape*>(body1->m_collisionShape))->getAngularMotionDisc()),
 #endif
 	  m_numPerturbationIterations(numPerturbationIterations),
 	  m_minimumPointsPerturbationThreshold(minimumPointsPerturbationThreshold)
@@ -275,7 +275,7 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 	if (!m_manifoldPtr)
 	{
 		//swapped?
-		m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject());
+		m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->m_collisionObject, body1Wrap->m_collisionObject);
 		m_ownManifold = true;
 	}
 	resultOut->setPersistentManifold(m_manifoldPtr);
@@ -283,8 +283,8 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 	//comment-out next line to test multi-contact generation
 	//resultOut->getPersistentManifold()->clearManifold();
 
-	const btConvexShape* min0 = static_cast<const btConvexShape*>(body0Wrap->getCollisionShape());
-	const btConvexShape* min1 = static_cast<const btConvexShape*>(body1Wrap->getCollisionShape());
+	const btConvexShape* min0 = static_cast<const btConvexShape*>(body0Wrap->m_collisionShape);
+	const btConvexShape* min1 = static_cast<const btConvexShape*>(body1Wrap->m_collisionShape);
 
 	btVector3 normalOnB;
 	btVector3 pointOnBWorld;
@@ -300,7 +300,7 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 
 		btScalar dist = capsuleCapsuleDistance(normalOnB, pointOnBWorld, capsuleA->getHalfHeight(), capsuleA->getRadius(),
 											   capsuleB->getHalfHeight(), capsuleB->getRadius(), capsuleA->getUpAxis(), capsuleB->getUpAxis(),
-											   body0Wrap->getWorldTransform(), body1Wrap->getWorldTransform(), threshold);
+											   body0Wrap->m_worldTransform, body1Wrap->m_worldTransform, threshold);
 
 		if (dist < threshold)
 		{
@@ -322,7 +322,7 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 
 		btScalar dist = capsuleCapsuleDistance(normalOnB, pointOnBWorld, capsuleA->getHalfHeight(), capsuleA->getRadius(),
 											   0., capsuleB->getRadius(), capsuleA->getUpAxis(), 1,
-											   body0Wrap->getWorldTransform(), body1Wrap->getWorldTransform(), threshold);
+											   body0Wrap->m_worldTransform, body1Wrap->m_worldTransform, threshold);
 
 		if (dist < threshold)
 		{
@@ -344,7 +344,7 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 
 		btScalar dist = capsuleCapsuleDistance(normalOnB, pointOnBWorld, 0., capsuleA->getRadius(),
 											   capsuleB->getHalfHeight(), capsuleB->getRadius(), 1, capsuleB->getUpAxis(),
-											   body0Wrap->getWorldTransform(), body1Wrap->getWorldTransform(), threshold);
+											   body0Wrap->m_worldTransform, body1Wrap->m_worldTransform, threshold);
 
 		if (dist < threshold)
 		{
@@ -359,7 +359,7 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 #ifdef USE_SEPDISTANCE_UTIL2
 	if (dispatchInfo.m_useConvexConservativeDistanceUtil)
 	{
-		m_sepDistance.updateSeparatingDistance(body0->getWorldTransform(), body1->getWorldTransform());
+		m_sepDistance.updateSeparatingDistance(body0->m_worldTransform, body1->m_worldTransform);
 	}
 
 	if (!dispatchInfo.m_useConvexConservativeDistanceUtil || m_sepDistance.getConservativeSeparatingDistance() <= 0.f)
@@ -383,7 +383,7 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 		{
 			//if (dispatchInfo.m_convexMaxDistanceUseCPT)
 			//{
-			//	input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactProcessingThreshold();
+			//	input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->m_contactProcessingThreshold;
 			//} else
 			//{
 			input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactBreakingThreshold() + resultOut->m_closestPointDistanceThreshold;
@@ -392,8 +392,8 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 			input.m_maximumDistanceSquared *= input.m_maximumDistanceSquared;
 		}
 
-		input.m_transformA = body0Wrap->getWorldTransform();
-		input.m_transformB = body1Wrap->getWorldTransform();
+		input.m_transformA = body0Wrap->m_worldTransform;
+		input.m_transformB = body1Wrap->m_worldTransform;
 
 #ifdef USE_SEPDISTANCE_UTIL2
 		btScalar sepDist = 0.f;
@@ -490,8 +490,8 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 				{
 					foundSepAxis = btPolyhedralContactClipping::findSeparatingAxis(
 						*polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(),
-						body0Wrap->getWorldTransform(),
-						body1Wrap->getWorldTransform(),
+						body0Wrap->m_worldTransform,
+						body1Wrap->m_worldTransform,
 						sepNormalWorldSpace, *resultOut);
 				}
 				else
@@ -524,8 +524,8 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 
 					worldVertsB1.resize(0);
 					btPolyhedralContactClipping::clipHullAgainstHull(sepNormalWorldSpace, *polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(),
-																	 body0Wrap->getWorldTransform(),
-																	 body1Wrap->getWorldTransform(), minDist - threshold, threshold, worldVertsB1, worldVertsB2,
+																	 body0Wrap->m_worldTransform,
+																	 body1Wrap->m_worldTransform, minDist - threshold, threshold, worldVertsB1, worldVertsB2,
 																	 *resultOut);
 				}
 				if (m_ownManifold)
@@ -541,9 +541,9 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 				{
 					btVertexArray worldSpaceVertices;
 					btTriangleShape* tri = (btTriangleShape*)polyhedronB;
-					worldSpaceVertices.push_back(body1Wrap->getWorldTransform() * tri->m_vertices1[0]);
-					worldSpaceVertices.push_back(body1Wrap->getWorldTransform() * tri->m_vertices1[1]);
-					worldSpaceVertices.push_back(body1Wrap->getWorldTransform() * tri->m_vertices1[2]);
+					worldSpaceVertices.push_back(body1Wrap->m_worldTransform * tri->m_vertices1[0]);
+					worldSpaceVertices.push_back(body1Wrap->m_worldTransform * tri->m_vertices1[1]);
+					worldSpaceVertices.push_back(body1Wrap->m_worldTransform * tri->m_vertices1[2]);
 
 					//tri->initializePolyhedralFeatures();
 
@@ -635,8 +635,8 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 
 						foundSepAxis = btPolyhedralContactClipping::findSeparatingAxis(
 							*polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(),
-							body0Wrap->getWorldTransform(),
-							body1Wrap->getWorldTransform(),
+							body0Wrap->m_worldTransform,
+							body1Wrap->m_worldTransform,
 							sepNormalWorldSpace, *resultOut);
 						//	 printf("sepNormalWorldSpace=%f,%f,%f\n",sepNormalWorldSpace.m_floats[0],sepNormalWorldSpace.m_floats[1],sepNormalWorldSpace.m_floats[2]);
 					}
@@ -683,7 +683,7 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 					{
 						worldVertsB2.resize(0);
 						btPolyhedralContactClipping::clipFaceAgainstHull(sepNormalWorldSpace, *polyhedronA->getConvexPolyhedron(),
-																		 body0Wrap->getWorldTransform(), worldSpaceVertices, worldVertsB2, minDist - threshold, maxDist, *resultOut);
+																		 body0Wrap->m_worldTransform, worldSpaceVertices, worldVertsB2, minDist - threshold, maxDist, *resultOut);
 					}
 
 					if (m_ownManifold)
@@ -752,16 +752,16 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 
 						if (perturbeA)
 						{
-							input.m_transformA.m_basis = btMatrix3x3(rotq.inverse() * perturbeRot * rotq) * body0Wrap->getWorldTransform().m_basis;
-							input.m_transformB = body1Wrap->getWorldTransform();
+							input.m_transformA.m_basis = btMatrix3x3(rotq.inverse() * perturbeRot * rotq) * body0Wrap->m_worldTransform.m_basis;
+							input.m_transformB = body1Wrap->m_worldTransform;
 #ifdef DEBUG_CONTACTS
 							dispatchInfo.m_debugDraw->drawTransform(input.m_transformA, 10.0);
 #endif  //DEBUG_CONTACTS
 						}
 						else
 						{
-							input.m_transformA = body0Wrap->getWorldTransform();
-							input.m_transformB.m_basis = btMatrix3x3(rotq.inverse() * perturbeRot * rotq) * body1Wrap->getWorldTransform().m_basis;
+							input.m_transformA = body0Wrap->m_worldTransform;
+							input.m_transformB.m_basis = btMatrix3x3(rotq.inverse() * perturbeRot * rotq) * body1Wrap->m_worldTransform.m_basis;
 #ifdef DEBUG_CONTACTS
 							dispatchInfo.m_debugDraw->drawTransform(input.m_transformB, 10.0);
 #endif
@@ -777,7 +777,7 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 #ifdef USE_SEPDISTANCE_UTIL2
 		if (dispatchInfo.m_useConvexConservativeDistanceUtil && (sepDist > SIMD_EPSILON))
 		{
-			m_sepDistance.initSeparatingDistance(gjkPairDetector.getCachedSeparatingAxis(), sepDist, body0->getWorldTransform(), body1->getWorldTransform());
+			m_sepDistance.initSeparatingDistance(gjkPairDetector.getCachedSeparatingAxis(), sepDist, body0->m_worldTransform, body1->m_worldTransform);
 		}
 #endif  //USE_SEPDISTANCE_UTIL2
 	}
@@ -799,8 +799,8 @@ btScalar btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,
 	///col0->m_worldTransform,
 	btScalar resultFraction = btScalar(1.);
 
-	btScalar squareMot0 = (col0->getInterpolationWorldTransform().m_origin - col0->getWorldTransform().m_origin).length2();
-	btScalar squareMot1 = (col1->getInterpolationWorldTransform().m_origin - col1->getWorldTransform().m_origin).length2();
+	btScalar squareMot0 = (col0->m_interpolationWorldTransform.m_origin - col0->m_worldTransform.m_origin).length2();
+	btScalar squareMot1 = (col1->m_interpolationWorldTransform.m_origin - col1->m_worldTransform.m_origin).length2();
 
 	if (squareMot0 < col0->getCcdSquareMotionThreshold() &&
 		squareMot1 < col1->getCcdSquareMotionThreshold())
@@ -817,25 +817,25 @@ btScalar btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,
 
 	/// Convex0 against sphere for Convex1
 	{
-		btConvexShape* convex0 = static_cast<btConvexShape*>(col0->getCollisionShape());
+		btConvexShape* convex0 = static_cast<btConvexShape*>(col0->m_collisionShape);
 
-		btSphereShape sphere1(col1->getCcdSweptSphereRadius());  //todo: allow non-zero sphere sizes, for better approximation
+		btSphereShape sphere1(col1->m_ccdSweptSphereRadius);  //todo: allow non-zero sphere sizes, for better approximation
 		btConvexCast::CastResult result;
 		btVoronoiSimplexSolver voronoiSimplex;
 		//SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex);
 		///Simplification, one object is simplified as a sphere
 		btGjkConvexCast ccd1(convex0, &sphere1, &voronoiSimplex);
 		//ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0);
-		if (ccd1.calcTimeOfImpact(col0->getWorldTransform(), col0->getInterpolationWorldTransform(),
-								  col1->getWorldTransform(), col1->getInterpolationWorldTransform(), result))
+		if (ccd1.calcTimeOfImpact(col0->m_worldTransform, col0->m_interpolationWorldTransform,
+								  col1->m_worldTransform, col1->m_interpolationWorldTransform, result))
 		{
 			//store result.m_fraction in both bodies
 
-			if (col0->getHitFraction() > result.m_fraction)
-				col0->setHitFraction(result.m_fraction);
+			if (col0->m_hitFraction > result.m_fraction)
+				col0->m_hitFraction = (result.m_fraction);
 
-			if (col1->getHitFraction() > result.m_fraction)
-				col1->setHitFraction(result.m_fraction);
+			if (col1->m_hitFraction > result.m_fraction)
+				col1->m_hitFraction = (result.m_fraction);
 
 			if (resultFraction > result.m_fraction)
 				resultFraction = result.m_fraction;
@@ -844,25 +844,25 @@ btScalar btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,
 
 	/// Sphere (for convex0) against Convex1
 	{
-		btConvexShape* convex1 = static_cast<btConvexShape*>(col1->getCollisionShape());
+		btConvexShape* convex1 = static_cast<btConvexShape*>(col1->m_collisionShape);
 
-		btSphereShape sphere0(col0->getCcdSweptSphereRadius());  //todo: allow non-zero sphere sizes, for better approximation
+		btSphereShape sphere0(col0->m_ccdSweptSphereRadius);  //todo: allow non-zero sphere sizes, for better approximation
 		btConvexCast::CastResult result;
 		btVoronoiSimplexSolver voronoiSimplex;
 		//SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex);
 		///Simplification, one object is simplified as a sphere
 		btGjkConvexCast ccd1(&sphere0, convex1, &voronoiSimplex);
 		//ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0);
-		if (ccd1.calcTimeOfImpact(col0->getWorldTransform(), col0->getInterpolationWorldTransform(),
-								  col1->getWorldTransform(), col1->getInterpolationWorldTransform(), result))
+		if (ccd1.calcTimeOfImpact(col0->m_worldTransform, col0->m_interpolationWorldTransform,
+								  col1->m_worldTransform, col1->m_interpolationWorldTransform, result))
 		{
 			//store result.m_fraction in both bodies
 
-			if (col0->getHitFraction() > result.m_fraction)
-				col0->setHitFraction(result.m_fraction);
+			if (col0->m_hitFraction > result.m_fraction)
+				col0->m_hitFraction = (result.m_fraction);
 
-			if (col1->getHitFraction() > result.m_fraction)
-				col1->setHitFraction(result.m_fraction);
+			if (col1->m_hitFraction > result.m_fraction)
+				col1->m_hitFraction = (result.m_fraction);
 
 			if (resultFraction > result.m_fraction)
 				resultFraction = result.m_fraction;

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp

@@ -34,9 +34,9 @@ btConvexPlaneCollisionAlgorithm::btConvexPlaneCollisionAlgorithm(btPersistentMan
 	const btCollisionObjectWrapper* convexObjWrap = m_isSwapped ? col1Wrap : col0Wrap;
 	const btCollisionObjectWrapper* planeObjWrap = m_isSwapped ? col0Wrap : col1Wrap;
 
-	if (!m_manifoldPtr && m_dispatcher->needsCollision(convexObjWrap->getCollisionObject(), planeObjWrap->getCollisionObject()))
+	if (!m_manifoldPtr && m_dispatcher->needsCollision(convexObjWrap->m_collisionObject, planeObjWrap->m_collisionObject))
 	{
-		m_manifoldPtr = m_dispatcher->getNewManifold(convexObjWrap->getCollisionObject(), planeObjWrap->getCollisionObject());
+		m_manifoldPtr = m_dispatcher->getNewManifold(convexObjWrap->m_collisionObject, planeObjWrap->m_collisionObject);
 		m_ownManifold = true;
 	}
 }
@@ -55,20 +55,20 @@ void btConvexPlaneCollisionAlgorithm::collideSingleContact(const btQuaternion& p
 	const btCollisionObjectWrapper* convexObjWrap = m_isSwapped ? body1Wrap : body0Wrap;
 	const btCollisionObjectWrapper* planeObjWrap = m_isSwapped ? body0Wrap : body1Wrap;
 
-	btConvexShape* convexShape = (btConvexShape*)convexObjWrap->getCollisionShape();
-	btStaticPlaneShape* planeShape = (btStaticPlaneShape*)planeObjWrap->getCollisionShape();
+	btConvexShape* convexShape = (btConvexShape*)convexObjWrap->m_collisionShape;
+	btStaticPlaneShape* planeShape = (btStaticPlaneShape*)planeObjWrap->m_collisionShape;
 
 	bool hasCollision = false;
 	const btVector3& planeNormal = planeShape->getPlaneNormal();
 	const btScalar& planeConstant = planeShape->getPlaneConstant();
 
-	btTransform convexWorldTransform = convexObjWrap->getWorldTransform();
+	btTransform convexWorldTransform = convexObjWrap->m_worldTransform;
 	btTransform convexInPlaneTrans;
-	convexInPlaneTrans = planeObjWrap->getWorldTransform().inverse() * convexWorldTransform;
+	convexInPlaneTrans = planeObjWrap->m_worldTransform.inverse() * convexWorldTransform;
 	//now perturbe the convex-world transform
 	convexWorldTransform.m_basis *= btMatrix3x3(perturbeRot);
 	btTransform planeInConvex;
-	planeInConvex = convexWorldTransform.inverse() * planeObjWrap->getWorldTransform();
+	planeInConvex = convexWorldTransform.inverse() * planeObjWrap->m_worldTransform;
 
 	btVector3 vtx = convexShape->localGetSupportingVertex(planeInConvex.m_basis * -planeNormal);
 
@@ -76,14 +76,14 @@ void btConvexPlaneCollisionAlgorithm::collideSingleContact(const btQuaternion& p
 	btScalar distance = (planeNormal.dot(vtxInPlane) - planeConstant);
 
 	btVector3 vtxInPlaneProjected = vtxInPlane - distance * planeNormal;
-	btVector3 vtxInPlaneWorld = planeObjWrap->getWorldTransform() * vtxInPlaneProjected;
+	btVector3 vtxInPlaneWorld = planeObjWrap->m_worldTransform * vtxInPlaneProjected;
 
 	hasCollision = distance < m_manifoldPtr->getContactBreakingThreshold();
 	resultOut->setPersistentManifold(m_manifoldPtr);
 	if (hasCollision)
 	{
 		/// report a contact. internally this will be kept persistent, and contact reduction is done
-		btVector3 normalOnSurfaceB = planeObjWrap->getWorldTransform().m_basis * planeNormal;
+		btVector3 normalOnSurfaceB = planeObjWrap->m_worldTransform.m_basis * planeNormal;
 		btVector3 pOnB = vtxInPlaneWorld;
 		resultOut->addContactPoint(normalOnSurfaceB, pOnB, distance);
 	}
@@ -98,30 +98,30 @@ void btConvexPlaneCollisionAlgorithm::processCollision(const btCollisionObjectWr
 	const btCollisionObjectWrapper* convexObjWrap = m_isSwapped ? body1Wrap : body0Wrap;
 	const btCollisionObjectWrapper* planeObjWrap = m_isSwapped ? body0Wrap : body1Wrap;
 
-	btConvexShape* convexShape = (btConvexShape*)convexObjWrap->getCollisionShape();
-	btStaticPlaneShape* planeShape = (btStaticPlaneShape*)planeObjWrap->getCollisionShape();
+	btConvexShape* convexShape = (btConvexShape*)convexObjWrap->m_collisionShape;
+	btStaticPlaneShape* planeShape = (btStaticPlaneShape*)planeObjWrap->m_collisionShape;
 
 	bool hasCollision = false;
 	const btVector3& planeNormal = planeShape->getPlaneNormal();
 	const btScalar& planeConstant = planeShape->getPlaneConstant();
 	btTransform planeInConvex;
-	planeInConvex = convexObjWrap->getWorldTransform().inverse() * planeObjWrap->getWorldTransform();
+	planeInConvex = convexObjWrap->m_worldTransform.inverse() * planeObjWrap->m_worldTransform;
 	btTransform convexInPlaneTrans;
-	convexInPlaneTrans = planeObjWrap->getWorldTransform().inverse() * convexObjWrap->getWorldTransform();
+	convexInPlaneTrans = planeObjWrap->m_worldTransform.inverse() * convexObjWrap->m_worldTransform;
 
 	btVector3 vtx = convexShape->localGetSupportingVertex(planeInConvex.m_basis * -planeNormal);
 	btVector3 vtxInPlane = convexInPlaneTrans(vtx);
 	btScalar distance = (planeNormal.dot(vtxInPlane) - planeConstant);
 
 	btVector3 vtxInPlaneProjected = vtxInPlane - distance * planeNormal;
-	btVector3 vtxInPlaneWorld = planeObjWrap->getWorldTransform() * vtxInPlaneProjected;
+	btVector3 vtxInPlaneWorld = planeObjWrap->m_worldTransform * vtxInPlaneProjected;
 
 	hasCollision = distance < m_manifoldPtr->getContactBreakingThreshold()+ resultOut->m_closestPointDistanceThreshold;
 	resultOut->setPersistentManifold(m_manifoldPtr);
 	if (hasCollision)
 	{
 		/// report a contact. internally this will be kept persistent, and contact reduction is done
-		btVector3 normalOnSurfaceB = planeObjWrap->getWorldTransform().m_basis * planeNormal;
+		btVector3 normalOnSurfaceB = planeObjWrap->m_worldTransform.m_basis * planeNormal;
 		btVector3 pOnB = vtxInPlaneWorld;
 		resultOut->addContactPoint(normalOnSurfaceB, pOnB, distance);
 	}

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btGhostObject.cpp

@@ -67,7 +67,7 @@ btPairCachingGhostObject::~btPairCachingGhostObject()
 
 void btPairCachingGhostObject::addOverlappingObjectInternal(btBroadphaseProxy* otherProxy, btBroadphaseProxy* thisProxy)
 {
-	btBroadphaseProxy* actualThisProxy = thisProxy ? thisProxy : getBroadphaseHandle();
+	btBroadphaseProxy* actualThisProxy = thisProxy ? thisProxy : m_broadphaseHandle;
 	btAssert(actualThisProxy);
 
 	btCollisionObject* otherObject = (btCollisionObject*)otherProxy->m_clientObject;
@@ -83,7 +83,7 @@ void btPairCachingGhostObject::addOverlappingObjectInternal(btBroadphaseProxy* o
 void btPairCachingGhostObject::removeOverlappingObjectInternal(btBroadphaseProxy* otherProxy, btDispatcher* dispatcher, btBroadphaseProxy* thisProxy1)
 {
 	btCollisionObject* otherObject = (btCollisionObject*)otherProxy->m_clientObject;
-	btBroadphaseProxy* actualThisProxy = thisProxy1 ? thisProxy1 : getBroadphaseHandle();
+	btBroadphaseProxy* actualThisProxy = thisProxy1 ? thisProxy1 : m_broadphaseHandle;
 	btAssert(actualThisProxy);
 
 	btAssert(otherObject);
@@ -119,11 +119,11 @@ void btGhostObject::convexSweepTest(const btConvexShape* castShape, const btTran
 	{
 		btCollisionObject* collisionObject = m_overlappingObjects[i];
 		//only perform raycast if filterMask matches
-		if (resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
+		if (resultCallback.needsCollision(collisionObject->m_broadphaseHandle))
 		{
 			//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
 			btVector3 collisionObjectAabbMin, collisionObjectAabbMax;
-			collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(), collisionObjectAabbMin, collisionObjectAabbMax);
+			collisionObject->m_collisionShape->getAabb(collisionObject->m_worldTransform, collisionObjectAabbMin, collisionObjectAabbMax);
 			AabbExpand(collisionObjectAabbMin, collisionObjectAabbMax, castShapeAabbMin, castShapeAabbMax);
 			btScalar hitLambda = btScalar(1.);  //could use resultCallback.m_closestHitFraction, but needs testing
 			btVector3 hitNormal;
@@ -131,8 +131,8 @@ void btGhostObject::convexSweepTest(const btConvexShape* castShape, const btTran
 			{
 				btCollisionWorld::objectQuerySingle(castShape, convexFromTrans, convexToTrans,
 													collisionObject,
-													collisionObject->getCollisionShape(),
-													collisionObject->getWorldTransform(),
+													collisionObject->m_collisionShape,
+													collisionObject->m_worldTransform,
 													resultCallback,
 													allowedCcdPenetration);
 			}
@@ -154,12 +154,12 @@ void btGhostObject::rayTest(const btVector3& rayFromWorld, const btVector3& rayT
 	{
 		btCollisionObject* collisionObject = m_overlappingObjects[i];
 		//only perform raycast if filterMask matches
-		if (resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
+		if (resultCallback.needsCollision(collisionObject->m_broadphaseHandle))
 		{
 			btCollisionWorld::rayTestSingle(rayFromTrans, rayToTrans,
 											collisionObject,
-											collisionObject->getCollisionShape(),
-											collisionObject->getWorldTransform(),
+											collisionObject->m_collisionShape,
+											collisionObject->m_worldTransform,
 											resultCallback);
 		}
 	}

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btGhostObject.h

@@ -81,13 +81,13 @@ public:
 
 	static const btGhostObject* upcast(const btCollisionObject* colObj)
 	{
-		if (colObj->getInternalType() == CO_GHOST_OBJECT)
+		if (colObj->m_internalType == CO_GHOST_OBJECT)
 			return (const btGhostObject*)colObj;
 		return 0;
 	}
 	static btGhostObject* upcast(btCollisionObject * colObj)
 	{
-		if (colObj->getInternalType() == CO_GHOST_OBJECT)
+		if (colObj->m_internalType == CO_GHOST_OBJECT)
 			return (btGhostObject*)colObj;
 		return 0;
 	}

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp

@@ -485,23 +485,23 @@ bool btClampNormal(const btVector3& edge, const btVector3& tri_normal_org, const
 /// Changes a btManifoldPoint collision normal to the normal from the mesh.
 void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0Wrap, const btCollisionObjectWrapper* colObj1Wrap, int partId0, int index0, int normalAdjustFlags)
 {
-	//btAssert(colObj0->getCollisionShape()->getShapeType() == TRIANGLE_SHAPE_PROXYTYPE);
-	if (colObj0Wrap->getCollisionShape()->getShapeType() != TRIANGLE_SHAPE_PROXYTYPE)
+	//btAssert(colObj0->m_collisionShape->getShapeType() == TRIANGLE_SHAPE_PROXYTYPE);
+	if (colObj0Wrap->m_collisionShape->getShapeType() != TRIANGLE_SHAPE_PROXYTYPE)
 		return;
 
 
 	btTriangleInfoMap* triangleInfoMapPtr = 0;
 
-	if (colObj0Wrap->getCollisionObject()->getCollisionShape()->getShapeType() == TERRAIN_SHAPE_PROXYTYPE)
+	if (colObj0Wrap->m_collisionObject->m_collisionShape->getShapeType() == TERRAIN_SHAPE_PROXYTYPE)
 	{
-		btHeightfieldTerrainShape* heightfield = (btHeightfieldTerrainShape*)colObj0Wrap->getCollisionObject()->getCollisionShape();
+		btHeightfieldTerrainShape* heightfield = (btHeightfieldTerrainShape*)colObj0Wrap->m_collisionObject->m_collisionShape;
 		triangleInfoMapPtr = heightfield->getTriangleInfoMap();
 
 //#define USE_HEIGHTFIELD_TRIANGLES
 #ifdef USE_HEIGHTFIELD_TRIANGLES
 		btVector3 newNormal = btVector3(0, 0, 1);
 
-		const btTriangleShape* tri_shape = static_cast<const btTriangleShape*>(colObj0Wrap->getCollisionShape());
+		const btTriangleShape* tri_shape = static_cast<const btTriangleShape*>(colObj0Wrap->m_collisionShape);
 		btVector3 tri_normal;
 		tri_shape->calcNormal(tri_normal);
 		newNormal = tri_normal;
@@ -509,7 +509,7 @@ void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWr
 		cp.m_normalWorldOnB = newNormal;
 		// Reproject collision point along normal. (what about cp.m_distance1?)
 		cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1;
-		cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB);
+		cp.m_localPointB = colObj0Wrap->m_worldTransform.invXform(cp.m_positionWorldOnB);
 		return;
 #endif
 	}
@@ -517,15 +517,15 @@ void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWr
 
 	btBvhTriangleMeshShape* trimesh = 0;
 
-	if (colObj0Wrap->getCollisionObject()->getCollisionShape()->getShapeType() == SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE)
+	if (colObj0Wrap->m_collisionObject->m_collisionShape->getShapeType() == SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE)
 	{
-		trimesh = ((btScaledBvhTriangleMeshShape*)colObj0Wrap->getCollisionObject()->getCollisionShape())->getChildShape();
+		trimesh = ((btScaledBvhTriangleMeshShape*)colObj0Wrap->m_collisionObject->m_collisionShape)->getChildShape();
 	}
 	else
 	{
-		if (colObj0Wrap->getCollisionObject()->getCollisionShape()->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
+		if (colObj0Wrap->m_collisionObject->m_collisionShape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
 		{
-			trimesh = (btBvhTriangleMeshShape*)colObj0Wrap->getCollisionObject()->getCollisionShape();
+			trimesh = (btBvhTriangleMeshShape*)colObj0Wrap->m_collisionObject->m_collisionShape;
 		}
 	}
 	if (trimesh)
@@ -545,7 +545,7 @@ void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWr
 
 	btScalar frontFacing = (normalAdjustFlags & BT_TRIANGLE_CONVEX_BACKFACE_MODE) == 0 ? 1.f : -1.f;
 
-	const btTriangleShape* tri_shape = static_cast<const btTriangleShape*>(colObj0Wrap->getCollisionShape());
+	const btTriangleShape* tri_shape = static_cast<const btTriangleShape*>(colObj0Wrap->m_collisionShape);
 	btVector3 v0, v1, v2;
 	tri_shape->getVertex(0, v0);
 	tri_shape->getVertex(1, v1);
@@ -563,7 +563,7 @@ void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWr
 
 	btVector3 contact = cp.m_localPointB;
 #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
-	const btTransform& tr = colObj0->getWorldTransform();
+	const btTransform& tr = colObj0->m_worldTransform;
 	btDebugDrawLine(tr * nearest, tr * cp.m_localPointB, red);
 #endif  //BT_INTERNAL_EDGE_DEBUG_DRAW
 
@@ -572,7 +572,7 @@ void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWr
 	int numConcaveEdgeHits = 0;
 	int numConvexEdgeHits = 0;
 
-	btVector3 localContactNormalOnB = colObj0Wrap->getWorldTransform().m_basis.transpose() * cp.m_normalWorldOnB;
+	btVector3 localContactNormalOnB = colObj0Wrap->m_worldTransform.m_basis.transpose() * cp.m_normalWorldOnB;
 	localContactNormalOnB.normalize();  //is this necessary?
 
 	// Get closest edge
@@ -678,12 +678,12 @@ void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWr
 						{
 							if (((normalAdjustFlags & BT_TRIANGLE_CONVEX_DOUBLE_SIDED) != 0) || (clampedLocalNormal.dot(frontFacing * tri_normal) > 0))
 							{
-								btVector3 newNormal = colObj0Wrap->getWorldTransform().m_basis * clampedLocalNormal;
+								btVector3 newNormal = colObj0Wrap->m_worldTransform.m_basis * clampedLocalNormal;
 								//					cp.m_distance1 = cp.m_distance1 * newNormal.dot(cp.m_normalWorldOnB);
 								cp.m_normalWorldOnB = newNormal;
 								// Reproject collision point along normal. (what about cp.m_distance1?)
 								cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1;
-								cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB);
+								cp.m_localPointB = colObj0Wrap->m_worldTransform.invXform(cp.m_positionWorldOnB);
 							}
 						}
 					}
@@ -756,19 +756,19 @@ void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWr
 					else
 					{
 						numConvexEdgeHits++;
-						btVector3 localContactNormalOnB = colObj0Wrap->getWorldTransform().m_basis.transpose() * cp.m_normalWorldOnB;
+						btVector3 localContactNormalOnB = colObj0Wrap->m_worldTransform.m_basis.transpose() * cp.m_normalWorldOnB;
 						btVector3 clampedLocalNormal;
 						bool isClamped = btClampNormal(edge, swapFactor * tri_normal, localContactNormalOnB, info->m_edgeV1V2Angle, clampedLocalNormal);
 						if (isClamped)
 						{
 							if (((normalAdjustFlags & BT_TRIANGLE_CONVEX_DOUBLE_SIDED) != 0) || (clampedLocalNormal.dot(frontFacing * tri_normal) > 0))
 							{
-								btVector3 newNormal = colObj0Wrap->getWorldTransform().m_basis * clampedLocalNormal;
+								btVector3 newNormal = colObj0Wrap->m_worldTransform.m_basis * clampedLocalNormal;
 								//					cp.m_distance1 = cp.m_distance1 * newNormal.dot(cp.m_normalWorldOnB);
 								cp.m_normalWorldOnB = newNormal;
 								// Reproject collision point along normal.
 								cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1;
-								cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB);
+								cp.m_localPointB = colObj0Wrap->m_worldTransform.invXform(cp.m_positionWorldOnB);
 							}
 						}
 					}
@@ -839,19 +839,19 @@ void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWr
 						numConvexEdgeHits++;
 						//				printf("hitting convex edge\n");
 
-						btVector3 localContactNormalOnB = colObj0Wrap->getWorldTransform().m_basis.transpose() * cp.m_normalWorldOnB;
+						btVector3 localContactNormalOnB = colObj0Wrap->m_worldTransform.m_basis.transpose() * cp.m_normalWorldOnB;
 						btVector3 clampedLocalNormal;
 						bool isClamped = btClampNormal(edge, swapFactor * tri_normal, localContactNormalOnB, info->m_edgeV2V0Angle, clampedLocalNormal);
 						if (isClamped)
 						{
 							if (((normalAdjustFlags & BT_TRIANGLE_CONVEX_DOUBLE_SIDED) != 0) || (clampedLocalNormal.dot(frontFacing * tri_normal) > 0))
 							{
-								btVector3 newNormal = colObj0Wrap->getWorldTransform().m_basis * clampedLocalNormal;
+								btVector3 newNormal = colObj0Wrap->m_worldTransform.m_basis * clampedLocalNormal;
 								//					cp.m_distance1 = cp.m_distance1 * newNormal.dot(cp.m_normalWorldOnB);
 								cp.m_normalWorldOnB = newNormal;
 								// Reproject collision point along normal.
 								cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1;
-								cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB);
+								cp.m_localPointB = colObj0Wrap->m_worldTransform.invXform(cp.m_positionWorldOnB);
 							}
 						}
 					}
@@ -877,7 +877,7 @@ void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWr
 				{
 					tri_normal *= -1;
 				}
-				cp.m_normalWorldOnB = colObj0Wrap->getWorldTransform().m_basis * tri_normal;
+				cp.m_normalWorldOnB = colObj0Wrap->m_worldTransform.m_basis * tri_normal;
 			}
 			else
 			{
@@ -889,12 +889,12 @@ void btAdjustInternalEdgeContacts(btManifoldPoint& cp, const btCollisionObjectWr
 					return;
 				}
 				//modify the normal to be the triangle normal (or backfacing normal)
-				cp.m_normalWorldOnB = colObj0Wrap->getWorldTransform().m_basis * newNormal;
+				cp.m_normalWorldOnB = colObj0Wrap->m_worldTransform.m_basis * newNormal;
 			}
 
 			// Reproject collision point along normal.
 			cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1;
-			cp.m_localPointB = colObj0Wrap->getWorldTransform().invXform(cp.m_positionWorldOnB);
+			cp.m_localPointB = colObj0Wrap->m_worldTransform.invXform(cp.m_positionWorldOnB);
 		}
 	}
 }

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp

@@ -4,8 +4,8 @@ Copyright (c) 2003-2006 Erwin Coumans  https://bulletphysics.org
 
 This software is provided 'as-is', without any express or implied warranty.
 In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
 subject to the following restrictions:
 
 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
@@ -30,7 +30,7 @@ CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback = &btManifo
 
 btScalar btManifoldResult::calculateCombinedRollingFriction(const btCollisionObject* body0, const btCollisionObject* body1)
 {
-	btScalar friction = body0->getRollingFriction() * body1->getFriction() + body1->getRollingFriction() * body0->getFriction();
+	btScalar friction = body0->m_rollingFriction * body1->m_friction + body1->m_rollingFriction * body0->m_friction;
 
 	const btScalar MAX_FRICTION = btScalar(10.);
 	if (friction < -MAX_FRICTION)
@@ -42,7 +42,7 @@ btScalar btManifoldResult::calculateCombinedRollingFriction(const btCollisionObj
 
 btScalar btManifoldResult::calculateCombinedSpinningFriction(const btCollisionObject* body0, const btCollisionObject* body1)
 {
-	btScalar friction = body0->getSpinningFriction() * body1->getFriction() + body1->getSpinningFriction() * body0->getFriction();
+	btScalar friction = body0->m_spinningFriction * body1->m_friction + body1->m_spinningFriction * body0->m_friction;
 
 	const btScalar MAX_FRICTION = btScalar(10.);
 	if (friction < -MAX_FRICTION)
@@ -55,7 +55,7 @@ btScalar btManifoldResult::calculateCombinedSpinningFriction(const btCollisionOb
 ///User can override this material combiner by implementing gContactAddedCallback and setting body0->m_collisionFlags |= btCollisionObject::customMaterialCallback;
 btScalar btManifoldResult::calculateCombinedFriction(const btCollisionObject* body0, const btCollisionObject* body1)
 {
-	btScalar friction = body0->getFriction() * body1->getFriction();
+	btScalar friction = body0->m_friction * body1->m_friction;
 
 	const btScalar MAX_FRICTION = btScalar(10.);
 	if (friction < -MAX_FRICTION)
@@ -67,18 +67,18 @@ btScalar btManifoldResult::calculateCombinedFriction(const btCollisionObject* bo
 
 btScalar btManifoldResult::calculateCombinedRestitution(const btCollisionObject* body0, const btCollisionObject* body1)
 {
-	return body0->getRestitution() * body1->getRestitution();
+	return body0->m_restitution * body1->m_restitution;
 }
 
 btScalar btManifoldResult::calculateCombinedContactDamping(const btCollisionObject* body0, const btCollisionObject* body1)
 {
-	return body0->getContactDamping() + body1->getContactDamping();
+	return body0->m_contactDamping + body1->m_contactDamping;
 }
 
 btScalar btManifoldResult::calculateCombinedContactStiffness(const btCollisionObject* body0, const btCollisionObject* body1)
 {
-	btScalar s0 = body0->getContactStiffness();
-	btScalar s1 = body1->getContactStiffness();
+	btScalar s0 = body0->m_contactStiffness;
+	btScalar s1 = body1->m_contactStiffness;
 
 	btScalar tmp0 = btScalar(1) / s0;
 	btScalar tmp1 = btScalar(1) / s1;
@@ -106,10 +106,10 @@ void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld, const
 	//order in manifold needs to match
 
 	if (depth > m_manifoldPtr->getContactBreakingThreshold())
-		//	if (depth > m_manifoldPtr->getContactProcessingThreshold())
+		//	if (depth > m_manifoldPtr->m_contactProcessingThreshold)
 		return;
 
-	bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject();
+	bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->m_collisionObject;
 	bool isNewCollision = m_manifoldPtr->getNumContacts() == 0;
 
 	btVector3 pointA = pointInWorld + normalOnBInWorld * depth;
@@ -119,13 +119,13 @@ void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld, const
 
 	if (isSwapped)
 	{
-		localA = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointA);
-		localB = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld);
+		localA = m_body1Wrap->m_collisionObject->m_worldTransform.invXform(pointA);
+		localB = m_body0Wrap->m_collisionObject->m_worldTransform.invXform(pointInWorld);
 	}
 	else
 	{
-		localA = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointA);
-		localB = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld);
+		localA = m_body0Wrap->m_collisionObject->m_worldTransform.invXform(pointA);
+		localB = m_body1Wrap->m_collisionObject->m_worldTransform.invXform(pointInWorld);
 	}
 
 	btManifoldPoint newPt(localA, localB, normalOnBInWorld, depth);
@@ -134,21 +134,21 @@ void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld, const
 
 	int insertIndex = m_manifoldPtr->getCacheEntry(newPt);
 
-	newPt.m_combinedFriction = gCalculateCombinedFrictionCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject());
-	newPt.m_combinedRestitution = gCalculateCombinedRestitutionCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject());
-	newPt.m_combinedRollingFriction = gCalculateCombinedRollingFrictionCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject());
-	newPt.m_combinedSpinningFriction = gCalculateCombinedSpinningFrictionCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject());
+	newPt.m_combinedFriction = gCalculateCombinedFrictionCallback(m_body0Wrap->m_collisionObject, m_body1Wrap->m_collisionObject);
+	newPt.m_combinedRestitution = gCalculateCombinedRestitutionCallback(m_body0Wrap->m_collisionObject, m_body1Wrap->m_collisionObject);
+	newPt.m_combinedRollingFriction = gCalculateCombinedRollingFrictionCallback(m_body0Wrap->m_collisionObject, m_body1Wrap->m_collisionObject);
+	newPt.m_combinedSpinningFriction = gCalculateCombinedSpinningFrictionCallback(m_body0Wrap->m_collisionObject, m_body1Wrap->m_collisionObject);
 
-	if ((m_body0Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_HAS_CONTACT_STIFFNESS_DAMPING) ||
-		(m_body1Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_HAS_CONTACT_STIFFNESS_DAMPING))
+	if ((m_body0Wrap->m_collisionObject->m_collisionFlags & btCollisionObject::CF_HAS_CONTACT_STIFFNESS_DAMPING) ||
+		(m_body1Wrap->m_collisionObject->m_collisionFlags & btCollisionObject::CF_HAS_CONTACT_STIFFNESS_DAMPING))
 	{
-		newPt.m_combinedContactDamping1 = gCalculateCombinedContactDampingCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject());
-		newPt.m_combinedContactStiffness1 = gCalculateCombinedContactStiffnessCallback(m_body0Wrap->getCollisionObject(), m_body1Wrap->getCollisionObject());
+		newPt.m_combinedContactDamping1 = gCalculateCombinedContactDampingCallback(m_body0Wrap->m_collisionObject, m_body1Wrap->m_collisionObject);
+		newPt.m_combinedContactStiffness1 = gCalculateCombinedContactStiffnessCallback(m_body0Wrap->m_collisionObject, m_body1Wrap->m_collisionObject);
 		newPt.m_contactPointFlags |= BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING;
 	}
 
-	if ((m_body0Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_HAS_FRICTION_ANCHOR) ||
-		(m_body1Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_HAS_FRICTION_ANCHOR))
+	if ((m_body0Wrap->m_collisionObject->m_collisionFlags & btCollisionObject::CF_HAS_FRICTION_ANCHOR) ||
+		(m_body1Wrap->m_collisionObject->m_collisionFlags & btCollisionObject::CF_HAS_FRICTION_ANCHOR))
 	{
 		newPt.m_contactPointFlags |= BT_CONTACT_FLAG_FRICTION_ANCHOR;
 	}
@@ -185,8 +185,8 @@ void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld, const
 	//User can override friction and/or restitution
 	if (gContactAddedCallback &&
 		//and if either of the two bodies requires custom material
-		((m_body0Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) ||
-		 (m_body1Wrap->getCollisionObject()->getCollisionFlags() & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK)))
+		((m_body0Wrap->m_collisionObject->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK) ||
+		 (m_body1Wrap->m_collisionObject->m_collisionFlags & btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK)))
 	{
 		//experimental feature info, for per-triangle material etc.
 		const btCollisionObjectWrapper* obj0Wrap = isSwapped ? m_body1Wrap : m_body0Wrap;

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btManifoldResult.h

@@ -108,15 +108,15 @@ public:
 		if (!m_manifoldPtr->getNumContacts())
 			return;
 
-		bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject();
+		bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->m_collisionObject;
 
 		if (isSwapped)
 		{
-			m_manifoldPtr->refreshContactPoints(m_body1Wrap->getCollisionObject()->getWorldTransform(), m_body0Wrap->getCollisionObject()->getWorldTransform());
+			m_manifoldPtr->refreshContactPoints(m_body1Wrap->m_collisionObject->m_worldTransform, m_body0Wrap->m_collisionObject->m_worldTransform);
 		}
 		else
 		{
-			m_manifoldPtr->refreshContactPoints(m_body0Wrap->getCollisionObject()->getWorldTransform(), m_body1Wrap->getCollisionObject()->getWorldTransform());
+			m_manifoldPtr->refreshContactPoints(m_body0Wrap->m_collisionObject->m_worldTransform, m_body1Wrap->m_collisionObject->m_worldTransform);
 		}
 	}
 
@@ -141,12 +141,12 @@ public:
 
 	const btCollisionObject* getBody0Internal() const
 	{
-		return m_body0Wrap->getCollisionObject();
+		return m_body0Wrap->m_collisionObject;
 	}
 
 	const btCollisionObject* getBody1Internal() const
 	{
-		return m_body1Wrap->getCollisionObject();
+		return m_body1Wrap->m_collisionObject;
 	}
 
 	btScalar m_closestPointDistanceThreshold;

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

@@ -55,8 +55,8 @@ void btSimulationIslandManager::findUnions(btDispatcher* /* dispatcher */, btCol
 				if (((colObj0) && ((colObj0)->mergesSimulationIslands())) &&
 					((colObj1) && ((colObj1)->mergesSimulationIslands())))
 				{
-					m_unionFind.unite((colObj0)->getIslandTag(),
-									  (colObj1)->getIslandTag());
+					m_unionFind.unite((colObj0)->m_islandTag1,
+									  (colObj1)->m_islandTag1);
 				}
 			}
 		}
@@ -76,10 +76,10 @@ void btSimulationIslandManager::updateActivationState(btCollisionWorld* colWorld
 			//Adding filtering here
 			if (!collisionObject->isStaticOrKinematicObject())
 			{
-				collisionObject->setIslandTag(index++);
+				collisionObject->m_islandTag1 = (index++);
 			}
-			collisionObject->setCompanionId(-1);
-			collisionObject->setHitFraction(btScalar(1.));
+			collisionObject->m_companionId = (-1);
+			collisionObject->m_hitFraction = (btScalar(1.));
 		}
 	}
 	// do the union find
@@ -100,16 +100,16 @@ void btSimulationIslandManager::storeIslandActivationState(btCollisionWorld* col
 			btCollisionObject* collisionObject = colWorld->getCollisionObjectArray()[i];
 			if (!collisionObject->isStaticOrKinematicObject())
 			{
-				collisionObject->setIslandTag(m_unionFind.find(index));
+				collisionObject->m_islandTag1 = (m_unionFind.find(index));
 				//Set the correct object offset in Collision Object Array
 				m_unionFind.getElement(index).m_sz = i;
-				collisionObject->setCompanionId(-1);
+				collisionObject->m_companionId = (-1);
 				index++;
 			}
 			else
 			{
-				collisionObject->setIslandTag(-1);
-				collisionObject->setCompanionId(-2);
+				collisionObject->m_islandTag1 = (-1);
+				collisionObject->m_companionId = (-2);
 			}
 		}
 	}
@@ -127,9 +127,9 @@ void btSimulationIslandManager::updateActivationState(btCollisionWorld* colWorld
 		for (i = 0; i < colWorld->getCollisionObjectArray().size(); i++)
 		{
 			btCollisionObject* collisionObject = colWorld->getCollisionObjectArray()[i];
-			collisionObject->setIslandTag(index);
-			collisionObject->setCompanionId(-1);
-			collisionObject->setHitFraction(btScalar(1.));
+			collisionObject->m_islandTag1 = (index);
+			collisionObject->m_companionId = (-1);
+			collisionObject->m_hitFraction = (btScalar(1.));
 			index++;
 		}
 	}
@@ -149,13 +149,13 @@ void btSimulationIslandManager::storeIslandActivationState(btCollisionWorld* col
 			btCollisionObject* collisionObject = colWorld->getCollisionObjectArray()[i];
 			if (!collisionObject->isStaticOrKinematicObject())
 			{
-				collisionObject->setIslandTag(m_unionFind.find(index));
-				collisionObject->setCompanionId(-1);
+				collisionObject->m_islandTag1 = (m_unionFind.find(index));
+				collisionObject->m_companionId = (-1);
 			}
 			else
 			{
-				collisionObject->setIslandTag(-1);
-				collisionObject->setCompanionId(-2);
+				collisionObject->m_islandTag1 = (-1);
+				collisionObject->m_companionId = (-2);
 			}
 			index++;
 		}
@@ -169,7 +169,7 @@ inline int getIslandId(const btPersistentManifold* lhs)
 	int islandId;
 	const btCollisionObject* rcolObj0 = static_cast<const btCollisionObject*>(lhs->getBody0());
 	const btCollisionObject* rcolObj1 = static_cast<const btCollisionObject*>(lhs->getBody1());
-	islandId = rcolObj0->getIslandTag() >= 0 ? rcolObj0->getIslandTag() : rcolObj1->getIslandTag();
+	islandId = rcolObj0->m_islandTag1 >= 0 ? rcolObj0->m_islandTag1 : rcolObj1->m_islandTag1;
 	return islandId;
 }
 
@@ -189,7 +189,7 @@ public:
 	SIMD_FORCE_INLINE bool operator()(const btPersistentManifold* lhs, const btPersistentManifold* rhs) const
 	{
 		return (
-			(getIslandId(lhs) < getIslandId(rhs)) || ((getIslandId(lhs) == getIslandId(rhs)) && lhs->getBody0()->getBroadphaseHandle()->m_uniqueId < rhs->getBody0()->getBroadphaseHandle()->m_uniqueId) || ((getIslandId(lhs) == getIslandId(rhs)) && (lhs->getBody0()->getBroadphaseHandle()->m_uniqueId == rhs->getBody0()->getBroadphaseHandle()->m_uniqueId) && (lhs->getBody1()->getBroadphaseHandle()->m_uniqueId < rhs->getBody1()->getBroadphaseHandle()->m_uniqueId)));
+			(getIslandId(lhs) < getIslandId(rhs)) || ((getIslandId(lhs) == getIslandId(rhs)) && lhs->getBody0()->m_broadphaseHandle->m_uniqueId < rhs->getBody0()->m_broadphaseHandle->m_uniqueId) || ((getIslandId(lhs) == getIslandId(rhs)) && (lhs->getBody0()->m_broadphaseHandle->m_uniqueId == rhs->getBody0()->m_broadphaseHandle->m_uniqueId) && (lhs->getBody1()->m_broadphaseHandle->m_uniqueId < rhs->getBody1()->m_broadphaseHandle->m_uniqueId)));
 	}
 };
 
@@ -228,16 +228,16 @@ void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher, btCollisi
 			int i = getUnionFind().getElement(idx).m_sz;
 
 			btCollisionObject* colObj0 = collisionObjects[i];
-			if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1))
+			if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
 			{
 				//				printf("error in island management\n");
 			}
 
-            btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
-			if (colObj0->getIslandTag() == islandId)
+            btAssert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
+			if (colObj0->m_islandTag1 == islandId)
 			{
-				if (colObj0->getActivationState() == ACTIVE_TAG ||
-					colObj0->getActivationState() == DISABLE_DEACTIVATION)
+				if (colObj0->m_activationState1 == ACTIVE_TAG ||
+					colObj0->m_activationState1 == DISABLE_DEACTIVATION)
 				{
 					allSleeping = false;
 					break;
@@ -252,14 +252,14 @@ void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher, btCollisi
 			{
 				int i = getUnionFind().getElement(idx).m_sz;
 				btCollisionObject* colObj0 = collisionObjects[i];
-				if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1))
+				if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
 				{
 					//					printf("error in island management\n");
 				}
 
-                btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
+                btAssert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
 
-				if (colObj0->getIslandTag() == islandId)
+				if (colObj0->m_islandTag1 == islandId)
 				{
 					colObj0->setActivationState(ISLAND_SLEEPING);
 				}
@@ -273,20 +273,20 @@ void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher, btCollisi
 				int i = getUnionFind().getElement(idx).m_sz;
 
 				btCollisionObject* colObj0 = collisionObjects[i];
-				if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1))
+				if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
 				{
 					//					printf("error in island management\n");
 				}
 
-                 btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
+                 btAssert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
 
 
-				if (colObj0->getIslandTag() == islandId)
+				if (colObj0->m_islandTag1 == islandId)
 				{
-					if (colObj0->getActivationState() == ISLAND_SLEEPING)
+					if (colObj0->m_activationState1 == ISLAND_SLEEPING)
 					{
 						colObj0->setActivationState(WANTS_DEACTIVATION);
-						colObj0->setDeactivationTime(0.f);
+						colObj0->m_deactivationTime = (0.f);
 					}
 				}
 			}
@@ -314,16 +314,16 @@ void btSimulationIslandManager::buildIslands(btDispatcher* dispatcher, btCollisi
 		const btCollisionObject* colObj1 = static_cast<const btCollisionObject*>(manifold->getBody1());
 
 		///@todo: check sleeping conditions!
-		if (((colObj0) && colObj0->getActivationState() != ISLAND_SLEEPING) ||
-			((colObj1) && colObj1->getActivationState() != ISLAND_SLEEPING))
+		if (((colObj0) && colObj0->m_activationState1 != ISLAND_SLEEPING) ||
+			((colObj1) && colObj1->m_activationState1 != ISLAND_SLEEPING))
 		{
 			//kinematic objects don't merge islands, but wake up all connected objects
-			if (colObj0->isKinematicObject() && colObj0->getActivationState() != ISLAND_SLEEPING)
+			if (colObj0->isKinematicObject() && colObj0->m_activationState1 != ISLAND_SLEEPING)
 			{
 				if (colObj0->hasContactResponse())
 					colObj1->activate();
 			}
-			if (colObj1->isKinematicObject() && colObj1->getActivationState() != ISLAND_SLEEPING)
+			if (colObj1->isKinematicObject() && colObj1->m_activationState1 != ISLAND_SLEEPING)
 			{
 				if (colObj1->hasContactResponse())
 					colObj0->activate();

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp

@@ -30,9 +30,9 @@ btSphereBoxCollisionAlgorithm::btSphereBoxCollisionAlgorithm(btPersistentManifol
 	const btCollisionObjectWrapper* sphereObjWrap = m_isSwapped ? col1Wrap : col0Wrap;
 	const btCollisionObjectWrapper* boxObjWrap = m_isSwapped ? col0Wrap : col1Wrap;
 
-	if (!m_manifoldPtr && m_dispatcher->needsCollision(sphereObjWrap->getCollisionObject(), boxObjWrap->getCollisionObject()))
+	if (!m_manifoldPtr && m_dispatcher->needsCollision(sphereObjWrap->m_collisionObject, boxObjWrap->m_collisionObject))
 	{
-		m_manifoldPtr = m_dispatcher->getNewManifold(sphereObjWrap->getCollisionObject(), boxObjWrap->getCollisionObject());
+		m_manifoldPtr = m_dispatcher->getNewManifold(sphereObjWrap->m_collisionObject, boxObjWrap->m_collisionObject);
 		m_ownManifold = true;
 	}
 }
@@ -60,8 +60,8 @@ void btSphereBoxCollisionAlgorithm::processCollision(const btCollisionObjectWrap
 
 	btVector3 normalOnSurfaceB;
 	btScalar penetrationDepth;
-	btVector3 sphereCenter = sphereObjWrap->getWorldTransform().m_origin;
-	const btSphereShape* sphere0 = (const btSphereShape*)sphereObjWrap->getCollisionShape();
+	btVector3 sphereCenter = sphereObjWrap->m_worldTransform.m_origin;
+	const btSphereShape* sphere0 = (const btSphereShape*)sphereObjWrap->m_collisionShape;
 	btScalar radius = sphere0->getRadius();
 	btScalar maxContactDistance = m_manifoldPtr->getContactBreakingThreshold();
 
@@ -95,13 +95,13 @@ btScalar btSphereBoxCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject*
 
 bool btSphereBoxCollisionAlgorithm::getSphereDistance(const btCollisionObjectWrapper* boxObjWrap, btVector3& pointOnBox, btVector3& normal, btScalar& penetrationDepth, const btVector3& sphereCenter, btScalar fRadius, btScalar maxContactDistance)
 {
-	const btBoxShape* boxShape = (const btBoxShape*)boxObjWrap->getCollisionShape();
+	const btBoxShape* boxShape = (const btBoxShape*)boxObjWrap->m_collisionShape;
 	btVector3 const& boxHalfExtent = boxShape->getHalfExtentsWithoutMargin();
 	btScalar boxMargin = boxShape->getMargin();
 	penetrationDepth = 1.0f;
 
 	// convert the sphere position to the box's local space
-	btTransform const& m44T = boxObjWrap->getWorldTransform();
+	btTransform const& m44T = boxObjWrap->m_worldTransform;
 	btVector3 sphereRelPos = m44T.invXform(sphereCenter);
 
 	// Determine the closest point to the sphere center in the box

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp

@@ -27,7 +27,7 @@ btSphereSphereCollisionAlgorithm::btSphereSphereCollisionAlgorithm(btPersistentM
 {
 	if (!m_manifoldPtr)
 	{
-		m_manifoldPtr = m_dispatcher->getNewManifold(col0Wrap->getCollisionObject(), col1Wrap->getCollisionObject());
+		m_manifoldPtr = m_dispatcher->getNewManifold(col0Wrap->m_collisionObject, col1Wrap->m_collisionObject);
 		m_ownManifold = true;
 	}
 }
@@ -50,10 +50,10 @@ void btSphereSphereCollisionAlgorithm::processCollision(const btCollisionObjectW
 
 	resultOut->setPersistentManifold(m_manifoldPtr);
 
-	btSphereShape* sphere0 = (btSphereShape*)col0Wrap->getCollisionShape();
-	btSphereShape* sphere1 = (btSphereShape*)col1Wrap->getCollisionShape();
+	btSphereShape* sphere0 = (btSphereShape*)col0Wrap->m_collisionShape;
+	btSphereShape* sphere1 = (btSphereShape*)col1Wrap->m_collisionShape;
 
-	btVector3 diff = col0Wrap->getWorldTransform().m_origin - col1Wrap->getWorldTransform().m_origin;
+	btVector3 diff = col0Wrap->m_worldTransform.m_origin - col1Wrap->m_worldTransform.m_origin;
 	btScalar len = diff.length();
 	btScalar radius0 = sphere0->getRadius();
 	btScalar radius1 = sphere1->getRadius();
@@ -80,9 +80,9 @@ void btSphereSphereCollisionAlgorithm::processCollision(const btCollisionObjectW
 	}
 
 	///point on A (worldspace)
-	///btVector3 pos0 = col0->getWorldTransform().m_origin - radius0 * normalOnSurfaceB;
+	///btVector3 pos0 = col0->m_worldTransform.m_origin - radius0 * normalOnSurfaceB;
 	///point on B (worldspace)
-	btVector3 pos1 = col1Wrap->getWorldTransform().m_origin + radius1 * normalOnSurfaceB;
+	btVector3 pos1 = col1Wrap->m_worldTransform.m_origin + radius1 * normalOnSurfaceB;
 
 	/// report a contact. internally this will be kept persistent, and contact reduction is done
 

3rdparty/bullet3/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp

@@ -28,7 +28,7 @@ btSphereTriangleCollisionAlgorithm::btSphereTriangleCollisionAlgorithm(btPersist
 {
 	if (!m_manifoldPtr)
 	{
-		m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->getCollisionObject(), body1Wrap->getCollisionObject());
+		m_manifoldPtr = m_dispatcher->getNewManifold(body0Wrap->m_collisionObject, body1Wrap->m_collisionObject);
 		m_ownManifold = true;
 	}
 }
@@ -50,8 +50,8 @@ void btSphereTriangleCollisionAlgorithm::processCollision(const btCollisionObjec
 	const btCollisionObjectWrapper* sphereObjWrap = m_swapped ? col1Wrap : col0Wrap;
 	const btCollisionObjectWrapper* triObjWrap = m_swapped ? col0Wrap : col1Wrap;
 
-	btSphereShape* sphere = (btSphereShape*)sphereObjWrap->getCollisionShape();
-	btTriangleShape* triangle = (btTriangleShape*)triObjWrap->getCollisionShape();
+	btSphereShape* sphere = (btSphereShape*)sphereObjWrap->m_collisionShape;
+	btTriangleShape* triangle = (btTriangleShape*)triObjWrap->m_collisionShape;
 
 	/// report a contact. internally this will be kept persistent, and contact reduction is done
 	resultOut->setPersistentManifold(m_manifoldPtr);
@@ -59,8 +59,8 @@ void btSphereTriangleCollisionAlgorithm::processCollision(const btCollisionObjec
 
 	btDiscreteCollisionDetectorInterface::ClosestPointInput input;
 	input.m_maximumDistanceSquared = btScalar(BT_LARGE_FLOAT);  ///@todo: tighter bounds
-	input.m_transformA = sphereObjWrap->getWorldTransform();
-	input.m_transformB = triObjWrap->getWorldTransform();
+	input.m_transformA = sphereObjWrap->m_worldTransform;
+	input.m_transformB = triObjWrap->m_worldTransform;
 
 	bool swapResults = m_swapped;
 

3rdparty/bullet3/src/BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h

@@ -30,7 +30,7 @@ bool btGjkEpaCalcPenDepth(const btConvexTemplate& a, const btConvexTemplate& b,
 
 	//	const btScalar				radialmargin(btScalar(0.));
 
-	btVector3 guessVector(b.getWorldTransform().m_origin - a.getWorldTransform().m_origin);  //?? why not use the GJK input?
+	btVector3 guessVector(b.m_worldTransform.m_origin - a.m_worldTransform.m_origin);  //?? why not use the GJK input?
 
 	btGjkEpaSolver3::sResults results;
 
@@ -67,8 +67,8 @@ int btComputeGjkEpaPenetration(const btConvexTemplate& a, const btConvexTemplate
 	btVector3 normalInB(btScalar(0.), btScalar(0.), btScalar(0.));
 
 	btVector3 pointOnA, pointOnB;
-	btTransform localTransA = a.getWorldTransform();
-	btTransform localTransB = b.getWorldTransform();
+	btTransform localTransA = a.m_worldTransform;
+	btTransform localTransB = b.m_worldTransform;
 
 	btScalar marginA = a.getMargin();
 	btScalar marginB = b.getMargin();

3rdparty/bullet3/src/BulletCollision/NarrowPhaseCollision/btGjkEpa3.h

@@ -885,8 +885,8 @@ static void Initialize(const btConvexTemplate& a, const btConvexTemplate& b,
 	results.status = btGjkEpaSolver3::sResults::Separated;
 	/* Shape		*/
 
-	shape.m_toshape1 = b.getWorldTransform().m_basis.transposeTimes(a.getWorldTransform().m_basis);
-	shape.m_toshape0 = a.getWorldTransform().inverseTimes(b.getWorldTransform());
+	shape.m_toshape1 = b.m_worldTransform.m_basis.transposeTimes(a.m_worldTransform.m_basis);
+	shape.m_toshape0 = a.m_worldTransform.inverseTimes(b.m_worldTransform);
 }
 
 //
@@ -913,8 +913,8 @@ bool btGjkEpaSolver3_Distance(const btConvexTemplate& a, const btConvexTemplate&
 			w0 += shape.Support(gjk.m_simplex->c[i]->d, 0) * p;
 			w1 += shape.Support(-gjk.m_simplex->c[i]->d, 1) * p;
 		}
-		results.witnesses[0] = a.getWorldTransform() * w0;
-		results.witnesses[1] = a.getWorldTransform() * w1;
+		results.witnesses[0] = a.m_worldTransform * w0;
+		results.witnesses[1] = a.m_worldTransform * w1;
 		results.normal = w0 - w1;
 		results.distance = results.normal.length();
 		results.normal /= results.distance > GJK_MIN_DISTANCE ? results.distance : 1;
@@ -951,8 +951,8 @@ bool btGjkEpaSolver3_Penetration(const btConvexTemplate& a,
 					w0 += shape.Support(epa.m_result.c[i]->d, 0) * epa.m_result.p[i];
 				}
 				results.status = btGjkEpaSolver3::sResults::Penetrating;
-				results.witnesses[0] = a.getWorldTransform() * w0;
-				results.witnesses[1] = a.getWorldTransform() * (w0 - epa.m_normal * epa.m_depth);
+				results.witnesses[0] = a.m_worldTransform * w0;
+				results.witnesses[1] = a.m_worldTransform * (w0 - epa.m_normal * epa.m_depth);
 				results.normal = -epa.m_normal;
 				results.distance = -epa.m_depth;
 				return (true);

3rdparty/bullet3/src/BulletCollision/NarrowPhaseCollision/btMprPenetration.h

@@ -309,14 +309,14 @@ inline void btMprSupport(const btConvexTemplate &a, const btConvexTemplate &b,
 						 const btMprCollisionDescription &colDesc,
 						 const btVector3 &dir, btMprSupport_t *supp)
 {
-	btVector3 separatingAxisInA = dir * a.getWorldTransform().m_basis;
-	btVector3 separatingAxisInB = -dir * b.getWorldTransform().m_basis;
+	btVector3 separatingAxisInA = dir * a.m_worldTransform.m_basis;
+	btVector3 separatingAxisInB = -dir * b.m_worldTransform.m_basis;
 
 	btVector3 pInA = a.getLocalSupportWithMargin(separatingAxisInA);
 	btVector3 qInB = b.getLocalSupportWithMargin(separatingAxisInB);
 
-	supp->v1 = a.getWorldTransform()(pInA);
-	supp->v2 = b.getWorldTransform()(qInB);
+	supp->v1 = a.m_worldTransform(pInA);
+	supp->v2 = b.m_worldTransform(qInB);
 	supp->v = supp->v1 - supp->v2;
 }
 

3rdparty/bullet3/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.cpp

@@ -314,7 +314,7 @@ const char* btPersistentManifold::serialize(const class btPersistentManifold* ma
 	dataOut->m_body0 = (btCollisionObjectData*)serializer->getUniquePointer((void*)manifold->getBody0());
 	dataOut->m_body1 = (btCollisionObjectData*)serializer->getUniquePointer((void*)manifold->getBody1());
 	dataOut->m_contactBreakingThreshold = manifold->getContactBreakingThreshold();
-	dataOut->m_contactProcessingThreshold = manifold->getContactProcessingThreshold();
+	dataOut->m_contactProcessingThreshold = manifold->m_contactProcessingThreshold;
 	dataOut->m_numCachedPoints = manifold->getNumContacts();
 	dataOut->m_companionIdA = manifold->m_companionIdA;
 	dataOut->m_companionIdB = manifold->m_companionIdB;

3rdparty/bullet3/src/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h

@@ -4,8 +4,8 @@ Copyright (c) 2003-2006 Erwin Coumans  https://bulletphysics.org
 
 This software is provided 'as-is', without any express or implied warranty.
 In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
 subject to the following restrictions:
 
 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.

3rdparty/bullet3/src/BulletDynamics/Character/btKinematicCharacterController.cpp

@@ -86,7 +86,7 @@ public:
 		else
 		{
 			///need to transform normal into worldspace
-			hitNormalWorld = convexResult.m_hitCollisionObject->getWorldTransform().m_basis * convexResult.m_hitNormalLocal;
+			hitNormalWorld = convexResult.m_hitCollisionObject->m_worldTransform.m_basis * convexResult.m_hitNormalLocal;
 		}
 
 		btScalar dotUp = m_up.dot(hitNormalWorld);
@@ -185,8 +185,8 @@ bool btKinematicCharacterController::recoverFromPenetration(btCollisionWorld* co
 	// paircache and the ghostobject's internal paircache at the same time.    /BW
 
 	btVector3 minAabb, maxAabb;
-	m_convexShape->getAabb(m_ghostObject->getWorldTransform(), minAabb, maxAabb);
-	collisionWorld->getBroadphase()->setAabb(m_ghostObject->getBroadphaseHandle(),
+	m_convexShape->getAabb(m_ghostObject->m_worldTransform, minAabb, maxAabb);
+	collisionWorld->getBroadphase()->setAabb(m_ghostObject->m_broadphaseHandle,
 											 minAabb,
 											 maxAabb,
 											 collisionWorld->getDispatcher());
@@ -195,7 +195,7 @@ bool btKinematicCharacterController::recoverFromPenetration(btCollisionWorld* co
 
 	collisionWorld->getDispatcher()->dispatchAllCollisionPairs(m_ghostObject->getOverlappingPairCache(), collisionWorld->getDispatchInfo(), collisionWorld->getDispatcher());
 
-	m_currentPosition = m_ghostObject->getWorldTransform().m_origin;
+	m_currentPosition = m_ghostObject->m_worldTransform.m_origin;
 
 	//	btScalar maxPen = btScalar(0.0);
 	for (int i = 0; i < m_ghostObject->getOverlappingPairCache()->getNumOverlappingPairs(); i++)
@@ -247,7 +247,7 @@ bool btKinematicCharacterController::recoverFromPenetration(btCollisionWorld* co
 			//manifold->clearManifold();
 		}
 	}
-	btTransform newTrans = m_ghostObject->getWorldTransform();
+	btTransform newTrans = m_ghostObject->m_worldTransform;
 	newTrans.m_origin = (m_currentPosition);
 	m_ghostObject->setWorldTransform(newTrans);
 	//	printf("m_touchingNormal = %f,%f,%f\n",m_touchingNormal[0],m_touchingNormal[1],m_touchingNormal[2]);
@@ -278,8 +278,8 @@ void btKinematicCharacterController::stepUp(btCollisionWorld* world)
 	end.setRotation(m_targetOrientation);
 
 	btKinematicClosestNotMeConvexResultCallback callback(m_ghostObject, -m_up, m_maxSlopeCosine);
-	callback.m_collisionFilterGroup = getGhostObject()->getBroadphaseHandle()->m_collisionFilterGroup;
-	callback.m_collisionFilterMask = getGhostObject()->getBroadphaseHandle()->m_collisionFilterMask;
+	callback.m_collisionFilterGroup = getGhostObject()->m_broadphaseHandle->m_collisionFilterGroup;
+	callback.m_collisionFilterMask = getGhostObject()->m_broadphaseHandle->m_collisionFilterMask;
 
 	if (m_useGhostObjectSweepTest)
 	{
@@ -303,7 +303,7 @@ void btKinematicCharacterController::stepUp(btCollisionWorld* world)
 				m_currentPosition = m_targetPosition;
 		}
 
-		btTransform& xform = m_ghostObject->getWorldTransform();
+		btTransform& xform = m_ghostObject->m_worldTransform;
 		xform.m_origin = (m_currentPosition);
 		m_ghostObject->setWorldTransform(xform);
 
@@ -320,7 +320,7 @@ void btKinematicCharacterController::stepUp(btCollisionWorld* world)
 				break;
 			}
 		}
-		m_targetPosition = m_ghostObject->getWorldTransform().m_origin;
+		m_targetPosition = m_ghostObject->m_worldTransform.m_origin;
 		m_currentPosition = m_targetPosition;
 
 		if (m_verticalOffset > 0)
@@ -339,8 +339,8 @@ void btKinematicCharacterController::stepUp(btCollisionWorld* world)
 
 bool btKinematicCharacterController::needsCollision(const btCollisionObject* body0, const btCollisionObject* body1)
 {
-	bool collides = (body0->getBroadphaseHandle()->m_collisionFilterGroup & body1->getBroadphaseHandle()->m_collisionFilterMask) != 0;
-	collides = collides && (body1->getBroadphaseHandle()->m_collisionFilterGroup & body0->getBroadphaseHandle()->m_collisionFilterMask);
+	bool collides = (body0->m_broadphaseHandle->m_collisionFilterGroup & body1->m_broadphaseHandle->m_collisionFilterMask) != 0;
+	collides = collides && (body1->m_broadphaseHandle->m_collisionFilterGroup & body0->m_broadphaseHandle->m_collisionFilterMask);
 	return collides;
 }
 
@@ -409,8 +409,8 @@ void btKinematicCharacterController::stepForwardAndStrafe(btCollisionWorld* coll
 		end.setRotation(m_targetOrientation);
 
 		btKinematicClosestNotMeConvexResultCallback callback(m_ghostObject, sweepDirNegative, btScalar(0.0));
-		callback.m_collisionFilterGroup = getGhostObject()->getBroadphaseHandle()->m_collisionFilterGroup;
-		callback.m_collisionFilterMask = getGhostObject()->getBroadphaseHandle()->m_collisionFilterMask;
+		callback.m_collisionFilterGroup = getGhostObject()->m_broadphaseHandle->m_collisionFilterGroup;
+		callback.m_collisionFilterMask = getGhostObject()->m_broadphaseHandle->m_collisionFilterMask;
 
 		btScalar margin = m_convexShape->getMargin();
 		m_convexShape->setMargin(margin + m_addedMargin);
@@ -489,12 +489,12 @@ void btKinematicCharacterController::stepDown(btCollisionWorld* collisionWorld,
 	m_targetPosition -= step_drop;
 
 	btKinematicClosestNotMeConvexResultCallback callback(m_ghostObject, m_up, m_maxSlopeCosine);
-	callback.m_collisionFilterGroup = getGhostObject()->getBroadphaseHandle()->m_collisionFilterGroup;
-	callback.m_collisionFilterMask = getGhostObject()->getBroadphaseHandle()->m_collisionFilterMask;
+	callback.m_collisionFilterGroup = getGhostObject()->m_broadphaseHandle->m_collisionFilterGroup;
+	callback.m_collisionFilterMask = getGhostObject()->m_broadphaseHandle->m_collisionFilterMask;
 
 	btKinematicClosestNotMeConvexResultCallback callback2(m_ghostObject, m_up, m_maxSlopeCosine);
-	callback2.m_collisionFilterGroup = getGhostObject()->getBroadphaseHandle()->m_collisionFilterGroup;
-	callback2.m_collisionFilterMask = getGhostObject()->getBroadphaseHandle()->m_collisionFilterMask;
+	callback2.m_collisionFilterGroup = getGhostObject()->m_broadphaseHandle->m_collisionFilterGroup;
+	callback2.m_collisionFilterMask = getGhostObject()->m_broadphaseHandle->m_collisionFilterMask;
 
 	while (1)
 	{
@@ -659,7 +659,7 @@ void btKinematicCharacterController::setLinearVelocity(const btVector3& velocity
 			if (c > 0.0f)
 			{
 				m_wasJumping = true;
-				m_jumpPosition = m_ghostObject->getWorldTransform().m_origin;
+				m_jumpPosition = m_ghostObject->m_worldTransform.m_origin;
 			}
 		}
 	}
@@ -699,10 +699,10 @@ void btKinematicCharacterController::warp(const btVector3& origin)
 
 void btKinematicCharacterController::preStep(btCollisionWorld* collisionWorld)
 {
-	m_currentPosition = m_ghostObject->getWorldTransform().m_origin;
+	m_currentPosition = m_ghostObject->m_worldTransform.m_origin;
 	m_targetPosition = m_currentPosition;
 
-	m_currentOrientation = m_ghostObject->getWorldTransform().getRotation();
+	m_currentOrientation = m_ghostObject->m_worldTransform.getRotation();
 	m_targetOrientation = m_currentOrientation;
 	//	printf("m_targetPosition=%f,%f,%f\n",m_targetPosition[0],m_targetPosition[1],m_targetPosition[2]);
 }
@@ -721,7 +721,7 @@ void btKinematicCharacterController::playerStep(btCollisionWorld* collisionWorld
 	if (m_AngVel.length2() > 0.0f)
 	{
 		btTransform xform;
-		xform = m_ghostObject->getWorldTransform();
+		xform = m_ghostObject->m_worldTransform;
 
 		btQuaternion rot(m_AngVel.normalized(), m_AngVel.length() * dt);
 
@@ -730,9 +730,9 @@ void btKinematicCharacterController::playerStep(btCollisionWorld* collisionWorld
 		xform.setRotation(orn);
 		m_ghostObject->setWorldTransform(xform);
 
-		m_currentPosition = m_ghostObject->getWorldTransform().m_origin;
+		m_currentPosition = m_ghostObject->m_worldTransform.m_origin;
 		m_targetPosition = m_currentPosition;
-		m_currentOrientation = m_ghostObject->getWorldTransform().getRotation();
+		m_currentOrientation = m_ghostObject->m_worldTransform.getRotation();
 		m_targetOrientation = m_currentOrientation;
 	}
 
@@ -769,7 +769,7 @@ void btKinematicCharacterController::playerStep(btCollisionWorld* collisionWorld
 	m_verticalOffset = m_verticalVelocity * dt;
 
 	btTransform xform;
-	xform = m_ghostObject->getWorldTransform();
+	xform = m_ghostObject->m_worldTransform;
 
 	//	printf("walkDirection(%f,%f,%f)\n",walkDirection[0],walkDirection[1],walkDirection[2]);
 	//	printf("walkSpeed=%f\n",walkSpeed);
@@ -790,7 +790,7 @@ void btKinematicCharacterController::playerStep(btCollisionWorld* collisionWorld
 	//	}
 	//	m_verticalOffset = m_verticalVelocity * dt;
 
-	//	xform = m_ghostObject->getWorldTransform();
+	//	xform = m_ghostObject->m_worldTransform;
 	//}
 
 	if (m_useWalkDirection)
@@ -878,7 +878,7 @@ void btKinematicCharacterController::jump(const btVector3& v)
 
 	m_jumpAxis = v.length2() == 0 ? m_up : v.normalized();
 
-	m_jumpPosition = m_ghostObject->getWorldTransform().m_origin;
+	m_jumpPosition = m_ghostObject->m_worldTransform.m_origin;
 
 #if 0
 	currently no jumping.
@@ -978,7 +978,7 @@ void btKinematicCharacterController::setUpVector(const btVector3& up)
 
 	//set orientation with new up
 	btTransform xform;
-	xform = m_ghostObject->getWorldTransform();
+	xform = m_ghostObject->m_worldTransform;
 	btQuaternion orn = rot.inverse() * xform.getRotation();
 	xform.setRotation(orn);
 	m_ghostObject->setWorldTransform(xform);

3rdparty/bullet3/src/BulletDynamics/ConstraintSolver/btBatchedConstraints.cpp

@@ -114,8 +114,8 @@ static void debugDrawSingleBatch(const btBatchedConstraints* bc,
 			const btSolverConstraint& con = constraints->at(iCon);
 			int iBody0 = con.m_solverBodyIdA;
 			int iBody1 = con.m_solverBodyIdB;
-			btVector3 pos0 = bodies[iBody0].getWorldTransform().m_origin + offset;
-			btVector3 pos1 = bodies[iBody1].getWorldTransform().m_origin + offset;
+			btVector3 pos0 = bodies[iBody0].m_worldTransform.m_origin + offset;
+			btVector3 pos1 = bodies[iBody1].m_worldTransform.m_origin + offset;
 			bc->m_debugDrawer->drawLine(pos0, pos1, color);
 		}
 	}
@@ -153,7 +153,7 @@ static void debugDrawAllBatches(const btBatchedConstraints* bc,
 		btVector3 bboxMax = -bboxMin;
 		for (int iBody = 0; iBody < bodies.size(); ++iBody)
 		{
-			const btVector3& pos = bodies[iBody].getWorldTransform().m_origin;
+			const btVector3& pos = bodies[iBody].m_worldTransform.m_origin;
 			bboxMin.setMin(pos);
 			bboxMax.setMax(pos);
 		}
@@ -872,7 +872,7 @@ static void setupSpatialGridBatchesMt(
 	for (int i = 0; i < bodies.size(); ++i)
 	{
 		const btSolverBody& body = bodies[i];
-		btVector3 bodyPos = body.getWorldTransform().m_origin;
+		btVector3 bodyPos = body.m_worldTransform.m_origin;
 		bool isDynamic = (body.internalGetInvMass().m_floats[0] > btScalar(0));
 		bodyPositions[i] = bodyPos;
 		bodyDynamicFlags[i] = isDynamic;

3rdparty/bullet3/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp

@@ -69,8 +69,8 @@ btScalar resolveSingleCollision(
 
 	const btVector3& normal = contactNormalOnB;
 
-	btVector3 rel_pos1 = contactPositionWorld - body1->getWorldTransform().m_origin;
-	btVector3 rel_pos2 = contactPositionWorld - colObj2->getWorldTransform().m_origin;
+	btVector3 rel_pos1 = contactPositionWorld - body1->m_worldTransform.m_origin;
+	btVector3 rel_pos2 = contactPositionWorld - colObj2->m_worldTransform.m_origin;
 
 	btVector3 vel1 = body1->getVelocityInLocalPoint(rel_pos1);
 	btVector3 vel2 = body2 ? body2->getVelocityInLocalPoint(rel_pos2) : btVector3(0, 0, 0);

3rdparty/bullet3/src/BulletDynamics/ConstraintSolver/btGearConstraint.cpp

@@ -39,8 +39,8 @@ void btGearConstraint::getInfo2(btConstraintInfo2* info)
 {
 	btVector3 globalAxisA, globalAxisB;
 
-	globalAxisA = m_rbA.getWorldTransform().m_basis * this->m_axisInA;
-	globalAxisB = m_rbB.getWorldTransform().m_basis * this->m_axisInB;
+	globalAxisA = m_rbA.m_worldTransform.m_basis * this->m_axisInA;
+	globalAxisB = m_rbB.m_worldTransform.m_basis * this->m_axisInB;
 
 	info->m_J1angularAxis[0] = globalAxisA[0];
 	info->m_J1angularAxis[1] = globalAxisA[1];

3rdparty/bullet3/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp

@@ -467,7 +467,7 @@ void btSequentialImpulseConstraintSolver::initSolverBody(btSolverBody* solverBod
 
 	if (rb)
 	{
-		solverBody->m_worldTransform = rb->getWorldTransform();
+		solverBody->m_worldTransform = rb->m_worldTransform;
 		solverBody->internalSetInvMass(btVector3(rb->getInvMass(), rb->getInvMass(), rb->getInvMass()) * rb->getLinearFactor());
 		solverBody->m_originalBody = rb;
 		solverBody->m_angularFactor = rb->getAngularFactor();
@@ -506,12 +506,12 @@ void btSequentialImpulseConstraintSolver::applyAnisotropicFriction(btCollisionOb
 	if (colObj && colObj->hasAnisotropicFriction(frictionMode))
 	{
 		// transform to local coordinates
-		btVector3 loc_lateral = frictionDirection * colObj->getWorldTransform().m_basis;
-		const btVector3& friction_scaling = colObj->getAnisotropicFriction();
+		btVector3 loc_lateral = frictionDirection * colObj->m_worldTransform.m_basis;
+		const btVector3& friction_scaling = colObj->m_anisotropicFriction;
 		//apply anisotropic friction
 		loc_lateral *= friction_scaling;
 		// ... and transform it back to global coordinates
-		frictionDirection = colObj->getWorldTransform().m_basis * loc_lateral;
+		frictionDirection = colObj->m_worldTransform.m_basis * loc_lateral;
 	}
 }
 
@@ -699,13 +699,13 @@ int btSequentialImpulseConstraintSolver::getOrInitSolverBody(btCollisionObject&
 	{
 		// dynamic body
 		// Dynamic bodies can only be in one island, so it's safe to write to the companionId
-		solverBodyId = body.getCompanionId();
+		solverBodyId = body.m_companionId;
 		if (solverBodyId < 0)
 		{
 			solverBodyId = m_tmpSolverBodyPool.size();
 			btSolverBody& solverBody = m_tmpSolverBodyPool.expand();
 			initSolverBody(&solverBody, &body, timeStep);
-			body.setCompanionId(solverBodyId);
+			body.m_companionId = (solverBodyId);
 		}
 	}
 	else if (isRigidBodyType && isKinematic)
@@ -717,7 +717,7 @@ int btSequentialImpulseConstraintSolver::getOrInitSolverBody(btCollisionObject&
 		// Kinematic bodies can be in multiple islands at once, so it is a
 		// race condition to write to them, so we use an alternate method
 		// to record the solverBodyId
-		int uniqueId = body.getWorldArrayIndex();
+		int uniqueId = body.m_worldArrayIndex;
 		const int INVALID_SOLVER_BODY_ID = -1;
 		if (uniqueId >= m_kinematicBodyUniqueIdToSolverBodyTable.size())
 		{
@@ -736,7 +736,7 @@ int btSequentialImpulseConstraintSolver::getOrInitSolverBody(btCollisionObject&
 	}
 	else
 	{
-		bool isMultiBodyType = (body.getInternalType() & btCollisionObject::CO_FEATHERSTONE_LINK);
+		bool isMultiBodyType = (body.m_internalType & btCollisionObject::CO_FEATHERSTONE_LINK);
 		// Incorrectly set collision object flags can degrade performance in various ways.
 		if (!isMultiBodyType)
 		{
@@ -758,10 +758,10 @@ int btSequentialImpulseConstraintSolver::getOrInitSolverBody(btCollisionObject&
 
 	int solverBodyIdA = -1;
 
-	if (body.getCompanionId() >= 0)
+	if (body.m_companionId >= 0)
 	{
 		//body has already been converted
-		solverBodyIdA = body.getCompanionId();
+		solverBodyIdA = body.m_companionId;
 		btAssert(solverBodyIdA < m_tmpSolverBodyPool.size());
 	}
 	else
@@ -773,7 +773,7 @@ int btSequentialImpulseConstraintSolver::getOrInitSolverBody(btCollisionObject&
 			solverBodyIdA = m_tmpSolverBodyPool.size();
 			btSolverBody& solverBody = m_tmpSolverBodyPool.expand();
 			initSolverBody(&solverBody, &body, timeStep);
-			body.setCompanionId(solverBodyIdA);
+			body.m_companionId = (solverBodyIdA);
 		}
 		else
 		{
@@ -808,10 +808,10 @@ void btSequentialImpulseConstraintSolver::setupContactConstraint(btSolverConstra
 	btRigidBody* rb0 = bodyA->m_originalBody;
 	btRigidBody* rb1 = bodyB->m_originalBody;
 
-	//			btVector3 rel_pos1 = pos1 - colObj0->getWorldTransform().m_origin;
-	//			btVector3 rel_pos2 = pos2 - colObj1->getWorldTransform().m_origin;
-	//rel_pos1 = pos1 - bodyA->getWorldTransform().m_origin;
-	//rel_pos2 = pos2 - bodyB->getWorldTransform().m_origin;
+	//			btVector3 rel_pos1 = pos1 - colObj0->m_worldTransform.m_origin;
+	//			btVector3 rel_pos2 = pos2 - colObj1->m_worldTransform.m_origin;
+	//rel_pos1 = pos1 - bodyA->m_worldTransform.m_origin;
+	//rel_pos2 = pos2 - bodyB->m_worldTransform.m_origin;
 
 	relaxation = infoGlobal.m_sor;
 	btScalar invTimeStep = btScalar(1) / infoGlobal.m_timeStep;
@@ -1037,8 +1037,8 @@ void btSequentialImpulseConstraintSolver::convertContact(btPersistentManifold* m
 			const btVector3& pos1 = cp.getPositionWorldOnA();
 			const btVector3& pos2 = cp.getPositionWorldOnB();
 
-			rel_pos1 = pos1 - colObj0->getWorldTransform().m_origin;
-			rel_pos2 = pos2 - colObj1->getWorldTransform().m_origin;
+			rel_pos1 = pos1 - colObj0->m_worldTransform.m_origin;
+			rel_pos2 = pos2 - colObj1->m_worldTransform.m_origin;
 
 			btVector3 vel1;
 			btVector3 vel2;
@@ -1360,7 +1360,7 @@ void btSequentialImpulseConstraintSolver::convertBodies(btCollisionObject** bodi
 	BT_PROFILE("convertBodies");
 	for (int i = 0; i < numBodies; i++)
 	{
-		bodies[i]->setCompanionId(-1);
+		bodies[i]->m_companionId = (-1);
 	}
 #if BT_THREADSAFE
 	m_kinematicBodyUniqueIdToSolverBodyTable.resize(0);
@@ -1751,7 +1751,7 @@ btScalar btSequentialImpulseConstraintSolver::solveGroupCacheFriendlyIterations(
 				m_analyticsData.m_numIterationsUsed = iteration+1;
 				m_analyticsData.m_islandId = -2;
 				if (numBodies>0)
-					m_analyticsData.m_islandId = bodies[0]->getCompanionId();
+					m_analyticsData.m_islandId = bodies[0]->m_companionId;
 				m_analyticsData.m_numBodies = numBodies;
 				m_analyticsData.m_numContactManifolds = numManifolds;
 				m_analyticsData.m_remainingLeastSquaresResidual = m_leastSquaresResidual;
@@ -1828,7 +1828,7 @@ void btSequentialImpulseConstraintSolver::writeBackBodies(int iBegin, int iEnd,
 			if (infoGlobal.m_splitImpulse)
 				m_tmpSolverBodyPool[i].m_originalBody->setWorldTransform(m_tmpSolverBodyPool[i].m_worldTransform);
 
-			m_tmpSolverBodyPool[i].m_originalBody->setCompanionId(-1);
+			m_tmpSolverBodyPool[i].m_originalBody->m_companionId = (-1);
 		}
 	}
 }

3rdparty/bullet3/src/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.cpp

@@ -84,8 +84,8 @@ void btSequentialImpulseConstraintSolverMt::internalSetupContactConstraints(int
 	const btVector3& pos1 = cp.getPositionWorldOnA();
 	const btVector3& pos2 = cp.getPositionWorldOnB();
 
-	rel_pos1 = pos1 - solverBodyA->getWorldTransform().m_origin;
-	rel_pos2 = pos2 - solverBodyB->getWorldTransform().m_origin;
+	rel_pos1 = pos1 - solverBodyA->m_worldTransform.m_origin;
+	rel_pos2 = pos2 - solverBodyB->m_worldTransform.m_origin;
 
 	btVector3 vel1;
 	btVector3 vel2;
@@ -307,18 +307,18 @@ int btSequentialImpulseConstraintSolverMt::getOrInitSolverBodyThreadsafe(btColli
 	{
 		// dynamic body
 		// Dynamic bodies can only be in one island, so it's safe to write to the companionId
-		solverBodyId = body.getCompanionId();
+		solverBodyId = body.m_companionId;
 		if (solverBodyId < 0)
 		{
 			m_bodySolverArrayMutex.lock();
 			// now that we have the lock, check again
-			solverBodyId = body.getCompanionId();
+			solverBodyId = body.m_companionId;
 			if (solverBodyId < 0)
 			{
 				solverBodyId = m_tmpSolverBodyPool.size();
 				btSolverBody& solverBody = m_tmpSolverBodyPool.expand();
 				initSolverBody(&solverBody, &body, timeStep);
-				body.setCompanionId(solverBodyId);
+				body.m_companionId = (solverBodyId);
 			}
 			m_bodySolverArrayMutex.unlock();
 		}
@@ -332,7 +332,7 @@ int btSequentialImpulseConstraintSolverMt::getOrInitSolverBodyThreadsafe(btColli
 		// Kinematic bodies can be in multiple islands at once, so it is a
 		// race condition to write to them, so we use an alternate method
 		// to record the solverBodyId
-		int uniqueId = body.getWorldArrayIndex();
+		int uniqueId = body.m_worldArrayIndex;
 		const int INVALID_SOLVER_BODY_ID = -1;
 		if (m_kinematicBodyUniqueIdToSolverBodyTable.size() <= uniqueId)
 		{
@@ -750,7 +750,7 @@ void btSequentialImpulseConstraintSolverMt::internalConvertBodies(btCollisionObj
 	for (int i = iBegin; i < iEnd; i++)
 	{
 		btCollisionObject* obj = bodies[i];
-		obj->setCompanionId(i);
+		obj->m_companionId = (i);
 		btSolverBody& solverBody = m_tmpSolverBodyPool[i];
 		initSolverBody(&solverBody, obj, infoGlobal.m_timeStep);
 

3rdparty/bullet3/src/BulletDynamics/ConstraintSolver/btSolverBody.h

@@ -4,8 +4,8 @@ Copyright (c) 2003-2006 Erwin Coumans  https://bulletphysics.org
 
 This software is provided 'as-is', without any express or implied warranty.
 In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
 subject to the following restrictions:
 
 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
@@ -256,7 +256,7 @@ btSolverBody
 			m_linearVelocity += m_deltaLinearVelocity;
 			m_angularVelocity += m_deltaAngularVelocity;
 
-			//m_originalBody->setCompanionId(-1);
+			//m_originalBody->m_companionId = (-1);
 		}
 	}
 
@@ -277,7 +277,7 @@ btSolverBody
 				m_worldTransform = newTransform;
 			}
 			//m_worldTransform.setRotation(orn);
-			//m_originalBody->setCompanionId(-1);
+			//m_originalBody->m_companionId = (-1);
 		}
 	}
 };

3rdparty/bullet3/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp

@@ -59,7 +59,7 @@ SIMD_FORCE_INLINE int btGetConstraintIslandId(const btTypedConstraint* lhs)
 
 	const btCollisionObject& rcolObj0 = lhs->getRigidBodyA();
 	const btCollisionObject& rcolObj1 = lhs->getRigidBodyB();
-	islandId = rcolObj0.getIslandTag() >= 0 ? rcolObj0.getIslandTag() : rcolObj1.getIslandTag();
+	islandId = rcolObj0.m_islandTag1 >= 0 ? rcolObj0.m_islandTag1 : rcolObj1.m_islandTag1;
 	return islandId;
 }
 
@@ -255,7 +255,7 @@ void btDiscreteDynamicsWorld::saveKinematicState(btScalar timeStep)
 	{
 		btCollisionObject* colObj = m_collisionObjects[i];
 		btRigidBody* body = btRigidBody::upcast(colObj);
-		if (body && body->getActivationState() != ISLAND_SLEEPING)
+		if (body && body->m_activationState1 != ISLAND_SLEEPING)
 		{
 			if (body->isKinematicObject())
 			{
@@ -341,12 +341,12 @@ void btDiscreteDynamicsWorld::synchronizeSingleMotionState(btRigidBody* body)
 		//we need to call the update at least once, even for sleeping objects
 		//otherwise the 'graphics' transform never updates properly
 		///@todo: add 'dirty' flag
-		//if (body->getActivationState() != ISLAND_SLEEPING)
+		//if (body->m_activationState1 != ISLAND_SLEEPING)
 		{
 			btTransform interpolatedTransform;
-			btTransformUtil::integrateTransform(body->getInterpolationWorldTransform(),
-												body->getInterpolationLinearVelocity(), body->getInterpolationAngularVelocity(),
-												(m_latencyMotionStateInterpolation && m_fixedTimeStep) ? m_localTime - m_fixedTimeStep : m_localTime * body->getHitFraction(),
+			btTransformUtil::integrateTransform(body->m_interpolationWorldTransform,
+												body->m_interpolationLinearVelocity, body->m_interpolationAngularVelocity,
+												(m_latencyMotionStateInterpolation && m_fixedTimeStep) ? m_localTime - m_fixedTimeStep : m_localTime * body->m_hitFraction,
 												interpolatedTransform);
 			body->getMotionState()->setWorldTransform(interpolatedTransform);
 		}
@@ -541,7 +541,7 @@ void btDiscreteDynamicsWorld::addRigidBody(btRigidBody* body)
 		body->setGravity(m_gravity);
 	}
 
-	if (body->getCollisionShape())
+	if (body->m_collisionShape)
 	{
 		if (!body->isStaticObject())
 		{
@@ -567,7 +567,7 @@ void btDiscreteDynamicsWorld::addRigidBody(btRigidBody* body, int group, int mas
 		body->setGravity(m_gravity);
 	}
 
-	if (body->getCollisionShape())
+	if (body->m_collisionShape)
 	{
 		if (!body->isStaticObject())
 		{
@@ -610,9 +610,9 @@ void btDiscreteDynamicsWorld::updateActivationState(btScalar timeStep)
 				}
 				else
 				{
-					if (body->getActivationState() == ACTIVE_TAG)
+					if (body->m_activationState1 == ACTIVE_TAG)
 						body->setActivationState(WANTS_DEACTIVATION);
-					if (body->getActivationState() == ISLAND_SLEEPING)
+					if (body->m_activationState1 == ISLAND_SLEEPING)
 					{
 						body->setAngularVelocity(btVector3(0, 0, 0));
 						body->setLinearVelocity(btVector3(0, 0, 0));
@@ -621,7 +621,7 @@ void btDiscreteDynamicsWorld::updateActivationState(btScalar timeStep)
 			}
 			else
 			{
-				if (body->getActivationState() != DISABLE_DEACTIVATION)
+				if (body->m_activationState1 != DISABLE_DEACTIVATION)
 					body->setActivationState(ACTIVE_TAG);
 			}
 		}
@@ -724,7 +724,7 @@ void btDiscreteDynamicsWorld::calculateSimulationIslands()
 			if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
 				((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
 			{
-				getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(), (colObj1)->getIslandTag());
+				getSimulationIslandManager()->getUnionFind().unite((colObj0)->m_islandTag1, (colObj1)->m_islandTag1);
 			}
 		}
 	}
@@ -743,7 +743,7 @@ void btDiscreteDynamicsWorld::calculateSimulationIslands()
 				if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
 					((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
 				{
-					getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(), (colObj1)->getIslandTag());
+					getSimulationIslandManager()->getUnionFind().unite((colObj0)->m_islandTag1, (colObj1)->m_islandTag1);
 				}
 			}
 		}
@@ -801,7 +801,7 @@ public:
 		if (!ClosestConvexResultCallback::needsCollision(proxy0))
 			return false;
 		if (m_pairCache->getOverlapFilterCallback()) {
-			btBroadphaseProxy* proxy1 = m_me->getBroadphaseHandle();
+			btBroadphaseProxy* proxy1 = m_me->m_broadphaseHandle;
 			bool collides = m_pairCache->needsBroadphaseCollision(proxy0, proxy1);
 			if (!collides)
 			{
@@ -820,7 +820,7 @@ public:
 #if 0
 			///don't do CCD when there are already contact points (touching contact/penetration)
 			btAlignedObjectArray<btPersistentManifold*> manifoldArray;
-			btBroadphasePair* collisionPair = m_pairCache->findPair(m_me->getBroadphaseHandle(),proxy0);
+			btBroadphasePair* collisionPair = m_pairCache->findPair(m_me->m_broadphaseHandle,proxy0);
 			if (collisionPair)
 			{
 				if (collisionPair->m_algorithm)
@@ -852,18 +852,18 @@ void btDiscreteDynamicsWorld::createPredictiveContactsInternal(btRigidBody** bod
 	for (int i = 0; i < numBodies; i++)
 	{
 		btRigidBody* body = bodies[i];
-		body->setHitFraction(1.f);
+		body->m_hitFraction = (1.f);
 
 		if (body->isActive() && (!body->isStaticOrKinematicObject()))
 		{
 			body->predictIntegratedTransform(timeStep, predictedTrans);
 
-			btScalar squareMotion = (predictedTrans.m_origin - body->getWorldTransform().m_origin).length2();
+			btScalar squareMotion = (predictedTrans.m_origin - body->m_worldTransform.m_origin).length2();
 
 			if (getDispatchInfo().m_useContinuous && body->getCcdSquareMotionThreshold() && body->getCcdSquareMotionThreshold() < squareMotion)
 			{
 				BT_PROFILE("predictive convexSweepTest");
-				if (body->getCollisionShape()->isConvex())
+				if (body->m_collisionShape->isConvex())
 				{
 					gNumClampedCcdMotions++;
 #ifdef PREDICTIVE_CONTACT_USE_STATIC_ONLY
@@ -883,23 +883,23 @@ void btDiscreteDynamicsWorld::createPredictiveContactsInternal(btRigidBody** bod
 						}
 					};
 
-					StaticOnlyCallback sweepResults(body, body->getWorldTransform().m_origin, predictedTrans.m_origin, getBroadphase()->getOverlappingPairCache(), getDispatcher());
+					StaticOnlyCallback sweepResults(body, body->m_worldTransform.m_origin, predictedTrans.m_origin, getBroadphase()->getOverlappingPairCache(), getDispatcher());
 #else
-					btClosestNotMeConvexResultCallback sweepResults(body, body->getWorldTransform().m_origin, predictedTrans.m_origin, getBroadphase()->getOverlappingPairCache(), getDispatcher());
+					btClosestNotMeConvexResultCallback sweepResults(body, body->m_worldTransform.m_origin, predictedTrans.m_origin, getBroadphase()->getOverlappingPairCache(), getDispatcher());
 #endif
-					//btConvexShape* convexShape = static_cast<btConvexShape*>(body->getCollisionShape());
-					btSphereShape tmpSphere(body->getCcdSweptSphereRadius());  //btConvexShape* convexShape = static_cast<btConvexShape*>(body->getCollisionShape());
+					//btConvexShape* convexShape = static_cast<btConvexShape*>(body->m_collisionShape);
+					btSphereShape tmpSphere(body->m_ccdSweptSphereRadius);  //btConvexShape* convexShape = static_cast<btConvexShape*>(body->m_collisionShape);
 					sweepResults.m_allowedPenetration = getDispatchInfo().m_allowedCcdPenetration;
 
 					sweepResults.m_collisionFilterGroup = body->getBroadphaseProxy()->m_collisionFilterGroup;
 					sweepResults.m_collisionFilterMask = body->getBroadphaseProxy()->m_collisionFilterMask;
 					btTransform modifiedPredictedTrans = predictedTrans;
-					modifiedPredictedTrans.m_basis = (body->getWorldTransform().m_basis);
+					modifiedPredictedTrans.m_basis = (body->m_worldTransform.m_basis);
 
-					convexSweepTest(&tmpSphere, body->getWorldTransform(), modifiedPredictedTrans, sweepResults);
+					convexSweepTest(&tmpSphere, body->m_worldTransform, modifiedPredictedTrans, sweepResults);
 					if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
 					{
-						btVector3 distVec = (predictedTrans.m_origin - body->getWorldTransform().m_origin) * sweepResults.m_closestHitFraction;
+						btVector3 distVec = (predictedTrans.m_origin - body->m_worldTransform.m_origin) * sweepResults.m_closestHitFraction;
 						btScalar distance = distVec.dot(-sweepResults.m_hitNormalWorld);
 
 						btMutexLock(&m_predictiveManifoldsMutex);
@@ -907,8 +907,8 @@ void btDiscreteDynamicsWorld::createPredictiveContactsInternal(btRigidBody** bod
 						m_predictiveManifolds.push_back(manifold);
 						btMutexUnlock(&m_predictiveManifoldsMutex);
 
-						btVector3 worldPointB = body->getWorldTransform().m_origin + distVec;
-						btVector3 localPointB = sweepResults.m_hitCollisionObject->getWorldTransform().inverse() * worldPointB;
+						btVector3 worldPointB = body->m_worldTransform.m_origin + distVec;
+						btVector3 localPointB = sweepResults.m_hitCollisionObject->m_worldTransform.inverse() * worldPointB;
 
 						btManifoldPoint newPoint(btVector3(0, 0, 0), localPointB, sweepResults.m_hitNormalWorld, distance);
 
@@ -917,7 +917,7 @@ void btDiscreteDynamicsWorld::createPredictiveContactsInternal(btRigidBody** bod
 						btManifoldPoint& pt = manifold->getContactPoint(index);
 						pt.m_combinedRestitution = 0;
 						pt.m_combinedFriction = gCalculateCombinedFrictionCallback(body, sweepResults.m_hitCollisionObject);
-						pt.m_positionWorldOnA = body->getWorldTransform().m_origin;
+						pt.m_positionWorldOnA = body->m_worldTransform.m_origin;
 						pt.m_positionWorldOnB = worldPointB;
 					}
 				}
@@ -954,18 +954,18 @@ void btDiscreteDynamicsWorld::integrateTransformsInternal(btRigidBody** bodies,
 	for (int i = 0; i < numBodies; i++)
 	{
 		btRigidBody* body = bodies[i];
-		body->setHitFraction(1.f);
+		body->m_hitFraction = (1.f);
 
 		if (body->isActive() && (!body->isStaticOrKinematicObject()))
 		{
 			body->predictIntegratedTransform(timeStep, predictedTrans);
 
-			btScalar squareMotion = (predictedTrans.m_origin - body->getWorldTransform().m_origin).length2();
+			btScalar squareMotion = (predictedTrans.m_origin - body->m_worldTransform.m_origin).length2();
 
 			if (getDispatchInfo().m_useContinuous && body->getCcdSquareMotionThreshold() && body->getCcdSquareMotionThreshold() < squareMotion)
 			{
 				BT_PROFILE("CCD motion clamping");
-				if (body->getCollisionShape()->isConvex())
+				if (body->m_collisionShape->isConvex())
 				{
 					gNumClampedCcdMotions++;
 #ifdef USE_STATIC_ONLY
@@ -985,26 +985,26 @@ void btDiscreteDynamicsWorld::integrateTransformsInternal(btRigidBody** bodies,
 						}
 					};
 
-					StaticOnlyCallback sweepResults(body, body->getWorldTransform().m_origin, predictedTrans.m_origin, getBroadphase()->getOverlappingPairCache(), getDispatcher());
+					StaticOnlyCallback sweepResults(body, body->m_worldTransform.m_origin, predictedTrans.m_origin, getBroadphase()->getOverlappingPairCache(), getDispatcher());
 #else
-					btClosestNotMeConvexResultCallback sweepResults(body, body->getWorldTransform().m_origin, predictedTrans.m_origin, getBroadphase()->getOverlappingPairCache(), getDispatcher());
+					btClosestNotMeConvexResultCallback sweepResults(body, body->m_worldTransform.m_origin, predictedTrans.m_origin, getBroadphase()->getOverlappingPairCache(), getDispatcher());
 #endif
-					//btConvexShape* convexShape = static_cast<btConvexShape*>(body->getCollisionShape());
-					btSphereShape tmpSphere(body->getCcdSweptSphereRadius());  //btConvexShape* convexShape = static_cast<btConvexShape*>(body->getCollisionShape());
+					//btConvexShape* convexShape = static_cast<btConvexShape*>(body->m_collisionShape);
+					btSphereShape tmpSphere(body->m_ccdSweptSphereRadius);  //btConvexShape* convexShape = static_cast<btConvexShape*>(body->m_collisionShape);
 					sweepResults.m_allowedPenetration = getDispatchInfo().m_allowedCcdPenetration;
 
 					sweepResults.m_collisionFilterGroup = body->getBroadphaseProxy()->m_collisionFilterGroup;
 					sweepResults.m_collisionFilterMask = body->getBroadphaseProxy()->m_collisionFilterMask;
 					btTransform modifiedPredictedTrans = predictedTrans;
-					modifiedPredictedTrans.m_basis = (body->getWorldTransform().m_basis);
+					modifiedPredictedTrans.m_basis = (body->m_worldTransform.m_basis);
 
-					convexSweepTest(&tmpSphere, body->getWorldTransform(), modifiedPredictedTrans, sweepResults);
+					convexSweepTest(&tmpSphere, body->m_worldTransform, modifiedPredictedTrans, sweepResults);
 					if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
 					{
 						//printf("clamped integration to hit fraction = %f\n",fraction);
-						body->setHitFraction(sweepResults.m_closestHitFraction);
-						body->predictIntegratedTransform(timeStep * body->getHitFraction(), predictedTrans);
-						body->setHitFraction(0.f);
+						body->m_hitFraction = (sweepResults.m_closestHitFraction);
+						body->predictIntegratedTransform(timeStep * body->m_hitFraction, predictedTrans);
+						body->m_hitFraction = (0.f);
 						body->proceedToTransform(predictedTrans);
 
 #if 0
@@ -1020,7 +1020,7 @@ void btDiscreteDynamicsWorld::integrateTransformsInternal(btRigidBody** bodies,
 							btScalar ms2 = body->getLinearVelocity().length2();
 							body->predictIntegratedTransform(timeStep, predictedTrans);
 
-							btScalar sm2 = (predictedTrans.m_origin-body->getWorldTransform().m_origin).length2();
+							btScalar sm2 = (predictedTrans.m_origin-body->m_worldTransform.m_origin).length2();
 							btScalar smt = body->getCcdSquareMotionThreshold();
 							printf("sm2=%f\n",sm2);
 						}
@@ -1075,8 +1075,8 @@ void btDiscreteDynamicsWorld::integrateTransforms(btScalar timeStep)
 					const btVector3& pos1 = pt.getPositionWorldOnA();
 					const btVector3& pos2 = pt.getPositionWorldOnB();
 
-					btVector3 rel_pos0 = pos1 - body0->getWorldTransform().m_origin;
-					btVector3 rel_pos1 = pos2 - body1->getWorldTransform().m_origin;
+					btVector3 rel_pos0 = pos1 - body0->m_worldTransform.m_origin;
+					btVector3 rel_pos1 = pos2 - body1->m_worldTransform.m_origin;
 
 					if (body0)
 						body0->applyImpulse(imp, rel_pos0);
@@ -1100,7 +1100,7 @@ void btDiscreteDynamicsWorld::predictUnconstraintMotion(btScalar timeStep)
 
 			body->applyDamping(timeStep);
 
-			body->predictIntegratedTransform(timeStep, body->getInterpolationWorldTransform());
+			body->predictIntegratedTransform(timeStep, body->m_interpolationWorldTransform);
 		}
 	}
 }
@@ -1383,7 +1383,7 @@ void btDiscreteDynamicsWorld::serializeRigidBodies(btSerializer* serializer)
 	for (i = 0; i < m_collisionObjects.size(); i++)
 	{
 		btCollisionObject* colObj = m_collisionObjects[i];
-		if (colObj->getInternalType() & btCollisionObject::CO_RIGID_BODY)
+		if (colObj->m_internalType & btCollisionObject::CO_RIGID_BODY)
 		{
 			int len = colObj->calculateSerializeBufferSize();
 			btChunk* chunk = serializer->allocate(len, 1);

3rdparty/bullet3/src/BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.cpp

@@ -203,7 +203,7 @@ struct UpdaterUnconstrainedMotion : public btIParallelForBody
 			{
 				//don't integrate/update velocities here, it happens in the constraint solver
 				body->applyDamping(timeStep);
-				body->predictIntegratedTransform(timeStep, body->getInterpolationWorldTransform());
+				body->predictIntegratedTransform(timeStep, body->m_interpolationWorldTransform);
 			}
 		}
 	}

3rdparty/bullet3/src/BulletDynamics/Dynamics/btRigidBody.cpp

@@ -122,7 +122,7 @@ void btRigidBody::saveKinematicState(btScalar timeStep)
 
 void btRigidBody::getAabb(btVector3& aabbMin, btVector3& aabbMax) const
 {
-	getCollisionShape()->getAabb(m_worldTransform, aabbMin, aabbMax);
+	m_collisionShape->getAabb(m_worldTransform, aabbMin, aabbMax);
 }
 
 void btRigidBody::setGravity(const btVector3& acceleration)
@@ -283,7 +283,7 @@ inline btMatrix3x3 evalEulerEqnDeriv(const btVector3& w1, const btVector3& w0, c
 btVector3 btRigidBody::computeGyroscopicForceExplicit(btScalar maxGyroscopicForce) const
 {
 	btVector3 inertiaLocal = getLocalInertia();
-	btMatrix3x3 inertiaTensorWorld = getWorldTransform().m_basis.scaled(inertiaLocal) * getWorldTransform().m_basis.transpose();
+	btMatrix3x3 inertiaTensorWorld = m_worldTransform.m_basis.scaled(inertiaLocal) * m_worldTransform.m_basis.transpose();
 	btVector3 tmp = inertiaTensorWorld * getAngularVelocity();
 	btVector3 gf = getAngularVelocity().cross(tmp);
 	btScalar l2 = gf.length2();
@@ -298,7 +298,7 @@ btVector3 btRigidBody::computeGyroscopicImpulseImplicit_Body(btScalar step) cons
 {
 	btVector3 idl = getLocalInertia();
 	btVector3 omega1 = getAngularVelocity();
-	btQuaternion q = getWorldTransform().getRotation();
+	btQuaternion q = m_worldTransform.getRotation();
 
 	// Convert to body coordinates
 	btVector3 omegab = quatRotate(q.inverse(), omega1);

3rdparty/bullet3/src/BulletDynamics/Dynamics/btRigidBody.h

@@ -4,8 +4,8 @@ Copyright (c) 2003-2006 Erwin Coumans  https://bulletphysics.org
 
 This software is provided 'as-is', without any express or implied warranty.
 In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
 subject to the following restrictions:
 
 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
@@ -188,13 +188,13 @@ public:
 	///but a rigidbody is derived from btCollisionObject, so we can safely perform an upcast
 	static const btRigidBody* upcast(const btCollisionObject* colObj)
 	{
-		if (colObj->getInternalType() & btCollisionObject::CO_RIGID_BODY)
+		if (colObj->m_internalType & btCollisionObject::CO_RIGID_BODY)
 			return (const btRigidBody*)colObj;
 		return 0;
 	}
 	static btRigidBody* upcast(btCollisionObject* colObj)
 	{
-		if (colObj->getInternalType() & btCollisionObject::CO_RIGID_BODY)
+		if (colObj->m_internalType & btCollisionObject::CO_RIGID_BODY)
 			return (btRigidBody*)colObj;
 		return 0;
 	}
@@ -205,7 +205,7 @@ public:
 	void saveKinematicState(btScalar step);
 
 	void applyGravity();
-    
+
     void clearGravity();
 
 	void setGravity(const btVector3& acceleration);
@@ -343,7 +343,7 @@ public:
 			}
 		}
 	}
-    
+
     void applyPushImpulse(const btVector3& impulse, const btVector3& rel_pos)
     {
         if (m_inverseMass != btScalar(0.))
@@ -355,17 +355,17 @@ public:
             }
         }
     }
-    
+
     btVector3 getPushVelocity() const
     {
         return m_pushVelocity;
     }
-    
+
     btVector3 getTurnVelocity() const
     {
         return m_turnVelocity;
     }
-    
+
     void setPushVelocity(const btVector3& v)
     {
         m_pushVelocity = v;
@@ -395,7 +395,7 @@ public:
         clampVelocity(m_turnVelocity);
         #endif
     }
-    
+
     void applyCentralPushImpulse(const btVector3& impulse)
     {
         m_pushVelocity += impulse * m_linearFactor * m_inverseMass;
@@ -403,7 +403,7 @@ public:
         clampVelocity(m_pushVelocity);
         #endif
     }
-    
+
     void applyTorqueTurnImpulse(const btVector3& torque)
     {
         m_turnVelocity += m_invInertiaTensorWorld * torque * m_angularFactor;
@@ -465,7 +465,7 @@ public:
 		//for kinematic objects, we could also use use:
 		//		return 	(m_worldTransform(rel_pos) - m_interpolationWorldTransform(rel_pos)) / m_kinematicTimeStep;
 	}
-    
+
     btVector3 getPushVelocityInLocalPoint(const btVector3& rel_pos) const
     {
         //we also calculate lin/ang velocity for kinematic objects
@@ -498,7 +498,7 @@ public:
 
 	SIMD_FORCE_INLINE void updateDeactivation(btScalar timeStep)
 	{
-		if ((getActivationState() == ISLAND_SLEEPING) || (getActivationState() == DISABLE_DEACTIVATION))
+		if ((m_activationState1 == ISLAND_SLEEPING) || (m_activationState1 == DISABLE_DEACTIVATION))
 			return;
 
 		if ((getLinearVelocity().length2() < m_linearSleepingThreshold * m_linearSleepingThreshold) &&
@@ -515,14 +515,14 @@ public:
 
 	SIMD_FORCE_INLINE bool wantsSleeping()
 	{
-		if (getActivationState() == DISABLE_DEACTIVATION)
+		if (m_activationState1 == DISABLE_DEACTIVATION)
 			return false;
 
 		//disable deactivation
 		if (gDisableDeactivation || (gDeactivationTime == btScalar(0.)))
 			return false;
 
-		if ((getActivationState() == ISLAND_SLEEPING) || (getActivationState() == WANTS_DEACTIVATION))
+		if ((m_activationState1 == ISLAND_SLEEPING) || (m_activationState1 == WANTS_DEACTIVATION))
 			return true;
 
 		if (m_deactivationTime > gDeactivationTime)

3rdparty/bullet3/src/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp

@@ -139,7 +139,7 @@ void btSimpleDynamicsWorld::addRigidBody(btRigidBody* body)
 {
 	body->setGravity(m_gravity);
 
-	if (body->getCollisionShape())
+	if (body->m_collisionShape)
 	{
 		addCollisionObject(body);
 	}
@@ -149,7 +149,7 @@ void btSimpleDynamicsWorld::addRigidBody(btRigidBody* body, int group, int mask)
 {
 	body->setGravity(m_gravity);
 
-	if (body->getCollisionShape())
+	if (body->m_collisionShape)
 	{
 		addCollisionObject(body, group, mask);
 	}
@@ -179,9 +179,9 @@ void btSimpleDynamicsWorld::updateAabbs()
 			if (body->isActive() && (!body->isStaticObject()))
 			{
 				btVector3 minAabb, maxAabb;
-				colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb, maxAabb);
+				colObj->m_collisionShape->getAabb(colObj->m_worldTransform, minAabb, maxAabb);
 				btBroadphaseInterface* bp = getBroadphase();
-				bp->setAabb(body->getBroadphaseHandle(), minAabb, maxAabb, m_dispatcher1);
+				bp->setAabb(body->m_broadphaseHandle, minAabb, maxAabb, m_dispatcher1);
 			}
 		}
 	}
@@ -220,7 +220,7 @@ void btSimpleDynamicsWorld::predictUnconstraintMotion(btScalar timeStep)
 					body->applyGravity();
 					body->integrateVelocities(timeStep);
 					body->applyDamping(timeStep);
-					body->predictIntegratedTransform(timeStep, body->getInterpolationWorldTransform());
+					body->predictIntegratedTransform(timeStep, body->m_interpolationWorldTransform);
 				}
 			}
 		}
@@ -236,9 +236,9 @@ void btSimpleDynamicsWorld::synchronizeMotionStates()
 		btRigidBody* body = btRigidBody::upcast(colObj);
 		if (body && body->getMotionState())
 		{
-			if (body->getActivationState() != ISLAND_SLEEPING)
+			if (body->m_activationState1 != ISLAND_SLEEPING)
 			{
-				body->getMotionState()->setWorldTransform(body->getWorldTransform());
+				body->getMotionState()->setWorldTransform(body->m_worldTransform);
 			}
 		}
 	}

3rdparty/bullet3/src/BulletDynamics/Dynamics/btSimulationIslandManagerMt.cpp

@@ -61,7 +61,7 @@ inline int getIslandId(const btPersistentManifold* lhs)
 {
 	const btCollisionObject* rcolObj0 = static_cast<const btCollisionObject*>(lhs->getBody0());
 	const btCollisionObject* rcolObj1 = static_cast<const btCollisionObject*>(lhs->getBody1());
-	int islandId = rcolObj0->getIslandTag() >= 0 ? rcolObj0->getIslandTag() : rcolObj1->getIslandTag();
+	int islandId = rcolObj0->m_islandTag1 >= 0 ? rcolObj0->m_islandTag1 : rcolObj1->m_islandTag1;
 	return islandId;
 }
 
@@ -69,7 +69,7 @@ SIMD_FORCE_INLINE int btGetConstraintIslandId1(const btTypedConstraint* lhs)
 {
 	const btCollisionObject& rcolObj0 = lhs->getRigidBodyA();
 	const btCollisionObject& rcolObj1 = lhs->getRigidBodyB();
-	int islandId = rcolObj0.getIslandTag() >= 0 ? rcolObj0.getIslandTag() : rcolObj1.getIslandTag();
+	int islandId = rcolObj0.m_islandTag1 >= 0 ? rcolObj0.m_islandTag1 : rcolObj1.m_islandTag1;
 	return islandId;
 }
 
@@ -294,16 +294,16 @@ void btSimulationIslandManagerMt::buildIslands(btDispatcher* dispatcher, btColli
 			int i = getUnionFind().getElement(idx).m_sz;
 
 			btCollisionObject* colObj0 = collisionObjects[i];
-			if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1))
+			if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
 			{
 				//				printf("error in island management\n");
 			}
 
-			btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
-			if (colObj0->getIslandTag() == islandId)
+			btAssert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
+			if (colObj0->m_islandTag1 == islandId)
 			{
-				if (colObj0->getActivationState() == ACTIVE_TAG ||
-					colObj0->getActivationState() == DISABLE_DEACTIVATION)
+				if (colObj0->m_activationState1 == ACTIVE_TAG ||
+					colObj0->m_activationState1 == DISABLE_DEACTIVATION)
 				{
 					allSleeping = false;
 					break;
@@ -318,14 +318,14 @@ void btSimulationIslandManagerMt::buildIslands(btDispatcher* dispatcher, btColli
 			{
 				int i = getUnionFind().getElement(idx).m_sz;
 				btCollisionObject* colObj0 = collisionObjects[i];
-				if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1))
+				if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
 				{
 					//					printf("error in island management\n");
 				}
 
-				btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
+				btAssert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
 
-				if (colObj0->getIslandTag() == islandId)
+				if (colObj0->m_islandTag1 == islandId)
 				{
 					colObj0->setActivationState(ISLAND_SLEEPING);
 				}
@@ -339,19 +339,19 @@ void btSimulationIslandManagerMt::buildIslands(btDispatcher* dispatcher, btColli
 				int i = getUnionFind().getElement(idx).m_sz;
 
 				btCollisionObject* colObj0 = collisionObjects[i];
-				if ((colObj0->getIslandTag() != islandId) && (colObj0->getIslandTag() != -1))
+				if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
 				{
 					//					printf("error in island management\n");
 				}
 
-				btAssert((colObj0->getIslandTag() == islandId) || (colObj0->getIslandTag() == -1));
+				btAssert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
 
-				if (colObj0->getIslandTag() == islandId)
+				if (colObj0->m_islandTag1 == islandId)
 				{
-					if (colObj0->getActivationState() == ISLAND_SLEEPING)
+					if (colObj0->m_activationState1 == ISLAND_SLEEPING)
 					{
 						colObj0->setActivationState(WANTS_DEACTIVATION);
-						colObj0->setDeactivationTime(0.f);
+						colObj0->m_deactivationTime = (0.f);
 					}
 				}
 			}
@@ -416,16 +416,16 @@ void btSimulationIslandManagerMt::addManifoldsToIslands(btDispatcher* dispatcher
 		const btCollisionObject* colObj1 = static_cast<const btCollisionObject*>(manifold->getBody1());
 
 		///@todo: check sleeping conditions!
-		if (((colObj0) && colObj0->getActivationState() != ISLAND_SLEEPING) ||
-			((colObj1) && colObj1->getActivationState() != ISLAND_SLEEPING))
+		if (((colObj0) && colObj0->m_activationState1 != ISLAND_SLEEPING) ||
+			((colObj1) && colObj1->m_activationState1 != ISLAND_SLEEPING))
 		{
 			//kinematic objects don't merge islands, but wake up all connected objects
-			if (colObj0->isKinematicObject() && colObj0->getActivationState() != ISLAND_SLEEPING)
+			if (colObj0->isKinematicObject() && colObj0->m_activationState1 != ISLAND_SLEEPING)
 			{
 				if (colObj0->hasContactResponse())
 					colObj1->activate();
 			}
-			if (colObj1->isKinematicObject() && colObj1->getActivationState() != ISLAND_SLEEPING)
+			if (colObj1->isKinematicObject() && colObj1->m_activationState1 != ISLAND_SLEEPING)
 			{
 				if (colObj1->hasContactResponse())
 					colObj0->activate();
@@ -645,16 +645,16 @@ void btSimulationIslandManagerMt::buildAndProcessIslands(btDispatcher* dispatche
 			const btCollisionObject* colObj1 = static_cast<const btCollisionObject*>(manifold->getBody1());
 
 			///@todo: check sleeping conditions!
-			if (((colObj0) && colObj0->getActivationState() != ISLAND_SLEEPING) ||
-				((colObj1) && colObj1->getActivationState() != ISLAND_SLEEPING))
+			if (((colObj0) && colObj0->m_activationState1 != ISLAND_SLEEPING) ||
+				((colObj1) && colObj1->m_activationState1 != ISLAND_SLEEPING))
 			{
 				//kinematic objects don't merge islands, but wake up all connected objects
-				if (colObj0->isKinematicObject() && colObj0->getActivationState() != ISLAND_SLEEPING)
+				if (colObj0->isKinematicObject() && colObj0->m_activationState1 != ISLAND_SLEEPING)
 				{
 					if (colObj0->hasContactResponse())
 						colObj1->activate();
 				}
-				if (colObj1->isKinematicObject() && colObj1->getActivationState() != ISLAND_SLEEPING)
+				if (colObj1->isKinematicObject() && colObj1->m_activationState1 != ISLAND_SLEEPING)
 				{
 					if (colObj1->hasContactResponse())
 						colObj0->activate();

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBody.cpp

@@ -695,9 +695,9 @@ bool btMultiBody::isBaseKinematic() const
 void btMultiBody::setBaseDynamicType(int dynamicType)
 {
 	if(getBaseCollider()) {
-		int oldFlags = getBaseCollider()->getCollisionFlags();
+		int oldFlags = getBaseCollider()->m_collisionFlags;
 		oldFlags &= ~(btCollisionObject::CF_STATIC_OBJECT | btCollisionObject::CF_KINEMATIC_OBJECT);
-		getBaseCollider()->setCollisionFlags(oldFlags | dynamicType);
+		getBaseCollider()->m_collisionFlags = (oldFlags | dynamicType);
 	}
 }
 

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBody.h

@@ -577,7 +577,7 @@ public:
 	}
 	void setCompanionId(int id)
 	{
-		//printf("for %p setCompanionId(%d)\n",this, id);
+		//printf("for %p m_companionId = (%d)\n",this, id);
 		m_companionId = id;
 	}
 

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.cpp

@@ -57,7 +57,7 @@ void btMultiBodyDynamicsWorld::calculateSimulationIslands()
 			if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
 				((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
 			{
-				getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(), (colObj1)->getIslandTag());
+				getSimulationIslandManager()->getUnionFind().unite((colObj0)->m_islandTag1, (colObj1)->m_islandTag1);
 			}
 		}
 	}
@@ -76,7 +76,7 @@ void btMultiBodyDynamicsWorld::calculateSimulationIslands()
 				if (((colObj0) && (!(colObj0)->isStaticOrKinematicObject())) &&
 					((colObj1) && (!(colObj1)->isStaticOrKinematicObject())))
 				{
-					getSimulationIslandManager()->getUnionFind().unite((colObj0)->getIslandTag(), (colObj1)->getIslandTag());
+					getSimulationIslandManager()->getUnionFind().unite((colObj0)->m_islandTag1, (colObj1)->m_islandTag1);
 				}
 			}
 		}
@@ -96,8 +96,8 @@ void btMultiBodyDynamicsWorld::calculateSimulationIslands()
 				if (((cur) && (!(cur)->isStaticOrKinematicObject())) &&
 					((prev) && (!(prev)->isStaticOrKinematicObject())))
 				{
-					int tagPrev = prev->getIslandTag();
-					int tagCur = cur->getIslandTag();
+					int tagPrev = prev->m_islandTag1;
+					int tagCur = cur->m_islandTag1;
 					getSimulationIslandManager()->getUnionFind().unite(tagPrev, tagCur);
 				}
 				if (cur && !cur->isStaticOrKinematicObject())
@@ -135,7 +135,7 @@ void btMultiBodyDynamicsWorld::updateActivationState(btScalar timeStep)
 			if (!body->isAwake())
 			{
 				btMultiBodyLinkCollider* col = body->getBaseCollider();
-				if (col && col->getActivationState() == ACTIVE_TAG)
+				if (col && col->m_activationState1 == ACTIVE_TAG)
 				{
                     if (body->hasFixedBase())
 					{
@@ -145,28 +145,28 @@ void btMultiBodyDynamicsWorld::updateActivationState(btScalar timeStep)
                         col->setActivationState(WANTS_DEACTIVATION);
                     }
 					
-					col->setDeactivationTime(0.f);
+					col->m_deactivationTime = (0.f);
 				}
 				for (int b = 0; b < body->getNumLinks(); b++)
 				{
 					btMultiBodyLinkCollider* col = body->getLink(b).m_collider;
-					if (col && col->getActivationState() == ACTIVE_TAG)
+					if (col && col->m_activationState1 == ACTIVE_TAG)
 					{
 						col->setActivationState(WANTS_DEACTIVATION);
-						col->setDeactivationTime(0.f);
+						col->m_deactivationTime = (0.f);
 					}
 				}
 			}
 			else
 			{
 				btMultiBodyLinkCollider* col = body->getBaseCollider();
-				if (col && col->getActivationState() != DISABLE_DEACTIVATION)
+				if (col && col->m_activationState1 != DISABLE_DEACTIVATION)
 					col->setActivationState(ACTIVE_TAG);
 
 				for (int b = 0; b < body->getNumLinks(); b++)
 				{
 					btMultiBodyLinkCollider* col = body->getLink(b).m_collider;
-					if (col && col->getActivationState() != DISABLE_DEACTIVATION)
+					if (col && col->m_activationState1 != DISABLE_DEACTIVATION)
 						col->setActivationState(ACTIVE_TAG);
 				}
 			}
@@ -245,13 +245,13 @@ void btMultiBodyDynamicsWorld::solveInternalConstraints(btContactSolverInfo& sol
             
             bool isSleeping = false;
             
-            if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
+            if (bod->getBaseCollider() && bod->getBaseCollider()->m_activationState1 == ISLAND_SLEEPING)
             {
                 isSleeping = true;
             }
             for (int b = 0; b < bod->getNumLinks(); b++)
             {
-                if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
+                if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->m_activationState1 == ISLAND_SLEEPING)
                     isSleeping = true;
             }
             
@@ -323,13 +323,13 @@ void btMultiBodyDynamicsWorld::solveExternalForces(btContactSolverInfo& solverIn
             
             bool isSleeping = false;
             
-            if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
+            if (bod->getBaseCollider() && bod->getBaseCollider()->m_activationState1 == ISLAND_SLEEPING)
             {
                 isSleeping = true;
             }
             for (int b = 0; b < bod->getNumLinks(); b++)
             {
-                if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
+                if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->m_activationState1 == ISLAND_SLEEPING)
                     isSleeping = true;
             }
             
@@ -359,13 +359,13 @@ void btMultiBodyDynamicsWorld::solveExternalForces(btContactSolverInfo& solverIn
             
             bool isSleeping = false;
             
-            if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
+            if (bod->getBaseCollider() && bod->getBaseCollider()->m_activationState1 == ISLAND_SLEEPING)
             {
                 isSleeping = true;
             }
             for (int b = 0; b < bod->getNumLinks(); b++)
             {
-                if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
+                if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->m_activationState1 == ISLAND_SLEEPING)
                     isSleeping = true;
             }
             
@@ -587,13 +587,13 @@ void btMultiBodyDynamicsWorld::integrateMultiBodyTransforms(btScalar timeStep)
 		{
 			btMultiBody* bod = m_multiBodies[b];
 			bool isSleeping = false;
-			if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
+			if (bod->getBaseCollider() && bod->getBaseCollider()->m_activationState1 == ISLAND_SLEEPING)
 			{
 				isSleeping = true;
 			}
 			for (int b = 0; b < bod->getNumLinks(); b++)
 			{
-				if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
+				if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->m_activationState1 == ISLAND_SLEEPING)
 					isSleeping = true;
 			}
 
@@ -636,13 +636,13 @@ void btMultiBodyDynamicsWorld::predictMultiBodyTransforms(btScalar timeStep)
     {
         btMultiBody* bod = m_multiBodies[b];
         bool isSleeping = false;
-        if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
+        if (bod->getBaseCollider() && bod->getBaseCollider()->m_activationState1 == ISLAND_SLEEPING)
         {
             isSleeping = true;
         }
         for (int b = 0; b < bod->getNumLinks(); b++)
         {
-            if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
+            if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->m_activationState1 == ISLAND_SLEEPING)
                 isSleeping = true;
         }
         
@@ -763,13 +763,13 @@ void btMultiBodyDynamicsWorld::applyGravity()
 
 		bool isSleeping = false;
 
-		if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
+		if (bod->getBaseCollider() && bod->getBaseCollider()->m_activationState1 == ISLAND_SLEEPING)
 		{
 			isSleeping = true;
 		}
 		for (int b = 0; b < bod->getNumLinks(); b++)
 		{
-			if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
+			if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->m_activationState1 == ISLAND_SLEEPING)
 				isSleeping = true;
 		}
 
@@ -804,13 +804,13 @@ void btMultiBodyDynamicsWorld::clearMultiBodyForces()
 
 			bool isSleeping = false;
 
-			if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
+			if (bod->getBaseCollider() && bod->getBaseCollider()->m_activationState1 == ISLAND_SLEEPING)
 			{
 				isSleeping = true;
 			}
 			for (int b = 0; b < bod->getNumLinks(); b++)
 			{
-				if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
+				if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->m_activationState1 == ISLAND_SLEEPING)
 					isSleeping = true;
 			}
 
@@ -867,7 +867,7 @@ void btMultiBodyDynamicsWorld::serializeMultiBodies(btSerializer* serializer)
 	for (i = 0; i < m_collisionObjects.size(); i++)
 	{
 		btCollisionObject* colObj = m_collisionObjects[i];
-		if (colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+		if (colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 		{
 			int len = colObj->calculateSerializeBufferSize();
 			btChunk* chunk = serializer->allocate(len, 1);

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodyFixedConstraint.cpp

@@ -60,7 +60,7 @@ btMultiBodyFixedConstraint::~btMultiBodyFixedConstraint()
 int btMultiBodyFixedConstraint::getIslandIdA() const
 {
 	if (m_rigidBodyA)
-		return m_rigidBodyA->getIslandTag();
+		return m_rigidBodyA->m_islandTag1;
 
 	if (m_bodyA)
 	{
@@ -68,12 +68,12 @@ int btMultiBodyFixedConstraint::getIslandIdA() const
 		{
 			btMultiBodyLinkCollider* col = m_bodyA->getBaseCollider();
 			if (col)
-				return col->getIslandTag();
+				return col->m_islandTag1;
 		}
 		else
 		{
 			if (m_bodyA->getLink(m_linkA).m_collider)
-				return m_bodyA->getLink(m_linkA).m_collider->getIslandTag();
+				return m_bodyA->getLink(m_linkA).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -82,19 +82,19 @@ int btMultiBodyFixedConstraint::getIslandIdA() const
 int btMultiBodyFixedConstraint::getIslandIdB() const
 {
 	if (m_rigidBodyB)
-		return m_rigidBodyB->getIslandTag();
+		return m_rigidBodyB->m_islandTag1;
 	if (m_bodyB)
 	{
 		if (m_linkB < 0)
 		{
 			btMultiBodyLinkCollider* col = m_bodyB->getBaseCollider();
 			if (col)
-				return col->getIslandTag();
+				return col->m_islandTag1;
 		}
 		else
 		{
 			if (m_bodyB->getLink(m_linkB).m_collider)
-				return m_bodyB->getLink(m_linkB).m_collider->getIslandTag();
+				return m_bodyB->getLink(m_linkB).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -123,7 +123,7 @@ void btMultiBodyFixedConstraint::createConstraintRows(btMultiBodyConstraintArray
 		btMatrix3x3 frameAworld = m_frameInA;
 		if (m_rigidBodyA)
 		{
-			constraintRow.m_solverBodyIdA = m_rigidBodyA->getCompanionId();
+			constraintRow.m_solverBodyIdA = m_rigidBodyA->m_companionId;
 			pivotAworld = m_rigidBodyA->getCenterOfMassTransform() * m_pivotInA;
 			frameAworld = frameAworld.transpose() * btMatrix3x3(m_rigidBodyA->getOrientation());
 		}
@@ -139,7 +139,7 @@ void btMultiBodyFixedConstraint::createConstraintRows(btMultiBodyConstraintArray
 		btMatrix3x3 frameBworld = m_frameInB;
 		if (m_rigidBodyB)
 		{
-			constraintRow.m_solverBodyIdB = m_rigidBodyB->getCompanionId();
+			constraintRow.m_solverBodyIdB = m_rigidBodyB->m_companionId;
 			pivotBworld = m_rigidBodyB->getCenterOfMassTransform() * m_pivotInB;
 			frameBworld = frameBworld.transpose() * btMatrix3x3(m_rigidBodyB->getOrientation());
 		}

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodyGearConstraint.cpp

@@ -48,12 +48,12 @@ int btMultiBodyGearConstraint::getIslandIdA() const
 		{
 			btMultiBodyLinkCollider* col = m_bodyA->getBaseCollider();
 			if (col)
-				return col->getIslandTag();
+				return col->m_islandTag1;
 		}
 		else
 		{
 			if (m_bodyA->getLink(m_linkA).m_collider)
-				return m_bodyA->getLink(m_linkA).m_collider->getIslandTag();
+				return m_bodyA->getLink(m_linkA).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -67,12 +67,12 @@ int btMultiBodyGearConstraint::getIslandIdB() const
 		{
 			btMultiBodyLinkCollider* col = m_bodyB->getBaseCollider();
 			if (col)
-				return col->getIslandTag();
+				return col->m_islandTag1;
 		}
 		else
 		{
 			if (m_bodyB->getLink(m_linkB).m_collider)
-				return m_bodyB->getLink(m_linkB).m_collider->getIslandTag();
+				return m_bodyB->getLink(m_linkB).m_collider->m_islandTag1;
 		}
 	}
 	return -1;

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h

@@ -25,7 +25,7 @@ SIMD_FORCE_INLINE int btGetConstraintIslandId2(const btTypedConstraint* lhs)
     
     const btCollisionObject& rcolObj0 = lhs->getRigidBodyA();
     const btCollisionObject& rcolObj1 = lhs->getRigidBodyB();
-    islandId = rcolObj0.getIslandTag() >= 0 ? rcolObj0.getIslandTag() : rcolObj1.getIslandTag();
+    islandId = rcolObj0.m_islandTag1 >= 0 ? rcolObj0.m_islandTag1 : rcolObj1.m_islandTag1;
     return islandId;
 }
 class btSortConstraintOnIslandPredicate2
@@ -190,7 +190,7 @@ struct MultiBodyInplaceSolverIslandCallback : public btSimulationIslandManager::
             {
                 for (i = 0; i < numBodies; i++)
 				{
-					bool isSoftBodyType = (bodies[i]->getInternalType() & btCollisionObject::CO_SOFT_BODY);
+					bool isSoftBodyType = (bodies[i]->m_internalType & btCollisionObject::CO_SOFT_BODY);
 					if (!isSoftBodyType)
 					{
 						m_bodies.push_back(bodies[i]);

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.cpp

@@ -58,12 +58,12 @@ int btMultiBodyJointLimitConstraint::getIslandIdA() const
 		{
 			btMultiBodyLinkCollider* col = m_bodyA->getBaseCollider();
 			if (col)
-				return col->getIslandTag();
+				return col->m_islandTag1;
 		}
 		else
 		{
 			if (m_bodyA->getLink(m_linkA).m_collider)
-				return m_bodyA->getLink(m_linkA).m_collider->getIslandTag();
+				return m_bodyA->getLink(m_linkA).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -77,12 +77,12 @@ int btMultiBodyJointLimitConstraint::getIslandIdB() const
 		{
 			btMultiBodyLinkCollider* col = m_bodyB->getBaseCollider();
 			if (col)
-				return col->getIslandTag();
+				return col->m_islandTag1;
 		}
 		else
 		{
 			if (m_bodyB->getLink(m_linkB).m_collider)
-				return m_bodyB->getLink(m_linkB).m_collider->getIslandTag();
+				return m_bodyB->getLink(m_linkB).m_collider->m_islandTag1;
 		}
 	}
 	return -1;

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodyJointMotor.cpp

@@ -73,13 +73,13 @@ int btMultiBodyJointMotor::getIslandIdA() const
 	{
 		btMultiBodyLinkCollider* col = m_bodyA->getBaseCollider();
 		if (col)
-			return col->getIslandTag();
+			return col->m_islandTag1;
 	}
 	else
 	{
 		if (m_bodyA->getLink(m_linkA).m_collider)
 		{
-			return m_bodyA->getLink(m_linkA).m_collider->getIslandTag();
+			return m_bodyA->getLink(m_linkA).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -91,13 +91,13 @@ int btMultiBodyJointMotor::getIslandIdB() const
 	{
 		btMultiBodyLinkCollider* col = m_bodyB->getBaseCollider();
 		if (col)
-			return col->getIslandTag();
+			return col->m_islandTag1;
 	}
 	else
 	{
 		if (m_bodyB->getLink(m_linkB).m_collider)
 		{
-			return m_bodyB->getLink(m_linkB).m_collider->getIslandTag();
+			return m_bodyB->getLink(m_linkB).m_collider->m_islandTag1;
 		}
 	}
 	return -1;

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodyLinkCollider.h

@@ -60,13 +60,13 @@ public:
 	}
 	static btMultiBodyLinkCollider* upcast(btCollisionObject* colObj)
 	{
-		if (colObj->getInternalType() & btCollisionObject::CO_FEATHERSTONE_LINK)
+		if (colObj->m_internalType & btCollisionObject::CO_FEATHERSTONE_LINK)
 			return (btMultiBodyLinkCollider*)colObj;
 		return 0;
 	}
 	static const btMultiBodyLinkCollider* upcast(const btCollisionObject* colObj)
 	{
-		if (colObj->getInternalType() & btCollisionObject::CO_FEATHERSTONE_LINK)
+		if (colObj->m_internalType & btCollisionObject::CO_FEATHERSTONE_LINK)
 			return (btMultiBodyLinkCollider*)colObj;
 		return 0;
 	}
@@ -142,9 +142,9 @@ public:
 
 	void setDynamicType(int dynamicType)
 	{
-		int oldFlags = getCollisionFlags();
+		int oldFlags = m_collisionFlags;
 		oldFlags &= ~(btCollisionObject::CF_STATIC_OBJECT | btCollisionObject::CF_KINEMATIC_OBJECT);
-		setCollisionFlags(oldFlags | dynamicType);
+		m_collisionFlags = (oldFlags | dynamicType);
 	}
 
 	virtual int calculateSerializeBufferSize() const;

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodyPoint2Point.cpp

@@ -59,7 +59,7 @@ btMultiBodyPoint2Point::~btMultiBodyPoint2Point()
 int btMultiBodyPoint2Point::getIslandIdA() const
 {
 	if (m_rigidBodyA)
-		return m_rigidBodyA->getIslandTag();
+		return m_rigidBodyA->m_islandTag1;
 
 	if (m_bodyA)
 	{
@@ -67,12 +67,12 @@ int btMultiBodyPoint2Point::getIslandIdA() const
 		{
 			btMultiBodyLinkCollider* col = m_bodyA->getBaseCollider();
 			if (col)
-				return col->getIslandTag();
+				return col->m_islandTag1;
 		}
 		else
 		{
 			if (m_bodyA->getLink(m_linkA).m_collider)
-				return m_bodyA->getLink(m_linkA).m_collider->getIslandTag();
+				return m_bodyA->getLink(m_linkA).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -81,19 +81,19 @@ int btMultiBodyPoint2Point::getIslandIdA() const
 int btMultiBodyPoint2Point::getIslandIdB() const
 {
 	if (m_rigidBodyB)
-		return m_rigidBodyB->getIslandTag();
+		return m_rigidBodyB->m_islandTag1;
 	if (m_bodyB)
 	{
 		if (m_linkB < 0)
 		{
 			btMultiBodyLinkCollider* col = m_bodyB->getBaseCollider();
 			if (col)
-				return col->getIslandTag();
+				return col->m_islandTag1;
 		}
 		else
 		{
 			if (m_bodyB->getLink(m_linkB).m_collider)
-				return m_bodyB->getLink(m_linkB).m_collider->getIslandTag();
+				return m_bodyB->getLink(m_linkB).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -132,7 +132,7 @@ void btMultiBodyPoint2Point::createConstraintRows(btMultiBodyConstraintArray& co
 		btVector3 pivotAworld = m_pivotInA;
 		if (m_rigidBodyA)
 		{
-			constraintRow.m_solverBodyIdA = m_rigidBodyA->getCompanionId();
+			constraintRow.m_solverBodyIdA = m_rigidBodyA->m_companionId;
 			pivotAworld = m_rigidBodyA->getCenterOfMassTransform() * m_pivotInA;
 		}
 		else
@@ -143,7 +143,7 @@ void btMultiBodyPoint2Point::createConstraintRows(btMultiBodyConstraintArray& co
 		btVector3 pivotBworld = m_pivotInB;
 		if (m_rigidBodyB)
 		{
-			constraintRow.m_solverBodyIdB = m_rigidBodyB->getCompanionId();
+			constraintRow.m_solverBodyIdB = m_rigidBodyB->m_companionId;
 			pivotBworld = m_rigidBodyB->getCenterOfMassTransform() * m_pivotInB;
 		}
 		else

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodySliderConstraint.cpp

@@ -63,7 +63,7 @@ btMultiBodySliderConstraint::~btMultiBodySliderConstraint()
 int btMultiBodySliderConstraint::getIslandIdA() const
 {
 	if (m_rigidBodyA)
-		return m_rigidBodyA->getIslandTag();
+		return m_rigidBodyA->m_islandTag1;
 
 	if (m_bodyA)
 	{
@@ -71,12 +71,12 @@ int btMultiBodySliderConstraint::getIslandIdA() const
 		{
 			btMultiBodyLinkCollider* col = m_bodyA->getBaseCollider();
 			if (col)
-				return col->getIslandTag();
+				return col->m_islandTag1;
 		}
 		else
 		{
 			if (m_bodyA->getLink(m_linkA).m_collider)
-				return m_bodyA->getLink(m_linkA).m_collider->getIslandTag();
+				return m_bodyA->getLink(m_linkA).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -85,19 +85,19 @@ int btMultiBodySliderConstraint::getIslandIdA() const
 int btMultiBodySliderConstraint::getIslandIdB() const
 {
 	if (m_rigidBodyB)
-		return m_rigidBodyB->getIslandTag();
+		return m_rigidBodyB->m_islandTag1;
 	if (m_bodyB)
 	{
 		if (m_linkB < 0)
 		{
 			btMultiBodyLinkCollider* col = m_bodyB->getBaseCollider();
 			if (col)
-				return col->getIslandTag();
+				return col->m_islandTag1;
 		}
 		else
 		{
 			if (m_bodyB->getLink(m_linkB).m_collider)
-				return m_bodyB->getLink(m_linkB).m_collider->getIslandTag();
+				return m_bodyB->getLink(m_linkB).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -168,11 +168,11 @@ void btMultiBodySliderConstraint::createConstraintRows(btMultiBodyConstraintArra
 
 		if (m_rigidBodyA)
 		{
-			constraintRow.m_solverBodyIdA = m_rigidBodyA->getCompanionId();
+			constraintRow.m_solverBodyIdA = m_rigidBodyA->m_companionId;
 		}
 		if (m_rigidBodyB)
 		{
-			constraintRow.m_solverBodyIdB = m_rigidBodyB->getCompanionId();
+			constraintRow.m_solverBodyIdB = m_rigidBodyB->m_companionId;
 		}
 
 		btVector3 constraintNormalLin(0, 0, 0);

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodySphericalJointLimit.cpp

@@ -77,13 +77,13 @@ int btMultiBodySphericalJointLimit::getIslandIdA() const
 	{
 		btMultiBodyLinkCollider* col = m_bodyA->getBaseCollider();
 		if (col)
-			return col->getIslandTag();
+			return col->m_islandTag1;
 	}
 	else
 	{
 		if (m_bodyA->getLink(m_linkA).m_collider)
 		{
-			return m_bodyA->getLink(m_linkA).m_collider->getIslandTag();
+			return m_bodyA->getLink(m_linkA).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -95,13 +95,13 @@ int btMultiBodySphericalJointLimit::getIslandIdB() const
 	{
 		btMultiBodyLinkCollider* col = m_bodyB->getBaseCollider();
 		if (col)
-			return col->getIslandTag();
+			return col->m_islandTag1;
 	}
 	else
 	{
 		if (m_bodyB->getLink(m_linkB).m_collider)
 		{
-			return m_bodyB->getLink(m_linkB).m_collider->getIslandTag();
+			return m_bodyB->getLink(m_linkB).m_collider->m_islandTag1;
 		}
 	}
 	return -1;

3rdparty/bullet3/src/BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.cpp

@@ -65,13 +65,13 @@ int btMultiBodySphericalJointMotor::getIslandIdA() const
 	{
 		btMultiBodyLinkCollider* col = m_bodyA->getBaseCollider();
 		if (col)
-			return col->getIslandTag();
+			return col->m_islandTag1;
 	}
 	else
 	{
 		if (m_bodyA->getLink(m_linkA).m_collider)
 		{
-			return m_bodyA->getLink(m_linkA).m_collider->getIslandTag();
+			return m_bodyA->getLink(m_linkA).m_collider->m_islandTag1;
 		}
 	}
 	return -1;
@@ -83,13 +83,13 @@ int btMultiBodySphericalJointMotor::getIslandIdB() const
 	{
 		btMultiBodyLinkCollider* col = m_bodyB->getBaseCollider();
 		if (col)
-			return col->getIslandTag();
+			return col->m_islandTag1;
 	}
 	else
 	{
 		if (m_bodyB->getLink(m_linkB).m_collider)
 		{
-			return m_bodyB->getLink(m_linkB).m_collider->getIslandTag();
+			return m_bodyB->getLink(m_linkB).m_collider->m_islandTag1;
 		}
 	}
 	return -1;

3rdparty/bullet3/src/BulletSoftBody/BulletReducedDeformableBody/btReducedDeformableBody.cpp

@@ -413,7 +413,7 @@ void btReducedDeformableBody::transform(const btTransform& trs)
 
   // transform mesh
   {
-    const btScalar margin = getCollisionShape()->getMargin();
+    const btScalar margin = m_collisionShape->getMargin();
     ATTRIBUTE_ALIGNED16(btDbvtVolume)
     vol;
 
@@ -459,7 +459,7 @@ void btReducedDeformableBody::scale(const btVector3& scl)
 
   // scale the mesh
   {
-    const btScalar margin = getCollisionShape()->getMargin();
+    const btScalar margin = m_collisionShape->getMargin();
     ATTRIBUTE_ALIGNED16(btDbvtVolume)
     vol;
 

3rdparty/bullet3/src/BulletSoftBody/BulletReducedDeformableBody/btReducedDeformableBodySolver.cpp

@@ -109,7 +109,7 @@ void btReducedDeformableBodySolver::predictReduceDeformableMotion(btScalar solve
     }
 
     // rigid motion: t, R at time^*
-    rsb->predictIntegratedTransform(solverdt, rsb->getInterpolationWorldTransform());
+    rsb->predictIntegratedTransform(solverdt, rsb->m_interpolationWorldTransform);
 
     // update reduced dofs at time^*
     // rsb->updateReducedDofs(solverdt);
@@ -119,10 +119,10 @@ void btReducedDeformableBodySolver::predictReduceDeformableMotion(btScalar solve
     // rsb->updateExternalForceProjectMatrix(true);
 
     // predict full space velocity at time^* (needed for constraints)
-    rsb->mapToFullVelocity(rsb->getInterpolationWorldTransform());
+    rsb->mapToFullVelocity(rsb->m_interpolationWorldTransform);
 
     // update full space nodal position at time^*
-    rsb->mapToFullPosition(rsb->getInterpolationWorldTransform());
+    rsb->mapToFullPosition(rsb->m_interpolationWorldTransform);
 
     // update bounding box
     rsb->updateBounds();
@@ -322,4 +322,4 @@ void btReducedDeformableBodySolver::deformableBodyInternalWriteBack()
     rsb->applyInternalVelocityChanges();
   }
   m_ascendOrder = true;
-}
+}

3rdparty/bullet3/src/BulletSoftBody/BulletReducedDeformableBody/btReducedDeformableContactConstraint.cpp

@@ -52,7 +52,7 @@ void btReducedDeformableStaticConstraint::applyImpulse(const btVector3& impulse)
 
 btVector3 btReducedDeformableStaticConstraint::getDeltaVa() const
 {
-	return m_rsb->internalComputeNodeDeltaVelocity(m_rsb->getInterpolationWorldTransform(), m_node->index);
+	return m_rsb->internalComputeNodeDeltaVelocity(m_rsb->m_interpolationWorldTransform, m_node->index);
 }
 
 // ================= base contact constraints ===================
@@ -75,7 +75,7 @@ btReducedDeformableRigidContactConstraint::btReducedDeformableRigidContactConstr
 	m_friction = infoGlobal.m_friction;
 
 	m_collideStatic = m_contact->m_cti.m_colObj->isStaticObject();
-	m_collideMultibody = (m_contact->m_cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK);
+	m_collideMultibody = (m_contact->m_cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK);
 }
 
 void btReducedDeformableRigidContactConstraint::setSolverBody(const int bodyId, btSolverBody& solver_body)
@@ -337,7 +337,7 @@ btReducedDeformableNodeRigidContactConstraint::btReducedDeformableNodeRigidConta
 		m_nodeQueryIndex = m_node->index - rsb->m_nodeIndexOffset;
 	}
 
-	if (m_contact->m_cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+	if (m_contact->m_cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 	{
 		m_relPosA = contact.m_c1;
 	}
@@ -442,7 +442,7 @@ void btReducedDeformableNodeRigidContactConstraint::warmStarting()
 	// if (!m_collideStatic)
 	// {
 	// 	const btSoftBody::sCti& cti = m_contact->m_cti;
-	// 	if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+	// 	if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 	// 	{
 	// 		m_solverBody->internalApplyImpulse(m_linearComponentNormal, m_angularComponentNormal, -m_rhs);
 	// 	}
@@ -505,7 +505,7 @@ btVector3 btReducedDeformableNodeRigidContactConstraint::getDeltaVa() const
 btVector3 btReducedDeformableNodeRigidContactConstraint::getDeltaVb() const
 {	
 	// std::cout << "node: " << m_node->index << '\n';
-	return m_rsb->internalComputeNodeDeltaVelocity(m_rsb->getInterpolationWorldTransform(), m_nodeQueryIndex);
+	return m_rsb->internalComputeNodeDeltaVelocity(m_rsb->m_interpolationWorldTransform, m_nodeQueryIndex);
 }
 
 btVector3 btReducedDeformableNodeRigidContactConstraint::getSplitVb() const
@@ -522,7 +522,7 @@ void btReducedDeformableNodeRigidContactConstraint::applyImpulse(const btVector3
 {
   m_rsb->internalApplyFullSpaceImpulse(impulse, m_relPosB, m_nodeQueryIndex, m_dt);
 	// m_rsb->applyFullSpaceImpulse(impulse, m_relPosB, m_node->index, m_dt);
-	// m_rsb->mapToFullVelocity(m_rsb->getInterpolationWorldTransform());
+	// m_rsb->mapToFullVelocity(m_rsb->m_interpolationWorldTransform);
 	// if (!m_collideStatic)
 	// {
 	// 	// std::cout << "impulse applied: " << impulse[0] << '\t' << impulse[1] << '\t' << impulse[2] << '\n';

3rdparty/bullet3/src/BulletSoftBody/btDeformableBodySolver.cpp

@@ -440,7 +440,7 @@ void btDeformableBodySolver::predictDeformableMotion(btSoftBody* psb, btScalar d
 	psb->m_sst.sdt = dt * psb->m_cfg.timescale;
 	psb->m_sst.isdt = 1 / psb->m_sst.sdt;
 	psb->m_sst.velmrg = psb->m_sst.sdt * 3;
-	psb->m_sst.radmrg = psb->getCollisionShape()->getMargin();
+	psb->m_sst.radmrg = psb->m_collisionShape->getMargin();
 	psb->m_sst.updmrg = psb->m_sst.radmrg * (btScalar)0.25;
 	/* Bounds                */
 	psb->updateBounds();
@@ -541,17 +541,17 @@ void btDeformableBodySolver::applyTransforms(btScalar timeStep)
 		{
 			btSoftBody::DeformableNodeRigidAnchor& a = psb->m_deformableAnchors[j];
 			btSoftBody::Node* n = a.m_node;
-			n->m_x = a.m_cti.m_colObj->getWorldTransform() * a.m_local;
+			n->m_x = a.m_cti.m_colObj->m_worldTransform * a.m_local;
 
 			// update multibody anchor info
-			if (a.m_cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+			if (a.m_cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 			{
 				btMultiBodyLinkCollider* multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(a.m_cti.m_colObj);
 				if (multibodyLinkCol)
 				{
 					btVector3 nrm;
-					const btCollisionShape* shp = multibodyLinkCol->getCollisionShape();
-					const btTransform& wtr = multibodyLinkCol->getWorldTransform();
+					const btCollisionShape* shp = multibodyLinkCol->m_collisionShape;
+					const btTransform& wtr = multibodyLinkCol->m_worldTransform;
 					psb->m_worldInfo->m_sparsesdf.Evaluate(
 						wtr.invXform(n->m_x),
 						shp,

3rdparty/bullet3/src/BulletSoftBody/btDeformableContactConstraint.cpp

@@ -35,12 +35,12 @@ btVector3 btDeformableNodeAnchorConstraint::getVa() const
 		btMultiBodyLinkCollider* multibodyLinkCol = 0;
 
 		// grab the velocity of the rigid body
-		if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+		if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 		{
 			rigidCol = (btRigidBody*)btRigidBody::upcast(cti.m_colObj);
 			va = rigidCol ? (rigidCol->getVelocityInLocalPoint(m_anchor->m_c1)) : btVector3(0, 0, 0);
 		}
-		else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+		else if (cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 		{
 			multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);
 			if (multibodyLinkCol)
@@ -83,7 +83,7 @@ btScalar btDeformableNodeAnchorConstraint::solveConstraint(const btContactSolver
 	btVector3 va = getVa();
 	btVector3 vb = getVb();
 	btVector3 vr = (vb - va);
-	// + (m_anchor->m_node->m_x - cti.m_colObj->getWorldTransform() * m_anchor->m_local) * 10.0
+	// + (m_anchor->m_node->m_x - cti.m_colObj->m_worldTransform * m_anchor->m_local) * 10.0
 	const btScalar dn = btDot(vr, vr);
 	// dn is the normal component of velocity diffrerence. Approximates the residual. // todo xuchenhan@: this prob needs to be scaled by dt
 	btScalar residualSquare = dn * dn;
@@ -92,7 +92,7 @@ btScalar btDeformableNodeAnchorConstraint::solveConstraint(const btContactSolver
 	applyImpulse(impulse);
 
 	// apply impulse to the rigid/multibodies involved and change their velocities
-	if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+	if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 	{
 		btRigidBody* rigidCol = 0;
 		rigidCol = (btRigidBody*)btRigidBody::upcast(cti.m_colObj);
@@ -101,7 +101,7 @@ btScalar btDeformableNodeAnchorConstraint::solveConstraint(const btContactSolver
 			rigidCol->applyImpulse(impulse, m_anchor->m_c1);
 		}
 	}
-	else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+	else if (cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 	{
 		btMultiBodyLinkCollider* multibodyLinkCol = 0;
 		multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);
@@ -160,12 +160,12 @@ btVector3 btDeformableRigidContactConstraint::getVa() const
 		btMultiBodyLinkCollider* multibodyLinkCol = 0;
 
 		// grab the velocity of the rigid body
-		if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+		if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 		{
 			rigidCol = (btRigidBody*)btRigidBody::upcast(cti.m_colObj);
 			va = rigidCol ? (rigidCol->getVelocityInLocalPoint(m_contact->m_c1)) : btVector3(0, 0, 0);
 		}
-		else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+		else if (cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 		{
 			multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);
 			if (multibodyLinkCol)
@@ -212,12 +212,12 @@ btVector3 btDeformableRigidContactConstraint::getSplitVa() const
 		btMultiBodyLinkCollider* multibodyLinkCol = 0;
 
 		// grab the velocity of the rigid body
-		if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+		if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 		{
 			rigidCol = (btRigidBody*)btRigidBody::upcast(cti.m_colObj);
 			va = rigidCol ? (rigidCol->getPushVelocityInLocalPoint(m_contact->m_c1)) : btVector3(0, 0, 0);
 		}
-		else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+		else if (cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 		{
 			multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);
 			if (multibodyLinkCol)
@@ -322,7 +322,7 @@ btScalar btDeformableRigidContactConstraint::solveConstraint(const btContactSolv
 	// apply impulse to deformable nodes involved and change their velocities
 	applyImpulse(impulse);
 	// apply impulse to the rigid/multibodies involved and change their velocities
-	if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+	if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 	{
 		btRigidBody* rigidCol = 0;
 		rigidCol = (btRigidBody*)btRigidBody::upcast(cti.m_colObj);
@@ -331,7 +331,7 @@ btScalar btDeformableRigidContactConstraint::solveConstraint(const btContactSolv
 			rigidCol->applyImpulse(impulse, m_contact->m_c1);
 		}
 	}
-	else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+	else if (cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 	{
 		btMultiBodyLinkCollider* multibodyLinkCol = 0;
 		multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);
@@ -385,7 +385,7 @@ btScalar btDeformableRigidContactConstraint::solveSplitImpulse(const btContactSo
 	applySplitImpulse(impulse);
 
 	// apply split impulse to the rigid/multibodies involved and change their velocities
-	if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+	if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 	{
 		btRigidBody* rigidCol = 0;
 		rigidCol = (btRigidBody*)btRigidBody::upcast(cti.m_colObj);
@@ -394,7 +394,7 @@ btScalar btDeformableRigidContactConstraint::solveSplitImpulse(const btContactSo
 			rigidCol->applyPushImpulse(impulse, m_contact->m_c1);
 		}
 	}
-	else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+	else if (cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 	{
 		btMultiBodyLinkCollider* multibodyLinkCol = 0;
 		multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);

3rdparty/bullet3/src/BulletSoftBody/btDeformableContactProjection.cpp

@@ -117,7 +117,7 @@ void btDeformableContactProjection::setConstraints(const btContactSolverInfo& in
 			{
 				continue;
 			}
-			anchor.m_c1 = anchor.m_cti.m_colObj->getWorldTransform().m_basis * anchor.m_local;
+			anchor.m_c1 = anchor.m_cti.m_colObj->m_worldTransform.m_basis * anchor.m_local;
 			btDeformableNodeAnchorConstraint constraint(anchor, infoGlobal);
 			m_nodeAnchorConstraints[i].push_back(constraint);
 		}

3rdparty/bullet3/src/BulletSoftBody/btDeformableMultiBodyConstraintSolver.cpp

@@ -56,7 +56,7 @@ btScalar btDeformableMultiBodyConstraintSolver::solveDeformableGroupIterations(b
 				m_analyticsData.m_numIterationsUsed = iteration + 1;
 				m_analyticsData.m_islandId = -2;
 				if (numBodies > 0)
-					m_analyticsData.m_islandId = bodies[0]->getCompanionId();
+					m_analyticsData.m_islandId = bodies[0]->m_companionId;
 				m_analyticsData.m_numBodies = numBodies;
 				m_analyticsData.m_numContactManifolds = numManifolds;
 				m_analyticsData.m_remainingLeastSquaresResidual = m_leastSquaresResidual;

3rdparty/bullet3/src/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.cpp

@@ -144,16 +144,16 @@ void btDeformableMultiBodyDynamicsWorld::updateActivationState(btScalar timeStep
 		psb->updateDeactivation(timeStep);
 		if (psb->wantsSleeping())
 		{
-			if (psb->getActivationState() == ACTIVE_TAG)
+			if (psb->m_activationState1 == ACTIVE_TAG)
 				psb->setActivationState(WANTS_DEACTIVATION);
-			if (psb->getActivationState() == ISLAND_SLEEPING)
+			if (psb->m_activationState1 == ISLAND_SLEEPING)
 			{
 				psb->setZeroVelocity();
 			}
 		}
 		else
 		{
-			if (psb->getActivationState() != DISABLE_DEACTIVATION)
+			if (psb->m_activationState1 != DISABLE_DEACTIVATION)
 				psb->setActivationState(ACTIVE_TAG);
 		}
 	}
@@ -285,7 +285,7 @@ void btDeformableMultiBodyDynamicsWorld::positionCorrection(btScalar timeStep)
 		btVector3 turnVelocity = rb->getTurnVelocity();
 		if (pushVelocity[0] != 0.f || pushVelocity[1] != 0 || pushVelocity[2] != 0 || turnVelocity[0] != 0.f || turnVelocity[1] != 0 || turnVelocity[2] != 0)
 		{
-			btTransformUtil::integrateTransform(rb->getWorldTransform(), pushVelocity, turnVelocity * infoGlobal.m_splitImpulseTurnErp, timeStep, newTransform);
+			btTransformUtil::integrateTransform(rb->m_worldTransform, pushVelocity, turnVelocity * infoGlobal.m_splitImpulseTurnErp, timeStep, newTransform);
 			rb->setWorldTransform(newTransform);
 			rb->setPushVelocity(zero);
 			rb->setTurnVelocity(zero);
@@ -382,13 +382,13 @@ void btDeformableMultiBodyDynamicsWorld::solveContactConstraints()
 
 			bool isSleeping = false;
 
-			if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
+			if (bod->getBaseCollider() && bod->getBaseCollider()->m_activationState1 == ISLAND_SLEEPING)
 			{
 				isSleeping = true;
 			}
 			for (int b = 0; b < bod->getNumLinks(); b++)
 			{
-				if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
+				if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->m_activationState1 == ISLAND_SLEEPING)
 					isSleeping = true;
 			}
 
@@ -512,13 +512,13 @@ void btDeformableMultiBodyDynamicsWorld::applyRigidBodyGravity(btScalar timeStep
 
 				bool isSleeping = false;
 
-				if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
+				if (bod->getBaseCollider() && bod->getBaseCollider()->m_activationState1 == ISLAND_SLEEPING)
 				{
 					isSleeping = true;
 				}
 				for (int b = 0; b < bod->getNumLinks(); b++)
 				{
-					if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
+					if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->m_activationState1 == ISLAND_SLEEPING)
 						isSleeping = true;
 				}
 
@@ -567,13 +567,13 @@ void btDeformableMultiBodyDynamicsWorld::clearGravity()
 
 		bool isSleeping = false;
 
-		if (bod->getBaseCollider() && bod->getBaseCollider()->getActivationState() == ISLAND_SLEEPING)
+		if (bod->getBaseCollider() && bod->getBaseCollider()->m_activationState1 == ISLAND_SLEEPING)
 		{
 			isSleeping = true;
 		}
 		for (int b = 0; b < bod->getNumLinks(); b++)
 		{
-			if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->getActivationState() == ISLAND_SLEEPING)
+			if (bod->getLink(b).m_collider && bod->getLink(b).m_collider->m_activationState1 == ISLAND_SLEEPING)
 				isSleeping = true;
 		}
 

3rdparty/bullet3/src/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h

@@ -220,18 +220,18 @@ public:
 			btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
 
 			//only perform raycast if filterMask matches
-			if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
+			if (m_resultCallback.needsCollision(collisionObject->m_broadphaseHandle))
 			{
 				//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
 				//btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
 #if 0
 #ifdef RECALCULATE_AABB
                 btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
-                collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
+                collisionObject->m_collisionShape->getAabb(collisionObject->m_worldTransform,collisionObjectAabbMin,collisionObjectAabbMax);
 #else
-                //getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax);
-                const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
-                const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
+                //getBroadphase()->getAabb(collisionObject->m_broadphaseHandle,collisionObjectAabbMin,collisionObjectAabbMax);
+                const btVector3& collisionObjectAabbMin = collisionObject->m_broadphaseHandle->m_aabbMin;
+                const btVector3& collisionObjectAabbMax = collisionObject->m_broadphaseHandle->m_aabbMax;
 #endif
 #endif
 				//btScalar hitLambda = m_resultCallback.m_closestHitFraction;
@@ -240,8 +240,8 @@ public:
 				{
 					m_world->rayTestSingle(m_rayFromTrans, m_rayToTrans,
 										   collisionObject,
-										   collisionObject->getCollisionShape(),
-										   collisionObject->getWorldTransform(),
+										   collisionObject->m_collisionShape,
+										   collisionObject->m_worldTransform,
 										   m_resultCallback);
 				}
 			}
@@ -261,7 +261,7 @@ public:
 #else
 		for (int i = 0; i < this->getNumCollisionObjects(); i++)
 		{
-			rayCB.process(m_collisionObjects[i]->getBroadphaseHandle());
+			rayCB.process(m_collisionObjects[i]->m_broadphaseHandle);
 		}
 #endif  //USE_BRUTEFORCE_RAYBROADPHASE
 	}

3rdparty/bullet3/src/BulletSoftBody/btSoftBody.cpp

@@ -141,7 +141,7 @@ btSoftBody::btSoftBody(btSoftBodyWorldInfo* worldInfo, int node_count, const btV
 	pm->m_flags = fMaterial::Default;
 
 	/* Nodes			*/
-	const btScalar margin = getCollisionShape()->getMargin();
+	const btScalar margin = m_collisionShape->getMargin();
 	m_nodes.resize(node_count);
 	m_X.resize(node_count);
 	for (int i = 0, ni = node_count; i < ni; ++i)
@@ -377,7 +377,7 @@ void btSoftBody::appendNode(const btVector3& x, btScalar m)
 		m_nodes.reserve(m_nodes.size() * 2 + 1);
 		indicesToPointers();
 	}
-	const btScalar margin = getCollisionShape()->getMargin();
+	const btScalar margin = m_collisionShape->getMargin();
 	m_nodes.push_back(Node());
 	Node& n = m_nodes[m_nodes.size() - 1];
 	ZeroInitialize(n);
@@ -503,7 +503,7 @@ void btSoftBody::appendTetra(int node0,
 
 void btSoftBody::appendAnchor(int node, btRigidBody* body, bool disableCollisionBetweenLinkedBodies, btScalar influence)
 {
-	btVector3 local = body->getWorldTransform().inverse() * m_nodes[node].m_x;
+	btVector3 local = body->m_worldTransform.inverse() * m_nodes[node].m_x;
 	appendAnchor(node, body, local, disableCollisionBetweenLinkedBodies, influence);
 }
 
@@ -535,8 +535,8 @@ void btSoftBody::appendDeformableAnchor(int node, btRigidBody* body)
 	const btScalar ima = n.m_im;
 	const btScalar imb = body->getInvMass();
 	btVector3 nrm;
-	const btCollisionShape* shp = body->getCollisionShape();
-	const btTransform& wtr = body->getWorldTransform();
+	const btCollisionShape* shp = body->m_collisionShape;
+	const btTransform& wtr = body->m_worldTransform;
 	btScalar dst =
 		m_worldInfo->m_sparsesdf.Evaluate(
 			wtr.invXform(m_nodes[node].m_x),
@@ -548,7 +548,7 @@ void btSoftBody::appendDeformableAnchor(int node, btRigidBody* body)
 	c.m_cti.m_normal = wtr.m_basis * nrm;
 	c.m_cti.m_offset = dst;
 	c.m_node = &m_nodes[node];
-	const btScalar fc = m_cfg.kDF * body->getFriction();
+	const btScalar fc = m_cfg.kDF * body->m_friction;
 	c.m_c2 = ima;
 	c.m_c3 = fc;
 	c.m_c4 = body->isStaticOrKinematicObject() ? m_cfg.kKHR : m_cfg.kCHR;
@@ -558,7 +558,7 @@ void btSoftBody::appendDeformableAnchor(int node, btRigidBody* body)
 
 	c.m_c0 = ImpulseMatrix(1, ima, imb, iwi, ra);
 	c.m_c1 = ra;
-	c.m_local = body->getWorldTransform().inverse() * m_nodes[node].m_x;
+	c.m_local = body->m_worldTransform.inverse() * m_nodes[node].m_x;
 	c.m_node->m_battach = 1;
 	m_deformableAnchors.push_back(c);
 }
@@ -587,8 +587,8 @@ void btSoftBody::appendDeformableAnchor(int node, btMultiBodyLinkCollider* link)
 	btSoftBody::Node& n = m_nodes[node];
 	const btScalar ima = n.m_im;
 	btVector3 nrm;
-	const btCollisionShape* shp = link->getCollisionShape();
-	const btTransform& wtr = link->getWorldTransform();
+	const btCollisionShape* shp = link->m_collisionShape;
+	const btTransform& wtr = link->m_worldTransform;
 	btScalar dst =
 		m_worldInfo->m_sparsesdf.Evaluate(
 			wtr.invXform(m_nodes[node].m_x),
@@ -599,7 +599,7 @@ void btSoftBody::appendDeformableAnchor(int node, btMultiBodyLinkCollider* link)
 	c.m_cti.m_normal = wtr.m_basis * nrm;
 	c.m_cti.m_offset = dst;
 	c.m_node = &m_nodes[node];
-	const btScalar fc = m_cfg.kDF * link->getFriction();
+	const btScalar fc = m_cfg.kDF * link->m_friction;
 	c.m_c2 = ima;
 	c.m_c3 = fc;
 	c.m_c4 = link->isStaticOrKinematicObject() ? m_cfg.kKHR : m_cfg.kCHR;
@@ -632,7 +632,7 @@ void btSoftBody::appendDeformableAnchor(int node, btMultiBodyLinkCollider* link)
 	c.t2 = t2;
 	const btVector3 ra = n.m_x - wtr.m_origin;
 	c.m_c1 = ra;
-	c.m_local = link->getWorldTransform().inverse() * m_nodes[node].m_x;
+	c.m_local = link->m_worldTransform.inverse() * m_nodes[node].m_x;
 	c.m_node->m_battach = 1;
 	m_deformableAnchors.push_back(c);
 }
@@ -1102,7 +1102,7 @@ void btSoftBody::transformTo(const btTransform& trs)
 //
 void btSoftBody::transform(const btTransform& trs)
 {
-	const btScalar margin = getCollisionShape()->getMargin();
+	const btScalar margin = m_collisionShape->getMargin();
 	ATTRIBUTE_ALIGNED16(btDbvtVolume)
 	vol;
 
@@ -1142,7 +1142,7 @@ void btSoftBody::rotate(const btQuaternion& rot)
 //
 void btSoftBody::scale(const btVector3& scl)
 {
-	const btScalar margin = getCollisionShape()->getMargin();
+	const btScalar margin = m_collisionShape->getMargin();
 	ATTRIBUTE_ALIGNED16(btDbvtVolume)
 	vol;
 
@@ -1177,7 +1177,7 @@ void btSoftBody::setRestLengthScale(btScalar restLengthScale)
 	}
 	m_restLengthScale = restLengthScale;
 
-	if (getActivationState() == ISLAND_SLEEPING)
+	if (m_activationState1 == ISLAND_SLEEPING)
 		activate();
 }
 
@@ -2116,7 +2116,7 @@ void btSoftBody::predictMotion(btScalar dt)
 	m_sst.sdt = dt * m_cfg.timescale;
 	m_sst.isdt = 1 / m_sst.sdt;
 	m_sst.velmrg = m_sst.sdt * 3;
-	m_sst.radmrg = getCollisionShape()->getMargin();
+	m_sst.radmrg = m_collisionShape->getMargin();
 	m_sst.updmrg = m_sst.radmrg * (btScalar)0.25;
 	/* Forces                */
 	addVelocity(m_worldInfo->m_gravity * m_sst.sdt);
@@ -2223,7 +2223,7 @@ void btSoftBody::solveConstraints()
 	for (i = 0, ni = m_anchors.size(); i < ni; ++i)
 	{
 		Anchor& a = m_anchors[i];
-		const btVector3 ra = a.m_body->getWorldTransform().m_basis * a.m_local;
+		const btVector3 ra = a.m_body->m_worldTransform.m_basis * a.m_local;
 		a.m_c0 = ImpulseMatrix(m_sst.sdt,
 							   a.m_node->m_im,
 							   a.m_body->getInvMass(),
@@ -2751,10 +2751,10 @@ bool btSoftBody::checkContact(const btCollisionObjectWrapper* colObjWrap,
 							  btSoftBody::sCti& cti) const
 {
 	btVector3 nrm;
-	const btCollisionShape* shp = colObjWrap->getCollisionShape();
-	//    const btRigidBody *tmpRigid = btRigidBody::upcast(colObjWrap->getCollisionObject());
-	//const btTransform &wtr = tmpRigid ? tmpRigid->getWorldTransform() : colObjWrap->getWorldTransform();
-	const btTransform& wtr = colObjWrap->getWorldTransform();
+	const btCollisionShape* shp = colObjWrap->m_collisionShape;
+	//    const btRigidBody *tmpRigid = btRigidBody::upcast(colObjWrap->m_collisionObject);
+	//const btTransform &wtr = tmpRigid ? tmpRigid->m_worldTransform : colObjWrap->m_worldTransform;
+	const btTransform& wtr = colObjWrap->m_worldTransform;
 	//todo: check which transform is needed here
 
 	btScalar dst =
@@ -2765,7 +2765,7 @@ bool btSoftBody::checkContact(const btCollisionObjectWrapper* colObjWrap,
 			margin);
 	if (dst < 0)
 	{
-		cti.m_colObj = colObjWrap->getCollisionObject();
+		cti.m_colObj = colObjWrap->m_collisionObject;
 		cti.m_normal = wtr.m_basis * nrm;
 		cti.m_offset = -btDot(cti.m_normal, x - cti.m_normal * dst);
 		return (true);
@@ -2780,12 +2780,12 @@ bool btSoftBody::checkDeformableContact(const btCollisionObjectWrapper* colObjWr
 										btSoftBody::sCti& cti, bool predict) const
 {
 	btVector3 nrm;
-	const btCollisionShape* shp = colObjWrap->getCollisionShape();
-	const btCollisionObject* tmpCollisionObj = colObjWrap->getCollisionObject();
+	const btCollisionShape* shp = colObjWrap->m_collisionShape;
+	const btCollisionObject* tmpCollisionObj = colObjWrap->m_collisionObject;
 	// use the position x_{n+1}^* = x_n + dt * v_{n+1}^* where v_{n+1}^* = v_n + dtg for collision detect
 	// but resolve contact at x_n
-	btTransform wtr = (predict) ? (colObjWrap->m_preTransform != NULL ? tmpCollisionObj->getInterpolationWorldTransform() * (*colObjWrap->m_preTransform) : tmpCollisionObj->getInterpolationWorldTransform())
-								: colObjWrap->getWorldTransform();
+	btTransform wtr = (predict) ? (colObjWrap->m_preTransform != NULL ? tmpCollisionObj->m_interpolationWorldTransform * (*colObjWrap->m_preTransform) : tmpCollisionObj->m_interpolationWorldTransform)
+								: colObjWrap->m_worldTransform;
 	btScalar dst =
 		m_worldInfo->m_sparsesdf.Evaluate(
 			wtr.invXform(x),
@@ -2795,7 +2795,7 @@ bool btSoftBody::checkDeformableContact(const btCollisionObjectWrapper* colObjWr
 
 	if (!predict)
 	{
-		cti.m_colObj = colObjWrap->getCollisionObject();
+		cti.m_colObj = colObjWrap->m_collisionObject;
 		cti.m_normal = wtr.m_basis * nrm;
 		cti.m_offset = dst;
 	}
@@ -2839,12 +2839,12 @@ bool btSoftBody::checkDeformableFaceContact(const btCollisionObjectWrapper* colO
 											btSoftBody::sCti& cti, bool predict) const
 {
 	btVector3 nrm;
-	const btCollisionShape* shp = colObjWrap->getCollisionShape();
-	const btCollisionObject* tmpCollisionObj = colObjWrap->getCollisionObject();
+	const btCollisionShape* shp = colObjWrap->m_collisionShape;
+	const btCollisionObject* tmpCollisionObj = colObjWrap->m_collisionObject;
 	// use the position x_{n+1}^* = x_n + dt * v_{n+1}^* where v_{n+1}^* = v_n + dtg for collision detect
 	// but resolve contact at x_n
-	btTransform wtr = (predict) ? (colObjWrap->m_preTransform != NULL ? tmpCollisionObj->getInterpolationWorldTransform() * (*colObjWrap->m_preTransform) : tmpCollisionObj->getInterpolationWorldTransform())
-								: colObjWrap->getWorldTransform();
+	btTransform wtr = (predict) ? (colObjWrap->m_preTransform != NULL ? tmpCollisionObj->m_interpolationWorldTransform * (*colObjWrap->m_preTransform) : tmpCollisionObj->m_interpolationWorldTransform)
+								: colObjWrap->m_worldTransform;
 	btScalar dst;
 	btGjkEpaSolver2::sResults results;
 
@@ -2878,7 +2878,7 @@ bool btSoftBody::checkDeformableFaceContact(const btCollisionObjectWrapper* colO
 			}
 			if (!predict)
 			{
-				cti.m_colObj = colObjWrap->getCollisionObject();
+				cti.m_colObj = colObjWrap->m_collisionObject;
 				cti.m_normal = wtr.m_basis * nrm;
 				cti.m_offset = dst;
 			}
@@ -2909,13 +2909,13 @@ bool btSoftBody::checkDeformableFaceContact(const btCollisionObjectWrapper* colO
 			contact_point = BaryEval(f.m_n[0]->m_x, f.m_n[1]->m_x, f.m_n[2]->m_x, bary);
 			const btConvexShape* csh = static_cast<const btConvexShape*>(shp);
 			btGjkEpaSolver2::SignedDistance(contact_point, margin, csh, wtr, results);
-			cti.m_colObj = colObjWrap->getCollisionObject();
+			cti.m_colObj = colObjWrap->m_collisionObject;
 			dst = results.distance;
 			cti.m_normal = results.normal;
 			cti.m_offset = dst;
 
 			//point-convex CD
-			wtr = colObjWrap->getWorldTransform();
+			wtr = colObjWrap->m_worldTransform;
 			btTriangleShape triangle2(btVector3(0, 0, 0), f.m_n[1]->m_x - f.m_n[0]->m_x, f.m_n[2]->m_x - f.m_n[0]->m_x);
 			triangle_transform.m_origin = (f.m_n[0]->m_x);
 			btGjkEpaSolver2::SignedDistance(&triangle2, triangle_transform, csh, wtr, guess, results);
@@ -2926,7 +2926,7 @@ bool btSoftBody::checkDeformableFaceContact(const btCollisionObjectWrapper* colO
 	}
 
 	// Use triangle-convex CD.
-	wtr = colObjWrap->getWorldTransform();
+	wtr = colObjWrap->m_worldTransform;
 	btTriangleShape triangle2(btVector3(0, 0, 0), f.m_n[1]->m_x - f.m_n[0]->m_x, f.m_n[2]->m_x - f.m_n[0]->m_x);
 	triangle_transform.m_origin = (f.m_n[0]->m_x);
 	btGjkEpaSolver2::SignedDistance(&triangle2, triangle_transform, csh, wtr, guess, results);
@@ -2937,7 +2937,7 @@ bool btSoftBody::checkDeformableFaceContact(const btCollisionObjectWrapper* colO
 		f.m_pcontact[i] = bary[i];
 
 	dst = results.distance - csh->getMargin() - margin;
-	cti.m_colObj = colObjWrap->getCollisionObject();
+	cti.m_colObj = colObjWrap->m_collisionObject;
 	cti.m_normal = results.normal;
 	cti.m_offset = dst;
 	return true;
@@ -2990,16 +2990,16 @@ void btSoftBody::updateBounds()
 	//    {
 	//        const btVector3& mins = m_ndbvt.m_root->volume.Mins();
 	//        const btVector3& maxs = m_ndbvt.m_root->volume.Maxs();
-	//        const btScalar csm = getCollisionShape()->getMargin();
+	//        const btScalar csm = m_collisionShape->getMargin();
 	//        const btVector3 mrg = btVector3(csm,
 	//                                        csm,
 	//                                        csm) *
 	//                              1;  // ??? to investigate...
 	//        m_bounds[0] = mins - mrg;
 	//        m_bounds[1] = maxs + mrg;
-	//        if (0 != getBroadphaseHandle())
+	//        if (0 != m_broadphaseHandle)
 	//        {
-	//            m_worldInfo->m_broadphase->setAabb(getBroadphaseHandle(),
+	//            m_worldInfo->m_broadphase->setAabb(m_broadphaseHandle,
 	//                                               m_bounds[0],
 	//                                               m_bounds[1],
 	//                                               m_worldInfo->m_dispatcher);
@@ -3024,15 +3024,15 @@ void btSoftBody::updateBounds()
 					mins[d] = m_nodes[i].m_x[d];
 			}
 		}
-		const btScalar csm = getCollisionShape()->getMargin();
+		const btScalar csm = m_collisionShape->getMargin();
 		const btVector3 mrg = btVector3(csm,
 										csm,
 										csm);
 		m_bounds[0] = mins - mrg;
 		m_bounds[1] = maxs + mrg;
-		if (0 != getBroadphaseHandle())
+		if (0 != m_broadphaseHandle)
 		{
-			m_worldInfo->m_broadphase->setAabb(getBroadphaseHandle(),
+			m_worldInfo->m_broadphase->setAabb(m_broadphaseHandle,
 											   m_bounds[0],
 											   m_bounds[1],
 											   m_worldInfo->m_dispatcher);
@@ -3878,7 +3878,7 @@ void btSoftBody::PSolve_Anchors(btSoftBody* psb, btScalar kst, btScalar ti)
 	for (int i = 0, ni = psb->m_anchors.size(); i < ni; ++i)
 	{
 		const Anchor& a = psb->m_anchors[i];
-		const btTransform& t = a.m_body->getWorldTransform();
+		const btTransform& t = a.m_body->m_worldTransform;
 		Node& n = *a.m_node;
 		const btVector3 wa = t * a.m_local;
 		const btVector3 va = a.m_body->getVelocityInLocalPoint(a.m_c1) * dt;
@@ -3895,7 +3895,7 @@ void btSoftBody::PSolve_RContacts(btSoftBody* psb, btScalar kst, btScalar ti)
 {
 	BT_PROFILE("PSolve_RContacts");
 	const btScalar dt = psb->m_sst.sdt;
-	const btScalar mrg = psb->getCollisionShape()->getMargin();
+	const btScalar mrg = psb->m_collisionShape->getMargin();
 	btMultiBodyJacobianData jacobianData;
 	for (int i = 0, ni = psb->m_rcontacts.size(); i < ni; ++i)
 	{
@@ -3908,12 +3908,12 @@ void btSoftBody::PSolve_RContacts(btSoftBody* psb, btScalar kst, btScalar ti)
 			btMultiBodyLinkCollider* multibodyLinkCol = 0;
 			btScalar* deltaV = NULL;
 
-			if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+			if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 			{
 				rigidCol = (btRigidBody*)btRigidBody::upcast(cti.m_colObj);
 				va = rigidCol ? rigidCol->getVelocityInLocalPoint(c.m_c1) * dt : btVector3(0, 0, 0);
 			}
-			else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+			else if (cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 			{
 				multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);
 				if (multibodyLinkCol)
@@ -3947,12 +3947,12 @@ void btSoftBody::PSolve_RContacts(btSoftBody* psb, btScalar kst, btScalar ti)
 				const btVector3 impulse = c.m_c0 * ((vr - (fv * c.m_c3) + (cti.m_normal * (dp * c.m_c4))) * kst);
 				c.m_node->m_x -= impulse * c.m_c2;
 
-				if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+				if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 				{
 					if (rigidCol)
 						rigidCol->applyImpulse(impulse, c.m_c1);
 				}
-				else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+				else if (cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 				{
 					if (multibodyLinkCol)
 					{
@@ -4089,17 +4089,17 @@ void btSoftBody::defaultCollisionHandler(const btCollisionObjectWrapper* pcoWrap
 		case fCollision::SDF_RS:
 		{
 			btSoftColliders::CollideSDF_RS docollide;
-			btRigidBody* prb1 = (btRigidBody*)btRigidBody::upcast(pcoWrap->getCollisionObject());
-			btTransform wtr = pcoWrap->getWorldTransform();
+			btRigidBody* prb1 = (btRigidBody*)btRigidBody::upcast(pcoWrap->m_collisionObject);
+			btTransform wtr = pcoWrap->m_worldTransform;
 
-			const btTransform ctr = pcoWrap->getWorldTransform();
+			const btTransform ctr = pcoWrap->m_worldTransform;
 			const btScalar timemargin = (wtr.m_origin - ctr.m_origin).length();
-			const btScalar basemargin = getCollisionShape()->getMargin();
+			const btScalar basemargin = m_collisionShape->getMargin();
 			btVector3 mins;
 			btVector3 maxs;
 			ATTRIBUTE_ALIGNED16(btDbvtVolume)
 			volume;
-			pcoWrap->getCollisionShape()->getAabb(pcoWrap->getWorldTransform(),
+			pcoWrap->m_collisionShape->getAabb(pcoWrap->m_worldTransform,
 												  mins,
 												  maxs);
 			volume = btDbvtVolume::FromMM(mins, maxs);
@@ -4121,17 +4121,17 @@ void btSoftBody::defaultCollisionHandler(const btCollisionObjectWrapper* pcoWrap
 		break;
 		case fCollision::SDF_RD:
 		{
-			btRigidBody* prb1 = (btRigidBody*)btRigidBody::upcast(pcoWrap->getCollisionObject());
+			btRigidBody* prb1 = (btRigidBody*)btRigidBody::upcast(pcoWrap->m_collisionObject);
 			if (this->isActive())
 			{
-				const btTransform wtr = pcoWrap->getWorldTransform();
+				const btTransform wtr = pcoWrap->m_worldTransform;
 				const btScalar timemargin = 0;
-				const btScalar basemargin = getCollisionShape()->getMargin();
+				const btScalar basemargin = m_collisionShape->getMargin();
 				btVector3 mins;
 				btVector3 maxs;
 				ATTRIBUTE_ALIGNED16(btDbvtVolume)
 				volume;
-				pcoWrap->getCollisionShape()->getAabb(wtr,
+				pcoWrap->m_collisionShape->getAabb(wtr,
 													  mins,
 													  maxs);
 				volume = btDbvtVolume::FromMM(mins, maxs);
@@ -4147,7 +4147,7 @@ void btSoftBody::defaultCollisionHandler(const btCollisionObjectWrapper* pcoWrap
 					m_ndbvt.collideTV(m_ndbvt.m_root, volume, docollideNode);
 				}
 
-				if (((pcoWrap->getCollisionObject()->getInternalType() == CO_RIGID_BODY) && (m_cfg.collisions & fCollision::SDF_RDF)) || ((pcoWrap->getCollisionObject()->getInternalType() == CO_FEATHERSTONE_LINK) && (m_cfg.collisions & fCollision::SDF_MDF)))
+				if (((pcoWrap->m_collisionObject->m_internalType == CO_RIGID_BODY) && (m_cfg.collisions & fCollision::SDF_RDF)) || ((pcoWrap->m_collisionObject->m_internalType == CO_FEATHERSTONE_LINK) && (m_cfg.collisions & fCollision::SDF_MDF)))
 				{
 					btSoftColliders::CollideSDF_RDF docollideFace;
 					docollideFace.psb = this;
@@ -4187,8 +4187,8 @@ void btSoftBody::defaultCollisionHandler(btSoftBody* psb)
 			{
 				btSoftColliders::CollideVF_SS docollide;
 				/* common					*/
-				docollide.mrg = getCollisionShape()->getMargin() +
-								psb->getCollisionShape()->getMargin();
+				docollide.mrg = m_collisionShape->getMargin() +
+								psb->m_collisionShape->getMargin();
 				/* psb0 nodes vs psb1 faces	*/
 				docollide.psb[0] = this;
 				docollide.psb[1] = psb;
@@ -4214,8 +4214,8 @@ void btSoftBody::defaultCollisionHandler(btSoftBody* psb)
 				{
 					btSoftColliders::CollideVF_DD docollide;
 					/* common                    */
-					docollide.mrg = getCollisionShape()->getMargin() +
-									psb->getCollisionShape()->getMargin();
+					docollide.mrg = m_collisionShape->getMargin() +
+									psb->m_collisionShape->getMargin();
 					/* psb0 nodes vs psb1 faces    */
 					if (psb->m_tetras.size() > 0)
 						docollide.useFaceNormal = true;
@@ -4243,7 +4243,7 @@ void btSoftBody::defaultCollisionHandler(btSoftBody* psb)
 					if (psb->useSelfCollision())
 					{
 						btSoftColliders::CollideFF_DD docollide;
-						docollide.mrg = 2 * getCollisionShape()->getMargin();
+						docollide.mrg = 2 * m_collisionShape->getMargin();
 						docollide.psb[0] = this;
 						docollide.psb[1] = psb;
 						if (this->m_tetras.size() > 0)
@@ -4715,7 +4715,7 @@ const char* btSoftBody::serialize(void* dataBuffer, class btSerializer* serializ
 
 void btSoftBody::updateDeactivation(btScalar timeStep)
 {
-	if ((getActivationState() == ISLAND_SLEEPING) || (getActivationState() == DISABLE_DEACTIVATION))
+	if ((m_activationState1 == ISLAND_SLEEPING) || (m_activationState1 == DISABLE_DEACTIVATION))
 		return;
 
 	if (m_maxSpeedSquared < m_sleepingThreshold * m_sleepingThreshold)
@@ -4739,14 +4739,14 @@ void btSoftBody::setZeroVelocity()
 
 bool btSoftBody::wantsSleeping()
 {
-	if (getActivationState() == DISABLE_DEACTIVATION)
+	if (m_activationState1 == DISABLE_DEACTIVATION)
 		return false;
 
 	//disable deactivation
 	if (gDisableDeactivation || (gDeactivationTime == btScalar(0.)))
 		return false;
 
-	if ((getActivationState() == ISLAND_SLEEPING) || (getActivationState() == WANTS_DEACTIVATION))
+	if ((m_activationState1 == ISLAND_SLEEPING) || (m_activationState1 == WANTS_DEACTIVATION))
 		return true;
 
 	if (m_deactivationTime > gDeactivationTime)

3rdparty/bullet3/src/BulletSoftBody/btSoftBody.h

@@ -548,7 +548,7 @@ public:
 		const btTransform& xform() const
 		{
 			static const btTransform identity = btTransform::getIdentity();
-			if (m_collisionObject) return (m_collisionObject->getWorldTransform());
+			if (m_collisionObject) return (m_collisionObject->m_worldTransform);
 			if (m_soft) return (m_soft->m_framexform);
 			return (identity);
 		}
@@ -1158,13 +1158,13 @@ public:
 
 	static const btSoftBody* upcast(const btCollisionObject* colObj)
 	{
-		if (colObj->getInternalType() == CO_SOFT_BODY)
+		if (colObj->m_internalType == CO_SOFT_BODY)
 			return (const btSoftBody*)colObj;
 		return 0;
 	}
 	static btSoftBody* upcast(btCollisionObject* colObj)
 	{
-		if (colObj->getInternalType() == CO_SOFT_BODY)
+		if (colObj->m_internalType == CO_SOFT_BODY)
 			return (btSoftBody*)colObj;
 		return 0;
 	}

3rdparty/bullet3/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.cpp

@@ -46,8 +46,8 @@ btSoftBodyConcaveCollisionAlgorithm::~btSoftBodyConcaveCollisionAlgorithm()
 btSoftBodyTriangleCallback::btSoftBodyTriangleCallback(btDispatcher* dispatcher, const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, bool isSwapped) : m_dispatcher(dispatcher),
 																																														 m_dispatchInfoPtr(0)
 {
-	m_softBody = (isSwapped ? (btSoftBody*)body1Wrap->getCollisionObject() : (btSoftBody*)body0Wrap->getCollisionObject());
-	m_triBody = isSwapped ? body0Wrap->getCollisionObject() : body1Wrap->getCollisionObject();
+	m_softBody = (isSwapped ? (btSoftBody*)body1Wrap->m_collisionObject : (btSoftBody*)body0Wrap->m_collisionObject);
+	m_triBody = isSwapped ? body0Wrap->m_collisionObject : body1Wrap->m_collisionObject;
 
 	//
 	// create the manifold from the dispatcher 'manifold pool'
@@ -88,7 +88,7 @@ void btSoftBodyTriangleCallback::processTriangle(btVector3* triangle, int partId
 	if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && (m_dispatchInfoPtr->m_debugDraw->getDebugMode() & btIDebugDraw::DBG_DrawWireframe))
 	{
 		btVector3 color(1, 1, 0);
-		const btTransform& tr = m_triBody->getWorldTransform();
+		const btTransform& tr = m_triBody->m_worldTransform;
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]), tr(triangle[1]), color);
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]), tr(triangle[2]), color);
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]), tr(triangle[0]), color);
@@ -104,11 +104,11 @@ void btSoftBodyTriangleCallback::processTriangle(btVector3* triangle, int partId
 		btAssert(tm);
 
 		//copy over user pointers to temporary shape
-		tm->setUserPointer(m_triBody->getCollisionShape()->getUserPointer());
+		tm->setUserPointer(m_triBody->m_collisionShape->getUserPointer());
 
-		btCollisionObjectWrapper softBody(0, m_softBody->getCollisionShape(), m_softBody, m_softBody->getWorldTransform(), -1, -1);
-		//btCollisionObjectWrapper triBody(0,tm, ob, btTransform::getIdentity());//ob->getWorldTransform());//??
-		btCollisionObjectWrapper triBody(0, tm, m_triBody, m_triBody->getWorldTransform(), partId, triangleIndex);
+		btCollisionObjectWrapper softBody(0, m_softBody->m_collisionShape, m_softBody, m_softBody->m_worldTransform, -1, -1);
+		//btCollisionObjectWrapper triBody(0,tm, ob, btTransform::getIdentity());//ob->m_worldTransform);//??
+		btCollisionObjectWrapper triBody(0, tm, m_triBody, m_triBody->m_worldTransform, partId, triangleIndex);
 		ebtDispatcherQueryType algoType = m_resultOut->m_closestPointDistanceThreshold > 0 ? BT_CLOSEST_POINT_ALGORITHMS : BT_CONTACT_POINT_ALGORITHMS;
 		btCollisionAlgorithm* colAlgo = ci.m_dispatcher1->findAlgorithm(&softBody, &triBody, 0, algoType);  //m_manifoldPtr);
 
@@ -123,7 +123,7 @@ void btSoftBodyTriangleCallback::processTriangle(btVector3* triangle, int partId
 
 	//btCollisionObject* colObj = static_cast<btCollisionObject*>(m_convexProxy->m_clientObject);
 
-	//	if (m_softBody->getCollisionShape()->getShapeType()==
+	//	if (m_softBody->m_collisionShape->getShapeType()==
 	{
 		//		btVector3 other;
 		btVector3 normal = (triangle[1] - triangle[0]).cross(triangle[2] - triangle[0]);
@@ -146,10 +146,10 @@ void btSoftBodyTriangleCallback::processTriangle(btVector3* triangle, int partId
 		//	tm.setMargin(m_collisionMarginTriangle);
 
 		//copy over user pointers to temporary shape
-		tm->setUserPointer(m_triBody->getCollisionShape()->getUserPointer());
+		tm->setUserPointer(m_triBody->m_collisionShape->getUserPointer());
 
-		btCollisionObjectWrapper softBody(0, m_softBody->getCollisionShape(), m_softBody, m_softBody->getWorldTransform(), -1, -1);
-		btCollisionObjectWrapper triBody(0, tm, m_triBody, m_triBody->getWorldTransform(), partId, triangleIndex);  //btTransform::getIdentity());//??
+		btCollisionObjectWrapper softBody(0, m_softBody->m_collisionShape, m_softBody, m_softBody->m_worldTransform, -1, -1);
+		btCollisionObjectWrapper triBody(0, tm, m_triBody, m_triBody->m_worldTransform, partId, triangleIndex);  //btTransform::getIdentity());//??
 
 		ebtDispatcherQueryType algoType = m_resultOut->m_closestPointDistanceThreshold > 0 ? BT_CLOSEST_POINT_ALGORITHMS : BT_CONTACT_POINT_ALGORITHMS;
 		btCollisionAlgorithm* colAlgo = ci.m_dispatcher1->findAlgorithm(&softBody, &triBody, 0, algoType);  //m_manifoldPtr);
@@ -179,7 +179,7 @@ void btSoftBodyTriangleCallback::setTimeStepAndCounters(btScalar collisionMargin
 	softTransform.m_origin = (softBodyCenter);
 
 	btTransform convexInTriangleSpace;
-	convexInTriangleSpace = triBodyWrap->getWorldTransform().inverse() * softTransform;
+	convexInTriangleSpace = triBodyWrap->m_worldTransform.inverse() * softTransform;
 	btTransformAabb(halfExtents, m_collisionMarginTriangle, convexInTriangleSpace, m_aabbMin, m_aabbMax);
 }
 
@@ -193,11 +193,11 @@ void btSoftBodyConcaveCollisionAlgorithm::processCollision(const btCollisionObje
 	//btCollisionObject* convexBody = m_isSwapped ? body1 : body0;
 	const btCollisionObjectWrapper* triBody = m_isSwapped ? body0Wrap : body1Wrap;
 
-	if (triBody->getCollisionShape()->isConcave())
+	if (triBody->m_collisionShape->isConcave())
 	{
-		const btConcaveShape* concaveShape = static_cast<const btConcaveShape*>(triBody->getCollisionShape());
+		const btConcaveShape* concaveShape = static_cast<const btConcaveShape*>(triBody->m_collisionShape);
 
-		//	if (convexBody->getCollisionShape()->isConvex())
+		//	if (convexBody->m_collisionShape->isConvex())
 		{
 			btScalar collisionMarginTriangle = concaveShape->getMargin();
 
@@ -222,7 +222,7 @@ btScalar btSoftBodyConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionO
 
 	//only perform CCD above a certain threshold, this prevents blocking on the long run
 	//because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame...
-	btScalar squareMot0 = (convexbody->getInterpolationWorldTransform().m_origin - convexbody->getWorldTransform().m_origin).length2();
+	btScalar squareMot0 = (convexbody->m_interpolationWorldTransform.m_origin - convexbody->m_worldTransform.m_origin).length2();
 	if (squareMot0 < convexbody->getCcdSquareMotionThreshold())
 	{
 		return btScalar(1.);
@@ -232,9 +232,9 @@ btScalar btSoftBodyConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionO
 	//btVector3 to = convexbody->m_interpolationWorldTransform.m_origin;
 	//todo: only do if the motion exceeds the 'radius'
 
-	btTransform triInv = triBody->getWorldTransform().inverse();
-	btTransform convexFromLocal = triInv * convexbody->getWorldTransform();
-	btTransform convexToLocal = triInv * convexbody->getInterpolationWorldTransform();
+	btTransform triInv = triBody->m_worldTransform.inverse();
+	btTransform convexFromLocal = triInv * convexbody->m_worldTransform;
+	btTransform convexToLocal = triInv * convexbody->m_interpolationWorldTransform;
 
 	struct LocalTriangleSphereCastCallback : public btTriangleCallback
 	{
@@ -279,34 +279,34 @@ btScalar btSoftBodyConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionO
 		}
 	};
 
-	if (triBody->getCollisionShape()->isConcave())
+	if (triBody->m_collisionShape->isConcave())
 	{
 		btVector3 rayAabbMin = convexFromLocal.m_origin;
 		rayAabbMin.setMin(convexToLocal.m_origin);
 		btVector3 rayAabbMax = convexFromLocal.m_origin;
 		rayAabbMax.setMax(convexToLocal.m_origin);
-		btScalar ccdRadius0 = convexbody->getCcdSweptSphereRadius();
+		btScalar ccdRadius0 = convexbody->m_ccdSweptSphereRadius;
 		rayAabbMin -= btVector3(ccdRadius0, ccdRadius0, ccdRadius0);
 		rayAabbMax += btVector3(ccdRadius0, ccdRadius0, ccdRadius0);
 
 		btScalar curHitFraction = btScalar(1.);  //is this available?
 		LocalTriangleSphereCastCallback raycastCallback(convexFromLocal, convexToLocal,
-														convexbody->getCcdSweptSphereRadius(), curHitFraction);
+														convexbody->m_ccdSweptSphereRadius, curHitFraction);
 
-		raycastCallback.m_hitFraction = convexbody->getHitFraction();
+		raycastCallback.m_hitFraction = convexbody->m_hitFraction;
 
 		btCollisionObject* concavebody = triBody;
 
-		btConcaveShape* triangleMesh = (btConcaveShape*)concavebody->getCollisionShape();
+		btConcaveShape* triangleMesh = (btConcaveShape*)concavebody->m_collisionShape;
 
 		if (triangleMesh)
 		{
 			triangleMesh->processAllTriangles(&raycastCallback, rayAabbMin, rayAabbMax);
 		}
 
-		if (raycastCallback.m_hitFraction < convexbody->getHitFraction())
+		if (raycastCallback.m_hitFraction < convexbody->m_hitFraction)
 		{
-			convexbody->setHitFraction(raycastCallback.m_hitFraction);
+			convexbody->m_hitFraction = (raycastCallback.m_hitFraction);
 			return raycastCallback.m_hitFraction;
 		}
 	}

3rdparty/bullet3/src/BulletSoftBody/btSoftBodyHelpers.cpp

@@ -360,7 +360,7 @@ void btSoftBodyHelpers::Draw(btSoftBody* psb,
 		for (i = 0; i < psb->m_anchors.size(); ++i)
 		{
 			const btSoftBody::Anchor& a = psb->m_anchors[i];
-			const btVector3 q = a.m_body->getWorldTransform() * a.m_local;
+			const btVector3 q = a.m_body->m_worldTransform * a.m_local;
 			drawVertex(idraw, a.m_node->m_x, 0.25, btVector3(1, 0, 0));
 			drawVertex(idraw, q, 0.25, btVector3(0, 1, 0));
 			idraw->drawLine(a.m_node->m_x, q, btVector3(1, 1, 1));

3rdparty/bullet3/src/BulletSoftBody/btSoftBodyInternals.h

@@ -1496,24 +1496,24 @@ struct btSoftColliders
 			btSoftBody::Cluster* cluster = (btSoftBody::Cluster*)leaf->data;
 			btSoftClusterCollisionShape cshape(cluster);
 
-			const btConvexShape* rshape = (const btConvexShape*)m_colObjWrap->getCollisionShape();
+			const btConvexShape* rshape = (const btConvexShape*)m_colObjWrap->m_collisionShape;
 
 			///don't collide an anchored cluster with a static/kinematic object
-			if (m_colObjWrap->getCollisionObject()->isStaticOrKinematicObject() && cluster->m_containsAnchor)
+			if (m_colObjWrap->m_collisionObject->isStaticOrKinematicObject() && cluster->m_containsAnchor)
 				return;
 
 			btGjkEpaSolver2::sResults res;
 			if (btGjkEpaSolver2::SignedDistance(&cshape, btTransform::getIdentity(),
-												rshape, m_colObjWrap->getWorldTransform(),
+												rshape, m_colObjWrap->m_worldTransform,
 												btVector3(1, 0, 0), res))
 			{
 				btSoftBody::CJoint joint;
-				if (SolveContact(res, cluster, m_colObjWrap->getCollisionObject(), joint))  //prb,joint))
+				if (SolveContact(res, cluster, m_colObjWrap->m_collisionObject, joint))  //prb,joint))
 				{
 					btSoftBody::CJoint* pj = new (btAlignedAlloc(sizeof(btSoftBody::CJoint), 16)) btSoftBody::CJoint();
 					*pj = joint;
 					psb->m_joints.push_back(pj);
-					if (m_colObjWrap->getCollisionObject()->isStaticOrKinematicObject())
+					if (m_colObjWrap->m_collisionObject->isStaticOrKinematicObject())
 					{
 						pj->m_erp *= psb->m_cfg.kSKHR_CL;
 						pj->m_split *= psb->m_cfg.kSK_SPLT_CL;
@@ -1531,15 +1531,15 @@ struct btSoftColliders
 			psb = ps;
 			m_colObjWrap = colObWrap;
 			idt = ps->m_sst.isdt;
-			m_margin = m_colObjWrap->getCollisionShape()->getMargin() + psb->getCollisionShape()->getMargin();
+			m_margin = m_colObjWrap->m_collisionShape->getMargin() + psb->m_collisionShape->getMargin();
 			///Bullet rigid body uses multiply instead of minimum to determine combined friction. Some customization would be useful.
-			friction = btMin(psb->m_cfg.kDF, m_colObjWrap->getCollisionObject()->getFriction());
+			friction = btMin(psb->m_cfg.kDF, m_colObjWrap->m_collisionObject->m_friction);
 			btVector3 mins;
 			btVector3 maxs;
 
 			ATTRIBUTE_ALIGNED16(btDbvtVolume)
 			volume;
-			colObWrap->getCollisionShape()->getAabb(colObWrap->getWorldTransform(), mins, maxs);
+			colObWrap->m_collisionShape->getAabb(colObWrap->m_worldTransform, mins, maxs);
 			volume = btDbvtVolume::FromMM(mins, maxs);
 			volume.Expand(btVector3(1, 1, 1) * m_margin);
 			ps->m_cdbvt.collideTV(ps->m_cdbvt.m_root, volume, *this);
@@ -1592,8 +1592,8 @@ struct btSoftColliders
 		void ProcessSoftSoft(btSoftBody* psa, btSoftBody* psb)
 		{
 			idt = psa->m_sst.isdt;
-			//m_margin		=	(psa->getCollisionShape()->getMargin()+psb->getCollisionShape()->getMargin())/2;
-			m_margin = (psa->getCollisionShape()->getMargin() + psb->getCollisionShape()->getMargin());
+			//m_margin		=	(psa->m_collisionShape->getMargin()+psb->m_collisionShape->getMargin())/2;
+			m_margin = (psa->m_collisionShape->getMargin() + psb->m_collisionShape->getMargin());
 			friction = btMin(psa->m_cfg.kDF, psb->m_cfg.kDF);
 			bodies[0] = psa;
 			bodies[1] = psb;
@@ -1623,7 +1623,7 @@ struct btSoftColliders
 				const btScalar ms = ima + imb;
 				if (ms > 0)
 				{
-					const btTransform& wtr = m_rigidBody ? m_rigidBody->getWorldTransform() : m_colObj1Wrap->getCollisionObject()->getWorldTransform();
+					const btTransform& wtr = m_rigidBody ? m_rigidBody->m_worldTransform : m_colObj1Wrap->m_collisionObject->m_worldTransform;
 					static const btMatrix3x3 iwiStatic(0, 0, 0, 0, 0, 0, 0, 0, 0);
 					const btMatrix3x3& iwi = m_rigidBody ? m_rigidBody->getInvInertiaTensorWorld() : iwiStatic;
 					const btVector3 ra = n.m_x - wtr.m_origin;
@@ -1632,13 +1632,13 @@ struct btSoftColliders
 					const btVector3 vr = vb - va;
 					const btScalar dn = btDot(vr, c.m_cti.m_normal);
 					const btVector3 fv = vr - c.m_cti.m_normal * dn;
-					const btScalar fc = psb->m_cfg.kDF * m_colObj1Wrap->getCollisionObject()->getFriction();
+					const btScalar fc = psb->m_cfg.kDF * m_colObj1Wrap->m_collisionObject->m_friction;
 					c.m_node = &n;
 					c.m_c0 = ImpulseMatrix(psb->m_sst.sdt, ima, imb, iwi, ra);
 					c.m_c1 = ra;
 					c.m_c2 = ima * psb->m_sst.sdt;
 					c.m_c3 = fv.length2() < (dn * fc * dn * fc) ? 0 : 1 - fc;
-					c.m_c4 = m_colObj1Wrap->getCollisionObject()->isStaticOrKinematicObject() ? psb->m_cfg.kKHR : psb->m_cfg.kCHR;
+					c.m_c4 = m_colObj1Wrap->m_collisionObject->isStaticOrKinematicObject() ? psb->m_cfg.kKHR : psb->m_cfg.kCHR;
 					psb->m_rcontacts.push_back(c);
 					if (m_rigidBody)
 						m_rigidBody->activate();
@@ -1682,15 +1682,15 @@ struct btSoftColliders
 						psb->checkDeformableContact(m_colObj1Wrap, n.m_x, m, c.m_cti, /*predict = */ false);
 						btSoftBody::sCti& cti = c.m_cti;
 						c.m_node = &n;
-						const btScalar fc = psb->m_cfg.kDF * m_colObj1Wrap->getCollisionObject()->getFriction();
+						const btScalar fc = psb->m_cfg.kDF * m_colObj1Wrap->m_collisionObject->m_friction;
 						c.m_c2 = ima;
 						c.m_c3 = fc;
-						c.m_c4 = m_colObj1Wrap->getCollisionObject()->isStaticOrKinematicObject() ? psb->m_cfg.kKHR : psb->m_cfg.kCHR;
+						c.m_c4 = m_colObj1Wrap->m_collisionObject->isStaticOrKinematicObject() ? psb->m_cfg.kKHR : psb->m_cfg.kCHR;
 						c.m_c5 = n.m_effectiveMass_inv;
 
-						if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+						if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 						{
-							const btTransform& wtr = m_rigidBody ? m_rigidBody->getWorldTransform() : m_colObj1Wrap->getCollisionObject()->getWorldTransform();
+							const btTransform& wtr = m_rigidBody ? m_rigidBody->m_worldTransform : m_colObj1Wrap->m_collisionObject->m_worldTransform;
 							const btVector3 ra = n.m_x - wtr.m_origin;
 
 							static const btMatrix3x3 iwiStatic(0, 0, 0, 0, 0, 0, 0, 0, 0);
@@ -1706,7 +1706,7 @@ struct btSoftColliders
 							}
 							c.m_c1 = ra;
 						}
-						else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+						else if (cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 						{
 							btMultiBodyLinkCollider* multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);
 							if (multibodyLinkCol)
@@ -1798,17 +1798,17 @@ struct btSoftColliders
 					c.m_face = &f;
 					// friction is handled by the nodes to prevent sticking
 					//                    const btScalar fc = 0;
-					const btScalar fc = psb->m_cfg.kDF * m_colObj1Wrap->getCollisionObject()->getFriction();
+					const btScalar fc = psb->m_cfg.kDF * m_colObj1Wrap->m_collisionObject->m_friction;
 
 					// the effective inverse mass of the face as in https://graphics.stanford.edu/papers/cloth-sig02/cloth.pdf
 					ima = bary.m_floats[0] * c.m_weights.m_floats[0] * n0->m_im + bary.m_floats[1] * c.m_weights.m_floats[1] * n1->m_im + bary.m_floats[2] * c.m_weights.m_floats[2] * n2->m_im;
 					c.m_c2 = ima;
 					c.m_c3 = fc;
-					c.m_c4 = m_colObj1Wrap->getCollisionObject()->isStaticOrKinematicObject() ? psb->m_cfg.kKHR : psb->m_cfg.kCHR;
+					c.m_c4 = m_colObj1Wrap->m_collisionObject->isStaticOrKinematicObject() ? psb->m_cfg.kKHR : psb->m_cfg.kCHR;
 					c.m_c5 = Diagonal(ima);
-					if (cti.m_colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY)
+					if (cti.m_colObj->m_internalType == btCollisionObject::CO_RIGID_BODY)
 					{
-						const btTransform& wtr = m_rigidBody ? m_rigidBody->getWorldTransform() : m_colObj1Wrap->getCollisionObject()->getWorldTransform();
+						const btTransform& wtr = m_rigidBody ? m_rigidBody->m_worldTransform : m_colObj1Wrap->m_collisionObject->m_worldTransform;
 						static const btMatrix3x3 iwiStatic(0, 0, 0, 0, 0, 0, 0, 0, 0);
 						const btMatrix3x3& iwi = m_rigidBody ? m_rigidBody->getInvInertiaTensorWorld() : iwiStatic;
 						const btVector3 ra = contact_point - wtr.m_origin;
@@ -1817,7 +1817,7 @@ struct btSoftColliders
 						c.m_c0 = ImpulseMatrix(1, ima, imb, iwi, ra);
 						c.m_c1 = ra;
 					}
-					else if (cti.m_colObj->getInternalType() == btCollisionObject::CO_FEATHERSTONE_LINK)
+					else if (cti.m_colObj->m_internalType == btCollisionObject::CO_FEATHERSTONE_LINK)
 					{
 						btMultiBodyLinkCollider* multibodyLinkCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(cti.m_colObj);
 						if (multibodyLinkCol)

3rdparty/bullet3/src/BulletSoftBody/btSoftMultiBodyDynamicsWorld.cpp

@@ -222,18 +222,18 @@ struct btSoftSingleRayCallback : public btBroadphaseRayCallback
 		btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
 
 		//only perform raycast if filterMask matches
-		if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
+		if (m_resultCallback.needsCollision(collisionObject->m_broadphaseHandle))
 		{
 			//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
 			//btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
 #if 0
 #ifdef RECALCULATE_AABB
 			btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
-			collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
+			collisionObject->m_collisionShape->getAabb(collisionObject->m_worldTransform,collisionObjectAabbMin,collisionObjectAabbMax);
 #else
-			//getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax);
-			const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
-			const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
+			//getBroadphase()->getAabb(collisionObject->m_broadphaseHandle,collisionObjectAabbMin,collisionObjectAabbMax);
+			const btVector3& collisionObjectAabbMin = collisionObject->m_broadphaseHandle->m_aabbMin;
+			const btVector3& collisionObjectAabbMax = collisionObject->m_broadphaseHandle->m_aabbMax;
 #endif
 #endif
 			//btScalar hitLambda = m_resultCallback.m_closestHitFraction;
@@ -242,8 +242,8 @@ struct btSoftSingleRayCallback : public btBroadphaseRayCallback
 			{
 				m_world->rayTestSingle(m_rayFromTrans, m_rayToTrans,
 									   collisionObject,
-									   collisionObject->getCollisionShape(),
-									   collisionObject->getWorldTransform(),
+									   collisionObject->m_collisionShape,
+									   collisionObject->m_worldTransform,
 									   m_resultCallback);
 			}
 		}
@@ -263,7 +263,7 @@ void btSoftMultiBodyDynamicsWorld::rayTest(const btVector3& rayFromWorld, const
 #else
 	for (int i = 0; i < this->getNumCollisionObjects(); i++)
 	{
-		rayCB.process(m_collisionObjects[i]->getBroadphaseHandle());
+		rayCB.process(m_collisionObjects[i]->m_broadphaseHandle);
 	}
 #endif  //USE_BRUTEFORCE_RAYBROADPHASE
 }
@@ -325,7 +325,7 @@ void btSoftMultiBodyDynamicsWorld::serializeSoftBodies(btSerializer* serializer)
 	for (i = 0; i < m_collisionObjects.size(); i++)
 	{
 		btCollisionObject* colObj = m_collisionObjects[i];
-		if (colObj->getInternalType() & btCollisionObject::CO_SOFT_BODY)
+		if (colObj->m_internalType & btCollisionObject::CO_SOFT_BODY)
 		{
 			int len = colObj->calculateSerializeBufferSize();
 			btChunk* chunk = serializer->allocate(len, 1);

3rdparty/bullet3/src/BulletSoftBody/btSoftRigidCollisionAlgorithm.cpp

@@ -57,10 +57,10 @@ void btSoftRigidCollisionAlgorithm::processCollision(const btCollisionObjectWrap
 	//printf("btSoftRigidCollisionAlgorithm\n");
 	//	const btCollisionObjectWrapper* softWrap = m_isSwapped?body1Wrap:body0Wrap;
 	//	const btCollisionObjectWrapper* rigidWrap = m_isSwapped?body0Wrap:body1Wrap;
-	btSoftBody* softBody = m_isSwapped ? (btSoftBody*)body1Wrap->getCollisionObject() : (btSoftBody*)body0Wrap->getCollisionObject();
+	btSoftBody* softBody = m_isSwapped ? (btSoftBody*)body1Wrap->m_collisionObject : (btSoftBody*)body0Wrap->m_collisionObject;
 	const btCollisionObjectWrapper* rigidCollisionObjectWrap = m_isSwapped ? body0Wrap : body1Wrap;
 
-	if (softBody->m_collisionDisabledObjects.findLinearSearch(rigidCollisionObjectWrap->getCollisionObject()) == softBody->m_collisionDisabledObjects.size())
+	if (softBody->m_collisionDisabledObjects.findLinearSearch(rigidCollisionObjectWrap->m_collisionObject) == softBody->m_collisionDisabledObjects.size())
 	{
 		softBody->getSoftBodySolver()->processCollision(softBody, rigidCollisionObjectWrap);
 	}

3rdparty/bullet3/src/BulletSoftBody/btSoftRigidDynamicsWorld.cpp

@@ -217,18 +217,18 @@ struct btSoftSingleRayCallback : public btBroadphaseRayCallback
 		btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
 
 		//only perform raycast if filterMask matches
-		if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
+		if (m_resultCallback.needsCollision(collisionObject->m_broadphaseHandle))
 		{
 			//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
 			//btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
 #if 0
 #ifdef RECALCULATE_AABB
 			btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
-			collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
+			collisionObject->m_collisionShape->getAabb(collisionObject->m_worldTransform,collisionObjectAabbMin,collisionObjectAabbMax);
 #else
-			//getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax);
-			const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
-			const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
+			//getBroadphase()->getAabb(collisionObject->m_broadphaseHandle,collisionObjectAabbMin,collisionObjectAabbMax);
+			const btVector3& collisionObjectAabbMin = collisionObject->m_broadphaseHandle->m_aabbMin;
+			const btVector3& collisionObjectAabbMax = collisionObject->m_broadphaseHandle->m_aabbMax;
 #endif
 #endif
 			//btScalar hitLambda = m_resultCallback.m_closestHitFraction;
@@ -237,8 +237,8 @@ struct btSoftSingleRayCallback : public btBroadphaseRayCallback
 			{
 				m_world->rayTestSingle(m_rayFromTrans, m_rayToTrans,
 									   collisionObject,
-									   collisionObject->getCollisionShape(),
-									   collisionObject->getWorldTransform(),
+									   collisionObject->m_collisionShape,
+									   collisionObject->m_worldTransform,
 									   m_resultCallback);
 			}
 		}
@@ -258,7 +258,7 @@ void btSoftRigidDynamicsWorld::rayTest(const btVector3& rayFromWorld, const btVe
 #else
 	for (int i = 0; i < this->getNumCollisionObjects(); i++)
 	{
-		rayCB.process(m_collisionObjects[i]->getBroadphaseHandle());
+		rayCB.process(m_collisionObjects[i]->m_broadphaseHandle);
 	}
 #endif  //USE_BRUTEFORCE_RAYBROADPHASE
 }
@@ -320,7 +320,7 @@ void btSoftRigidDynamicsWorld::serializeSoftBodies(btSerializer* serializer)
 	for (i = 0; i < m_collisionObjects.size(); i++)
 	{
 		btCollisionObject* colObj = m_collisionObjects[i];
-		if (colObj->getInternalType() & btCollisionObject::CO_SOFT_BODY)
+		if (colObj->m_internalType & btCollisionObject::CO_SOFT_BODY)
 		{
 			int len = colObj->calculateSerializeBufferSize();
 			btChunk* chunk = serializer->allocate(len, 1);

3rdparty/bullet3/src/BulletSoftBody/btSoftSoftCollisionAlgorithm.cpp

@@ -36,8 +36,8 @@ btSoftSoftCollisionAlgorithm::~btSoftSoftCollisionAlgorithm()
 
 void btSoftSoftCollisionAlgorithm::processCollision(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, const btDispatcherInfo& /*dispatchInfo*/, btManifoldResult* /*resultOut*/)
 {
-	btSoftBody* soft0 = (btSoftBody*)body0Wrap->getCollisionObject();
-	btSoftBody* soft1 = (btSoftBody*)body1Wrap->getCollisionObject();
+	btSoftBody* soft0 = (btSoftBody*)body0Wrap->m_collisionObject;
+	btSoftBody* soft1 = (btSoftBody*)body1Wrap->m_collisionObject;
 	soft0->getSoftBodySolver()->processCollision(soft0, soft1);
 }
 

src/world/physics_world_bullet.cpp

@@ -502,11 +502,11 @@ struct PhysicsWorldImpl
 		// Create rigid body
 		btRigidBody *body = CE_NEW(*_allocator, btRigidBody)(rbinfo);
 
-		int cflags = body->getCollisionFlags();
+		int cflags = body->m_collisionFlags;
 		cflags |= is_kinematic ? btCollisionObject::CF_KINEMATIC_OBJECT    : 0;
 		cflags |= is_static    ? btCollisionObject::CF_STATIC_OBJECT       : 0;
 		cflags |= is_trigger   ? btCollisionObject::CF_NO_CONTACT_RESPONSE : 0;
-		body->setCollisionFlags(cflags);
+		body->m_collisionFlags = (cflags);
 		if (is_kinematic)
 			body->setActivationState(DISABLE_DEACTIVATION);
 
@@ -521,7 +521,7 @@ struct PhysicsWorldImpl
 			));
 
 		const u32 last = array::size(_actor);
-		body->setUserPointer((void *)(uintptr_t)last);
+		body->m_userObjectPointer = ((void *)(uintptr_t)last);
 
 		// Set collision filters
 		const u32 me   = physics_config_resource::filter(_config_resource, ar->collision_filter)->me;
@@ -551,7 +551,7 @@ struct PhysicsWorldImpl
 		CE_DELETE(*_allocator, _actor[actor.i].body);
 
 		_actor[actor.i] = _actor[last];
-		_actor[actor.i].body->setUserPointer((void *)(uintptr_t)actor.i);
+		_actor[actor.i].body->m_userObjectPointer = ((void *)(uintptr_t)actor.i);
 
 		array::pop_back(_actor);
 
@@ -641,25 +641,25 @@ struct PhysicsWorldImpl
 	void actor_set_kinematic(ActorInstance actor, bool kinematic)
 	{
 		btRigidBody *body = _actor[actor.i].body;
-		int flags = body->getCollisionFlags();
+		int flags = body->m_collisionFlags;
 
 		if (kinematic) {
-			body->setCollisionFlags(flags | btCollisionObject::CF_KINEMATIC_OBJECT);
+			body->m_collisionFlags = (flags | btCollisionObject::CF_KINEMATIC_OBJECT);
 			body->setActivationState(DISABLE_DEACTIVATION);
 		} else {
-			body->setCollisionFlags(flags & ~btCollisionObject::CF_KINEMATIC_OBJECT);
+			body->m_collisionFlags = (flags & ~btCollisionObject::CF_KINEMATIC_OBJECT);
 			body->setActivationState(ACTIVE_TAG);
 		}
 	}
 
 	bool actor_is_static(ActorInstance actor) const
 	{
-		return _actor[actor.i].body->getCollisionFlags() & btCollisionObject::CF_STATIC_OBJECT;
+		return _actor[actor.i].body->m_collisionFlags & btCollisionObject::CF_STATIC_OBJECT;
 	}
 
 	bool actor_is_dynamic(ActorInstance actor) const
 	{
-		const int flags = _actor[actor.i].body->getCollisionFlags();
+		const int flags = _actor[actor.i].body->m_collisionFlags;
 		return !(flags & btCollisionObject::CF_STATIC_OBJECT)
 			&& !(flags & btCollisionObject::CF_KINEMATIC_OBJECT)
 			;
@@ -667,7 +667,7 @@ struct PhysicsWorldImpl
 
 	bool actor_is_kinematic(ActorInstance actor) const
 	{
-		const int flags = _actor[actor.i].body->getCollisionFlags();
+		const int flags = _actor[actor.i].body->m_collisionFlags;
 		return (flags & (btCollisionObject::CF_KINEMATIC_OBJECT)) != 0;
 	}
 
@@ -839,7 +839,7 @@ struct PhysicsWorldImpl
 		_dynamics_world->rayTest(aa, bb, cb);
 
 		if (cb.hasHit()) {
-			const u32 actor_i = (u32)(uintptr_t)btRigidBody::upcast(cb.m_collisionObject)->getUserPointer();
+			const u32 actor_i = (u32)(uintptr_t)btRigidBody::upcast(cb.m_collisionObject)->m_userObjectPointer;
 
 			hit.position = to_vector3(cb.m_hitPointWorld);
 			hit.normal   = to_vector3(cb.m_hitNormalWorld);
@@ -869,7 +869,7 @@ struct PhysicsWorldImpl
 			array::resize(hits, num);
 
 			for (int i = 0; i < num; ++i) {
-				const u32 actor_i = (u32)(uintptr_t)btRigidBody::upcast(cb.m_collisionObjects[i])->getUserPointer();
+				const u32 actor_i = (u32)(uintptr_t)btRigidBody::upcast(cb.m_collisionObjects[i])->m_userObjectPointer;
 
 				hits[i].position = to_vector3(cb.m_hitPointWorld[i]);
 				hits[i].normal   = to_vector3(cb.m_hitNormalWorld[i]);
@@ -896,7 +896,7 @@ struct PhysicsWorldImpl
 		_dynamics_world->convexSweepTest(shape, aa, bb, cb);
 
 		if (cb.hasHit()) {
-			const u32 actor_i = (u32)(uintptr_t)btRigidBody::upcast(cb.m_hitCollisionObject)->getUserPointer();
+			const u32 actor_i = (u32)(uintptr_t)btRigidBody::upcast(cb.m_hitCollisionObject)->m_userObjectPointer;
 
 			hit.position = to_vector3(cb.m_hitPointWorld);
 			hit.normal   = to_vector3(cb.m_hitNormalWorld);
@@ -956,7 +956,7 @@ struct PhysicsWorldImpl
 		const btCollisionObjectArray &collision_array = _dynamics_world->getCollisionObjectArray();
 		// Update actors
 		for (int i = 0; i < num; ++i) {
-			if ((uintptr_t)collision_array[i]->getUserPointer() == (uintptr_t)UINT32_MAX)
+			if ((uintptr_t)collision_array[i]->m_userObjectPointer == (uintptr_t)UINT32_MAX)
 				continue;
 
 			btRigidBody *body = btRigidBody::upcast(collision_array[i]);
@@ -964,7 +964,7 @@ struct PhysicsWorldImpl
 				&& body->getMotionState()
 				&& body->isActive()
 				) {
-				const UnitId unit_id = _actor[(u32)(uintptr_t)body->getUserPointer()].unit;
+				const UnitId unit_id = _actor[(u32)(uintptr_t)body->m_userObjectPointer].unit;
 
 				btTransform tr;
 				body->getMotionState()->getWorldTransform(tr);
@@ -1019,8 +1019,8 @@ struct PhysicsWorldImpl
 
 			const btCollisionObject *obj_a = manifold->getBody0();
 			const btCollisionObject *obj_b = manifold->getBody1();
-			const ActorInstance a0 = make_actor_instance((u32)(uintptr_t)obj_a->getUserPointer());
-			const ActorInstance a1 = make_actor_instance((u32)(uintptr_t)obj_b->getUserPointer());
+			const ActorInstance a0 = make_actor_instance((u32)(uintptr_t)obj_a->m_userObjectPointer);
+			const ActorInstance a1 = make_actor_instance((u32)(uintptr_t)obj_b->m_userObjectPointer);
 			const UnitId u0 = _actor[a0.i].unit;
 			const UnitId u1 = _actor[a1.i].unit;