void UMaxFind::StartFileFinder()
{
TCHAR szExeFile[_MAX_PATH];
TSTR szPath;
PROCESS_INFORMATION process;
STARTUPINFO si;
BOOL res;
memset(&si, 0, sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
si.wShowWindow = SW_SHOWDEFAULT;
si.hStdError = NULL;
GetModuleFileName(NULL, szExeFile, _MAX_PATH);
SplitFilename(TSTR(szExeFile), &szPath, NULL, NULL);
szPath = szPath+GetString(IDS_EXE_FILENAME);
res = CreateProcess(NULL, szPath, NULL, NULL, FALSE, 0, NULL, NULL, &si, &process);
if (!res) {
// Error
TSTR msg = GetString(IDS_ERROR);
MessageBox(hPanel, GetString(IDS_NOEXE), msg, MB_OK | MB_ICONEXCLAMATION);
return;
}
CloseHandle(process.hThread);
}
PyObject* CGenethonDoc::setPythonPath(CString& fileName) {
CString filePath;
CString appName;
SplitFilename(fileName, &filePath, &appName);
PyObject* sysPath = PySys_GetObject("path");
PyObject* pyPath = PyUnicode_FromString(filePath);
PyList_Append(sysPath, pyPath);
Py_DECREF(pyPath);
pyPath = PyUnicode_FromString("c:/users/karl/Anaconda3");
PyList_Append(sysPath, pyPath);
Py_DECREF(pyPath);
pyPath = PyUnicode_FromString("c:/users/karl/Anaconda3/Lib");
PyList_Append(sysPath, pyPath);
Py_DECREF(pyPath);
pyPath = PyUnicode_FromString("c:/users/karl/Anaconda3/Dlls");
PyList_Append(sysPath, pyPath);
Py_DECREF(pyPath);
pyPath = PyUnicode_FromString("c:/users/karl/Anaconda3/Lib/site-packages");
PyList_Append(sysPath, pyPath);
Py_DECREF(pyPath);
PyObject*pName = PyUnicode_DecodeFSDefault(appName);
PyObject*pModule = PyImport_Import(pName);
Py_DECREF(pName);
return pModule;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------
void SplitFullFilename( const std::string& qualifiedName,
std::string& outBasename, std::string& outExtention, std::string& outPath )
{
std::string fullName;
SplitFilename( qualifiedName, fullName, outPath );
SplitBaseFilename( fullName, outBasename, outExtention );
}
rapp_platform_ros_communications::ontologyLoadDumpSrv::Response KnowrobWrapper::dumpOntologyQuery(rapp_platform_ros_communications::ontologyLoadDumpSrv::Request req)
{
rapp_platform_ros_communications::ontologyLoadDumpSrv::Response res;
std::string path = getenv("HOME");
path=path+std::string("/rapp_platform_files/");
if(req.file_url.empty()) // || req.file_url==std::string("")
{
res.success=false;
res.trace.push_back(std::string("Empty file path"));
res.trace.push_back(req.file_url);
res.error=std::string("Empty file path");
return res;
}
size_t pathDepth = std::count(req.file_url.begin(), req.file_url.end(), '/');
std::string str2 ("/");
std::size_t found = req.file_url.find(str2);
if (found!=std::string::npos && pathDepth>1)
{
std::string folderFromPath=SplitFilename(req.file_url);
const char * c = folderFromPath.c_str();
if(!checkIfFileExists(c))
{
res.success=false;
res.trace.push_back(std::string("Path does not exist, invalid folder?"));
res.trace.push_back(req.file_url);
res.error=std::string("Path does not exist, invalid folder?");
return res;
}
}
req.file_url=path+req.file_url;
std::string query = std::string("rdf_save('") + req.file_url + std::string("')");
json_prolog::PrologQueryProxy results = pl.query(query.c_str());
char status = results.getStatus();
if(status==0)
{
res.success=false;
//std_msgs::String temp_std_msgs_string;
//temp_std_msgs_string.data=std::string("Ontology dump failed");
res.trace.push_back(std::string("Ontology dump failed"));
res.error=std::string("Ontology dump failed");
return res;
}
else if(status==3)
{
res.success=true;
}
return res;
}
bool SURFFeatureManager::LoadFeatureSet() {
DIR *dir = opendir(kDataFolder);
struct dirent *dir_ent = NULL;
char folder[64];
char filepath[128];
while ((dir_ent = readdir(dir)) != NULL) {
if (strcmp(".", dir_ent->d_name) == 0 ||
strcmp("..", dir_ent->d_name) == 0) continue;
sprintf(folder, "%s/%s", kDataFolder, dir_ent->d_name);
printf("In folder %s\n", folder);
DIR *category_dir = opendir(folder);
struct dirent *file_ent = NULL;
while ((file_ent = readdir(category_dir)) != NULL) {
if (strcmp(".", file_ent->d_name) == 0 ||
strcmp("..", file_ent->d_name) == 0) continue;
sprintf(filepath, "%s/%s", folder, file_ent->d_name);
std::vector<std::string> arr;
SplitFilename(file_ent->d_name, &arr);
cv::FileStorage fs(filepath, cv::FileStorage::READ);
SURFFeature *feature = new SURFFeature;
fs["D"] >> feature->descriptor;
fs["I"] >> feature->image;
cv::FileNode roi_node = fs["R"];
feature->roi.x = roi_node["x"];
feature->roi.y = roi_node["y"];
feature->roi.width = roi_node["width"];
feature->roi.height = roi_node["height"];
cv::FileNode kp_node = fs["K"];
for (cv::FileNodeIterator fit = kp_node.begin();
fit != kp_node.end();
++fit) {
cv::FileNode kp = *fit;
cv::KeyPoint point;
point.pt.x = kp["x"];
point.pt.y = kp["y"];
point.size = kp["size"];
point.angle = kp["angle"];
point.octave = kp["octave"];
point.response = kp["response"];
point.class_id = kp["class_id"];
feature->key_points.push_back(point);
int media_type = atoi(dir_ent->d_name);
FeatureMap::iterator it;
if ((it = feature_map_.find(media_type)) == feature_map_.end()) {
feature_map_.insert(make_pair(media_type,
std::map<std::string, SURFFeature*>()));
} else {
it->second.insert(make_pair(arr[1], feature));
}
}
}
}
for (FeatureMap::iterator it = feature_map_.begin();
it != feature_map_.end();
++it) {
printf("%d: %lu\n", it->first, it->second.size());
}
return true;
}
void SetupTitle(HWND hWnd,TSTR &name)
{
TSTR fl, ext;
SplitFilename(name,NULL,&fl,&ext);
fl = TSTR(GetString(IDS_RB_COLORCLIPSHORT)) +
TSTR(_T(" - ")) + fl + ext;
SetWindowText(hWnd,fl);
}
/**
* @brief Update document filenames to title
*/
void CHexMergeDoc::SetTitle(LPCTSTR lpszTitle)
{
const TCHAR pszSeparator[] = _T(" - ");
String sTitle;
if (lpszTitle)
sTitle = lpszTitle;
else
{
if (!m_strDesc[0].empty())
sTitle += m_strDesc[0];
else
{
String file;
String ext;
SplitFilename(m_filePaths.GetLeft().c_str(), NULL, &file, &ext);
sTitle += file.c_str();
if (!ext.empty())
{
sTitle += _T(".");
sTitle += ext.c_str();
}
}
sTitle += pszSeparator;
if (!m_strDesc[1].empty())
sTitle += m_strDesc[1];
else
{
String file;
String ext;
SplitFilename(m_filePaths.GetRight().c_str(), NULL, &file, &ext);
sTitle += file.c_str();
if (!ext.empty())
{
sTitle += _T(".");
sTitle += ext.c_str();
}
}
}
CDocument::SetTitle(sTitle.c_str());
}
int main ()
{
std::string str1 ("/usr/bin/man");
std::string str2 ("c:\\windows\\winhelp.exe");
std::string str3 ("woman");
std::string str4 ("/hello");
SplitFilename (str1);
std::cout << " newfile " << str1 << '\n';
SplitFilename (str2);
std::cout << " newfile " << str2 << '\n';
SplitFilename (str3);
std::cout << " newfile " << str3 << '\n';
SplitFilename (str4);
std::cout << " newfile " << str4 << '\n';
return 0;
}
/**
* @brief Install new filter.
* This function is called when user selects "Install" button from GUI.
* Function allows easy installation of new filters for user. For example
* when user has downloaded filter file from net. First we ask user to
* select filter to install. Then we copy selected filter to private
* filters folder.
*/
void FileFiltersDlg::OnBnClickedFilterfileInstall()
{
CString s;
String path;
String userPath = theApp.m_globalFileFilter.GetUserFilterPathWithCreate();
if (SelectFile(GetSafeHwnd(), s, path.c_str(), IDS_FILEFILTER_INSTALL, IDS_FILEFILTER_FILEMASK,
TRUE))
{
String sfile, sext;
SplitFilename(s, NULL, &sfile, &sext);
String filename = sfile;
filename += _T(".");
filename += sext;
userPath = paths_ConcatPath(userPath, filename);
if (!CopyFile(s, userPath.c_str(), TRUE))
{
// If file already exists, ask from user
// If user wants to, overwrite existing filter
if (paths_DoesPathExist(userPath.c_str()) == IS_EXISTING_FILE)
{
int res = LangMessageBox(IDS_FILEFILTER_OVERWRITE, MB_YESNO |
MB_ICONWARNING);
if (res == IDYES)
{
if (!CopyFile(s, userPath.c_str(), FALSE))
{
LangMessageBox(IDS_FILEFILTER_INSTALLFAIL, MB_ICONSTOP);
}
}
}
else
{
LangMessageBox(IDS_FILEFILTER_INSTALLFAIL, MB_ICONSTOP);
}
}
else
{
FileFilterMgr *pMgr = theApp.m_globalFileFilter.GetManager();
pMgr->AddFilter(userPath.c_str());
// Remove all from filterslist and re-add so we can update UI
CString selected;
m_Filters->RemoveAll();
theApp.m_globalFileFilter.GetFileFilters(m_Filters, selected);
UpdateFiltersList();
}
}
}
VSIVirtualHandle* VSITarFilesystemHandler::Open( const char *pszFilename,
const char *pszAccess)
{
char* tarFilename;
CPLString osTarInFileName;
if (strchr(pszAccess, 'w') != NULL ||
strchr(pszAccess, '+') != NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Only read-only mode is supported for /vsitar");
return NULL;
}
tarFilename = SplitFilename(pszFilename, osTarInFileName, TRUE);
if (tarFilename == NULL)
return NULL;
VSIArchiveReader* poReader = OpenArchiveFile(tarFilename, osTarInFileName);
if (poReader == NULL)
{
CPLFree(tarFilename);
return NULL;
}
CPLString osSubFileName("/vsisubfile/");
VSITarEntryFileOffset* pOffset = (VSITarEntryFileOffset*) poReader->GetFileOffset();
osSubFileName += CPLString().Printf(CPL_FRMT_GUIB, pOffset->nOffset);
osSubFileName += "_";
osSubFileName += CPLString().Printf(CPL_FRMT_GUIB, poReader->GetFileSize());
osSubFileName += ",";
delete pOffset;
if (VSIIsTGZ(tarFilename))
{
osSubFileName += "/vsigzip/";
osSubFileName += tarFilename;
}
else
osSubFileName += tarFilename;
delete(poReader);
CPLFree(tarFilename);
tarFilename = NULL;
return (VSIVirtualHandle* )VSIFOpenL(osSubFileName, "rb");
}
void CubeMap::UpdateButtonText()
{
IAutoMParamDlg *dlg = pblock->GetMParamDlg();
IParamMap2 *map = dlg->GetMap();
if(map)
{
TSTR p,f,e,name;
ParamDef &mapdef = pblock->GetParamDef(pb_cubemapfile); //Added to force a filename to be present
mapdef.init_file = cubeMapFile; //Added to force a filename to be present
SplitFilename(cubeMapFile, &p, &f, &e);
name = f+e;
map->SetText(pb_cubemapfile, name.data());
}
}
BOOL GetSoundFileName(HWND hWnd,TSTR &name,TSTR &dir)
{
#ifndef INTERIM_64_BIT // CCJ
OPENFILENAME ofn;
char filter[256];
AVIBuildFilter(filter,sizeof(filter),FALSE);
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hWnd;
ofn.hInstance = NULL;
ofn.lpstrTitle = GetResString(IDS_RB_OPENSOUND);
ofn.lpstrFilter = filter;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 0;
ofn.lpstrFile = fileName;
ofn.nMaxFile = sizeof(fileName);
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = dir;
ofn.Flags = OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY;
ofn.nFileOffset = 0;
ofn.nFileExtension = 0;
ofn.lpstrDefExt = NULL;
ofn.lCustData = 0;
ofn.lpfnHook = NULL;
ofn.lpTemplateName = NULL;
if (GetOpenFileNamePreview(&ofn)) {
name = fileName;
SplitFilename(name,&dir,NULL,NULL);
return TRUE;
} else {
return FALSE;
}
#else // INTERIM_64_BIT
return FALSE;
#endif // INTERIM_64_BIT
}
int file_initialize_time_step(int current_time_step, char* file_name, char* file_template)
{
int N;
char dirname[PIDX_FILE_PATH_LENGTH], basename[PIDX_FILE_PATH_LENGTH];
int nbits_blocknumber;
char *directory_path;
char *data_set_path;
data_set_path = malloc(sizeof(*data_set_path) * PIDX_FILE_PATH_LENGTH);
memset(data_set_path, 0, sizeof(*data_set_path) * PIDX_FILE_PATH_LENGTH);
directory_path = malloc(sizeof(*directory_path) * PIDX_FILE_PATH_LENGTH);
memset(directory_path, 0, sizeof(*directory_path) * PIDX_FILE_PATH_LENGTH);
strncpy(directory_path, file_name, strlen(file_name) - 4);
char time_template[512];
sprintf(time_template, "%%s/%s.idx", file->idx->filename_time_template);
sprintf(data_set_path, time_template, directory_path, current_time_step);
free(directory_path);
nbits_blocknumber = (maxh - bits_per_block - 1);
SplitFilename(data_set_path, dirname, basename);
//remove suffix
for (N = strlen(basename) - 1; N >= 0; N--)
{
int ch = basename[N];
basename[N] = 0;
if (ch == '.') break;
}
#if 0
//if i put . as the first character, if I move files VisusOpen can do path remapping
sprintf(file_template, "./%s", basename);
#endif
//pidx does not do path remapping
strcpy(file_template, data_set_path);
for (N = strlen(file_template) - 1; N >= 0; N--)
{
int ch = file_template[N];
file_template[N] = 0;
if (ch == '.') break;
}
//can happen if I have only only one block
if (nbits_blocknumber == 0)
strcat(file_template, "/%01x.bin");
else
{
//approximate to 4 bits
if (nbits_blocknumber % 4)
{
nbits_blocknumber += (4 - (nbits_blocknumber % 4));
//assert(!(nbits_blocknumber % 4));
}
if (nbits_blocknumber <= 8)
strcat(file_template, "/%02x.bin"); //no directories, 256 files
else if (nbits_blocknumber <= 12)
strcat(file_template, "/%03x.bin"); //no directories, 4096 files
else if (nbits_blocknumber <= 16)
strcat(file_template, "/%04x.bin"); //no directories, 65536 files
else
{
while (nbits_blocknumber > 16)
{
strcat(file_template, "/%02x"); //256 subdirectories
nbits_blocknumber -= 8;
}
strcat(file_template, "/%04x.bin"); //max 65536 files
nbits_blocknumber -= 16;
//assert(nbits_blocknumber <= 0);
}
}
free(data_set_path);
return 0;
}
/**
* @brief Shows file/folder selection dialog.
*
* We need this custom function so we can select files and folders with the
* same dialog.
* - If existing filename is selected return it
* - If filename in (CFileDialog) editbox and current folder doesn't form
* a valid path to file, return current folder.
* @param [in] parent Handle to parent window. Can be a NULL, but then
* CMainFrame is used which can cause modality problems.
* @param [out] path Selected folder/filename
* @param [in] initialPath Initial file or folder shown/selected.
* @return TRUE if user choosed a file/folder, FALSE if user canceled dialog.
*/
BOOL SelectFileOrFolder(HWND parent, CString& path, LPCTSTR initialPath /*=NULL*/)
{
String title = theApp.LoadString(IDS_OPEN_TITLE);
// This will tell common file dialog what to show
// and also this will hold its return value
CString sSelectedFile;
// check if specified path is a file
if (initialPath && initialPath[0])
{
// If initial path info includes a file
// we put the bare filename into sSelectedFile
// so the common file dialog will start up with that file selected
if (paths_DoesPathExist(initialPath) == IS_EXISTING_FILE)
{
String temp;
SplitFilename(initialPath, 0, &temp, 0);
sSelectedFile = temp.c_str();
}
}
if (parent == NULL)
parent = AfxGetMainWnd()->GetSafeHwnd();
int filterid = IDS_ALLFILES;
if (!filterid)
filterid = IDS_ALLFILES;
String filters = theApp.LoadString(filterid);
// Convert extension mask from MFC style separators ('|')
// to Win32 style separators ('\0')
LPTSTR filtersStr = &*filters.begin();
ConvertFilter(filtersStr);
String dirSelTag = theApp.LoadString(IDS_DIRSEL_TAG);
// Set initial filename to folder selection tag
dirSelTag += _T("."); // Treat it as filename
sSelectedFile = dirSelTag.c_str(); // What is assignment above good for?
OPENFILENAME_NT4 ofn;
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = parent;
ofn.lpstrFilter = filtersStr;
ofn.lpstrCustomFilter = NULL;
ofn.nFilterIndex = 1;
ofn.lpstrFile = sSelectedFile.GetBuffer(MAX_PATH);
ofn.nMaxFile = MAX_PATH;
ofn.lpstrInitialDir = initialPath;
ofn.lpstrTitle = title.c_str();
ofn.lpstrFileTitle = NULL;
ofn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_NOTESTFILECREATE;
BOOL bRetVal = GetOpenFileName((OPENFILENAME *)&ofn);
// common file dialog populated sSelectedFile variable's buffer
sSelectedFile.ReleaseBuffer();
SetCurrentDirectory(env_GetWindowsDirectory().c_str()); // Free handle held by GetOpenFileName
if (bRetVal)
{
path = sSelectedFile;
struct _stati64 statBuffer;
int nRetVal = _tstati64(path, &statBuffer);
if (nRetVal == -1)
{
// We have a valid folder name, but propably garbage as a filename.
// Return folder name
String folder = GetPathOnly(sSelectedFile);
path.Format(_T("%s\\"), folder.c_str());
}
}
return bRetVal;
}
/**
* @brief Generate report and save it to file.
* @param [out] errStr Empty if succeeded, otherwise contains error message.
* @return TRUE if report was created, FALSE if user canceled report.
*/
BOOL DirCmpReport::GenerateReport(String &errStr)
{
ASSERT(m_pList != NULL);
ASSERT(m_pFile == NULL);
BOOL bRet = FALSE;
DirCmpReportDlg dlg;
if (dlg.DoModal() == IDOK) try
{
WaitStatusCursor waitstatus(IDS_STATUS_CREATEREPORT);
if (dlg.m_bCopyToClipboard)
{
if (!CWnd::GetSafeOwner()->OpenClipboard())
return FALSE;
if (!EmptyClipboard())
return FALSE;
CSharedFile file(GMEM_DDESHARE|GMEM_MOVEABLE|GMEM_ZEROINIT);
m_pFile = &file;
GenerateReport(dlg.m_nReportType);
SetClipboardData(CF_TEXT, file.Detach());
// If report type is HTML, render CF_HTML format as well
if (dlg.m_nReportType == REPORT_TYPE_SIMPLEHTML)
{
// Reconstruct the CSharedFile object
file.~CSharedFile();
file.CSharedFile::CSharedFile(GMEM_DDESHARE|GMEM_MOVEABLE|GMEM_ZEROINIT);
// Write preliminary CF_HTML header with all offsets zero
static const char header[] =
"Version:0.9\n"
"StartHTML:%09d\n"
"EndHTML:%09d\n"
"StartFragment:%09d\n"
"EndFragment:%09d\n";
static const char start[] = "<html><body>\n<!--StartFragment -->";
static const char end[] = "\n<!--EndFragment -->\n</body>\n</html>\n";
char buffer[256];
int cbHeader = wsprintfA(buffer, header, 0, 0, 0, 0);
file.Write(buffer, cbHeader);
file.Write(start, sizeof start - 1);
GenerateHTMLHeaderBodyPortion();
GenerateXmlHtmlContent(false);
file.Write(end, sizeof end); // include terminating zero
DWORD size = GetLength32(file);
// Rewrite CF_HTML header with valid offsets
file.SeekToBegin();
wsprintfA(buffer, header, cbHeader, size - 1,
cbHeader + sizeof start - 1, size - sizeof end + 1);
file.Write(buffer, cbHeader);
SetClipboardData(CF_HTML, GlobalReAlloc(file.Detach(), size, 0));
}
CloseClipboard();
}
if (!dlg.m_sReportFile.IsEmpty())
{
String path;
SplitFilename(dlg.m_sReportFile, &path, NULL, NULL);
if (!paths_CreateIfNeeded(path.c_str()))
{
errStr = LoadResString(IDS_FOLDER_NOTEXIST);
return FALSE;
}
CFile file(dlg.m_sReportFile,
CFile::modeWrite|CFile::modeCreate|CFile::shareDenyWrite);
m_pFile = &file;
GenerateReport(dlg.m_nReportType);
}
bRet = TRUE;
}
catch (CException *e)
{
e->ReportError(MB_ICONSTOP);
e->Delete();
}
m_pFile = NULL;
return bRet;
}
/**
* @brief Helper function for selecting folder or file.
* This function shows standard Windows file selection dialog for selecting
* file or folder to open or file to save. The last parameter @p is_open selects
* between open or save modes. Biggest difference is that in save-mode Windows
* asks if user wants to override existing file.
* @param [in] parent Handle to parent window. Can be a NULL, but then
* CMainFrame is used which can cause modality problems.
* @param [out] path Selected path is returned in this string
* @param [in] initialPath Initial path (and file) shown when dialog is opened
* @param [in] titleid Resource string ID for dialog title.
* @param [in] filterid 0 or STRING ID for filter string
* - 0 means "All files (*.*)". Note the string formatting!
* @param [in] is_open Selects Open/Save -dialog (mode).
* @note Be careful when setting @p parent to NULL as there are potential
* modality problems with this. Dialog can be lost behind other windows!
* @param [in] defaultExtension Extension to append if user doesn't provide one
*/
BOOL SelectFile(HWND parent, CString& path, LPCTSTR initialPath /*=NULL*/,
UINT titleid /*=0*/, UINT filterid /*=0*/,
BOOL is_open /*=TRUE*/, LPCTSTR defaultExtension /*=NULL*/)
{
path.Empty(); // Clear output param
// This will tell common file dialog what to show
// and also this will hold its return value
CString sSelectedFile;
// check if specified path is a file
if (initialPath && initialPath[0])
{
// If initial path info includes a file
// we put the bare filename into sSelectedFile
// so the common file dialog will start up with that file selected
if (paths_DoesPathExist(initialPath) == IS_EXISTING_FILE)
{
String temp;
SplitFilename(initialPath, 0, &temp, 0);
sSelectedFile = temp.c_str();
}
}
if (parent == NULL)
parent = AfxGetMainWnd()->GetSafeHwnd();
if (!filterid)
filterid = IDS_ALLFILES;
String title = theApp.LoadString(titleid);
String filters = theApp.LoadString(filterid);
// Convert extension mask from MFC style separators ('|')
// to Win32 style separators ('\0')
LPTSTR filtersStr = &*filters.begin();
ConvertFilter(filtersStr);
OPENFILENAME_NT4 ofn;
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = parent;
ofn.lpstrFilter = filtersStr;
ofn.lpstrCustomFilter = NULL;
ofn.nFilterIndex = 1;
ofn.lpstrFile = sSelectedFile.GetBuffer(MAX_PATH);
ofn.nMaxFile = MAX_PATH;
ofn.lpstrInitialDir = initialPath;
ofn.lpstrTitle = title.c_str();
ofn.lpstrFileTitle = NULL;
if (defaultExtension)
ofn.lpstrDefExt = defaultExtension;
ofn.Flags = OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
BOOL bRetVal = FALSE;
if (is_open)
bRetVal = GetOpenFileName((OPENFILENAME *)&ofn);
else
bRetVal = GetSaveFileName((OPENFILENAME *)&ofn);
// common file dialog populated sSelectedFile variable's buffer
sSelectedFile.ReleaseBuffer();
SetCurrentDirectory(env_GetWindowsDirectory().c_str()); // Free handle held by GetOpenFileName
if (bRetVal)
path = sSelectedFile;
return bRetVal;
}
int VSIArchiveFilesystemHandler::Stat( const char *pszFilename,
VSIStatBufL *pStatBuf,
CPL_UNUSED int nFlags )
{
int ret = -1;
CPLString osFileInArchive;
memset(pStatBuf, 0, sizeof(VSIStatBufL));
char* archiveFilename = SplitFilename(pszFilename, osFileInArchive, TRUE);
if (archiveFilename == NULL)
return -1;
if (strlen(osFileInArchive) != 0)
{
if (ENABLE_DEBUG) CPLDebug("VSIArchive", "Looking for %s %s\n",
archiveFilename, osFileInArchive.c_str());
const VSIArchiveEntry* archiveEntry = NULL;
if (FindFileInArchive(archiveFilename, osFileInArchive, &archiveEntry))
{
/* Patching st_size with uncompressed file size */
pStatBuf->st_size = archiveEntry->uncompressed_size;
pStatBuf->st_mtime = (time_t)archiveEntry->nModifiedTime;
if (archiveEntry->bIsDir)
pStatBuf->st_mode = S_IFDIR;
else
pStatBuf->st_mode = S_IFREG;
ret = 0;
}
}
else
{
VSIArchiveReader* poReader = CreateReader(archiveFilename);
CPLFree(archiveFilename);
archiveFilename = NULL;
if (poReader != NULL && poReader->GotoFirstFile())
{
/* Skip optionnal leading subdir */
CPLString osFileName = poReader->GetFileName();
const char* fileName = osFileName.c_str();
if (fileName[strlen(fileName)-1] == '/' || fileName[strlen(fileName)-1] == '\\')
{
if (poReader->GotoNextFile() == FALSE)
{
delete(poReader);
return -1;
}
}
if (poReader->GotoNextFile())
{
/* Several files in archive --> treat as dir */
pStatBuf->st_size = 0;
pStatBuf->st_mode = S_IFDIR;
}
else
{
/* Patching st_size with uncompressed file size */
pStatBuf->st_size = poReader->GetFileSize();
pStatBuf->st_mtime = (time_t)poReader->GetModifiedTime();
pStatBuf->st_mode = S_IFREG;
}
ret = 0;
}
delete(poReader);
}
CPLFree(archiveFilename);
return ret;
}
int Unreal3DExport::DoExport( const TCHAR *name, ExpInterface *ei, Interface *i, BOOL suppressPrompts, DWORD options )
{
int Result = FALSE;
// Set a global prompt display switch
bShowPrompts = suppressPrompts ? false : true;
bExportSelected = (options & SCENE_EXPORT_SELECTED) ? true : false;
// Get file names
SplitFilename(TSTR(name), &FilePath, &FileName, &FileExt);
if( MatchPattern(FileName,TSTR(_T("*_d")),TRUE)
|| MatchPattern(FileName,TSTR(_T("*_a")),TRUE) )
{
FileName = FileName.Substr(0,FileName.length()-2);
}
ModelFileName = FilePath + _T("\\") + FileName + TSTR(_T("_d")) + FileExt;
AnimFileName = FilePath + _T("\\") + FileName + TSTR(_T("_a")) + FileExt;
ScriptFileName = FilePath + _T("\\") + FileName + TSTR(_T("_rc.uc"));
// Open Log
fLog = _tfopen(FilePath + _T("\\") + FileName + _T(".log") ,_T("wb"));
// Init
pInt = GetCOREInterface();
pInt->ProgressStart( GetString(IDS_INFO_INIT), TRUE, fn, this);
Progress += U3D_PROGRESS_INIT;
try
{
MyErrorProc pErrorProc;
SetErrorCallBack(&pErrorProc);
ReadConfig();
//if(bShowPrompts)
/*DialogBoxParam(hInstance,
MAKEINTRESOURCE(IDD_PANEL),
GetActiveWindow(),
Unreal3DExportOptionsDlgProc, (LPARAM)this);*/
//if(showPrompts)
{
// Prompt the user with our dialogbox, and get all the options.
if(!DialogBoxParam(hInstance,
MAKEINTRESOURCE(IDD_PANEL),
GetActiveWindow(),
Unreal3DExportOptionsDlgProc, (LPARAM)this))
{
throw CancelException();
}
}
// Enumerate interesting nodes
Init();
// Fetch data from nodes
GetTris();
GetAnim();
// Prepare data for writing
Prepare();
// Write to files
WriteScript();
WriteModel();
WriteTracking();
// Show optional summary
ShowSummary();
WriteConfig();
Result = IMPEXP_SUCCESS;
}
catch( CancelException& )
{
Result = IMPEXP_CANCEL;
}
catch( MAXException& e )
{
if( bShowPrompts && !e.message.isNull() )
{
MaxMsgBox(pInt->GetMAXHWnd(),e.message,ShortDesc(),MB_OK|MB_ICONERROR);
}
Result = IMPEXP_FAIL;
}
// Release scene
if( pScene != NULL )
{
pScene->ReleaseIGame();
pScene = NULL;
}
// Close files
fclosen(fMesh);
fclosen(fAnim);
fclosen(fLog);
fclosen(fScript);
// Return to MAX
pInt->ProgressEnd();
return Result;
}
BOOL RendVueParamDlg::FileBrowse() {
int tried = 0;
FilterList filterList;
HWND hWnd = hPanel;
static int filterIndex = 1;
OPENFILENAME ofn;
TSTR filename;
TCHAR fname[512];
TCHAR saveDir[1024];
{
TSTR dir;
SplitFilename(workFileName, &dir, &filename,NULL);
_tcscpy(saveDir,dir.data());
}
_tcscpy(fname,filename.data());
_tcscat(fname, VUEEXT);
filterList.Append(GetString(IDS_VUE_FILE));
filterList.Append(VUEFILTER);
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(OPENFILENAME); // No OFN_ENABLEHOOK
ofn.hwndOwner = hWnd;
ofn.hInstance = hInstance;
ofn.nFilterIndex = filterIndex;
ofn.lpstrFilter = filterList;
ofn.lpstrTitle = GetString(IDS_WRITE_VUEFILE);
ofn.lpstrFile = fname;
ofn.nMaxFile = _countof(fname);
Interface *iface = GetCOREInterface();
if(saveDir[0])
ofn.lpstrInitialDir = saveDir;
else
ofn.lpstrInitialDir = iface->GetDir(APP_SCENE_DIR);
if(RunningNewShell()) {
ofn.Flags = OFN_HIDEREADONLY | OFN_EXPLORER /* | OFN_ENABLEHOOK | OFN_ENABLETEMPLATE*/; // OFN_OVERWRITEPROMPT;
ofn.lpfnHook = NULL;// (LPOFNHOOKPROC)FileHook;
ofn.lCustData = 0; // 0 for save, 1 for open
// ofn.lpTemplateName = MAKEINTRESOURCE(IDD_EXT_FILE);
}
else {
ofn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST /* |OFN_ENABLEHOOK | OFN_ENABLETEMPLATE */;
ofn.lpfnHook = NULL; // (LPOFNHOOKPROC)PMFileHook;
ofn.lCustData = 0;
// ofn.lpTemplateName = MAKEINTRESOURCE(IDD_PM_EXT_FILE);
}
ofn.FlagsEx = OFN_EX_NOPLACESBAR;
FixFileExt(ofn,VUEEXT); // add ".vue" if absent
while (GetSaveFileName(&ofn)) {
FixFileExt(ofn,VUEEXT); // add ".vue" if absent
workFileName = ofn.lpstrFile;
return TRUE;
}
return FALSE;
}
void plStaticEnvLayer::RenderCubicMap( INode *node )
{
int res, size;
BOOL success = 0;
TSTR fname, fullname;
Bitmap *bm = NULL;
TSTR path, filename, ext, thisFilename;
BitmapInfo biOutFile;
static TCHAR suffixes[ 6 ][ 4 ] = { "_FR", "_BK", "_LF", "_RT", "_UP", "_DN" };
Interface *ip = GetCOREInterface();
size = fBitmapPB->GetInt( kBmpTextureSize, ip->GetTime() );
if( size <= 0 )
{
return;
}
thisFilename = fBitmapPB->GetStr( kBmpBaseFilename, ip->GetTime() );
if( thisFilename.isNull() )
{
return;
}
SplitFilename( thisFilename, &path, &filename, &ext );
BOOL wasHid = node->IsNodeHidden();
node->Hide( TRUE );
// Create a blank bitmap
biOutFile.SetWidth( size );
biOutFile.SetHeight( size );
biOutFile.SetType( BMM_TRUE_64 );
biOutFile.SetAspect( 1.0f );
biOutFile.SetCurrentFrame( 0 );
bm = TheManager->Create( &biOutFile );
Matrix3 nodeTM = node->GetNodeTM( ip->GetTime() );
Matrix3 tm;
INode *root = ip->GetRootNode();
bm->Display( GetString( IDS_CUBIC_RENDER_TITLE ) );
/// Set up rendering contexts
ViewParams vp;
vp.projType = PROJ_PERSPECTIVE;
vp.hither = .001f;
vp.yon = 1.0e30f;
vp.fov = M_PI/2.0f;
if( fBitmapPB->GetInt( kBmpUseMAXAtmosphere ) )
{
vp.nearRange = 0;
vp.farRange = fBitmapPB->GetFloat( kBmpFarDistance );
}
else
{
vp.nearRange = vp.farRange = 1.0e30f;
}
BOOL saveUseEnvMap = ip->GetUseEnvironmentMap();
ip->SetUseEnvironmentMap( false );
res = ip->OpenCurRenderer( &vp );
for( int i = 0; i < 6; i++ )
{
tm = IGetViewTM( i );
tm.PreTranslate( -nodeTM.GetTrans() );
vp.affineTM = tm;
// Construct filename
thisFilename.printf( _T( "%s\\%s%s%s" ), path, filename, suffixes[ i ], ext );
res = ip->CurRendererRenderFrame( ip->GetTime(), bm, NULL, 1.0f, &vp );
if( !res )
goto fail;
if( !IWriteBM( &biOutFile, bm, thisFilename ) )
goto fail;
}
success = 1;
fail:
ip->CloseCurRenderer();
ip->SetUseEnvironmentMap( saveUseEnvMap );
bm->DeleteThis();
node->Hide( wasHid );
if( success )
{
for(int i = 0; i < 6; i++ )
{
BitmapInfo bi;
thisFilename.printf( _T( "%s\\%s%s%s" ), path, filename, suffixes[ i ], ext );
bi.SetName( thisFilename );
PBBitmap pbBitmap( bi );
fBitmapPB->SetValue( kBmpFrontBitmap + i, ip->GetTime(), &pbBitmap );
}
fBitmapPB->GetMap()->UpdateUI( ip->GetTime() );
}
}
int SmdExportClass::DoExport(const TCHAR *name,ExpInterface *ei,Interface *i, BOOL suppressPrompts)
{
ExpInterface *pexpiface = ei; // Hungarian
Interface *piface = i; // Hungarian
// Reset the name-map property manager
g_inmMac = 0;
// Present the user with the Export Options dialog
if (DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_EXPORTOPTIONS), GetActiveWindow(),
ExportOptionsDlgProc, (LPARAM)this) <= 0)
return 0; // error or cancel
// Break up filename, re-assemble longer versions
TSTR strPath, strFile, strExt;
TCHAR szFile[MAX_PATH];
SplitFilename(TSTR(name), &strPath, &strFile, &strExt);
sprintf(szFile, "%s\\%s.%s", (char*)strPath, (char*)strFile, DEFAULT_EXT);
/*
if (m_fReferenceFrame)
sprintf(szFile, "%s\\%s_model.%s", (char*)strPath, (char*)strFile, DEFAULT_EXT);
*/
FILE *pFile;
if ((pFile = fopen(szFile, "w")) == NULL)
return FALSE/*failure*/;
fprintf( pFile, "version %d\n", 1 );
// Get animation metrics
m_intervalOfAnimation = piface->GetAnimRange();
m_tvStart = m_intervalOfAnimation.Start();
m_tvEnd = m_intervalOfAnimation.End();
m_tpf = ::GetTicksPerFrame();
// Count nodes, label them, collect into array
if (!CollectNodes(pexpiface))
return 0; /*fail*/
// Output nodes
if (!DumpBones(pFile, pexpiface))
{
fclose( pFile );
return 0; /*fail*/
}
// Output bone rotations, for each frame. Do only first frame if this is the reference frame MAX file
DumpRotations(pFile, pexpiface);
// Output triangle meshes (first frame/all frames), if this is the reference frame MAX file
if (m_fReferenceFrame)
{
DumpModel(pFile, pexpiface);
}
// Tell user that exporting is finished (it can take a while with no feedback)
char szExportComplete[300];
sprintf(szExportComplete, "Exported %s.", szFile);
MessageBox(GetActiveWindow(), szExportComplete, "Status", MB_OK);
fclose( pFile );
return 1/*success*/;
}
TCHAR *FindFile(TCHAR *File)
{
int i;
BOOL Found;
TCHAR *Part;
Interface *I;
Found = 0;
// NH 21|04|2002
// Replaced the current search but used the actual path including drive prefix
// the original seemed to get stuck in the current path, or the last path used
// this caused files not to be loaded, even though they were there.
//
// _splitpath(File,Drive,Dir,FileName,Ext);
//
// Found = SearchPath(Dir,FileName,Ext,MAX_PATH,gFilePath,&Part);
////////////////////////////////////////////////////////////////////////////////
TSTR p,f,e;
TSTR name(File);
SplitFilename(name, &p, &f, &e);
name = f + e;
//left the following in as it is used in other methods
// Found = SearchPath(p.data(),f.data(),e.data(),MAX_PATH,gFilePath,&Part);
Found = SearchPath(p.data(),name.data(),NULL,MAX_PATH,gFilePath,&Part);
if(!Found)
{
I = GetCOREInterface();
// Search the from where the file was loaded....
TSTR CurFileP = I->GetCurFilePath();
// TSTR CurFile = I->GetCurFileName();
TSTR tP;
SplitFilename(CurFileP,&tP,NULL,NULL);
Found = SearchPath(tP.data(),name.data(),NULL,MAX_PATH,gFilePath,&Part);
//
// Search maps
//
if(!Found)
{
for (i=0; i<TheManager->GetMapDirCount(); i++) {
TCHAR* dir = TheManager->GetMapDir(i);
if((Found = SearchPath(dir,name.data(),NULL,MAX_PATH,gFilePath,&Part)))
{
break;
}
}
}
// not sure why we search here....
if(!Found)
{
//
// Search plugins
//
for(i=0; i < I->GetPlugInEntryCount(); i++)
{
TCHAR* dir = I->GetPlugInDir(i);
if((Found = SearchPath(dir,name.data(),NULL,MAX_PATH,gFilePath,&Part)))
{
break;
}
}
}
}
if(Found)
{
return(gFilePath);
}
else
{
return(NULL);
}
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CStravaganzaMaxTools
//
// - prototype : bool BuildShaders()
//
// - Purpose : Builds the shader list from MAX's materials.
// Preview mode requires texture files to be stored with full
// path in order to load them. When we export, we only store the
// filename. Another thing is that in the export mode, we copy
// all textures into the path specified by the user if that
// option is checked.
//
// -----------------------------------------------------------------------------
bool CStravaganzaMaxTools::BuildShaders()
{
std::vector<Mtl*>::iterator it;
assert(m_vecShaders.empty());
if(!m_bPreview && m_bCopyTextures && m_strTexturePath == "")
{
CLogger::NotifyWindow("Textures won't be copied\nSpecify a valid output texture path first");
}
LOG.Write("\n\n-Building shaders: ");
for(it = m_vecMaterials.begin(); it != m_vecMaterials.end(); ++it)
{
Mtl* pMaxMaterial = *it;
assert(pMaxMaterial);
LOG.Write("\n %s", pMaxMaterial->GetName().data());
CShaderStandard* pShaderStd = new CShaderStandard;
pShaderStd->SetName(pMaxMaterial->GetName().data());
// Properties
StdMat2 *pMaxStandardMtl = NULL;
StdMat2 *pMaxBakedMtl = NULL;
float fAlpha;
if(pMaxMaterial->ClassID() == Class_ID(DMTL_CLASS_ID, 0))
{
pMaxStandardMtl = (StdMat2 *)pMaxMaterial;
}
else if(pMaxMaterial->ClassID() == Class_ID(BAKE_SHELL_CLASS_ID, 0))
{
pMaxStandardMtl = (StdMat2 *)pMaxMaterial->GetSubMtl(0);
pMaxBakedMtl = (StdMat2 *)pMaxMaterial->GetSubMtl(1);
}
if(pMaxStandardMtl)
{
// Standard material
fAlpha = pMaxStandardMtl->GetOpacity(0);
Shader* pMaxShader = pMaxStandardMtl->GetShader();
CVector4 v4Specular = ColorToVector4(pMaxStandardMtl->GetSpecular(0), 0.0f) * pMaxShader->GetSpecularLevel(0, 0);
pShaderStd->SetAmbient (ColorToVector4(pMaxStandardMtl->GetAmbient(0), 0.0f));
pShaderStd->SetDiffuse (ColorToVector4(pMaxStandardMtl->GetDiffuse(0), fAlpha));
pShaderStd->SetSpecular (v4Specular);
pShaderStd->SetShininess(pMaxShader->GetGlossiness(0, 0) * 128.0f);
if(pMaxStandardMtl->GetTwoSided() == TRUE)
{
pShaderStd->SetTwoSided(true);
}
// Need to cast to StdMat2 in order to get access to IsFaceted().
// ¿Is StdMat2 always the interface for standard materials?
if(((StdMat2*)pMaxStandardMtl)->IsFaceted())
{
pShaderStd->SetFaceted(true);
}
if(pMaxStandardMtl->GetWire() == TRUE)
{
pShaderStd->SetPostWire(true);
pShaderStd->SetWireLineThickness(pMaxStandardMtl->GetWireSize(0));
}
}
else
{
// Material != Standard
fAlpha = 1.0f; // pMaxMaterial->GetXParency();
pShaderStd->SetAmbient (ColorToVector4(pMaxMaterial->GetAmbient(), 0.0f));
pShaderStd->SetDiffuse (ColorToVector4(pMaxMaterial->GetDiffuse(), fAlpha));
pShaderStd->SetSpecular (CVector4(0.0f, 0.0f, 0.0f, 0.0f));
pShaderStd->SetShininess(0.0f);
}
// Layers
if(!pMaxStandardMtl)
{
m_vecShaders.push_back(pShaderStd);
continue;
}
bool bDiffuseMap32Bits = false;
StdMat2 *pStandardMtl;
for(int i = 0; i < 3; i++)
{
int nMap;
pStandardMtl = pMaxStandardMtl;
// 0 = diffuse, 1 == bump, 2 = lightmap (self illumination slot) or envmap (reflection slot)
if(i == 0)
{
nMap = ID_DI;
}
else if(i == 1)
{
nMap = ID_BU;
// If its a baked material, get the bump map from there
if(pMaxBakedMtl)
{
pStandardMtl = pMaxBakedMtl;
}
}
else if(i == 2)
{
bool bBaked = false;
// If its a baked material, get the map2 (lightmap) from there
if(pMaxBakedMtl)
{
if(pMaxBakedMtl->GetMapState(ID_SI) == MAXMAPSTATE_ENABLED)
{
bBaked = true;
nMap = ID_SI;
pStandardMtl = pMaxBakedMtl;
}
}
if(!bBaked)
{
if(pStandardMtl->GetMapState(ID_SI) == MAXMAPSTATE_ENABLED)
{
nMap = ID_SI;
}
else
{
nMap = ID_RL;
}
}
}
// Check validity
if(pStandardMtl->GetMapState(nMap) != MAXMAPSTATE_ENABLED)
{
if(i == 0)
{
LOG.Write("\n No diffuse. Skipping.");
break;
}
continue;
}
Texmap* pMaxTexmap = pStandardMtl->GetSubTexmap(nMap);
if(!pMaxTexmap)
{
if(i == 0)
{
LOG.Write("\n No diffuse. Skipping.");
break;
}
continue;
}
// Get texmaps
std::vector<std::string> vecTextures, vecPaths;
CShaderStandard::SLayerInfo layerInfo;
CShaderStandard::SBitmapInfo bitmapInfo;
if(pMaxTexmap->ClassID() == Class_ID(BMTEX_CLASS_ID, 0))
{
BitmapTex* pMaxBitmapTex = (BitmapTex*)pMaxTexmap;
Bitmap* pMaxBitmap = pMaxBitmapTex->GetBitmap(SECONDS_TO_TICKS(m_fStartTime));
StdUVGen* pMaxUVGen = pMaxBitmapTex->GetUVGen();
if(!pMaxBitmap)
{
if(i == 0)
{
LOG.Write("\n Invalid diffuse. Skipping.");
break;
}
continue;
}
assert(pMaxUVGen);
BitmapInfo bi = pMaxBitmap->Storage()->bi;
// bi.Name() returns the full path
// bi.Filename() returns just the filename
vecTextures.push_back(bi.Filename());
vecPaths. push_back(bi.Name());
LOG.Write("\n Bitmap %s", vecTextures[0].data());
// Check if diffuse texture has alpha channel
if(i == 0)
{
CBitmap bitmap;
CInputFile bitmapFile;
if(!bitmapFile.Open(bi.Name(), false))
{
CLogger::NotifyWindow("WARNING - CStravaganzaMaxTools::BuildShaders():\nUnable to load file %s", bi.Name());
}
else
{
if(!bitmap.Load(&bitmapFile, GetFileExt(bi.Name())))
{
CLogger::NotifyWindow("WARNING - CStravaganzaMaxTools::BuildShaders():\nUnable to load bitmap %s", bi.Name());
}
else
{
if(bitmap.GetBpp() == 32)
{
bDiffuseMap32Bits = true;
LOG.Write(" (with alpha channel)");
}
bitmap.Free();
}
bitmapFile.Close();
}
}
// Ok, copy properties
layerInfo.texInfo.bLoop = false;
layerInfo.texInfo.eTextureType = UtilGL::Texturing::CTexture::TEXTURE2D;
bitmapInfo.strFile = m_bPreview ? bi.Name() : bi.Filename();
bitmapInfo.bTile = ((pMaxUVGen->GetTextureTiling() & (U_WRAP | V_WRAP)) == (U_WRAP | V_WRAP)) ? true : false;
bitmapInfo.fSeconds = 0.0f;
bitmapInfo.bForceFiltering = false;
bitmapInfo.eFilter = UtilGL::Texturing::FILTER_TRILINEAR; // won't be used (forcefiltering = false)
layerInfo.texInfo.m_vecBitmaps.push_back(bitmapInfo);
layerInfo.eTexEnv = nMap == ID_RL ? CShaderStandard::TEXENV_ADD : CShaderStandard::TEXENV_MODULATE;
layerInfo.eUVGen = pMaxUVGen->GetCoordMapping(0) == UVMAP_SPHERE_ENV ? CShaderStandard::UVGEN_ENVMAPPING : CShaderStandard::UVGEN_EXPLICITMAPPING;
layerInfo.uMapChannel = pMaxUVGen->GetMapChannel();
layerInfo.v3ScrollSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3RotationSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3ScrollOffset = CVector3(pMaxUVGen->GetUOffs(0), pMaxUVGen->GetVOffs(0), 0.0f);
layerInfo.v3RotationOffset = CVector3(pMaxUVGen->GetUAng(0), pMaxUVGen->GetVAng(0), pMaxUVGen->GetWAng(0));
}
else if(pMaxTexmap->ClassID() == Class_ID(ACUBIC_CLASS_ID, 0))
{
ACubic* pMaxCubic = (ACubic*)pMaxTexmap;
IParamBlock2* pBlock = pMaxCubic->pblock;
Interval validRange = m_pMaxInterface->GetAnimRange();
for(int nFace = 0; nFace < 6; nFace++)
{
int nMaxFace;
switch(nFace)
{
case 0: nMaxFace = 3; break;
case 1: nMaxFace = 2; break;
case 2: nMaxFace = 1; break;
case 3: nMaxFace = 0; break;
case 4: nMaxFace = 5; break;
case 5: nMaxFace = 4; break;
}
TCHAR *name;
pBlock->GetValue(acubic_bitmap_names, TICKS_TO_SECONDS(m_fStartTime), name, validRange, nMaxFace);
vecPaths.push_back(name);
CStr path, file, ext;
SplitFilename(CStr(name), &path, &file, &ext);
std::string strFile = std::string(file.data()) + ext.data();
vecTextures.push_back(strFile);
bitmapInfo.strFile = m_bPreview ? name : strFile;
bitmapInfo.bTile = false;
bitmapInfo.fSeconds = 0.0f;
bitmapInfo.bForceFiltering = false;
bitmapInfo.eFilter = UtilGL::Texturing::FILTER_TRILINEAR;
layerInfo.texInfo.m_vecBitmaps.push_back(bitmapInfo);
}
layerInfo.texInfo.bLoop = false;
layerInfo.texInfo.eTextureType = UtilGL::Texturing::CTexture::TEXTURECUBEMAP;
layerInfo.eTexEnv = nMap == ID_RL ? CShaderStandard::TEXENV_ADD : CShaderStandard::TEXENV_MODULATE;
layerInfo.eUVGen = CShaderStandard::UVGEN_ENVMAPPING;
layerInfo.uMapChannel = 0;
layerInfo.v3ScrollSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3RotationSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3ScrollOffset = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3RotationOffset = CVector3(0.0f, 0.0f, 0.0f);
}
else
{
if(i == 0)
{
LOG.Write("\n No diffuse. Skipping.");
break;
}
continue;
}
if(!m_bPreview && m_bCopyTextures && m_strTexturePath != "")
{
for(int nTex = 0; nTex != vecTextures.size(); nTex++)
{
// Copy textures into the specified folder
std::string strDestPath = m_strTexturePath;
if(strDestPath[strDestPath.length() - 1] != '\\')
{
strDestPath.append("\\", 1);
}
strDestPath.append(vecTextures[nTex]);
if(!CopyFile(vecPaths[nTex].data(), strDestPath.data(), FALSE))
{
CLogger::NotifyWindow("Unable to copy %s to\n%s", vecPaths[i], strDestPath.data());
}
}
}
if(layerInfo.eUVGen == CShaderStandard::UVGEN_ENVMAPPING && i == 1)
{
CLogger::NotifyWindow("%s : Bump with spheremapping not supported", pShaderStd->GetName().data());
}
else
{
// Add layer
switch(i)
{
case 0: pShaderStd->SetLayer(CShaderStandard::LAYER_DIFF, layerInfo); break;
case 1: pShaderStd->SetLayer(CShaderStandard::LAYER_BUMP, layerInfo); break;
case 2: pShaderStd->SetLayer(CShaderStandard::LAYER_MAP2, layerInfo); break;
}
}
}
// ¿Do we need blending?
if(ARE_EQUAL(fAlpha, 1.0f) && !bDiffuseMap32Bits)
{
pShaderStd->SetBlendSrcFactor(UtilGL::States::BLEND_ONE);
pShaderStd->SetBlendDstFactor(UtilGL::States::BLEND_ZERO);
}
else
{
pShaderStd->SetBlendSrcFactor(UtilGL::States::BLEND_SRCALPHA);
pShaderStd->SetBlendDstFactor(UtilGL::States::BLEND_INVSRCALPHA);
}
// Add shader
m_vecShaders.push_back(pShaderStd);
}
return true;
}
int VWeightExportClass::DoExport(const TCHAR *name, ExpInterface *ei, Interface *pi, BOOL suppressPrompts, DWORD options)
{
ExpInterface *pexpiface = ei; // Hungarian
Interface *piface = pi; // Hungarian
// Reset the name-map property manager
ResetINodeMap();
// Break up filename, re-assemble longer versions
TSTR strPath, strFile, strExt;
TCHAR szFile[MAX_PATH];
SplitFilename(TSTR(name), &strPath, &strFile, &strExt);
sprintf(szFile, "%s\\%s.%s", (char*)strPath, (char*)strFile, DEFAULT_EXT);
// Get animation metrics
m_intervalOfAnimation = piface->GetAnimRange();
m_tvStart = m_intervalOfAnimation.Start();
m_tvEnd = m_intervalOfAnimation.End();
m_tpf = ::GetTicksPerFrame();
Interface *ip = GetCOREInterface();
ResetINodeMap( );
m_cMaxNode = BuildINodeMap( ip->GetRootNode() );
// Count nodes, label them, collect into array
CollectNodes( ip->GetRootNode() );
CollectModel( pexpiface );
#if 1
FILE *pFile;
if ((pFile = fopen(szFile, "wb")) == NULL)
return FALSE/*failure*/;
int version = 1;
fwrite( &version, 1, sizeof( int ), pFile );
int i, j;
fwrite( &m_cMaxNode, 1, sizeof( int ), pFile );
fwrite( &m_cMaxVertex, 1, sizeof( int ), pFile );
for (i = 0; i < m_cMaxNode; i++)
{
fwrite( &m_MaxNode[i], 1, sizeof(m_MaxNode[i]), pFile );
}
for (j = 0; j < m_cMaxVertex; j++)
{
fwrite( m_MaxVertex[j], m_cMaxNode, sizeof(MaxVertWeight), pFile );
}
fclose( pFile );
#else
FILE *pFile;
if ((pFile = fopen(szFile, "w")) == NULL)
return FALSE/*failure*/;
fprintf( pFile, "version %d\n", 1 );
int i, j;
fprintf(pFile, "%d\n", m_cMaxNode );
fprintf(pFile, "%d\n", m_cMaxVertex );
for (i = 0; i < m_cMaxNode; i++)
{
fprintf(pFile, "%5d \"%s\" %3d\n",
i, m_MaxNode[i].szNodeName, m_MaxNode[i].imaxnodeParent );
}
for (j = 0; j < m_cMaxVertex; j++)
{
fprintf( pFile, "%d ", j );
for (int i = 0; i < m_cMaxNode; i++)
{
// if (strstr(m_MaxNode[i].szNodeName, "Bip01 R Finger"))
// if (m_MaxNode[i].szNodeName[0] == 'D')
{
fprintf(pFile, " %5.3f", m_MaxVertex[j][i].flDist );
fprintf(pFile, " %3.0f", m_MaxVertex[j][i].flWeight );
}
}
fprintf(pFile, "\n" );
}
fclose( pFile );
#endif
// Tell user that exporting is finished (it can take a while with no feedback)
char szExportComplete[300];
sprintf(szExportComplete, "Exported %s.", szFile);
MessageBox(GetActiveWindow(), szExportComplete, "Status", MB_OK);
return 1/*success*/;
}
bool SURFFeatureManager::CalculateFeatureSet(const int media_type,
const std::string& image_folder) {
std::string folder = image_folder;
if (image_folder[image_folder.size() - 1] != '/') {
folder += "/";
}
DIR *dir = opendir(folder.c_str());
if (dir == NULL) return false;
struct dirent *ent = NULL;
while ((ent = readdir(dir)) != NULL) {
if (strcmp(".", ent->d_name) == 0 || strcmp("..", ent->d_name) == 0) continue;
std::vector<std::string> arr;
SplitFilename(ent->d_name, &arr);
SURFFeature *feature = new SURFFeature;
GetFeature(folder + ent->d_name, feature);
char data_folder[64];
sprintf(data_folder, "%s/%d", kDataFolder, media_type);
mkdir(kDataFolder, S_IRWXU | S_IRWXG | S_IRWXO);
mkdir(data_folder, S_IRWXU | S_IRWXG | S_IRWXO);
char filepath[128];
sprintf(filepath, "%s/%s_%s_.yaml",
data_folder, arr[0].c_str(), arr[1].c_str());
cv::FileStorage fs(filepath,
cv::FileStorage::WRITE);
fs << "D" << feature->descriptor;
fs << "I" << feature->image;
fs << "K" << "[";
for (std::vector<cv::KeyPoint>::iterator it = feature->key_points.begin();
it != feature->key_points.end();
++it) {
fs << "{"
<< "x" << it->pt.x
<< "y" << it->pt.y
<< "size" << it->size
<< "angle" << it->angle
<< "response" << it->response
<< "octave" << it->octave
<< "class_id" << it->class_id
<< "}";
}
fs << "]";
fs << "R" << "{"
<< "x" << feature->roi.x
<< "y" << feature->roi.y
<< "width" << feature->roi.width
<< "height" << feature->roi.height
<< "}";
fs.release();
FeatureMap::iterator it;
if ((it = feature_map_.find(media_type)) == feature_map_.end()) {
feature_map_.insert(make_pair(
media_type,
std::map<std::string, SURFFeature*>()));
} else {
it->second.insert(make_pair(arr[1], feature));
}
}
return true;
}
