3rdparty: bullet3: remove getters/setters from btVector3 and btQuadWord

Part-of: #259

3rdparty/bullet3/src/BulletCollision/BroadphaseCollision/btAxisSweep3Internal.h

@@ -180,8 +180,8 @@ public:
 	{
 		/*		printf("btAxisSweep3.h\n");
 		printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_maxHandles);
-		printf("aabbMin=%f,%f,%f,aabbMax=%f,%f,%f\n",m_worldAabbMin.getX(),m_worldAabbMin.getY(),m_worldAabbMin.getZ(),
-			m_worldAabbMax.getX(),m_worldAabbMax.getY(),m_worldAabbMax.getZ());
+		printf("aabbMin=%f,%f,%f,aabbMax=%f,%f,%f\n",m_worldAabbMin.m_floats[0],m_worldAabbMin.m_floats[1],m_worldAabbMin.m_floats[2],
+			m_worldAabbMax.m_floats[0],m_worldAabbMax.m_floats[1],m_worldAabbMax.m_floats[2]);
 			*/
 	}
 };
@@ -320,10 +320,10 @@ void btAxisSweep3Internal<BP_FP_INT_TYPE>::unQuantize(btBroadphaseProxy* proxy,
 	vecInMin[2] = m_pEdges[2][pHandle->m_minEdges[2]].m_pos;
 	vecInMax[2] = m_pEdges[2][pHandle->m_maxEdges[2]].m_pos + 1;
 
-	aabbMin.setValue((btScalar)(vecInMin[0]) / (m_quantize.getX()), (btScalar)(vecInMin[1]) / (m_quantize.getY()), (btScalar)(vecInMin[2]) / (m_quantize.getZ()));
+	aabbMin.setValue((btScalar)(vecInMin[0]) / (m_quantize.m_floats[0]), (btScalar)(vecInMin[1]) / (m_quantize.m_floats[1]), (btScalar)(vecInMin[2]) / (m_quantize.m_floats[2]));
 	aabbMin += m_worldAabbMin;
 
-	aabbMax.setValue((btScalar)(vecInMax[0]) / (m_quantize.getX()), (btScalar)(vecInMax[1]) / (m_quantize.getY()), (btScalar)(vecInMax[2]) / (m_quantize.getZ()));
+	aabbMax.setValue((btScalar)(vecInMax[0]) / (m_quantize.m_floats[0]), (btScalar)(vecInMax[1]) / (m_quantize.m_floats[1]), (btScalar)(vecInMax[2]) / (m_quantize.m_floats[2]));
 	aabbMax += m_worldAabbMin;
 }
 
@@ -442,9 +442,9 @@ void btAxisSweep3Internal<BP_FP_INT_TYPE>::quantize(BP_FP_INT_TYPE* out, const b
 	clampedPoint.setMax(m_worldAabbMin);
 	clampedPoint.setMin(m_worldAabbMax);
 	btVector3 v = (clampedPoint - m_worldAabbMin) * m_quantize;
-	out[0] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getX() & m_bpHandleMask) | isMax);
-	out[1] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getY() & m_bpHandleMask) | isMax);
-	out[2] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getZ() & m_bpHandleMask) | isMax);
+	out[0] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.m_floats[0] & m_bpHandleMask) | isMax);
+	out[1] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.m_floats[1] & m_bpHandleMask) | isMax);
+	out[2] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.m_floats[2] & m_bpHandleMask) | isMax);
 #else
 	btVector3 v = (point - m_worldAabbMin) * m_quantize;
 	out[0] = (v[0] <= 0) ? (BP_FP_INT_TYPE)isMax : (v[0] >= m_handleSentinel) ? (BP_FP_INT_TYPE)((m_handleSentinel & m_bpHandleMask) | isMax) : (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v[0] & m_bpHandleMask) | isMax);

3rdparty/bullet3/src/BulletCollision/BroadphaseCollision/btDbvt.cpp

@@ -52,8 +52,8 @@ static DBVT_INLINE btDbvtVolume merge(const btDbvtVolume& a,
 static DBVT_INLINE btScalar size(const btDbvtVolume& a)
 {
 	const btVector3 edges = a.Lengths();
-	return (edges.x() * edges.y() * edges.z() +
-			edges.x() + edges.y() + edges.z());
+	return (edges.m_floats[0] * edges.m_floats[1] * edges.m_floats[2] +
+			edges.m_floats[0] + edges.m_floats[1] + edges.m_floats[2]);
 }
 
 //

3rdparty/bullet3/src/BulletCollision/BroadphaseCollision/btDbvt.h

@@ -520,29 +520,29 @@ DBVT_INLINE void btDbvtAabbMm::Expand(const btVector3& e)
 //
 DBVT_INLINE void btDbvtAabbMm::SignedExpand(const btVector3& e)
 {
-	if (e.x() > 0)
-		mx.setX(mx.x() + e[0]);
+	if (e.m_floats[0] > 0)
+		mx.m_floats[0] = (mx.m_floats[0] + e[0]);
 	else
-		mi.setX(mi.x() + e[0]);
-	if (e.y() > 0)
-		mx.setY(mx.y() + e[1]);
+		mi.m_floats[0] = (mi.m_floats[0] + e[0]);
+	if (e.m_floats[1] > 0)
+		mx.m_floats[1] = (mx.m_floats[1] + e[1]);
 	else
-		mi.setY(mi.y() + e[1]);
-	if (e.z() > 0)
-		mx.setZ(mx.z() + e[2]);
+		mi.m_floats[1] = (mi.m_floats[1] + e[1]);
+	if (e.m_floats[2] > 0)
+		mx.m_floats[2] = (mx.m_floats[2] + e[2]);
 	else
-		mi.setZ(mi.z() + e[2]);
+		mi.m_floats[2] = (mi.m_floats[2] + e[2]);
 }
 
 //
 DBVT_INLINE bool btDbvtAabbMm::Contain(const btDbvtAabbMm& a) const
 {
-	return ((mi.x() <= a.mi.x()) &&
-			(mi.y() <= a.mi.y()) &&
-			(mi.z() <= a.mi.z()) &&
-			(mx.x() >= a.mx.x()) &&
-			(mx.y() >= a.mx.y()) &&
-			(mx.z() >= a.mx.z()));
+	return ((mi.m_floats[0] <= a.mi.m_floats[0]) &&
+			(mi.m_floats[1] <= a.mi.m_floats[1]) &&
+			(mi.m_floats[2] <= a.mi.m_floats[2]) &&
+			(mx.m_floats[0] >= a.mx.m_floats[0]) &&
+			(mx.m_floats[1] >= a.mx.m_floats[1]) &&
+			(mx.m_floats[2] >= a.mx.m_floats[2]));
 }
 
 //
@@ -552,36 +552,36 @@ DBVT_INLINE int btDbvtAabbMm::Classify(const btVector3& n, btScalar o, int s) co
 	switch (s)
 	{
 		case (0 + 0 + 0):
-			px = btVector3(mi.x(), mi.y(), mi.z());
-			pi = btVector3(mx.x(), mx.y(), mx.z());
+			px = btVector3(mi.m_floats[0], mi.m_floats[1], mi.m_floats[2]);
+			pi = btVector3(mx.m_floats[0], mx.m_floats[1], mx.m_floats[2]);
 			break;
 		case (1 + 0 + 0):
-			px = btVector3(mx.x(), mi.y(), mi.z());
-			pi = btVector3(mi.x(), mx.y(), mx.z());
+			px = btVector3(mx.m_floats[0], mi.m_floats[1], mi.m_floats[2]);
+			pi = btVector3(mi.m_floats[0], mx.m_floats[1], mx.m_floats[2]);
 			break;
 		case (0 + 2 + 0):
-			px = btVector3(mi.x(), mx.y(), mi.z());
-			pi = btVector3(mx.x(), mi.y(), mx.z());
+			px = btVector3(mi.m_floats[0], mx.m_floats[1], mi.m_floats[2]);
+			pi = btVector3(mx.m_floats[0], mi.m_floats[1], mx.m_floats[2]);
 			break;
 		case (1 + 2 + 0):
-			px = btVector3(mx.x(), mx.y(), mi.z());
-			pi = btVector3(mi.x(), mi.y(), mx.z());
+			px = btVector3(mx.m_floats[0], mx.m_floats[1], mi.m_floats[2]);
+			pi = btVector3(mi.m_floats[0], mi.m_floats[1], mx.m_floats[2]);
 			break;
 		case (0 + 0 + 4):
-			px = btVector3(mi.x(), mi.y(), mx.z());
-			pi = btVector3(mx.x(), mx.y(), mi.z());
+			px = btVector3(mi.m_floats[0], mi.m_floats[1], mx.m_floats[2]);
+			pi = btVector3(mx.m_floats[0], mx.m_floats[1], mi.m_floats[2]);
 			break;
 		case (1 + 0 + 4):
-			px = btVector3(mx.x(), mi.y(), mx.z());
-			pi = btVector3(mi.x(), mx.y(), mi.z());
+			px = btVector3(mx.m_floats[0], mi.m_floats[1], mx.m_floats[2]);
+			pi = btVector3(mi.m_floats[0], mx.m_floats[1], mi.m_floats[2]);
 			break;
 		case (0 + 2 + 4):
-			px = btVector3(mi.x(), mx.y(), mx.z());
-			pi = btVector3(mx.x(), mi.y(), mi.z());
+			px = btVector3(mi.m_floats[0], mx.m_floats[1], mx.m_floats[2]);
+			pi = btVector3(mx.m_floats[0], mi.m_floats[1], mi.m_floats[2]);
 			break;
 		case (1 + 2 + 4):
-			px = btVector3(mx.x(), mx.y(), mx.z());
-			pi = btVector3(mi.x(), mi.y(), mi.z());
+			px = btVector3(mx.m_floats[0], mx.m_floats[1], mx.m_floats[2]);
+			pi = btVector3(mi.m_floats[0], mi.m_floats[1], mi.m_floats[2]);
 			break;
 	}
 	if ((btDot(n, px) + o) < 0) return (-1);
@@ -593,9 +593,9 @@ DBVT_INLINE int btDbvtAabbMm::Classify(const btVector3& n, btScalar o, int s) co
 DBVT_INLINE btScalar btDbvtAabbMm::ProjectMinimum(const btVector3& v, unsigned signs) const
 {
 	const btVector3* b[] = {&mx, &mi};
-	const btVector3 p(b[(signs >> 0) & 1]->x(),
-					  b[(signs >> 1) & 1]->y(),
-					  b[(signs >> 2) & 1]->z());
+	const btVector3 p(b[(signs >> 0) & 1]->m_floats[0],
+					  b[(signs >> 1) & 1]->m_floats[1],
+					  b[(signs >> 2) & 1]->m_floats[2]);
 	return (btDot(p, v));
 }
 
@@ -631,12 +631,12 @@ DBVT_INLINE bool Intersect(const btDbvtAabbMm& a,
 #endif
 	return ((pu[0] | pu[1] | pu[2]) == 0);
 #else
-	return ((a.mi.x() <= b.mx.x()) &&
-			(a.mx.x() >= b.mi.x()) &&
-			(a.mi.y() <= b.mx.y()) &&
-			(a.mx.y() >= b.mi.y()) &&
-			(a.mi.z() <= b.mx.z()) &&
-			(a.mx.z() >= b.mi.z()));
+	return ((a.mi.m_floats[0] <= b.mx.m_floats[0]) &&
+			(a.mx.m_floats[0] >= b.mi.m_floats[0]) &&
+			(a.mi.m_floats[1] <= b.mx.m_floats[1]) &&
+			(a.mx.m_floats[1] >= b.mi.m_floats[1]) &&
+			(a.mi.m_floats[2] <= b.mx.m_floats[2]) &&
+			(a.mx.m_floats[2] >= b.mi.m_floats[2]));
 #endif
 }
 
@@ -644,12 +644,12 @@ DBVT_INLINE bool Intersect(const btDbvtAabbMm& a,
 DBVT_INLINE bool Intersect(const btDbvtAabbMm& a,
 						   const btVector3& b)
 {
-	return ((b.x() >= a.mi.x()) &&
-			(b.y() >= a.mi.y()) &&
-			(b.z() >= a.mi.z()) &&
-			(b.x() <= a.mx.x()) &&
-			(b.y() <= a.mx.y()) &&
-			(b.z() <= a.mx.z()));
+	return ((b.m_floats[0] >= a.mi.m_floats[0]) &&
+			(b.m_floats[1] >= a.mi.m_floats[1]) &&
+			(b.m_floats[2] >= a.mi.m_floats[2]) &&
+			(b.m_floats[0] <= a.mx.m_floats[0]) &&
+			(b.m_floats[1] <= a.mx.m_floats[1]) &&
+			(b.m_floats[2] <= a.mx.m_floats[2]));
 }
 
 //////////////////////////////////////
@@ -659,7 +659,7 @@ DBVT_INLINE btScalar Proximity(const btDbvtAabbMm& a,
 							   const btDbvtAabbMm& b)
 {
 	const btVector3 d = (a.mi + a.mx) - (b.mi + b.mx);
-	return (btFabs(d.x()) + btFabs(d.y()) + btFabs(d.z()));
+	return (btFabs(d.m_floats[0]) + btFabs(d.m_floats[1]) + btFabs(d.m_floats[2]));
 }
 
 //
@@ -774,12 +774,12 @@ DBVT_INLINE void Merge(const btDbvtAabbMm& a,
 DBVT_INLINE bool NotEqual(const btDbvtAabbMm& a,
 						  const btDbvtAabbMm& b)
 {
-	return ((a.mi.x() != b.mi.x()) ||
-			(a.mi.y() != b.mi.y()) ||
-			(a.mi.z() != b.mi.z()) ||
-			(a.mx.x() != b.mx.x()) ||
-			(a.mx.y() != b.mx.y()) ||
-			(a.mx.z() != b.mx.z()));
+	return ((a.mi.m_floats[0] != b.mi.m_floats[0]) ||
+			(a.mi.m_floats[1] != b.mi.m_floats[1]) ||
+			(a.mi.m_floats[2] != b.mi.m_floats[2]) ||
+			(a.mx.m_floats[0] != b.mx.m_floats[0]) ||
+			(a.mx.m_floats[1] != b.mx.m_floats[1]) ||
+			(a.mx.m_floats[2] != b.mx.m_floats[2]));
 }
 
 //
@@ -1362,9 +1362,9 @@ inline void btDbvt::collideKDOP(const btDbvtNode* root,
 		btAssert(count < int(sizeof(signs) / sizeof(signs[0])));
 		for (int i = 0; i < count; ++i)
 		{
-			signs[i] = ((normals[i].x() >= 0) ? 1 : 0) +
-					   ((normals[i].y() >= 0) ? 2 : 0) +
-					   ((normals[i].z() >= 0) ? 4 : 0);
+			signs[i] = ((normals[i].m_floats[0] >= 0) ? 1 : 0) +
+					   ((normals[i].m_floats[1] >= 0) ? 2 : 0) +
+					   ((normals[i].m_floats[2] >= 0) ? 4 : 0);
 		}
 		stack.reserve(SIMPLE_STACKSIZE);
 		stack.push_back(sStkNP(root, 0));
@@ -1429,9 +1429,9 @@ inline void btDbvt::collideOCL(const btDbvtNode* root,
 		btAssert(count < int(sizeof(signs) / sizeof(signs[0])));
 		for (int i = 0; i < count; ++i)
 		{
-			signs[i] = ((normals[i].x() >= 0) ? 1 : 0) +
-					   ((normals[i].y() >= 0) ? 2 : 0) +
-					   ((normals[i].z() >= 0) ? 4 : 0);
+			signs[i] = ((normals[i].m_floats[0] >= 0) ? 1 : 0) +
+					   ((normals[i].m_floats[1] >= 0) ? 2 : 0) +
+					   ((normals[i].m_floats[2] >= 0) ? 4 : 0);
 		}
 		stock.reserve(SIMPLE_STACKSIZE);
 		stack.reserve(SIMPLE_STACKSIZE);

3rdparty/bullet3/src/BulletCollision/BroadphaseCollision/btQuantizedBvh.h

@@ -329,13 +329,13 @@ public:
 	{
 		btAssert(m_useQuantization);
 
-		btAssert(point.getX() <= m_bvhAabbMax.getX());
-		btAssert(point.getY() <= m_bvhAabbMax.getY());
-		btAssert(point.getZ() <= m_bvhAabbMax.getZ());
+		btAssert(point.m_floats[0] <= m_bvhAabbMax.m_floats[0]);
+		btAssert(point.m_floats[1] <= m_bvhAabbMax.m_floats[1]);
+		btAssert(point.m_floats[2] <= m_bvhAabbMax.m_floats[2]);
 
-		btAssert(point.getX() >= m_bvhAabbMin.getX());
-		btAssert(point.getY() >= m_bvhAabbMin.getY());
-		btAssert(point.getZ() >= m_bvhAabbMin.getZ());
+		btAssert(point.m_floats[0] >= m_bvhAabbMin.m_floats[0]);
+		btAssert(point.m_floats[1] >= m_bvhAabbMin.m_floats[1]);
+		btAssert(point.m_floats[2] >= m_bvhAabbMin.m_floats[2]);
 
 		btVector3 v = (point - m_bvhAabbMin) * m_bvhQuantization;
 		///Make sure rounding is done in a way that unQuantize(quantizeWithClamp(...)) is conservative
@@ -343,47 +343,47 @@ public:
 		///@todo: double-check this
 		if (isMax)
 		{
-			out[0] = (unsigned short)(((unsigned short)(v.getX() + btScalar(1.)) | 1));
-			out[1] = (unsigned short)(((unsigned short)(v.getY() + btScalar(1.)) | 1));
-			out[2] = (unsigned short)(((unsigned short)(v.getZ() + btScalar(1.)) | 1));
+			out[0] = (unsigned short)(((unsigned short)(v.m_floats[0] + btScalar(1.)) | 1));
+			out[1] = (unsigned short)(((unsigned short)(v.m_floats[1] + btScalar(1.)) | 1));
+			out[2] = (unsigned short)(((unsigned short)(v.m_floats[2] + btScalar(1.)) | 1));
 		}
 		else
 		{
-			out[0] = (unsigned short)(((unsigned short)(v.getX()) & 0xfffe));
-			out[1] = (unsigned short)(((unsigned short)(v.getY()) & 0xfffe));
-			out[2] = (unsigned short)(((unsigned short)(v.getZ()) & 0xfffe));
+			out[0] = (unsigned short)(((unsigned short)(v.m_floats[0]) & 0xfffe));
+			out[1] = (unsigned short)(((unsigned short)(v.m_floats[1]) & 0xfffe));
+			out[2] = (unsigned short)(((unsigned short)(v.m_floats[2]) & 0xfffe));
 		}
 
 #ifdef DEBUG_CHECK_DEQUANTIZATION
 		btVector3 newPoint = unQuantize(out);
 		if (isMax)
 		{
-			if (newPoint.getX() < point.getX())
+			if (newPoint.m_floats[0] < point.m_floats[0])
 			{
-				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.getX() - point.getX(), newPoint.getX(), point.getX());
+				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.m_floats[0] - point.m_floats[0], newPoint.m_floats[0], point.m_floats[0]);
 			}
-			if (newPoint.getY() < point.getY())
+			if (newPoint.m_floats[1] < point.m_floats[1])
 			{
-				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.getY() - point.getY(), newPoint.getY(), point.getY());
+				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.m_floats[1] - point.m_floats[1], newPoint.m_floats[1], point.m_floats[1]);
 			}
-			if (newPoint.getZ() < point.getZ())
+			if (newPoint.m_floats[2] < point.m_floats[2])
 			{
-				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.getZ() - point.getZ(), newPoint.getZ(), point.getZ());
+				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.m_floats[2] - point.m_floats[2], newPoint.m_floats[2], point.m_floats[2]);
 			}
 		}
 		else
 		{
-			if (newPoint.getX() > point.getX())
+			if (newPoint.m_floats[0] > point.m_floats[0])
 			{
-				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.getX() - point.getX(), newPoint.getX(), point.getX());
+				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n", newPoint.m_floats[0] - point.m_floats[0], newPoint.m_floats[0], point.m_floats[0]);
 			}
-			if (newPoint.getY() > point.getY())
+			if (newPoint.m_floats[1] > point.m_floats[1])
 			{
-				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.getY() - point.getY(), newPoint.getY(), point.getY());
+				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n", newPoint.m_floats[1] - point.m_floats[1], newPoint.m_floats[1], point.m_floats[1]);
 			}
-			if (newPoint.getZ() > point.getZ())
+			if (newPoint.m_floats[2] > point.m_floats[2])
 			{
-				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.getZ() - point.getZ(), newPoint.getZ(), point.getZ());
+				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n", newPoint.m_floats[2] - point.m_floats[2], newPoint.m_floats[2], point.m_floats[2]);
 			}
 		}
 #endif  //DEBUG_CHECK_DEQUANTIZATION
@@ -404,9 +404,9 @@ public:
 	{
 		btVector3 vecOut;
 		vecOut.setValue(
-			(btScalar)(vecIn[0]) / (m_bvhQuantization.getX()),
-			(btScalar)(vecIn[1]) / (m_bvhQuantization.getY()),
-			(btScalar)(vecIn[2]) / (m_bvhQuantization.getZ()));
+			(btScalar)(vecIn[0]) / (m_bvhQuantization.m_floats[0]),
+			(btScalar)(vecIn[1]) / (m_bvhQuantization.m_floats[1]),
+			(btScalar)(vecIn[2]) / (m_bvhQuantization.m_floats[2]));
 		vecOut += m_bvhAabbMin;
 		return vecOut;
 	}

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

@@ -87,7 +87,7 @@ struct ClipVertex
 #define b2Mul(a, b) (a) * (b)
 #define b2MulT(a, b) (a).transpose() * (b)
 #define b2Cross(a, b) (a).cross(b)
-#define btCrossS(a, s) btVector3(s* a.getY(), -s* a.getX(), 0.f)
+#define btCrossS(a, s) btVector3(s* a.m_floats[1], -s* a.m_floats[0], 0.f)
 
 int b2_maxManifoldPoints = 2;
 

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

@@ -740,14 +740,14 @@ void btBoxBoxDetector::getClosestPoints(const ClosestPointInput& input, Result&
 
 	for (int j = 0; j < 3; j++)
 	{
-		R1[0 + 4 * j] = transformA.m_basis[j].x();
-		R2[0 + 4 * j] = transformB.m_basis[j].x();
+		R1[0 + 4 * j] = transformA.m_basis[j].m_floats[0];
+		R2[0 + 4 * j] = transformB.m_basis[j].m_floats[0];
 
-		R1[1 + 4 * j] = transformA.m_basis[j].y();
-		R2[1 + 4 * j] = transformB.m_basis[j].y();
+		R1[1 + 4 * j] = transformA.m_basis[j].m_floats[1];
+		R2[1 + 4 * j] = transformB.m_basis[j].m_floats[1];
 
-		R1[2 + 4 * j] = transformA.m_basis[j].z();
-		R2[2 + 4 * j] = transformB.m_basis[j].z();
+		R1[2 + 4 * j] = transformA.m_basis[j].m_floats[2];
+		R2[2 + 4 * j] = transformB.m_basis[j].m_floats[2];
 	}
 
 	btVector3 normal;

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

@@ -520,7 +520,7 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 				}
 				if (foundSepAxis)
 				{
-					//				printf("sepNormalWorldSpace=%f,%f,%f\n",sepNormalWorldSpace.getX(),sepNormalWorldSpace.getY(),sepNormalWorldSpace.getZ());
+					//				printf("sepNormalWorldSpace=%f,%f,%f\n",sepNormalWorldSpace.m_floats[0],sepNormalWorldSpace.m_floats[1],sepNormalWorldSpace.m_floats[2]);
 
 					worldVertsB1.resize(0);
 					btPolyhedralContactClipping::clipHullAgainstHull(sepNormalWorldSpace, *polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(),
@@ -638,7 +638,7 @@ void btConvexConvexAlgorithm ::processCollision(const btCollisionObjectWrapper*
 							body0Wrap->getWorldTransform(),
 							body1Wrap->getWorldTransform(),
 							sepNormalWorldSpace, *resultOut);
-						//	 printf("sepNormalWorldSpace=%f,%f,%f\n",sepNormalWorldSpace.getX(),sepNormalWorldSpace.getY(),sepNormalWorldSpace.getZ());
+						//	 printf("sepNormalWorldSpace=%f,%f,%f\n",sepNormalWorldSpace.m_floats[0],sepNormalWorldSpace.m_floats[1],sepNormalWorldSpace.m_floats[2]);
 					}
 					else
 					{

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

@@ -80,15 +80,15 @@ struct btConnectivityProcessor : public btTriangleCallback
 
 #if 0
 		printf("triangle A[0]	=	(%f,%f,%f)\ntriangle A[1]	=	(%f,%f,%f)\ntriangle A[2]	=	(%f,%f,%f)\n",
-			m_triangleVerticesA[0].getX(),m_triangleVerticesA[0].getY(),m_triangleVerticesA[0].getZ(),
-			m_triangleVerticesA[1].getX(),m_triangleVerticesA[1].getY(),m_triangleVerticesA[1].getZ(),
-			m_triangleVerticesA[2].getX(),m_triangleVerticesA[2].getY(),m_triangleVerticesA[2].getZ());
+			m_triangleVerticesA[0].m_floats[0],m_triangleVerticesA[0].m_floats[1],m_triangleVerticesA[0].m_floats[2],
+			m_triangleVerticesA[1].m_floats[0],m_triangleVerticesA[1].m_floats[1],m_triangleVerticesA[1].m_floats[2],
+			m_triangleVerticesA[2].m_floats[0],m_triangleVerticesA[2].m_floats[1],m_triangleVerticesA[2].m_floats[2]);
 
 		printf("partId=%d, triangleIndex=%d\n",partId,triangleIndex);
 		printf("triangle B[0]	=	(%f,%f,%f)\ntriangle B[1]	=	(%f,%f,%f)\ntriangle B[2]	=	(%f,%f,%f)\n",
-			triangle[0].getX(),triangle[0].getY(),triangle[0].getZ(),
-			triangle[1].getX(),triangle[1].getY(),triangle[1].getZ(),
-			triangle[2].getX(),triangle[2].getY(),triangle[2].getZ());
+			triangle[0].m_floats[0],triangle[0].m_floats[1],triangle[0].m_floats[2],
+			triangle[1].m_floats[0],triangle[1].m_floats[1],triangle[1].m_floats[2],
+			triangle[2].m_floats[0],triangle[2].m_floats[1],triangle[2].m_floats[2]);
 #endif
 
 		for (int i = 0; i < 3; i++)
@@ -372,14 +372,14 @@ void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape* trimeshShape, btTriangle
 				{
 					float* graphicsbase = (float*)(vertexbase + graphicsindex * stride);
 					triangleVerts[j] = btVector3(
-						graphicsbase[0] * meshScaling.getX(),
-						graphicsbase[1] * meshScaling.getY(),
-						graphicsbase[2] * meshScaling.getZ());
+						graphicsbase[0] * meshScaling.m_floats[0],
+						graphicsbase[1] * meshScaling.m_floats[1],
+						graphicsbase[2] * meshScaling.m_floats[2]);
 				}
 				else
 				{
 					double* graphicsbase = (double*)(vertexbase + graphicsindex * stride);
-					triangleVerts[j] = btVector3(btScalar(graphicsbase[0] * meshScaling.getX()), btScalar(graphicsbase[1] * meshScaling.getY()), btScalar(graphicsbase[2] * meshScaling.getZ()));
+					triangleVerts[j] = btVector3(btScalar(graphicsbase[0] * meshScaling.m_floats[0]), btScalar(graphicsbase[1] * meshScaling.m_floats[1]), btScalar(graphicsbase[2] * meshScaling.m_floats[2]));
 				}
 			}
 			aabbMin.setValue(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT));

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

