3rdparty: bullet3: remove getters/setters from btRigidBody

Part-of: #259

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

@@ -883,10 +883,10 @@ void btKinematicCharacterController::jump(const btVector3& v)
 #if 0
 	currently no jumping.
 	btTransform xform;
-	m_rigidBody->getMotionState()->getWorldTransform (xform);
+	m_rigidBody->m_optionalMotionState->getWorldTransform (xform);
 	btVector3 up = xform.m_basis[1];
 	up.normalize ();
-	btScalar magnitude = (btScalar(1.0)/m_rigidBody->getInvMass()) * btScalar(8.0);
+	btScalar magnitude = (btScalar(1.0)/m_rigidBody->m_inverseMass) * btScalar(8.0);
 	m_rigidBody->applyCentralImpulse (up * magnitude);
 #endif
 }

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

@@ -75,7 +75,7 @@ void btConeTwistConstraint::getInfo1(btConstraintInfo1* info)
 	{
 		info->m_numConstraintRows = 3;
 		info->nub = 3;
-		calcAngleInfo2(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getInvInertiaTensorWorld(), m_rbB.getInvInertiaTensorWorld());
+		calcAngleInfo2(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.m_invInertiaTensorWorld, m_rbB.m_invInertiaTensorWorld);
 		if (m_solveSwingLimit)
 		{
 			info->m_numConstraintRows++;
@@ -103,7 +103,7 @@ void btConeTwistConstraint::getInfo1NonVirtual(btConstraintInfo1* info)
 
 void btConeTwistConstraint::getInfo2(btConstraintInfo2* info)
 {
-	getInfo2NonVirtual(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getInvInertiaTensorWorld(), m_rbB.getInvInertiaTensorWorld());
+	getInfo2NonVirtual(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.m_invInertiaTensorWorld, m_rbB.m_invInertiaTensorWorld);
 }
 
 void btConeTwistConstraint::getInfo2NonVirtual(btConstraintInfo2* info, const btTransform& transA, const btTransform& transB, const btMatrix3x3& invInertiaWorldA, const btMatrix3x3& invInertiaWorldB)
@@ -278,14 +278,14 @@ void btConeTwistConstraint::buildJacobian()
 					pivotAInW - m_rbA.getCenterOfMassPosition(),
 					pivotBInW - m_rbB.getCenterOfMassPosition(),
 					normal[i],
-					m_rbA.getInvInertiaDiagLocal(),
-					m_rbA.getInvMass(),
-					m_rbB.getInvInertiaDiagLocal(),
-					m_rbB.getInvMass());
+					m_rbA.m_invInertiaLocal,
+					m_rbA.m_inverseMass,
+					m_rbB.m_invInertiaLocal,
+					m_rbB.m_inverseMass);
 			}
 		}
 
-		calcAngleInfo2(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getInvInertiaTensorWorld(), m_rbB.getInvInertiaTensorWorld());
+		calcAngleInfo2(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.m_invInertiaTensorWorld, m_rbB.m_invInertiaTensorWorld);
 	}
 }
 
@@ -325,8 +325,8 @@ void btConeTwistConstraint::solveConstraintObsolete(btSolverBody& bodyA, btSolve
 
 				btVector3 ftorqueAxis1 = rel_pos1.cross(normal);
 				btVector3 ftorqueAxis2 = rel_pos2.cross(normal);
-				bodyA.internalApplyImpulse(normal * m_rbA.getInvMass(), m_rbA.getInvInertiaTensorWorld() * ftorqueAxis1, impulse);
-				bodyB.internalApplyImpulse(normal * m_rbB.getInvMass(), m_rbB.getInvInertiaTensorWorld() * ftorqueAxis2, -impulse);
+				bodyA.internalApplyImpulse(normal * m_rbA.m_inverseMass, m_rbA.m_invInertiaTensorWorld * ftorqueAxis1, impulse);
+				bodyB.internalApplyImpulse(normal * m_rbB.m_inverseMass, m_rbB.m_invInertiaTensorWorld * ftorqueAxis2, -impulse);
 			}
 		}
 
@@ -415,8 +415,8 @@ void btConeTwistConstraint::solveConstraintObsolete(btSolverBody& bodyA, btSolve
 				btScalar impulseMag = impulse.length();
 				btVector3 impulseAxis = impulse / impulseMag;
 
-				bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.getInvInertiaTensorWorld() * impulseAxis, impulseMag);
-				bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.getInvInertiaTensorWorld() * impulseAxis, -impulseMag);
+				bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.m_invInertiaTensorWorld * impulseAxis, impulseMag);
+				bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.m_invInertiaTensorWorld * impulseAxis, -impulseMag);
 			}
 		}
 		else if (m_damping > SIMD_EPSILON)  // no motor: do a little damping
@@ -436,8 +436,8 @@ void btConeTwistConstraint::solveConstraintObsolete(btSolverBody& bodyA, btSolve
 
 				btScalar impulseMag = impulse.length();
 				btVector3 impulseAxis = impulse / impulseMag;
-				bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.getInvInertiaTensorWorld() * impulseAxis, impulseMag);
-				bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.getInvInertiaTensorWorld() * impulseAxis, -impulseMag);
+				bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.m_invInertiaTensorWorld * impulseAxis, impulseMag);
+				bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.m_invInertiaTensorWorld * impulseAxis, -impulseMag);
 			}
 		}
 
@@ -476,8 +476,8 @@ void btConeTwistConstraint::solveConstraintObsolete(btSolverBody& bodyA, btSolve
 				impulseMag = impulse.length();
 				btVector3 noTwistSwingAxis = impulse / impulseMag;
 
-				bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.getInvInertiaTensorWorld() * noTwistSwingAxis, impulseMag);
-				bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.getInvInertiaTensorWorld() * noTwistSwingAxis, -impulseMag);
+				bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.m_invInertiaTensorWorld * noTwistSwingAxis, impulseMag);
+				bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.m_invInertiaTensorWorld * noTwistSwingAxis, -impulseMag);
 			}
 
 			// solve twist limit
@@ -496,8 +496,8 @@ void btConeTwistConstraint::solveConstraintObsolete(btSolverBody& bodyA, btSolve
 
 				//		btVector3 impulse = m_twistAxis * impulseMag;
 
-				bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.getInvInertiaTensorWorld() * m_twistAxis, impulseMag);
-				bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.getInvInertiaTensorWorld() * m_twistAxis, -impulseMag);
+				bodyA.internalApplyImpulse(btVector3(0, 0, 0), m_rbA.m_invInertiaTensorWorld * m_twistAxis, impulseMag);
+				bodyB.internalApplyImpulse(btVector3(0, 0, 0), m_rbB.m_invInertiaTensorWorld * m_twistAxis, -impulseMag);
 			}
 		}
 	}

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

@@ -126,17 +126,17 @@ void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1,
 
 	btJacobianEntry jac(body1.getCenterOfMassTransform().m_basis.transpose(),
 						body2.getCenterOfMassTransform().m_basis.transpose(),
-						rel_pos1, rel_pos2, normal, body1.getInvInertiaDiagLocal(), body1.getInvMass(),
-						body2.getInvInertiaDiagLocal(), body2.getInvMass());
+						rel_pos1, rel_pos2, normal, body1.m_invInertiaLocal, body1.m_inverseMass,
+						body2.m_invInertiaLocal, body2.m_inverseMass);
 
 	btScalar jacDiagAB = jac.getDiagonal();
 	btScalar jacDiagABInv = btScalar(1.) / jacDiagAB;
 
 	btScalar rel_vel = jac.getRelativeVelocity(
-		body1.getLinearVelocity(),
-		body1.getCenterOfMassTransform().m_basis.transpose() * body1.getAngularVelocity(),
-		body2.getLinearVelocity(),
-		body2.getCenterOfMassTransform().m_basis.transpose() * body2.getAngularVelocity());
+		body1.m_linearVelocity,
+		body1.getCenterOfMassTransform().m_basis.transpose() * body1.m_angularVelocity,
+		body2.m_linearVelocity,
+		body2.getCenterOfMassTransform().m_basis.transpose() * body2.m_angularVelocity);
 
 	rel_vel = normal.dot(vel);
 
