add support for serialization/writing DNA on big endian machines

fix for swapping endianness for nested array of structures

Extras/Serialize/BulletFileLoader/bDNA.cpp

@@ -341,6 +341,7 @@ static int name_is_array(char* name, int* dim1, int* dim2) {
 // ----------------------------------------------------- //
 void bDNA::init(char *data, int len, bool swap)
 {
+	printf("swap = %d\n",swap);
 	int *intPtr=0;short *shtPtr=0;
 	char *cp = 0;int dataLen =0;long nr=0;
 	intPtr = (int*)data;

Extras/Serialize/BulletFileLoader/bFile.cpp

@@ -140,8 +140,11 @@ void bFile::parseHeader()
 	else if (VOID_IS_8) mFlags |= FD_BITS_VARIES;
 
 	// swap endian...
-	if (header[8]=='V' && littleEndian ==1)
+	if (header[8]=='V')
+	{
+		if (littleEndian ==1)
 			mFlags |= FD_ENDIAN_SWAP;
+	}
 	else
 		if (littleEndian==0)
 			mFlags |= FD_ENDIAN_SWAP;
@@ -199,7 +202,10 @@ void bFile::parseInternal(bool verboseDumpAllTypes, char* memDna,int memDnaLengt
 	}
 
 	mMemoryDNA = new bDNA();
-	mMemoryDNA->init(memDna,memDnaLength);
+	int littleEndian= 1;
+	littleEndian= ((char*)&littleEndian)[0];
+			
+	mMemoryDNA->init(memDna,memDnaLength,littleEndian==0);
 
 
 
@@ -644,14 +650,25 @@ void bFile::swapStruct(int dna_nr, char *data)
 		if (strc[0] >= first && name[0]!='*')
 		{
 			int old_nr = mFileDNA->getReverseType(type);
+			int arrayLen = mFileDNA->getArraySizeNew(strc[1]);
+			if (arrayLen==1)
+			{
 				swapStruct(old_nr,buf);
+			} else
+			{
+				char* tmpBuf = buf;
+				for (int i=0;i<arrayLen;i++)
+				{
+					swapStruct(old_nr,tmpBuf);
+					tmpBuf+=size/arrayLen;
+				}
+			}
 		}
 		else
 		{
 			//int arrayLenOld = mFileDNA->getArraySize(name);
 			int arrayLen = mFileDNA->getArraySizeNew(strc[1]);
 			//assert(arrayLenOld == arrayLen);
-
 			swapData(buf, strc[0], arrayLen);
 		}
 		buf+=size;

src/LinearMath/btSerializer.h

@@ -77,6 +77,8 @@ public:
 #define BT_SHAPE_CODE			MAKE_ID('S','H','A','P')
 #define BT_ARRAY_CODE			MAKE_ID('A','R','A','Y')
 
+
+
 class btDefaultSerializer	:	public btSerializer
 {
 
@@ -113,19 +115,24 @@ protected:
 			return -1;
 		}
 
-		void initDNA(const char* bdna,int dnalen)
+		void initDNA(const char* bdnaOrg,int dnalen)
 		{
 			///was already initialized
 			if (m_dna)
 				return;
 
+			int littleEndian= 1;
+			littleEndian= ((char*)&littleEndian)[0];
+			
+
 			m_dna = btAlignedAlloc(dnalen,16);
-			memcpy(m_dna,bdna,dnalen);
+			memcpy(m_dna,bdnaOrg,dnalen);
 			m_dnaLength = dnalen;
 
-			int *intPtr=0;short *shtPtr=0;
+			int *intPtr=0;
+			short *shtPtr=0;
 			char *cp = 0;int dataLen =0;long nr=0;
-			intPtr = (int*)bdna;
+			intPtr = (int*)m_dna;
 
 			/*
 				SDNA (4 bytes) (magic number)
@@ -135,15 +142,18 @@ protected:
 				<string>
 			*/
 
-			if (strncmp((const char*)bdna, "SDNA", 4)==0)
+			if (strncmp((const char*)m_dna, "SDNA", 4)==0)
 			{
 				// skip ++ NAME
 				intPtr++; intPtr++;
 			}
 
 			// Parse names
+			if (!littleEndian)
+				*intPtr = btSwapEndian(*intPtr);
 				
 			dataLen = *intPtr;
+			
 			intPtr++;
 
 			cp = (char*)intPtr;
@@ -173,6 +183,9 @@ protected:
 			intPtr = (int*)cp;
 			assert(strncmp(cp, "TYPE", 4)==0); intPtr++;
 
+			if (!littleEndian)
+				*intPtr =  btSwapEndian(*intPtr);
+			
 			dataLen = *intPtr;
 			intPtr++;
 
@@ -210,6 +223,8 @@ protected:
 			shtPtr = (short*)intPtr;
 			for (int i=0; i<dataLen; i++, shtPtr++)
 			{
+				if (!littleEndian)
+					shtPtr[0] = btSwapEndian(shtPtr[0]);
 				mTlens.push_back(shtPtr[0]);
 			}
 
@@ -230,6 +245,8 @@ protected:
 			cp = (char*)intPtr;
 			assert(strncmp(cp, "STRC", 4)==0); intPtr++;
 
+			if (!littleEndian)
+				*intPtr = btSwapEndian(*intPtr);
 			dataLen = *intPtr ; 
 			intPtr++;
 
@@ -238,8 +255,26 @@ protected:
 			for (int i=0; i<dataLen; i++)
 			{
 				mStructs.push_back (shtPtr);
+				
+				if (!littleEndian)
+				{
+					shtPtr[0]= btSwapEndian(shtPtr[0]);
+					shtPtr[1]= btSwapEndian(shtPtr[1]);
+
+					int len = shtPtr[1];
+					shtPtr+= 2;
+
+					for (int a=0; a<len; a++, shtPtr+=2)
+					{
+							shtPtr[0]= btSwapEndian(shtPtr[0]);
+							shtPtr[1]= btSwapEndian(shtPtr[1]);
+					}
+
+				} else
+				{
 					shtPtr+= (2*shtPtr[1])+2;
 				}
+			}
 
 			// build reverse lookups
 			for (int i=0; i<(int)mStructs.size(); i++)