void ReaderWriterTest::testReader()
{
#define READ_FILE(filename, objtype, reader) \
{ \
OSLM_WARN("testing : <" << filename << "> (" << #objtype << ") with <" << reader << ">" ); \
const ::boost::filesystem::path file = ::fwTest::Data::dir() / filename; \
::fwData::objtype::sptr object = ::fwData::objtype::New(); \
runImageSrv("::io::IReader", reader, getIOConfiguration(file), object); \
} \
READ_FILE( "fw4spl/PatientDB/yaf/generated-patientdb.yaf" , PatientDB, "::ioXML::FwXMLGenericReaderService");
READ_FILE( "fw4spl/PatientDB/yaf/generated-patientdb.yaf" , PatientDB, "::ioXML::FwXMLPatientDBReaderService");
READ_FILE( "fw4spl/Patient/yaf/generated-patient.yaf" , Patient , "::ioXML::FwXMLGenericReaderService");
READ_FILE( "fw4spl/aquisition/yaf/generated-acquisition.yaf" , Acquisition, "::ioXML::FwXMLGenericReaderService");
// READ_FILE( "fw4spl/image/yaf/image-double.yaf" , Image, "::ioXML::FwXMLGenericReaderService");
// READ_FILE( "fw4spl/image/yaf/image-float.yaf" , Image, "::ioXML::FwXMLGenericReaderService");
// READ_FILE( "fw4spl/image/yaf/image-int16.yaf" , Image, "::ioXML::FwXMLGenericReaderService");
// READ_FILE( "fw4spl/image/yaf/image-int32.yaf" , Image, "::ioXML::FwXMLGenericReaderService");
// READ_FILE( "fw4spl/image/yaf/image-int64.yaf" , Image, "::ioXML::FwXMLGenericReaderService");
// READ_FILE( "fw4spl/image/yaf/image-int8.yaf" , Image, "::ioXML::FwXMLGenericReaderService");
// READ_FILE( "fw4spl/image/yaf/image-uint16.yaf" , Image, "::ioXML::FwXMLGenericReaderService");
// READ_FILE( "fw4spl/image/yaf/image-uint32.yaf" , Image, "::ioXML::FwXMLGenericReaderService");
// READ_FILE( "fw4spl/image/yaf/image-uint64.yaf" , Image, "::ioXML::FwXMLGenericReaderService");
// READ_FILE( "fw4spl/image/yaf/image-uint8.yaf" , Image, "::ioXML::FwXMLGenericReaderService");
}
void Model::ReadNode(std::fstream &file, Node * node, std::map<unsigned int, Node*> &map)
{
unsigned int data;
READ_FILE(data);
map[data] = node;
READ_SZ_FILE(node->meshes);
if (data>0) READ_FILE_EX(&node->meshes[0], node->meshes.size() * sizeof(unsigned int));
READ_SZ_FILE(node->children);
for (unsigned i = 0; i < node->children.size(); i++)
ReadNode(file, &node->children[i], map);
}
FFError FFHeaderI::Read(char const *_filename)
{
if (_filename)
{
if (filename) delete[] filename;
filename = new char [strlen(_filename)+1];
strcpy(filename,_filename);
}
FILE *h = OpenGameFile(filename, FILEMODE_READONLY, FILETYPE_PERM);
if (h == NULL)
{
ReportError(filename);
return FF_COULDNOTOPENFILE;
}
// reset vars
Clear();
char magic[4];
unsigned long rffl_version;
size_t num_files;
size_t total_headsize;
DWORD bytes_read;
READ_FILE(filename,(void)0,fclose(h),h,magic,4,bytes_read,0)
READ_FILE(filename,(void)0,fclose(h),h,&rffl_version,4,bytes_read,0)
READ_FILE(filename,(void)0,fclose(h),h,&num_files,4,bytes_read,0)
READ_FILE(filename,(void)0,fclose(h),h,&total_headsize,4,bytes_read,0)
READ_FILE(filename,(void)0,fclose(h),h,&length,4,bytes_read,0)
if (strncmp(magic,"RFFL",4))
{
ReportError(filename,"Incorrect file type");
fclose(h);
return FF_COULDNOTREADFILE;
}
if (rffl_version>0)
{
ReportError(filename,"Version not supported");
fclose(h);
return FF_COULDNOTREADFILE;
}
void * header = malloc(total_headsize);
READ_FILE(filename,(void)0,fclose(h),h,header,total_headsize,bytes_read,0)
data = malloc(length);
READ_FILE(filename,(void)0,fclose(h),h,data,length,bytes_read,0)
fclose(h);
// now parse the header
void * headerP = header;
for (unsigned int i=0; i<num_files; ++i)
{
char const * fnameP = (char *)((size_t)headerP + 8);
size_t leng = *(size_t *)((size_t)headerP + 4);
void * dataP = (void *)((size_t)data + *(size_t *)headerP);
files[HashFunction(fnameP)].add_entry(FFDataI(fnameP,dataP,leng));
// increment pointer
headerP = (void *)((size_t)headerP + 8 + strlen(fnameP) +4&~3);
}
free(header);
return FF_OK;
}
void Model::LoadModel(std::string filename)
{
std::fstream file;
file.open("models\\" + filename, std::fstream::in | std::fstream::binary);
if (file.fail())
{
std::cout << "Couldn't open file for loading: " << filename << std::endl;
return;
}
std::map<unsigned int, Node*> map;
bool tree;
READ_FILE(tree);
if (tree)
{
m_animationtree = new AnimatedModelInfo;
ReadNode(file, &m_animationtree->rootnode, map);
}
unsigned int data;
std::vector<SkinVertex> svertices;
std::vector<Vertex> vertices;
std::vector<unsigned short> indices;
READ_SZ_FILE(m_meshes);
for (unsigned i = 0; i < m_meshes.size(); ++i)
{
unsigned int bns_sz;
READ_FILE(bns_sz);
if (bns_sz > 0 && tree)
{
READ_SZ_FILE(svertices);
if (data > 0) READ_FILE_EX(&svertices[0], svertices.size() * sizeof(SkinVertex));
}
else
{
READ_SZ_FILE(vertices);
if (data > 0) READ_FILE_EX(&vertices[0], vertices.size() * sizeof(Vertex));
}
READ_SZ_FILE(indices);
if (data > 0) READ_FILE_EX(&indices[0], indices.size() * sizeof(unsigned short));
if (bns_sz > 0 && tree)
{
m_meshes[i].LoadData(svertices, indices);
m_meshes[i].m_bones->resize(bns_sz);
for (unsigned j = 0; j < m_meshes[i].m_bones->size(); ++j)
{
Bone * bn = &(*m_meshes[i].m_bones)[j];
READ_FILE(data);
bn->node = map[data];
READ_FILE_EX(&bn->offset[0][0], 4 * 4 * sizeof(float));
}
}
else
m_meshes[i].LoadData(vertices, indices);
char str[100];
READ_FILE(data);
READ_FILE_EX(str, data);
str[data] = '\0';
m_meshes[i].SetTexture(LoadTexture("textures\\" +std::string(str)));
m_meshes[i].SetRenderer(m_renderer);
}
if (tree)
{
READ_SZ_FILE(m_animationtree->animations);
for (unsigned i = 0; i < m_animationtree->animations.size(); ++i)
{
Animation * anim = &m_animationtree->animations[i];
READ_FILE(anim->duration);
READ_FILE(anim->speed);
READ_SZ_FILE(anim->nodeanims);
for (unsigned j = 0; j < anim->nodeanims.size(); ++j)
{
NodeAnim * nodeanim = &anim->nodeanims[j];
READ_FILE(data);
nodeanim->node = map[data];
READ_SZ_FILE(nodeanim->poskeys);
if (data > 0) READ_FILE_EX(&nodeanim->poskeys[0], nodeanim->poskeys.size() * sizeof(VecKey));
READ_SZ_FILE(nodeanim->rotkeys);
if (data > 0) READ_FILE_EX(&nodeanim->rotkeys[0], nodeanim->rotkeys.size() * sizeof(RotKey));
}
}
}
READ_FILE(m_boundvolume.m_parent);
READ_SZ_FILE(m_boundvolume.m_children);
if (data > 0) READ_FILE_EX(&m_boundvolume.m_children[0], m_boundvolume.m_children.size() * sizeof(BoundVolume));
file.close();
}
