int create_folders(char *path) {
/*
* Recursively create all folders for the given path. Returns -1 on
* failure and 0 on success.
*/
char tmp[2048];
char *p = NULL;
int success;
size_t len;
tmp[0] = 0;
strcat(tmp, path);
len = strlen(tmp);
if (tmp[len - 1] == PATHSEP)
tmp[len - 1] = 0;
for (p = tmp + 1; *p; p++) {
if (*p == PATHSEP && *(p-1) != ':') {
*p = 0;
success = create_folder(tmp);
if (success != -2 && success != 0)
return success;
*p = PATHSEP;
}
}
success = create_folder(tmp);
if (success != -2 && success != 0)
return success;
return 0;
}
void outdata::write_final_data(class_worker &worker, class_stats &stats){
if (worker.team->is_commander()) {
folder = "outdata/final/";
create_folder(folder);
string name_E = folder + string("E.dat");
string name_M = folder + string("M.dat");
string name_T = folder + string("T.dat");
string name_s = folder + string("s.dat");
string name_c = folder + string("c.dat");
string name_m = folder + string("m.dat");
string name_u = folder + string("u.dat");
string name_f = folder + string("f.dat");
string name_x = folder + string("x.dat");
string name_dos1D = folder + string("dos1D.dat");
string name_dos = folder + string("dos.dat");
string name_D = folder + string("D.dat");
string name_F = folder + string("F.dat");
string name_P = folder + string("P.dat");
write_to_file(stats.E_avg, name_E);
write_to_file(stats.M_avg, name_M);
write_to_file(stats.T, name_T);
write_to_file(stats.s_avg, name_s);
write_to_file(stats.c_avg, name_c);
write_to_file(stats.m_avg, name_m);
write_to_file(stats.u_avg, name_u);
write_to_file(stats.f_avg, name_f);
write_to_file(stats.x_avg, name_x);
write_to_file(stats.dos1D_avg, name_dos1D);
write_to_file(stats.dos_avg, name_dos);
write_to_file(stats.D_avg, name_D);
write_to_file(stats.F_avg, name_F);
write_to_file(stats.P_avg, name_P);
name_s = folder + string("s_err.dat");
name_c = folder + string("c_err.dat");
name_m = folder + string("m_err.dat");
name_u = folder + string("u_err.dat");
name_f = folder + string("f_err.dat");
name_x = folder + string("x_err.dat");
name_dos1D = folder + string("dos1D_err.dat");
name_dos = folder + string("dos_err.dat");
name_D = folder + string("D_err.dat");
name_F = folder + string("F_err.dat");
name_P = folder + string("P_err.dat");
write_to_file(stats.s_err, name_s);
write_to_file(stats.c_err, name_c);
write_to_file(stats.m_err, name_m);
write_to_file(stats.u_err, name_u);
write_to_file(stats.f_err, name_f);
write_to_file(stats.x_err, name_x);
write_to_file(stats.dos1D_err, name_dos1D);
write_to_file(stats.dos_err, name_dos);
write_to_file(stats.D_err, name_D);
write_to_file(stats.F_err, name_F);
write_to_file(stats.P_err, name_P);
}
}
static void create_folder_tree()
{
struct message_folder *parent, *child;
folder_tree = create_folder("/", "FILTER (!BOUND(?msg))");
parent = create_folder("telecom", "FILTER (!BOUND(?msg))");
folder_tree->subfolders = g_slist_append(folder_tree->subfolders,
parent);
child = create_folder("msg", "FILTER (!BOUND(?msg))");
parent->subfolders = g_slist_append(parent->subfolders, child);
parent = child;
child = create_folder("inbox", "?msg nmo:isSent \"false\" ; "
"nmo:isDeleted \"false\" ; "
"nmo:isDraft \"false\". ");
parent->subfolders = g_slist_append(parent->subfolders, child);
child = create_folder("sent", "?msg nmo:isDeleted \"false\" ; "
"nmo:isSent \"true\" . ");
parent->subfolders = g_slist_append(parent->subfolders, child);
child = create_folder("deleted", "?msg nmo:isDeleted \"true\" . ");
parent->subfolders = g_slist_append(parent->subfolders, child);
}
HRESULT Camera::takePicture(HWND hwndOwner,LPTSTR pszFilename)
{
HRESULT hResult = S_OK;
#if defined(_WIN32_WCE) && !defined( OS_PLATFORM_MOTCE )
SHCAMERACAPTURE shcc;
StringW root;
convertToStringW(rho_rhodesapp_getblobsdirpath(), root);
wsprintf( pszFilename, L"%s", root.c_str() );
create_folder(pszFilename);
//LPCTSTR szExt = wcsrchr(pszFilename, '.');
TCHAR filename[256];
generate_filename(filename,L".jpg");
// Set the SHCAMERACAPTURE structure.
ZeroMemory(&shcc, sizeof(shcc));
shcc.cbSize = sizeof(shcc);
shcc.hwndOwner = hwndOwner;
shcc.pszInitialDir = pszFilename;
shcc.pszDefaultFileName = filename;
shcc.pszTitle = TEXT("Camera");
shcc.VideoTypes = CAMERACAPTURE_VIDEOTYPE_MESSAGING;
shcc.nResolutionWidth = 176;
shcc.nResolutionHeight = 144;
shcc.nVideoTimeLimit = 15;
shcc.Mode = CAMERACAPTURE_MODE_STILL;
// Display the Camera Capture dialog.
hResult = SHCameraCapture(&shcc);
// The next statements will execute only after the user takes
// a picture or video, or closes the Camera Capture dialog.
if (S_OK == hResult) {
LPTSTR fname = get_file_name(shcc.szFile,pszFilename);
if (fname) {
StringCchCopy(pszFilename, MAX_PATH, fname);
free(fname);
} else {
LOG(ERROR) + "takePicture error get file: " + shcc.szFile;
hResult = E_INVALIDARG;
}
}else
{
LOG(ERROR) + "takePicture failed with code: " + LOGFMT("0x%X") + hResult;
}
#endif //_WIN32_WCE
return hResult;
}
bool Database::folder_create(void) {
_BOOL_ success = create_folder(directory_path.c_str(), NULL);
if(success == 0) {
_ERR_ err = _OBTAIN_LAST_ERROR;
// These are windows api macros that must be changed later on for compatibility reasons.
if(err == ERROR_ALREADY_EXISTS) {
db_error = get_error_msg(Errors::error_folder_already_exists);
} else if(err == ERROR_PATH_NOT_FOUND) {
db_error = get_error_msg(Errors::error_path_not_found);
}
}
return bool(success);
}
HRESULT Camera::selectPicture(HWND hwndOwner,LPTSTR pszFilename) {
RHO_ASSERT(pszFilename);
OPENFILENAMEEX ofn = {0};
ofn.lStructSize = sizeof(ofn);
ofn.lpstrFilter = NULL;
ofn.lpstrFile = pszFilename;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrInitialDir = NULL;
ofn.lpstrTitle = _T("Select an image");
ofn.ExFlags = OFN_EXFLAG_THUMBNAILVIEW|OFN_EXFLAG_NOFILECREATE|OFN_EXFLAG_LOCKDIRECTORY;
if (GetOpenFileNameEx(&ofn)) {
HRESULT hResult = S_OK;
TCHAR rhoroot[MAX_PATH];
wchar_t* root = wce_mbtowc(RhoGetRootPath());
wsprintf(rhoroot,L"%s%s",root,L"apps\\public\\db-files");
free(root);
create_folder(rhoroot);
TCHAR filename[256];
generate_filename(filename);
int len = wcslen(rhoroot) + wcslen(L"\\") + wcslen(filename);
wchar_t* full_name = (wchar_t*) malloc((len+2)*sizeof(wchar_t));
wsprintf(full_name,L"%s\\%s",rhoroot,filename);
if (copy_file(pszFilename,full_name)) {
StringCchCopy(pszFilename, MAX_PATH, filename);
} else {
hResult = E_INVALIDARG;
}
free(full_name);
return hResult;
} else if (GetLastError()==ERROR_SUCCESS) {
return S_FALSE; //user cancel op
}
return E_INVALIDARG;
}
HRESULT Camera::takePicture(HWND hwndOwner,LPTSTR pszFilename) {
HRESULT hResult;
SHCAMERACAPTURE shcc;
wchar_t* root = wce_mbtowc(RhoGetRootPath());
wsprintf(pszFilename,L"%s%s",root,L"apps\\public\\db-files");
free(root);
create_folder(pszFilename);
TCHAR filename[256];
generate_filename(filename);
// Set the SHCAMERACAPTURE structure.
ZeroMemory(&shcc, sizeof(shcc));
shcc.cbSize = sizeof(shcc);
shcc.hwndOwner = hwndOwner;
shcc.pszInitialDir = pszFilename;
shcc.pszDefaultFileName = filename;
shcc.pszTitle = TEXT("Camera");
shcc.VideoTypes = CAMERACAPTURE_VIDEOTYPE_MESSAGING;
shcc.nResolutionWidth = 176;
shcc.nResolutionHeight = 144;
shcc.nVideoTimeLimit = 15;
shcc.Mode = CAMERACAPTURE_MODE_STILL;
// Display the Camera Capture dialog.
hResult = SHCameraCapture(&shcc);
// The next statements will execute only after the user takes
// a picture or video, or closes the Camera Capture dialog.
if (S_OK == hResult) {
LPTSTR fname = get_file_name(shcc.szFile,pszFilename);
if (fname) {
StringCchCopy(pszFilename, MAX_PATH, fname);
free(fname);
} else {
hResult = E_INVALIDARG;
}
}
return hResult;
}
static HRESULT WINAPI
NewMenu_ContextMenu3_InvokeCommand(IContextMenu3 *iface, LPCMINVOKECOMMANDINFO info)
{
NewMenuImpl *This = impl_from_IContextMenu3(iface);
IShellBrowser *browser;
IShellView *view = NULL;
HRESULT hr = E_FAIL;
TRACE("(%p)->(%p)\n", This, info);
/* New Folder */
if (info->lpVerb == 0)
{
if ((browser = (IShellBrowser *)SendMessageA(info->hwnd, CWM_GETISHELLBROWSER, 0, 0)))
{
if (FAILED(IShellBrowser_QueryActiveShellView(browser, &view)))
view = NULL;
}
hr = create_folder(This, view);
if (view) IShellView_Release(view);
}
return hr;
}
int data_compiler_main(bx::CommandLine* cmdline)
{
delete_file(DC_RESULT);
int err = kErrorSuccess;
uint32_t timeMS = ::GetTickCount();
LOG_INIT("DataCompilerLog.html", "Data Compiler");
MemoryConfig cfg;
memset(&cfg, 0, sizeof cfg);
cfg.m_debugMemSize = SIZE_MB(2);
g_memoryMgr.init(cfg);
#ifdef DC_DUMP_PROFILE
g_profiler.init(TOTAL_BLOCK_NUM);
#endif
register_engine_factories();
g_config = new DC_Config;
const char* inputChar = cmdline->findOption('i');
if(!inputChar) inputChar = "intermediate";
const char* outputFolderChar = cmdline->findOption('o');
if(!outputFolderChar) outputFolderChar = "data";
const char* threadChar = cmdline->findOption('t');
if(threadChar) g_config->m_numThreads = atoi(threadChar);
g_config->m_ignoreTextures = cmdline->hasArg("ignore_texture");
g_config->m_slient = cmdline->hasArg("slient");
g_config->m_bundled = cmdline->hasArg("bundle");
g_config->m_forceRecompile = cmdline->hasArg('b');
create_folder("data");
g_config->m_database.load(DC_DATABASE);
g_config->m_inputDir = inputChar;
string_replace(g_config->m_inputDir, "\\", "/");
add_trailing_slash(g_config->m_inputDir);
g_config->m_topFolder = get_top_folder(g_config->m_inputDir);
g_config->m_outputDir = input_to_output(g_config->m_inputDir);
ENGINE_ASSERT(g_config->m_topFolder.length(), "top folder error.");
string_replace(g_config->m_outputDir, "\\", "/");
add_trailing_slash(g_config->m_outputDir);
std::string secondFolder = remove_top_folder(g_config->m_outputDir);
if(secondFolder.length()) g_config->m_packageName = get_top_folder(secondFolder);
LOGI("input = %s, output = %s, top-folder = %s, package-name=%s",
g_config->m_inputDir.c_str(),
g_config->m_outputDir.c_str(),
g_config->m_topFolder.c_str(),
g_config->m_packageName.c_str());
level_processing();
resources_process();
if(g_config->m_compilers.size() < 10) g_config->m_numThreads = 0;
if(g_config->m_numThreads < 2)
{
for(size_t i=0; i<g_config->m_compilers.size(); ++i)
{
g_config->m_compilers[i]->go();
}
}
else
{
const int maxThreads = 8;
if(g_config->m_numThreads > maxThreads) g_config->m_numThreads = maxThreads;
uint32_t totalNum = g_config->m_compilers.size();
uint32_t numPerThread = totalNum / g_config->m_numThreads + 1;
bx::Thread* threads[maxThreads];
std::vector<BaseCompiler*> compilers[maxThreads];
uint32_t currIndex = 0;
for (int i=0; i<g_config->m_numThreads; ++i)
{
uint32_t elementNum = numPerThread;
uint32_t numLeft = totalNum - currIndex;
if(numLeft < elementNum) elementNum = numLeft;
if(elementNum == 0) continue;
std::vector<BaseCompiler*>& comArray = compilers[i];
comArray.resize(elementNum);
memcpy(&comArray[0], &g_config->m_compilers[currIndex], elementNum*sizeof(void*));
currIndex += elementNum;
if(i == 0) continue;
threads[i] = new bx::Thread();
threads[i]->init(thread_compile, &comArray);
}
//main thread with other threads.
thread_compile(&compilers[0]);
for (int i=1; i<g_config->m_numThreads; ++i)
{
delete threads[i];
}
}
g_config->post_process();
package_processing();
timeMS = ::GetTickCount() - timeMS;
if(!g_config->m_slient) g_config->m_error.show_error();
g_config->m_database.save(DC_DATABASE);
g_config->m_database.m_files.clear();
SAFE_DELETE(g_config);
#ifdef DC_DUMP_PROFILE
g_profiler.dump_to_file("data_compiler_profile.txt", true, true);
g_profiler.shutdown();
#endif
g_memoryMgr.shutdown();
LOGD("******************************************************");
LOGD("******************************************************");
LOGD("* TOTAL TIME COST = %d[MS] *", timeMS);
LOGD("******************************************************");
LOGD("******************************************************");
LOG_TERM();
return err;
}
int main()
{
User new_user; //初始化用户信息
new_user.username = "******";
new_user.password = "******";
user.push_back(new_user);
string username;
string password;
string command;
string subcommand;
string temp_path;
char t;
init();
save();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN);
cout << "welcome to system" << endl;
cout << "please login" << endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_BLUE|FOREGROUND_GREEN|FOREGROUND_RED);
while (1)
{
username = "";
password = "";
cout << "username:"******"password:"******"username or password error" << endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_BLUE|FOREGROUND_GREEN|FOREGROUND_RED);
}
}
system("cls");
getline(cin, command);
while (1)
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_BLUE);
cout << username;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN|FOREGROUND_RED);
cout << "@filesystem ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_BLUE);
if (path.size() == 1)
cout << "/";
else
{
for (auto p : path)
{
if (p == 0)
continue;
cout << "/" << catalog[p].info.name;
}
}
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_BLUE|FOREGROUND_GREEN|FOREGROUND_RED);
cout << endl << ">";
getline(cin, command);
stringstream command_stream(command);
command_stream >> subcommand;
if (subcommand == "")
{
}
else if (subcommand == "cd")
{
change_path(command);
}
else if (subcommand == "ls")
{
show_folder(command);
}
else if (subcommand == "create")
{
create(command);
}
else if (subcommand == "mkdir")
{
create_folder(command);
}
else if (subcommand == "delete")
{
delete_file(command);
}
else if (subcommand == "edit")
{
edit(command);
}
else if (subcommand == "search")
{
search_file(command);
}
else if (subcommand == "open")
{
open_file(command);
}
else if (subcommand == "close")
{
close_file(command);
}
else if (subcommand == "cp")
{
copy(command);
}
else if (subcommand == "mv")
{
move(command);
}
else if (subcommand == "bs"){
backstage();
}
else if (subcommand == "l"){
l();
}
else if (subcommand == "info"){
info();
}
else if (subcommand == "format")
{
remove("disk.txt");
remove("diskdata.txt");
init();
}
else
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED);
cout << "command not found" << endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_BLUE|FOREGROUND_GREEN|FOREGROUND_RED);
}
cout << endl;
save();
command = "";
subcommand = "";
}
}
void outdata::create_iteration_folder_worker(const int iter){
set_foldername_to_iteration(iter);
create_folder(folder);
}
void outdata::create_iteration_folder_commander(class_worker &worker, int iter){
if(worker.team->is_commander()){
set_foldername_to_iteration(iter);
create_folder(folder);
}
}
void outdata::create_set_folder(string folder_name){
folder = folder_name;
create_folder(folder);
}
int main()
{
string username;
string password;
string command;
string subcommand;
string temp_path;
char t;
load_user();
init();
save();
while (1)
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN);
cout << "welcome to system" << endl;
cout << "please login" << endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
while (1)
{
username = "";
password = "";
cout << "username:"******"password:"******"username or password error" << endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
}
}
system("cls");
getline(cin, command);
while (1)
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE);
cout << username;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED);
cout << "@filesystem ";
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_BLUE);
if (path.size() == 1)
cout << "/";
else
{
for (auto p : path)
{
if (p == 0)
continue;
cout << "/" << catalog[p].info.name;
}
}
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
cout << endl << ">";
getline(cin, command);
stringstream command_stream(command);
command_stream >> subcommand;
if (subcommand == "")
{
}
else if (subcommand == "cd")
{
change_path(command);
}
else if (subcommand == "ls")
{
show_folder(command);
}
else if (subcommand == "create")
{
create(command);
}
else if (subcommand == "mkdir")
{
create_folder(command);
}
else if (subcommand == "delete")
{
delete_file(command);
}
else if (subcommand == "edit")
{
edit(command);
}
else if (subcommand == "search")
{
search_file(command);
}
else if (subcommand == "open")
{
open_file(command);
}
else if (subcommand == "close")
{
close_file(command);
}
else if (subcommand == "cp")
{
copy(command);
}
else if (subcommand == "mv")
{
move(command);
}
else if (subcommand == "bs"){
backstage();
}
else if (subcommand == "l"){
l();
}
else if (subcommand == "info"){
info();
}
else if (subcommand == "format")
{
char c;
cout << "Are you sure you want to format the disk?(y/N)";
c = _getch();
if (c == 'n' || c == 'N' || c == '\r')
{
cout << c << endl;
continue;
}
else if (c == 'y' || c == 'Y')
{
remove("disk.txt");
remove("diskdata.txt");
init();
cout << c << "\nformat complete" << endl;
}
}
else if (subcommand == "useradd")
{
add_user(command);
}
else if (subcommand == "userdelete")
{
delete_user(command);
}
else if (subcommand == "passwd")
{
change_password(command);
}
else if (subcommand == "clear")
{
system("cls");
}
else if (subcommand == "exit")
{
system("cls");
break;
}
else
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED);
cout << "command not found" << endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
}
cout << endl;
save();
command = "";
subcommand = "";
}
}
}
int havok_convert_main(bx::CommandLine* cmdline)
{
#ifdef HAVOK_COMPILE
uint32_t timeMS = GetTickCount();
int err = kErrorSuccess;
LOG_INIT("HavokConverterLog.html", "Havok Converter");
MemoryConfig cfg;
memset(&cfg, 0, sizeof(cfg));
cfg.m_debugMemSize = SIZE_MB(2);
cfg.m_initHavok = true;
cfg.m_havokFrameMemSize = 0;
cfg.m_havokMonitorMemSize = 0;
g_memoryMgr.init(cfg);
#ifdef HC_DUMP_PROFILE
g_profiler.init(64);
#endif
register_engine_factories();
g_hc_config = new HC_Config;
g_hc_config->m_packNormal = cmdline->hasArg("packnormal");
g_hc_config->m_packUV = cmdline->hasArg("packuv");
g_hc_config->m_slient = cmdline->hasArg("slient");
g_hc_config->m_verbose = cmdline->hasArg("verbose");
g_hc_config->m_merge = !cmdline->hasArg('b');
Actor_Config config;
ActorConverter* converter = 0;
const char* mode = cmdline->findOption('m');
if(!mode)
mode = "model";
const char* class_name = cmdline->findOption('c');
if(!class_name)
class_name = "level_geometry";
const char* input = cmdline->findOption('f');
const char* output = cmdline->findOption('o');
if(!input)
{
g_hc_config->m_error.add_error("havok convert must specific f args!");
err = kErrorArg;
goto error_exit;
}
config.m_exportMode = mode;
config.m_input = input;
config.m_exportName = getFileName(input);
config.m_exportFolder = "";
config.m_rootPath = "";
config.m_exportClass = class_name;
if(output)
{
std::string output_path = output;
string_replace(output_path, "\\", "/");
if (str_begin_with(output_path, "./"))
{
output_path = output_path.substr(2, output_path.length() - 2);
}
if(!str_begin_with(output_path, INTERMEDIATE_PATH))
config.m_exportFolder = std::string(INTERMEDIATE_PATH) + output_path;
else
config.m_exportFolder = output_path;
add_trailing_slash(config.m_exportFolder);
std::string path = config.m_exportFolder;
string_replace(path, INTERMEDIATE_PATH, "");
config.m_rootPath = path;
LOGD("export-folder=%s *********** root-folder=%s", config.m_exportFolder.c_str(), config.m_rootPath.c_str());
}
else
{
config.m_exportFolder = TEMP_PATH;
}
config.m_output = config.m_exportFolder + config.m_exportName + "." + std::string(EngineNames::ACTOR);
config.m_loader = new hkLoader;
hkRootLevelContainer* rlc = config.m_loader->load(config.m_input.c_str());
if (!rlc)
{
g_hc_config->m_error.add_error("can not load input havok file %s", config.m_input.c_str());
err = kErrorLoadHavok;
goto error_exit;
}
config.m_rlc = rlc;
create_folder(config.m_exportFolder);
hkxEnvironment* env = LOAD_OBJECT(rlc, hkxEnvironment);
if(env)
{
hkStringBuf env_str;
env->convertToString(env_str);
LOGI(env_str.cString());
config.m_assetFolder = env->getVariableValue("assetFolder");
config.m_assetPath = env->getVariableValue("assetPath");
}
hkaAnimationContainer* ac = LOAD_OBJECT(rlc, hkaAnimationContainer);
hkxScene* scene = LOAD_OBJECT(rlc,hkxScene);
hkpPhysicsData* data = LOAD_OBJECT(rlc, hkpPhysicsData);
config.m_scene = scene;
config.m_animation = ac;
config.m_physics = data;
if(config.m_exportMode == "model")
{
if(!scene || !scene->m_rootNode)
{
g_hc_config->m_error.add_error("hkx file do not has root scene node.");
goto error_exit;
}
converter = new StaticModelConverter;
converter->setClass(config.m_exportClass);
}
else if(config.m_exportMode == "skin")
{
converter = new CharacterConverter;
converter->setClass("character");
}
else if(config.m_exportMode == "level")
{
converter = new LevelConverter;
config.m_output = config.m_exportFolder + config.m_exportName + "." + std::string(EngineNames::LEVEL);
}
else if(config.m_exportMode == "animation")
{
converter = new AnimationConverter;
config.m_output = config.m_exportFolder + config.m_exportName + "." + std::string(EngineNames::ANIMATION);
}
if(!converter)
{
g_hc_config->m_error.add_error("havok converter export mode error.");
err = kErrorArg;
goto error_exit;
}
converter->m_config = &config;
converter->setName(config.m_exportName);
if(config.m_exportMode == "skin")
{
converter->process(ac);
}
else if(config.m_exportMode == "animation")
{
converter->process(ac);
}
else
{
converter->process(scene);
}
converter->postProcess();
converter->serializeToFile(config.m_output.c_str());
error_exit:
SAFE_REMOVEREF(converter);
SAFE_REMOVEREF(config.m_loader);
if(!g_hc_config->m_slient)
g_hc_config->m_error.show_error();
SAFE_DELETE(g_hc_config);
#ifdef HC_DUMP_PROFILE
g_profiler.dump_to_file("havokconverter_profile.txt", true, true);
g_profiler.shutdown();
#endif
g_memoryMgr.shutdown();
timeMS = GetTickCount() - timeMS;
LOGD("******************************************************");
LOGD("******************************************************");
LOGD("* TOTAL TIME COST = %d[MS]", timeMS);
LOGD("******************************************************");
LOGD("******************************************************");
LOG_TERM();
#endif
return kErrorSuccess;
}
char *
m_draft (char *folder, char *msg, int use, int *isdf)
{
register char *cp;
register struct msgs *mp;
static char buffer[BUFSIZ];
if (*isdf == -1 || folder == NULL || *folder == '\0') {
if (*isdf == -1 || (cp = context_find ("Draft-Folder")) == NULL) {
*isdf = 0;
return m_maildir (msg && *msg ? msg : draft);
} else {
folder = path (*cp == '+' || *cp == '@' ? cp + 1 : cp,
*cp != '@' ? TFOLDER : TSUBCWF);
}
}
*isdf = 1;
chdir (m_maildir (""));
strncpy (buffer, m_maildir (folder), sizeof(buffer));
create_folder (buffer, 0, done);
if (chdir (buffer) == -1)
adios (buffer, "unable to change directory to");
if (!(mp = folder_read (folder)))
adios (NULL, "unable to read folder %s", folder);
/*
* Make sure we have enough message status space for all
* the message numbers from 1 to "new", since we might
* select an empty slot. If we add more space at the
* end, go ahead and add 10 additional slots.
*/
if (mp->hghmsg >= mp->hghoff) {
if (!(mp = folder_realloc (mp, 1, mp->hghmsg + 10)))
adios (NULL, "unable to allocate folder storage");
} else if (mp->lowoff > 1) {
if (!(mp = folder_realloc (mp, 1, mp->hghoff)))
adios (NULL, "unable to allocate folder storage");
}
mp->msgflags |= ALLOW_NEW; /* allow the "new" sequence */
/*
* If we have been give a valid message name, then use that.
* Else, if we are given the "use" option, then use the
* current message. Else, use special sequence "new".
*/
if (!m_convert (mp, msg && *msg ? msg : use ? "cur" : "new"))
done (1);
seq_setprev (mp);
if (mp->numsel > 1)
adios (NULL, "only one message draft at a time!");
snprintf (buffer, sizeof(buffer), "%s/%s", mp->foldpath, m_name (mp->lowsel));
cp = buffer;
seq_setcur (mp, mp->lowsel);/* set current message for folder */
seq_save (mp); /* synchronize message sequences */
folder_free (mp); /* free folder/message structure */
return cp;
}
void control(void)
{
uint16_t work_slice;
char c = 0;
while(c != 27)
{
c = getch();
if(c == 80)
{
opt_slice = (opt_slice_init*) &mem[(cursor.ID_slice - 1)*32];
if(opt_slice->next_slice != 0)
{
cursor.ID_slice = opt_slice->next_slice;
opt_slice = (opt_slice_init*) &mem[(cursor.ID_slice - 1)*32];
cursor.ID_file = opt_slice->ID_file;
cursor.ID_folder = opt_slice->ID_folder;
}
system("cls");
output_PC();
//cursor(output_PC)
}
if(c == 72)
{
opt_slice = (opt_slice_init*) &mem[(cursor.ID_slice - 1)*32];
if(opt_slice->prev_slice != 0)
{
prev_opt_slice = (opt_slice_init*) &mem[(opt_slice->prev_slice - 1)*32];
if(prev_opt_slice->ID_folder == opt_slice->ID_folder)
{
cursor.ID_slice = opt_slice->prev_slice;
opt_slice = (opt_slice_init*) &mem[(cursor.ID_slice - 1)*32];
cursor.ID_file = opt_slice->ID_file;
cursor.ID_folder = opt_slice->ID_folder;
}
}
system("cls");
output_PC();
//cursor(output_PC)
}
if(c == 13)
{
opt_slice = (opt_slice_init*) &mem[(cursor.ID_slice - 1)*32];
if(opt_slice->safe == 3)
{
cursor.ID_slice = opt_slice->next_slice_folder;
opt_slice = (opt_slice_init*) &mem[(cursor.ID_slice - 1)*32];
cursor.ID_file = opt_slice->ID_file;
cursor.ID_folder = opt_slice->ID_folder;
}
system("cls");
output_PC();
//cursor(output_PC)
}
if(c == 8)
{
opt_slice = (opt_slice_init*) &mem[(cursor.ID_slice - 1)*32];
if(opt_slice->ID_folder != 1)
{
work_slice = find_first_file_in_folder(cursor.ID_slice);
opt_slice = (opt_slice_init*) &mem[(work_slice - 1)*32];
prev_opt_slice = (opt_slice_init*) &mem[(opt_slice->prev_slice - 1)*32];
work_slice = find_first_file_in_folder(opt_slice->prev_slice_folder);
opt_slice = (opt_slice_init*) &mem[(work_slice - 1)*32];
cursor.ID_slice = opt_slice->ID_slice;
cursor.ID_file = opt_slice->ID_file;
cursor.ID_folder = opt_slice->ID_folder;
system("cls");
output_PC();
//cursor(output_PC)
}
}
if(c == 32)
{
system("cls");
printf("Enter name temporary and value: \n");
scanf("%s %u", &name_file, &val_temp);
//getch();
//printf("Enter value temporary \n");
//scanf("/u", &val_temp);
create_file(&name_file[0], val_temp);
system("cls");
output_PC();
//cursor(output_PC)
}
if(c == 57)
{
system("cls");
printf("Enter name folder, name first temporary in folder\n and her value: \n ");
scanf("%s %s %u", &name_folder, &name_file, &val_temp);
//getch();
//printf("Enter value temporary \n");
//scanf("/u", &val_temp);
create_folder(&name_folder[0], &name_file[0], val_temp);
system("cls");
output_PC();
//cursor(output_PC)
}
if(c == 56)
{
system("cls");
printf("Enter name temporary and value: \n");
scanf("%s %u", &name_file, &val_temp);
change_file(&name_file[0], val_temp);
system("cls");
output_PC();
}
if(c == 55)
{
system("cls");
printf("Enter name folder: \n");
scanf("%s", &name_folder);
change_folder(&name_folder[0]);
system("cls");
output_PC();
}
}
}
int main(int arg, char *args[])
{
set_folder_template();
if(args[1]!=NULL)
{
printf("Projeto: %s \n",args[1]);
if(args[2]!=NULL && verified_folder(args[1]))
{
path = args[1];
printf("Namespace: %s\n",args[2]);
int verified = verified_namespace(args[2]);
if(verified==1)
{
name_space = args[2];
printf("criando pasta do modulo \n");
if(create_folder(args[3]))
{
module = args[3];
printf("pasta criada \n");
char* option;
scanf("tipo do modulo %s\n",&option);
printf("%s\n",option);
}
else
{
printf("erro ao criar o folder \n");
}
}
else
{
printf("não existe namespace com esse nome \n ");
if(args[2]!=NULL && verified == 0)
{
printf("criando o namespace \n");
if(create_folder(args[2]))
{
name_space = args[2];
chdir(args[2]);
printf("criando pasta do modulo \n");
if(create_folder(args[3]))
{
printf("pasta criada \n");
chdir(args[3]);
set_module(args[3]);
printf("selecione a opção de módulo que você deseja\n");
printf("1. simples(etc/config.xml, diretório controller e Block ).\n2. básico (todos os diretórios e também o arquivo de configuração). \n");
int option;
printf("escolha o tipo do módulo:\n");
scanf("%d",&option);
printf("opção escolhida %d\n",option);
printf("criando template");
create_template(option);
}
else
{
printf("erro ao criar o folder \n");
}
}else{
printf("erro ao criar o namespace \n");
}
}else{
printf("verifique a estrutura de seu projeto \n");
}
}
}
else
printf("Nenhum namespace foi especificado \n");
}
else
{
printf("Nenhum Projeto foi especificado \n");
}
return 0;
}