@@ -144,7 +144,7 @@ void resolveSingleBilateral(btRigidBody& body1, const btVector3& pos1,
 	btScalar contactDamping = btScalar(0.2);
 
 #ifdef ONLY_USE_LINEAR_MASS
-	btScalar massTerm = btScalar(1.) / (body1.getInvMass() + body2.getInvMass());
+	btScalar massTerm = btScalar(1.) / (body1.m_inverseMass + body2.m_inverseMass);
 	impulse = -contactDamping * rel_vel * massTerm;
 #else
 	btScalar velocityImpulse = -contactDamping * rel_vel * jacDiagABInv;

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

@@ -149,8 +149,8 @@ btScalar btRotationalLimitMotor::solveAngularLimits(
 
 	// current velocity difference
 
-	btVector3 angVelA = body0->getAngularVelocity();
-	btVector3 angVelB = body1->getAngularVelocity();
+	btVector3 angVelA = body0->m_angularVelocity;
+	btVector3 angVelB = body1->m_angularVelocity;
 
 	btVector3 vel_diff;
 	vel_diff = angVelA - angVelB;
@@ -346,8 +346,8 @@ void btGeneric6DofConstraint::calculateTransforms(const btTransform& transA, con
 	calculateAngleInfo();
 	if (m_useOffsetForConstraintFrame)
 	{  //  get weight factors depending on masses
-		btScalar miA = getRigidBodyA().getInvMass();
-		btScalar miB = getRigidBodyB().getInvMass();
+		btScalar miA = getRigidBodyA().m_inverseMass;
+		btScalar miB = getRigidBodyB().m_inverseMass;
 		m_hasStaticBody = (miA < SIMD_EPSILON) || (miB < SIMD_EPSILON);
 		btScalar miS = miA + miB;
 		if (miS > btScalar(0.f))
@@ -372,10 +372,10 @@ void btGeneric6DofConstraint::buildLinearJacobian(
 		pivotAInW - m_rbA.getCenterOfMassPosition(),
 		pivotBInW - m_rbB.getCenterOfMassPosition(),
 		normalWorld,
-		m_rbA.getInvInertiaDiagLocal(),
-		m_rbA.getInvMass(),
-		m_rbB.getInvInertiaDiagLocal(),
-		m_rbB.getInvMass());
+		m_rbA.m_invInertiaLocal,
+		m_rbA.m_inverseMass,
+		m_rbB.m_invInertiaLocal,
+		m_rbB.m_inverseMass);
 }
 
 void btGeneric6DofConstraint::buildAngularJacobian(
@@ -384,8 +384,8 @@ void btGeneric6DofConstraint::buildAngularJacobian(
 	new (&jacAngular) btJacobianEntry(jointAxisW,
 									  m_rbA.getCenterOfMassTransform().m_basis.transpose(),
 									  m_rbB.getCenterOfMassTransform().m_basis.transpose(),
-									  m_rbA.getInvInertiaDiagLocal(),
-									  m_rbB.getInvInertiaDiagLocal());
+									  m_rbA.m_invInertiaLocal,
+									  m_rbB.m_invInertiaLocal);
 }
 
 bool btGeneric6DofConstraint::testAngularLimitMotor(int axis_index)
@@ -511,10 +511,10 @@ void btGeneric6DofConstraint::getInfo2(btConstraintInfo2* info)
 
 	const btTransform& transA = m_rbA.getCenterOfMassTransform();
 	const btTransform& transB = m_rbB.getCenterOfMassTransform();
-	const btVector3& linVelA = m_rbA.getLinearVelocity();
-	const btVector3& linVelB = m_rbB.getLinearVelocity();
-	const btVector3& angVelA = m_rbA.getAngularVelocity();
-	const btVector3& angVelB = m_rbB.getAngularVelocity();
+	const btVector3& linVelA = m_rbA.m_linearVelocity;
+	const btVector3& linVelB = m_rbB.m_linearVelocity;
+	const btVector3& angVelA = m_rbA.m_angularVelocity;
+	const btVector3& angVelB = m_rbB.m_angularVelocity;
 
 	if (m_useOffsetForConstraintFrame)
 	{  // for stability better to solve angular limits first
@@ -659,8 +659,8 @@ btScalar btGeneric6DofConstraint::getAngle(int axisIndex) const
 
 void btGeneric6DofConstraint::calcAnchorPos(void)
 {
-	btScalar imA = m_rbA.getInvMass();
-	btScalar imB = m_rbB.getInvMass();
+	btScalar imA = m_rbA.m_inverseMass;
+	btScalar imB = m_rbB.m_inverseMass;
 	btScalar weight;
 	if (imB == btScalar(0.0))
 	{

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

@@ -420,8 +420,8 @@ void btGeneric6DofSpring2Constraint::calculateTransforms(const btTransform& tran
 	calculateLinearInfo();
 	calculateAngleInfo();
 
-	btScalar miA = getRigidBodyA().getInvMass();
-	btScalar miB = getRigidBodyB().getInvMass();
+	btScalar miA = getRigidBodyA().m_inverseMass;
+	btScalar miB = getRigidBodyB().m_inverseMass;
 	m_hasStaticBody = (miA < SIMD_EPSILON) || (miB < SIMD_EPSILON);
 	btScalar miS = miA + miB;
 	if (miS > btScalar(0.f))
@@ -477,10 +477,10 @@ void btGeneric6DofSpring2Constraint::getInfo2(btConstraintInfo2* info)
 {
 	const btTransform& transA = m_rbA.getCenterOfMassTransform();
 	const btTransform& transB = m_rbB.getCenterOfMassTransform();
-	const btVector3& linVelA = m_rbA.getLinearVelocity();
-	const btVector3& linVelB = m_rbB.getLinearVelocity();
-	const btVector3& angVelA = m_rbA.getAngularVelocity();
-	const btVector3& angVelB = m_rbB.getAngularVelocity();
+	const btVector3& linVelA = m_rbA.m_linearVelocity;
+	const btVector3& linVelB = m_rbB.m_linearVelocity;
+	const btVector3& angVelA = m_rbA.m_angularVelocity;
+	const btVector3& angVelB = m_rbB.m_angularVelocity;
 
 	// for stability better to solve angular limits first
 	int row = setAngularLimits(info, 0, transA, transB, linVelA, linVelB, angVelA, angVelB);
@@ -833,18 +833,18 @@ int btGeneric6DofSpring2Constraint::get_limit_motor_info2(
 			vel = (linVelA + tanVelA).dot(ax1) - (linVelB + tanVelB).dot(ax1);
 		}
 		btScalar cfm = BT_ZERO;
-		btScalar mA = BT_ONE / m_rbA.getInvMass();
-		btScalar mB = BT_ONE / m_rbB.getInvMass();
+		btScalar mA = BT_ONE / m_rbA.m_inverseMass;
+		btScalar mB = BT_ONE / m_rbB.m_inverseMass;
 		if (rotational)
 		{
 			btScalar rrA = (m_calculatedTransformA.m_origin - transA.m_origin).length2();
 			btScalar rrB = (m_calculatedTransformB.m_origin - transB.m_origin).length2();
-			if (m_rbA.getInvMass()) mA = mA * rrA + 1 / (m_rbA.getInvInertiaTensorWorld() * ax1).length();
-			if (m_rbB.getInvMass()) mB = mB * rrB + 1 / (m_rbB.getInvInertiaTensorWorld() * ax1).length();
+			if (m_rbA.m_inverseMass) mA = mA * rrA + 1 / (m_rbA.m_invInertiaTensorWorld * ax1).length();
+			if (m_rbB.m_inverseMass) mB = mB * rrB + 1 / (m_rbB.m_invInertiaTensorWorld * ax1).length();
 		}
 		btScalar m;
-		if (m_rbA.getInvMass() == 0) m = mB; else
-		if (m_rbB.getInvMass() == 0) m = mA; else
+		if (m_rbA.m_inverseMass == 0) m = mB; else
+		if (m_rbB.m_inverseMass == 0) m = mA; else
 			m = mA*mB / (mA + mB);
 		btScalar angularfreq = btSqrt(ks / m);
 

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

@@ -107,7 +107,7 @@ void btGeneric6DofSpringConstraint::internalUpdateSprings(btConstraintInfo2* inf
 {
 	// it is assumed that calculateTransforms() have been called before this call
 	int i;
-	//btVector3 relVel = m_rbB.getLinearVelocity() - m_rbA.getLinearVelocity();
+	//btVector3 relVel = m_rbB.m_linearVelocity - m_rbA.m_linearVelocity;
 	for (i = 0; i < 3; i++)
 	{
 		if (m_springEnabled[i])

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

@@ -234,10 +234,10 @@ void btHingeConstraint::buildJacobian()
 					pivotAInW - m_rbA.getCenterOfMassPosition(),
 					pivotBInW - m_rbB.getCenterOfMassPosition(),
 					normal[i],
-					m_rbA.getInvInertiaDiagLocal(),
-					m_rbA.getInvMass(),
-					m_rbB.getInvInertiaDiagLocal(),
-					m_rbB.getInvMass());
+					m_rbA.m_invInertiaLocal,
+					m_rbA.m_inverseMass,
+					m_rbB.m_invInertiaLocal,
+					m_rbB.m_inverseMass);
 			}
 		}
 
@@ -257,20 +257,20 @@ void btHingeConstraint::buildJacobian()
 		new (&m_jacAng[0]) btJacobianEntry(jointAxis0,
 										   m_rbA.getCenterOfMassTransform().m_basis.transpose(),
 										   m_rbB.getCenterOfMassTransform().m_basis.transpose(),
-										   m_rbA.getInvInertiaDiagLocal(),
-										   m_rbB.getInvInertiaDiagLocal());
+										   m_rbA.m_invInertiaLocal,
+										   m_rbB.m_invInertiaLocal);
 
 		new (&m_jacAng[1]) btJacobianEntry(jointAxis1,
 										   m_rbA.getCenterOfMassTransform().m_basis.transpose(),
 										   m_rbB.getCenterOfMassTransform().m_basis.transpose(),
-										   m_rbA.getInvInertiaDiagLocal(),
-										   m_rbB.getInvInertiaDiagLocal());
+										   m_rbA.m_invInertiaLocal,
+										   m_rbB.m_invInertiaLocal);
 
 		new (&m_jacAng[2]) btJacobianEntry(hingeAxisWorld,
 										   m_rbA.getCenterOfMassTransform().m_basis.transpose(),
 										   m_rbB.getCenterOfMassTransform().m_basis.transpose(),
-										   m_rbA.getInvInertiaDiagLocal(),
-										   m_rbB.getInvInertiaDiagLocal());
+										   m_rbA.m_invInertiaLocal,
+										   m_rbB.m_invInertiaLocal);
 
 		// clear accumulator
 		m_accLimitImpulse = btScalar(0.);
@@ -373,11 +373,11 @@ void btHingeConstraint::getInfo2(btConstraintInfo2* info)
 {
 	if (m_useOffsetForConstraintFrame)
 	{
-		getInfo2InternalUsingFrameOffset(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getAngularVelocity(), m_rbB.getAngularVelocity());
+		getInfo2InternalUsingFrameOffset(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.m_angularVelocity, m_rbB.m_angularVelocity);
 	}
 	else
 	{
-		getInfo2Internal(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getAngularVelocity(), m_rbB.getAngularVelocity());
+		getInfo2Internal(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.m_angularVelocity, m_rbB.m_angularVelocity);
 	}
 }
 
@@ -745,8 +745,8 @@ void btHingeConstraint::getInfo2InternalUsingFrameOffset(btConstraintInfo2* info
 	// difference between frames in WCS
 	btVector3 ofs = trB.m_origin - trA.m_origin;
 	// now get weight factors depending on masses
-	btScalar miA = getRigidBodyA().getInvMass();
-	btScalar miB = getRigidBodyB().getInvMass();
+	btScalar miA = getRigidBodyA().m_inverseMass;
+	btScalar miB = getRigidBodyB().m_inverseMass;
 	bool hasStaticBody = (miA < SIMD_EPSILON) || (miB < SIMD_EPSILON);
 	btScalar miS = miA + miB;
 	btScalar factA, factB;

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

@@ -44,10 +44,10 @@ void btPoint2PointConstraint::buildJacobian()
 				m_rbA.getCenterOfMassTransform() * m_pivotInA - m_rbA.getCenterOfMassPosition(),
 				m_rbB.getCenterOfMassTransform() * m_pivotInB - m_rbB.getCenterOfMassPosition(),
 				normal,
-				m_rbA.getInvInertiaDiagLocal(),
-				m_rbA.getInvMass(),
-				m_rbB.getInvInertiaDiagLocal(),
-				m_rbB.getInvMass());
+				m_rbA.m_invInertiaLocal,
+				m_rbA.m_inverseMass,
+				m_rbB.m_invInertiaLocal,
+				m_rbB.m_inverseMass);
 			normal[i] = 0;
 		}
 	}

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

