void DiMeshSerializer::ImportMesh( DiDataStreamPtr& stream, DiMesh* pDest )
{
DI_SERIAL_LOG("Loading mesh : %s", stream->GetName().c_str());
char sign[4];
stream->Read(sign,4);
if (CheckHead(sign))
{
uint16 version;
stream->Read(&version,sizeof(uint16));
DI_SERIAL_LOG("Mesh version: %d", version);
if (version >= MODEL_SERIAL_VERSION_NUM)
{
DI_ERROR("Unknow mesh version.");
return;
}
DiMeshSerializerImpl* impl = GetImplemention((DiMeshSerialVersion)version);
if (impl)
{
impl->ImportMesh(stream,pDest);
}
DI_DELETE impl;
return;
}
DI_ERROR("Invalid mesh file head.");
return;
}
void DiMotionSerializerImpl::ImportMotion( DiDataStreamPtr& stream, DiMotion* pDest )
{
ReadFileHeader(stream);
if (!stream->Eof())
{
uint16 streamID = ReadChunk(stream);
while(!stream->Eof() &&
(streamID == DI_SKELETON ||
streamID == DI_POSE ||
streamID == DI_ANIMATION))
{
switch(streamID)
{
case DI_SKELETON:
ReadSkeleton(stream,pDest);
break;
case DI_ANIMATION:
ReadAnimations(stream, pDest);
break;
case DI_POSE:
ReadPoses(stream,pDest);
break;
}
if (!stream->Eof())
streamID = ReadChunk(stream);
}
if (!stream->Eof())
stream->Skip(-MSTREAM_OVERHEAD_SIZE);
}
}
void DiMeshSerializerImpl::ReadSubMesh( DiDataStreamPtr& stream, DiMesh* pMesh )
{
DI_SERIAL_LOG("Reading submesh..");
DiSubMesh* sm = pMesh->CreateSubMesh();
unsigned short streamID = 0;
DiString material = ReadString(stream);
sm->SetMaterialName(material);
DI_SERIAL_LOG("Liking material: %s", material.c_str());
unsigned int indexCount = 0;
ReadInts(stream, &indexCount, 1);
DI_SERIAL_LOG("Indeices count: %d", indexCount);
bool idx32bit;
ReadBools(stream, &idx32bit, 1);
DI_SERIAL_LOG("Index size: %d", idx32bit?32:16);
uint16 primitive;
ReadShorts(stream,&primitive,1);
sm->SetPrimitiveType((DiPrimitiveType)primitive);
DI_SERIAL_LOG("Primitive type: %d", primitive);
if (indexCount > 0)
{
void* indexdata = sm->CreateIndexData(indexCount,idx32bit?TRUE:FALSE);
int size = indexCount * (sm->GetIndexSize() / 8);
stream->Read(indexdata, size);
DI_SERIAL_LOG("%d bytes readed", size);
}
streamID = ReadChunk(stream);
if (streamID != DI_GEOMETRY)
{
DI_ERROR("Bad stream ID");
return;
}
ReadGeometry(stream, sm);
if (!stream->Eof())
{
streamID = ReadChunk(stream);
if (streamID == DI_MESH_WEIGHTS)
{
ReadSubMeshBoneWeights(stream,sm);
}
else
{
if (!stream->Eof())
stream->Skip(-MSTREAM_OVERHEAD_SIZE);
}
}
}
void DiMotionSerializer::ImportMotion( DiDataStreamPtr& stream, DiMotion* pDest )
{
char sign[4];
stream->Read(sign,4);
if (sign[0] == 'D' &&
sign[1] == 'i' &&
sign[2] == 'M' &&
sign[3] == 'o')
{
uint16 version;
stream->Read(&version,sizeof(uint16));
if (version >= MOTION_SERIAL_VERSION_NUM)
{
DI_ERROR("Invalid version number!");
return;
}
DiMotionSerializerImpl* impl = GetImplemention((DiMotionSerialVersion)version);
if (impl)
{
impl->ImportMotion(stream,pDest);
}
DI_DELETE impl;
return;
}
DI_ERROR("Invalid head format!");
return;
}
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 DiMeshSerializerImpl::ReadGeometryVertexDeclaration(
DiDataStreamPtr& stream, DiSubMesh* pMesh)
{
DI_SERIAL_LOG("Reading vertex declaration info...");
uint32 elementsNum = (mCurChunkSize - MSTREAM_OVERHEAD_SIZE)/(sizeof(uint16)*4);
DI_SERIAL_LOG("Number of elements: %d", elementsNum);
if (elementsNum > 0 && !stream->Eof())
{
pMesh->GetVertexElements().ClearElements();
for (uint32 i=0; i<elementsNum; i++)
{
unsigned short source, tmp;
DiVertexType vType;
DiVertexUsage vSemantic;
ReadShorts(stream, &source, 1);
ReadShorts(stream, &tmp, 1);
vType = static_cast<DiVertexType>(tmp);
ReadShorts(stream, &tmp, 1);
vSemantic = static_cast<DiVertexUsage>(tmp);
ReadShorts(stream, &tmp, 1);
uint8 usageID = static_cast<uint8>(tmp);
pMesh->GetVertexElements().AddElement(source,vType,vSemantic,usageID);
}
}
}
void DiMeshSerializer::ExportMesh( const DiMeshPtr pMesh, DiDataStreamPtr stream )
{
static char head[4] = { 'D', 'e', 'm', 'i' };
stream->Write(head, 4);
uint16 version = MODEL_SERIAL_VERSION_NUM - 1;
stream->Write(&version,sizeof(uint16));
DiMeshSerializerImpl* impl = GetImplemention((DiMeshSerialVersion)version);
if (impl)
{
impl->ExportMesh(pMesh.get(),stream);
}
DI_DELETE impl;
}
void DiMotionSerializerImpl::ReadAnimations( DiDataStreamPtr& stream, DiMotion* motion )
{
// name
DiString name = ReadString(stream);
// length
float len = 0;
ReadFloats(stream,&len, 1);
DiAnimation* anim = motion->CreateAnimation(name,len);
if (!stream->Eof())
{
uint16 streamID = ReadChunk(stream);
while(!stream->Eof() &&
(streamID == DI_CLIPS_NODE ||
streamID == DI_CLIPS_ATTACH ||
streamID == DI_CLIPS_POSE))
{
switch(streamID)
{
case DI_CLIPS_NODE:
ReadNodeClips(stream,anim);
break;
case DI_CLIPS_POSE:
ReadPoseClips(stream,anim);
break;
case DI_CLIPS_ATTACH:
ReadAttachClips(stream,anim);
break;
}
if (!stream->Eof())
{
streamID = ReadChunk(stream);
}
}
if (!stream->Eof())
{
stream->Skip(-MSTREAM_OVERHEAD_SIZE);
}
}
}
DiString DiSerializer::ReadString( DiDataStreamPtr& stream, size_t numChars )
{
assert (numChars <= 255);
char str[255];
stream->Read(str, numChars);
str[numChars] = '\0';
return str;
}
void DiMeshSerializerImpl::ReadGeometry( DiDataStreamPtr& stream, DiSubMesh* pMesh )
{
DI_SERIAL_LOG("Reading geometry data...");
unsigned int vertexCount = 0;
ReadInts(stream, &vertexCount, 1);
pMesh->SetVerticeNum(vertexCount);
DI_SERIAL_LOG("Vertices count: %d", vertexCount);
unsigned int faceCount = 0;
ReadInts(stream, &faceCount, 1);
pMesh->SetPrimitiveCount(faceCount);
DI_SERIAL_LOG("Face count: %d", faceCount);
if (!stream->Eof())
{
unsigned short streamID = ReadChunk(stream);
while(!stream->Eof() &&
(streamID == DI_GEOMETRY_VERTEX_BUFFER ||
streamID == DI_GEOMETRY_VERTEX_DECLARATION))
{
switch (streamID)
{
case DI_GEOMETRY_VERTEX_DECLARATION:
ReadGeometryVertexDeclaration(stream, pMesh);
break;
case DI_GEOMETRY_VERTEX_BUFFER:
ReadGeometryVertexBuffer(stream, pMesh);
break;
}
if (!stream->Eof())
{
streamID = ReadChunk(stream);
}
}
if (!stream->Eof())
{
stream->Skip(-MSTREAM_OVERHEAD_SIZE);
}
}
}
bool DiMaterial::Load( DiDataStreamPtr data )
{
DiMaterialSerializer ms;
if(ms.ParseMaterial(data,this) == false)
{
DI_WARNING("Failed to load the material : %s",data->GetName().c_str());
return false;
}
return true;
}
void DiMotionSerializer::ExportMotion( const DiMotionPtr pMotion, DiDataStreamPtr stream )
{
char sign[4];
sign[0] = 'D';
sign[1] = 'i';
sign[2] = 'M';
sign[3] = 'o';
stream->Write(sign,4);
uint16 version = MOTION_SERIAL_VERSION_NUM - 1;
stream->Write(&version,sizeof(uint16));
DiMotionSerializerImpl* impl = GetImplemention((DiMotionSerialVersion)version);
if (impl)
{
impl->ExportMotion(pMotion.get(),stream);
}
DI_DELETE impl;
}
void DiSerializer::ReadFloats( DiDataStreamPtr& stream, double* pDest, size_t count )
{
float* tmp = DI_NEW float[count];
float* ptmp = tmp;
stream->Read(tmp, sizeof(float) * count);
while(count--)
{
*pDest++ = *ptmp++;
}
DI_DELETE[] tmp;
}
void DiMotionSerializerImpl::ReadSkeleton( DiDataStreamPtr& stream,DiMotion* motion )
{
DiSkeleton* skel = motion->CreateSkeleton();
uint16 blendmode;
ReadShorts(stream,&blendmode,1);
skel->SetBlendMode(SkeletonBlendMode(blendmode));
if (!stream->Eof())
{
uint16 streamID = ReadChunk(stream);
while(!stream->Eof() &&
(streamID == DI_BONES ||
streamID == DI_BONES_PARENT))
{
switch(streamID)
{
case DI_BONES:
ReadBones(stream,skel);
break;
case DI_BONES_PARENT:
ReadBonesParents(stream,skel);
break;
}
if (!stream->Eof())
{
streamID = ReadChunk(stream);
}
}
if (!stream->Eof())
{
stream->Skip(-MSTREAM_OVERHEAD_SIZE);
}
}
}
void DiMeshSerializerImpl::ReadGeometryVertexBuffer(
DiDataStreamPtr& stream, DiSubMesh* pMesh )
{
DI_SERIAL_LOG("Reading vertex buffer...");
uint16 bindIndex, vertexSize;
ReadShorts(stream, &bindIndex, 1);
ReadShorts(stream, &vertexSize, 1);
uint32 size = vertexSize * pMesh->GetVerticeNum();
void* buf = pMesh->CreateSourceData(bindIndex,pMesh->GetVerticeNum(),vertexSize);
stream->Read(buf, size);
DI_SERIAL_LOG("%d bytes readed", size);
}
DiString DiSerializer::ReadString( DiDataStreamPtr& stream )
{
return stream->GetLine();
}
void DiSerializer::ReadBools( DiDataStreamPtr& stream, bool* pDest, size_t count )
{
stream->Read(pDest, sizeof(bool) * count);
}
void DiSerializer::ReadFloats( DiDataStreamPtr& stream, float* pDest, size_t count )
{
stream->Read(pDest, sizeof(float) * count);
}
void DiSerializer::ReadShorts( DiDataStreamPtr& stream, uint16* pDest, size_t count )
{
stream->Read(pDest, sizeof(unsigned short) * count);
}
void DiSerializer::ReadInts( DiDataStreamPtr& stream, uint32* pDest, size_t count )
{
stream->Read(pDest, sizeof(unsigned int) * count);
}
