String Asset::GetCachePath() const
{
AssetDatabase* db = GetSubsystem<AssetDatabase>();
String cachePath = db->GetCachePath();
cachePath += guid_;
return cachePath;
}
bool Asset::CheckCacheFile()
{
if (importer_.Null())
return true;
FileSystem* fs = GetSubsystem<FileSystem>();
AssetDatabase* db = GetSubsystem<AssetDatabase>();
String cachePath = db->GetCachePath();
String cacheFile = cachePath + guid_;
unsigned modifiedTime = fs->GetLastModifiedTime(path_);
if (importer_->RequiresCacheFile()) {
if (!fs->FileExists(cacheFile) || fs->GetLastModifiedTime(cacheFile) < modifiedTime)
return false;
}
if (fs->GetLastModifiedTime(GetDotAssetFilename()) < modifiedTime)
{
return false;
}
return true;
}
static int AssetDatabase_GetAssetsByImporterType(duk_context* ctx)
{
JSVM* vm = JSVM::GetJSVM(ctx);
ToolSystem* ts = vm->GetSubsystem<ToolSystem>();
AssetDatabase* db = vm->GetSubsystem<AssetDatabase>();
Project* project = ts->GetProject();
StringHash type = duk_require_string(ctx, 0);
String resourceType = duk_require_string(ctx, 1);
duk_push_array(ctx);
if (!project)
return 1;
PODVector<Asset*> assets;
db->GetAssetsByImporterType(type, resourceType, assets);
for(unsigned i = 0; i < assets.Size(); i++)
{
js_push_class_object_instance(ctx, assets[i], 0);
duk_put_prop_index(ctx, -2, i);
}
return 1;
}
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;
}
Asset* Asset::GetParent()
{
AssetDatabase* db = GetSubsystem<AssetDatabase>();
String pathName;
String fileName;
String ext;
SplitPath(path_, pathName, fileName, ext);
return db->GetAssetByPath(RemoveTrailingSlash(pathName));
}
int main()
{
GLEngine::initialize("GLResourceBuilder", 0, 0, EWindowMode::NONE);
SceneProcessor sceneProcessor;
AssetDatabase objDB;
ResourceBuilder::ResourceProcessorMap processors = {{"obj", &sceneProcessor}};
objDB.createNew("..\\GLApp\\assets\\OBJ-DB.da");
ResourceBuilder::buildResourcesDB(processors, "..\\GLApp\\assets\\Models", objDB);
objDB.writeAndClose();
print("Press enter to exit\n");
std::cin.ignore();
GLEngine::finish();
return 0;
}
bool BuildWindows::CheckIncludeResourceFile(const String& resourceDir, const String& fileName)
{
// #623 BEGIN TODO: Skip files that have a converted version in the cache
AssetDatabase* db = GetSubsystem<AssetDatabase>();
String cachePath = db->GetCachePath();
if (resourceDir != cachePath)
{
String ext = GetExtension(fileName);
if (ext == ".jpg" || ext == ".png" || ext == ".tga")
{
FileSystem* fileSystem = GetSubsystem<FileSystem>();
String compressedPath = cachePath + "DDS/" + fileName + ".dds";
if (fileSystem->FileExists(compressedPath))
return false;
}
}
// #623 END TODO
return BuildBase::CheckIncludeResourceFile(resourceDir, fileName);
}
void BuildWindows::Initialize()
{
ToolSystem* tsystem = GetSubsystem<ToolSystem>();
Project* project = tsystem->GetProject();
Vector<String> defaultResourcePaths;
GetDefaultResourcePaths(defaultResourcePaths);
for (unsigned i = 0; i < defaultResourcePaths.Size(); i++)
{
AddResourceDir(defaultResourcePaths[i]);
}
BuildDefaultResourceEntries();
// Include the project resources and cache separately
AddProjectResourceDir(project->GetResourcePath());
AssetDatabase* db = GetSubsystem<AssetDatabase>();
String cachePath = db->GetCachePath();
AddProjectResourceDir(cachePath);
BuildProjectResourceEntries();
}
bool Asset::SetPath(const String& path)
{
assert(!guid_.Length());
assert(!path_.Length());
// need to update path, not set, which should only be done on first import
assert(importer_.Null());
FileSystem* fs = GetSubsystem<FileSystem>();
AssetDatabase* db = GetSubsystem<AssetDatabase>();
path_ = path;
// create importer based on path
if (!CreateImporter())
return false;
String assetFilename = GetDotAssetFilename();
if (fs->FileExists(assetFilename))
{
// load the json, todo: handle fail
Load();
}
else
{
dirty_ = true;
guid_ = db->GenerateAssetGUID();
Save();
}
// TODO: handle failed
return true;
}
// load .asset
bool Asset::Load()
{
FileSystem* fs = GetSubsystem<FileSystem>();
AssetDatabase* db = GetSubsystem<AssetDatabase>();
String assetFilename = GetDotAssetFilename();
SharedPtr<File> file(new File(context_, assetFilename));
json_ = new JSONFile(context_);
json_->Load(*file);
file->Close();
JSONValue root = json_->GetRoot();
assert(root.Get("version").GetInt() == ASSET_VERSION);
guid_ = root.Get("guid").GetString();
db->RegisterGUID(guid_);
dirty_ = false;
if (!CheckCacheFile())
{
LOGINFOF("CheckCacheFile:false - %s", path_.CString());
dirty_ = true;
}
// handle import
if (importer_.NotNull())
importer_->LoadSettings(root);
json_ = 0;
return true;
}
void BuildAndroid::Initialize()
{
ToolSystem* tsystem = GetSubsystem<ToolSystem>();
Project* project = tsystem->GetProject();
Vector<String> defaultResourcePaths;
GetDefaultResourcePaths(defaultResourcePaths);
for (unsigned i = 0; i < defaultResourcePaths.Size(); i++)
{
AddResourceDir(defaultResourcePaths[i]);
}
BuildDefaultResourceEntries();
// TODO: smart filtering of cache
String projectResources = project->GetResourcePath();
AddProjectResourceDir(projectResources);
AssetDatabase* db = GetSubsystem<AssetDatabase>();
String cachePath = db->GetCachePath();
AddProjectResourceDir(cachePath);
BuildProjectResourceEntries();
}
bool ModelImporter::ImportAnimations()
{
if (!animationInfo_.Size())
{
if (!ImportAnimation(asset_->GetPath(), "RootAnim"))
return false;
}
// embedded animations
for (unsigned i = 0; i < animationInfo_.Size(); i++)
{
const SharedPtr<AnimationImportInfo>& info = animationInfo_[i];
if (!ImportAnimation(asset_->GetPath(), info->GetName(), info->GetStartTime(), info->GetEndTime()))
return false;
}
// add @ animations
FileSystem* fs = GetSubsystem<FileSystem>();
String pathName, fileName, ext;
SplitPath(asset_->GetPath(), pathName, fileName, ext);
Vector<String> results;
fs->ScanDir(results, pathName, ext, SCAN_FILES, false);
for (unsigned i = 0; i < results.Size(); i++)
{
const String& result = results[i];
if (result.Contains("@"))
{
Vector<String> components = GetFileName(result).Split('@');
if (components.Size() == 2 && components[1].Length() && components[0] == fileName)
{
String animationName = components[1];
AssetDatabase* db = GetSubsystem<AssetDatabase>();
Asset* asset = db->GetAssetByPath(pathName + result);
assert(asset);
assert(asset->GetImporter()->GetType() == ModelImporter::GetTypeStatic());
ModelImporter* importer = (ModelImporter*) asset->GetImporter();
if (!importer->animationInfo_.Size())
{
if (!ImportAnimation(asset->GetPath(), animationName))
return false;
}
else
{
// embedded animations
for (unsigned i = 0; i < importer->animationInfo_.Size(); i++)
{
const SharedPtr<AnimationImportInfo>& info = importer->animationInfo_[i];
if (!ImportAnimation(asset->GetPath(), info->GetName(), info->GetStartTime(), info->GetEndTime()))
return false;
}
}
}
}
}
return true;
}