bool ObjReader::readData(char *filename) {
numOfTexels = 0;
numOfVertices = 0;
numOfNormals = 0;
numOfPolygons = 0;
vertices = new vector<Vertex *>(INITIAL_VECTOR_SIZE);
texels = new vector<Texel *>(INITIAL_VECTOR_SIZE);
normals = new vector<Normal *>(INITIAL_VECTOR_SIZE);
polygons = new vector<Polygon3 *>(INITIAL_VECTOR_SIZE);
ifstream *datafile = new ifstream(filename);
if (datafile->is_open())
{
char controlSymbol;
char buffer[1024];
while (!datafile->eof()) {
*datafile >> controlSymbol;
if (!datafile->eof()) {
switch (controlSymbol) {
case 'v': //vertex data
readVertexData(datafile);
break;
case 'f': //polygon data
readPolygonData(datafile);
break;
default:
datafile->getline(buffer, 1024);
break;
}
}
}
datafile->close();
return true;
}else {
void fbxLoader2::readVertexData(FbxNode* node)
{
if(node->GetNodeAttribute())
{
switch(node->GetNodeAttribute()->GetAttributeType())
{
case FbxNodeAttribute::eMesh:
vertexMaxCount += node->GetMesh()->GetControlPointsCount();
indicesMaxCount += node->GetMesh()->GetPolygonVertexCount();
printf("");
break;
}
}
for(int i = 0; i<node->GetChildCount(); i++)
{
readVertexData(node->GetChild(i));
}
}
//! (static)
Mesh * StreamerMMF::loadMesh(std::istream & input) {
// std::cout << "\nloadMMF...";
Reader reader(input);
uint32_t format = reader.read_uint32();
if(format!=MMF_HEADER) {
WARN(std::string("wrong mesh format: ") + Util::StringUtils::toString(format));
return nullptr;
}
uint32_t version = reader.read_uint32();
if(version>MMF_VERSION) {
WARN(std::string("can't read mesh, version to high: ") + Util::StringUtils::toString(version));
return nullptr;
}
auto mesh = new Mesh;
uint32_t blockType = reader.read_uint32();
while(blockType != StreamerMMF::MMF_END && input.good()) {
// blocksize is discarded.
uint32_t blockSize = reader.read_uint32();
switch(blockType) {
case StreamerMMF::MMF_VERTEX_DATA:
readVertexData(mesh, reader);
break;
case StreamerMMF::MMF_INDEX_DATA:
readIndexData(mesh, reader);
break;
default:
WARN("LoaderMMF::loadMesh: unknown data block found.");
std::cout << "blockSize:"<<blockSize<<" \n";
reader.skip(blockSize);
break;
}
blockType = reader.read_uint32();
}
// std::cout << "done.\n";
return mesh;
}
void fbxLoader2::loadFbx(char* filename)
{
//create memory manager
loaderManager = FbxManager::Create();
//create settings for input/output
ios = FbxIOSettings::Create(loaderManager, IOSROOT);
loaderManager->SetIOSettings(ios);
lImporter = FbxImporter::Create(loaderManager, "");
lImportStatus = lImporter->Initialize(filename, -1, loaderManager->GetIOSettings());
scene = FbxScene::Create(loaderManager, "newscene");
FbxAxisSystem SceneAxisSystem = scene->GetGlobalSettings().GetAxisSystem();
FbxAxisSystem OurAxisSystem(FbxAxisSystem::eYAxis, FbxAxisSystem::eParityOdd, FbxAxisSystem::eLeftHanded);
lImporter->Import(scene);
lImporter->Destroy();
lRootNode = scene->GetRootNode();
//int numberOfChildren = lRootNode->GetChildCount();
skeleton = new SkeletalData();
animationStructure = new AnimationData();
buildSkeleton(findSkeletonRootBone(lRootNode));
readAnimationTakeData(findSkeletonRootBone(lRootNode)->GetChild(0));
readVertexData(lRootNode);
indices = new indexesStructure[indicesMaxCount];
vertexArray = new vertexWeights[vertexMaxCount];
processNode(lRootNode);
//processMesh(lRootNode);
/*for (int i = 0; i< numberOfChildren; i++)
{
lNode = lRootNode->GetChild(i);
printf("Child name: %s\n", lNode->GetName());
lMesh = lNode->GetMesh();
if(lMesh == NULL)
{
printf("No mesh here\n");
}
else
{
if(lMesh->IsTriangleMesh())
{
int numVerts = lMesh->GetControlPointsCount();
for (int j = 0; j < numVerts; j++)
{
FbxVector4 vert = lMesh->GetControlPointAt(j);
Vertices[numberVertices].x = (float)vert.mData[0];
Vertices[numberVertices].y = (float)vert.mData[1];
Vertices[numberVertices].z = (float)vert.mData[2];
numberVertices++;
}
int *indices = lMesh->GetPolygonVertices();
numIndices+= lMesh->GetPolygonVertexCount();
}
else
{
printf("Mesh not triangulated\n");
}
}
}*/
}
