Scene3DMesh* SGMExporter::ConvertMesh(IGameNode* meshNode)
{
std::string meshNodeName = StringUtils::ToNarrow(meshNode->GetName());
Log::LogT("exporting node '%s'", meshNodeName.c_str());
IGameMesh *gMesh = (IGameMesh*)meshNode ->GetIGameObject();
assert(gMesh);
if (!gMesh ->InitializeData())
{
Log::LogT("error: couldnt initialize data, skipping node");
return NULL;
}
if (!gMesh->IsObjectSkinned())
{
Log::LogT("Mesh '%s' is not skinned", meshNodeName.c_str());
meshNode->ReleaseIGameObject();
return NULL;
}
else
Log::LogT("Mesh '%s' is skinned", meshNodeName.c_str());
Scene3DMesh *mesh = new Scene3DMesh();
mesh->id = meshNode->GetNodeID();
mesh->name = StringUtils::ToNarrow(meshNode->GetName());
CollectProperties(mesh, gMesh);
IGameMaterial *mat = meshNode ->GetNodeMaterial();
if (mat != NULL)
mesh->materialName = StringUtils::ToNarrow(mat->GetMaterialName());
IGameSkin* skin = gMesh->GetIGameSkin();
for (int i = 0; i < skin->GetTotalSkinBoneCount(); i++)
mesh->bonesIds.push_back(skin->GetIGameBone(i)->GetNodeID());
for (int i = 0; i < gMesh ->GetNumberOfFaces(); i++)
ExtractVertices(skin, gMesh ->GetFace(i), gMesh, mesh->vertices);
Log::LogT("Min bones = %d, max bones = %d", dbgMinBonesCount, dbgMaxBonesCount);
meshNode ->ReleaseIGameObject();
return mesh;
}
void Unreal3DExport::RegisterMaterial( IGameNode* node, IGameMesh* mesh, FaceEx* f, FJSMeshTri* tri )
{
tri->TextureNum = f->matID;
int matid = f->matID;
IGameMaterial* mat = mesh->GetMaterialFromFace(f);
if( mat )
{
Tab<TSTR*> tokens = TokStr(mat->GetMaterialName(),_T(" \t,;"));
for( int i=0; i!=tokens.Count(); ++i )
{
if( MatchPattern(*tokens[i],TSTR(_T("F=*")),TRUE) )
{
SplitStr(*tokens[i],_T('='));
tri->Flags = static_cast<byte>(_ttoi(tokens[i]->data()));
}
}
tokens.Delete(0,tokens.Count());
if( Materials.Count() <= matid )
{
Materials.Append(matid-Materials.Count()+1,&sMaterial::DefaultMaterial);
}
if( Materials[matid].Mat != mat )
{
Materials[matid].Mat = mat;
}
/*for( int i=0; i!=mat->GetSubMaterialCount(); ++i )
{
IGameMaterial* sub = mat->GetSubMaterial(i);
if( sub )
{
TSTR matname = sub->GetMaterialName();
int subid = mat->GetMaterialID(i);
int x = 0;
}
}*/
}
}
bool MeshXMLExporter::Export(OutputMap& output)
{
try {
// write XML to a strstream
std::stringstream of;
while (!m_submeshNames.empty())
m_submeshNames.pop();
if (m_pGame) {
m_pGame->ReleaseIGame();
m_pGame = 0;
}
m_ei->theScene->EnumTree(this);
m_pGame = GetIGameInterface();
IGameConversionManager* cm = GetConversionManager();
cm->SetCoordSystem(IGameConversionManager::IGAME_OGL);
m_pGame->InitialiseIGame(m_nodeTab, false);
m_pGame->SetStaticFrame(0);
int nodeCount = m_pGame->GetTopLevelNodeCount();
if (nodeCount == 0) {
MessageBox(GetActiveWindow(), "No nodes available to export, aborting...", "Nothing To Export", MB_ICONINFORMATION);
m_pGame->ReleaseIGame();
return false;
}
// if we are writing everything to one file, use the name provided when the user first started the export;
// otherwise, create filenames on the basis of the node (submesh) names
std::string fileName;
IGameNode* node = m_pGame->GetTopLevelNode(0);
if (!m_config.getExportMultipleFiles())
fileName = m_config.getExportFilename();
else {
fileName = m_config.getExportPath() + "\\";
fileName += node->GetName();
fileName += ".mesh.xml";
}
// write start of XML data
streamFileHeader(of);
int nodeIdx = 0;
std::map<std::string, std::string> materialScripts;
while (nodeIdx < nodeCount) {
std::string mtlName;
IGameNode* node = m_pGame->GetTopLevelNode(nodeIdx);
IGameObject* obj = node->GetIGameObject();
// InitializeData() is important -- it performs all of the WSM/time eval for us; no data without it
obj->InitializeData();
IGameMaterial* mtl = node->GetNodeMaterial();
if (mtl == NULL)
mtlName = m_config.getDefaultMaterialName();
else
mtlName = mtl->GetMaterialName();
// clean out any spaces the user left in their material name
std::string::size_type pos;
while ((pos = mtlName.find_first_of(' ')) != std::string::npos)
mtlName.replace(pos, 1, _T("_"));
if (materialScripts.find(mtlName) == materialScripts.end()) {
// export new material script
MaterialExporter mexp(m_config, m_materialMap);
std::string script;
mexp.buildMaterial(mtl, mtlName, script);
materialScripts[mtlName] = script;
}
//if (streamSubmesh(of, node, mtlName))
if (streamSubmesh(of, obj, mtlName))
m_submeshNames.push(std::string(node->GetName()));
node->ReleaseIGameObject();
nodeIdx++;
if (m_config.getExportMultipleFiles() || nodeIdx == nodeCount) {
// write end of this file's XML
streamFileFooter(of);
// insert new filename --> stream pair into output map
output[fileName] = std::string(of.str());
of.str("");
if (nodeIdx != nodeCount) {
fileName = m_config.getExportPath() + "\\";
node = m_pGame->GetTopLevelNode(nodeIdx);
fileName += node->GetName();
fileName += ".mesh.xml";
// start over again with new data
streamFileHeader(of);
}
}
}
m_pGame->ReleaseIGame();
// export materials if we are writing those
if (m_config.getExportMaterial()) {
std::ofstream materialFile;
materialFile.open((m_config.getExportPath() + "\\" + m_config.getMaterialFilename()).c_str(), std::ios::out);
if (materialFile.is_open()) {
for (std::map<std::string, std::string>::iterator it = materialScripts.begin();
it != materialScripts.end(); ++it)
{
materialFile << it->second;
}
materialFile.close();
}
}
return true;
}
catch (...) {
MessageBox(GetActiveWindow(), "An unexpected error has occurred while trying to export, aborting", "Error", MB_ICONEXCLAMATION);
if (m_pGame)
m_pGame->ReleaseIGame();
return false;
}
}
