void DiMeshSerializerImpl::ImportMesh( DiDataStreamPtr& stream, DiMesh* pMesh )
{
ReadFileHeader(stream);
if (!stream->Eof())
{
uint16 streamID = ReadChunk(stream);
while(!stream->Eof() &&
(
streamID == DI_SUBMESH ||
streamID == DI_MESH_BOUNDS))
{
switch(streamID)
{
case DI_SUBMESH:
ReadSubMesh(stream, pMesh);
break;
case DI_MESH_BOUNDS:
ReadBoundsInfo(stream, pMesh);
break;
}
if (!stream->Eof())
{
streamID = ReadChunk(stream);
}
}
if (!stream->Eof())
{
stream->Skip(-MSTREAM_OVERHEAD_SIZE);
}
}
}
void OgreXmlSerializer::ReadMesh(MeshXml *mesh)
{
if (NextNode() != nnMesh) {
throw DeadlyImportError("Root node is <" + m_currentNodeName + "> expecting <mesh>");
}
DefaultLogger::get()->debug("Reading Mesh");
NextNode();
// Root level nodes
while(m_currentNodeName == nnSharedGeometry ||
m_currentNodeName == nnSubMeshes ||
m_currentNodeName == nnSkeletonLink ||
m_currentNodeName == nnBoneAssignments ||
m_currentNodeName == nnLOD ||
m_currentNodeName == nnSubMeshNames ||
m_currentNodeName == nnExtremes ||
m_currentNodeName == nnPoses ||
m_currentNodeName == nnAnimations)
{
if (m_currentNodeName == nnSharedGeometry)
{
mesh->sharedVertexData = new VertexDataXml();
ReadGeometry(mesh->sharedVertexData);
}
else if (m_currentNodeName == nnSubMeshes)
{
NextNode();
while(m_currentNodeName == nnSubMesh) {
ReadSubMesh(mesh);
}
}
else if (m_currentNodeName == nnBoneAssignments)
{
ReadBoneAssignments(mesh->sharedVertexData);
}
else if (m_currentNodeName == nnSkeletonLink)
{
mesh->skeletonRef = ReadAttribute<std::string>("name");
DefaultLogger::get()->debug("Read skeleton link " + mesh->skeletonRef);
NextNode();
}
// Assimp incompatible/ignored nodes
else
SkipCurrentNode();
}
}
int MREAData::ReadMesh(FILE* fp, int index, int segmentNum)
{
MeshData & mesh = m_meshes[index];
mesh.glList = 0;
u32 nextOffset = ftell(fp) + m_sectionSizes[segmentNum];
fread(&mesh.header.unknown0x00, 4, 1, fp);
toDWORD(mesh.header.unknown0x00);
fread(mesh.header.transformMatrix, 4, 12, fp);
for (u32 i = 0; i < 12; ++i)
{
toDWORD((u32&)mesh.header.transformMatrix[i]);
}
fread(mesh.header.boundingBox, 4, 6, fp);
for (u32 i = 0; i < 6; ++i)
{
toDWORD((u32&)mesh.header.boundingBox[i]);
}
if (0 == index)
{
// minimum
if (mesh.header.boundingBox[0] < minBounds.X)
{
minBounds.X = mesh.header.boundingBox[0];
}
if (mesh.header.boundingBox[1] < minBounds.Y)
{
minBounds.Y = mesh.header.boundingBox[1];
}
if (mesh.header.boundingBox[2] < minBounds.Z)
{
minBounds.Z = mesh.header.boundingBox[2];
}
// maximum bounds
if (mesh.header.boundingBox[3] > maxBounds.X)
{
maxBounds.X = mesh.header.boundingBox[3];
}
if (mesh.header.boundingBox[4] > maxBounds.Y)
{
maxBounds.Y = mesh.header.boundingBox[4];
}
if (mesh.header.boundingBox[5] > maxBounds.Z)
{
maxBounds.Z = mesh.header.boundingBox[5];
}
}
// move to next section data
fseek(fp, nextOffset, SEEK_SET);
++segmentNum;
nextOffset += m_sectionSizes[segmentNum];
u32 dataCount = m_sectionSizes[segmentNum] / 0x0C;
u32 dataNum = 0;
mesh.vertices.resize(dataCount);
for(dataNum=0; dataNum<dataCount; ++dataNum)
{
fread(&mesh.vertices[dataNum].X, sizeof(float), 1, fp);
fread(&mesh.vertices[dataNum].Y, sizeof(float), 1, fp);
fread(&mesh.vertices[dataNum].Z, sizeof(float), 1, fp);
toDWORD((u32&)mesh.vertices[dataNum].X);
toDWORD((u32&)mesh.vertices[dataNum].Y);
toDWORD((u32&)mesh.vertices[dataNum].Z);
const tex vert = mesh.vertices[dataNum];
if (0) // == index)
{
// minimum bounds
if (vert.X < minBounds.X)
{
minBounds.X = vert.X;
}
if (vert.Y < minBounds.Y)
{
minBounds.Y = vert.Y;
}
if (vert.Z < minBounds.Z)
{
minBounds.Z = vert.Z;
}
// maximum bounds
if (vert.X > maxBounds.X)
{
maxBounds.X = vert.X;
}
if (vert.Y > maxBounds.Y)
{
maxBounds.Y = vert.Y;
}
if (vert.Z > maxBounds.Z)
{
maxBounds.Z = vert.Z;
}
}
}
// move to next section data
fseek(fp, nextOffset, SEEK_SET);
++segmentNum;
nextOffset += m_sectionSizes[segmentNum];
signed short x, y, z;
dataCount = m_sectionSizes[segmentNum] / 0x06;
mesh.normals.resize(dataCount);
for(dataNum=0; dataNum<dataCount; ++dataNum)
{
fread(&x,sizeof(signed short),1,fp);
fread(&y,sizeof(signed short),1,fp);
fread(&z,sizeof(signed short),1,fp);
toWORD((u16&)x);
toWORD((u16&)y);
toWORD((u16&)z);
mesh.normals[dataNum].X = float(x) / 16834.0f;
mesh.normals[dataNum].Y = float(y) / 16834.0f;
mesh.normals[dataNum].Z = float(z) / 16834.0f;
}
// move to next section data
fseek(fp, nextOffset, SEEK_SET);
++segmentNum;
nextOffset += m_sectionSizes[segmentNum];
// read zero data
// move to next section data
fseek(fp, nextOffset, SEEK_SET);
++segmentNum;
nextOffset += m_sectionSizes[segmentNum];
// read texture coordinate data
dataCount = m_sectionSizes[segmentNum] / 0x08;
mesh.uvs.resize(dataCount);
for(dataNum=0; dataNum<dataCount; ++dataNum)
{
fread(&mesh.uvs[dataNum].U, sizeof(float), 1, fp);
fread(&mesh.uvs[dataNum].V, sizeof(float), 1, fp);
toDWORD((u32&)mesh.uvs[dataNum].U);
toDWORD((u32&)mesh.uvs[dataNum].V);
}
// move to next section data
fseek(fp, nextOffset, SEEK_SET);
++segmentNum;
nextOffset += m_sectionSizes[segmentNum];
// read unknown data
// move to next section data
fseek(fp, nextOffset, SEEK_SET);
++segmentNum;
nextOffset += m_sectionSizes[segmentNum];
// read sub mesh info data
fread(&mesh.subMeshInfo.subMeshCount, 4, 1, fp);
toDWORD(mesh.subMeshInfo.subMeshCount);
mesh.subMeshInfo.subMeshOffsets.resize(mesh.subMeshInfo.subMeshCount);
fread(&mesh.subMeshInfo.subMeshOffsets.front(), 4, mesh.subMeshInfo.subMeshCount, fp);
for (u32 i = 0; i < mesh.subMeshInfo.subMeshCount; ++i)
{
toDWORD(mesh.subMeshInfo.subMeshOffsets[i]);
}
// move to next section data
fseek(fp, nextOffset, SEEK_SET);
++segmentNum;
nextOffset += m_sectionSizes[segmentNum];
// read sub mesh data
for (u32 i = 0; i < mesh.subMeshInfo.subMeshCount; ++i)
{
ReadSubMesh(fp, mesh);
// move to next section data
fseek(fp, nextOffset, SEEK_SET);
++segmentNum;
nextOffset += m_sectionSizes[segmentNum];
}
return segmentNum;
}