@@ -468,14 +468,14 @@ void btSequentialImpulseConstraintSolver::initSolverBody(btSolverBody* solverBod
 	if (rb)
 	{
 		solverBody->m_worldTransform = rb->m_worldTransform;
-		solverBody->internalSetInvMass(btVector3(rb->getInvMass(), rb->getInvMass(), rb->getInvMass()) * rb->getLinearFactor());
+		solverBody->internalSetInvMass(btVector3(rb->m_inverseMass, rb->m_inverseMass, rb->m_inverseMass) * rb->m_linearFactor);
 		solverBody->m_originalBody = rb;
-		solverBody->m_angularFactor = rb->getAngularFactor();
-		solverBody->m_linearFactor = rb->getLinearFactor();
-		solverBody->m_linearVelocity = rb->getLinearVelocity();
-		solverBody->m_angularVelocity = rb->getAngularVelocity();
-		solverBody->m_externalForceImpulse = rb->getTotalForce() * rb->getInvMass() * timeStep;
-		solverBody->m_externalTorqueImpulse = rb->getTotalTorque() * rb->getInvInertiaTensorWorld() * timeStep;
+		solverBody->m_angularFactor = rb->m_angularFactor;
+		solverBody->m_linearFactor = rb->m_linearFactor;
+		solverBody->m_linearVelocity = rb->m_linearVelocity;
+		solverBody->m_angularVelocity = rb->m_angularVelocity;
+		solverBody->m_externalForceImpulse = rb->m_totalForce * rb->m_inverseMass * timeStep;
+		solverBody->m_externalTorqueImpulse = rb->m_totalTorque * rb->m_invInertiaTensorWorld * timeStep;
 	}
 	else
 		{
@@ -537,7 +537,7 @@ void btSequentialImpulseConstraintSolver::setupFrictionConstraint(btSolverConstr
 		solverConstraint.m_contactNormal1 = normalAxis;
 		btVector3 ftorqueAxis1 = rel_pos1.cross(solverConstraint.m_contactNormal1);
 		solverConstraint.m_relpos1CrossNormal = ftorqueAxis1;
-		solverConstraint.m_angularComponentA = body0->getInvInertiaTensorWorld() * ftorqueAxis1 * body0->getAngularFactor();
+		solverConstraint.m_angularComponentA = body0->m_invInertiaTensorWorld * ftorqueAxis1 * body0->m_angularFactor;
 	}
 	else
 	{
@@ -551,7 +551,7 @@ void btSequentialImpulseConstraintSolver::setupFrictionConstraint(btSolverConstr
 		solverConstraint.m_contactNormal2 = -normalAxis;
 		btVector3 ftorqueAxis1 = rel_pos2.cross(solverConstraint.m_contactNormal2);
 		solverConstraint.m_relpos2CrossNormal = ftorqueAxis1;
-		solverConstraint.m_angularComponentB = bodyA->getInvInertiaTensorWorld() * ftorqueAxis1 * bodyA->getAngularFactor();
+		solverConstraint.m_angularComponentB = bodyA->m_invInertiaTensorWorld * ftorqueAxis1 * bodyA->m_angularFactor;
 	}
 	else
 	{
@@ -567,12 +567,12 @@ void btSequentialImpulseConstraintSolver::setupFrictionConstraint(btSolverConstr
 		if (body0)
 		{
 			vec = (solverConstraint.m_angularComponentA).cross(rel_pos1);
-			denom0 = body0->getInvMass() + normalAxis.dot(vec);
+			denom0 = body0->m_inverseMass + normalAxis.dot(vec);
 		}
 		if (bodyA)
 		{
 			vec = (-solverConstraint.m_angularComponentB).cross(rel_pos2);
-			denom1 = bodyA->getInvMass() + normalAxis.dot(vec);
+			denom1 = bodyA->m_inverseMass + normalAxis.dot(vec);
 		}
 		btScalar denom = relaxation / (denom0 + denom1);
 		solverConstraint.m_jacDiagABInv = denom;
@@ -644,17 +644,17 @@ void btSequentialImpulseConstraintSolver::setupTorsionalFrictionConstraint(btSol
 	{
 		btVector3 ftorqueAxis1 = -normalAxis1;
 		solverConstraint.m_relpos1CrossNormal = ftorqueAxis1;
-		solverConstraint.m_angularComponentA = body0 ? body0->getInvInertiaTensorWorld() * ftorqueAxis1 * body0->getAngularFactor() : btVector3(0, 0, 0);
+		solverConstraint.m_angularComponentA = body0 ? body0->m_invInertiaTensorWorld * ftorqueAxis1 * body0->m_angularFactor : btVector3(0, 0, 0);
 	}
 	{
 		btVector3 ftorqueAxis1 = normalAxis1;
 		solverConstraint.m_relpos2CrossNormal = ftorqueAxis1;
-		solverConstraint.m_angularComponentB = bodyA ? bodyA->getInvInertiaTensorWorld() * ftorqueAxis1 * bodyA->getAngularFactor() : btVector3(0, 0, 0);
+		solverConstraint.m_angularComponentB = bodyA ? bodyA->m_invInertiaTensorWorld * ftorqueAxis1 * bodyA->m_angularFactor : btVector3(0, 0, 0);
 	}
 
 	{
-		btVector3 iMJaA = body0 ? body0->getInvInertiaTensorWorld() * solverConstraint.m_relpos1CrossNormal : btVector3(0, 0, 0);
-		btVector3 iMJaB = bodyA ? bodyA->getInvInertiaTensorWorld() * solverConstraint.m_relpos2CrossNormal : btVector3(0, 0, 0);
+		btVector3 iMJaA = body0 ? body0->m_invInertiaTensorWorld * solverConstraint.m_relpos1CrossNormal : btVector3(0, 0, 0);
+		btVector3 iMJaB = bodyA ? bodyA->m_invInertiaTensorWorld * solverConstraint.m_relpos2CrossNormal : btVector3(0, 0, 0);
 		btScalar sum = 0;
 		sum += iMJaA.dot(solverConstraint.m_relpos1CrossNormal);
 		sum += iMJaB.dot(solverConstraint.m_relpos2CrossNormal);
@@ -768,7 +768,7 @@ int btSequentialImpulseConstraintSolver::getOrInitSolverBody(btCollisionObject&
 	{
 		btRigidBody* rb = btRigidBody::upcast(&body);
 		//convert both active and kinematic objects (for their velocity)
-		if (rb && (rb->getInvMass() || rb->isKinematicObject()))
+		if (rb && (rb->m_inverseMass || rb->isKinematicObject()))
 		{
 			solverBodyIdA = m_tmpSolverBodyPool.size();
 			btSolverBody& solverBody = m_tmpSolverBodyPool.expand();
@@ -846,9 +846,9 @@ void btSequentialImpulseConstraintSolver::setupContactConstraint(btSolverConstra
 	cfm *= invTimeStep;
 
 	btVector3 torqueAxis0 = rel_pos1.cross(cp.m_normalWorldOnB);
-	solverConstraint.m_angularComponentA = rb0 ? rb0->getInvInertiaTensorWorld() * torqueAxis0 * rb0->getAngularFactor() : btVector3(0, 0, 0);
+	solverConstraint.m_angularComponentA = rb0 ? rb0->m_invInertiaTensorWorld * torqueAxis0 * rb0->m_angularFactor : btVector3(0, 0, 0);
 	btVector3 torqueAxis1 = rel_pos2.cross(cp.m_normalWorldOnB);
-	solverConstraint.m_angularComponentB = rb1 ? rb1->getInvInertiaTensorWorld() * -torqueAxis1 * rb1->getAngularFactor() : btVector3(0, 0, 0);
+	solverConstraint.m_angularComponentB = rb1 ? rb1->m_invInertiaTensorWorld * -torqueAxis1 * rb1->m_angularFactor : btVector3(0, 0, 0);
 
 	{
 #ifdef COMPUTE_IMPULSE_DENOM
@@ -861,12 +861,12 @@ void btSequentialImpulseConstraintSolver::setupContactConstraint(btSolverConstra
 		if (rb0)
 		{
 			vec = (solverConstraint.m_angularComponentA).cross(rel_pos1);
-			denom0 = rb0->getInvMass() + cp.m_normalWorldOnB.dot(vec);
+			denom0 = rb0->m_inverseMass + cp.m_normalWorldOnB.dot(vec);
 		}
 		if (rb1)
 		{
 			vec = (-solverConstraint.m_angularComponentB).cross(rel_pos2);
-			denom1 = rb1->getInvMass() + cp.m_normalWorldOnB.dot(vec);
+			denom1 = rb1->m_inverseMass + cp.m_normalWorldOnB.dot(vec);
 		}
 #endif  //COMPUTE_IMPULSE_DENOM
 
@@ -1244,18 +1244,18 @@ void btSequentialImpulseConstraintSolver::convertJoint(btSolverConstraint* curre
 
 		{
 			const btVector3& ftorqueAxis1 = solverConstraint.m_relpos1CrossNormal;
-			solverConstraint.m_angularComponentA = constraint->getRigidBodyA().getInvInertiaTensorWorld() * ftorqueAxis1 * constraint->getRigidBodyA().getAngularFactor();
+			solverConstraint.m_angularComponentA = constraint->getRigidBodyA().m_invInertiaTensorWorld * ftorqueAxis1 * constraint->getRigidBodyA().m_angularFactor;
 		}
 		{
 			const btVector3& ftorqueAxis2 = solverConstraint.m_relpos2CrossNormal;
-			solverConstraint.m_angularComponentB = constraint->getRigidBodyB().getInvInertiaTensorWorld() * ftorqueAxis2 * constraint->getRigidBodyB().getAngularFactor();
+			solverConstraint.m_angularComponentB = constraint->getRigidBodyB().m_invInertiaTensorWorld * ftorqueAxis2 * constraint->getRigidBodyB().m_angularFactor;
 		}
 
 		{
-			btVector3 iMJlA = solverConstraint.m_contactNormal1 * rbA.getInvMass();
-			btVector3 iMJaA = rbA.getInvInertiaTensorWorld() * solverConstraint.m_relpos1CrossNormal;
-			btVector3 iMJlB = solverConstraint.m_contactNormal2 * rbB.getInvMass();  //sign of normal?
-			btVector3 iMJaB = rbB.getInvInertiaTensorWorld() * solverConstraint.m_relpos2CrossNormal;
+			btVector3 iMJlA = solverConstraint.m_contactNormal1 * rbA.m_inverseMass;
+			btVector3 iMJaA = rbA.m_invInertiaTensorWorld * solverConstraint.m_relpos1CrossNormal;
+			btVector3 iMJlB = solverConstraint.m_contactNormal2 * rbB.m_inverseMass;  //sign of normal?
+			btVector3 iMJaB = rbB.m_invInertiaTensorWorld * solverConstraint.m_relpos2CrossNormal;
 
 			btScalar sum = iMJlA.dot(solverConstraint.m_contactNormal1);
 			sum += iMJaA.dot(solverConstraint.m_relpos1CrossNormal);
@@ -1275,9 +1275,9 @@ void btSequentialImpulseConstraintSolver::convertJoint(btSolverConstraint* curre
 			btVector3 externalForceImpulseB = bodyBPtr->m_originalBody ? bodyBPtr->m_externalForceImpulse : btVector3(0, 0, 0);
 			btVector3 externalTorqueImpulseB = bodyBPtr->m_originalBody ? bodyBPtr->m_externalTorqueImpulse : btVector3(0, 0, 0);
 
-			btScalar vel1Dotn = solverConstraint.m_contactNormal1.dot(rbA.getLinearVelocity() + externalForceImpulseA) + solverConstraint.m_relpos1CrossNormal.dot(rbA.getAngularVelocity() + externalTorqueImpulseA);
+			btScalar vel1Dotn = solverConstraint.m_contactNormal1.dot(rbA.m_linearVelocity + externalForceImpulseA) + solverConstraint.m_relpos1CrossNormal.dot(rbA.m_angularVelocity + externalTorqueImpulseA);
 
-			btScalar vel2Dotn = solverConstraint.m_contactNormal2.dot(rbB.getLinearVelocity() + externalForceImpulseB) + solverConstraint.m_relpos2CrossNormal.dot(rbB.getAngularVelocity() + externalTorqueImpulseB);
+			btScalar vel2Dotn = solverConstraint.m_contactNormal2.dot(rbB.m_linearVelocity + externalForceImpulseB) + solverConstraint.m_relpos2CrossNormal.dot(rbB.m_angularVelocity + externalTorqueImpulseB);
 
 			rel_vel = vel1Dotn + vel2Dotn;
 			btScalar restitution = 0.f;
@@ -1377,21 +1377,21 @@ void btSequentialImpulseConstraintSolver::convertBodies(btCollisionObject** bodi
 		int bodyId = getOrInitSolverBody(*bodies[i], infoGlobal.m_timeStep);
 
 		btRigidBody* body = btRigidBody::upcast(bodies[i]);
-		if (body && body->getInvMass())
+		if (body && body->m_inverseMass)
 		{
 			btSolverBody& solverBody = m_tmpSolverBodyPool[bodyId];
 			btVector3 gyroForce(0, 0, 0);
-			if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT)
+			if (body->m_rigidbodyFlags & BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT)
 			{
 				gyroForce = body->computeGyroscopicForceExplicit(infoGlobal.m_maxGyroscopicForce);
-				solverBody.m_externalTorqueImpulse -= gyroForce * body->getInvInertiaTensorWorld() * infoGlobal.m_timeStep;
+				solverBody.m_externalTorqueImpulse -= gyroForce * body->m_invInertiaTensorWorld * infoGlobal.m_timeStep;
 			}
-			if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD)
+			if (body->m_rigidbodyFlags & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD)
 			{
 				gyroForce = body->computeGyroscopicImpulseImplicit_World(infoGlobal.m_timeStep);
 				solverBody.m_externalTorqueImpulse += gyroForce;
 			}
-			if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY)
+			if (body->m_rigidbodyFlags & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY)
 			{
 				gyroForce = body->computeGyroscopicImpulseImplicit_Body(infoGlobal.m_timeStep);
 				solverBody.m_externalTorqueImpulse += gyroForce;
@@ -1791,10 +1791,10 @@ void btSequentialImpulseConstraintSolver::writeBackJoints(int iBegin, int iEnd,
 		btJointFeedback* fb = constr->getJointFeedback();
 		if (fb)
 		{
-			fb->m_appliedForceBodyA += solverConstr.m_contactNormal1 * solverConstr.m_appliedImpulse * constr->getRigidBodyA().getLinearFactor() / infoGlobal.m_timeStep;
-			fb->m_appliedForceBodyB += solverConstr.m_contactNormal2 * solverConstr.m_appliedImpulse * constr->getRigidBodyB().getLinearFactor() / infoGlobal.m_timeStep;
-			fb->m_appliedTorqueBodyA += solverConstr.m_relpos1CrossNormal * constr->getRigidBodyA().getAngularFactor() * solverConstr.m_appliedImpulse / infoGlobal.m_timeStep;
-			fb->m_appliedTorqueBodyB += solverConstr.m_relpos2CrossNormal * constr->getRigidBodyB().getAngularFactor() * solverConstr.m_appliedImpulse / infoGlobal.m_timeStep; /*RGM ???? */
+			fb->m_appliedForceBodyA += solverConstr.m_contactNormal1 * solverConstr.m_appliedImpulse * constr->getRigidBodyA().m_linearFactor / infoGlobal.m_timeStep;
+			fb->m_appliedForceBodyB += solverConstr.m_contactNormal2 * solverConstr.m_appliedImpulse * constr->getRigidBodyB().m_linearFactor / infoGlobal.m_timeStep;
+			fb->m_appliedTorqueBodyA += solverConstr.m_relpos1CrossNormal * constr->getRigidBodyA().m_angularFactor * solverConstr.m_appliedImpulse / infoGlobal.m_timeStep;
+			fb->m_appliedTorqueBodyB += solverConstr.m_relpos2CrossNormal * constr->getRigidBodyB().m_angularFactor * solverConstr.m_appliedImpulse / infoGlobal.m_timeStep; /*RGM ???? */
 		}
 
 		constr->internalSetAppliedImpulse(solverConstr.m_appliedImpulse);

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

@@ -755,20 +755,20 @@ void btSequentialImpulseConstraintSolverMt::internalConvertBodies(btCollisionObj
 		initSolverBody(&solverBody, obj, infoGlobal.m_timeStep);
 
 		btRigidBody* body = btRigidBody::upcast(obj);
-		if (body && body->getInvMass())
+		if (body && body->m_inverseMass)
 		{
 			btVector3 gyroForce(0, 0, 0);
-			if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT)
+			if (body->m_rigidbodyFlags & BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT)
 			{
 				gyroForce = body->computeGyroscopicForceExplicit(infoGlobal.m_maxGyroscopicForce);
-				solverBody.m_externalTorqueImpulse -= gyroForce * body->getInvInertiaTensorWorld() * infoGlobal.m_timeStep;
+				solverBody.m_externalTorqueImpulse -= gyroForce * body->m_invInertiaTensorWorld * infoGlobal.m_timeStep;
 			}
-			if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD)
+			if (body->m_rigidbodyFlags & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD)
 			{
 				gyroForce = body->computeGyroscopicImpulseImplicit_World(infoGlobal.m_timeStep);
 				solverBody.m_externalTorqueImpulse += gyroForce;
 			}
-			if (body->getFlags() & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY)
+			if (body->m_rigidbodyFlags & BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY)
 			{
 				gyroForce = body->computeGyroscopicImpulseImplicit_Body(infoGlobal.m_timeStep);
 				solverBody.m_externalTorqueImpulse += gyroForce;

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

@@ -133,7 +133,7 @@ void btSliderConstraint::getInfo1NonVirtual(btConstraintInfo1* info)
 
 void btSliderConstraint::getInfo2(btConstraintInfo2* info)
 {
-	getInfo2NonVirtual(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.getLinearVelocity(), m_rbB.getLinearVelocity(), m_rbA.getInvMass(), m_rbB.getInvMass());
+	getInfo2NonVirtual(info, m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform(), m_rbA.m_linearVelocity, m_rbB.m_linearVelocity, m_rbA.m_inverseMass, m_rbB.m_inverseMass);
 }
 
 void btSliderConstraint::calculateTransforms(const btTransform& transA, const btTransform& transB)
@@ -635,8 +635,8 @@ void btSliderConstraint::getInfo2NonVirtual(btConstraintInfo2* info, const btTra
 			btScalar bounce = btFabs(btScalar(1.0) - getDampingLimAng());
 			if (bounce > btScalar(0.0))
 			{
-				btScalar vel = m_rbA.getAngularVelocity().dot(ax1);
-				vel -= m_rbB.getAngularVelocity().dot(ax1);
+				btScalar vel = m_rbA.m_angularVelocity.dot(ax1);
+				vel -= m_rbB.m_angularVelocity.dot(ax1);
 				// only apply bounce if the velocity is incoming, and if the
 				// resulting c[] exceeds what we already have.
 				if (limit == 1)

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

@@ -336,7 +336,7 @@ void btDiscreteDynamicsWorld::synchronizeSingleMotionState(btRigidBody* body)
 {
 	btAssert(body);
 
-	if (body->getMotionState() && !body->isStaticOrKinematicObject())
+	if (body->m_optionalMotionState && !body->isStaticOrKinematicObject())
 	{
 		//we need to call the update at least once, even for sleeping objects
 		//otherwise the 'graphics' transform never updates properly
@@ -348,7 +348,7 @@ void btDiscreteDynamicsWorld::synchronizeSingleMotionState(btRigidBody* body)
 												body->m_interpolationLinearVelocity, body->m_interpolationAngularVelocity,
 												(m_latencyMotionStateInterpolation && m_fixedTimeStep) ? m_localTime - m_fixedTimeStep : m_localTime * body->m_hitFraction,
 												interpolatedTransform);
-			body->getMotionState()->setWorldTransform(interpolatedTransform);
+			body->m_optionalMotionState->setWorldTransform(interpolatedTransform);
 		}
 	}
 }
@@ -502,7 +502,7 @@ void btDiscreteDynamicsWorld::setGravity(const btVector3& gravity)
 	for (int i = 0; i < m_nonStaticRigidBodies.size(); i++)
 	{
 		btRigidBody* body = m_nonStaticRigidBodies[i];
-		if (body->isActive() && !(body->getFlags() & BT_DISABLE_WORLD_GRAVITY))
+		if (body->isActive() && !(body->m_rigidbodyFlags & BT_DISABLE_WORLD_GRAVITY))
 		{
 			body->setGravity(gravity);
 		}
@@ -536,7 +536,7 @@ void btDiscreteDynamicsWorld::removeRigidBody(btRigidBody* body)
 
 void btDiscreteDynamicsWorld::addRigidBody(btRigidBody* body)
 {
-	if (!body->isStaticOrKinematicObject() && !(body->getFlags() & BT_DISABLE_WORLD_GRAVITY))
+	if (!body->isStaticOrKinematicObject() && !(body->m_rigidbodyFlags & BT_DISABLE_WORLD_GRAVITY))
 	{
 		body->setGravity(m_gravity);
 	}
@@ -562,7 +562,7 @@ void btDiscreteDynamicsWorld::addRigidBody(btRigidBody* body)
 
 void btDiscreteDynamicsWorld::addRigidBody(btRigidBody* body, int group, int mask)
 {
-	if (!body->isStaticOrKinematicObject() && !(body->getFlags() & BT_DISABLE_WORLD_GRAVITY))
+	if (!body->isStaticOrKinematicObject() && !(body->m_rigidbodyFlags & BT_DISABLE_WORLD_GRAVITY))
 	{
 		body->setGravity(m_gravity);
 	}
@@ -891,8 +891,8 @@ void btDiscreteDynamicsWorld::createPredictiveContactsInternal(btRigidBody** bod
 					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;
+					sweepResults.m_collisionFilterGroup = body->m_broadphaseHandle->m_collisionFilterGroup;
+					sweepResults.m_collisionFilterMask = body->m_broadphaseHandle->m_collisionFilterMask;
 					btTransform modifiedPredictedTrans = predictedTrans;
 					modifiedPredictedTrans.m_basis = (body->m_worldTransform.m_basis);
 
@@ -993,8 +993,8 @@ void btDiscreteDynamicsWorld::integrateTransformsInternal(btRigidBody** bodies,
 					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;
+					sweepResults.m_collisionFilterGroup = body->m_broadphaseHandle->m_collisionFilterGroup;
+					sweepResults.m_collisionFilterMask = body->m_broadphaseHandle->m_collisionFilterMask;
 					btTransform modifiedPredictedTrans = predictedTrans;
 					modifiedPredictedTrans.m_basis = (body->m_worldTransform.m_basis);
 
@@ -1008,7 +1008,7 @@ void btDiscreteDynamicsWorld::integrateTransformsInternal(btRigidBody** bodies,
 						body->proceedToTransform(predictedTrans);
 
 #if 0
-						btVector3 linVel = body->getLinearVelocity();
+						btVector3 linVel = body->m_linearVelocity;
 
 						btScalar maxSpeed = body->getCcdMotionThreshold()/getSolverInfo().m_timeStep;
 						btScalar maxSpeedSqr = maxSpeed*maxSpeed;
@@ -1017,7 +1017,7 @@ void btDiscreteDynamicsWorld::integrateTransformsInternal(btRigidBody** bodies,
 							linVel.normalize();
 							linVel*= maxSpeed;
 							body->setLinearVelocity(linVel);
-							btScalar ms2 = body->getLinearVelocity().length2();
+							btScalar ms2 = body->m_linearVelocity.length2();
 							body->predictIntegratedTransform(timeStep, predictedTrans);
 
 							btScalar sm2 = (predictedTrans.m_origin-body->m_worldTransform.m_origin).length2();
@@ -1200,7 +1200,7 @@ void btDiscreteDynamicsWorld::debugDrawConstraint(btTypedConstraint* constraint)
 				}
 				btScalar tws = pCT->getTwistSpan();
 				btScalar twa = pCT->getTwistAngle();
-				bool useFrameB = (pCT->getRigidBodyB().getInvMass() > btScalar(0.f));
+				bool useFrameB = (pCT->getRigidBodyB().m_inverseMass > btScalar(0.f));
 				if (useFrameB)
 				{
 					tr = pCT->getRigidBodyB().getCenterOfMassTransform() * pCT->getBFrame();

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

@@ -108,8 +108,8 @@ void btRigidBody::saveKinematicState(btScalar timeStep)
 	if (timeStep != btScalar(0.))
 	{
 		//if we use motionstate to synchronize world transforms, get the new kinematic/animated world transform
-		if (getMotionState())
-			getMotionState()->getWorldTransform(m_worldTransform);
+		if (m_optionalMotionState)
+			m_optionalMotionState->getWorldTransform(m_worldTransform);
 		btVector3 linVel, angVel;
 
 		btTransformUtil::calculateVelocity(m_interpolationWorldTransform, m_worldTransform, timeStep, m_linearVelocity, m_angularVelocity);
@@ -284,8 +284,8 @@ btVector3 btRigidBody::computeGyroscopicForceExplicit(btScalar maxGyroscopicForc
 {
 	btVector3 inertiaLocal = getLocalInertia();
 	btMatrix3x3 inertiaTensorWorld = m_worldTransform.m_basis.scaled(inertiaLocal) * m_worldTransform.m_basis.transpose();
-	btVector3 tmp = inertiaTensorWorld * getAngularVelocity();
-	btVector3 gf = getAngularVelocity().cross(tmp);
+	btVector3 tmp = inertiaTensorWorld * m_angularVelocity;
+	btVector3 gf = m_angularVelocity.cross(tmp);
 	btScalar l2 = gf.length2();
 	if (l2 > maxGyroscopicForce * maxGyroscopicForce)
 	{
@@ -297,7 +297,7 @@ btVector3 btRigidBody::computeGyroscopicForceExplicit(btScalar maxGyroscopicForc
 btVector3 btRigidBody::computeGyroscopicImpulseImplicit_Body(btScalar step) const
 {
 	btVector3 idl = getLocalInertia();
-	btVector3 omega1 = getAngularVelocity();
+	btVector3 omega1 = m_angularVelocity;
 	btQuaternion q = m_worldTransform.getRotation();
 
 	// Convert to body coordinates
@@ -339,7 +339,7 @@ btVector3 btRigidBody::computeGyroscopicImpulseImplicit_World(btScalar step) con
 	// calculate using implicit euler step so it's stable.
 
 	const btVector3 inertiaLocal = getLocalInertia();
-	const btVector3 w0 = getAngularVelocity();
+	const btVector3 w0 = m_angularVelocity;
 
 	btMatrix3x3 I;
 
@@ -406,8 +406,8 @@ void btRigidBody::setCenterOfMassTransform(const btTransform& xform)
 	{
 		m_interpolationWorldTransform = xform;
 	}
-	m_interpolationLinearVelocity = getLinearVelocity();
-	m_interpolationAngularVelocity = getAngularVelocity();
+	m_interpolationLinearVelocity = m_linearVelocity;
+	m_interpolationAngularVelocity = m_angularVelocity;
 	m_worldTransform = xform;
 	updateInertiaTensor();
 }

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

@@ -58,6 +58,7 @@ enum btRigidBodyFlags
 ///Deactivated (sleeping) rigid bodies don't take any processing time, except a minor broadphase collision detection impact (to allow active objects to activate/wake up sleeping objects)
 class btRigidBody : public btCollisionObject
 {
+public:
 	btMatrix3x3 m_invInertiaTensorWorld;
 	btVector3 m_linearVelocity;
 	btVector3 m_angularVelocity;
@@ -92,7 +93,6 @@ class btRigidBody : public btCollisionObject
 
 	int m_debugBodyId;
 
-protected:
 	ATTRIBUTE_ALIGNED16(btVector3 m_deltaLinearVelocity);
 	btVector3 m_deltaAngularVelocity;
 	btVector3 m_angularFactor;
@@ -210,62 +210,18 @@ public:
 
 	void setGravity(const btVector3& acceleration);
 
-	const btVector3& getGravity() const
-	{
-		return m_gravity_acceleration;
-	}
-
 	void setDamping(btScalar lin_damping, btScalar ang_damping);
 
-	btScalar getLinearDamping() const
-	{
-		return m_linearDamping;
-	}
-
-	btScalar getAngularDamping() const
-	{
-		return m_angularDamping;
-	}
-
-	btScalar getLinearSleepingThreshold() const
-	{
-		return m_linearSleepingThreshold;
-	}
-
-	btScalar getAngularSleepingThreshold() const
-	{
-		return m_angularSleepingThreshold;
-	}
-
 	void applyDamping(btScalar timeStep);
 
-	SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const
-	{
-		return m_collisionShape;
-	}
-
-	SIMD_FORCE_INLINE btCollisionShape* getCollisionShape()
-	{
-		return m_collisionShape;
-	}
-
 	void setMassProps(btScalar mass, const btVector3& inertia);
 
-	const btVector3& getLinearFactor() const
-	{
-		return m_linearFactor;
-	}
 	void setLinearFactor(const btVector3& linearFactor)
 	{
 		m_linearFactor = linearFactor;
 		m_invMass = m_linearFactor * m_inverseMass;
 	}
-	btScalar getInvMass() const { return m_inverseMass; }
 	btScalar getMass() const { return m_inverseMass == btScalar(0.) ? btScalar(0.) : btScalar(1.0) / m_inverseMass; }
-	const btMatrix3x3& getInvInertiaTensorWorld() const
-	{
-		return m_invInertiaTensorWorld;
-	}
 
 	void integrateVelocities(btScalar step);
 
@@ -276,26 +232,6 @@ public:
 		m_totalForce += force * m_linearFactor;
 	}
 
-	const btVector3& getTotalForce() const
-	{
-		return m_totalForce;
-	};
-
-	const btVector3& getTotalTorque() const
-	{
-		return m_totalTorque;
-	};
-
-	const btVector3& getInvInertiaDiagLocal() const
-	{
-		return m_invInertiaLocal;
-	};
-
-	void setInvInertiaDiagLocal(const btVector3& diagInvInertia)
-	{
-		m_invInertiaLocal = diagInvInertia;
-	}
-
 	void setSleepingThresholds(btScalar linear, btScalar angular)
 	{
 		m_linearSleepingThreshold = linear;
@@ -356,21 +292,6 @@ public:
         }
     }
 
-    btVector3 getPushVelocity() const
-    {
-        return m_pushVelocity;
-    }
-
-    btVector3 getTurnVelocity() const
-    {
-        return m_turnVelocity;
-    }
-
-    void setPushVelocity(const btVector3& v)
-    {
-        m_pushVelocity = v;
-    }
-
     #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
     void clampVelocity(btVector3& v) const {
         v.m_floats[0] = (
@@ -430,14 +351,6 @@ public:
 	{
 		return m_worldTransform;
 	}
-	const btVector3& getLinearVelocity() const
-	{
-		return m_linearVelocity;
-	}
-	const btVector3& getAngularVelocity() const
-	{
-		return m_angularVelocity;
-	}
 
 	inline void setLinearVelocity(const btVector3& lin_vel)
 	{
@@ -485,14 +398,14 @@ public:
 
 		btVector3 c0 = (r0).cross(normal);
 
-		btVector3 vec = (c0 * getInvInertiaTensorWorld()).cross(r0);
+		btVector3 vec = (c0 * m_invInertiaTensorWorld).cross(r0);
 
 		return m_inverseMass + normal.dot(vec);
 	}
 
 	SIMD_FORCE_INLINE btScalar computeAngularImpulseDenominator(const btVector3& axis) const
 	{
-		btVector3 vec = axis * getInvInertiaTensorWorld();
+		btVector3 vec = axis * m_invInertiaTensorWorld;
 		return axis.dot(vec);
 	}
 
@@ -501,8 +414,8 @@ public:
 		if ((m_activationState1 == ISLAND_SLEEPING) || (m_activationState1 == DISABLE_DEACTIVATION))
 			return;
 
-		if ((getLinearVelocity().length2() < m_linearSleepingThreshold * m_linearSleepingThreshold) &&
-			(getAngularVelocity().length2() < m_angularSleepingThreshold * m_angularSleepingThreshold))
+		if ((m_linearVelocity.length2() < m_linearSleepingThreshold * m_linearSleepingThreshold) &&
+			(m_angularVelocity.length2() < m_angularSleepingThreshold * m_angularSleepingThreshold))
 		{
 			m_deactivationTime += timeStep;
 		}
@@ -532,28 +445,6 @@ public:
 		return false;
 	}
 
-	const btBroadphaseProxy* getBroadphaseProxy() const
-	{
-		return m_broadphaseHandle;
-	}
-	btBroadphaseProxy* getBroadphaseProxy()
-	{
-		return m_broadphaseHandle;
-	}
-	void setNewBroadphaseProxy(btBroadphaseProxy* broadphaseProxy)
-	{
-		m_broadphaseHandle = broadphaseProxy;
-	}
-
-	//btMotionState allows to automatic synchronize the world transform for active objects
-	btMotionState* getMotionState()
-	{
-		return m_optionalMotionState;
-	}
-	const btMotionState* getMotionState() const
-	{
-		return m_optionalMotionState;
-	}
 	void setMotionState(btMotionState* motionState)
 	{
 		m_optionalMotionState = motionState;
@@ -576,15 +467,11 @@ public:
 		m_updateRevision++;
 		m_angularFactor.setValue(angFac, angFac, angFac);
 	}
-	const btVector3& getAngularFactor() const
-	{
-		return m_angularFactor;
-	}
 
 	//is this rigidbody added to a btCollisionWorld/btDynamicsWorld/btBroadphase?
 	bool isInWorld() const
 	{
-		return (getBroadphaseProxy() != 0);
+		return (m_broadphaseHandle != 0);
 	}
 
 	void addConstraintRef(btTypedConstraint* c);
@@ -600,16 +487,6 @@ public:
 		return m_constraintRefs.size();
 	}
 
-	void setFlags(int flags)
-	{
-		m_rigidbodyFlags = flags;
-	}
-
-	int getFlags() const
-	{
-		return m_rigidbodyFlags;
-	}
-
 	///perform implicit force computation in world space
 	btVector3 computeGyroscopicImpulseImplicit_World(btScalar dt) const;
 

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

@@ -234,11 +234,11 @@ void btSimpleDynamicsWorld::synchronizeMotionStates()
 	{
 		btCollisionObject* colObj = m_collisionObjects[i];
 		btRigidBody* body = btRigidBody::upcast(colObj);
-		if (body && body->getMotionState())
+		if (body && body->m_optionalMotionState)
 		{
 			if (body->m_activationState1 != ISLAND_SLEEPING)
 			{
-				body->getMotionState()->setWorldTransform(body->m_worldTransform);
+				body->m_optionalMotionState->setWorldTransform(body->m_worldTransform);
 			}
 		}
 	}

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

@@ -158,7 +158,7 @@ btScalar btMultiBodyConstraint::fillMultiBodyConstraint(btMultiBodySolverConstra
 		{
 			torqueAxis0 = rel_pos1.cross(constraintNormalLin);
 		}
-		solverConstraint.m_angularComponentA = rb0 ? rb0->getInvInertiaTensorWorld() * torqueAxis0 * rb0->getAngularFactor() : btVector3(0, 0, 0);
+		solverConstraint.m_angularComponentA = rb0 ? rb0->m_invInertiaTensorWorld * torqueAxis0 * rb0->m_angularFactor : btVector3(0, 0, 0);
 		solverConstraint.m_relpos1CrossNormal = torqueAxis0;
 		solverConstraint.m_contactNormal1 = constraintNormalLin;
 	}
@@ -231,7 +231,7 @@ btScalar btMultiBodyConstraint::fillMultiBodyConstraint(btMultiBodySolverConstra
 		{
 			torqueAxis1 = rel_pos2.cross(constraintNormalLin);
 		}
-		solverConstraint.m_angularComponentB = rb1 ? rb1->getInvInertiaTensorWorld() * -torqueAxis1 * rb1->getAngularFactor() : btVector3(0, 0, 0);
+		solverConstraint.m_angularComponentB = rb1 ? rb1->m_invInertiaTensorWorld * -torqueAxis1 * rb1->m_angularFactor : btVector3(0, 0, 0);
 		solverConstraint.m_relpos2CrossNormal = -torqueAxis1;
 		solverConstraint.m_contactNormal2 = -constraintNormalLin;
 	}
@@ -266,7 +266,7 @@ btScalar btMultiBodyConstraint::fillMultiBodyConstraint(btMultiBodySolverConstra
 			}
 			else
 			{
-				denom0 = rb0->getInvMass() + constraintNormalLin.dot(vec);
+				denom0 = rb0->m_inverseMass + constraintNormalLin.dot(vec);
 			}
 		}
 		//
@@ -291,7 +291,7 @@ btScalar btMultiBodyConstraint::fillMultiBodyConstraint(btMultiBodySolverConstra
 			}
 			else
 			{
-				denom1 = rb1->getInvMass() + constraintNormalLin.dot(vec);
+				denom1 = rb1->m_inverseMass + constraintNormalLin.dot(vec);
 			}
 		}
 
@@ -325,8 +325,8 @@ btScalar btMultiBodyConstraint::fillMultiBodyConstraint(btMultiBodySolverConstra
 		}
 		else if (rb0)
 		{
-			rel_vel += rb0->getLinearVelocity().dot(solverConstraint.m_contactNormal1);
-			rel_vel += rb0->getAngularVelocity().dot(solverConstraint.m_relpos1CrossNormal);
+			rel_vel += rb0->m_linearVelocity.dot(solverConstraint.m_contactNormal1);
+			rel_vel += rb0->m_angularVelocity.dot(solverConstraint.m_relpos1CrossNormal);
 		}
 		if (multiBodyB)
 		{
@@ -337,8 +337,8 @@ btScalar btMultiBodyConstraint::fillMultiBodyConstraint(btMultiBodySolverConstra
 		}
 		else if (rb1)
 		{
-			rel_vel += rb1->getLinearVelocity().dot(solverConstraint.m_contactNormal2);
-			rel_vel += rb1->getAngularVelocity().dot(solverConstraint.m_relpos2CrossNormal);
+			rel_vel += rb1->m_linearVelocity.dot(solverConstraint.m_contactNormal2);
+			rel_vel += rb1->m_angularVelocity.dot(solverConstraint.m_relpos2CrossNormal);
 		}
 
 		solverConstraint.m_friction = 0.f;  //cp.m_combinedFriction;

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

@@ -608,7 +608,7 @@ void btMultiBodyConstraintSolver::setupMultiBodyContactConstraint(btMultiBodySol
 		btVector3 torqueAxis0 = rel_pos1.cross(contactNormal);
 		solverConstraint.m_relpos1CrossNormal = torqueAxis0;
 		solverConstraint.m_contactNormal1 = contactNormal;
-		solverConstraint.m_angularComponentA = rb0 ? rb0->getInvInertiaTensorWorld() * torqueAxis0 * rb0->getAngularFactor() : btVector3(0, 0, 0);
+		solverConstraint.m_angularComponentA = rb0 ? rb0->m_invInertiaTensorWorld * torqueAxis0 * rb0->m_angularFactor : btVector3(0, 0, 0);
 	}
 
 	if (multiBodyB)
@@ -651,7 +651,7 @@ void btMultiBodyConstraintSolver::setupMultiBodyContactConstraint(btMultiBodySol
 		solverConstraint.m_relpos2CrossNormal = -torqueAxis1;
 		solverConstraint.m_contactNormal2 = -contactNormal;
 
-		solverConstraint.m_angularComponentB = rb1 ? rb1->getInvInertiaTensorWorld() * -torqueAxis1 * rb1->getAngularFactor() : btVector3(0, 0, 0);
+		solverConstraint.m_angularComponentB = rb1 ? rb1->m_invInertiaTensorWorld * -torqueAxis1 * rb1->m_angularFactor : btVector3(0, 0, 0);
 	}
 
 	{
@@ -680,7 +680,7 @@ void btMultiBodyConstraintSolver::setupMultiBodyContactConstraint(btMultiBodySol
 			if (rb0)
 			{
 				vec = (solverConstraint.m_angularComponentA).cross(rel_pos1);
-				denom0 = rb0->getInvMass() + contactNormal.dot(vec);
+				denom0 = rb0->m_inverseMass + contactNormal.dot(vec);
 			}
 		}
 		if (multiBodyB)
@@ -700,7 +700,7 @@ void btMultiBodyConstraintSolver::setupMultiBodyContactConstraint(btMultiBodySol
 			if (rb1)
 			{
 				vec = (-solverConstraint.m_angularComponentB).cross(rel_pos2);
-				denom1 = rb1->getInvMass() + contactNormal.dot(vec);
+				denom1 = rb1->m_inverseMass + contactNormal.dot(vec);
 			}
 		}
 
@@ -749,8 +749,8 @@ void btMultiBodyConstraintSolver::setupMultiBodyContactConstraint(btMultiBodySol
 			if (rb0)
 			{
 				rel_vel += (rb0->getVelocityInLocalPoint(rel_pos1) +
-							(rb0->getTotalTorque() * rb0->getInvInertiaTensorWorld() * infoGlobal.m_timeStep).cross(rel_pos1) +
-							rb0->getTotalForce() * rb0->getInvMass() * infoGlobal.m_timeStep)
+							(rb0->m_totalTorque * rb0->m_invInertiaTensorWorld * infoGlobal.m_timeStep).cross(rel_pos1) +
+							rb0->m_totalForce * rb0->m_inverseMass * infoGlobal.m_timeStep)
 							   .dot(solverConstraint.m_contactNormal1);
 			}
 		}
@@ -766,8 +766,8 @@ void btMultiBodyConstraintSolver::setupMultiBodyContactConstraint(btMultiBodySol
 			if (rb1)
 			{
 				rel_vel += (rb1->getVelocityInLocalPoint(rel_pos2) +
-							(rb1->getTotalTorque() * rb1->getInvInertiaTensorWorld() * infoGlobal.m_timeStep).cross(rel_pos2) +
-							rb1->getTotalForce() * rb1->getInvMass() * infoGlobal.m_timeStep)
+							(rb1->m_totalTorque * rb1->m_invInertiaTensorWorld * infoGlobal.m_timeStep).cross(rel_pos2) +
+							rb1->m_totalForce * rb1->m_inverseMass * infoGlobal.m_timeStep)
 							   .dot(solverConstraint.m_contactNormal2);
 			}
 		}
@@ -862,7 +862,7 @@ void btMultiBodyConstraintSolver::setupMultiBodyContactConstraint(btMultiBodySol
 			else
 			{
 				if (rb0)
-					bodyA->internalApplyImpulse(solverConstraint.m_contactNormal1 * bodyA->internalGetInvMass() * rb0->getLinearFactor(), solverConstraint.m_angularComponentA, solverConstraint.m_appliedImpulse);
+					bodyA->internalApplyImpulse(solverConstraint.m_contactNormal1 * bodyA->internalGetInvMass() * rb0->m_linearFactor, solverConstraint.m_angularComponentA, solverConstraint.m_appliedImpulse);
 			}
 			if (multiBodyB)
 			{
@@ -874,7 +874,7 @@ void btMultiBodyConstraintSolver::setupMultiBodyContactConstraint(btMultiBodySol
 			else
 			{
 				if (rb1)
-					bodyB->internalApplyImpulse(-solverConstraint.m_contactNormal2 * bodyB->internalGetInvMass() * rb1->getLinearFactor(), -solverConstraint.m_angularComponentB, -(btScalar)solverConstraint.m_appliedImpulse);
+					bodyB->internalApplyImpulse(-solverConstraint.m_contactNormal2 * bodyB->internalGetInvMass() * rb1->m_linearFactor, -solverConstraint.m_angularComponentB, -(btScalar)solverConstraint.m_appliedImpulse);
 			}
 		}
 	}
@@ -962,7 +962,7 @@ void btMultiBodyConstraintSolver::setupMultiBodyTorsionalFrictionConstraint(btMu
 		btVector3 torqueAxis0 = constraintNormal;
 		solverConstraint.m_relpos1CrossNormal = torqueAxis0;
 		solverConstraint.m_contactNormal1 = btVector3(0, 0, 0);
-		solverConstraint.m_angularComponentA = rb0 ? rb0->getInvInertiaTensorWorld() * torqueAxis0 * rb0->getAngularFactor() : btVector3(0, 0, 0);
+		solverConstraint.m_angularComponentA = rb0 ? rb0->m_invInertiaTensorWorld * torqueAxis0 * rb0->m_angularFactor : btVector3(0, 0, 0);
 	}
 
 	if (multiBodyB)
@@ -1005,7 +1005,7 @@ void btMultiBodyConstraintSolver::setupMultiBodyTorsionalFrictionConstraint(btMu
 		solverConstraint.m_relpos2CrossNormal = torqueAxis1;
 		solverConstraint.m_contactNormal2 = -btVector3(0, 0, 0);
 
-		solverConstraint.m_angularComponentB = rb1 ? rb1->getInvInertiaTensorWorld() * torqueAxis1 * rb1->getAngularFactor() : btVector3(0, 0, 0);
+		solverConstraint.m_angularComponentB = rb1 ? rb1->m_invInertiaTensorWorld * torqueAxis1 * rb1->m_angularFactor : btVector3(0, 0, 0);
 	}
 
 	{
@@ -1032,7 +1032,7 @@ void btMultiBodyConstraintSolver::setupMultiBodyTorsionalFrictionConstraint(btMu
 		{
 			if (rb0)
 			{
-				btVector3 iMJaA = rb0 ? rb0->getInvInertiaTensorWorld() * solverConstraint.m_relpos1CrossNormal : btVector3(0, 0, 0);
+				btVector3 iMJaA = rb0 ? rb0->m_invInertiaTensorWorld * solverConstraint.m_relpos1CrossNormal : btVector3(0, 0, 0);
 				denom0 = iMJaA.dot(solverConstraint.m_relpos1CrossNormal);
 			}
 		}
@@ -1052,7 +1052,7 @@ void btMultiBodyConstraintSolver::setupMultiBodyTorsionalFrictionConstraint(btMu
 		{
 			if (rb1)
 			{
-				btVector3 iMJaB = rb1 ? rb1->getInvInertiaTensorWorld() * solverConstraint.m_relpos2CrossNormal : btVector3(0, 0, 0);
+				btVector3 iMJaB = rb1 ? rb1->m_invInertiaTensorWorld * solverConstraint.m_relpos2CrossNormal : btVector3(0, 0, 0);
 				denom1 = iMJaB.dot(solverConstraint.m_relpos2CrossNormal);
 			}
 		}
@@ -1717,10 +1717,10 @@ btScalar btMultiBodyConstraintSolver::solveGroupCacheFriendlyFinish(btCollisionO
 		btJointFeedback* fb = constr->getJointFeedback();
 		if (fb)
 		{
-			fb->m_appliedForceBodyA += c.m_contactNormal1*c.m_appliedImpulse*constr->getRigidBodyA().getLinearFactor()/infoGlobal.m_timeStep;
-			fb->m_appliedForceBodyB += c.m_contactNormal2*c.m_appliedImpulse*constr->getRigidBodyB().getLinearFactor()/infoGlobal.m_timeStep;
-			fb->m_appliedTorqueBodyA += c.m_relpos1CrossNormal* constr->getRigidBodyA().getAngularFactor()*c.m_appliedImpulse/infoGlobal.m_timeStep;
-			fb->m_appliedTorqueBodyB += c.m_relpos2CrossNormal* constr->getRigidBodyB().getAngularFactor()*c.m_appliedImpulse/infoGlobal.m_timeStep; /*RGM ???? */
+			fb->m_appliedForceBodyA += c.m_contactNormal1*c.m_appliedImpulse*constr->getRigidBodyA().m_linearFactor/infoGlobal.m_timeStep;
+			fb->m_appliedForceBodyB += c.m_contactNormal2*c.m_appliedImpulse*constr->getRigidBodyB().m_linearFactor/infoGlobal.m_timeStep;
+			fb->m_appliedTorqueBodyA += c.m_relpos1CrossNormal* constr->getRigidBodyA().m_angularFactor*c.m_appliedImpulse/infoGlobal.m_timeStep;
+			fb->m_appliedTorqueBodyB += c.m_relpos2CrossNormal* constr->getRigidBodyB().m_angularFactor*c.m_appliedImpulse/infoGlobal.m_timeStep; /*RGM ???? */
 			
 		}
 

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

@@ -85,7 +85,7 @@ static btScalar computeConstraintMatrixDiagElementMultiBody(
 		const int solverBodyIdA = constraint.m_solverBodyIdA;
 		btAssert(solverBodyIdA != -1);
 		const btSolverBody* solverBodyA = &solverBodyPool[solverBodyIdA];
-		const btScalar invMassA = solverBodyA->m_originalBody ? solverBodyA->m_originalBody->getInvMass() : 0.0;
+		const btScalar invMassA = solverBodyA->m_originalBody ? solverBodyA->m_originalBody->m_inverseMass : 0.0;
 		ret += computeDeltaVelocityInConstraintSpace(
 			constraint.m_relpos1CrossNormal,
 			invMassA,
@@ -104,7 +104,7 @@ static btScalar computeConstraintMatrixDiagElementMultiBody(
 		const int solverBodyIdB = constraint.m_solverBodyIdB;
 		btAssert(solverBodyIdB != -1);
 		const btSolverBody* solverBodyB = &solverBodyPool[solverBodyIdB];
-		const btScalar invMassB = solverBodyB->m_originalBody ? solverBodyB->m_originalBody->getInvMass() : 0.0;
+		const btScalar invMassB = solverBodyB->m_originalBody ? solverBodyB->m_originalBody->m_inverseMass : 0.0;
 		ret += computeDeltaVelocityInConstraintSpace(
 			constraint.m_relpos2CrossNormal,
 			invMassB,
@@ -160,7 +160,7 @@ static btScalar computeConstraintMatrixOffDiagElementMultiBody(
 		{
 			btAssert(solverBodyIdA != -1);
 			const btSolverBody* solverBodyA = &solverBodyPool[solverBodyIdA];
-			const btScalar invMassA = solverBodyA->m_originalBody ? solverBodyA->m_originalBody->getInvMass() : 0.0;
+			const btScalar invMassA = solverBodyA->m_originalBody ? solverBodyA->m_originalBody->m_inverseMass : 0.0;
 			offDiagA += computeDeltaVelocityInConstraintSpace(
 				offDiagConstraint.m_relpos1CrossNormal,
 				offDiagConstraint.m_contactNormal1,
@@ -171,7 +171,7 @@ static btScalar computeConstraintMatrixOffDiagElementMultiBody(
 		{
 			btAssert(solverBodyIdB != -1);
 			const btSolverBody* solverBodyB = &solverBodyPool[solverBodyIdB];
-			const btScalar invMassB = solverBodyB->m_originalBody ? solverBodyB->m_originalBody->getInvMass() : 0.0;
+			const btScalar invMassB = solverBodyB->m_originalBody ? solverBodyB->m_originalBody->m_inverseMass : 0.0;
 			offDiagA += computeDeltaVelocityInConstraintSpace(
 				offDiagConstraint.m_relpos1CrossNormal,
 				offDiagConstraint.m_contactNormal1,
@@ -210,7 +210,7 @@ static btScalar computeConstraintMatrixOffDiagElementMultiBody(
 		{
 			btAssert(solverBodyIdA != -1);
 			const btSolverBody* solverBodyA = &solverBodyPool[solverBodyIdA];
-			const btScalar invMassA = solverBodyA->m_originalBody ? solverBodyA->m_originalBody->getInvMass() : 0.0;
+			const btScalar invMassA = solverBodyA->m_originalBody ? solverBodyA->m_originalBody->m_inverseMass : 0.0;
 			offDiagA += computeDeltaVelocityInConstraintSpace(
 				offDiagConstraint.m_relpos2CrossNormal,
 				offDiagConstraint.m_contactNormal2,
@@ -221,7 +221,7 @@ static btScalar computeConstraintMatrixOffDiagElementMultiBody(
 		{
 			btAssert(solverBodyIdB != -1);
 			const btSolverBody* solverBodyB = &solverBodyPool[solverBodyIdB];
-			const btScalar invMassB = solverBodyB->m_originalBody ? solverBodyB->m_originalBody->getInvMass() : 0.0;
+			const btScalar invMassB = solverBodyB->m_originalBody ? solverBodyB->m_originalBody->m_inverseMass : 0.0;
 			offDiagA += computeDeltaVelocityInConstraintSpace(
 				offDiagConstraint.m_relpos2CrossNormal,
 				offDiagConstraint.m_contactNormal2,
@@ -359,8 +359,8 @@ void btMultiBodyMLCPConstraintSolver::createMLCPFastRigidBody(const btContactSol
 				}
 				for (int row = 0; row < numRows; row++, cur++)
 				{
-					btVector3 normalInvMass = m_allConstraintPtrArray[i + row]->m_contactNormal1 * orgBodyA->getInvMass();
-					btVector3 relPosCrossNormalInvInertia = m_allConstraintPtrArray[i + row]->m_relpos1CrossNormal * orgBodyA->getInvInertiaTensorWorld();
+					btVector3 normalInvMass = m_allConstraintPtrArray[i + row]->m_contactNormal1 * orgBodyA->m_inverseMass;
+					btVector3 relPosCrossNormalInvInertia = m_allConstraintPtrArray[i + row]->m_relpos1CrossNormal * orgBodyA->m_invInertiaTensorWorld;
 
 					for (int r = 0; r < 3; r++)
 					{
@@ -396,8 +396,8 @@ void btMultiBodyMLCPConstraintSolver::createMLCPFastRigidBody(const btContactSol
 
 				for (int row = 0; row < numRows; row++, cur++)
 				{
-					btVector3 normalInvMassB = m_allConstraintPtrArray[i + row]->m_contactNormal2 * orgBodyB->getInvMass();
-					btVector3 relPosInvInertiaB = m_allConstraintPtrArray[i + row]->m_relpos2CrossNormal * orgBodyB->getInvInertiaTensorWorld();
+					btVector3 normalInvMassB = m_allConstraintPtrArray[i + row]->m_contactNormal2 * orgBodyB->m_inverseMass;
+					btVector3 relPosInvInertiaB = m_allConstraintPtrArray[i + row]->m_relpos2CrossNormal * orgBodyB->m_invInertiaTensorWorld;
 
 					for (int r = 0; r < 3; r++)
 					{

3rdparty/bullet3/src/BulletDynamics/MLCPSolvers/btMLCPSolver.cpp

@@ -261,8 +261,8 @@ void btMLCPSolver::createMLCPFast(const btContactSolverInfo& infoGlobal)
 				}
 				for (int row = 0; row < numRows; row++, cur++)
 				{
-					btVector3 normalInvMass = m_allConstraintPtrArray[i + row]->m_contactNormal1 * orgBodyA->getInvMass();
-					btVector3 relPosCrossNormalInvInertia = m_allConstraintPtrArray[i + row]->m_relpos1CrossNormal * orgBodyA->getInvInertiaTensorWorld();
+					btVector3 normalInvMass = m_allConstraintPtrArray[i + row]->m_contactNormal1 * orgBodyA->m_inverseMass;
+					btVector3 relPosCrossNormalInvInertia = m_allConstraintPtrArray[i + row]->m_relpos1CrossNormal * orgBodyA->m_invInertiaTensorWorld;
 
 					for (int r = 0; r < 3; r++)
 					{
@@ -298,8 +298,8 @@ void btMLCPSolver::createMLCPFast(const btContactSolverInfo& infoGlobal)
 
 				for (int row = 0; row < numRows; row++, cur++)
 				{
-					btVector3 normalInvMassB = m_allConstraintPtrArray[i + row]->m_contactNormal2 * orgBodyB->getInvMass();
-					btVector3 relPosInvInertiaB = m_allConstraintPtrArray[i + row]->m_relpos2CrossNormal * orgBodyB->getInvInertiaTensorWorld();
+					btVector3 normalInvMassB = m_allConstraintPtrArray[i + row]->m_contactNormal2 * orgBodyB->m_inverseMass;
+					btVector3 relPosInvInertiaB = m_allConstraintPtrArray[i + row]->m_relpos2CrossNormal * orgBodyB->m_invInertiaTensorWorld;
 
 					for (int r = 0; r < 3; r++)
 					{
@@ -491,7 +491,7 @@ void btMLCPSolver::createMLCP(const btContactSolverInfo& infoGlobal)
 
 		for (int r = 0; r < 3; r++)
 			for (int c = 0; c < 3; c++)
-				setElem(Minv, i * 6 + 3 + r, i * 6 + 3 + c, orgBody ? orgBody->getInvInertiaTensorWorld()[r][c] : 0);
+				setElem(Minv, i * 6 + 3 + r, i * 6 + 3 + c, orgBody ? orgBody->m_invInertiaTensorWorld[r][c] : 0);
 	}
 
 	btMatrixXu& J = m_scratchJ;

3rdparty/bullet3/src/BulletDynamics/Vehicle/btRaycastVehicle.cpp

@@ -147,9 +147,9 @@ void btRaycastVehicle::updateWheelTransformsWS(btWheelInfo& wheel, bool interpol
 	wheel.m_raycastInfo.m_isInContact = false;
 
 	btTransform chassisTrans = getChassisWorldTransform();
-	if (interpolatedTransform && (getRigidBody()->getMotionState()))
+	if (interpolatedTransform && (getRigidBody()->m_optionalMotionState))
 	{
-		getRigidBody()->getMotionState()->getWorldTransform(chassisTrans);
+		getRigidBody()->m_optionalMotionState->getWorldTransform(chassisTrans);
 	}
 
 	wheel.m_raycastInfo.m_hardPointWS = chassisTrans(wheel.m_chassisConnectionPointCS);
@@ -242,10 +242,10 @@ btScalar btRaycastVehicle::rayCast(btWheelInfo& wheel)
 
 const btTransform& btRaycastVehicle::getChassisWorldTransform() const
 {
-	/*if (getRigidBody()->getMotionState())
+	/*if (getRigidBody()->m_optionalMotionState)
 	{
 		btTransform chassisWorldTrans;
-		getRigidBody()->getMotionState()->getWorldTransform(chassisWorldTrans);
+		getRigidBody()->m_optionalMotionState->getWorldTransform(chassisWorldTrans);
 		return chassisWorldTrans;
 	}
 	*/
@@ -262,7 +262,7 @@ void btRaycastVehicle::updateVehicle(btScalar step)
 		}
 	}
 
-	m_currentVehicleSpeedKmHour = btScalar(3.6) * getRigidBody()->getLinearVelocity().length();
+	m_currentVehicleSpeedKmHour = btScalar(3.6) * getRigidBody()->m_linearVelocity.length();
 
 	const btTransform& chassisTrans = getChassisWorldTransform();
 
@@ -271,7 +271,7 @@ void btRaycastVehicle::updateVehicle(btScalar step)
 		chassisTrans.m_basis[1][m_indexForwardAxis],
 		chassisTrans.m_basis[2][m_indexForwardAxis]);
 
-	if (forwardW.dot(getRigidBody()->getLinearVelocity()) < btScalar(0.))
+	if (forwardW.dot(getRigidBody()->m_linearVelocity) < btScalar(0.))
 	{
 		m_currentVehicleSpeedKmHour *= btScalar(-1.);
 	}
@@ -385,7 +385,7 @@ void btRaycastVehicle::updateSuspension(btScalar deltaTime)
 {
 	(void)deltaTime;
 
-	btScalar chassisMass = btScalar(1.) / m_chassisBody->getInvMass();
+	btScalar chassisMass = btScalar(1.) / m_chassisBody->m_inverseMass;
 
 	for (int w_it = 0; w_it < getNumWheels(); w_it++)
 	{

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

@@ -86,11 +86,11 @@ void btReducedDeformableRigidContactConstraint::setSolverBody(const int bodyId,
 		m_solverBody = &solver_body;
 		m_linearComponentNormal = -m_contactNormalA * m_solverBody->internalGetInvMass();
 		btVector3	torqueAxis = -m_relPosA.cross(m_contactNormalA);
-		m_angularComponentNormal = m_solverBody->m_originalBody->getInvInertiaTensorWorld() * torqueAxis;
+		m_angularComponentNormal = m_solverBody->m_originalBody->m_invInertiaTensorWorld * torqueAxis;
 		
 		m_linearComponentTangent = m_contactTangent * m_solverBody->internalGetInvMass();
 		btVector3 torqueAxisTangent = m_relPosA.cross(m_contactTangent);
-		m_angularComponentTangent = m_solverBody->m_originalBody->getInvInertiaTensorWorld() * torqueAxisTangent;
+		m_angularComponentTangent = m_solverBody->m_originalBody->m_invInertiaTensorWorld * torqueAxisTangent;
 	}
 }
 
@@ -112,9 +112,9 @@ btScalar btReducedDeformableRigidContactConstraint::solveConstraint(const btCont
 	// {
 		// std::cout << "moving collision!!!\n";
 		// std::cout << "relPosA: " << m_relPosA[0] << "\t" << m_relPosA[1] << "\t" << m_relPosA[2] << "\n";
-		// std::cout << "moving rigid linear_vel: " << m_solverBody->m_originalBody->getLinearVelocity()[0] << '\t'
-		//  << m_solverBody->m_originalBody->getLinearVelocity()[1] << '\t'
-		//   << m_solverBody->m_originalBody->getLinearVelocity()[2] << '\n';
+		// std::cout << "moving rigid linear_vel: " << m_solverBody->m_originalBody->m_linearVelocity[0] << '\t'
+		//  << m_solverBody->m_originalBody->m_linearVelocity[1] << '\t'
+		//   << m_solverBody->m_originalBody->m_linearVelocity[2] << '\n';
 	// }
 	btVector3 deltaVa = getDeltaVa();
 	btVector3 deltaVb = getDeltaVb();

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

@@ -101,11 +101,11 @@ void btDeformableMultiBodyConstraintSolver::writeToSolverBody(btCollisionObject*
 		int bodyId = getOrInitSolverBody(*bodies[i], infoGlobal.m_timeStep);
 
 		btRigidBody* body = btRigidBody::upcast(bodies[i]);
-		if (body && body->getInvMass())
+		if (body && body->m_inverseMass)
 		{
 			btSolverBody& solverBody = m_tmpSolverBodyPool[bodyId];
-			solverBody.m_linearVelocity = body->getLinearVelocity() - solverBody.m_deltaLinearVelocity;
-			solverBody.m_angularVelocity = body->getAngularVelocity() - solverBody.m_deltaAngularVelocity;
+			solverBody.m_linearVelocity = body->m_linearVelocity - solverBody.m_deltaLinearVelocity;
+			solverBody.m_angularVelocity = body->m_angularVelocity - solverBody.m_deltaAngularVelocity;
 		}
 	}
 }
@@ -153,7 +153,7 @@ void btDeformableMultiBodyConstraintSolver::pairDeformableAndSolverBody(btCollis
 				int bodyId = getOrInitSolverBody(col_obj, infoGlobal.m_timeStep);
 				
 				const btRigidBody* body = btRigidBody::upcast(bodies[bodyId]);
-				if (body && body->getInvMass())
+				if (body && body->m_inverseMass)
 				{
 						// std::cout << "Node: " << constraint.m_node->index << ", body: " << bodyId << "\n";
 					btSolverBody& solverBody = m_tmpSolverBodyPool[bodyId];
@@ -167,7 +167,7 @@ void btDeformableMultiBodyConstraintSolver::pairDeformableAndSolverBody(btCollis
 		// 	int bodyId = getOrInitSolverBody(*bodies[j], infoGlobal.m_timeStep);
 
 		// 	btRigidBody* body = btRigidBody::upcast(bodies[j]);
-		// 	if (body && body->getInvMass())
+		// 	if (body && body->m_inverseMass)
 		// 	{
 		// 		btSolverBody& solverBody = m_tmpSolverBodyPool[bodyId];
 		// 		m_deformableSolver->pairConstraintWithSolverBody(i, bodyId, solverBody);

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

@@ -1,6 +1,6 @@
 /*
  Written by Xuchen Han <[email protected]>
- 
+
  Bullet Continuous Collision Detection and Physics Library
  Copyright (c) 2019 Google Inc. http://bulletphysics.org
  This software is provided 'as-is', without any express or implied warranty.
@@ -281,14 +281,14 @@ void btDeformableMultiBodyDynamicsWorld::positionCorrection(btScalar timeStep)
 		btRigidBody* rb = m_nonStaticRigidBodies[i];
 		//correct the position/orientation based on push/turn recovery
 		btTransform newTransform;
-		btVector3 pushVelocity = rb->getPushVelocity();
-		btVector3 turnVelocity = rb->getTurnVelocity();
+		btVector3 pushVelocity = rb->m_pushVelocity;
+		btVector3 turnVelocity = rb->m_turnVelocity;
 		if (pushVelocity[0] != 0.f || pushVelocity[1] != 0 || pushVelocity[2] != 0 || turnVelocity[0] != 0.f || turnVelocity[1] != 0 || turnVelocity[2] != 0)
 		{
 			btTransformUtil::integrateTransform(rb->m_worldTransform, pushVelocity, turnVelocity * infoGlobal.m_splitImpulseTurnErp, timeStep, newTransform);
 			rb->setWorldTransform(newTransform);
-			rb->setPushVelocity(zero);
-			rb->setTurnVelocity(zero);
+			rb->m_pushVelocity = (zero);
+			rb->m_turnVelocity = (zero);
 		}
 	}
 }

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

@@ -533,7 +533,7 @@ void btSoftBody::appendDeformableAnchor(int node, btRigidBody* body)
 	DeformableNodeRigidAnchor c;
 	btSoftBody::Node& n = m_nodes[node];
 	const btScalar ima = n.m_im;
-	const btScalar imb = body->getInvMass();
+	const btScalar imb = body->m_inverseMass;
 	btVector3 nrm;
 	const btCollisionShape* shp = body->m_collisionShape;
 	const btTransform& wtr = body->m_worldTransform;
@@ -553,7 +553,7 @@ void btSoftBody::appendDeformableAnchor(int node, btRigidBody* body)
 	c.m_c3 = fc;
 	c.m_c4 = body->isStaticOrKinematicObject() ? m_cfg.kKHR : m_cfg.kCHR;
 	static const btMatrix3x3 iwiStatic(0, 0, 0, 0, 0, 0, 0, 0, 0);
-	const btMatrix3x3& iwi = body->getInvInertiaTensorWorld();
+	const btMatrix3x3& iwi = body->m_invInertiaTensorWorld;
 	const btVector3 ra = n.m_x - wtr.m_origin;
 
 	c.m_c0 = ImpulseMatrix(1, ima, imb, iwi, ra);
@@ -2226,8 +2226,8 @@ void btSoftBody::solveConstraints()
 		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(),
-							   a.m_body->getInvInertiaTensorWorld(),
+							   a.m_body->m_inverseMass,
+							   a.m_body->m_invInertiaTensorWorld,
 							   ra);
 		a.m_c1 = ra;
 		a.m_c2 = m_sst.sdt * a.m_node->m_im;

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

@@ -535,13 +535,13 @@ public:
 		const btMatrix3x3& invWorldInertia() const
 		{
 			static const btMatrix3x3 iwi(0, 0, 0, 0, 0, 0, 0, 0, 0);
-			if (m_rigid) return (m_rigid->getInvInertiaTensorWorld());
+			if (m_rigid) return (m_rigid->m_invInertiaTensorWorld);
 			if (m_soft) return (m_soft->m_invwi);
 			return (iwi);
 		}
 		btScalar invMass() const
 		{
-			if (m_rigid) return (m_rigid->getInvMass());
+			if (m_rigid) return (m_rigid->m_inverseMass);
 			if (m_soft) return (m_soft->m_imass);
 			return (0);
 		}
@@ -554,19 +554,19 @@ public:
 		}
 		btVector3 linearVelocity() const
 		{
-			if (m_rigid) return (m_rigid->getLinearVelocity());
+			if (m_rigid) return (m_rigid->m_linearVelocity);
 			if (m_soft) return (m_soft->m_lv);
 			return (btVector3(0, 0, 0));
 		}
 		btVector3 angularVelocity(const btVector3& rpos) const
 		{
-			if (m_rigid) return (btCross(m_rigid->getAngularVelocity(), rpos));
+			if (m_rigid) return (btCross(m_rigid->m_angularVelocity, rpos));
 			if (m_soft) return (btCross(m_soft->m_av, rpos));
 			return (btVector3(0, 0, 0));
 		}
 		btVector3 angularVelocity() const
 		{
-			if (m_rigid) return (m_rigid->getAngularVelocity());
+			if (m_rigid) return (m_rigid->m_angularVelocity);
 			if (m_soft) return (m_soft->m_av);
 			return (btVector3(0, 0, 0));
 		}

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

@@ -1619,13 +1619,13 @@ struct btSoftColliders
 				psb->checkContact(m_colObj1Wrap, n.m_x, m, c.m_cti))
 			{
 				const btScalar ima = n.m_im;
-				const btScalar imb = m_rigidBody ? m_rigidBody->getInvMass() : 0.f;
+				const btScalar imb = m_rigidBody ? m_rigidBody->m_inverseMass : 0.f;
 				const btScalar ms = ima + imb;
 				if (ms > 0)
 				{
 					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 btMatrix3x3& iwi = m_rigidBody ? m_rigidBody->m_invInertiaTensorWorld : iwiStatic;
 					const btVector3 ra = n.m_x - wtr.m_origin;
 					const btVector3 va = m_rigidBody ? m_rigidBody->getVelocityInLocalPoint(ra) * psb->m_sst.sdt : btVector3(0, 0, 0);
 					const btVector3 vb = n.m_x - n.m_q;
@@ -1674,7 +1674,7 @@ struct btSoftColliders
 				{
 					const btScalar ima = n.m_im;
 					// todo: collision between multibody and fixed deformable node will be missed.
-					const btScalar imb = m_rigidBody ? m_rigidBody->getInvMass() : 0.f;
+					const btScalar imb = m_rigidBody ? m_rigidBody->m_inverseMass : 0.f;
 					const btScalar ms = ima + imb;
 					if (ms > 0)
 					{
@@ -1694,7 +1694,7 @@ struct btSoftColliders
 							const btVector3 ra = n.m_x - wtr.m_origin;
 
 							static const btMatrix3x3 iwiStatic(0, 0, 0, 0, 0, 0, 0, 0, 0);
-							const btMatrix3x3& iwi = m_rigidBody ? m_rigidBody->getInvInertiaTensorWorld() : iwiStatic;
+							const btMatrix3x3& iwi = m_rigidBody ? m_rigidBody->m_invInertiaTensorWorld : iwiStatic;
 							if (psb->m_reducedModel)
 							{
 								c.m_c0 = MassMatrix(imb, iwi, ra); //impulse factor K of the rigid body only (not the inverse)
@@ -1783,7 +1783,7 @@ struct btSoftColliders
 			if (psb->checkDeformableFaceContact(m_colObj1Wrap, f, contact_point, bary, m, c.m_cti, true))
 			{
 				btScalar ima = n0->m_im + n1->m_im + n2->m_im;
-				const btScalar imb = m_rigidBody ? m_rigidBody->getInvMass() : 0.f;
+				const btScalar imb = m_rigidBody ? m_rigidBody->m_inverseMass : 0.f;
 				// todo: collision between multibody and fixed deformable face will be missed.
 				const btScalar ms = ima + imb;
 				if (ms > 0)
@@ -1810,7 +1810,7 @@ struct btSoftColliders
 					{
 						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 btMatrix3x3& iwi = m_rigidBody ? m_rigidBody->m_invInertiaTensorWorld : iwiStatic;
 						const btVector3 ra = contact_point - wtr.m_origin;
 
 						// we do not scale the impulse matrix by dt

src/world/physics_world_bullet.cpp

@@ -271,8 +271,8 @@ struct PhysicsWorldImpl
 			btRigidBody *body = _actor[i].body;
 
 			_dynamics_world->removeRigidBody(body);
-			CE_DELETE(*_allocator, body->getMotionState());
-			CE_DELETE(*_allocator, body->getCollisionShape());
+			CE_DELETE(*_allocator, body->m_optionalMotionState);
+			CE_DELETE(*_allocator, body->m_collisionShape);
 			CE_DELETE(*_allocator, body);
 		}
 
@@ -546,8 +546,8 @@ struct PhysicsWorldImpl
 		const UnitId last_u = _actor[last].unit;
 
 		_dynamics_world->removeRigidBody(_actor[actor.i].body);
-		CE_DELETE(*_allocator, _actor[actor.i].body->getMotionState());
-		CE_DELETE(*_allocator, _actor[actor.i].body->getCollisionShape());
+		CE_DELETE(*_allocator, _actor[actor.i].body->m_optionalMotionState);
+		CE_DELETE(*_allocator, _actor[actor.i].body->m_collisionShape);
 		CE_DELETE(*_allocator, _actor[actor.i].body);
 
 		_actor[actor.i] = _actor[last];
@@ -612,14 +612,14 @@ struct PhysicsWorldImpl
 	void actor_enable_gravity(ActorInstance actor)
 	{
 		btRigidBody *body = _actor[actor.i].body;
-		body->setFlags(body->getFlags() & ~BT_DISABLE_WORLD_GRAVITY);
+		body->m_rigidbodyFlags = (body->m_rigidbodyFlags & ~BT_DISABLE_WORLD_GRAVITY);
 		body->setGravity(_dynamics_world->getGravity());
 	}
 
 	void actor_disable_gravity(ActorInstance actor)
 	{
 		btRigidBody *body = _actor[actor.i].body;
-		body->setFlags(body->getFlags() | BT_DISABLE_WORLD_GRAVITY);
+		body->m_rigidbodyFlags = (body->m_rigidbodyFlags | BT_DISABLE_WORLD_GRAVITY);
 		body->setGravity(btVector3(0.0f, 0.0f, 0.0f));
 	}
 
@@ -678,27 +678,27 @@ struct PhysicsWorldImpl
 
 	f32 actor_linear_damping(ActorInstance actor) const
 	{
-		return _actor[actor.i].body->getLinearDamping();
+		return _actor[actor.i].body->m_linearDamping;
 	}
 
 	void actor_set_linear_damping(ActorInstance actor, f32 rate)
 	{
-		_actor[actor.i].body->setDamping(rate, _actor[actor.i].body->getAngularDamping());
+		_actor[actor.i].body->setDamping(rate, _actor[actor.i].body->m_angularDamping);
 	}
 
 	f32 actor_angular_damping(ActorInstance actor) const
 	{
-		return _actor[actor.i].body->getAngularDamping();
+		return _actor[actor.i].body->m_angularDamping;
 	}
 
 	void actor_set_angular_damping(ActorInstance actor, f32 rate)
 	{
-		_actor[actor.i].body->setDamping(_actor[actor.i].body->getLinearDamping(), rate);
+		_actor[actor.i].body->setDamping(_actor[actor.i].body->m_linearDamping, rate);
 	}
 
 	Vector3 actor_linear_velocity(ActorInstance actor) const
 	{
-		btVector3 v = _actor[actor.i].body->getLinearVelocity();
+		btVector3 v = _actor[actor.i].body->m_linearVelocity;
 		return to_vector3(v);
 	}
 
@@ -710,7 +710,7 @@ struct PhysicsWorldImpl
 
 	Vector3 actor_angular_velocity(ActorInstance actor) const
 	{
-		btVector3 v = _actor[actor.i].body->getAngularVelocity();
+		btVector3 v = _actor[actor.i].body->m_angularVelocity;
 		return to_vector3(v);
 	}
 
@@ -941,7 +941,7 @@ struct PhysicsWorldImpl
 			const Quaternion rot = rotation(*begin_world);
 			const Vector3 pos = translation(*begin_world);
 			// http://www.bulletphysics.org/mediawiki-1.5.8/index.php/MotionStates
-			btMotionState *ms = _actor[ai].body->getMotionState();
+			btMotionState *ms = _actor[ai].body->m_optionalMotionState;
 			if (ms)
 				ms->setWorldTransform(btTransform(to_btQuaternion(rot), to_btVector3(pos)));
 		}
@@ -961,13 +961,13 @@ struct PhysicsWorldImpl
 
 			btRigidBody *body = btRigidBody::upcast(collision_array[i]);
 			if (body
-				&& body->getMotionState()
+				&& body->m_optionalMotionState
 				&& body->isActive()
 				) {
 				const UnitId unit_id = _actor[(u32)(uintptr_t)body->m_userObjectPointer].unit;
 
 				btTransform tr;
-				body->getMotionState()->getWorldTransform(tr);
+				body->m_optionalMotionState->getWorldTransform(tr);
 
 				// Post transform event
 				{
@@ -1005,7 +1005,7 @@ struct PhysicsWorldImpl
 		// Limit bodies velocity
 		for (u32 i = 0; i < array::size(_actor); ++i) {
 			CE_ENSURE(NULL != _actor[i].body);
-			const btVector3 velocity = _actor[i].body->getLinearVelocity();
+			const btVector3 velocity = _actor[i].body->m_linearVelocity;
 			const btScalar speed = velocity.length();
 
 			if (speed > 100.0f)