void copySysOSX(const char* projName)
{
#ifdef _DEBUG
const char * appName = "MaratisPlayerDebug";
#else
const char * appName = "MaratisPlayer";
#endif
MWindow * window = MWindow::getInstance();
MEngine* engine = MEngine::getInstance();
MSystemContext* system = engine->getSystemContext();
char filename[256];
getLocalFilename(filename, system->getWorkingDirectory(), projName);
if(char* ext = strstr(filename, ".mproj"))
{
MProject proj;
if(proj.loadXML(projName))
{
strcpy(ext, ".app");
char path[256];
char srcName[256];
char destName[256];
char appPath[256];
char level[256];
getLocalFilename(level, system->getWorkingDirectory(), proj.startLevel.c_str());
getGlobalFilename(appPath, getPubDir(), filename);
sprintf(path, "../../../%s.app", appName);
getGlobalFilename(srcName, window->getCurrentDirectory(), path);
copyDirectory(srcName, appPath);
strcpy(ext, "");
sprintf(srcName, "%s/Contents/MacOS/%s", appPath, appName);
strcpy(ext, ".mproj");
embedProject(srcName, srcName, filename, level, proj.renderer.c_str());
chmod(srcName, 0777);
// we need to put all data in app/Contents/Resources/
sprintf(destName, "%s/Contents/Resources", appPath);
createDirectory(destName);
s_dataDir = destName;
}
}
}
void MaratisPlayer::loadProject(MProject* proj, const char * filename)
{
MWindow * window = MWindow::getInstance();
MEngine * engine = MEngine::getInstance();
// working directory
char workingDir[256];
getRepertory(workingDir, filename);
window->setWorkingDirectory(workingDir);
// restart
restart();
loadGamePlugin();
// renderer
changeRenderer(proj->renderer.c_str());
// if we have a package manager, try to load the package
if(MPackageManager* pPackMan = MEngine::getInstance()->getPackageManager())
{
char projName[256];
getLocalFilename(projName, workingDir, filename);
if(char* ext = strstr(projName, ".mproj"))
{
sprintf(ext, ".npk");
char packageFile[256];
getGlobalFilename(packageFile, workingDir, projName);
pPackMan->loadPackage(packageFile);
}
}
// load start level
engine->loadLevel(proj->startLevel.c_str());
}
bool MProject::saveXML(const char * filename)
{
FILE * file = fopen(filename, "wt");
if(! file)
return false;
// get rep
char rep[256];
getRepertory(rep, filename);
char version[] = "3.0";
fprintf(file, "<Maratis version=\"%s\">\n\n", version);
fprintf(file, "<Project>\n\n");
// renderer
if(renderer.size() > 0)
{
fprintf(file, "\t<renderer name=\"%s\" />\n", renderer.c_str());
}
// start
{
// file
char levelFilename[256];
getLocalFilename(levelFilename, rep, startLevel.c_str());
fprintf(file, "\t<start file=\"%s\" />\n\n", levelFilename);
}
fprintf(file, "</Project>\n\n");
fprintf(file, "</Maratis>");
fclose(file);
return true;
}
bool MWindow::getOpenMultipleFiles(const char * title, const char * filter, string * repertory, list <string> * filesList)
{
const char * currentDir = getCurrentDirectory();
setActive(false);
static char filename[65536];
OPENFILENAME fn;
memset(&fn, 0, sizeof(fn));
strcpy(filename, "");
fn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_LONGNAMES | OFN_EXPLORER | OFN_ALLOWMULTISELECT;
fn.lStructSize = sizeof(fn);
fn.lpstrFilter = filter;
fn.lpstrFile = filename;
fn.nMaxFile = 65536*4;
fn.lpstrTitle = title;
fn.hwndOwner = m_hWnd;
filename[0] = NULL;
if(GetOpenFileName(&fn))
{
setCurrentDirectory(currentDir);
if(fn.nFileOffset < lstrlen(filename))
{
char rep[256];
getRepertory(rep, filename);
getLocalFilename(filename, rep, filename);
(*repertory) = rep;
filesList->push_back(filename);
}
else
{
char filePath[256];
strcpy(filePath, filename);
filePath[fn.nFileOffset] = 0;
(*repertory) = filePath;
while(filename[fn.nFileOffset] != 0)
{
char Message[256];
strcpy(Message, filename+fn.nFileOffset);
filesList->push_back(Message);
fn.nFileOffset += (strlen(filename+fn.nFileOffset) + 1);
}
}
setActive(true);
return true;
}
setActive(true);
return false;
}
bool MEmbedFile::IsFile(const char* name)
{
M_PROFILE_SCOPE(MEmbedFile::IsFile);
MEngine* engine = MEngine::getInstance();
MSystemContext* system = engine->getSystemContext();
char localFilename[256];
getLocalFilename(localFilename, system->getWorkingDirectory(), name);
return strcmp(localFilename, m_Filename) == 0;
}
void copySysLinux(const char* projName)
{
#ifdef _DEBUG
const char * appName = "MaratisPlayerDebug";
#else
const char * appName = "MaratisPlayer";
#endif
MEngine* engine = MEngine::getInstance();
MSystemContext* system = engine->getSystemContext();
char filename[256];
getLocalFilename(filename, system->getWorkingDirectory(), projName);
if(char* ext = strstr(filename, ".mproj"))
{
*ext = 0;
MProject proj;
if(proj.loadXML(projName))
{
char destName[256];
getGlobalFilename(destName, getPubDir(), filename);
char level[256];
getLocalFilename(level, system->getWorkingDirectory(), proj.startLevel.c_str());
strcpy(ext, ".mproj");
embedProject(appName, destName, filename, level, proj.renderer.c_str());
chmod(destName, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
// find all dynamic libraries
copyDirFiles(".", getPubDir(), ".so");
}
}
}
void copySysWindows(const char* projName)
{
#ifdef _DEBUG
const char * appName = "MaratisPlayerDebug.exe";
#else
const char * appName = "MaratisPlayer.exe";
#endif
MEngine* engine = MEngine::getInstance();
MSystemContext* system = engine->getSystemContext();
char filename[256];
getLocalFilename(filename, system->getWorkingDirectory(), projName);
if(char* ext = strstr(filename, ".mproj"))
{
MProject proj;
if(proj.loadXML(projName))
{
strcpy(ext, ".exe");
char destName[256];
getGlobalFilename(destName, getPubDir(), filename);
char level[256];
getLocalFilename(level, system->getWorkingDirectory(), proj.startLevel.c_str());
// we need the project "filename" to still be a .mproj for MaratisPlayer to behave
// correctly
strcpy(ext, ".mproj");
embedProject(appName, destName, filename, level, proj.renderer.c_str());
// find all dynamic libraries
copyDirFiles(".", getPubDir(), ".dll");
}
}
}
bool includeFile(SpriteNode* node, TiXmlElement* includeNode, SpriteBlock* &oldSibling)
{
// get path... ugly
char configfilepath[FILENAME_BUFFERSIZE] = {0};
const char* documentRef = getDocument(includeNode);
if (!getLocalFilename(configfilepath,includeNode->Attribute("file"),documentRef))
{
return false;
}
ALLEGRO_PATH * incpath = al_create_path(configfilepath);
al_append_path_component(incpath, "include");
TiXmlDocument doc( al_path_cstr(incpath, ALLEGRO_NATIVE_PATH_SEP) );
al_destroy_path(incpath);
bool loadOkay = doc.LoadFile();
TiXmlHandle hDoc(&doc);
TiXmlElement* elemParent;
if(!loadOkay)
{
contentError("Include failed",includeNode);
WriteErr("File load failed: %s\n",configfilepath);
WriteErr("Line %d: %s\n",doc.ErrorRow(),doc.ErrorDesc());
return false;
}
elemParent = hDoc.FirstChildElement("include").Element();
if( elemParent == NULL)
{
contentError("Main <include> node not present",&doc);
return false;
}
TiXmlElement* elemNode = elemParent->FirstChildElement();
if (elemNode == NULL)
{
contentError("Empty include",elemParent);
return false;
}
while (elemNode)
{
if (!readNode(node, elemNode, elemParent, oldSibling))
return false;
elemNode = elemNode->NextSiblingElement();
}
return true;
}
static void writeDataRef(MFile * file, MDataRef * dataRef, const char * rep)
{
char localFile[256];
bool state = false;
if(dataRef)
{
const char * filename = dataRef->getFilename();
if(filename != NULL)
state = true;
}
M_fwrite(&state, sizeof(bool), 1, file);
if(state)
{
getLocalFilename(localFile, rep, dataRef->getFilename());
writeString(file, localFile);
}
}
/*--------------------------------------------------------------------------------
* MPackageFileOpenHook::open
* File open callback
*-------------------------------------------------------------------------------*/
MFile* MPackageFileOpenHook::open(const char* path, const char* mode)
{
MEngine* engine = MEngine::getInstance();
MSystemContext * system = engine->getSystemContext();
char localFilename[256];
getLocalFilename(localFilename, system->getWorkingDirectory(), path);
if(strstr(mode, "w") != 0)
return MStdFile::getNew(path, mode);
// look within the package for a file with the requested name
if(MPackageEnt ent = engine->getPackageManager()->findEntity(localFilename))
return MPackageFile::getNew(ent);
// give up, just look for a new file using stdio
return MStdFile::getNew(path, mode);
}
MPackage openProjectPackage(const char* projName)
{
MEngine* engine = MEngine::getInstance();
MSystemContext* system = engine->getSystemContext();
char projFile[256];
getLocalFilename(projFile, system->getWorkingDirectory(), projName);
char* ext = strstr(projFile, ".mproj");
if(ext == 0)
{
return 0;
}
sprintf(ext, ".npk");
char packFile[256];
getGlobalFilename(packFile, getDataDir(), projFile);
MPackageManager* packageManager = engine->getPackageManager();
MPackage package = packageManager->openPackage(packFile);
return package;
}
void execute(const char* projName)
{
MEngine* engine = MEngine::getInstance();
MSystemContext* system = engine->getSystemContext();
MPackageManager* packageManager = engine->getPackageManager();
char directory[256], localFilename[256];
getGlobalFilename(directory, system->getWorkingDirectory(), "meshs");
vector<string> files;
readDirectory(directory, &files, 1, 1);
MLevel* currentLevel = engine->getLevel();
MLevel* tempLevel = new MLevel();
engine->setLevel(tempLevel);
MMesh* mesh = MMesh::getNew();
MArmatureAnim* armAnim = MArmatureAnim::getNew();
MTexturesAnim* texAnim = MTexturesAnim::getNew();
MMaterialsAnim* matAnim = MMaterialsAnim::getNew();
// open package and scan meshes
MPackage package = openProjectPackage(projName);
for(int i = 0; i < files.size(); ++i)
{
bool binarized = false;
if(strstr(files[i].c_str(), "._bin") != 0)
continue;
// export bin
if(strstr(files[i].c_str(), ".mesh") != 0)
{
if(engine->getMeshLoader()->loadData(files[i].c_str(), mesh))
binarized = exportMeshBin((files[i] + "._bin").c_str(), mesh);
}
else if (strstr(files[i].c_str(), ".maa") != 0)
{
if(engine->getArmatureAnimLoader()->loadData(files[i].c_str(), armAnim))
binarized = exportArmatureAnimBin((files[i] + "._bin").c_str(), armAnim);
}
else if (strstr(files[i].c_str(), ".mma") != 0)
{
if(engine->getMaterialsAnimLoader()->loadData(files[i].c_str(), matAnim))
binarized = exportMaterialsAnimBin((files[i] + "._bin").c_str(), matAnim);
}
else if (strstr(files[i].c_str(), ".mta") != 0)
{
if(engine->getTexturesAnimLoader()->loadData(files[i].c_str(), texAnim))
binarized = exportTexturesAnimBin((files[i] + "._bin").c_str(), texAnim);
}
else
{
// try to export unknow format
if(engine->getMeshLoader()->loadData(files[i].c_str(), mesh))
{
binarized = exportMeshBin((files[i] + "._bin").c_str(), mesh);
// try to export animation
MArmatureAnimRef * maaRef = mesh->getArmatureAnimRef();
if(maaRef)
{
exportArmatureAnimBin((files[i] + ".maa._bin").c_str(), maaRef->getArmatureAnim());
getLocalFilename(localFilename, system->getWorkingDirectory(), (files[i] + ".maa").c_str());
packageManager->addFileToPackage((files[i] + ".maa._bin").c_str(), package, localFilename);
}
}
}
tempLevel->clear();
// pack file
getLocalFilename(localFilename, system->getWorkingDirectory(), files[i].c_str());
if(binarized)
packageManager->addFileToPackage((files[i] + "._bin").c_str(), package, localFilename); // pack bin file
else
packageManager->addFileToPackage(files[i].c_str(), package, localFilename); // pack original file
}
packageManager->closePackage(package);
// clear mesh
mesh->destroy();
armAnim->destroy();
texAnim->destroy();
matAnim->destroy();
// remove bin
for(int i = 0; i < files.size(); ++i)
{
remove((files[i] + "._bin").c_str());
remove((files[i] + ".maa._bin").c_str());
}
// restore level
engine->setLevel(currentLevel);
SAFE_DELETE(tempLevel);
}
