Change to looped writes

to avoid struct packing issues

code/AssbinExporter.cpp

@@ -207,6 +207,14 @@ inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
 	return t + Write<T>(stream,maxc);
 }
 
+template <typename T>
+inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size)
+{
+	size_t n = 0;
+	for (unsigned int i=0; i<size; i++) n += Write<T>(stream,in[i]);
+	return n;
+}
+
 	// ----------------------------------------------------------------------------------
 	/**	@class	AssbinChunkWriter
 	 *	@brief	Chunk writer mechanism for the .assbin file structure
@@ -356,7 +364,7 @@ inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
 			if (shortened) {
 				WriteBounds(&chunk,b->mWeights,b->mNumWeights);
 			} // else write as usual
-			else chunk.Write(b->mWeights,1,b->mNumWeights*sizeof(aiVertexWeight));
+			else WriteArray<aiVertexWeight>(&chunk,b->mWeights,b->mNumWeights);
 		}
 
 		// -----------------------------------------------------------------------------------
@@ -400,13 +408,13 @@ inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
 				if (shortened) {
 					WriteBounds(&chunk,mesh->mVertices,mesh->mNumVertices);
 				} // else write as usual
-				else chunk.Write(mesh->mVertices,1,12*mesh->mNumVertices);
+				else WriteArray<aiVector3D>(&chunk,mesh->mVertices,mesh->mNumVertices);
 			}
 			if (mesh->mNormals) {
 				if (shortened) {
 					WriteBounds(&chunk,mesh->mNormals,mesh->mNumVertices);
 				} // else write as usual
-				else chunk.Write(mesh->mNormals,1,12*mesh->mNumVertices);
+				else WriteArray<aiVector3D>(&chunk,mesh->mNormals,mesh->mNumVertices);
 			}
 			if (mesh->mTangents && mesh->mBitangents) {
 				if (shortened) {
@@ -414,8 +422,8 @@ inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
 					WriteBounds(&chunk,mesh->mBitangents,mesh->mNumVertices);
 				} // else write as usual
 				else {
-					chunk.Write(mesh->mTangents,1,12*mesh->mNumVertices);
-					chunk.Write(mesh->mBitangents,1,12*mesh->mNumVertices);
+					WriteArray<aiVector3D>(&chunk,mesh->mTangents,mesh->mNumVertices);
+					WriteArray<aiVector3D>(&chunk,mesh->mBitangents,mesh->mNumVertices);
 				}
 			}
 			for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
@@ -425,7 +433,7 @@ inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
 				if (shortened) {
 					WriteBounds(&chunk,mesh->mColors[n],mesh->mNumVertices);
 				} // else write as usual
-				else chunk.Write(mesh->mColors[n],16*mesh->mNumVertices,1);
+				else WriteArray<aiColor4D>(&chunk,mesh->mColors[n],mesh->mNumVertices);
 			}
 			for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
 				if (!mesh->mTextureCoords[n])
@@ -437,7 +445,7 @@ inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
 				if (shortened) {
 					WriteBounds(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
 				} // else write as usual
-				else chunk.Write(mesh->mTextureCoords[n],12*mesh->mNumVertices,1);
+				else WriteArray<aiVector3D>(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
 			}
 
 			// write faces. There are no floating-point calculations involved
@@ -532,21 +540,21 @@ inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
 					WriteBounds(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
 
 				} // else write as usual
-				else chunk.Write(nd->mPositionKeys,1,nd->mNumPositionKeys*sizeof(aiVectorKey));
+				else WriteArray<aiVectorKey>(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
 			}
 			if (nd->mRotationKeys) {
 				if (shortened) {
 					WriteBounds(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
 
 				} // else write as usual
-				else chunk.Write(nd->mRotationKeys,1,nd->mNumRotationKeys*sizeof(aiQuatKey));
+				else WriteArray<aiQuatKey>(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
 			}
 			if (nd->mScalingKeys) {
 				if (shortened) {
 					WriteBounds(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
 
 				} // else write as usual
-				else chunk.Write(nd->mScalingKeys,1,nd->mNumScalingKeys*sizeof(aiVectorKey));
+				else WriteArray<aiVectorKey>(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
 			}
 		}
 

code/AssbinLoader.cpp

@@ -121,6 +121,30 @@ aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream)
 	return m;
 }
 
+template <>
+aiVectorKey Read<aiVectorKey>(IOStream * stream)
+{
+	aiVectorKey v;
+	v.mTime = Read<double>(stream);
+	v.mValue = Read<aiVector3D>(stream);
+	return v;
+}
+
+template <>
+aiQuatKey Read<aiQuatKey>(IOStream * stream)
+{
+	aiQuatKey v;
+	v.mTime = Read<double>(stream);
+	v.mValue = Read<aiQuaternion>(stream);
+	return v;
+}
+
+template <typename T>
+void ReadArray(IOStream * stream, T * out, unsigned int size)
+{ 
+	for (unsigned int i=0; i<size; i++) out[i] = Read<T>(stream);
+}
+
 template <typename T> void ReadBounds( IOStream * stream, T* p, unsigned int n )
 {
 	// not sure what to do here, the data isn't really useful.
@@ -176,7 +200,7 @@ void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b )
 	else 
 	{
 		b->mWeights = new aiVertexWeight[b->mNumWeights];
-		stream->Read(b->mWeights,1,b->mNumWeights*sizeof(aiVertexWeight));
+		ReadArray<aiVertexWeight>(stream,b->mWeights,b->mNumWeights);
 	}
 }
 
@@ -203,7 +227,7 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
 		else 
 		{
 			mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-			stream->Read(mesh->mVertices,1,12*mesh->mNumVertices);
+			ReadArray<aiVector3D>(stream,mesh->mVertices,mesh->mNumVertices);
 		}
 	}
 	if (c & ASSBIN_MESH_HAS_NORMALS) 
@@ -214,7 +238,7 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
 		else 
 		{
 			mesh->mNormals = new aiVector3D[mesh->mNumVertices];
-			stream->Read(mesh->mNormals,1,12*mesh->mNumVertices);
+			ReadArray<aiVector3D>(stream,mesh->mNormals,mesh->mNumVertices);
 		}
 	}
 	if (c & ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS) 
@@ -226,9 +250,9 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
 		else 
 		{
 			mesh->mTangents = new aiVector3D[mesh->mNumVertices];
-			stream->Read(mesh->mTangents,1,12*mesh->mNumVertices);
+			ReadArray<aiVector3D>(stream,mesh->mTangents,mesh->mNumVertices);
 			mesh->mBitangents = new aiVector3D[mesh->mNumVertices];
-			stream->Read(mesh->mBitangents,1,12*mesh->mNumVertices);
+			ReadArray<aiVector3D>(stream,mesh->mBitangents,mesh->mNumVertices);
 		}
 	}
 	for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) 
@@ -243,7 +267,7 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
 		else 
 		{
 			mesh->mColors[n] = new aiColor4D[mesh->mNumVertices];
-			stream->Read(mesh->mColors[n],16*mesh->mNumVertices,1);
+			ReadArray<aiColor4D>(stream,mesh->mColors[n],mesh->mNumVertices);
 		}
 	}
 	for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) 
@@ -260,7 +284,7 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
 		else 
 		{
 			mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices];
-			stream->Read(mesh->mTextureCoords[n],12*mesh->mNumVertices,1);
+			ReadArray<aiVector3D>(stream,mesh->mTextureCoords[n],mesh->mNumVertices);
 		}
 	}
 
@@ -361,7 +385,7 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
 		} // else write as usual
 		else {
 			nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];
-			stream->Read(nd->mPositionKeys,1,nd->mNumPositionKeys*sizeof(aiVectorKey));
+			ReadArray<aiVectorKey>(stream,nd->mPositionKeys,nd->mNumPositionKeys);
 		}
 	}
 	if (nd->mNumRotationKeys) {
@@ -372,7 +396,7 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
 		else 
 		{
 			nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys];
-			stream->Read(nd->mRotationKeys,1,nd->mNumRotationKeys*sizeof(aiQuatKey));
+			ReadArray<aiQuatKey>(stream,nd->mRotationKeys,nd->mNumRotationKeys);
 		}
 	}
 	if (nd->mNumScalingKeys) {
@@ -383,7 +407,7 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
 		else 
 		{
 			nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys];
-			stream->Read(nd->mScalingKeys,1,nd->mNumScalingKeys*sizeof(aiVectorKey));
+			ReadArray<aiVectorKey>(stream,nd->mScalingKeys,nd->mNumScalingKeys);
 		}
 	}
 }