@@ -106,12 +106,12 @@ bool btSphereBoxCollisionAlgorithm::getSphereDistance(const btCollisionObjectWra
 
 	// Determine the closest point to the sphere center in the box
 	btVector3 closestPoint = sphereRelPos;
-	closestPoint.setX(btMin(boxHalfExtent.getX(), closestPoint.getX()));
-	closestPoint.setX(btMax(-boxHalfExtent.getX(), closestPoint.getX()));
-	closestPoint.setY(btMin(boxHalfExtent.getY(), closestPoint.getY()));
-	closestPoint.setY(btMax(-boxHalfExtent.getY(), closestPoint.getY()));
-	closestPoint.setZ(btMin(boxHalfExtent.getZ(), closestPoint.getZ()));
-	closestPoint.setZ(btMax(-boxHalfExtent.getZ(), closestPoint.getZ()));
+	closestPoint.m_floats[0] = (btMin(boxHalfExtent.m_floats[0], closestPoint.m_floats[0]));
+	closestPoint.m_floats[0] = (btMax(-boxHalfExtent.m_floats[0], closestPoint.m_floats[0]));
+	closestPoint.m_floats[1] = (btMin(boxHalfExtent.m_floats[1], closestPoint.m_floats[1]));
+	closestPoint.m_floats[1] = (btMax(-boxHalfExtent.m_floats[1], closestPoint.m_floats[1]));
+	closestPoint.m_floats[2] = (btMin(boxHalfExtent.m_floats[2], closestPoint.m_floats[2]));
+	closestPoint.m_floats[2] = (btMax(-boxHalfExtent.m_floats[2], closestPoint.m_floats[2]));
 
 	btScalar intersectionDist = fRadius + boxMargin;
 	btScalar contactDist = intersectionDist + maxContactDistance;
@@ -155,53 +155,53 @@ bool btSphereBoxCollisionAlgorithm::getSphereDistance(const btCollisionObjectWra
 btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration(btVector3 const& boxHalfExtent, btVector3 const& sphereRelPos, btVector3& closestPoint, btVector3& normal)
 {
 	//project the center of the sphere on the closest face of the box
-	btScalar faceDist = boxHalfExtent.getX() - sphereRelPos.getX();
+	btScalar faceDist = boxHalfExtent.m_floats[0] - sphereRelPos.m_floats[0];
 	btScalar minDist = faceDist;
-	closestPoint.setX(boxHalfExtent.getX());
+	closestPoint.m_floats[0] = (boxHalfExtent.m_floats[0]);
 	normal.setValue(btScalar(1.0f), btScalar(0.0f), btScalar(0.0f));
 
-	faceDist = boxHalfExtent.getX() + sphereRelPos.getX();
+	faceDist = boxHalfExtent.m_floats[0] + sphereRelPos.m_floats[0];
 	if (faceDist < minDist)
 	{
 		minDist = faceDist;
 		closestPoint = sphereRelPos;
-		closestPoint.setX(-boxHalfExtent.getX());
+		closestPoint.m_floats[0] = (-boxHalfExtent.m_floats[0]);
 		normal.setValue(btScalar(-1.0f), btScalar(0.0f), btScalar(0.0f));
 	}
 
-	faceDist = boxHalfExtent.getY() - sphereRelPos.getY();
+	faceDist = boxHalfExtent.m_floats[1] - sphereRelPos.m_floats[1];
 	if (faceDist < minDist)
 	{
 		minDist = faceDist;
 		closestPoint = sphereRelPos;
-		closestPoint.setY(boxHalfExtent.getY());
+		closestPoint.m_floats[1] = (boxHalfExtent.m_floats[1]);
 		normal.setValue(btScalar(0.0f), btScalar(1.0f), btScalar(0.0f));
 	}
 
-	faceDist = boxHalfExtent.getY() + sphereRelPos.getY();
+	faceDist = boxHalfExtent.m_floats[1] + sphereRelPos.m_floats[1];
 	if (faceDist < minDist)
 	{
 		minDist = faceDist;
 		closestPoint = sphereRelPos;
-		closestPoint.setY(-boxHalfExtent.getY());
+		closestPoint.m_floats[1] = (-boxHalfExtent.m_floats[1]);
 		normal.setValue(btScalar(0.0f), btScalar(-1.0f), btScalar(0.0f));
 	}
 
-	faceDist = boxHalfExtent.getZ() - sphereRelPos.getZ();
+	faceDist = boxHalfExtent.m_floats[2] - sphereRelPos.m_floats[2];
 	if (faceDist < minDist)
 	{
 		minDist = faceDist;
 		closestPoint = sphereRelPos;
-		closestPoint.setZ(boxHalfExtent.getZ());
+		closestPoint.m_floats[2] = (boxHalfExtent.m_floats[2]);
 		normal.setValue(btScalar(0.0f), btScalar(0.0f), btScalar(1.0f));
 	}
 
-	faceDist = boxHalfExtent.getZ() + sphereRelPos.getZ();
+	faceDist = boxHalfExtent.m_floats[2] + sphereRelPos.m_floats[2];
 	if (faceDist < minDist)
 	{
 		minDist = faceDist;
 		closestPoint = sphereRelPos;
-		closestPoint.setZ(-boxHalfExtent.getZ());
+		closestPoint.m_floats[2] = (-boxHalfExtent.m_floats[2]);
 		normal.setValue(btScalar(0.0f), btScalar(0.0f), btScalar(-1.0f));
 	}
 

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btBox2dShape.cpp

@@ -27,9 +27,9 @@ void btBox2dShape::calculateLocalInertia(btScalar mass, btVector3& inertia) cons
 	//btScalar margin = btScalar(0.);
 	btVector3 halfExtents = getHalfExtentsWithMargin();
 
-	btScalar lx = btScalar(2.) * (halfExtents.x());
-	btScalar ly = btScalar(2.) * (halfExtents.y());
-	btScalar lz = btScalar(2.) * (halfExtents.z());
+	btScalar lx = btScalar(2.) * (halfExtents.m_floats[0]);
+	btScalar ly = btScalar(2.) * (halfExtents.m_floats[1]);
+	btScalar lz = btScalar(2.) * (halfExtents.m_floats[2]);
 
 	inertia.setValue(mass / (btScalar(12.0)) * (ly * ly + lz * lz),
 					 mass / (btScalar(12.0)) * (lx * lx + lz * lz),

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btBox2dShape.h

@@ -54,18 +54,18 @@ public:
 		btVector3 margin(getMargin(), getMargin(), getMargin());
 		halfExtents += margin;
 
-		return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
-						 btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
-						 btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+		return btVector3(btFsels(vec.m_floats[0], halfExtents.m_floats[0], -halfExtents.m_floats[0]),
+						 btFsels(vec.m_floats[1], halfExtents.m_floats[1], -halfExtents.m_floats[1]),
+						 btFsels(vec.m_floats[2], halfExtents.m_floats[2], -halfExtents.m_floats[2]));
 	}
 
 	SIMD_FORCE_INLINE btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const
 	{
 		const btVector3& halfExtents = getHalfExtentsWithoutMargin();
 
-		return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
-						 btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
-						 btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+		return btVector3(btFsels(vec.m_floats[0], halfExtents.m_floats[0], -halfExtents.m_floats[0]),
+						 btFsels(vec.m_floats[1], halfExtents.m_floats[1], -halfExtents.m_floats[1]),
+						 btFsels(vec.m_floats[2], halfExtents.m_floats[2], -halfExtents.m_floats[2]));
 	}
 
 	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const
@@ -75,9 +75,9 @@ public:
 		for (int i = 0; i < numVectors; i++)
 		{
 			const btVector3& vec = vectors[i];
-			supportVerticesOut[i].setValue(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
-										   btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
-										   btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+			supportVerticesOut[i].setValue(btFsels(vec.m_floats[0], halfExtents.m_floats[0], -halfExtents.m_floats[0]),
+										   btFsels(vec.m_floats[1], halfExtents.m_floats[1], -halfExtents.m_floats[1]),
+										   btFsels(vec.m_floats[2], halfExtents.m_floats[2], -halfExtents.m_floats[2]));
 		}
 	}
 
@@ -86,19 +86,19 @@ public:
 		: btPolyhedralConvexShape(),
 		  m_centroid(0, 0, 0)
 	{
-		m_vertices[0].setValue(-boxHalfExtents.getX(), -boxHalfExtents.getY(), 0);
-		m_vertices[1].setValue(boxHalfExtents.getX(), -boxHalfExtents.getY(), 0);
-		m_vertices[2].setValue(boxHalfExtents.getX(), boxHalfExtents.getY(), 0);
-		m_vertices[3].setValue(-boxHalfExtents.getX(), boxHalfExtents.getY(), 0);
+		m_vertices[0].setValue(-boxHalfExtents.m_floats[0], -boxHalfExtents.m_floats[1], 0);
+		m_vertices[1].setValue(boxHalfExtents.m_floats[0], -boxHalfExtents.m_floats[1], 0);
+		m_vertices[2].setValue(boxHalfExtents.m_floats[0], boxHalfExtents.m_floats[1], 0);
+		m_vertices[3].setValue(-boxHalfExtents.m_floats[0], boxHalfExtents.m_floats[1], 0);
 
 		m_normals[0].setValue(0, -1, 0);
 		m_normals[1].setValue(1, 0, 0);
 		m_normals[2].setValue(0, 1, 0);
 		m_normals[3].setValue(-1, 0, 0);
 
-		btScalar minDimension = boxHalfExtents.getX();
-		if (minDimension > boxHalfExtents.getY())
-			minDimension = boxHalfExtents.getY();
+		btScalar minDimension = boxHalfExtents.m_floats[0];
+		if (minDimension > boxHalfExtents.m_floats[1])
+			minDimension = boxHalfExtents.m_floats[1];
 
 		m_shapeType = BOX_2D_SHAPE_PROXYTYPE;
 		btVector3 margin(getMargin(), getMargin(), getMargin());
@@ -157,7 +157,7 @@ public:
 		//this plane might not be aligned...
 		btVector4 plane;
 		getPlaneEquation(plane, i);
-		planeNormal = btVector3(plane.getX(), plane.getY(), plane.getZ());
+		planeNormal = btVector3(plane.m_floats[0], plane.m_floats[1], plane.m_floats[2]);
 		planeSupport = localGetSupportingVertex(-planeNormal);
 	}
 
@@ -181,9 +181,9 @@ public:
 		btVector3 halfExtents = getHalfExtentsWithoutMargin();
 
 		vtx = btVector3(
-			halfExtents.x() * (1 - (i & 1)) - halfExtents.x() * (i & 1),
-			halfExtents.y() * (1 - ((i & 2) >> 1)) - halfExtents.y() * ((i & 2) >> 1),
-			halfExtents.z() * (1 - ((i & 4) >> 2)) - halfExtents.z() * ((i & 4) >> 2));
+			halfExtents.m_floats[0] * (1 - (i & 1)) - halfExtents.m_floats[0] * (i & 1),
+			halfExtents.m_floats[1] * (1 - ((i & 2) >> 1)) - halfExtents.m_floats[1] * ((i & 2) >> 1),
+			halfExtents.m_floats[2] * (1 - ((i & 4) >> 2)) - halfExtents.m_floats[2] * ((i & 4) >> 2));
 	}
 
 	virtual void getPlaneEquation(btVector4 & plane, int i) const
@@ -193,22 +193,22 @@ public:
 		switch (i)
 		{
 			case 0:
-				plane.setValue(btScalar(1.), btScalar(0.), btScalar(0.), -halfExtents.x());
+				plane.setValue(btScalar(1.), btScalar(0.), btScalar(0.), -halfExtents.m_floats[0]);
 				break;
 			case 1:
-				plane.setValue(btScalar(-1.), btScalar(0.), btScalar(0.), -halfExtents.x());
+				plane.setValue(btScalar(-1.), btScalar(0.), btScalar(0.), -halfExtents.m_floats[0]);
 				break;
 			case 2:
-				plane.setValue(btScalar(0.), btScalar(1.), btScalar(0.), -halfExtents.y());
+				plane.setValue(btScalar(0.), btScalar(1.), btScalar(0.), -halfExtents.m_floats[1]);
 				break;
 			case 3:
-				plane.setValue(btScalar(0.), btScalar(-1.), btScalar(0.), -halfExtents.y());
+				plane.setValue(btScalar(0.), btScalar(-1.), btScalar(0.), -halfExtents.m_floats[1]);
 				break;
 			case 4:
-				plane.setValue(btScalar(0.), btScalar(0.), btScalar(1.), -halfExtents.z());
+				plane.setValue(btScalar(0.), btScalar(0.), btScalar(1.), -halfExtents.m_floats[2]);
 				break;
 			case 5:
-				plane.setValue(btScalar(0.), btScalar(0.), btScalar(-1.), -halfExtents.z());
+				plane.setValue(btScalar(0.), btScalar(0.), btScalar(-1.), -halfExtents.m_floats[2]);
 				break;
 			default:
 				btAssert(0);
@@ -287,12 +287,12 @@ public:
 
 		//btScalar minDist = 2*tolerance;
 
-		bool result = (pt.x() <= (halfExtents.x() + tolerance)) &&
-					  (pt.x() >= (-halfExtents.x() - tolerance)) &&
-					  (pt.y() <= (halfExtents.y() + tolerance)) &&
-					  (pt.y() >= (-halfExtents.y() - tolerance)) &&
-					  (pt.z() <= (halfExtents.z() + tolerance)) &&
-					  (pt.z() >= (-halfExtents.z() - tolerance));
+		bool result = (pt.m_floats[0] <= (halfExtents.m_floats[0] + tolerance)) &&
+					  (pt.m_floats[0] >= (-halfExtents.m_floats[0] - tolerance)) &&
+					  (pt.m_floats[1] <= (halfExtents.m_floats[1] + tolerance)) &&
+					  (pt.m_floats[1] >= (-halfExtents.m_floats[1] - tolerance)) &&
+					  (pt.m_floats[2] <= (halfExtents.m_floats[2] + tolerance)) &&
+					  (pt.m_floats[2] >= (-halfExtents.m_floats[2] - tolerance));
 
 		return result;
 	}

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btBoxShape.cpp

@@ -35,9 +35,9 @@ void btBoxShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const
 	//btScalar margin = btScalar(0.);
 	btVector3 halfExtents = getHalfExtentsWithMargin();
 
-	btScalar lx = btScalar(2.) * (halfExtents.x());
-	btScalar ly = btScalar(2.) * (halfExtents.y());
-	btScalar lz = btScalar(2.) * (halfExtents.z());
+	btScalar lx = btScalar(2.) * (halfExtents.m_floats[0]);
+	btScalar ly = btScalar(2.) * (halfExtents.m_floats[1]);
+	btScalar lz = btScalar(2.) * (halfExtents.m_floats[2]);
 
 	inertia.setValue(mass / (btScalar(12.0)) * (ly * ly + lz * lz),
 					 mass / (btScalar(12.0)) * (lx * lx + lz * lz),

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btBoxShape.h

@@ -50,18 +50,18 @@ public:
 		btVector3 margin(getMargin(), getMargin(), getMargin());
 		halfExtents += margin;
 
-		return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
-						 btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
-						 btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+		return btVector3(btFsels(vec.m_floats[0], halfExtents.m_floats[0], -halfExtents.m_floats[0]),
+						 btFsels(vec.m_floats[1], halfExtents.m_floats[1], -halfExtents.m_floats[1]),
+						 btFsels(vec.m_floats[2], halfExtents.m_floats[2], -halfExtents.m_floats[2]));
 	}
 
 	SIMD_FORCE_INLINE btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec) const
 	{
 		const btVector3& halfExtents = getHalfExtentsWithoutMargin();
 
-		return btVector3(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
-						 btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
-						 btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+		return btVector3(btFsels(vec.m_floats[0], halfExtents.m_floats[0], -halfExtents.m_floats[0]),
+						 btFsels(vec.m_floats[1], halfExtents.m_floats[1], -halfExtents.m_floats[1]),
+						 btFsels(vec.m_floats[2], halfExtents.m_floats[2], -halfExtents.m_floats[2]));
 	}
 
 	virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors, btVector3* supportVerticesOut, int numVectors) const
@@ -71,9 +71,9 @@ public:
 		for (int i = 0; i < numVectors; i++)
 		{
 			const btVector3& vec = vectors[i];
-			supportVerticesOut[i].setValue(btFsels(vec.x(), halfExtents.x(), -halfExtents.x()),
-										   btFsels(vec.y(), halfExtents.y(), -halfExtents.y()),
-										   btFsels(vec.z(), halfExtents.z(), -halfExtents.z()));
+			supportVerticesOut[i].setValue(btFsels(vec.m_floats[0], halfExtents.m_floats[0], -halfExtents.m_floats[0]),
+										   btFsels(vec.m_floats[1], halfExtents.m_floats[1], -halfExtents.m_floats[1]),
+										   btFsels(vec.m_floats[2], halfExtents.m_floats[2], -halfExtents.m_floats[2]));
 		}
 	}
 
@@ -109,7 +109,7 @@ public:
 		//this plane might not be aligned...
 		btVector4 plane;
 		getPlaneEquation(plane, i);
-		planeNormal = btVector3(plane.getX(), plane.getY(), plane.getZ());
+		planeNormal = btVector3(plane.m_floats[0], plane.m_floats[1], plane.m_floats[2]);
 		planeSupport = localGetSupportingVertex(-planeNormal);
 	}
 
@@ -133,9 +133,9 @@ public:
 		btVector3 halfExtents = getHalfExtentsWithMargin();
 
 		vtx = btVector3(
-			halfExtents.x() * (1 - (i & 1)) - halfExtents.x() * (i & 1),
-			halfExtents.y() * (1 - ((i & 2) >> 1)) - halfExtents.y() * ((i & 2) >> 1),
-			halfExtents.z() * (1 - ((i & 4) >> 2)) - halfExtents.z() * ((i & 4) >> 2));
+			halfExtents.m_floats[0] * (1 - (i & 1)) - halfExtents.m_floats[0] * (i & 1),
+			halfExtents.m_floats[1] * (1 - ((i & 2) >> 1)) - halfExtents.m_floats[1] * ((i & 2) >> 1),
+			halfExtents.m_floats[2] * (1 - ((i & 4) >> 2)) - halfExtents.m_floats[2] * ((i & 4) >> 2));
 	}
 
 	virtual void getPlaneEquation(btVector4 & plane, int i) const
@@ -145,22 +145,22 @@ public:
 		switch (i)
 		{
 			case 0:
-				plane.setValue(btScalar(1.), btScalar(0.), btScalar(0.), -halfExtents.x());
+				plane.setValue(btScalar(1.), btScalar(0.), btScalar(0.), -halfExtents.m_floats[0]);
 				break;
 			case 1:
-				plane.setValue(btScalar(-1.), btScalar(0.), btScalar(0.), -halfExtents.x());
+				plane.setValue(btScalar(-1.), btScalar(0.), btScalar(0.), -halfExtents.m_floats[0]);
 				break;
 			case 2:
-				plane.setValue(btScalar(0.), btScalar(1.), btScalar(0.), -halfExtents.y());
+				plane.setValue(btScalar(0.), btScalar(1.), btScalar(0.), -halfExtents.m_floats[1]);
 				break;
 			case 3:
-				plane.setValue(btScalar(0.), btScalar(-1.), btScalar(0.), -halfExtents.y());
+				plane.setValue(btScalar(0.), btScalar(-1.), btScalar(0.), -halfExtents.m_floats[1]);
 				break;
 			case 4:
-				plane.setValue(btScalar(0.), btScalar(0.), btScalar(1.), -halfExtents.z());
+				plane.setValue(btScalar(0.), btScalar(0.), btScalar(1.), -halfExtents.m_floats[2]);
 				break;
 			case 5:
-				plane.setValue(btScalar(0.), btScalar(0.), btScalar(-1.), -halfExtents.z());
+				plane.setValue(btScalar(0.), btScalar(0.), btScalar(-1.), -halfExtents.m_floats[2]);
 				break;
 			default:
 				btAssert(0);
@@ -239,12 +239,12 @@ public:
 
 		//btScalar minDist = 2*tolerance;
 
-		bool result = (pt.x() <= (halfExtents.x() + tolerance)) &&
-					  (pt.x() >= (-halfExtents.x() - tolerance)) &&
-					  (pt.y() <= (halfExtents.y() + tolerance)) &&
-					  (pt.y() >= (-halfExtents.y() - tolerance)) &&
-					  (pt.z() <= (halfExtents.z() + tolerance)) &&
-					  (pt.z() >= (-halfExtents.z() - tolerance));
+		bool result = (pt.m_floats[0] <= (halfExtents.m_floats[0] + tolerance)) &&
+					  (pt.m_floats[0] >= (-halfExtents.m_floats[0] - tolerance)) &&
+					  (pt.m_floats[1] <= (halfExtents.m_floats[1] + tolerance)) &&
+					  (pt.m_floats[1] >= (-halfExtents.m_floats[1] - tolerance)) &&
+					  (pt.m_floats[2] <= (halfExtents.m_floats[2] + tolerance)) &&
+					  (pt.m_floats[2] >= (-halfExtents.m_floats[2] - tolerance));
 
 		return result;
 	}

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp

@@ -140,13 +140,13 @@ void btBvhTriangleMeshShape::performRaycast(btTriangleCallback* callback, const
 				{
 					float* graphicsbase = (float*)(vertexbase + graphicsindex * stride);
 
-					m_triangle[j] = btVector3(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+					m_triangle[j] = btVector3(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 				}
 				else
 				{
 					double* graphicsbase = (double*)(vertexbase + graphicsindex * stride);
 
-					m_triangle[j] = btVector3(btScalar(graphicsbase[0]) * meshScaling.getX(), btScalar(graphicsbase[1]) * meshScaling.getY(), btScalar(graphicsbase[2]) * meshScaling.getZ());
+					m_triangle[j] = btVector3(btScalar(graphicsbase[0]) * meshScaling.m_floats[0], btScalar(graphicsbase[1]) * meshScaling.m_floats[1], btScalar(graphicsbase[2]) * meshScaling.m_floats[2]);
 				}
 			}
 
@@ -214,13 +214,13 @@ void btBvhTriangleMeshShape::performConvexcast(btTriangleCallback* callback, con
 				{
 					float* graphicsbase = (float*)(vertexbase + graphicsindex * stride);
 
-					m_triangle[j] = btVector3(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+					m_triangle[j] = btVector3(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 				}
 				else
 				{
 					double* graphicsbase = (double*)(vertexbase + graphicsindex * stride);
 
-					m_triangle[j] = btVector3(btScalar(graphicsbase[0]) * meshScaling.getX(), btScalar(graphicsbase[1]) * meshScaling.getY(), btScalar(graphicsbase[2]) * meshScaling.getZ());
+					m_triangle[j] = btVector3(btScalar(graphicsbase[0]) * meshScaling.m_floats[0], btScalar(graphicsbase[1]) * meshScaling.m_floats[1], btScalar(graphicsbase[2]) * meshScaling.m_floats[2]);
 				}
 			}
 
@@ -298,21 +298,21 @@ void btBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callback, c
 					float* graphicsbase = (float*)(vertexbase + graphicsindex * stride);
 
 					m_triangle[j] = btVector3(
-						graphicsbase[0] * meshScaling.getX(),
-						graphicsbase[1] * meshScaling.getY(),
-						graphicsbase[2] * meshScaling.getZ());
+						graphicsbase[0] * meshScaling.m_floats[0],
+						graphicsbase[1] * meshScaling.m_floats[1],
+						graphicsbase[2] * meshScaling.m_floats[2]);
 				}
 				else
 				{
 					double* graphicsbase = (double*)(vertexbase + graphicsindex * stride);
 
 					m_triangle[j] = btVector3(
-						btScalar(graphicsbase[0]) * meshScaling.getX(),
-						btScalar(graphicsbase[1]) * meshScaling.getY(),
-						btScalar(graphicsbase[2]) * meshScaling.getZ());
+						btScalar(graphicsbase[0]) * meshScaling.m_floats[0],
+						btScalar(graphicsbase[1]) * meshScaling.m_floats[1],
+						btScalar(graphicsbase[2]) * meshScaling.m_floats[2]);
 				}
 #ifdef DEBUG_TRIANGLE_MESH
-				printf("triangle vertices:%f,%f,%f\n", triangle[j].x(), triangle[j].y(), triangle[j].z());
+				printf("triangle vertices:%f,%f,%f\n", triangle[j].m_floats[0], triangle[j].m_floats[1], triangle[j].m_floats[2]);
 #endif  //DEBUG_TRIANGLE_MESH
 			}
 

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btCollisionShape.cpp

@@ -59,28 +59,28 @@ void btCollisionShape::calculateTemporalAabb(const btTransform& curTrans, const
 	//start with static aabb
 	getAabb(curTrans, temporalAabbMin, temporalAabbMax);
 
-	btScalar temporalAabbMaxx = temporalAabbMax.getX();
-	btScalar temporalAabbMaxy = temporalAabbMax.getY();
-	btScalar temporalAabbMaxz = temporalAabbMax.getZ();
-	btScalar temporalAabbMinx = temporalAabbMin.getX();
-	btScalar temporalAabbMiny = temporalAabbMin.getY();
-	btScalar temporalAabbMinz = temporalAabbMin.getZ();
+	btScalar temporalAabbMaxx = temporalAabbMax.m_floats[0];
+	btScalar temporalAabbMaxy = temporalAabbMax.m_floats[1];
+	btScalar temporalAabbMaxz = temporalAabbMax.m_floats[2];
+	btScalar temporalAabbMinx = temporalAabbMin.m_floats[0];
+	btScalar temporalAabbMiny = temporalAabbMin.m_floats[1];
+	btScalar temporalAabbMinz = temporalAabbMin.m_floats[2];
 
 	// add linear motion
 	btVector3 linMotion = linvel * timeStep;
 	///@todo: simd would have a vector max/min operation, instead of per-element access
-	if (linMotion.x() > btScalar(0.))
-		temporalAabbMaxx += linMotion.x();
+	if (linMotion.m_floats[0] > btScalar(0.))
+		temporalAabbMaxx += linMotion.m_floats[0];
 	else
-		temporalAabbMinx += linMotion.x();
-	if (linMotion.y() > btScalar(0.))
-		temporalAabbMaxy += linMotion.y();
+		temporalAabbMinx += linMotion.m_floats[0];
+	if (linMotion.m_floats[1] > btScalar(0.))
+		temporalAabbMaxy += linMotion.m_floats[1];
 	else
-		temporalAabbMiny += linMotion.y();
-	if (linMotion.z() > btScalar(0.))
-		temporalAabbMaxz += linMotion.z();
+		temporalAabbMiny += linMotion.m_floats[1];
+	if (linMotion.m_floats[2] > btScalar(0.))
+		temporalAabbMaxz += linMotion.m_floats[2];
 	else
-		temporalAabbMinz += linMotion.z();
+		temporalAabbMinz += linMotion.m_floats[2];
 
 	//add conservative angular motion
 	btScalar angularMotion = angvel.length() * getAngularMotionDisc() * timeStep;
@@ -116,4 +116,4 @@ void btCollisionShape::serializeSingleShape(btSerializer* serializer) const
 	btChunk* chunk = serializer->allocate(len, 1);
 	const char* structType = serialize(chunk->m_oldPtr, serializer);
 	serializer->finalizeChunk(chunk, structType, BT_SHAPE_CODE, (void*)this);
-}
+}

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btCompoundShape.cpp

@@ -190,9 +190,9 @@ void btCompoundShape::calculateLocalInertia(btScalar mass, btVector3& inertia) c
 
 	btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5);
 
-	btScalar lx = btScalar(2.) * (halfExtents.x());
-	btScalar ly = btScalar(2.) * (halfExtents.y());
-	btScalar lz = btScalar(2.) * (halfExtents.z());
+	btScalar lx = btScalar(2.) * (halfExtents.m_floats[0]);
+	btScalar ly = btScalar(2.) * (halfExtents.m_floats[1]);
+	btScalar lz = btScalar(2.) * (halfExtents.m_floats[2]);
 
 	inertia[0] = mass / (btScalar(12.0)) * (ly * ly + lz * lz);
 	inertia[1] = mass / (btScalar(12.0)) * (lx * lx + lz * lz);
@@ -245,9 +245,9 @@ void btCompoundShape::calculatePrincipalAxisTransform(const btScalar* masses, bt
 		j[0].setValue(o2, 0, 0);
 		j[1].setValue(0, o2, 0);
 		j[2].setValue(0, 0, o2);
-		j[0] += o * -o.x();
-		j[1] += o * -o.y();
-		j[2] += o * -o.z();
+		j[0] += o * -o.m_floats[0];
+		j[1] += o * -o.m_floats[1];
+		j[2] += o * -o.m_floats[2];
 
 		//add inertia tensor of pointmass
 		tensor[0] += masses[k] * j[0];

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btConeShape.h

@@ -62,9 +62,9 @@ public:
 
 		btScalar margin = getMargin();
 
-		btScalar lx = btScalar(2.) * (halfExtents.x() + margin);
-		btScalar ly = btScalar(2.) * (halfExtents.y() + margin);
-		btScalar lz = btScalar(2.) * (halfExtents.z() + margin);
+		btScalar lx = btScalar(2.) * (halfExtents.m_floats[0] + margin);
+		btScalar ly = btScalar(2.) * (halfExtents.m_floats[1] + margin);
+		btScalar lz = btScalar(2.) * (halfExtents.m_floats[2] + margin);
 		const btScalar x2 = lx * lx;
 		const btScalar y2 = ly * ly;
 		const btScalar z2 = lz * lz;
@@ -72,9 +72,9 @@ public:
 
 		inertia = scaledmass * (btVector3(y2 + z2, x2 + z2, x2 + y2));
 
-		//		inertia.x() = scaledmass * (y2+z2);
-		//		inertia.y() = scaledmass * (x2+z2);
-		//		inertia.z() = scaledmass * (x2+y2);
+		//		inertia.m_floats[0] = scaledmass * (y2+z2);
+		//		inertia.m_floats[1] = scaledmass * (x2+z2);
+		//		inertia.m_floats[2] = scaledmass * (x2+y2);
 	}
 
 	virtual const char* getName() const

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp

