void Replay::StartPlayback(const FilePath & dirName)
{
DVASSERT(!isRecord);
DVASSERT(!isPlayback);
pauseReplay = false;
isPlayback = true;
FileSystem::Instance()->DeleteDirectoryFiles("~doc:/", false);
FileList * list = new FileList(dirName);
int32 listSize = list->GetCount();
for(int32 i = 0; i < listSize; ++i)
{
String fileName = list->GetFilename(i);
if(!list->IsNavigationDirectory(i) && !list->IsDirectory(i))
{
FilePath existingFile = dirName + fileName;
FilePath newFile("~doc:/" + fileName);
FileSystem::Instance()->CopyFile(existingFile, newFile);
}
}
list->Release();
skipType = false;
file = File::Create("~doc:/LastReplay.rep", File::OPEN | File::READ);
}
void Replay::StartRecord(const FilePath & dirName)
{
DVASSERT(!isRecord);
DVASSERT(!isPlayback);
isRecord = true;
pauseReplay = false;
FileSystem::Instance()->DeleteDirectoryFiles(dirName, false);
FileSystem::Instance()->CreateDirectory(dirName);
FileList * list = new FileList("~doc:/");
int32 listSize = list->GetCount();
for(int32 i = 0; i < listSize; ++i)
{
String fileName = list->GetFilename(i);
if(!list->IsNavigationDirectory(i) && !list->IsDirectory(i) && fileName != "LastReplay.rep")
{
FileSystem::Instance()->CopyFile(list->GetPathname(i), dirName + fileName);
}
}
list->Release();
FilePath filePath = dirName + "LastReplay.rep";
file = File::Create(filePath, File::CREATE | File::WRITE);
Random::Instance()->Seed();
}
uint32 FileSystem::DeleteDirectoryFiles(const String & path, bool isRecursive)
{
uint32 fileCount = 0;
FileList * fileList = new FileList(path);
for(int i = 0; i < fileList->GetCount(); ++i)
{
if(fileList->IsDirectory(i))
{
if(!fileList->IsNavigationDirectory(i))
{
if(isRecursive)
{
fileCount += DeleteDirectoryFiles(fileList->GetPathname(i), isRecursive);
}
}
}
else
{
bool success = DeleteFile(fileList->GetPathname(i));
if(success)fileCount++;
}
}
SafeRelease(fileList);
return fileCount;
}
FilePath HeightmapModificationCommand::SaveHeightmap(Heightmap* heightmap)
{
FilePath documentsPath("~doc:/");
FilePath folderPathname("~doc:/History/");
FileSystem::Instance()->CreateDirectory(folderPathname);
folderPathname = folderPathname + "Heightmap/";
FileSystem::Instance()->CreateDirectory(folderPathname);
FileList* fileList = new FileList(folderPathname);
bool validFileName = false;
String filename;
String time = TimeString();
uint32 num = 0;
do
{
filename = time;
if (num)
{
filename += Format(" (%d)", num);
}
filename += Heightmap::FileExtension();
int32 i = 0;
for (; i < fileList->GetCount(); ++i)
{
if (fileList->GetFilename(i) == filename)
{
++num;
break;
}
}
if (i >= fileList->GetCount())
validFileName = true;
} while (!validFileName);
FilePath saveFileName = folderPathname + filename;
heightmap->Save(saveFileName);
SafeRelease(fileList);
return saveFileName;
}
void LightmapsPacker::ParseSpriteDescriptors()
{
FileList * fileList = new FileList(outputDir);
char8 buf[512];
uint32 readSize;
int32 itemsCount = fileList->GetCount();
for(int32 i = 0; i < itemsCount; ++i)
{
const FilePath & filePath = fileList->GetPathname(i);
if(fileList->IsDirectory(i) || !filePath.IsEqualToExtension(".txt"))
{
continue;
}
LightmapAtlasingData data;
data.meshInstanceName = filePath.GetBasename();
File * file = File::Create(filePath, File::OPEN | File::READ);
file->ReadLine(buf, sizeof(buf)); //textures count
readSize = file->ReadLine(buf, sizeof(buf)); //texture name
FilePath originalTextureName = outputDir + String(buf, readSize);
data.textureName = originalTextureName;
file->ReadLine(buf, sizeof(buf)); //image size
file->ReadLine(buf, sizeof(buf)); //frames count
file->ReadLine(buf, sizeof(buf)); //frame rect
int32 x, y, dx, dy, unused0, unused1, unused2;
sscanf(buf, "%d %d %d %d %d %d %d", &x, &y, &dx, &dy, &unused0, &unused1, &unused2);
dx++;//cause TexturePacker::ReduceRectToOriginalSize removed one pixel by default
dy++;
Vector2 textureSize = GetTextureSize(originalTextureName);
data.uvOffset = Vector2((float32)x/textureSize.x, (float32)y/textureSize.y);
data.uvScale = Vector2((float32)dx/textureSize.x, (float32)dy/textureSize.y);
file->Release();
atlasingData.push_back(data);
FileSystem::Instance()->DeleteFile(filePath);
}
fileList->Release();
}
void UIFileTree::RecursiveTreeWalk(const String & path, UITreeItemInfo * current)
{
FileList * fileList = new FileList(path);
// Find flags and setup them
for (int fi = 0; fi < fileList->GetCount(); ++fi)
{
bool addElement = true;
if (!fileList->IsDirectory(fi))
{
size_t extsSize = extensions.size();
if (extsSize > 0)
{
addElement = false;
String ext = FileSystem::GetExtension(fileList->GetFilename(fi));
for (size_t ei = 0; ei < extsSize; ++ei)
if (extensions[ei] == ext)
{
addElement = true;
break;
}
}
}
if (!isFolderNavigationEnabled)
if (fileList->IsNavigationDirectory(fi))
addElement = false;
if (fileList->GetFilename(fi) == ".")
addElement = false;
if (addElement)
{
UITreeItemInfo *child = new UITreeItemInfo(this);
child->Set(current->GetLevel() + 1, fileList->GetFilename(fi), fileList->GetPathname(fi), fileList->IsDirectory(fi));
current->AddChild(child);
// if (fileList->IsDirectory(fi) )
// {
// if (!fileList->IsNavigationDirectory(fi))
// {
// RecursiveTreeWalk(path + String("/") + fileList->GetFilename(fi), child);
// }
// }
}
}
SafeRelease(fileList);
}
void LightmapsPacker::CreateDescriptors()
{
FileList * fileList = new FileList(outputDir);
int32 itemsCount = fileList->GetCount();
for(int32 i = 0; i < itemsCount; ++i)
{
const FilePath & filePath = fileList->GetPathname(i);
if(fileList->IsDirectory(i) || !filePath.IsEqualToExtension(".png"))
{
continue;
}
TextureDescriptor descriptor;
descriptor.Save(TextureDescriptor::GetDescriptorPathname(filePath));
}
fileList->Release();
}
void TextureDescriptorUtils::CopyCompressionParamsForFolder(const FilePath &folderPathname)
{
FileList * fileList = new FileList(folderPathname);
for (int32 fi = 0; fi < fileList->GetCount(); ++fi)
{
const FilePath &pathname = fileList->GetPathname(fi);
if(IsCorrectDirectory(fileList, fi))
{
CopyCompressionParamsForFolder(pathname);
}
else if(IsDescriptorPathname(pathname))
{
CopyCompressionParams(pathname);
}
}
SafeRelease(fileList);
}
bool FileSystem::DeleteDirectory(const String & path, bool isRecursive)
{
FileList * fileList = new FileList(path);
for(int i = 0; i < fileList->GetCount(); ++i)
{
if(fileList->IsDirectory(i))
{
if(!fileList->IsNavigationDirectory(i))
{
if(isRecursive)
{
// Logger::Debug("- try to delete directory: %s / %s", fileList->GetPathname(i).c_str(), fileList->GetFilename(i).c_str());
bool success = DeleteDirectory(fileList->GetPathname(i), isRecursive);
// Logger::Debug("- delete directory: %s / %s- %d", fileList->GetPathname(i).c_str(), fileList->GetFilename(i).c_str(), success ? (1): (0));
if (!success)return false;
}
}
}
else
{
bool success = DeleteFile(fileList->GetPathname(i));
// Logger::Debug("- delete file: %s / %s- %d", fileList->GetPathname(i).c_str(), fileList->GetFilename(i).c_str(), success ? (1): (0));
if(!success)return false;
}
}
SafeRelease(fileList);
#ifdef __DAVAENGINE_WIN32__
String sysPath = SystemPathForFrameworkPath(path);
int32 chmodres = _chmod(sysPath.c_str(), _S_IWRITE); // change read-only file mode
int32 res = _rmdir(sysPath.c_str());
return (res == 0);
/*int32 res = ::RemoveDirectoryA(path.c_str());
if (res == 0)
{
Logger::Warning("Failed to delete directory: %s error: 0x%x", path.c_str(), GetLastError());
}
return (res != 0);*/
#elif defined(__DAVAENGINE_MACOS__) || defined(__DAVAENGINE_IPHONE__) || defined(__DAVAENGINE_ANDROID__)
int32 res = rmdir(SystemPathForFrameworkPath(path).c_str());
return (res == 0);
#endif //PLATFORMS
}
void TextureDescriptorUtils::SetCompressionParamsForFolder( const FilePath &folderPathname, const DAVA::Map<DAVA::eGPUFamily, DAVA::TextureDescriptor::Compression> & compressionParams, bool convertionEnabled, bool force )
{
FileList * fileList = new FileList(folderPathname);
if(!fileList) return;
for (int32 fi = 0; fi < fileList->GetCount(); ++fi)
{
const FilePath &pathname = fileList->GetPathname(fi);
if(IsCorrectDirectory(fileList, fi))
{
SetCompressionParamsForFolder(pathname, compressionParams, convertionEnabled, force);
}
else if(IsDescriptorPathname(pathname))
{
SetCompressionParams(pathname, compressionParams, convertionEnabled, force);
}
}
SafeRelease(fileList);
}
void TextureDescriptorUtils::CreateDescriptorsForFolder(const FilePath &folderPathname)
{
FileList * fileList = new FileList(folderPathname);
if(!fileList) return;
for (int32 fi = 0; fi < fileList->GetCount(); ++fi)
{
const FilePath &pathname = fileList->GetPathname(fi);
if(IsCorrectDirectory(fileList, fi))
{
CreateDescriptorsForFolder(pathname);
}
else if(pathname.IsEqualToExtension(".png"))
{
CreateDescriptorIfNeed(pathname);
}
}
SafeRelease(fileList);
}
void ResourcePackerScreen::RecursiveTreeWalk(const String & inputPath, const String & outputPath)
{
uint64 packTime = SystemTimer::Instance()->AbsoluteMS();
FileList * fileList = new FileList(inputPath);
/* New $process folder structure */
String dataSourceRelativePath = inputPath;
StringReplace(dataSourceRelativePath, excludeDirectory, std::string(""));
// printf("%s\n", dataSourceRelativePath.c_str());
String processDirectoryPath = excludeDirectory + String("/") + GetProcessFolderName() + String("/") + dataSourceRelativePath;
if (FileSystem::Instance()->CreateDirectory(processDirectoryPath, true) == FileSystem::DIRECTORY_CANT_CREATE)
{
//Logger::Error("Can't create directory: %s", processDirectoryPath.c_str());
}
if(clearProcessDirectory)
{
FileSystem::Instance()->DeleteDirectoryFiles(processDirectoryPath, false);
}
//String outputPath = outputPath;
if (FileSystem::Instance()->CreateDirectory(outputPath) == FileSystem::DIRECTORY_CANT_CREATE)
{
//Logger::Error("Can't create directory: %s", outputPath.c_str());
}
CommandLineParser::Instance()->ClearFlags();
std::list<DefinitionFile *> definitionFileList;
// Find flags and setup them
for (int fi = 0; fi < fileList->GetCount(); ++fi)
{
if (!fileList->IsDirectory(fi))
{
if (fileList->GetFilename(fi) == "flags.txt")
{
String fullname = inputPath + String("/") + fileList->GetFilename(fi);
ProcessFlags(fullname);
break;
}
}
}
bool modified = isGfxModified;
// Process all psd / png files
if (IsMD5ChangedDir(processDirectoryPath, inputPath, "dir.md5", false))
{
modified = true;
//if (Core::Instance()->IsConsoleMode())
// printf("[Directory changed - rebuild: %s]\n", inputGfxDirectory.c_str());
}
if (modified)
{
FileSystem::Instance()->DeleteDirectoryFiles(outputPath, false);
for (int fi = 0; fi < fileList->GetCount(); ++fi)
{
if (!fileList->IsDirectory(fi))
{
String fullname = inputPath + String("/") + fileList->GetFilename(fi);
if (FileSystem::GetExtension(fullname) == ".psd")
{
DefinitionFile * defFile = ProcessPSD(processDirectoryPath, fullname, fileList->GetFilename(fi));
definitionFileList.push_back(defFile);
}
else if(isLightmapsPacking && FileSystem::GetExtension(fullname) == ".png")
{
DefinitionFile * defFile = new DefinitionFile();
defFile->LoadPNG(fullname, processDirectoryPath);
definitionFileList.push_back(defFile);
}
else if (FileSystem::GetExtension(fullname) == ".pngdef")
{
DefinitionFile * defFile = new DefinitionFile();
if (defFile->LoadPNGDef(fullname, processDirectoryPath))
{
definitionFileList.push_back(defFile);
}
else
{
SafeDelete(defFile);
}
}
}
}
//
if (definitionFileList.size() > 0 && modified)
{
TexturePacker packer;
String outputPathWithSlash = outputPath + String("/");
if(isLightmapsPacking)
{
packer.UseOnlySquareTextures();
packer.SetMaxTextureSize(2048);
}
if (CommandLineParser::Instance()->IsFlagSet("--split"))
{
packer.PackToTexturesSeparate(excludeDirectory.c_str(), outputPathWithSlash.c_str(), definitionFileList);
}
else
{
packer.PackToTextures(excludeDirectory.c_str(), outputPathWithSlash.c_str(), definitionFileList);
}
}
}
packTime = SystemTimer::Instance()->AbsoluteMS() - packTime;
if (Core::Instance()->IsConsoleMode())
{
if (CommandLineParser::Instance()->IsExtendedOutput())
{
printf("[%d files packed with flags: %s]\n", (int)definitionFileList.size(), currentFlags.c_str());
}
String result = "[unchanged]";
if (modified)
result = "[REPACKED]";
printf("[%s - %.2lf secs] - %s\n", inputPath.c_str(), (float64)packTime / 1000.0f, result.c_str());
}
for (std::list<DefinitionFile*>::iterator it = definitionFileList.begin(); it != definitionFileList.end(); ++it)
{
DefinitionFile * file = *it;
SafeDelete(file);
}
definitionFileList.clear();
for (int fi = 0; fi < fileList->GetCount(); ++fi)
{
if (fileList->IsDirectory(fi))
{
String filename = fileList->GetFilename(fi);
if ((filename != ".") && (filename != "..") && (filename != "$process") && (filename != ".svn"))
{
if ((filename.size() > 0) && (filename[0] != '.'))
RecursiveTreeWalk(inputPath + String("/") + fileList->GetFilename(fi),
outputPath + String("/") + fileList->GetFilename(fi));
}
}
}
SafeRelease(fileList);
}