void AssetDatabase::DeleteAsset(Asset* asset)
{
SharedPtr<Asset> assetPtr(asset);
List<SharedPtr<Asset>>::Iterator itr = assets_.Find(assetPtr);
if (itr == assets_.End())
return;
assets_.Erase(itr);
const String& resourcePath = asset->GetPath();
FileSystem* fs = GetSubsystem<FileSystem>();
if (fs->DirExists(resourcePath))
{
fs->RemoveDir(resourcePath, true);
}
else if (fs->FileExists(resourcePath))
{
fs->Delete(resourcePath);
}
String dotAsset = resourcePath + ".asset";
if (fs->FileExists(dotAsset))
{
fs->Delete(dotAsset);
}
VariantMap eventData;
eventData[ResourceRemoved::P_GUID] = asset->GetGUID();
SendEvent(E_RESOURCEREMOVED, eventData);
}
void LicenseSystem::RemoveLicense()
{
FileSystem* filesystem = GetSubsystem<FileSystem>();
if (filesystem->FileExists(licenseFilePath_))
{
filesystem->Delete(licenseFilePath_);
}
if (filesystem->FileExists(licenseCachePath_))
{
filesystem->Delete(licenseCachePath_);
}
}
void AssetDatabase::PruneOrphanedDotAssetFiles()
{
if (project_.Null())
{
LOGDEBUG("AssetDatabase::PruneOrphanedDotAssetFiles - called without project loaded");
return;
}
FileSystem* fs = GetSubsystem<FileSystem>();
const String& resourcePath = project_->GetResourcePath();
Vector<String> allResults;
fs->ScanDir(allResults, resourcePath, "*.asset", SCAN_FILES, true);
for (unsigned i = 0; i < allResults.Size(); i++)
{
String dotAssetFilename = resourcePath + allResults[i];
String assetFilename = ReplaceExtension(dotAssetFilename, "");
// remove orphaned asset files
if (!fs->FileExists(assetFilename) && !fs->DirExists(assetFilename))
{
LOGINFOF("Removing orphaned asset file: %s", dotAssetFilename.CString());
fs->Delete(dotAssetFilename);
}
}
}
bool TextureImporter::Import()
{
AssetDatabase* db = GetSubsystem<AssetDatabase>();
ResourceCache* cache = GetSubsystem<ResourceCache>();
String cachePath = db->GetCachePath();
FileSystem* fileSystem = GetSubsystem<FileSystem>();
String compressedPath = cachePath + "DDS/" + asset_->GetRelativePath() + ".dds";
if (fileSystem->FileExists(compressedPath))
fileSystem->Delete(compressedPath);
SharedPtr<Image> image = cache->GetTempResource<Image>(asset_->GetPath());
if (image.Null())
return false;
if (compressTextures_ &&
!image->IsCompressed())
{
fileSystem->CreateDirs(cachePath, "DDS/" + Atomic::GetPath(asset_->GetRelativePath()));
float resizefactor;
float width = image->GetWidth();
float height = image->GetHeight();
if (width > compressedSize_ || height > compressedSize_)
{
if (width >= height)
{
resizefactor = compressedSize_ / width;
}
else
{
resizefactor = compressedSize_ / height;
}
image->Resize(width*resizefactor, height*resizefactor);
}
if (image->SaveDDS(compressedPath))
{
Renderer * renderer = GetSubsystem<Renderer>();
renderer->ReloadTextures();
}
}
// todo, proper proportions
image->Resize(64, 64);
// not sure entirely what we want to do here, though if the cache file doesn't exist
// will reimport
image->SavePNG(cachePath + asset_->GetGUID());
// save thumbnail
image->SavePNG(cachePath + asset_->GetGUID() + "_thumbnail.png");
return true;
}
/// Save account information to a file
void GameEconomicGameClient::SaveConfiguration(Configuration &configuration)
{
/// Get Resource
ResourceCache * cache = GetSubsystem<ResourceCache>();
FileSystem * fileSystem = GetSubsystem<FileSystem>();
String configFileName;
/// Set directory and path for network file
configFileName.Append(fileSystem->GetProgramDir().CString());
configFileName.Append("");
configFileName.Append("Configuration.xml");
/// Check if the account file information exist
if(fileSystem->FileExists(configFileName.CString()))
{
fileSystem->Delete(configFileName.CString());
}
cout << "It got here "<<endl;
File saveFile(context_, configFileName.CString(), FILE_WRITE);
XMLFile * preferencefileconfig = new XMLFile(context_);
XMLElement configElem = preferencefileconfig -> CreateRoot("Configuration");
XMLElement GameModeConfigurationElement = configElem.CreateChild("GameModeConfiguration");
XMLElement VideoConfigurationElement= configElem.CreateChild("VideoConfiguration");
/// Set true false
if(configuration.GameModeForceTablet==true)
{
GameModeConfigurationElement.SetAttribute("GameModeForceTablet", "true");
}
else
{
GameModeConfigurationElement.SetAttribute("GameModeForceTablet", "false");
}
/// Convert video bloom to float
String VideoBloomParamValue1String(configuration.VideoBloomParam1);
String VideoBloomParamValue2String(configuration.VideoBloomParam2);
/// Copy values testing
VideoConfigurationElement.SetAttribute("BloomParam1",VideoBloomParamValue1String);
VideoConfigurationElement.SetAttribute("BloomParam2",VideoBloomParamValue2String);
preferencefileconfig->Save(saveFile);
return;
}
void LicenseSystem::RemoveLicense()
{
FileSystem* filesystem = GetSubsystem<FileSystem>();
String licenseFilePath = filesystem->GetAppPreferencesDir("AtomicEditor", "License");
licenseFilePath = AddTrailingSlash(licenseFilePath);
licenseFilePath += "AtomicLicense";
if (filesystem->FileExists(licenseFilePath))
{
filesystem->Delete(licenseFilePath);
}
}
void ResourceOps::HandleResourceDelete(const String& resourcePath, bool reportError)
{
Editor* editor = GetSubsystem<Editor>();
FileSystem* fs = GetSubsystem<FileSystem>();
if (fs->DirExists(resourcePath))
{
fs->RemoveDir(resourcePath, true);
GetSubsystem<MainFrame>()->GetProjectFrame()->Refresh();
return;
}
else if (fs->FileExists(resourcePath))
{
if (!fs->Delete(resourcePath))
{
if (reportError)
{
String errorMsg;
errorMsg.AppendWithFormat("Unable to delete:\n\n %s", resourcePath.CString());
editor->PostModalError("Delete Resource Error", errorMsg);
}
return;
}
GetSubsystem<MainFrame>()->GetProjectFrame()->Refresh();
return;
}
else
{
if (reportError)
{
String errorMsg;
errorMsg.AppendWithFormat("Unable to find:\n\n %s", resourcePath.CString());
editor->PostModalError("Delete Resource Error", errorMsg);
}
return;
}
}