@@ -116,7 +116,7 @@ btVector3 btConvexHullShape::localGetSupportingVertex(const btVector3& vec) cons
 void btConvexHullShape::optimizeConvexHull()
 {
 	btConvexHullComputer conv;
-	conv.compute(&m_unscaledPoints[0].getX(), sizeof(btVector3), m_unscaledPoints.size(), 0.f, 0.f);
+	conv.compute(&m_unscaledPoints[0].m_floats[0], sizeof(btVector3), m_unscaledPoints.size(), 0.f, 0.f);
 	int numVerts = conv.vertices.size();
 	m_unscaledPoints.resize(0);
 	for (int i = 0; i < numVerts; i++)

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btConvexPolyhedron.cpp

@@ -29,7 +29,7 @@ btConvexPolyhedron::~btConvexPolyhedron()
 
 inline bool IsAlmostZero1(const btVector3& v)
 {
-	if (btFabs(v.x()) > 1e-6 || btFabs(v.y()) > 1e-6 || btFabs(v.z()) > 1e-6) return false;
+	if (btFabs(v.m_floats[0]) > 1e-6 || btFabs(v.m_floats[1]) > 1e-6 || btFabs(v.m_floats[2]) > 1e-6) return false;
 	return true;
 }
 
@@ -218,12 +218,12 @@ void btConvexPolyhedron::initialize2()
 		for (int i = 0; i < m_vertices.size(); i++)
 		{
 			const btVector3& pt = m_vertices[i];
-			if (pt.x() < MinX) MinX = pt.x();
-			if (pt.x() > MaxX) MaxX = pt.x();
-			if (pt.y() < MinY) MinY = pt.y();
-			if (pt.y() > MaxY) MaxY = pt.y();
-			if (pt.z() < MinZ) MinZ = pt.z();
-			if (pt.z() > MaxZ) MaxZ = pt.z();
+			if (pt.m_floats[0] < MinX) MinX = pt.m_floats[0];
+			if (pt.m_floats[0] > MaxX) MaxX = pt.m_floats[0];
+			if (pt.m_floats[1] < MinY) MinY = pt.m_floats[1];
+			if (pt.m_floats[1] > MaxY) MaxY = pt.m_floats[1];
+			if (pt.m_floats[2] < MinZ) MinZ = pt.m_floats[2];
+			if (pt.m_floats[2] > MaxZ) MaxZ = pt.m_floats[2];
 		}
 		mC.setValue(MaxX + MinX, MaxY + MinY, MaxZ + MinZ);
 		mE.setValue(MaxX - MinX, MaxY - MinY, MaxZ - MinZ);

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btConvexShape.cpp

@@ -150,19 +150,19 @@ btVector3 btConvexShape::localGetSupportVertexWithoutMarginNonVirtual(const btVe
 #error unknown vector arch
 #endif
 #else
-			return btVector3(btFsels(localDir.x(), halfExtents.x(), -halfExtents.x()),
-							 btFsels(localDir.y(), halfExtents.y(), -halfExtents.y()),
-							 btFsels(localDir.z(), halfExtents.z(), -halfExtents.z()));
+			return btVector3(btFsels(localDir.m_floats[0], halfExtents.m_floats[0], -halfExtents.m_floats[0]),
+							 btFsels(localDir.m_floats[1], halfExtents.m_floats[1], -halfExtents.m_floats[1]),
+							 btFsels(localDir.m_floats[2], halfExtents.m_floats[2], -halfExtents.m_floats[2]));
 #endif
 		}
 		case TRIANGLE_SHAPE_PROXYTYPE:
 		{
 			btTriangleShape* triangleShape = (btTriangleShape*)this;
-			btVector3 dir(localDir.getX(), localDir.getY(), localDir.getZ());
+			btVector3 dir(localDir.m_floats[0], localDir.m_floats[1], localDir.m_floats[2]);
 			btVector3* vertices = &triangleShape->m_vertices1[0];
 			btVector3 dots = dir.dot3(vertices[0], vertices[1], vertices[2]);
 			btVector3 sup = vertices[dots.maxAxis()];
-			return btVector3(sup.getX(), sup.getY(), sup.getZ());
+			return btVector3(sup.m_floats[0], sup.m_floats[1], sup.m_floats[2]);
 		}
 		case CYLINDER_SHAPE_PROXYTYPE:
 		{
@@ -170,7 +170,7 @@ btVector3 btConvexShape::localGetSupportVertexWithoutMarginNonVirtual(const btVe
 			//mapping of halfextents/dimension onto radius/height depends on how cylinder local orientation is (upAxis)
 
 			btVector3 halfExtents = cylShape->getImplicitShapeDimensions();
-			btVector3 v(localDir.getX(), localDir.getY(), localDir.getZ());
+			btVector3 v(localDir.m_floats[0], localDir.m_floats[1], localDir.m_floats[2]);
 			int cylinderUpAxis = cylShape->getUpAxis();
 			int XX(1), YY(0), ZZ(2);
 
@@ -215,19 +215,19 @@ btVector3 btConvexShape::localGetSupportVertexWithoutMarginNonVirtual(const btVe
 				tmp[XX] = v[XX] * d;
 				tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight;
 				tmp[ZZ] = v[ZZ] * d;
-				return btVector3(tmp.getX(), tmp.getY(), tmp.getZ());
+				return btVector3(tmp.m_floats[0], tmp.m_floats[1], tmp.m_floats[2]);
 			}
 			else
 			{
 				tmp[XX] = radius;
 				tmp[YY] = v[YY] < 0.0 ? -halfHeight : halfHeight;
 				tmp[ZZ] = btScalar(0.0);
-				return btVector3(tmp.getX(), tmp.getY(), tmp.getZ());
+				return btVector3(tmp.m_floats[0], tmp.m_floats[1], tmp.m_floats[2]);
 			}
 		}
 		case CAPSULE_SHAPE_PROXYTYPE:
 		{
-			btVector3 vec0(localDir.getX(), localDir.getY(), localDir.getZ());
+			btVector3 vec0(localDir.m_floats[0], localDir.m_floats[1], localDir.m_floats[2]);
 
 			btCapsuleShape* capsuleShape = (btCapsuleShape*)this;
 			btScalar halfHeight = capsuleShape->getHalfHeight();
@@ -275,7 +275,7 @@ btVector3 btConvexShape::localGetSupportVertexWithoutMarginNonVirtual(const btVe
 					supVec = vtx;
 				}
 			}
-			return btVector3(supVec.getX(), supVec.getY(), supVec.getZ());
+			return btVector3(supVec.m_floats[0], supVec.m_floats[1], supVec.m_floats[2]);
 		}
 		case CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE:
 		{
@@ -378,7 +378,7 @@ void btConvexShape::getAabbNonVirtual(const btTransform& t, btVector3& aabbMin,
 		case SPHERE_SHAPE_PROXYTYPE:
 		{
 			btSphereShape* sphereShape = (btSphereShape*)this;
-			btScalar radius = sphereShape->getImplicitShapeDimensions().getX();  // * convexShape->getLocalScaling().getX();
+			btScalar radius = sphereShape->getImplicitShapeDimensions().m_floats[0];  // * convexShape->getLocalScaling().m_floats[0];
 			btScalar margin = radius + sphereShape->getMarginNonVirtual();
 			const btVector3& center = t.m_origin;
 			btVector3 extent(margin, margin, margin);

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btCylinderShape.cpp

@@ -105,9 +105,9 @@ void btCylinderShape::calculateLocalInertia(btScalar mass, btVector3& inertia) c
 	//approximation of box shape
 	btVector3 halfExtents = getHalfExtentsWithMargin();
 
-	btScalar lx = btScalar(2.) * (halfExtents.x());
-	btScalar ly = btScalar(2.) * (halfExtents.y());
-	btScalar lz = btScalar(2.) * (halfExtents.z());
+	btScalar lx = btScalar(2.) * (halfExtents.m_floats[0]);
+	btScalar ly = btScalar(2.) * (halfExtents.m_floats[1]);
+	btScalar lz = btScalar(2.) * (halfExtents.m_floats[2]);
 
 	inertia.setValue(mass / (btScalar(12.0)) * (ly * ly + lz * lz),
 					 mass / (btScalar(12.0)) * (lx * lx + lz * lz),

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btCylinderShape.h

@@ -100,7 +100,7 @@ public:
 
 	virtual btScalar getRadius() const
 	{
-		return getHalfExtentsWithMargin().getX();
+		return getHalfExtentsWithMargin().m_floats[0];
 	}
 
 	virtual void setLocalScaling(const btVector3& scaling)
@@ -144,7 +144,7 @@ public:
 
 	virtual btScalar getRadius() const
 	{
-		return getHalfExtentsWithMargin().getY();
+		return getHalfExtentsWithMargin().m_floats[1];
 	}
 };
 
@@ -166,7 +166,7 @@ public:
 
 	virtual btScalar getRadius() const
 	{
-		return getHalfExtentsWithMargin().getX();
+		return getHalfExtentsWithMargin().m_floats[0];
 	}
 };
 

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp

@@ -244,7 +244,7 @@ void btHeightfieldTerrainShape::getVertex(int x, int y, btVector3& vertex) const
 		case 0:
 		{
 			vertex.setValue(
-				height - m_localOrigin.getX(),
+				height - m_localOrigin.m_floats[0],
 				(-m_width / btScalar(2.0)) + x,
 				(-m_length / btScalar(2.0)) + y);
 			break;
@@ -253,7 +253,7 @@ void btHeightfieldTerrainShape::getVertex(int x, int y, btVector3& vertex) const
 		{
 			vertex.setValue(
 				(-m_width / btScalar(2.0)) + x,
-				height - m_localOrigin.getY(),
+				height - m_localOrigin.m_floats[1],
 				(-m_length / btScalar(2.0)) + y);
 			break;
 		};
@@ -262,7 +262,7 @@ void btHeightfieldTerrainShape::getVertex(int x, int y, btVector3& vertex) const
 			vertex.setValue(
 				(-m_width / btScalar(2.0)) + x,
 				(-m_length / btScalar(2.0)) + y,
-				height - m_localOrigin.getZ());
+				height - m_localOrigin.m_floats[2]);
 			break;
 		}
 		default:
@@ -325,9 +325,9 @@ void btHeightfieldTerrainShape::quantizeWithClamp(int* out, const btVector3& poi
 	clampedPoint.setMax(m_localAabbMin);
 	clampedPoint.setMin(m_localAabbMax);
 
-	out[0] = getQuantized(clampedPoint.getX());
-	out[1] = getQuantized(clampedPoint.getY());
-	out[2] = getQuantized(clampedPoint.getZ());
+	out[0] = getQuantized(clampedPoint.m_floats[0]);
+	out[1] = getQuantized(clampedPoint.m_floats[1]);
+	out[2] = getQuantized(clampedPoint.m_floats[2]);
 }
 
 /// process all triangles within the provided axis-aligned bounding box

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp

@@ -59,9 +59,9 @@ void btMinkowskiSumShape::calculateLocalInertia(btScalar mass, btVector3& inerti
 
 	btScalar margin = getMargin();
 
-	btScalar lx = btScalar(2.) * (halfExtents.x() + margin);
-	btScalar ly = btScalar(2.) * (halfExtents.y() + margin);
-	btScalar lz = btScalar(2.) * (halfExtents.z() + margin);
+	btScalar lx = btScalar(2.) * (halfExtents.m_floats[0] + margin);
+	btScalar ly = btScalar(2.) * (halfExtents.m_floats[1] + margin);
+	btScalar lz = btScalar(2.) * (halfExtents.m_floats[2] + margin);
 	const btScalar x2 = lx * lx;
 	const btScalar y2 = ly * ly;
 	const btScalar z2 = lz * lz;

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp

@@ -131,9 +131,9 @@ void btMultiSphereShape::calculateLocalInertia(btScalar mass, btVector3& inertia
 	getCachedLocalAabb(localAabbMin, localAabbMax);
 	btVector3 halfExtents = (localAabbMax - localAabbMin) * btScalar(0.5);
 
-	btScalar lx = btScalar(2.) * (halfExtents.x());
-	btScalar ly = btScalar(2.) * (halfExtents.y());
-	btScalar lz = btScalar(2.) * (halfExtents.z());
+	btScalar lx = btScalar(2.) * (halfExtents.m_floats[0]);
+	btScalar ly = btScalar(2.) * (halfExtents.m_floats[1]);
+	btScalar lz = btScalar(2.) * (halfExtents.m_floats[2]);
 
 	inertia.setValue(mass / (btScalar(12.0)) * (ly * ly + lz * lz),
 					 mass / (btScalar(12.0)) * (lx * lx + lz * lz),

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp

@@ -111,20 +111,20 @@ void btOptimizedBvh::build(btStridingMeshInterface* triangles, bool useQuantized
 			//PCK: add these checks for zero dimensions of aabb
 			const btScalar MIN_AABB_DIMENSION = btScalar(0.002);
 			const btScalar MIN_AABB_HALF_DIMENSION = btScalar(0.001);
-			if (aabbMax.x() - aabbMin.x() < MIN_AABB_DIMENSION)
+			if (aabbMax.m_floats[0] - aabbMin.m_floats[0] < MIN_AABB_DIMENSION)
 			{
-				aabbMax.setX(aabbMax.x() + MIN_AABB_HALF_DIMENSION);
-				aabbMin.setX(aabbMin.x() - MIN_AABB_HALF_DIMENSION);
+				aabbMax.m_floats[0] = (aabbMax.m_floats[0] + MIN_AABB_HALF_DIMENSION);
+				aabbMin.m_floats[0] = (aabbMin.m_floats[0] - MIN_AABB_HALF_DIMENSION);
 			}
-			if (aabbMax.y() - aabbMin.y() < MIN_AABB_DIMENSION)
+			if (aabbMax.m_floats[1] - aabbMin.m_floats[1] < MIN_AABB_DIMENSION)
 			{
-				aabbMax.setY(aabbMax.y() + MIN_AABB_HALF_DIMENSION);
-				aabbMin.setY(aabbMin.y() - MIN_AABB_HALF_DIMENSION);
+				aabbMax.m_floats[1] = (aabbMax.m_floats[1] + MIN_AABB_HALF_DIMENSION);
+				aabbMin.m_floats[1] = (aabbMin.m_floats[1] - MIN_AABB_HALF_DIMENSION);
 			}
-			if (aabbMax.z() - aabbMin.z() < MIN_AABB_DIMENSION)
+			if (aabbMax.m_floats[2] - aabbMin.m_floats[2] < MIN_AABB_DIMENSION)
 			{
-				aabbMax.setZ(aabbMax.z() + MIN_AABB_HALF_DIMENSION);
-				aabbMin.setZ(aabbMin.z() - MIN_AABB_HALF_DIMENSION);
+				aabbMax.m_floats[2] = (aabbMax.m_floats[2] + MIN_AABB_HALF_DIMENSION);
+				aabbMin.m_floats[2] = (aabbMin.m_floats[2] - MIN_AABB_HALF_DIMENSION);
 			}
 
 			m_optimizedTree->quantize(&node.m_quantizedAabbMin[0], aabbMin, 0);
@@ -215,13 +215,13 @@ void btOptimizedBvh::refitPartial(btStridingMeshInterface* meshInterface, const
 	//incrementally initialize quantization values
 	btAssert(m_useQuantization);
 
-	btAssert(aabbMin.getX() > m_bvhAabbMin.getX());
-	btAssert(aabbMin.getY() > m_bvhAabbMin.getY());
-	btAssert(aabbMin.getZ() > m_bvhAabbMin.getZ());
+	btAssert(aabbMin.m_floats[0] > m_bvhAabbMin.m_floats[0]);
+	btAssert(aabbMin.m_floats[1] > m_bvhAabbMin.m_floats[1]);
+	btAssert(aabbMin.m_floats[2] > m_bvhAabbMin.m_floats[2]);
 
-	btAssert(aabbMax.getX() < m_bvhAabbMax.getX());
-	btAssert(aabbMax.getY() < m_bvhAabbMax.getY());
-	btAssert(aabbMax.getZ() < m_bvhAabbMax.getZ());
+	btAssert(aabbMax.m_floats[0] < m_bvhAabbMax.m_floats[0]);
+	btAssert(aabbMax.m_floats[1] < m_bvhAabbMax.m_floats[1]);
+	btAssert(aabbMax.m_floats[2] < m_bvhAabbMax.m_floats[2]);
 
 	///we should update all quantization values, using updateBvhNodes(meshInterface);
 	///but we only update chunks that overlap the given aabb
@@ -304,14 +304,14 @@ void btOptimizedBvh::updateBvhNodes(btStridingMeshInterface* meshInterface, int
 				{
 					float* graphicsbase = (float*)(vertexbase + graphicsindex * stride);
 					triangleVerts[j] = btVector3(
-						graphicsbase[0] * meshScaling.getX(),
-						graphicsbase[1] * meshScaling.getY(),
-						graphicsbase[2] * meshScaling.getZ());
+						graphicsbase[0] * meshScaling.m_floats[0],
+						graphicsbase[1] * meshScaling.m_floats[1],
+						graphicsbase[2] * meshScaling.m_floats[2]);
 				}
 				else
 				{
 					double* graphicsbase = (double*)(vertexbase + graphicsindex * stride);
-					triangleVerts[j] = btVector3(btScalar(graphicsbase[0] * meshScaling.getX()), btScalar(graphicsbase[1] * meshScaling.getY()), btScalar(graphicsbase[2] * meshScaling.getZ()));
+					triangleVerts[j] = btVector3(btScalar(graphicsbase[0] * meshScaling.m_floats[0]), btScalar(graphicsbase[1] * meshScaling.m_floats[1]), btScalar(graphicsbase[2] * meshScaling.m_floats[2]));
 				}
 			}
 

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp

@@ -89,11 +89,11 @@ bool btPolyhedralConvexShape::initializePolyhedralFeatures(int shiftVerticesByMa
 
 		btGeometryUtil::getVerticesFromPlaneEquations(shiftedPlaneEquations, tmpVertices);
 
-		conv.compute(&tmpVertices[0].getX(), sizeof(btVector3), tmpVertices.size(), 0.f, 0.f);
+		conv.compute(&tmpVertices[0].m_floats[0], sizeof(btVector3), tmpVertices.size(), 0.f, 0.f);
 	}
 	else
 	{
-		conv.compute(&orgVertices[0].getX(), sizeof(btVector3), orgVertices.size(), 0.f, 0.f);
+		conv.compute(&orgVertices[0].m_floats[0], sizeof(btVector3), orgVertices.size(), 0.f, 0.f);
 	}
 
 #ifndef BT_RECONSTRUCT_FACES
@@ -148,9 +148,9 @@ bool btPolyhedralConvexShape::initializePolyhedralFeatures(int shiftVerticesByMa
 				planeEq = eq;
 			}
 		}
-		combinedFace.m_plane[0] = faceNormal.getX();
-		combinedFace.m_plane[1] = faceNormal.getY();
-		combinedFace.m_plane[2] = faceNormal.getZ();
+		combinedFace.m_plane[0] = faceNormal.m_floats[0];
+		combinedFace.m_plane[1] = faceNormal.m_floats[1];
+		combinedFace.m_plane[2] = faceNormal.m_floats[2];
 		combinedFace.m_plane[3] = -planeEq;
 
 		m_polyhedron->m_faces.push_back(combinedFace);
@@ -206,9 +206,9 @@ bool btPolyhedralConvexShape::initializePolyhedralFeatures(int shiftVerticesByMa
 		{
 			faceNormals[i] = edges[0].cross(edges[1]);
 			faceNormals[i].normalize();
-			tmpFaces[i].m_plane[0] = faceNormals[i].getX();
-			tmpFaces[i].m_plane[1] = faceNormals[i].getY();
-			tmpFaces[i].m_plane[2] = faceNormals[i].getZ();
+			tmpFaces[i].m_plane[0] = faceNormals[i].m_floats[0];
+			tmpFaces[i].m_plane[1] = faceNormals[i].m_floats[1];
+			tmpFaces[i].m_plane[2] = faceNormals[i].m_floats[2];
 			tmpFaces[i].m_plane[3] = planeEq;
 		}
 		else
@@ -471,9 +471,9 @@ void btPolyhedralConvexShape::calculateLocalInertia(btScalar mass, btVector3& in
 	getAabb(ident, aabbMin, aabbMax);
 	btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5);
 
-	btScalar lx = btScalar(2.) * (halfExtents.x() + margin);
-	btScalar ly = btScalar(2.) * (halfExtents.y() + margin);
-	btScalar lz = btScalar(2.) * (halfExtents.z() + margin);
+	btScalar lx = btScalar(2.) * (halfExtents.m_floats[0] + margin);
+	btScalar ly = btScalar(2.) * (halfExtents.m_floats[1] + margin);
+	btScalar lz = btScalar(2.) * (halfExtents.m_floats[2] + margin);
 	const btScalar x2 = lx * lx;
 	const btScalar y2 = ly * ly;
 	const btScalar z2 = lz * lz;

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp

@@ -52,18 +52,18 @@ void btScaledBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callb
 {
 	btScaledTriangleCallback scaledCallback(callback, m_localScaling);
 
-	btVector3 invLocalScaling(1.f / m_localScaling.getX(), 1.f / m_localScaling.getY(), 1.f / m_localScaling.getZ());
+	btVector3 invLocalScaling(1.f / m_localScaling.m_floats[0], 1.f / m_localScaling.m_floats[1], 1.f / m_localScaling.m_floats[2]);
 	btVector3 scaledAabbMin, scaledAabbMax;
 
 	///support negative scaling
-	scaledAabbMin[0] = m_localScaling.getX() >= 0. ? aabbMin[0] * invLocalScaling[0] : aabbMax[0] * invLocalScaling[0];
-	scaledAabbMin[1] = m_localScaling.getY() >= 0. ? aabbMin[1] * invLocalScaling[1] : aabbMax[1] * invLocalScaling[1];
-	scaledAabbMin[2] = m_localScaling.getZ() >= 0. ? aabbMin[2] * invLocalScaling[2] : aabbMax[2] * invLocalScaling[2];
+	scaledAabbMin[0] = m_localScaling.m_floats[0] >= 0. ? aabbMin[0] * invLocalScaling[0] : aabbMax[0] * invLocalScaling[0];
+	scaledAabbMin[1] = m_localScaling.m_floats[1] >= 0. ? aabbMin[1] * invLocalScaling[1] : aabbMax[1] * invLocalScaling[1];
+	scaledAabbMin[2] = m_localScaling.m_floats[2] >= 0. ? aabbMin[2] * invLocalScaling[2] : aabbMax[2] * invLocalScaling[2];
 	scaledAabbMin[3] = 0.f;
 
-	scaledAabbMax[0] = m_localScaling.getX() <= 0. ? aabbMin[0] * invLocalScaling[0] : aabbMax[0] * invLocalScaling[0];
-	scaledAabbMax[1] = m_localScaling.getY() <= 0. ? aabbMin[1] * invLocalScaling[1] : aabbMax[1] * invLocalScaling[1];
-	scaledAabbMax[2] = m_localScaling.getZ() <= 0. ? aabbMin[2] * invLocalScaling[2] : aabbMax[2] * invLocalScaling[2];
+	scaledAabbMax[0] = m_localScaling.m_floats[0] <= 0. ? aabbMin[0] * invLocalScaling[0] : aabbMax[0] * invLocalScaling[0];
+	scaledAabbMax[1] = m_localScaling.m_floats[1] <= 0. ? aabbMin[1] * invLocalScaling[1] : aabbMax[1] * invLocalScaling[1];
+	scaledAabbMax[2] = m_localScaling.m_floats[2] <= 0. ? aabbMin[2] * invLocalScaling[2] : aabbMax[2] * invLocalScaling[2];
 	scaledAabbMax[3] = 0.f;
 
 	m_bvhTriMeshShape->processAllTriangles(&scaledCallback, scaledAabbMin, scaledAabbMax);
@@ -77,12 +77,12 @@ void btScaledBvhTriangleMeshShape::getAabb(const btTransform& trans, btVector3&
 	btVector3 tmpLocalAabbMin = localAabbMin * m_localScaling;
 	btVector3 tmpLocalAabbMax = localAabbMax * m_localScaling;
 
-	localAabbMin[0] = (m_localScaling.getX() >= 0.) ? tmpLocalAabbMin[0] : tmpLocalAabbMax[0];
-	localAabbMin[1] = (m_localScaling.getY() >= 0.) ? tmpLocalAabbMin[1] : tmpLocalAabbMax[1];
-	localAabbMin[2] = (m_localScaling.getZ() >= 0.) ? tmpLocalAabbMin[2] : tmpLocalAabbMax[2];
-	localAabbMax[0] = (m_localScaling.getX() <= 0.) ? tmpLocalAabbMin[0] : tmpLocalAabbMax[0];
-	localAabbMax[1] = (m_localScaling.getY() <= 0.) ? tmpLocalAabbMin[1] : tmpLocalAabbMax[1];
-	localAabbMax[2] = (m_localScaling.getZ() <= 0.) ? tmpLocalAabbMin[2] : tmpLocalAabbMax[2];
+	localAabbMin[0] = (m_localScaling.m_floats[0] >= 0.) ? tmpLocalAabbMin[0] : tmpLocalAabbMax[0];
+	localAabbMin[1] = (m_localScaling.m_floats[1] >= 0.) ? tmpLocalAabbMin[1] : tmpLocalAabbMax[1];
+	localAabbMin[2] = (m_localScaling.m_floats[2] >= 0.) ? tmpLocalAabbMin[2] : tmpLocalAabbMax[2];
+	localAabbMax[0] = (m_localScaling.m_floats[0] <= 0.) ? tmpLocalAabbMin[0] : tmpLocalAabbMax[0];
+	localAabbMax[1] = (m_localScaling.m_floats[1] <= 0.) ? tmpLocalAabbMin[1] : tmpLocalAabbMax[1];
+	localAabbMax[2] = (m_localScaling.m_floats[2] <= 0.) ? tmpLocalAabbMin[2] : tmpLocalAabbMax[2];
 
 	btVector3 localHalfExtents = btScalar(0.5) * (localAabbMax - localAabbMin);
 	btScalar margin = m_bvhTriMeshShape->getMargin();

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btSphereShape.h

@@ -31,7 +31,7 @@ public:
 		m_shapeType = SPHERE_SHAPE_PROXYTYPE;
 		m_localScaling.setValue(1.0, 1.0, 1.0);
 		m_implicitShapeDimensions.setZero();
-		m_implicitShapeDimensions.setX(radius);
+		m_implicitShapeDimensions.m_floats[0] = (radius);
 		m_collisionMargin = radius;
 		m_padding = 0;
 	}
@@ -45,11 +45,11 @@ public:
 
 	virtual void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const;
 
-	btScalar getRadius() const { return m_implicitShapeDimensions.getX() * m_localScaling.getX(); }
+	btScalar getRadius() const { return m_implicitShapeDimensions.m_floats[0] * m_localScaling.m_floats[0]; }
 
 	void setUnscaledRadius(btScalar radius)
 	{
-		m_implicitShapeDimensions.setX(radius);
+		m_implicitShapeDimensions.m_floats[0] = (radius);
 		btConvexInternalShape::setMargin(radius);
 	}
 

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp

@@ -61,11 +61,11 @@ void btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 						{
 							unsigned int* tri_indices = (unsigned int*)(indexbase + gfxindex * indexstride);
 							graphicsbase = (float*)(vertexbase + tri_indices[0] * stride);
-							triangle[0].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+							triangle[0].setValue(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (float*)(vertexbase + tri_indices[1] * stride);
-							triangle[1].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+							triangle[1].setValue(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (float*)(vertexbase + tri_indices[2] * stride);
-							triangle[2].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+							triangle[2].setValue(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 							callback->internalProcessTriangleIndex(triangle, part, gfxindex);
 						}
 						break;
@@ -76,11 +76,11 @@ void btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 						{
 							unsigned short int* tri_indices = (unsigned short int*)(indexbase + gfxindex * indexstride);
 							graphicsbase = (float*)(vertexbase + tri_indices[0] * stride);
-							triangle[0].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+							triangle[0].setValue(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (float*)(vertexbase + tri_indices[1] * stride);
-							triangle[1].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+							triangle[1].setValue(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (float*)(vertexbase + tri_indices[2] * stride);
-							triangle[2].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+							triangle[2].setValue(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 							callback->internalProcessTriangleIndex(triangle, part, gfxindex);
 						}
 						break;
@@ -91,11 +91,11 @@ void btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 						{
 							unsigned char* tri_indices = (unsigned char*)(indexbase + gfxindex * indexstride);
 							graphicsbase = (float*)(vertexbase + tri_indices[0] * stride);
-							triangle[0].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+							triangle[0].setValue(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (float*)(vertexbase + tri_indices[1] * stride);
-							triangle[1].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+							triangle[1].setValue(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (float*)(vertexbase + tri_indices[2] * stride);
-							triangle[2].setValue(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
+							triangle[2].setValue(graphicsbase[0] * meshScaling.m_floats[0], graphicsbase[1] * meshScaling.m_floats[1], graphicsbase[2] * meshScaling.m_floats[2]);
 							callback->internalProcessTriangleIndex(triangle, part, gfxindex);
 						}
 						break;
@@ -118,11 +118,11 @@ void btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 						{
 							unsigned int* tri_indices = (unsigned int*)(indexbase + gfxindex * indexstride);
 							graphicsbase = (double*)(vertexbase + tri_indices[0] * stride);
-							triangle[0].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ());
+							triangle[0].setValue((btScalar)graphicsbase[0] * meshScaling.m_floats[0], (btScalar)graphicsbase[1] * meshScaling.m_floats[1], (btScalar)graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (double*)(vertexbase + tri_indices[1] * stride);
-							triangle[1].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ());
+							triangle[1].setValue((btScalar)graphicsbase[0] * meshScaling.m_floats[0], (btScalar)graphicsbase[1] * meshScaling.m_floats[1], (btScalar)graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (double*)(vertexbase + tri_indices[2] * stride);
-							triangle[2].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ());
+							triangle[2].setValue((btScalar)graphicsbase[0] * meshScaling.m_floats[0], (btScalar)graphicsbase[1] * meshScaling.m_floats[1], (btScalar)graphicsbase[2] * meshScaling.m_floats[2]);
 							callback->internalProcessTriangleIndex(triangle, part, gfxindex);
 						}
 						break;
@@ -133,11 +133,11 @@ void btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 						{
 							unsigned short int* tri_indices = (unsigned short int*)(indexbase + gfxindex * indexstride);
 							graphicsbase = (double*)(vertexbase + tri_indices[0] * stride);
-							triangle[0].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ());
+							triangle[0].setValue((btScalar)graphicsbase[0] * meshScaling.m_floats[0], (btScalar)graphicsbase[1] * meshScaling.m_floats[1], (btScalar)graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (double*)(vertexbase + tri_indices[1] * stride);
-							triangle[1].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ());
+							triangle[1].setValue((btScalar)graphicsbase[0] * meshScaling.m_floats[0], (btScalar)graphicsbase[1] * meshScaling.m_floats[1], (btScalar)graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (double*)(vertexbase + tri_indices[2] * stride);
-							triangle[2].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ());
+							triangle[2].setValue((btScalar)graphicsbase[0] * meshScaling.m_floats[0], (btScalar)graphicsbase[1] * meshScaling.m_floats[1], (btScalar)graphicsbase[2] * meshScaling.m_floats[2]);
 							callback->internalProcessTriangleIndex(triangle, part, gfxindex);
 						}
 						break;
@@ -148,11 +148,11 @@ void btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 						{
 							unsigned char* tri_indices = (unsigned char*)(indexbase + gfxindex * indexstride);
 							graphicsbase = (double*)(vertexbase + tri_indices[0] * stride);
-							triangle[0].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ());
+							triangle[0].setValue((btScalar)graphicsbase[0] * meshScaling.m_floats[0], (btScalar)graphicsbase[1] * meshScaling.m_floats[1], (btScalar)graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (double*)(vertexbase + tri_indices[1] * stride);
-							triangle[1].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ());
+							triangle[1].setValue((btScalar)graphicsbase[0] * meshScaling.m_floats[0], (btScalar)graphicsbase[1] * meshScaling.m_floats[1], (btScalar)graphicsbase[2] * meshScaling.m_floats[2]);
 							graphicsbase = (double*)(vertexbase + tri_indices[2] * stride);
-							triangle[2].setValue((btScalar)graphicsbase[0] * meshScaling.getX(), (btScalar)graphicsbase[1] * meshScaling.getY(), (btScalar)graphicsbase[2] * meshScaling.getZ());
+							triangle[2].setValue((btScalar)graphicsbase[0] * meshScaling.m_floats[0], (btScalar)graphicsbase[1] * meshScaling.m_floats[1], (btScalar)graphicsbase[2] * meshScaling.m_floats[2]);
 							callback->internalProcessTriangleIndex(triangle, part, gfxindex);
 						}
 						break;

3rdparty/bullet3/src/BulletCollision/CollisionShapes/btTriangleMesh.cpp

@@ -116,9 +116,9 @@ int btTriangleMesh::findOrAddVertex(const btVector3& vertex, bool removeDuplicat
 				}
 			}
 		}
-		m_3componentVertices.push_back(vertex.getX());
-		m_3componentVertices.push_back(vertex.getY());
-		m_3componentVertices.push_back(vertex.getZ());
+		m_3componentVertices.push_back(vertex.m_floats[0]);
+		m_3componentVertices.push_back(vertex.m_floats[1]);
+		m_3componentVertices.push_back(vertex.m_floats[2]);
 		m_indexedMeshes[0].m_numVertices++;
 		m_indexedMeshes[0].m_vertexBase = (unsigned char*)&m_3componentVertices[0];
 		return (m_3componentVertices.size() / 3) - 1;

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

@@ -195,9 +195,9 @@ int btComputeGjkEpaPenetration(const btConvexTemplate& a, const btConvexTemplate
 
 				printf("btGjkPairDetector maxIter exceeded:%i\n", m_curIter);
 				printf("sepAxis=(%f,%f,%f), squaredDistance = %f\n",
-					   m_cachedSeparatingAxis.getX(),
-					   m_cachedSeparatingAxis.getY(),
-					   m_cachedSeparatingAxis.getZ(),
+					   m_cachedSeparatingAxis.m_floats[0],
+					   m_cachedSeparatingAxis.m_floats[1],
+					   m_cachedSeparatingAxis.m_floats[2],
 					   squaredDistance);
 #endif
 

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

@@ -418,9 +418,9 @@ struct GJK
 	}
 	static btScalar det(const btVector3& a, const btVector3& b, const btVector3& c)
 	{
-		return (a.y() * b.z() * c.x() + a.z() * b.x() * c.y() -
-				a.x() * b.z() * c.y() - a.y() * b.x() * c.z() +
-				a.x() * b.y() * c.z() - a.z() * b.y() * c.x());
+		return (a.m_floats[1] * b.m_floats[2] * c.m_floats[0] + a.m_floats[2] * b.m_floats[0] * c.m_floats[1] -
+				a.m_floats[0] * b.m_floats[2] * c.m_floats[1] - a.m_floats[1] * b.m_floats[0] * c.m_floats[2] +
+				a.m_floats[0] * b.m_floats[1] * c.m_floats[2] - a.m_floats[2] * b.m_floats[1] * c.m_floats[0]);
 	}
 	static btScalar projectorigin(const btVector3& a,
 								  const btVector3& b,

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

@@ -392,9 +392,9 @@ struct GJK
 	}
 	static btScalar det(const btVector3& a, const btVector3& b, const btVector3& c)
 	{
-		return (a.y() * b.z() * c.x() + a.z() * b.x() * c.y() -
-				a.x() * b.z() * c.y() - a.y() * b.x() * c.z() +
-				a.x() * b.y() * c.z() - a.z() * b.y() * c.x());
+		return (a.m_floats[1] * b.m_floats[2] * c.m_floats[0] + a.m_floats[2] * b.m_floats[0] * c.m_floats[1] -
+				a.m_floats[0] * b.m_floats[2] * c.m_floats[1] - a.m_floats[1] * b.m_floats[0] * c.m_floats[2] +
+				a.m_floats[0] * b.m_floats[1] * c.m_floats[2] - a.m_floats[2] * b.m_floats[1] * c.m_floats[0]);
 	}
 	static btScalar projectorigin(const btVector3& a,
 								  const btVector3& b,

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

@@ -215,17 +215,17 @@ inline int ccdEq(btScalar _a, btScalar _b)
 
 btScalar ccdVec3X(const btVector3 *v)
 {
-	return v->x();
+	return v->m_floats[0];
 }
 
 btScalar ccdVec3Y(const btVector3 *v)
 {
-	return v->y();
+	return v->m_floats[1];
 }
 
 btScalar ccdVec3Z(const btVector3 *v)
 {
-	return v->z();
+	return v->m_floats[2];
 }
 inline int btVec3Eq(const btVector3 *a, const btVector3 *b)
 {
@@ -945,9 +945,9 @@ void btGjkPairDetector::getClosestPointsNonVirtual(const ClosestPointInput &inpu
 
 					printf("btGjkPairDetector maxIter exceeded:%i\n", m_curIter);
 					printf("sepAxis=(%f,%f,%f), squaredDistance = %f, shapeTypeA=%i,shapeTypeB=%i\n",
-						   m_cachedSeparatingAxis.getX(),
-						   m_cachedSeparatingAxis.getY(),
-						   m_cachedSeparatingAxis.getZ(),
+						   m_cachedSeparatingAxis.m_floats[0],
+						   m_cachedSeparatingAxis.m_floats[1],
+						   m_cachedSeparatingAxis.m_floats[2],
 						   squaredDistance,
 						   m_minkowskiA->getShapeType(),
 						   m_minkowskiB->getShapeType());

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

@@ -94,9 +94,9 @@ inline void btMprSimplexSetSize(btMprSimplex_t *s, int size)
 #ifdef DEBUG_MPR
 inline void btPrintPortalVertex(_btMprSimplex_t *portal, int index)
 {
-	printf("portal[%d].v = %f,%f,%f, v1=%f,%f,%f, v2=%f,%f,%f\n", index, portal->ps[index].v.x(), portal->ps[index].v.y(), portal->ps[index].v.z(),
-		   portal->ps[index].v1.x(), portal->ps[index].v1.y(), portal->ps[index].v1.z(),
-		   portal->ps[index].v2.x(), portal->ps[index].v2.y(), portal->ps[index].v2.z());
+	printf("portal[%d].v = %f,%f,%f, v1=%f,%f,%f, v2=%f,%f,%f\n", index, portal->ps[index].v.m_floats[0], portal->ps[index].v.m_floats[1], portal->ps[index].v.m_floats[2],
+		   portal->ps[index].v1.m_floats[0], portal->ps[index].v1.m_floats[1], portal->ps[index].v1.m_floats[2],
+		   portal->ps[index].v2.m_floats[0], portal->ps[index].v2.m_floats[1], portal->ps[index].v2.m_floats[2]);
 }
 #endif  //DEBUG_MPR
 
@@ -158,7 +158,7 @@ inline int btMprEq(float _a, float _b)
 
 inline int btMprVec3Eq(const btVector3 *a, const btVector3 *b)
 {
-	return btMprEq((*a).x(), (*b).x()) && btMprEq((*a).y(), (*b).y()) && btMprEq((*a).z(), (*b).z());
+	return btMprEq((*a).m_floats[0], (*b).m_floats[0]) && btMprEq((*a).m_floats[1], (*b).m_floats[1]) && btMprEq((*a).m_floats[2], (*b).m_floats[2]);
 }
 
 template <typename btConvexTemplate>
@@ -754,7 +754,7 @@ static void btFindPenetr(const btConvexTemplate &a, const btConvexTemplate &b,
 			*depth = btMprVec3PointTriDist2(origin, &btMprSimplexPoint(portal, 1)->v, &btMprSimplexPoint(portal, 2)->v, &btMprSimplexPoint(portal, 3)->v, pdir);
 			*depth = BT_MPR_SQRT(*depth);
 
-			if (btMprIsZero((*pdir).x()) && btMprIsZero((*pdir).y()) && btMprIsZero((*pdir).z()))
+			if (btMprIsZero((*pdir).m_floats[0]) && btMprIsZero((*pdir).m_floats[1]) && btMprIsZero((*pdir).m_floats[2]))
 			{
 				*pdir = dir;
 			}

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

@@ -249,12 +249,12 @@ void btPersistentManifold::refreshContactPoints(const btTransform& trA, const bt
 	int i;
 #ifdef DEBUG_PERSISTENCY
 	printf("refreshContactPoints posA = (%f,%f,%f) posB = (%f,%f,%f)\n",
-		   trA.m_origin.getX(),
-		   trA.m_origin.getY(),
-		   trA.m_origin.getZ(),
-		   trB.m_origin.getX(),
-		   trB.m_origin.getY(),
-		   trB.m_origin.getZ());
+		   trA.m_origin.m_floats[0],
+		   trA.m_origin.m_floats[1],
+		   trA.m_origin.m_floats[2],
+		   trB.m_origin.m_floats[0],
+		   trB.m_origin.m_floats[1],
+		   trB.m_origin.m_floats[2]);
 #endif  //DEBUG_PERSISTENCY
 	/// first refresh worldspace positions and distance
 	for (i = getNumContacts() - 1; i >= 0; i--)

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

@@ -110,7 +110,7 @@ static int gActualSATPairTests = 0;
 
 inline bool IsAlmostZero(const btVector3& v)
 {
-	if (btFabs(v.x()) > 1e-6 || btFabs(v.y()) > 1e-6 || btFabs(v.z()) > 1e-6) return false;
+	if (btFabs(v.m_floats[0]) > 1e-6 || btFabs(v.m_floats[1]) > 1e-6 || btFabs(v.m_floats[2]) > 1e-6) return false;
 	return true;
 }
 
@@ -134,9 +134,9 @@ void InverseTransformPoint3x3(btVector3& out, const btVector3& in, const btTrans
 	const btVector3& r1 = rot[1];
 	const btVector3& r2 = rot[2];
 
-	const btScalar x = r0.x() * in.x() + r1.x() * in.y() + r2.x() * in.z();
-	const btScalar y = r0.y() * in.x() + r1.y() * in.y() + r2.y() * in.z();
-	const btScalar z = r0.z() * in.x() + r1.z() * in.y() + r2.z() * in.z();
+	const btScalar x = r0.m_floats[0] * in.m_floats[0] + r1.m_floats[0] * in.m_floats[1] + r2.m_floats[0] * in.m_floats[2];
+	const btScalar y = r0.m_floats[1] * in.m_floats[0] + r1.m_floats[1] * in.m_floats[1] + r2.m_floats[1] * in.m_floats[2];
+	const btScalar z = r0.m_floats[2] * in.m_floats[0] + r1.m_floats[2] * in.m_floats[1] + r2.m_floats[2] * in.m_floats[2];
 
 	out.setValue(x, y, z);
 }
@@ -155,8 +155,8 @@ bool TestInternalObjects(const btTransform& trans0, const btTransform& trans1, c
 	btScalar p1[3];
 	BoxSupport(convex1.m_extents, localAxis1, p1);
 
-	const btScalar Radius0 = p0[0] * localAxis0.x() + p0[1] * localAxis0.y() + p0[2] * localAxis0.z();
-	const btScalar Radius1 = p1[0] * localAxis1.x() + p1[1] * localAxis1.y() + p1[2] * localAxis1.z();
+	const btScalar Radius0 = p0[0] * localAxis0.m_floats[0] + p0[1] * localAxis0.m_floats[1] + p0[2] * localAxis0.m_floats[2];
+	const btScalar Radius1 = p1[0] * localAxis1.m_floats[0] + p1[1] * localAxis1.m_floats[1] + p1[2] * localAxis1.m_floats[2];
 
 	const btScalar MinRadius = Radius0 > convex0.m_radius ? Radius0 : convex0.m_radius;
 	const btScalar MaxRadius = Radius1 > convex1.m_radius ? Radius1 : convex1.m_radius;

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

@@ -563,9 +563,9 @@ void btKinematicCharacterController::stepDown(btCollisionWorld* collisionWorld,
 	if ((m_ghostObject->hasContactResponse() && (callback.hasHit() && needsCollision(m_ghostObject, callback.m_hitCollisionObject))) || runonce == true)
 	{
 		// we dropped a fraction of the height -> hit floor
-		btScalar fraction = (m_currentPosition.getY() - callback.m_hitPointWorld.getY()) / 2;
+		btScalar fraction = (m_currentPosition.m_floats[1] - callback.m_hitPointWorld.m_floats[1]) / 2;
 
-		//printf("hitpoint: %g - pos %g\n", callback.m_hitPointWorld.getY(), m_currentPosition.getY());
+		//printf("hitpoint: %g - pos %g\n", callback.m_hitPointWorld.m_floats[1], m_currentPosition.m_floats[1]);
 
 		if (bounce_fix == true)
 		{
@@ -601,7 +601,7 @@ void btKinematicCharacterController::stepDown(btCollisionWorld* collisionWorld,
 				m_targetPosition -= step_drop;
 			}
 		}
-		//printf("full drop - %g, %g\n", m_currentPosition.getY(), m_targetPosition.getY());
+		//printf("full drop - %g, %g\n", m_currentPosition.m_floats[1], m_targetPosition.m_floats[1]);
 
 		m_currentPosition = m_targetPosition;
 	}
@@ -622,7 +622,7 @@ void btKinematicCharacterController::setVelocityForTimeInterval(
 	//	printf("setVelocity!\n");
 	//	printf("  interval: %f\n", timeInterval);
 	//	printf("  velocity: (%f, %f, %f)\n",
-	//		 velocity.x(), velocity.y(), velocity.z());
+	//		 velocity.m_floats[0], velocity.m_floats[1], velocity.m_floats[2]);
 
 	m_useWalkDirection = false;
 	m_walkDirection = velocity;

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

@@ -158,8 +158,8 @@ static void debugDrawAllBatches(const btBatchedConstraints* bc,
 			bboxMax.setMax(pos);
 		}
 		btVector3 bboxExtent = bboxMax - bboxMin;
-		btVector3 offsetBase = btVector3(0, bboxExtent.y() * 1.1f, 0);
-		btVector3 offsetStep = btVector3(0, 0, bboxExtent.z() * 1.1f);
+		btVector3 offsetBase = btVector3(0, bboxExtent.m_floats[1] * 1.1f, 0);
+		btVector3 offsetStep = btVector3(0, 0, bboxExtent.m_floats[2] * 1.1f);
 		int numPhases = bc->m_phases.size();
 		for (int iPhase = 0; iPhase < numPhases; ++iPhase)
 		{
@@ -180,7 +180,7 @@ static void initBatchedBodyDynamicFlags(btAlignedObjectArray<bool>* outBodyDynam
 	for (int i = 0; i < bodies.size(); ++i)
 	{
 		const btSolverBody& body = bodies[i];
-		bodyDynamicFlags[i] = (body.internalGetInvMass().x() > btScalar(0));
+		bodyDynamicFlags[i] = (body.internalGetInvMass().m_floats[0] > btScalar(0));
 	}
 }
 
@@ -873,7 +873,7 @@ static void setupSpatialGridBatchesMt(
 	{
 		const btSolverBody& body = bodies[i];
 		btVector3 bodyPos = body.getWorldTransform().m_origin;
-		bool isDynamic = (body.internalGetInvMass().x() > btScalar(0));
+		bool isDynamic = (body.internalGetInvMass().m_floats[0] > btScalar(0));
 		bodyPositions[i] = bodyPos;
 		bodyDynamicFlags[i] = isDynamic;
 		if (isDynamic)
@@ -894,9 +894,9 @@ static void setupSpatialGridBatchesMt(
 
 	btVector3 gridCellSize = consExtent;
 	int gridDim[3];
-	gridDim[0] = int(1.0 + gridExtent.x() / gridCellSize.x());
-	gridDim[1] = int(1.0 + gridExtent.y() / gridCellSize.y());
-	gridDim[2] = int(1.0 + gridExtent.z() / gridCellSize.z());
+	gridDim[0] = int(1.0 + gridExtent.m_floats[0] / gridCellSize.m_floats[0]);
+	gridDim[1] = int(1.0 + gridExtent.m_floats[1] / gridCellSize.m_floats[1]);
+	gridDim[2] = int(1.0 + gridExtent.m_floats[2] / gridCellSize.m_floats[2]);
 
 	// if we can collapse an axis, it will cut our number of phases in half which could be more efficient
 	int phaseMask = 7;
@@ -924,9 +924,9 @@ static void setupSpatialGridBatchesMt(
 	btIntVec3 gridChunkDim;  // each chunk is 2x2x2 group of cells
 	while (true)
 	{
-		gridDim[0] = int(1.0 + gridExtent.x() / gridCellSize.x());
-		gridDim[1] = int(1.0 + gridExtent.y() / gridCellSize.y());
-		gridDim[2] = int(1.0 + gridExtent.z() / gridCellSize.z());
+		gridDim[0] = int(1.0 + gridExtent.m_floats[0] / gridCellSize.m_floats[0]);
+		gridDim[1] = int(1.0 + gridExtent.m_floats[1] / gridCellSize.m_floats[1]);
+		gridDim[2] = int(1.0 + gridExtent.m_floats[2] / gridCellSize.m_floats[2]);
 		gridChunkDim[0] = btMax(1, (gridDim[0] + 0) / 2);
 		gridChunkDim[1] = btMax(1, (gridDim[1] + 0) / 2);
 		gridChunkDim[2] = btMax(1, (gridDim[2] + 0) / 2);
@@ -950,9 +950,9 @@ static void setupSpatialGridBatchesMt(
 		if (bodyDynamicFlags[iBody])
 		{
 			btVector3 v = (bodyPositions[iBody] - bboxMin) * invGridCellSize;
-			coords.m_ints[0] = int(v.x());
-			coords.m_ints[1] = int(v.y());
-			coords.m_ints[2] = int(v.z());
+			coords.m_ints[0] = int(v.m_floats[0]);
+			coords.m_ints[1] = int(v.m_floats[1]);
+			coords.m_ints[2] = int(v.m_floats[2]);
 			btAssert(coords.m_ints[0] >= 0 && coords.m_ints[0] < gridDim[0]);
 			btAssert(coords.m_ints[1] >= 0 && coords.m_ints[1] < gridDim[1]);
 			btAssert(coords.m_ints[2] >= 0 && coords.m_ints[2] < gridDim[2]);

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

@@ -618,7 +618,7 @@ void btConeTwistConstraint::calcAngleInfo2(const btTransform& transA, const btTr
 		btTransform trB = transB * m_rbBFrame;
 		btTransform trDeltaAB = trB * trPose * trA.inverse();
 		btQuaternion qDeltaAB = trDeltaAB.getRotation();
-		btVector3 swingAxis = btVector3(qDeltaAB.x(), qDeltaAB.y(), qDeltaAB.z());
+		btVector3 swingAxis = btVector3(qDeltaAB.m_floats[0], qDeltaAB.m_floats[1], qDeltaAB.m_floats[2]);
 		btScalar swingAxisLen2 = swingAxis.length2();
 		if (btFuzzyZero(swingAxisLen2))
 		{
@@ -812,11 +812,11 @@ void btConeTwistConstraint::computeConeLimitInfo(const btQuaternion& qCone,
 	swingAngle = qCone.getAngle();
 	if (swingAngle > SIMD_EPSILON)
 	{
-		vSwingAxis = btVector3(qCone.x(), qCone.y(), qCone.z());
+		vSwingAxis = btVector3(qCone.m_floats[0], qCone.m_floats[1], qCone.m_floats[2]);
 		vSwingAxis.normalize();
 #if 0
         // non-zero twist?! this should never happen.
-       btAssert(fabs(vSwingAxis.x()) <= SIMD_EPSILON));
+       btAssert(fabs(vSwingAxis.m_floats[0]) <= SIMD_EPSILON));
 #endif
 
 		// Compute limit for given swing. tricky:
@@ -826,8 +826,8 @@ void btConeTwistConstraint::computeConeLimitInfo(const btQuaternion& qCone,
 		// For starters, compute the direction from center to surface of ellipse.
 		// This is just the perpendicular (ie. rotate 2D vector by PI/2) of the swing axis.
 		// (vSwingAxis is the cone rotation (in z,y); change vars and rotate to (x,y) coords.)
-		btScalar xEllipse = vSwingAxis.y();
-		btScalar yEllipse = -vSwingAxis.z();
+		btScalar xEllipse = vSwingAxis.m_floats[1];
+		btScalar yEllipse = -vSwingAxis.m_floats[2];
 
 		// Now, we use the slope of the vector (using x/yEllipse) and find the length
 		// of the line that intersects the ellipse:
@@ -848,12 +848,12 @@ void btConeTwistConstraint::computeConeLimitInfo(const btQuaternion& qCone,
 
 		// test!
 		/*swingLimit = m_swingSpan2;
-		if (fabs(vSwingAxis.z()) > SIMD_EPSILON)
+		if (fabs(vSwingAxis.m_floats[2]) > SIMD_EPSILON)
 		{
 		btScalar mag_2 = m_swingSpan1*m_swingSpan1 + m_swingSpan2*m_swingSpan2;
 		btScalar sinphi = m_swingSpan2 / sqrt(mag_2);
 		btScalar phi = asin(sinphi);
-		btScalar theta = atan2(fabs(vSwingAxis.y()),fabs(vSwingAxis.z()));
+		btScalar theta = atan2(fabs(vSwingAxis.m_floats[1]),fabs(vSwingAxis.m_floats[2]));
 		btScalar alpha = 3.14159f - theta - phi;
 		btScalar sinalpha = sin(alpha);
 		swingLimit = m_swingSpan1 * sinphi/sinalpha;
@@ -921,7 +921,7 @@ void btConeTwistConstraint::computeTwistLimitInfo(const btQuaternion& qTwist,
 #endif
 	}
 
-	vTwistAxis = btVector3(qMinTwist.x(), qMinTwist.y(), qMinTwist.z());
+	vTwistAxis = btVector3(qMinTwist.m_floats[0], qMinTwist.m_floats[1], qMinTwist.m_floats[2]);
 	if (twistAngle > SIMD_EPSILON)
 		vTwistAxis.normalize();
 }
@@ -935,8 +935,8 @@ void btConeTwistConstraint::adjustSwingAxisToUseEllipseNormal(btVector3& vSwingA
 
 	// convert swing axis to direction from center to surface of ellipse
 	// (ie. rotate 2D vector by PI/2)
-	btScalar y = -vSwingAxis.z();
-	btScalar z = vSwingAxis.y();
+	btScalar y = -vSwingAxis.m_floats[2];
+	btScalar z = vSwingAxis.m_floats[1];
 
 	// do the math...
 	if (fabs(z) > SIMD_EPSILON)  // avoid division by 0. and we don't need an update if z == 0.
@@ -952,8 +952,8 @@ void btConeTwistConstraint::adjustSwingAxisToUseEllipseNormal(btVector3& vSwingA
 			y = -fabs(grad * z);
 
 		// convert ellipse direction back to swing axis
-		vSwingAxis.setZ(-y);
-		vSwingAxis.setY(z);
+		vSwingAxis.m_floats[2] = (-y);
+		vSwingAxis.m_floats[1] = (z);
 		vSwingAxis.normalize();
 	}
 }

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

@@ -67,18 +67,18 @@ btHingeConstraint::btHingeConstraint(btRigidBody& rbA, btRigidBody& rbB, const b
 		rbAxisA1 = rbAxisA2.cross(axisInA);
 	}
 
-	m_rbAFrame.m_basis.setValue(rbAxisA1.getX(), rbAxisA2.getX(), axisInA.getX(),
-								   rbAxisA1.getY(), rbAxisA2.getY(), axisInA.getY(),
-								   rbAxisA1.getZ(), rbAxisA2.getZ(), axisInA.getZ());
+	m_rbAFrame.m_basis.setValue(rbAxisA1.m_floats[0], rbAxisA2.m_floats[0], axisInA.m_floats[0],
+								   rbAxisA1.m_floats[1], rbAxisA2.m_floats[1], axisInA.m_floats[1],
+								   rbAxisA1.m_floats[2], rbAxisA2.m_floats[2], axisInA.m_floats[2]);
 
 	btQuaternion rotationArc = shortestArcQuat(axisInA, axisInB);
 	btVector3 rbAxisB1 = quatRotate(rotationArc, rbAxisA1);
 	btVector3 rbAxisB2 = axisInB.cross(rbAxisB1);
 
 	m_rbBFrame.m_origin = pivotInB;
-	m_rbBFrame.m_basis.setValue(rbAxisB1.getX(), rbAxisB2.getX(), axisInB.getX(),
-								   rbAxisB1.getY(), rbAxisB2.getY(), axisInB.getY(),
-								   rbAxisB1.getZ(), rbAxisB2.getZ(), axisInB.getZ());
+	m_rbBFrame.m_basis.setValue(rbAxisB1.m_floats[0], rbAxisB2.m_floats[0], axisInB.m_floats[0],
+								   rbAxisB1.m_floats[1], rbAxisB2.m_floats[1], axisInB.m_floats[1],
+								   rbAxisB1.m_floats[2], rbAxisB2.m_floats[2], axisInB.m_floats[2]);
 
 #ifndef _BT_USE_CENTER_LIMIT_
 	//start with free
@@ -114,9 +114,9 @@ btHingeConstraint::btHingeConstraint(btRigidBody& rbA, const btVector3& pivotInA
 	btPlaneSpace1(axisInA, rbAxisA1, rbAxisA2);
 
 	m_rbAFrame.m_origin = pivotInA;
-	m_rbAFrame.m_basis.setValue(rbAxisA1.getX(), rbAxisA2.getX(), axisInA.getX(),
-								   rbAxisA1.getY(), rbAxisA2.getY(), axisInA.getY(),
-								   rbAxisA1.getZ(), rbAxisA2.getZ(), axisInA.getZ());
+	m_rbAFrame.m_basis.setValue(rbAxisA1.m_floats[0], rbAxisA2.m_floats[0], axisInA.m_floats[0],
+								   rbAxisA1.m_floats[1], rbAxisA2.m_floats[1], axisInA.m_floats[1],
+								   rbAxisA1.m_floats[2], rbAxisA2.m_floats[2], axisInA.m_floats[2]);
 
 	btVector3 axisInB = rbA.getCenterOfMassTransform().m_basis * axisInA;
 
@@ -125,9 +125,9 @@ btHingeConstraint::btHingeConstraint(btRigidBody& rbA, const btVector3& pivotInA
 	btVector3 rbAxisB2 = axisInB.cross(rbAxisB1);
 
 	m_rbBFrame.m_origin = rbA.getCenterOfMassTransform()(pivotInA);
-	m_rbBFrame.m_basis.setValue(rbAxisB1.getX(), rbAxisB2.getX(), axisInB.getX(),
-								   rbAxisB1.getY(), rbAxisB2.getY(), axisInB.getY(),
-								   rbAxisB1.getZ(), rbAxisB2.getZ(), axisInB.getZ());
+	m_rbBFrame.m_basis.setValue(rbAxisB1.m_floats[0], rbAxisB2.m_floats[0], axisInB.m_floats[0],
+								   rbAxisB1.m_floats[1], rbAxisB2.m_floats[1], axisInB.m_floats[1],
+								   rbAxisB1.m_floats[2], rbAxisB2.m_floats[2], axisInB.m_floats[2]);
 
 #ifndef _BT_USE_CENTER_LIMIT_
 	//start with free
@@ -706,7 +706,7 @@ void btHingeConstraint::setMotorTarget(const btQuaternion& qAinB, btScalar dt)
 		qHinge = -(qHinge);
 		targetAngle = qHinge.getAngle();
 	}
-	if (qHinge.getZ() < 0)
+	if (qHinge.m_floats[2] < 0)
 		targetAngle = -targetAngle;
 
 	setMotorTarget(targetAngle, dt);

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

@@ -218,9 +218,9 @@ public:
 		btPlaneSpace1(axisInA, rbAxisA1, rbAxisA2);
 		btVector3 pivotInA = m_rbAFrame.m_origin;
 		//		m_rbAFrame.m_origin = pivotInA;
-		m_rbAFrame.m_basis.setValue(rbAxisA1.getX(), rbAxisA2.getX(), axisInA.getX(),
-									   rbAxisA1.getY(), rbAxisA2.getY(), axisInA.getY(),
-									   rbAxisA1.getZ(), rbAxisA2.getZ(), axisInA.getZ());
+		m_rbAFrame.m_basis.setValue(rbAxisA1.m_floats[0], rbAxisA2.m_floats[0], axisInA.m_floats[0],
+									   rbAxisA1.m_floats[1], rbAxisA2.m_floats[1], axisInA.m_floats[1],
+									   rbAxisA1.m_floats[2], rbAxisA2.m_floats[2], axisInA.m_floats[2]);
 
 		btVector3 axisInB = m_rbA.getCenterOfMassTransform().m_basis * axisInA;
 
@@ -230,9 +230,9 @@ public:
 
 		m_rbBFrame.m_origin = m_rbB.getCenterOfMassTransform().inverse()(m_rbA.getCenterOfMassTransform()(pivotInA));
 
-		m_rbBFrame.m_basis.setValue(rbAxisB1.getX(), rbAxisB2.getX(), axisInB.getX(),
-									   rbAxisB1.getY(), rbAxisB2.getY(), axisInB.getY(),
-									   rbAxisB1.getZ(), rbAxisB2.getZ(), axisInB.getZ());
+		m_rbBFrame.m_basis.setValue(rbAxisB1.m_floats[0], rbAxisB2.m_floats[0], axisInB.m_floats[0],
+									   rbAxisB1.m_floats[1], rbAxisB2.m_floats[1], axisInB.m_floats[1],
+									   rbAxisB1.m_floats[2], rbAxisB2.m_floats[2], axisInB.m_floats[2]);
 		m_rbBFrame.m_basis = m_rbB.getCenterOfMassTransform().m_basis.inverse() * m_rbBFrame.m_basis;
 	}
 

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

@@ -116,7 +116,7 @@ void btRigidBody::saveKinematicState(btScalar timeStep)
 		m_interpolationLinearVelocity = m_linearVelocity;
 		m_interpolationAngularVelocity = m_angularVelocity;
 		m_interpolationWorldTransform = m_worldTransform;
-		//printf("angular = %f %f %f\n",m_angularVelocity.getX(),m_angularVelocity.getY(),m_angularVelocity.getZ());
+		//printf("angular = %f %f %f\n",m_angularVelocity.m_floats[0],m_angularVelocity.m_floats[1],m_angularVelocity.m_floats[2]);
 	}
 }
 
@@ -239,9 +239,9 @@ void btRigidBody::setMassProps(btScalar mass, const btVector3& inertia)
 	//Fg = m * a
 	m_gravity = mass * m_gravity_acceleration;
 
-	m_invInertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
-							   inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
-							   inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
+	m_invInertiaLocal.setValue(inertia.m_floats[0] != btScalar(0.0) ? btScalar(1.0) / inertia.m_floats[0] : btScalar(0.0),
+							   inertia.m_floats[1] != btScalar(0.0) ? btScalar(1.0) / inertia.m_floats[1] : btScalar(0.0),
+							   inertia.m_floats[2] != btScalar(0.0) ? btScalar(1.0) / inertia.m_floats[2] : btScalar(0.0));
 
 	m_invMass = m_linearFactor * m_inverseMass;
 }
@@ -255,9 +255,9 @@ btVector3 btRigidBody::getLocalInertia() const
 {
 	btVector3 inertiaLocal;
 	const btVector3 inertia = m_invInertiaLocal;
-	inertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
-						  inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
-						  inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
+	inertiaLocal.setValue(inertia.m_floats[0] != btScalar(0.0) ? btScalar(1.0) / inertia.m_floats[0] : btScalar(0.0),
+						  inertia.m_floats[1] != btScalar(0.0) ? btScalar(1.0) / inertia.m_floats[1] : btScalar(0.0),
+						  inertia.m_floats[2] != btScalar(0.0) ? btScalar(1.0) / inertia.m_floats[2] : btScalar(0.0));
 	return inertiaLocal;
 }
 
@@ -303,9 +303,9 @@ btVector3 btRigidBody::computeGyroscopicImpulseImplicit_Body(btScalar step) cons
 	// Convert to body coordinates
 	btVector3 omegab = quatRotate(q.inverse(), omega1);
 	btMatrix3x3 Ib;
-	Ib.setValue(idl.x(), 0, 0,
-				0, idl.y(), 0,
-				0, 0, idl.z());
+	Ib.setValue(idl.m_floats[0], 0, 0,
+				0, idl.m_floats[1], 0,
+				0, 0, idl.m_floats[2]);
 
 	btVector3 ibo = Ib * omegab;
 

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

@@ -373,17 +373,17 @@ public:
 
     #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
     void clampVelocity(btVector3& v) const {
-        v.setX(
+        v.m_floats[0] = (
             fmax(-BT_CLAMP_VELOCITY_TO,
-                 fmin(BT_CLAMP_VELOCITY_TO, v.getX()))
+                 fmin(BT_CLAMP_VELOCITY_TO, v.m_floats[0]))
         );
-        v.setY(
+        v.m_floats[1] = (
             fmax(-BT_CLAMP_VELOCITY_TO,
-                 fmin(BT_CLAMP_VELOCITY_TO, v.getY()))
+                 fmin(BT_CLAMP_VELOCITY_TO, v.m_floats[1]))
         );
-        v.setZ(
+        v.m_floats[2] = (
             fmax(-BT_CLAMP_VELOCITY_TO,
-                 fmin(BT_CLAMP_VELOCITY_TO, v.getZ()))
+                 fmin(BT_CLAMP_VELOCITY_TO, v.m_floats[2]))
         );
     }
     #endif

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

@@ -704,17 +704,17 @@ void btMultiBody::setBaseDynamicType(int dynamicType)
 inline btMatrix3x3 outerProduct(const btVector3 &v0, const btVector3 &v1)  //renamed it from vecMulVecTranspose (http://en.wikipedia.org/wiki/Outer_product); maybe it should be moved to btVector3 like dot and cross?
 {
 	btVector3 row0 = btVector3(
-		v0.x() * v1.x(),
-		v0.x() * v1.y(),
-		v0.x() * v1.z());
+		v0.m_floats[0] * v1.m_floats[0],
+		v0.m_floats[0] * v1.m_floats[1],
+		v0.m_floats[0] * v1.m_floats[2]);
 	btVector3 row1 = btVector3(
-		v0.y() * v1.x(),
-		v0.y() * v1.y(),
-		v0.y() * v1.z());
+		v0.m_floats[1] * v1.m_floats[0],
+		v0.m_floats[1] * v1.m_floats[1],
+		v0.m_floats[1] * v1.m_floats[2]);
 	btVector3 row2 = btVector3(
-		v0.z() * v1.x(),
-		v0.z() * v1.y(),
-		v0.z() * v1.z());
+		v0.m_floats[2] * v1.m_floats[0],
+		v0.m_floats[2] * v1.m_floats[1],
+		v0.m_floats[2] * v1.m_floats[2]);
 
 	btMatrix3x3 m(row0[0], row0[1], row0[2],
 				  row1[0], row1[1], row1[2],
@@ -963,9 +963,9 @@ void btMultiBody::computeAccelerationsArticulatedBodyAlgorithmMultiDof(btScalar
 												 0, m_links[i].m_inertiaLocal[1], 0,
 												 0, 0, m_links[i].m_inertiaLocal[2]));
 
-		//printf("w[%d] = [%.4f %.4f %.4f]\n", i, vel_top_angular[i+1].x(), vel_top_angular[i+1].y(), vel_top_angular[i+1].z());
-		//printf("v[%d] = [%.4f %.4f %.4f]\n", i, vel_bottom_linear[i+1].x(), vel_bottom_linear[i+1].y(), vel_bottom_linear[i+1].z());
-		//printf("c[%d] = [%.4f %.4f %.4f]\n", i, coriolis_bottom_linear[i].x(), coriolis_bottom_linear[i].y(), coriolis_bottom_linear[i].z());
+		//printf("w[%d] = [%.4f %.4f %.4f]\n", i, vel_top_angular[i+1].m_floats[0], vel_top_angular[i+1].m_floats[1], vel_top_angular[i+1].m_floats[2]);
+		//printf("v[%d] = [%.4f %.4f %.4f]\n", i, vel_bottom_linear[i+1].m_floats[0], vel_bottom_linear[i+1].m_floats[1], vel_bottom_linear[i+1].m_floats[2]);
+		//printf("c[%d] = [%.4f %.4f %.4f]\n", i, coriolis_bottom_linear[i].m_floats[0], coriolis_bottom_linear[i].m_floats[1], coriolis_bottom_linear[i].m_floats[2]);
 	}
 
 	// 'Downward' loop.
@@ -1199,7 +1199,7 @@ void btMultiBody::computeAccelerationsArticulatedBodyAlgorithmMultiDof(btScalar
 
 	/////////////////
 	//printf("q = [");
-	//printf("%.6f, %.6f, %.6f, %.6f, %.6f, %.6f, %.6f ", m_baseQuat.x(), m_baseQuat.y(), m_baseQuat.z(), m_baseQuat.w(), m_basePos.x(), m_basePos.y(), m_basePos.z());
+	//printf("%.6f, %.6f, %.6f, %.6f, %.6f, %.6f, %.6f ", m_baseQuat.m_floats[0], m_baseQuat.m_floats[1], m_baseQuat.m_floats[2], m_baseQuat.m_floats[3], m_basePos.m_floats[0], m_basePos.m_floats[1], m_basePos.m_floats[2]);
 	//for(int link = 0; link < getNumLinks(); ++link)
 	//	for(int dof = 0; dof < m_links[link].m_dofCount; ++dof)
 	//		printf("%.6f ", m_links[link].m_jointPos[dof]);
@@ -1657,10 +1657,10 @@ void btMultiBody::predictPositionsMultiDof(btScalar dt)
             }
             
             if (!baseBody)
-                quat = btQuaternion(axis.x(), axis.y(), axis.z(), btCos(fAngle * dt * btScalar(0.5))) * quat;
+                quat = btQuaternion(axis.m_floats[0], axis.m_floats[1], axis.m_floats[2], btCos(fAngle * dt * btScalar(0.5))) * quat;
             else
-                quat = quat * btQuaternion(-axis.x(), -axis.y(), -axis.z(), btCos(fAngle * dt * btScalar(0.5)));
-            //equivalent to: quat = (btQuaternion(axis.x(),axis.y(),axis.z(),btCos( fAngle*dt*btScalar(0.5) )) * quat.inverse()).inverse();
+                quat = quat * btQuaternion(-axis.m_floats[0], -axis.m_floats[1], -axis.m_floats[2], btCos(fAngle * dt * btScalar(0.5)));
+            //equivalent to: quat = (btQuaternion(axis.m_floats[0],axis.m_floats[1],axis.m_floats[2],btCos( fAngle*dt*btScalar(0.5) )) * quat.inverse()).inverse();
             
             quat.normalize();
         }
@@ -1687,10 +1687,10 @@ void btMultiBody::predictPositionsMultiDof(btScalar dt)
         btVector3 baseOmega;
         baseOmega.setValue(pBaseOmega[0], pBaseOmega[1], pBaseOmega[2]);
         pQuatUpdateFun(baseOmega, baseQuat, true, dt);
-        pBaseQuat[0] = baseQuat.x();
-        pBaseQuat[1] = baseQuat.y();
-        pBaseQuat[2] = baseQuat.z();
-        pBaseQuat[3] = baseQuat.w();
+        pBaseQuat[0] = baseQuat.m_floats[0];
+        pBaseQuat[1] = baseQuat.m_floats[1];
+        pBaseQuat[2] = baseQuat.m_floats[2];
+        pBaseQuat[3] = baseQuat.m_floats[3];
 		}
 
     // Finally we can update m_jointPos for each of the m_links
@@ -1758,10 +1758,10 @@ void btMultiBody::predictPositionsMultiDof(btScalar dt)
                     btQuaternion jointOri;
                     jointOri.setValue(pJointPos[0], pJointPos[1], pJointPos[2], pJointPos[3]);
                     pQuatUpdateFun(jointVel, jointOri, false, dt);
-                    pJointPos[0] = jointOri.x();
-                    pJointPos[1] = jointOri.y();
-                    pJointPos[2] = jointOri.z();
-                    pJointPos[3] = jointOri.w();
+                    pJointPos[0] = jointOri.m_floats[0];
+                    pJointPos[1] = jointOri.m_floats[1];
+                    pJointPos[2] = jointOri.m_floats[2];
+                    pJointPos[3] = jointOri.m_floats[3];
                     break;
                 }
                 case btMultibodyLink::ePlanar:
@@ -1842,10 +1842,10 @@ void btMultiBody::stepPositionsMultiDof(btScalar dt, btScalar *pq, btScalar *pqd
 			}
 
 			if (!baseBody)
-				quat = btQuaternion(axis.x(), axis.y(), axis.z(), btCos(fAngle * dt * btScalar(0.5))) * quat;
+				quat = btQuaternion(axis.m_floats[0], axis.m_floats[1], axis.m_floats[2], btCos(fAngle * dt * btScalar(0.5))) * quat;
 			else
-				quat = quat * btQuaternion(-axis.x(), -axis.y(), -axis.z(), btCos(fAngle * dt * btScalar(0.5)));
-			//equivalent to: quat = (btQuaternion(axis.x(),axis.y(),axis.z(),btCos( fAngle*dt*btScalar(0.5) )) * quat.inverse()).inverse();
+				quat = quat * btQuaternion(-axis.m_floats[0], -axis.m_floats[1], -axis.m_floats[2], btCos(fAngle * dt * btScalar(0.5)));
+			//equivalent to: quat = (btQuaternion(axis.m_floats[0],axis.m_floats[1],axis.m_floats[2],btCos( fAngle*dt*btScalar(0.5) )) * quat.inverse()).inverse();
 
 			quat.normalize();
 		}
@@ -1864,14 +1864,14 @@ void btMultiBody::stepPositionsMultiDof(btScalar dt, btScalar *pq, btScalar *pqd
 		btVector3 baseOmega;
 		baseOmega.setValue(pBaseOmega[0], pBaseOmega[1], pBaseOmega[2]);
 		pQuatUpdateFun(baseOmega, baseQuat, true, dt);
-		pBaseQuat[0] = baseQuat.x();
-		pBaseQuat[1] = baseQuat.y();
-		pBaseQuat[2] = baseQuat.z();
-		pBaseQuat[3] = baseQuat.w();
+		pBaseQuat[0] = baseQuat.m_floats[0];
+		pBaseQuat[1] = baseQuat.m_floats[1];
+		pBaseQuat[2] = baseQuat.m_floats[2];
+		pBaseQuat[3] = baseQuat.m_floats[3];
 
-		//printf("pBaseOmega = %.4f %.4f %.4f\n", pBaseOmega->x(), pBaseOmega->y(), pBaseOmega->z());
-		//printf("pBaseVel = %.4f %.4f %.4f\n", pBaseVel->x(), pBaseVel->y(), pBaseVel->z());
-		//printf("baseQuat = %.4f %.4f %.4f %.4f\n", pBaseQuat->x(), pBaseQuat->y(), pBaseQuat->z(), pBaseQuat->w());
+		//printf("pBaseOmega = %.4f %.4f %.4f\n", pBaseOmega->m_floats[0], pBaseOmega->m_floats[1], pBaseOmega->m_floats[2]);
+		//printf("pBaseVel = %.4f %.4f %.4f\n", pBaseVel->m_floats[0], pBaseVel->m_floats[1], pBaseVel->m_floats[2]);
+		//printf("baseQuat = %.4f %.4f %.4f %.4f\n", pBaseQuat->m_floats[0], pBaseQuat->m_floats[1], pBaseQuat->m_floats[2], pBaseQuat->m_floats[3]);
 	}
 
 	if (pq)
@@ -1907,10 +1907,10 @@ void btMultiBody::stepPositionsMultiDof(btScalar dt, btScalar *pq, btScalar *pqd
 					btQuaternion jointOri;
 					jointOri.setValue(pJointPos[0], pJointPos[1], pJointPos[2], pJointPos[3]);
 					pQuatUpdateFun(jointVel, jointOri, false, dt);
-					pJointPos[0] = jointOri.x();
-					pJointPos[1] = jointOri.y();
-					pJointPos[2] = jointOri.z();
-					pJointPos[3] = jointOri.w();
+					pJointPos[0] = jointOri.m_floats[0];
+					pJointPos[1] = jointOri.m_floats[1];
+					pJointPos[2] = jointOri.m_floats[2];
+					pJointPos[3] = jointOri.m_floats[3];
 					break;
 				}
 				case btMultibodyLink::ePlanar:
@@ -2165,7 +2165,7 @@ void btMultiBody::forwardKinematics(btAlignedObjectArray<btQuaternion> &world_to
 		int index = link + 1;
 
 		btVector3 posr = local_origin[index];
-		btScalar quat[4] = {-world_to_local[index].x(), -world_to_local[index].y(), -world_to_local[index].z(), world_to_local[index].w()};
+		btScalar quat[4] = {-world_to_local[index].m_floats[0], -world_to_local[index].m_floats[1], -world_to_local[index].m_floats[2], world_to_local[index].m_floats[3]};
 		btTransform tr;
 		tr.setIdentity();
 		tr.m_origin = (posr);
@@ -2185,8 +2185,8 @@ void btMultiBody::updateCollisionObjectWorldTransforms(btAlignedObjectArray<btQu
 	if (getBaseCollider())
 	{
 		btVector3 posr = local_origin[0];
-		//	float pos[4]={posr.x(),posr.y(),posr.z(),1};
-		btScalar quat[4] = {-world_to_local[0].x(), -world_to_local[0].y(), -world_to_local[0].z(), world_to_local[0].w()};
+		//	float pos[4]={posr.m_floats[0],posr.m_floats[1],posr.m_floats[2],1};
+		btScalar quat[4] = {-world_to_local[0].m_floats[0], -world_to_local[0].m_floats[1], -world_to_local[0].m_floats[2], world_to_local[0].m_floats[3]};
 		btTransform tr;
 		tr.setIdentity();
 		tr.m_origin = (posr);
@@ -2214,8 +2214,8 @@ void btMultiBody::updateCollisionObjectWorldTransforms(btAlignedObjectArray<btQu
 			int index = link + 1;
 
 			btVector3 posr = local_origin[index];
-			//			float pos[4]={posr.x(),posr.y(),posr.z(),1};
-			btScalar quat[4] = {-world_to_local[index].x(), -world_to_local[index].y(), -world_to_local[index].z(), world_to_local[index].w()};
+			//			float pos[4]={posr.m_floats[0],posr.m_floats[1],posr.m_floats[2],1};
+			btScalar quat[4] = {-world_to_local[index].m_floats[0], -world_to_local[index].m_floats[1], -world_to_local[index].m_floats[2], world_to_local[index].m_floats[3]};
 			btTransform tr;
 			tr.setIdentity();
 			tr.m_origin = (posr);
@@ -2245,8 +2245,8 @@ void btMultiBody::updateCollisionObjectInterpolationWorldTransforms(btAlignedObj
     if (getBaseCollider())
     {
         btVector3 posr = local_origin[0];
-        //    float pos[4]={posr.x(),posr.y(),posr.z(),1};
-        btScalar quat[4] = {-world_to_local[0].x(), -world_to_local[0].y(), -world_to_local[0].z(), world_to_local[0].w()};
+        //    float pos[4]={posr.m_floats[0],posr.m_floats[1],posr.m_floats[2],1};
+        btScalar quat[4] = {-world_to_local[0].m_floats[0], -world_to_local[0].m_floats[1], -world_to_local[0].m_floats[2], world_to_local[0].m_floats[3]};
         btTransform tr;
         tr.setIdentity();
         tr.m_origin = (posr);
@@ -2273,8 +2273,8 @@ void btMultiBody::updateCollisionObjectInterpolationWorldTransforms(btAlignedObj
             int index = link + 1;
             
             btVector3 posr = local_origin[index];
-            //            float pos[4]={posr.x(),posr.y(),posr.z(),1};
-            btScalar quat[4] = {-world_to_local[index].x(), -world_to_local[index].y(), -world_to_local[index].z(), world_to_local[index].w()};
+            //            float pos[4]={posr.m_floats[0],posr.m_floats[1],posr.m_floats[2],1};
+            btScalar quat[4] = {-world_to_local[index].m_floats[0], -world_to_local[index].m_floats[1], -world_to_local[index].m_floats[2], world_to_local[index].m_floats[3]};
             btTransform tr;
             tr.setIdentity();
             tr.m_origin = (posr);

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

@@ -418,13 +418,13 @@ void btMultiBodyDynamicsWorld::solveExternalForces(btContactSolverInfo& solverIn
                         
                         /////
                         //copy q0 to scratch_q0 and qd0 to scratch_qd0
-                        scratch_q0[0] = bod->getWorldToBaseRot().x();
-                        scratch_q0[1] = bod->getWorldToBaseRot().y();
-                        scratch_q0[2] = bod->getWorldToBaseRot().z();
-                        scratch_q0[3] = bod->getWorldToBaseRot().w();
-                        scratch_q0[4] = bod->getBasePos().x();
-                        scratch_q0[5] = bod->getBasePos().y();
-                        scratch_q0[6] = bod->getBasePos().z();
+                        scratch_q0[0] = bod->getWorldToBaseRot().m_floats[0];
+                        scratch_q0[1] = bod->getWorldToBaseRot().m_floats[1];
+                        scratch_q0[2] = bod->getWorldToBaseRot().m_floats[2];
+                        scratch_q0[3] = bod->getWorldToBaseRot().m_floats[3];
+                        scratch_q0[4] = bod->getBasePos().m_floats[0];
+                        scratch_q0[5] = bod->getBasePos().m_floats[1];
+                        scratch_q0[6] = bod->getBasePos().m_floats[2];
                         //
                         for (int link = 0; link < bod->getNumLinks(); ++link)
                         {

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

@@ -165,7 +165,7 @@ void btMultiBodySphericalJointLimit::createConstraintRows(btMultiBodyConstraintA
 		qMinTwist = -(qABTwist);
 		twistAngle = qMinTwist.getAngle();
 	}
-	btVector3 vTwistAxis = btVector3(qMinTwist.x(), qMinTwist.y(), qMinTwist.z());
+	btVector3 vTwistAxis = btVector3(qMinTwist.m_floats[0], qMinTwist.m_floats[1], qMinTwist.m_floats[2]);
 	if (twistAngle > SIMD_EPSILON)
 		vTwistAxis.normalize();
 	

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

@@ -238,20 +238,20 @@ class btReducedDeformableBody : public btSoftBody
 
   #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0
   void clampVelocity(btVector3& v) const {
-      v.setX(
+      v.m_floats[0] = (
           fmax(-BT_CLAMP_VELOCITY_TO,
-                fmin(BT_CLAMP_VELOCITY_TO, v.getX()))
+                fmin(BT_CLAMP_VELOCITY_TO, v.m_floats[0]))
       );
-      v.setY(
+      v.m_floats[1] = (
           fmax(-BT_CLAMP_VELOCITY_TO,
-                fmin(BT_CLAMP_VELOCITY_TO, v.getY()))
+                fmin(BT_CLAMP_VELOCITY_TO, v.m_floats[1]))
       );
-      v.setZ(
+      v.m_floats[2] = (
           fmax(-BT_CLAMP_VELOCITY_TO,
-                fmin(BT_CLAMP_VELOCITY_TO, v.getZ()))
+                fmin(BT_CLAMP_VELOCITY_TO, v.m_floats[2]))
       );
   }
   #endif
 };
 
-#endif // BT_REDUCED_SOFT_BODY_H
+#endif // BT_REDUCED_SOFT_BODY_H

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

@@ -64,12 +64,12 @@ btReducedDeformableBody* btReducedDeformableBodyHelpers::createFromVtkFile(btSof
 		{
 			btScalar p;
 			ss >> p;
-			position.setX(p);
+			position.m_floats[0] = (p);
 			ss >> p;
-			position.setY(p);
+			position.m_floats[1] = (p);
 			ss >> p;
-			position.setZ(p);
-			//printf("v %f %f %f\n", position.getX(), position.getY(), position.getZ());
+			position.m_floats[2] = (p);
+			//printf("v %f %f %f\n", position.m_floats[0], position.m_floats[1], position.m_floats[2]);
 			X[x_count++] = position;
 		}
 		else if (reading_tets)

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

@@ -97,9 +97,9 @@ void btDefaultSoftBodySolver::copySoftBodyToVertexBuffer(const btSoftBody *const
 			for (int vertexIndex = 0; vertexIndex < numVertices; ++vertexIndex)
 			{
 				btVector3 position = clothVertices[vertexIndex].m_x;
-				*(vertexPointer + 0) = (float)position.getX();
-				*(vertexPointer + 1) = (float)position.getY();
-				*(vertexPointer + 2) = (float)position.getZ();
+				*(vertexPointer + 0) = (float)position.m_floats[0];
+				*(vertexPointer + 1) = (float)position.m_floats[1];
+				*(vertexPointer + 2) = (float)position.m_floats[2];
 				vertexPointer += vertexStride;
 			}
 		}
@@ -112,9 +112,9 @@ void btDefaultSoftBodySolver::copySoftBodyToVertexBuffer(const btSoftBody *const
 			for (int vertexIndex = 0; vertexIndex < numVertices; ++vertexIndex)
 			{
 				btVector3 normal = clothVertices[vertexIndex].m_n;
-				*(normalPointer + 0) = (float)normal.getX();
-				*(normalPointer + 1) = (float)normal.getY();
-				*(normalPointer + 2) = (float)normal.getZ();
+				*(normalPointer + 0) = (float)normal.m_floats[0];
+				*(normalPointer + 1) = (float)normal.m_floats[1];
+				*(normalPointer + 2) = (float)normal.m_floats[2];
 				normalPointer += normalStride;
 			}
 		}

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

@@ -574,9 +574,9 @@ void btDeformableBodySolver::applyTransforms(btScalar timeStep)
 					btScalar* u_t1 = &jacobianData_t1.m_deltaVelocitiesUnitImpulse[0];
 					btScalar* u_t2 = &jacobianData_t2.m_deltaVelocitiesUnitImpulse[0];
 
-					btMatrix3x3 rot(normal.getX(), normal.getY(), normal.getZ(),
-									t1.getX(), t1.getY(), t1.getZ(),
-									t2.getX(), t2.getY(), t2.getZ());  // world frame to local frame
+					btMatrix3x3 rot(normal.m_floats[0], normal.m_floats[1], normal.m_floats[2],
+									t1.m_floats[0], t1.m_floats[1], t1.m_floats[2],
+									t2.m_floats[0], t2.m_floats[1], t2.m_floats[2]);  // world frame to local frame
 					const int ndof = multibodyLinkCol->m_multiBody->getNumDofs() + 6;
 					btMatrix3x3 local_impulse_matrix = (Diagonal(n->m_im) + OuterProduct(J_n, J_t1, J_t2, u_n, u_t1, u_t2, ndof)).inverse();
 					a.m_c0 = rot.transpose() * local_impulse_matrix * rot;

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

@@ -160,9 +160,9 @@ public:
 		// populate dx with random vectors
 		for (int i = 0; i < dx.size(); ++i)
 		{
-			dx[i].setX(randomDouble(-1, 1));
-			dx[i].setY(randomDouble(-1, 1));
-			dx[i].setZ(randomDouble(-1, 1));
+			dx[i].m_floats[0] = (randomDouble(-1, 1));
+			dx[i].m_floats[1] = (randomDouble(-1, 1));
+			dx[i].m_floats[2] = (randomDouble(-1, 1));
 		}
 
 		btAlignedObjectArray<double> errors;
@@ -269,9 +269,9 @@ public:
 		// populate dx with random vectors
 		for (int i = 0; i < dx.size(); ++i)
 		{
-			dx[i].setX(randomDouble(-1, 1));
-			dx[i].setY(randomDouble(-1, 1));
-			dx[i].setZ(randomDouble(-1, 1));
+			dx[i].m_floats[0] = (randomDouble(-1, 1));
+			dx[i].m_floats[1] = (randomDouble(-1, 1));
+			dx[i].m_floats[2] = (randomDouble(-1, 1));
 		}
 
 		btAlignedObjectArray<double> errors;

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

@@ -324,10 +324,10 @@ void btSoftBody::appendNote(const char* text,
 	n.m_rank = 0;
 	n.m_text = text;
 	n.m_offset = o;
-	n.m_coords[0] = c.x();
-	n.m_coords[1] = c.y();
-	n.m_coords[2] = c.z();
-	n.m_coords[3] = c.w();
+	n.m_coords[0] = c.m_floats[0];
+	n.m_coords[1] = c.m_floats[1];
+	n.m_coords[2] = c.m_floats[2];
+	n.m_coords[3] = c.m_floats[3];
 	n.m_nodes[0] = n0;
 	n.m_rank += n0 ? 1 : 0;
 	n.m_nodes[1] = n1;
@@ -619,9 +619,9 @@ void btSoftBody::appendDeformableAnchor(int node, btMultiBodyLinkCollider* link)
 	btScalar* u_t1 = &jacobianData_t1.m_deltaVelocitiesUnitImpulse[0];
 	btScalar* u_t2 = &jacobianData_t2.m_deltaVelocitiesUnitImpulse[0];
 
-	btMatrix3x3 rot(normal.getX(), normal.getY(), normal.getZ(),
-					t1.getX(), t1.getY(), t1.getZ(),
-					t2.getX(), t2.getY(), t2.getZ());  // world frame to local frame
+	btMatrix3x3 rot(normal.m_floats[0], normal.m_floats[1], normal.m_floats[2],
+					t1.m_floats[0], t1.m_floats[1], t1.m_floats[2],
+					t2.m_floats[0], t2.m_floats[1], t2.m_floats[2]);  // world frame to local frame
 	const int ndof = link->m_multiBody->getNumDofs() + 6;
 	btMatrix3x3 local_impulse_matrix = (Diagonal(n.m_im) + OuterProduct(J_n, J_t1, J_t2, u_n, u_t1, u_t2, ndof)).inverse();
 	c.m_c0 = rot.transpose() * local_impulse_matrix * rot;
@@ -1221,9 +1221,9 @@ void btSoftBody::setPose(bool bvolume, bool bframe)
 	{
 		const btVector3& q = m_pose.m_pos[i];
 		const btVector3 mq = m_pose.m_wgh[i] * q;
-		m_pose.m_aqq[0] += mq.x() * q;
-		m_pose.m_aqq[1] += mq.y() * q;
-		m_pose.m_aqq[2] += mq.z() * q;
+		m_pose.m_aqq[0] += mq.m_floats[0] * q;
+		m_pose.m_aqq[1] += mq.m_floats[1] * q;
+		m_pose.m_aqq[2] += mq.m_floats[2] * q;
 	}
 	m_pose.m_aqq = m_pose.m_aqq.inverse();
 
@@ -2819,15 +2819,15 @@ static void getBarycentric(const btVector3& p, const btVector3& a, const btVecto
 	// In the case of a degenerate triangle, pick a vertex.
 	if (btFabs(denom) < SIMD_EPSILON) 
 	{
-		bary.setY(btScalar(0.0));
-		bary.setZ(btScalar(0.0));
+		bary.m_floats[1] = (btScalar(0.0));
+		bary.m_floats[2] = (btScalar(0.0));
 	} 
 	else 
 	{
-		bary.setY((d11 * d20 - d01 * d21) / denom);
-		bary.setZ((d00 * d21 - d01 * d20) / denom);
+		bary.m_floats[1] = ((d11 * d20 - d01 * d21) / denom);
+		bary.m_floats[2] = ((d00 * d21 - d01 * d20) / denom);
   	}
-	bary.setX(btScalar(1) - bary.getY() - bary.getZ());
+	bary.m_floats[0] = (btScalar(1) - bary.m_floats[1] - bary.m_floats[2]);
 }
 
 //
@@ -3058,16 +3058,16 @@ void btSoftBody::updatePose()
 		btMatrix3x3 Apq;
 		const btScalar eps = SIMD_EPSILON;
 		Apq[0] = Apq[1] = Apq[2] = btVector3(0, 0, 0);
-		Apq[0].setX(eps);
-		Apq[1].setY(eps * 2);
-		Apq[2].setZ(eps * 3);
+		Apq[0].m_floats[0] = (eps);
+		Apq[1].m_floats[1] = (eps * 2);
+		Apq[2].m_floats[2] = (eps * 3);
 		for (int i = 0, ni = m_nodes.size(); i < ni; ++i)
 		{
 			const btVector3 a = pose.m_wgh[i] * (m_nodes[i].m_x - com);
 			const btVector3& b = pose.m_pos[i];
-			Apq[0] += a.x() * b;
-			Apq[1] += a.y() * b;
-			Apq[2] += a.z() * b;
+			Apq[0] += a.m_floats[0] * b;
+			Apq[1] += a.m_floats[1] * b;
+			Apq[2] += a.m_floats[2] * b;
 		}
 		btMatrix3x3 r, s;
 		PolarDecompose(Apq, r, s);
@@ -3488,9 +3488,9 @@ void btSoftBody::initializeDmInverse()
 		btVector3 c1 = t.m_n[1]->m_x - t.m_n[0]->m_x;
 		btVector3 c2 = t.m_n[2]->m_x - t.m_n[0]->m_x;
 		btVector3 c3 = t.m_n[3]->m_x - t.m_n[0]->m_x;
-		btMatrix3x3 Dm(c1.getX(), c2.getX(), c3.getX(),
-					   c1.getY(), c2.getY(), c3.getY(),
-					   c1.getZ(), c2.getZ(), c3.getZ());
+		btMatrix3x3 Dm(c1.m_floats[0], c2.m_floats[0], c3.m_floats[0],
+					   c1.m_floats[1], c2.m_floats[1], c3.m_floats[1],
+					   c1.m_floats[2], c2.m_floats[2], c3.m_floats[2]);
 		t.m_element_measure = Dm.determinant() * unit_simplex_measure;
 		t.m_Dm_inverse = Dm.inverse();
 
@@ -3539,16 +3539,16 @@ void btSoftBody::updateDeformation()
 		btVector3 c1 = t.m_n[1]->m_q - t.m_n[0]->m_q;
 		btVector3 c2 = t.m_n[2]->m_q - t.m_n[0]->m_q;
 		btVector3 c3 = t.m_n[3]->m_q - t.m_n[0]->m_q;
-		btMatrix3x3 Ds(c1.getX(), c2.getX(), c3.getX(),
-					   c1.getY(), c2.getY(), c3.getY(),
-					   c1.getZ(), c2.getZ(), c3.getZ());
+		btMatrix3x3 Ds(c1.m_floats[0], c2.m_floats[0], c3.m_floats[0],
+					   c1.m_floats[1], c2.m_floats[1], c3.m_floats[1],
+					   c1.m_floats[2], c2.m_floats[2], c3.m_floats[2]);
 		t.m_F = Ds * t.m_Dm_inverse;
 
 		btSoftBody::TetraScratch& s = m_tetraScratches[i];
 		s.m_F = t.m_F;
 		s.m_J = t.m_F.determinant();
 		btMatrix3x3 C = t.m_F.transpose() * t.m_F;
-		s.m_trace = C[0].getX() + C[1].getY() + C[2].getZ();
+		s.m_trace = C[0].m_floats[0] + C[1].m_floats[1] + C[2].m_floats[2];
 		s.m_cofF = t.m_F.adjoint().transpose();
 
 		btVector3 a = t.m_n[0]->m_q;
@@ -3713,8 +3713,8 @@ void btSoftBody::CJoint::Solve(btScalar dt, btScalar sor)
 
 	if (m_bodies[0].m_soft == m_bodies[1].m_soft)
 	{
-		if ((impulse.m_velocity.getX() == impulse.m_velocity.getX()) && (impulse.m_velocity.getY() == impulse.m_velocity.getY()) &&
-			(impulse.m_velocity.getZ() == impulse.m_velocity.getZ()))
+		if ((impulse.m_velocity.m_floats[0] == impulse.m_velocity.m_floats[0]) && (impulse.m_velocity.m_floats[1] == impulse.m_velocity.m_floats[1]) &&
+			(impulse.m_velocity.m_floats[2] == impulse.m_velocity.m_floats[2]))
 		{
 			if (impulse.m_asVelocity)
 			{
@@ -3994,9 +3994,9 @@ void btSoftBody::PSolve_SContacts(btSoftBody* psb, btScalar, btScalar ti)
 		}
 		corr -= ProjectOnPlane(vr, nr) * c.m_friction;
 		n.m_x += corr * c.m_cfm[0];
-		f.m_n[0]->m_x -= corr * (c.m_cfm[1] * c.m_weights.x());
-		f.m_n[1]->m_x -= corr * (c.m_cfm[1] * c.m_weights.y());
-		f.m_n[2]->m_x -= corr * (c.m_cfm[1] * c.m_weights.z());
+		f.m_n[0]->m_x -= corr * (c.m_cfm[1] * c.m_weights.m_floats[0]);
+		f.m_n[1]->m_x -= corr * (c.m_cfm[1] * c.m_weights.m_floats[1]);
+		f.m_n[2]->m_x -= corr * (c.m_cfm[1] * c.m_weights.m_floats[2]);
 	}
 }
 

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

@@ -588,12 +588,12 @@ public:
 		{
 			if (impulse.m_asVelocity)
 			{
-				//				printf("impulse.m_velocity = %f,%f,%f\n",impulse.m_velocity.getX(),impulse.m_velocity.getY(),impulse.m_velocity.getZ());
+				//				printf("impulse.m_velocity = %f,%f,%f\n",impulse.m_velocity.m_floats[0],impulse.m_velocity.m_floats[1],impulse.m_velocity.m_floats[2]);
 				applyVImpulse(impulse.m_velocity, rpos);
 			}
 			if (impulse.m_asDrift)
 			{
-				//				printf("impulse.m_drift = %f,%f,%f\n",impulse.m_drift.getX(),impulse.m_drift.getY(),impulse.m_drift.getZ());
+				//				printf("impulse.m_drift = %f,%f,%f\n",impulse.m_drift.m_floats[0],impulse.m_drift.m_floats[1],impulse.m_drift.m_floats[2]);
 				applyDImpulse(impulse.m_drift, rpos);
 			}
 		}
@@ -1313,7 +1313,7 @@ public:
 							 const T& c,
 							 const btVector3& coord)
 	{
-		return (a * coord.x() + b * coord.y() + c * coord.z());
+		return (a * coord.m_floats[0] + b * coord.m_floats[1] + c * coord.m_floats[2]);
 	}
 
 	void applyRepulsionForce(btScalar timeStep, bool applySpringForce)

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

@@ -138,7 +138,7 @@ void btSoftBodyTriangleCallback::processTriangle(btVector3* triangle, int partId
 							triangle[1] - normal,
 							triangle[2] - normal};
 
-		btConvexHullShape* tm = new btConvexHullShape(&pts[0].getX(), 6);
+		btConvexHullShape* tm = new btConvexHullShape(&pts[0].m_floats[0], 6);
 
 		//		btBU_Simplex1to4 tm(triangle[0],triangle[1],triangle[2],other);
 

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

@@ -42,14 +42,14 @@ static void drawBox(btIDebugDraw* idraw,
 					const btVector3& maxs,
 					const btVector3& color)
 {
-	const btVector3 c[] = {btVector3(mins.x(), mins.y(), mins.z()),
-						   btVector3(maxs.x(), mins.y(), mins.z()),
-						   btVector3(maxs.x(), maxs.y(), mins.z()),
-						   btVector3(mins.x(), maxs.y(), mins.z()),
-						   btVector3(mins.x(), mins.y(), maxs.z()),
-						   btVector3(maxs.x(), mins.y(), maxs.z()),
-						   btVector3(maxs.x(), maxs.y(), maxs.z()),
-						   btVector3(mins.x(), maxs.y(), maxs.z())};
+	const btVector3 c[] = {btVector3(mins.m_floats[0], mins.m_floats[1], mins.m_floats[2]),
+						   btVector3(maxs.m_floats[0], mins.m_floats[1], mins.m_floats[2]),
+						   btVector3(maxs.m_floats[0], maxs.m_floats[1], mins.m_floats[2]),
+						   btVector3(mins.m_floats[0], maxs.m_floats[1], mins.m_floats[2]),
+						   btVector3(mins.m_floats[0], mins.m_floats[1], maxs.m_floats[2]),
+						   btVector3(maxs.m_floats[0], mins.m_floats[1], maxs.m_floats[2]),
+						   btVector3(maxs.m_floats[0], maxs.m_floats[1], maxs.m_floats[2]),
+						   btVector3(mins.m_floats[0], maxs.m_floats[1], maxs.m_floats[2])};
 	idraw->drawLine(c[0], c[1], color);
 	idraw->drawLine(c[1], c[2], color);
 	idraw->drawLine(c[2], c[3], color);
@@ -205,7 +205,7 @@ void btSoftBodyHelpers::Draw(btSoftBody* psb,
 				int count = vertices.size();
 				btScalar shrink = 0.f;
 				btScalar shrinkClamp = 0.f;
-				computer.compute(&vertices[0].getX(), stride, count, shrink, shrinkClamp);
+				computer.compute(&vertices[0].m_floats[0], stride, count, shrink, shrinkClamp);
 				for (int i = 0; i < computer.faces.size(); i++)
 				{
 					int face = computer.faces[i];
@@ -750,10 +750,10 @@ btSoftBody* btSoftBodyHelpers::CreatePatch(btSoftBodyWorldInfo& worldInfo, const
 			const btScalar tx = ix / (btScalar)(rx - 1);
 			btScalar pert = perturbation * btScalar(rand()) / RAND_MAX;
 			btVector3 temp1 = py1;
-			temp1.setY(py1.getY() + pert);
+			temp1.m_floats[1] = (py1.m_floats[1] + pert);
 			btVector3 temp = py0;
 			pert = perturbation * btScalar(rand()) / RAND_MAX;
-			temp.setY(py0.getY() + pert);
+			temp.m_floats[1] = (py0.m_floats[1] + pert);
 			x[IDX(ix, iy)] = lerp(temp, temp1, tx);
 			m[IDX(ix, iy)] = 1;
 		}
@@ -1173,9 +1173,9 @@ btSoftBody* btSoftBodyHelpers::CreateFromTetGenData(btSoftBodyWorldInfo& worldIn
 		//if(hasbounds)
 		//	sn>>bound;
 
-		pos[index].setX(btScalar(x));
-		pos[index].setY(btScalar(y));
-		pos[index].setZ(btScalar(z));
+		pos[index].m_floats[0] = (btScalar(x));
+		pos[index].m_floats[1] = (btScalar(y));
+		pos[index].m_floats[2] = (btScalar(z));
 	}
 	btSoftBody* psb = new btSoftBody(&worldInfo, nnode, &pos[0], 0);
 #if 0
@@ -1292,12 +1292,12 @@ btSoftBody* btSoftBodyHelpers::CreateFromVtkFile(btSoftBodyWorldInfo& worldInfo,
 		{
 			btScalar p;
 			ss >> p;
-			position.setX(p);
+			position.m_floats[0] = (p);
 			ss >> p;
-			position.setY(p);
+			position.m_floats[1] = (p);
 			ss >> p;
-			position.setZ(p);
-			//printf("v %f %f %f\n", position.getX(), position.getY(), position.getZ());
+			position.m_floats[2] = (p);
+			//printf("v %f %f %f\n", position.m_floats[0], position.m_floats[1], position.m_floats[2]);
 			X[x_count++] = position;
 		}
 		else if (reading_tets)

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

@@ -46,9 +46,9 @@ static SIMD_FORCE_INLINE void findJacobian(const btMultiBodyLinkCollider* multib
 }
 static SIMD_FORCE_INLINE btVector3 generateUnitOrthogonalVector(const btVector3& u)
 {
-	btScalar ux = u.getX();
-	btScalar uy = u.getY();
-	btScalar uz = u.getZ();
+	btScalar ux = u.m_floats[0];
+	btScalar uy = u.m_floats[1];
+	btScalar uz = u.m_floats[2];
 	btScalar ax = std::abs(ux);
 	btScalar ay = std::abs(uy);
 	btScalar az = std::abs(uz);
@@ -686,14 +686,14 @@ public:
 		/* t is usually identity, except when colliding against btCompoundShape. See Issue 512 */
 		const btVector3 mins = m_body->m_bounds[0];
 		const btVector3 maxs = m_body->m_bounds[1];
-		const btVector3 crns[] = {t * btVector3(mins.x(), mins.y(), mins.z()),
-								  t * btVector3(maxs.x(), mins.y(), mins.z()),
-								  t * btVector3(maxs.x(), maxs.y(), mins.z()),
-								  t * btVector3(mins.x(), maxs.y(), mins.z()),
-								  t * btVector3(mins.x(), mins.y(), maxs.z()),
-								  t * btVector3(maxs.x(), mins.y(), maxs.z()),
-								  t * btVector3(maxs.x(), maxs.y(), maxs.z()),
-								  t * btVector3(mins.x(), maxs.y(), maxs.z())};
+		const btVector3 crns[] = {t * btVector3(mins.m_floats[0], mins.m_floats[1], mins.m_floats[2]),
+								  t * btVector3(maxs.m_floats[0], mins.m_floats[1], mins.m_floats[2]),
+								  t * btVector3(maxs.m_floats[0], maxs.m_floats[1], mins.m_floats[2]),
+								  t * btVector3(mins.m_floats[0], maxs.m_floats[1], mins.m_floats[2]),
+								  t * btVector3(mins.m_floats[0], mins.m_floats[1], maxs.m_floats[2]),
+								  t * btVector3(maxs.m_floats[0], mins.m_floats[1], maxs.m_floats[2]),
+								  t * btVector3(maxs.m_floats[0], maxs.m_floats[1], maxs.m_floats[2]),
+								  t * btVector3(mins.m_floats[0], maxs.m_floats[1], maxs.m_floats[2])};
 		aabbMin = aabbMax = crns[0];
 		for (int i = 1; i < 8; ++i)
 		{
@@ -873,12 +873,12 @@ static inline btScalar ClusterMetric(const btVector3& x, const btVector3& y)
 //
 static inline btMatrix3x3 ScaleAlongAxis(const btVector3& a, btScalar s)
 {
-	const btScalar xx = a.x() * a.x();
-	const btScalar yy = a.y() * a.y();
-	const btScalar zz = a.z() * a.z();
-	const btScalar xy = a.x() * a.y();
-	const btScalar yz = a.y() * a.z();
-	const btScalar zx = a.z() * a.x();
+	const btScalar xx = a.m_floats[0] * a.m_floats[0];
+	const btScalar yy = a.m_floats[1] * a.m_floats[1];
+	const btScalar zz = a.m_floats[2] * a.m_floats[2];
+	const btScalar xy = a.m_floats[0] * a.m_floats[1];
+	const btScalar yz = a.m_floats[1] * a.m_floats[2];
+	const btScalar zx = a.m_floats[2] * a.m_floats[0];
 	btMatrix3x3 m;
 	m[0] = btVector3(1 - xx + xx * s, xy * s - xy, zx * s - zx);
 	m[1] = btVector3(xy * s - xy, 1 - yy + yy * s, yz * s - yz);
@@ -889,9 +889,9 @@ static inline btMatrix3x3 ScaleAlongAxis(const btVector3& a, btScalar s)
 static inline btMatrix3x3 Cross(const btVector3& v)
 {
 	btMatrix3x3 m;
-	m[0] = btVector3(0, -v.z(), +v.y());
-	m[1] = btVector3(+v.z(), 0, -v.x());
-	m[2] = btVector3(-v.y(), +v.x(), 0);
+	m[0] = btVector3(0, -v.m_floats[2], +v.m_floats[1]);
+	m[1] = btVector3(+v.m_floats[2], 0, -v.m_floats[0]);
+	m[2] = btVector3(-v.m_floats[1], +v.m_floats[0], 0);
 	return (m);
 }
 //
@@ -907,9 +907,9 @@ static inline btMatrix3x3 Diagonal(btScalar x)
 static inline btMatrix3x3 Diagonal(const btVector3& v)
 {
 	btMatrix3x3 m;
-	m[0] = btVector3(v.getX(), 0, 0);
-	m[1] = btVector3(0, v.getY(), 0);
-	m[2] = btVector3(0, 0, v.getZ());
+	m[0] = btVector3(v.m_floats[0], 0, 0);
+	m[1] = btVector3(0, v.m_floats[1], 0);
+	m[2] = btVector3(0, 0, v.m_floats[2]);
 	return (m);
 }
 
@@ -1180,7 +1180,7 @@ static inline T BaryEval(const T& a,
 						 const T& c,
 						 const btVector3& coord)
 {
-	return (a * coord.x() + b * coord.y() + c * coord.z());
+	return (a * coord.m_floats[0] + b * coord.m_floats[1] + c * coord.m_floats[2]);
 }
 //
 static inline btVector3 BaryCoord(const btVector3& a,
@@ -1472,7 +1472,7 @@ struct btSoftColliders
 				joint.m_drift = depth * norm;
 
 				joint.m_normal = norm;
-				//				printf("normal=%f,%f,%f\n",res.normal.getX(),res.normal.getY(),res.normal.getZ());
+				//				printf("normal=%f,%f,%f\n",res.normal.m_floats[0],res.normal.m_floats[1],res.normal.m_floats[2]);
 				joint.m_delete = false;
 				joint.m_friction = fv.length2() < (rvac * friction * rvac * friction) ? 1 : friction;
 				joint.m_massmatrix = ImpulseMatrix(ba.invMass(), ba.invWorldInertia(), joint.m_rpos[0],
@@ -1727,9 +1727,9 @@ struct btSoftColliders
 								btScalar* u_t1 = &jacobianData_t1.m_deltaVelocitiesUnitImpulse[0];
 								btScalar* u_t2 = &jacobianData_t2.m_deltaVelocitiesUnitImpulse[0];
 
-								btMatrix3x3 rot(normal.getX(), normal.getY(), normal.getZ(),
-												t1.getX(), t1.getY(), t1.getZ(),
-												t2.getX(), t2.getY(), t2.getZ());  // world frame to local frame
+								btMatrix3x3 rot(normal.m_floats[0], normal.m_floats[1], normal.m_floats[2],
+												t1.m_floats[0], t1.m_floats[1], t1.m_floats[2],
+												t2.m_floats[0], t2.m_floats[1], t2.m_floats[2]);  // world frame to local frame
 								const int ndof = multibodyLinkCol->m_multiBody->getNumDofs() + 6;
 								
 								btMatrix3x3 local_impulse_matrix;
@@ -1801,7 +1801,7 @@ struct btSoftColliders
 					const btScalar fc = psb->m_cfg.kDF * m_colObj1Wrap->getCollisionObject()->getFriction();
 
 					// the effective inverse mass of the face as in https://graphics.stanford.edu/papers/cloth-sig02/cloth.pdf
-					ima = bary.getX() * c.m_weights.getX() * n0->m_im + bary.getY() * c.m_weights.getY() * n1->m_im + bary.getZ() * c.m_weights.getZ() * n2->m_im;
+					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;
@@ -1838,9 +1838,9 @@ struct btSoftColliders
 							btScalar* u_t1 = &jacobianData_t1.m_deltaVelocitiesUnitImpulse[0];
 							btScalar* u_t2 = &jacobianData_t2.m_deltaVelocitiesUnitImpulse[0];
 
-							btMatrix3x3 rot(normal.getX(), normal.getY(), normal.getZ(),
-											t1.getX(), t1.getY(), t1.getZ(),
-											t2.getX(), t2.getY(), t2.getZ());  // world frame to local frame
+							btMatrix3x3 rot(normal.m_floats[0], normal.m_floats[1], normal.m_floats[2],
+											t1.m_floats[0], t1.m_floats[1], t1.m_floats[2],
+											t2.m_floats[0], t2.m_floats[1], t2.m_floats[2]);  // world frame to local frame
 							const int ndof = multibodyLinkCol->m_multiBody->getNumDofs() + 6;
 							btMatrix3x3 local_impulse_matrix = (Diagonal(ima) + OuterProduct(J_n, J_t1, J_t2, u_n, u_t1, u_t2, ndof)).inverse();
 							c.m_c0 = rot.transpose() * local_impulse_matrix * rot;

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

@@ -200,9 +200,9 @@ struct btSparseSdf
 	{
 		/* Lookup cell			*/
 		const btVector3 scx = x / voxelsz;
-		const IntFrac ix = Decompose(scx.x());
-		const IntFrac iy = Decompose(scx.y());
-		const IntFrac iz = Decompose(scx.z());
+		const IntFrac ix = Decompose(scx.m_floats[0]);
+		const IntFrac iy = Decompose(scx.m_floats[1]);
+		const IntFrac iz = Decompose(scx.m_floats[2]);
 		const unsigned h = Hash(ix.b, iy.b, iz.b, shape);
 		Cell*& root = cells[static_cast<int>(h % cells.size())];
 		Cell* c = root;
@@ -268,11 +268,11 @@ struct btSparseSdf
 							   d[7] - d[4], d[6] - d[5]};
 		const btScalar gz[] = {d[4] - d[0], d[5] - d[1],
 							   d[7] - d[3], d[6] - d[2]};
-		normal.setX(Lerp(Lerp(gx[0], gx[1], iy.f),
+		normal.m_floats[0] = (Lerp(Lerp(gx[0], gx[1], iy.f),
 						 Lerp(gx[2], gx[3], iy.f), iz.f));
-		normal.setY(Lerp(Lerp(gy[0], gy[1], ix.f),
+		normal.m_floats[1] = (Lerp(Lerp(gy[0], gy[1], ix.f),
 						 Lerp(gy[2], gy[3], ix.f), iz.f));
-		normal.setZ(Lerp(Lerp(gz[0], gz[1], ix.f),
+		normal.m_floats[2] = (Lerp(Lerp(gz[0], gz[1], ix.f),
 						 Lerp(gz[2], gz[3], ix.f), iy.f));
 		normal.safeNormalize();
 #else
@@ -294,13 +294,13 @@ struct btSparseSdf
 							  CELLSIZE * voxelsz;
 		for (int k = 0; k <= CELLSIZE; ++k)
 		{
-			const btScalar z = voxelsz * k + org.z();
+			const btScalar z = voxelsz * k + org.m_floats[2];
 			for (int j = 0; j <= CELLSIZE; ++j)
 			{
-				const btScalar y = voxelsz * j + org.y();
+				const btScalar y = voxelsz * j + org.m_floats[1];
 				for (int i = 0; i <= CELLSIZE; ++i)
 				{
-					const btScalar x = voxelsz * i + org.x();
+					const btScalar x = voxelsz * i + org.m_floats[0];
 					c.d[i][j][k] = DistanceToShape(btVector3(x, y, z),
 												   c.pclient);
 				}

3rdparty/bullet3/src/LinearMath/btAabbUtil2.h

@@ -33,9 +33,9 @@ SIMD_FORCE_INLINE bool TestPointAgainstAabb2(const btVector3& aabbMin1, const bt
 											 const btVector3& point)
 {
 	bool overlap = true;
-	overlap = (aabbMin1.getX() > point.getX() || aabbMax1.getX() < point.getX()) ? false : overlap;
-	overlap = (aabbMin1.getZ() > point.getZ() || aabbMax1.getZ() < point.getZ()) ? false : overlap;
-	overlap = (aabbMin1.getY() > point.getY() || aabbMax1.getY() < point.getY()) ? false : overlap;
+	overlap = (aabbMin1.m_floats[0] > point.m_floats[0] || aabbMax1.m_floats[0] < point.m_floats[0]) ? false : overlap;
+	overlap = (aabbMin1.m_floats[2] > point.m_floats[2] || aabbMax1.m_floats[2] < point.m_floats[2]) ? false : overlap;
+	overlap = (aabbMin1.m_floats[1] > point.m_floats[1] || aabbMax1.m_floats[1] < point.m_floats[1]) ? false : overlap;
 	return overlap;
 }
 
@@ -44,9 +44,9 @@ SIMD_FORCE_INLINE bool TestAabbAgainstAabb2(const btVector3& aabbMin1, const btV
 											const btVector3& aabbMin2, const btVector3& aabbMax2)
 {
 	bool overlap = true;
-	overlap = (aabbMin1.getX() > aabbMax2.getX() || aabbMax1.getX() < aabbMin2.getX()) ? false : overlap;
-	overlap = (aabbMin1.getZ() > aabbMax2.getZ() || aabbMax1.getZ() < aabbMin2.getZ()) ? false : overlap;
-	overlap = (aabbMin1.getY() > aabbMax2.getY() || aabbMax1.getY() < aabbMin2.getY()) ? false : overlap;
+	overlap = (aabbMin1.m_floats[0] > aabbMax2.m_floats[0] || aabbMax1.m_floats[0] < aabbMin2.m_floats[0]) ? false : overlap;
+	overlap = (aabbMin1.m_floats[2] > aabbMax2.m_floats[2] || aabbMax1.m_floats[2] < aabbMin2.m_floats[2]) ? false : overlap;
+	overlap = (aabbMin1.m_floats[1] > aabbMax2.m_floats[1] || aabbMax1.m_floats[1] < aabbMin2.m_floats[1]) ? false : overlap;
 	return overlap;
 }
 
@@ -71,12 +71,12 @@ SIMD_FORCE_INLINE bool TestTriangleAgainstAabb2(const btVector3* vertices,
 
 SIMD_FORCE_INLINE int btOutcode(const btVector3& p, const btVector3& halfExtent)
 {
-	return (p.getX() < -halfExtent.getX() ? 0x01 : 0x0) |
-		   (p.getX() > halfExtent.getX() ? 0x08 : 0x0) |
-		   (p.getY() < -halfExtent.getY() ? 0x02 : 0x0) |
-		   (p.getY() > halfExtent.getY() ? 0x10 : 0x0) |
-		   (p.getZ() < -halfExtent.getZ() ? 0x4 : 0x0) |
-		   (p.getZ() > halfExtent.getZ() ? 0x20 : 0x0);
+	return (p.m_floats[0] < -halfExtent.m_floats[0] ? 0x01 : 0x0) |
+		   (p.m_floats[0] > halfExtent.m_floats[0] ? 0x08 : 0x0) |
+		   (p.m_floats[1] < -halfExtent.m_floats[1] ? 0x02 : 0x0) |
+		   (p.m_floats[1] > halfExtent.m_floats[1] ? 0x10 : 0x0) |
+		   (p.m_floats[2] < -halfExtent.m_floats[2] ? 0x4 : 0x0) |
+		   (p.m_floats[2] > halfExtent.m_floats[2] ? 0x20 : 0x0);
 }
 
 SIMD_FORCE_INLINE bool btRayAabb2(const btVector3& rayFrom,
@@ -88,10 +88,10 @@ SIMD_FORCE_INLINE bool btRayAabb2(const btVector3& rayFrom,
 								  btScalar lambda_max)
 {
 	btScalar tmax, tymin, tymax, tzmin, tzmax;
-	tmin = (bounds[raySign[0]].getX() - rayFrom.getX()) * rayInvDirection.getX();
-	tmax = (bounds[1 - raySign[0]].getX() - rayFrom.getX()) * rayInvDirection.getX();
-	tymin = (bounds[raySign[1]].getY() - rayFrom.getY()) * rayInvDirection.getY();
-	tymax = (bounds[1 - raySign[1]].getY() - rayFrom.getY()) * rayInvDirection.getY();
+	tmin = (bounds[raySign[0]].m_floats[0] - rayFrom.m_floats[0]) * rayInvDirection.m_floats[0];
+	tmax = (bounds[1 - raySign[0]].m_floats[0] - rayFrom.m_floats[0]) * rayInvDirection.m_floats[0];
+	tymin = (bounds[raySign[1]].m_floats[1] - rayFrom.m_floats[1]) * rayInvDirection.m_floats[1];
+	tymax = (bounds[1 - raySign[1]].m_floats[1] - rayFrom.m_floats[1]) * rayInvDirection.m_floats[1];
 
 	if ((tmin > tymax) || (tymin > tmax))
 		return false;
@@ -102,8 +102,8 @@ SIMD_FORCE_INLINE bool btRayAabb2(const btVector3& rayFrom,
 	if (tymax < tmax)
 		tmax = tymax;
 
-	tzmin = (bounds[raySign[2]].getZ() - rayFrom.getZ()) * rayInvDirection.getZ();
-	tzmax = (bounds[1 - raySign[2]].getZ() - rayFrom.getZ()) * rayInvDirection.getZ();
+	tzmin = (bounds[raySign[2]].m_floats[2] - rayFrom.m_floats[2]) * rayInvDirection.m_floats[2];
+	tzmax = (bounds[1 - raySign[2]].m_floats[2] - rayFrom.m_floats[2]) * rayInvDirection.m_floats[2];
 
 	if ((tmin > tzmax) || (tzmin > tmax))
 		return false;
@@ -181,9 +181,9 @@ SIMD_FORCE_INLINE void btTransformAabb(const btVector3& halfExtents, btScalar ma
 
 SIMD_FORCE_INLINE void btTransformAabb(const btVector3& localAabbMin, const btVector3& localAabbMax, btScalar margin, const btTransform& trans, btVector3& aabbMinOut, btVector3& aabbMaxOut)
 {
-	btAssert(localAabbMin.getX() <= localAabbMax.getX());
-	btAssert(localAabbMin.getY() <= localAabbMax.getY());
-	btAssert(localAabbMin.getZ() <= localAabbMax.getZ());
+	btAssert(localAabbMin.m_floats[0] <= localAabbMax.m_floats[0]);
+	btAssert(localAabbMin.m_floats[1] <= localAabbMax.m_floats[1]);
+	btAssert(localAabbMin.m_floats[2] <= localAabbMax.m_floats[2]);
 	btVector3 localHalfExtents = btScalar(0.5) * (localAabbMax - localAabbMin);
 	localHalfExtents += btVector3(margin, margin, margin);
 

3rdparty/bullet3/src/LinearMath/btConvexHull.cpp

@@ -75,7 +75,7 @@ btVector3 ThreePlaneIntersection(const btPlane &p0, const btPlane &p1, const btP
 	potentialVertex += n1n2;
 	potentialVertex *= quotient;
 
-	btVector3 result(potentialVertex.getX(), potentialVertex.getY(), potentialVertex.getZ());
+	btVector3 result(potentialVertex.m_floats[0], potentialVertex.m_floats[1], potentialVertex.m_floats[2]);
 	return result;
 }
 
@@ -941,9 +941,9 @@ bool HullLibrary::CleanupVertices(unsigned int svcount,
 		const btVector3 *p = (const btVector3 *)vtx;
 		vtx += stride;
 
-		btScalar px = p->getX();
-		btScalar py = p->getY();
-		btScalar pz = p->getZ();
+		btScalar px = p->m_floats[0];
+		btScalar py = p->m_floats[1];
+		btScalar pz = p->m_floats[2];
 
 		if (scale)
 		{

3rdparty/bullet3/src/LinearMath/btMatrix3x3.h

@@ -270,10 +270,10 @@ public:
 		m_el[1] = V2;
 		m_el[2] = V3;
 #else
-		btScalar xs = q.x() * s, ys = q.y() * s, zs = q.z() * s;
-		btScalar wx = q.w() * xs, wy = q.w() * ys, wz = q.w() * zs;
-		btScalar xx = q.x() * xs, xy = q.x() * ys, xz = q.x() * zs;
-		btScalar yy = q.y() * ys, yz = q.y() * zs, zz = q.z() * zs;
+		btScalar xs = q.m_floats[0] * s, ys = q.m_floats[1] * s, zs = q.m_floats[2] * s;
+		btScalar wx = q.m_floats[3] * xs, wy = q.m_floats[3] * ys, wz = q.m_floats[3] * zs;
+		btScalar xx = q.m_floats[0] * xs, xy = q.m_floats[0] * ys, xz = q.m_floats[0] * zs;
+		btScalar yy = q.m_floats[1] * ys, yz = q.m_floats[1] * zs, zz = q.m_floats[2] * zs;
 		setValue(
 			btScalar(1.0) - (yy + zz), xy - wz, xz + wy,
 			xy + wz, btScalar(1.0) - (xx + zz), yz - wx,
@@ -400,17 +400,17 @@ public:
 		vm[1] = v1;
 		vm[2] = v2;
 #else
-		m[0] = btScalar(m_el[0].x());
-		m[1] = btScalar(m_el[1].x());
-		m[2] = btScalar(m_el[2].x());
+		m[0] = btScalar(m_el[0].m_floats[0]);
+		m[1] = btScalar(m_el[1].m_floats[0]);
+		m[2] = btScalar(m_el[2].m_floats[0]);
 		m[3] = btScalar(0.0);
-		m[4] = btScalar(m_el[0].y());
-		m[5] = btScalar(m_el[1].y());
-		m[6] = btScalar(m_el[2].y());
+		m[4] = btScalar(m_el[0].m_floats[1]);
+		m[5] = btScalar(m_el[1].m_floats[1]);
+		m[6] = btScalar(m_el[2].m_floats[1]);
 		m[7] = btScalar(0.0);
-		m[8] = btScalar(m_el[0].z());
-		m[9] = btScalar(m_el[1].z());
-		m[10] = btScalar(m_el[2].z());
+		m[8] = btScalar(m_el[0].m_floats[2]);
+		m[9] = btScalar(m_el[1].m_floats[2]);
+		m[10] = btScalar(m_el[2].m_floats[2]);
 		m[11] = btScalar(0.0);
 #endif
 	}
@@ -420,7 +420,7 @@ public:
 	void getRotation(btQuaternion & q) const
 	{
 #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
-		btScalar trace = m_el[0].x() + m_el[1].y() + m_el[2].z();
+		btScalar trace = m_el[0].m_floats[0] + m_el[1].m_floats[1] + m_el[2].m_floats[2];
 		btScalar s, x;
 
 		union {
@@ -432,18 +432,18 @@ public:
 		{
 			x = trace + btScalar(1.0);
 
-			temp.f[0] = m_el[2].y() - m_el[1].z();
-			temp.f[1] = m_el[0].z() - m_el[2].x();
-			temp.f[2] = m_el[1].x() - m_el[0].y();
+			temp.f[0] = m_el[2].m_floats[1] - m_el[1].m_floats[2];
+			temp.f[1] = m_el[0].m_floats[2] - m_el[2].m_floats[0];
+			temp.f[2] = m_el[1].m_floats[0] - m_el[0].m_floats[1];
 			temp.f[3] = x;
 			//temp.f[3]= s * btScalar(0.5);
 		}
 		else
 		{
 			int i, j, k;
-			if (m_el[0].x() < m_el[1].y())
+			if (m_el[0].m_floats[0] < m_el[1].m_floats[1])
 			{
-				if (m_el[1].y() < m_el[2].z())
+				if (m_el[1].m_floats[1] < m_el[2].m_floats[2])
 				{
 					i = 2;
 					j = 0;
@@ -458,7 +458,7 @@ public:
 			}
 			else
 			{
-				if (m_el[0].x() < m_el[2].z())
+				if (m_el[0].m_floats[0] < m_el[2].m_floats[2])
 				{
 					i = 2;
 					j = 0;
@@ -487,7 +487,7 @@ public:
 
 		q *= s;
 #else
-		btScalar trace = m_el[0].x() + m_el[1].y() + m_el[2].z();
+		btScalar trace = m_el[0].m_floats[0] + m_el[1].m_floats[1] + m_el[2].m_floats[2];
 
 		btScalar temp[4];
 
@@ -497,13 +497,13 @@ public:
 			temp[3] = (s * btScalar(0.5));
 			s = btScalar(0.5) / s;
 
-			temp[0] = ((m_el[2].y() - m_el[1].z()) * s);
-			temp[1] = ((m_el[0].z() - m_el[2].x()) * s);
-			temp[2] = ((m_el[1].x() - m_el[0].y()) * s);
+			temp[0] = ((m_el[2].m_floats[1] - m_el[1].m_floats[2]) * s);
+			temp[1] = ((m_el[0].m_floats[2] - m_el[2].m_floats[0]) * s);
+			temp[2] = ((m_el[1].m_floats[0] - m_el[0].m_floats[1]) * s);
 		}
 		else
 		{
-			int i = m_el[0].x() < m_el[1].y() ? (m_el[1].y() < m_el[2].z() ? 2 : 1) : (m_el[0].x() < m_el[2].z() ? 2 : 0);
+			int i = m_el[0].m_floats[0] < m_el[1].m_floats[1] ? (m_el[1].m_floats[1] < m_el[2].m_floats[2] ? 2 : 1) : (m_el[0].m_floats[0] < m_el[2].m_floats[2] ? 2 : 0);
 			int j = (i + 1) % 3;
 			int k = (i + 2) % 3;
 
@@ -526,9 +526,9 @@ public:
 	void getEulerYPR(btScalar & yaw, btScalar & pitch, btScalar & roll) const
 	{
 		// first use the normal calculus
-		yaw = btScalar(btAtan2(m_el[1].x(), m_el[0].x()));
-		pitch = btScalar(btAsin(-m_el[2].x()));
-		roll = btScalar(btAtan2(m_el[2].y(), m_el[2].z()));
+		yaw = btScalar(btAtan2(m_el[1].m_floats[0], m_el[0].m_floats[0]));
+		pitch = btScalar(btAsin(-m_el[2].m_floats[0]));
+		roll = btScalar(btAtan2(m_el[2].m_floats[1], m_el[2].m_floats[2]));
 
 		// on pitch = +/-HalfPI
 		if (btFabs(pitch) == SIMD_HALF_PI)
@@ -564,14 +564,14 @@ public:
 		//get the pointer to the raw data
 
 		// Check that pitch is not at a singularity
-		if (btFabs(m_el[2].x()) >= 1)
+		if (btFabs(m_el[2].m_floats[0]) >= 1)
 		{
 			euler_out.yaw = 0;
 			euler_out2.yaw = 0;
 
 			// From difference of angles formula
-			btScalar delta = btAtan2(m_el[0].x(), m_el[0].z());
-			if (m_el[2].x() > 0)  //gimbal locked up
+			btScalar delta = btAtan2(m_el[0].m_floats[0], m_el[0].m_floats[2]);
+			if (m_el[2].m_floats[0] > 0)  //gimbal locked up
 			{
 				euler_out.pitch = SIMD_PI / btScalar(2.0);
 				euler_out2.pitch = SIMD_PI / btScalar(2.0);
@@ -588,18 +588,18 @@ public:
 		}
 		else
 		{
-			euler_out.pitch = -btAsin(m_el[2].x());
+			euler_out.pitch = -btAsin(m_el[2].m_floats[0]);
 			euler_out2.pitch = SIMD_PI - euler_out.pitch;
 
-			euler_out.roll = btAtan2(m_el[2].y() / btCos(euler_out.pitch),
-									 m_el[2].z() / btCos(euler_out.pitch));
-			euler_out2.roll = btAtan2(m_el[2].y() / btCos(euler_out2.pitch),
-									  m_el[2].z() / btCos(euler_out2.pitch));
+			euler_out.roll = btAtan2(m_el[2].m_floats[1] / btCos(euler_out.pitch),
+									 m_el[2].m_floats[2] / btCos(euler_out.pitch));
+			euler_out2.roll = btAtan2(m_el[2].m_floats[1] / btCos(euler_out2.pitch),
+									  m_el[2].m_floats[2] / btCos(euler_out2.pitch));
 
-			euler_out.yaw = btAtan2(m_el[1].x() / btCos(euler_out.pitch),
-									m_el[0].x() / btCos(euler_out.pitch));
-			euler_out2.yaw = btAtan2(m_el[1].x() / btCos(euler_out2.pitch),
-									 m_el[0].x() / btCos(euler_out2.pitch));
+			euler_out.yaw = btAtan2(m_el[1].m_floats[0] / btCos(euler_out.pitch),
+									m_el[0].m_floats[0] / btCos(euler_out.pitch));
+			euler_out2.yaw = btAtan2(m_el[1].m_floats[0] / btCos(euler_out2.pitch),
+									 m_el[0].m_floats[0] / btCos(euler_out2.pitch));
 		}
 
 		if (solution_number == 1)
@@ -625,9 +625,9 @@ public:
 		return btMatrix3x3(m_el[0] * s, m_el[1] * s, m_el[2] * s);
 #else
 		return btMatrix3x3(
-			m_el[0].x() * s.x(), m_el[0].y() * s.y(), m_el[0].z() * s.z(),
-			m_el[1].x() * s.x(), m_el[1].y() * s.y(), m_el[1].z() * s.z(),
-			m_el[2].x() * s.x(), m_el[2].y() * s.y(), m_el[2].z() * s.z());
+			m_el[0].m_floats[0] * s.m_floats[0], m_el[0].m_floats[1] * s.m_floats[1], m_el[0].m_floats[2] * s.m_floats[2],
+			m_el[1].m_floats[0] * s.m_floats[0], m_el[1].m_floats[1] * s.m_floats[1], m_el[1].m_floats[2] * s.m_floats[2],
+			m_el[2].m_floats[0] * s.m_floats[0], m_el[2].m_floats[1] * s.m_floats[1], m_el[2].m_floats[2] * s.m_floats[2]);
 #endif
 	}
 
@@ -668,15 +668,15 @@ public:
 
 	SIMD_FORCE_INLINE btScalar tdotx(const btVector3& v) const
 	{
-		return m_el[0].x() * v.x() + m_el[1].x() * v.y() + m_el[2].x() * v.z();
+		return m_el[0].m_floats[0] * v.m_floats[0] + m_el[1].m_floats[0] * v.m_floats[1] + m_el[2].m_floats[0] * v.m_floats[2];
 	}
 	SIMD_FORCE_INLINE btScalar tdoty(const btVector3& v) const
 	{
-		return m_el[0].y() * v.x() + m_el[1].y() * v.y() + m_el[2].y() * v.z();
+		return m_el[0].m_floats[1] * v.m_floats[0] + m_el[1].m_floats[1] * v.m_floats[1] + m_el[2].m_floats[1] * v.m_floats[2];
 	}
 	SIMD_FORCE_INLINE btScalar tdotz(const btVector3& v) const
 	{
-		return m_el[0].z() * v.x() + m_el[1].z() * v.y() + m_el[2].z() * v.z();
+		return m_el[0].m_floats[2] * v.m_floats[0] + m_el[1].m_floats[2] * v.m_floats[1] + m_el[2].m_floats[2] * v.m_floats[2];
 	}
 
 	///extractRotation is from "A robust method to extract the rotational part of deformations"
@@ -942,9 +942,9 @@ operator*(const btMatrix3x3& m, const btScalar& k)
 		vmulq_n_f32(m[2].mVec128, k));
 #else
 	return btMatrix3x3(
-		m[0].x() * k, m[0].y() * k, m[0].z() * k,
-		m[1].x() * k, m[1].y() * k, m[1].z() * k,
-		m[2].x() * k, m[2].y() * k, m[2].z() * k);
+		m[0].m_floats[0] * k, m[0].m_floats[1] * k, m[0].m_floats[2] * k,
+		m[1].m_floats[0] * k, m[1].m_floats[1] * k, m[1].m_floats[2] * k,
+		m[2].m_floats[0] * k, m[2].m_floats[1] * k, m[2].m_floats[2] * k);
 #endif
 }
 
@@ -1039,9 +1039,9 @@ btMatrix3x3::absolute() const
 		(float32x4_t)vandq_s32((int32x4_t)m_el[2].mVec128, btv3AbsMask));
 #else
 	return btMatrix3x3(
-		btFabs(m_el[0].x()), btFabs(m_el[0].y()), btFabs(m_el[0].z()),
-		btFabs(m_el[1].x()), btFabs(m_el[1].y()), btFabs(m_el[1].z()),
-		btFabs(m_el[2].x()), btFabs(m_el[2].y()), btFabs(m_el[2].z()));
+		btFabs(m_el[0].m_floats[0]), btFabs(m_el[0].m_floats[1]), btFabs(m_el[0].m_floats[2]),
+		btFabs(m_el[1].m_floats[0]), btFabs(m_el[1].m_floats[1]), btFabs(m_el[1].m_floats[2]),
+		btFabs(m_el[2].m_floats[0]), btFabs(m_el[2].m_floats[1]), btFabs(m_el[2].m_floats[2]));
 #endif
 }
 
@@ -1075,9 +1075,9 @@ btMatrix3x3::transpose() const
 	float32x4_t v2 = vcombine_f32(vget_high_f32(top.val[0]), q);  // z0 z1 z2  0
 	return btMatrix3x3(v0, v1, v2);
 #else
-	return btMatrix3x3(m_el[0].x(), m_el[1].x(), m_el[2].x(),
-					   m_el[0].y(), m_el[1].y(), m_el[2].y(),
-					   m_el[0].z(), m_el[1].z(), m_el[2].z());
+	return btMatrix3x3(m_el[0].m_floats[0], m_el[1].m_floats[0], m_el[2].m_floats[0],
+					   m_el[0].m_floats[1], m_el[1].m_floats[1], m_el[2].m_floats[1],
+					   m_el[0].m_floats[2], m_el[1].m_floats[2], m_el[2].m_floats[2]);
 #endif
 }
 
@@ -1097,9 +1097,9 @@ btMatrix3x3::inverse() const
 	//btFullAssert(det != btScalar(0.0));
 	btAssert(det != btScalar(0.0));
 	btScalar s = btScalar(1.0) / det;
-	return btMatrix3x3(co.x() * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
-					   co.y() * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
-					   co.z() * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s);
+	return btMatrix3x3(co.m_floats[0] * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
+					   co.m_floats[1] * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
+					   co.m_floats[2] * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s);
 }
 
 SIMD_FORCE_INLINE btMatrix3x3
@@ -1146,15 +1146,15 @@ btMatrix3x3::transposeTimes(const btMatrix3x3& m) const
 	return btMatrix3x3(r0, r1, r2);
 #else
 	return btMatrix3x3(
-		m_el[0].x() * m[0].x() + m_el[1].x() * m[1].x() + m_el[2].x() * m[2].x(),
-		m_el[0].x() * m[0].y() + m_el[1].x() * m[1].y() + m_el[2].x() * m[2].y(),
-		m_el[0].x() * m[0].z() + m_el[1].x() * m[1].z() + m_el[2].x() * m[2].z(),
-		m_el[0].y() * m[0].x() + m_el[1].y() * m[1].x() + m_el[2].y() * m[2].x(),
-		m_el[0].y() * m[0].y() + m_el[1].y() * m[1].y() + m_el[2].y() * m[2].y(),
-		m_el[0].y() * m[0].z() + m_el[1].y() * m[1].z() + m_el[2].y() * m[2].z(),
-		m_el[0].z() * m[0].x() + m_el[1].z() * m[1].x() + m_el[2].z() * m[2].x(),
-		m_el[0].z() * m[0].y() + m_el[1].z() * m[1].y() + m_el[2].z() * m[2].y(),
-		m_el[0].z() * m[0].z() + m_el[1].z() * m[1].z() + m_el[2].z() * m[2].z());
+		m_el[0].m_floats[0] * m[0].m_floats[0] + m_el[1].m_floats[0] * m[1].m_floats[0] + m_el[2].m_floats[0] * m[2].m_floats[0],
+		m_el[0].m_floats[0] * m[0].m_floats[1] + m_el[1].m_floats[0] * m[1].m_floats[1] + m_el[2].m_floats[0] * m[2].m_floats[1],
+		m_el[0].m_floats[0] * m[0].m_floats[2] + m_el[1].m_floats[0] * m[1].m_floats[2] + m_el[2].m_floats[0] * m[2].m_floats[2],
+		m_el[0].m_floats[1] * m[0].m_floats[0] + m_el[1].m_floats[1] * m[1].m_floats[0] + m_el[2].m_floats[1] * m[2].m_floats[0],
+		m_el[0].m_floats[1] * m[0].m_floats[1] + m_el[1].m_floats[1] * m[1].m_floats[1] + m_el[2].m_floats[1] * m[2].m_floats[1],
+		m_el[0].m_floats[1] * m[0].m_floats[2] + m_el[1].m_floats[1] * m[1].m_floats[2] + m_el[2].m_floats[1] * m[2].m_floats[2],
+		m_el[0].m_floats[2] * m[0].m_floats[0] + m_el[1].m_floats[2] * m[1].m_floats[0] + m_el[2].m_floats[2] * m[2].m_floats[0],
+		m_el[0].m_floats[2] * m[0].m_floats[1] + m_el[1].m_floats[2] * m[1].m_floats[1] + m_el[2].m_floats[2] * m[2].m_floats[1],
+		m_el[0].m_floats[2] * m[0].m_floats[2] + m_el[1].m_floats[2] * m[1].m_floats[2] + m_el[2].m_floats[2] * m[2].m_floats[2]);
 #endif
 }
 

3rdparty/bullet3/src/LinearMath/btQuadWord.h

@@ -3,8 +3,8 @@ Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  https://bulletphysi
 
 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.
@@ -22,7 +22,7 @@ subject to the following restrictions:
 #include <altivec.h>
 #endif
 
-/**@brief The btQuadWord class is base class for btVector3 and btQuaternion. 
+/**@brief The btQuadWord class is base class for btVector3 and btQuaternion.
  * Some issues under PS3 Linux with IBM 2.1 SDK, gcc compiler prevent from using aligned quadword.
  */
 #ifndef USE_LIBSPE2
@@ -32,7 +32,7 @@ btQuadWord
 class btQuadWord
 #endif
 {
-protected:
+public:
 #if defined(__SPU__) && defined(__CELLOS_LV2__)
 	union {
 		vec_float4 mVec128;
@@ -95,29 +95,6 @@ public:
 
 #endif
 
-	/**@brief Return the x value */
-	SIMD_FORCE_INLINE const btScalar& getX() const { return m_floats[0]; }
-	/**@brief Return the y value */
-	SIMD_FORCE_INLINE const btScalar& getY() const { return m_floats[1]; }
-	/**@brief Return the z value */
-	SIMD_FORCE_INLINE const btScalar& getZ() const { return m_floats[2]; }
-	/**@brief Set the x value */
-	SIMD_FORCE_INLINE void setX(btScalar _x) { m_floats[0] = _x; };
-	/**@brief Set the y value */
-	SIMD_FORCE_INLINE void setY(btScalar _y) { m_floats[1] = _y; };
-	/**@brief Set the z value */
-	SIMD_FORCE_INLINE void setZ(btScalar _z) { m_floats[2] = _z; };
-	/**@brief Set the w value */
-	SIMD_FORCE_INLINE void setW(btScalar _w) { m_floats[3] = _w; };
-	/**@brief Return the x value */
-	SIMD_FORCE_INLINE const btScalar& x() const { return m_floats[0]; }
-	/**@brief Return the y value */
-	SIMD_FORCE_INLINE const btScalar& y() const { return m_floats[1]; }
-	/**@brief Return the z value */
-	SIMD_FORCE_INLINE const btScalar& z() const { return m_floats[2]; }
-	/**@brief Return the w value */
-	SIMD_FORCE_INLINE const btScalar& w() const { return m_floats[3]; }
-
 	//SIMD_FORCE_INLINE btScalar&       operator[](int i)       { return (&m_floats[0])[i];	}
 	//SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; }
 	///operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons.
@@ -141,7 +118,7 @@ public:
 		return !(*this == other);
 	}
 
-	/**@brief Set x,y,z and zero w 
+	/**@brief Set x,y,z and zero w
    * @param x Value of x
    * @param y Value of y
    * @param z Value of z
@@ -154,14 +131,14 @@ public:
 		m_floats[3] = 0.f;
 	}
 
-	/*		void getValue(btScalar *m) const 
+	/*		void getValue(btScalar *m) const
 		{
 			m[0] = m_floats[0];
 			m[1] = m_floats[1];
 			m[2] = m_floats[2];
 		}
 */
-	/**@brief Set the values 
+	/**@brief Set the values
    * @param x Value of x
    * @param y Value of y
    * @param z Value of z
@@ -202,7 +179,7 @@ public:
 	}
 
 	/**@brief Set each element to the max of the current values and the values of another btQuadWord
-   * @param other The other btQuadWord to compare with 
+   * @param other The other btQuadWord to compare with
    */
 	SIMD_FORCE_INLINE void setMax(const btQuadWord& other)
 	{
@@ -218,7 +195,7 @@ public:
 #endif
 	}
 	/**@brief Set each element to the min of the current values and the values of another btQuadWord
-   * @param other The other btQuadWord to compare with 
+   * @param other The other btQuadWord to compare with
    */
 	SIMD_FORCE_INLINE void setMin(const btQuadWord& other)
 	{

3rdparty/bullet3/src/LinearMath/btQuaternion.h

@@ -110,7 +110,7 @@ public:
 		btScalar d = axis.length();
 		btAssert(d != btScalar(0.0));
 		btScalar s = btSin(_angle * btScalar(0.5)) / d;
-		setValue(axis.x() * s, axis.y() * s, axis.z() * s,
+		setValue(axis.m_floats[0] * s, axis.m_floats[1] * s, axis.m_floats[2] * s,
 				 btCos(_angle * btScalar(0.5)));
 	}
 	/**@brief Set the quaternion using Euler angles
@@ -204,9 +204,9 @@ public:
 #elif defined(BT_USE_NEON)
 		mVec128 = vaddq_f32(mVec128, q.mVec128);
 #else
-		m_floats[0] += q.x();
-		m_floats[1] += q.y();
-		m_floats[2] += q.z();
+		m_floats[0] += q.m_floats[0];
+		m_floats[1] += q.m_floats[1];
+		m_floats[2] += q.m_floats[2];
 		m_floats[3] += q.m_floats[3];
 #endif
 		return *this;
@@ -221,9 +221,9 @@ public:
 #elif defined(BT_USE_NEON)
 		mVec128 = vsubq_f32(mVec128, q.mVec128);
 #else
-		m_floats[0] -= q.x();
-		m_floats[1] -= q.y();
-		m_floats[2] -= q.z();
+		m_floats[0] -= q.m_floats[0];
+		m_floats[1] -= q.m_floats[1];
+		m_floats[2] -= q.m_floats[2];
 		m_floats[3] -= q.m_floats[3];
 #endif
 		return *this;
@@ -325,10 +325,10 @@ public:
 		mVec128 = A0;
 #else
 		setValue(
-			m_floats[3] * q.x() + m_floats[0] * q.m_floats[3] + m_floats[1] * q.z() - m_floats[2] * q.y(),
-			m_floats[3] * q.y() + m_floats[1] * q.m_floats[3] + m_floats[2] * q.x() - m_floats[0] * q.z(),
-			m_floats[3] * q.z() + m_floats[2] * q.m_floats[3] + m_floats[0] * q.y() - m_floats[1] * q.x(),
-			m_floats[3] * q.m_floats[3] - m_floats[0] * q.x() - m_floats[1] * q.y() - m_floats[2] * q.z());
+			m_floats[3] * q.m_floats[0] + m_floats[0] * q.m_floats[3] + m_floats[1] * q.m_floats[2] - m_floats[2] * q.m_floats[1],
+			m_floats[3] * q.m_floats[1] + m_floats[1] * q.m_floats[3] + m_floats[2] * q.m_floats[0] - m_floats[0] * q.m_floats[2],
+			m_floats[3] * q.m_floats[2] + m_floats[2] * q.m_floats[3] + m_floats[0] * q.m_floats[1] - m_floats[1] * q.m_floats[0],
+			m_floats[3] * q.m_floats[3] - m_floats[0] * q.m_floats[0] - m_floats[1] * q.m_floats[1] - m_floats[2] * q.m_floats[2]);
 #endif
 		return *this;
 	}
@@ -353,9 +353,9 @@ public:
 		x = vpadd_f32(x, x);
 		return vget_lane_f32(x, 0);
 #else
-		return m_floats[0] * q.x() +
-			   m_floats[1] * q.y() +
-			   m_floats[2] * q.z() +
+		return m_floats[0] * q.m_floats[0] +
+			   m_floats[1] * q.m_floats[1] +
+			   m_floats[2] * q.m_floats[2] +
 			   m_floats[3] * q.m_floats[3];
 #endif
 	}
@@ -418,7 +418,7 @@ public:
 #elif defined(BT_USE_NEON)
 		return btQuaternion(vmulq_n_f32(mVec128, s));
 #else
-		return btQuaternion(x() * s, y() * s, z() * s, m_floats[3] * s);
+		return btQuaternion(m_floats[0] * s, m_floats[1] * s, m_floats[2] * s, m_floats[3] * s);
 #endif
 	}
 
@@ -516,7 +516,7 @@ public:
 		return btQuaternion(vaddq_f32(mVec128, q2.mVec128));
 #else
 		const btQuaternion& q1 = *this;
-		return btQuaternion(q1.x() + q2.x(), q1.y() + q2.y(), q1.z() + q2.z(), q1.m_floats[3] + q2.m_floats[3]);
+		return btQuaternion(q1.m_floats[0] + q2.m_floats[0], q1.m_floats[1] + q2.m_floats[1], q1.m_floats[2] + q2.m_floats[2], q1.m_floats[3] + q2.m_floats[3]);
 #endif
 	}
 
@@ -531,7 +531,7 @@ public:
 		return btQuaternion(vsubq_f32(mVec128, q2.mVec128));
 #else
 		const btQuaternion& q1 = *this;
-		return btQuaternion(q1.x() - q2.x(), q1.y() - q2.y(), q1.z() - q2.z(), q1.m_floats[3] - q2.m_floats[3]);
+		return btQuaternion(q1.m_floats[0] - q2.m_floats[0], q1.m_floats[1] - q2.m_floats[1], q1.m_floats[2] - q2.m_floats[2], q1.m_floats[3] - q2.m_floats[3]);
 #endif
 	}
 
@@ -545,7 +545,7 @@ public:
 		return btQuaternion((btSimdFloat4)veorq_s32((int32x4_t)mVec128, (int32x4_t)btvMzeroMask));
 #else
 		const btQuaternion& q2 = *this;
-		return btQuaternion(-q2.x(), -q2.y(), -q2.z(), -q2.m_floats[3]);
+		return btQuaternion(-q2.m_floats[0], -q2.m_floats[1], -q2.m_floats[2], -q2.m_floats[3]);
 #endif
 	}
 	/**@todo document this and it's use */
@@ -594,10 +594,10 @@ public:
 			const btScalar s1 = btSin(sign * t * theta) / d;
 
 			return btQuaternion(
-				(m_floats[0] * s0 + q.x() * s1),
-				(m_floats[1] * s0 + q.y() * s1),
-				(m_floats[2] * s0 + q.z() * s1),
-				(m_floats[3] * s0 + q.w() * s1));
+				(m_floats[0] * s0 + q.m_floats[0] * s1),
+				(m_floats[1] * s0 + q.m_floats[1] * s1),
+				(m_floats[2] * s0 + q.m_floats[2] * s1),
+				(m_floats[3] * s0 + q.m_floats[3] * s1));
 		}
 		else
 		{
@@ -710,10 +710,10 @@ operator*(const btQuaternion& q1, const btQuaternion& q2)
 
 #else
 	return btQuaternion(
-		q1.w() * q2.x() + q1.x() * q2.w() + q1.y() * q2.z() - q1.z() * q2.y(),
-		q1.w() * q2.y() + q1.y() * q2.w() + q1.z() * q2.x() - q1.x() * q2.z(),
-		q1.w() * q2.z() + q1.z() * q2.w() + q1.x() * q2.y() - q1.y() * q2.x(),
-		q1.w() * q2.w() - q1.x() * q2.x() - q1.y() * q2.y() - q1.z() * q2.z());
+		q1.m_floats[3] * q2.m_floats[0] + q1.m_floats[0] * q2.m_floats[3] + q1.m_floats[1] * q2.m_floats[2] - q1.m_floats[2] * q2.m_floats[1],
+		q1.m_floats[3] * q2.m_floats[1] + q1.m_floats[1] * q2.m_floats[3] + q1.m_floats[2] * q2.m_floats[0] - q1.m_floats[0] * q2.m_floats[2],
+		q1.m_floats[3] * q2.m_floats[2] + q1.m_floats[2] * q2.m_floats[3] + q1.m_floats[0] * q2.m_floats[1] - q1.m_floats[1] * q2.m_floats[0],
+		q1.m_floats[3] * q2.m_floats[3] - q1.m_floats[0] * q2.m_floats[0] - q1.m_floats[1] * q2.m_floats[1] - q1.m_floats[2] * q2.m_floats[2]);
 #endif
 }
 
@@ -793,10 +793,10 @@ operator*(const btQuaternion& q, const btVector3& w)
 
 #else
 	return btQuaternion(
-		q.w() * w.x() + q.y() * w.z() - q.z() * w.y(),
-		q.w() * w.y() + q.z() * w.x() - q.x() * w.z(),
-		q.w() * w.z() + q.x() * w.y() - q.y() * w.x(),
-		-q.x() * w.x() - q.y() * w.y() - q.z() * w.z());
+		q.m_floats[3] * w.m_floats[0] + q.m_floats[1] * w.m_floats[2] - q.m_floats[2] * w.m_floats[1],
+		q.m_floats[3] * w.m_floats[1] + q.m_floats[2] * w.m_floats[0] - q.m_floats[0] * w.m_floats[2],
+		q.m_floats[3] * w.m_floats[2] + q.m_floats[0] * w.m_floats[1] - q.m_floats[1] * w.m_floats[0],
+		-q.m_floats[0] * w.m_floats[0] - q.m_floats[1] * w.m_floats[1] - q.m_floats[2] * w.m_floats[2]);
 #endif
 }
 
@@ -876,10 +876,10 @@ operator*(const btVector3& w, const btQuaternion& q)
 
 #else
 	return btQuaternion(
-		+w.x() * q.w() + w.y() * q.z() - w.z() * q.y(),
-		+w.y() * q.w() + w.z() * q.x() - w.x() * q.z(),
-		+w.z() * q.w() + w.x() * q.y() - w.y() * q.x(),
-		-w.x() * q.x() - w.y() * q.y() - w.z() * q.z());
+		+w.m_floats[0] * q.m_floats[3] + w.m_floats[1] * q.m_floats[2] - w.m_floats[2] * q.m_floats[1],
+		+w.m_floats[1] * q.m_floats[3] + w.m_floats[2] * q.m_floats[0] - w.m_floats[0] * q.m_floats[2],
+		+w.m_floats[2] * q.m_floats[3] + w.m_floats[0] * q.m_floats[1] - w.m_floats[1] * q.m_floats[0],
+		-w.m_floats[0] * q.m_floats[0] - w.m_floats[1] * q.m_floats[1] - w.m_floats[2] * q.m_floats[2]);
 #endif
 }
 
@@ -932,7 +932,7 @@ quatRotate(const btQuaternion& rotation, const btVector3& v)
 #elif defined(BT_USE_NEON)
 	return btVector3((float32x4_t)vandq_s32((int32x4_t)q.get128(), btvFFF0Mask));
 #else
-	return btVector3(q.getX(), q.getY(), q.getZ());
+	return btVector3(q.m_floats[0], q.m_floats[1], q.m_floats[2]);
 #endif
 }
 
@@ -946,13 +946,13 @@ shortestArcQuat(const btVector3& v0, const btVector3& v1)  // Game Programming G
 	{
 		btVector3 n, unused;
 		btPlaneSpace1(v0, n, unused);
-		return btQuaternion(n.x(), n.y(), n.z(), 0.0f);  // just pick any vector that is orthogonal to v0
+		return btQuaternion(n.m_floats[0], n.m_floats[1], n.m_floats[2], 0.0f);  // just pick any vector that is orthogonal to v0
 	}
 
 	btScalar s = btSqrt((1.0f + d) * 2.0f);
 	btScalar rs = 1.0f / s;
 
-	return btQuaternion(c.getX() * rs, c.getY() * rs, c.getZ() * rs, s * 0.5f);
+	return btQuaternion(c.m_floats[0] * rs, c.m_floats[1] * rs, c.m_floats[2] * rs, s * 0.5f);
 }
 
 SIMD_FORCE_INLINE btQuaternion

3rdparty/bullet3/src/LinearMath/btTransform.h

@@ -127,9 +127,9 @@ public:
 	void getOpenGLMatrix(btScalar * m) const
 	{
 		m_basis.getOpenGLSubMatrix(m);
-		m[12] = m_origin.x();
-		m[13] = m_origin.y();
-		m[14] = m_origin.z();
+		m[12] = m_origin.m_floats[0];
+		m[13] = m_origin.m_floats[1];
+		m[14] = m_origin.m_floats[2];
 		m[15] = btScalar(1.0);
 	}
 

3rdparty/bullet3/src/LinearMath/btTransformUtil.h

@@ -20,9 +20,9 @@ subject to the following restrictions:
 
 SIMD_FORCE_INLINE btVector3 btAabbSupport(const btVector3& halfExtents, const btVector3& supportDir)
 {
-	return btVector3(supportDir.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(),
-					 supportDir.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(),
-					 supportDir.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z());
+	return btVector3(supportDir.m_floats[0] < btScalar(0.0) ? -halfExtents.m_floats[0] : halfExtents.m_floats[0],
+					 supportDir.m_floats[1] < btScalar(0.0) ? -halfExtents.m_floats[1] : halfExtents.m_floats[1],
+					 supportDir.m_floats[2] < btScalar(0.0) ? -halfExtents.m_floats[2] : halfExtents.m_floats[2]);
 }
 
 /// Utils related to temporal transforms
@@ -65,7 +65,7 @@ public:
 			// sync(fAngle) = sin(c*fAngle)/t
 			axis = angvel * (btSin(btScalar(0.5) * fAngle * timeStep) / fAngle);
 		}
-		btQuaternion dorn(axis.x(), axis.y(), axis.z(), btCos(fAngle * timeStep * btScalar(0.5)));
+		btQuaternion dorn(axis.m_floats[0], axis.m_floats[1], axis.m_floats[2], btCos(fAngle * timeStep * btScalar(0.5)));
 		btQuaternion orn0 = curTrans.getRotation();
 
 		btQuaternion predictedOrn = dorn * orn0;
@@ -102,7 +102,7 @@ public:
 		btQuaternion orn1 = orn0.nearest(orn1a);
 		btQuaternion dorn = orn1 * orn0.inverse();
 		angle = dorn.getAngle();
-		axis = btVector3(dorn.x(), dorn.y(), dorn.z());
+		axis = btVector3(dorn.m_floats[0], dorn.m_floats[1], dorn.m_floats[2]);
 		axis[3] = btScalar(0.);
 		//check for axis length
 		btScalar len = axis.length2();
@@ -131,7 +131,7 @@ public:
 		dorn.normalize();
 
 		angle = dorn.getAngle();
-		axis = btVector3(dorn.x(), dorn.y(), dorn.z());
+		axis = btVector3(dorn.m_floats[0], dorn.m_floats[1], dorn.m_floats[2]);
 		axis[3] = btScalar(0.);
 		//check for axis length
 		btScalar len = axis.length2();

3rdparty/bullet3/src/LinearMath/btVector3.h

@@ -3,8 +3,8 @@ Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  https://bulletphysi
 
 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.
@@ -118,10 +118,10 @@ public:
 	{
 	}
 
-	/**@brief Constructor from scalars 
+	/**@brief Constructor from scalars
    * @param x X value
-   * @param y Y value 
-   * @param z Z value 
+   * @param y Y value
+   * @param z Z value
    */
 	SIMD_FORCE_INLINE btVector3(const btScalar& _x, const btScalar& _y, const btScalar& _z)
 	{
@@ -154,7 +154,7 @@ public:
 	}
 #endif  // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON)
 
-	/**@brief Add a vector to this one 
+	/**@brief Add a vector to this one
  * @param The vector to add to this one */
 	SIMD_FORCE_INLINE btVector3& operator+=(const btVector3& v)
 	{
@@ -204,7 +204,7 @@ public:
 		return *this;
 	}
 
-	/**@brief Inversely scale the vector 
+	/**@brief Inversely scale the vector
    * @param s Scale factor to divide by */
 	SIMD_FORCE_INLINE btVector3& operator/=(const btScalar& s)
 	{
@@ -217,7 +217,7 @@ public:
 		vs = bt_pshufd_ps(vs, 0x00);	//	(S S S S)
 
 		mVec128 = _mm_mul_ps(mVec128, vs);
-		
+
 		return *this;
 #else
 		return *this *= btScalar(1.0) / s;
@@ -298,7 +298,7 @@ public:
 		return *this;
 	}
 
-	/**@brief Normalize this vector 
+	/**@brief Normalize this vector
    * x^2 + y^2 + z^2 = 1 */
 	SIMD_FORCE_INLINE btVector3& normalize()
 	{
@@ -347,7 +347,7 @@ public:
 	SIMD_FORCE_INLINE btVector3 normalized() const;
 
 	/**@brief Return a rotated version of this vector
-   * @param wAxis The axis to rotate about 
+   * @param wAxis The axis to rotate about
    * @param angle The angle to rotate by */
 	SIMD_FORCE_INLINE btVector3 rotate(const btVector3& wAxis, const btScalar angle) const;
 
@@ -375,7 +375,7 @@ public:
 #endif
 	}
 
-	/**@brief Return the cross product between this and another vector 
+	/**@brief Return the cross product between this and another vector
    * @param v The other vector */
 	SIMD_FORCE_INLINE btVector3 cross(const btVector3& v) const
 	{
@@ -465,14 +465,14 @@ public:
 #endif
 	}
 
-	/**@brief Return the axis with the smallest value 
+	/**@brief Return the axis with the smallest value
    * Note return values are 0,1,2 for x, y, or z */
 	SIMD_FORCE_INLINE int minAxis() const
 	{
 		return m_floats[0] < m_floats[1] ? (m_floats[0] < m_floats[2] ? 0 : 2) : (m_floats[1] < m_floats[2] ? 1 : 2);
 	}
 
-	/**@brief Return the axis with the largest value 
+	/**@brief Return the axis with the largest value
    * Note return values are 0,1,2 for x, y, or z */
 	SIMD_FORCE_INLINE int maxAxis() const
 	{
@@ -515,8 +515,8 @@ public:
 #endif
 	}
 
-	/**@brief Return the linear interpolation between this and another vector 
-   * @param v The other vector 
+	/**@brief Return the linear interpolation between this and another vector
+   * @param v The other vector
    * @param t The ration of this to v (t = 0 => return this, t=1 => return other) */
 	SIMD_FORCE_INLINE btVector3 lerp(const btVector3& v, const btScalar& t) const
 	{
@@ -541,7 +541,7 @@ public:
 #endif
 	}
 
-	/**@brief Elementwise multiply this vector by the other 
+	/**@brief Elementwise multiply this vector by the other
    * @param v The other vector */
 	SIMD_FORCE_INLINE btVector3& operator*=(const btVector3& v)
 	{
@@ -557,29 +557,6 @@ public:
 		return *this;
 	}
 
-	/**@brief Return the x value */
-	SIMD_FORCE_INLINE const btScalar& getX() const { return m_floats[0]; }
-	/**@brief Return the y value */
-	SIMD_FORCE_INLINE const btScalar& getY() const { return m_floats[1]; }
-	/**@brief Return the z value */
-	SIMD_FORCE_INLINE const btScalar& getZ() const { return m_floats[2]; }
-	/**@brief Set the x value */
-	SIMD_FORCE_INLINE void setX(btScalar _x) { m_floats[0] = _x; };
-	/**@brief Set the y value */
-	SIMD_FORCE_INLINE void setY(btScalar _y) { m_floats[1] = _y; };
-	/**@brief Set the z value */
-	SIMD_FORCE_INLINE void setZ(btScalar _z) { m_floats[2] = _z; };
-	/**@brief Set the w value */
-	SIMD_FORCE_INLINE void setW(btScalar _w) { m_floats[3] = _w; };
-	/**@brief Return the x value */
-	SIMD_FORCE_INLINE const btScalar& x() const { return m_floats[0]; }
-	/**@brief Return the y value */
-	SIMD_FORCE_INLINE const btScalar& y() const { return m_floats[1]; }
-	/**@brief Return the z value */
-	SIMD_FORCE_INLINE const btScalar& z() const { return m_floats[2]; }
-	/**@brief Return the w value */
-	SIMD_FORCE_INLINE const btScalar& w() const { return m_floats[3]; }
-
 	//SIMD_FORCE_INLINE btScalar&       operator[](int i)       { return (&m_floats[0])[i];	}
 	//SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; }
 	///operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons.
@@ -604,7 +581,7 @@ public:
 	}
 
 	/**@brief Set each element to the max of the current values and the values of another btVector3
-   * @param other The other btVector3 to compare with 
+   * @param other The other btVector3 to compare with
    */
 	SIMD_FORCE_INLINE void setMax(const btVector3& other)
 	{
@@ -616,12 +593,12 @@ public:
 		btSetMax(m_floats[0], other.m_floats[0]);
 		btSetMax(m_floats[1], other.m_floats[1]);
 		btSetMax(m_floats[2], other.m_floats[2]);
-		btSetMax(m_floats[3], other.w());
+		btSetMax(m_floats[3], other.m_floats[3]);
 #endif
 	}
 
 	/**@brief Set each element to the min of the current values and the values of another btVector3
-   * @param other The other btVector3 to compare with 
+   * @param other The other btVector3 to compare with
    */
 	SIMD_FORCE_INLINE void setMin(const btVector3& other)
 	{
@@ -633,7 +610,7 @@ public:
 		btSetMin(m_floats[0], other.m_floats[0]);
 		btSetMin(m_floats[1], other.m_floats[1]);
 		btSetMin(m_floats[2], other.m_floats[2]);
-		btSetMin(m_floats[3], other.w());
+		btSetMin(m_floats[3], other.m_floats[3]);
 #endif
 	}
 
@@ -662,9 +639,9 @@ public:
 		v1->mVec128 = V1;
 		v2->mVec128 = V2;
 #else
-		v0->setValue(0., -z(), y());
-		v1->setValue(z(), 0., -x());
-		v2->setValue(-y(), x(), 0.);
+		v0->setValue(0., -m_floats[2], m_floats[1]);
+		v1->setValue(m_floats[2], 0., -m_floats[0]);
+		v2->setValue(-m_floats[1], m_floats[0], 0.);
 #endif
 	}
 
@@ -705,14 +682,14 @@ public:
 	SIMD_FORCE_INLINE void deSerializeDouble(const struct btVector3DoubleData& dataIn);
 
 	/**@brief returns index of maximum dot product between this and vectors in array[]
-         * @param array The other vectors 
-         * @param array_count The number of other vectors 
+         * @param array The other vectors
+         * @param array_count The number of other vectors
          * @param dotOut The maximum dot product */
 	SIMD_FORCE_INLINE long maxDot(const btVector3* array, long array_count, btScalar& dotOut) const;
 
 	/**@brief returns index of minimum dot product between this and vectors in array[]
-         * @param array The other vectors 
-         * @param array_count The number of other vectors 
+         * @param array The other vectors
+         * @param array_count The number of other vectors
          * @param dotOut The minimum dot product */
 	SIMD_FORCE_INLINE long minDot(const btVector3* array, long array_count, btScalar& dotOut) const;
 
@@ -927,8 +904,8 @@ btTriple(const btVector3& v1, const btVector3& v2, const btVector3& v3)
 }
 
 /**@brief Return the linear interpolation between two vectors
- * @param v1 One vector 
- * @param v2 The other vector 
+ * @param v1 One vector
+ * @param v2 The other vector
  * @param t The ration of this to v (t = 0 => return v1, t=1 => return v2) */
 SIMD_FORCE_INLINE btVector3
 lerp(const btVector3& v1, const btVector3& v2, const btScalar& t)
@@ -1176,20 +1153,20 @@ public:
 		return absolute4().maxAxis4();
 	}
 
-	/**@brief Set x,y,z and zero w 
+	/**@brief Set x,y,z and zero w
    * @param x Value of x
    * @param y Value of y
    * @param z Value of z
    */
 
-	/*		void getValue(btScalar *m) const 
+	/*		void getValue(btScalar *m) const
 		{
 			m[0] = m_floats[0];
 			m[1] = m_floats[1];
 			m[2] =m_floats[2];
 		}
 */
-	/**@brief Set the values 
+	/**@brief Set the values
    * @param x Value of x
    * @param y Value of y
    * @param z Value of z

src/world/physics_world_bullet.cpp

@@ -99,12 +99,12 @@ static inline btTransform to_btTransform(const Matrix4x4 &m)
 
 static inline Vector3 to_vector3(const btVector3 &v)
 {
-	return vector3(v.x(), v.y(), v.z());
+	return vector3(v.m_floats[0], v.m_floats[1], v.m_floats[2]);
 }
 
 static inline Quaternion to_quaternion(const btQuaternion &q)
 {
-	return from_elements(q.x(), q.y(), q.z(), q.w());
+	return from_elements(q.m_floats[0], q.m_floats[1], q.m_floats[2], q.m_floats[3]);
 }
 
 static inline Matrix4x4 to_matrix4x4(const btTransform &t)
@@ -115,24 +115,24 @@ static inline Matrix4x4 to_matrix4x4(const btTransform &t)
 	const btVector3 o = t.m_origin;
 
 	Matrix4x4 m;
-	m.x.x = x.x();
-	m.x.y = y.x();
-	m.x.z = z.x();
+	m.x.x = x.m_floats[0];
+	m.x.y = y.m_floats[0];
+	m.x.z = z.m_floats[0];
 	m.x.w = 0.0f;
 
-	m.y.x = x.y();
-	m.y.y = y.y();
-	m.y.z = z.y();
+	m.y.x = x.m_floats[1];
+	m.y.y = y.m_floats[1];
+	m.y.z = z.m_floats[1];
 	m.y.w = 0.0f;
 
-	m.z.x = x.z();
-	m.z.y = y.z();
-	m.z.z = z.z();
+	m.z.x = x.m_floats[2];
+	m.z.y = y.m_floats[2];
+	m.z.z = z.m_floats[2];
 	m.z.w = 0.0f;
 
-	m.t.x = o.x();
-	m.t.y = o.y();
-	m.t.z = o.z();
+	m.t.x = o.m_floats[0];
+	m.t.y = o.m_floats[1];
+	m.t.z = o.m_floats[2];
 	m.t.w = 1.0f;
 
 	return m;