HMesh loadMesh(const Path& path, float scale)
{
Path assetPath = path;
assetPath.setExtension(path.getExtension() + ".asset");
HMesh model = gResources().load<Mesh>(assetPath);
if (model == nullptr) // Mesh file doesn't exist, import from the source file.
{
// When importing you may specify optional import options that control how is the asset imported.
SPtr<ImportOptions> meshImportOptions = Importer::instance().createImportOptions(path);
// rtti_is_of_type checks if the import options are of valid type, in case the provided path is pointing to a
// non-mesh resource. This is similar to dynamic_cast but uses Banshee internal RTTI system for type checking.
if (rtti_is_of_type<MeshImportOptions>(meshImportOptions))
{
MeshImportOptions* importOptions = static_cast<MeshImportOptions*>(meshImportOptions.get());
importOptions->setImportScale(scale);
}
model = gImporter().import<Mesh>(path, meshImportOptions);
// Save for later use, so we don't have to import on the next run.
gResources().save(model, assetPath, true);
}
return model;
}
HTexture loadTexture(const Path& path, bool isSRGB, bool isCubemap, bool isHDR)
{
Path assetPath = path;
assetPath.setExtension(path.getExtension() + ".asset");
HTexture texture = gResources().load<Texture>(assetPath);
if (texture == nullptr) // Texture file doesn't exist, import from the source file.
{
// When importing you may specify optional import options that control how is the asset imported.
SPtr<ImportOptions> textureImportOptions = Importer::instance().createImportOptions(path);
// rtti_is_of_type checks if the import options are of valid type, in case the provided path is pointing to a
// non-texture resource. This is similar to dynamic_cast but uses Banshee internal RTTI system for type checking.
if (rtti_is_of_type<TextureImportOptions>(textureImportOptions))
{
TextureImportOptions* importOptions = static_cast<TextureImportOptions*>(textureImportOptions.get());
// We want maximum number of mipmaps to be generated
importOptions->setGenerateMipmaps(true);
// If the texture is in sRGB space the system needs to know about it
importOptions->setSRGB(isSRGB);
// Ensures we can save the texture contents
importOptions->setCPUCached(true);
// Import as cubemap if needed
importOptions->setIsCubemap(isCubemap);
// If importing as cubemap, assume source is a panorama
importOptions->setCubemapSourceType(CubemapSourceType::Cylindrical);
// Importing using a HDR format if requested
if (isHDR)
importOptions->setFormat(PF_RG11B10F);
}
// Import texture with specified import options
texture = gImporter().import<Texture>(path, textureImportOptions);
// Save for later use, so we don't have to import on the next run.
gResources().save(texture, assetPath, true);
}
return texture;
}
void BuiltinEditorResources::preprocess(bool forceImport, time_t lastUpdateTime)
{
Resources::instance().unloadAllUnused();
Path dataListsFilePath = BuiltinRawDataFolder + DATA_LIST_JSON;
SPtr<DataStream> dataListStream = FileSystem::openFile(dataListsFilePath);
json dataListJSON = json::parse(dataListStream->getAsString().c_str());
json skinJSON = dataListJSON["Skin"];
json iconsJSON = dataListJSON["Icons"];
json includesJSON = dataListJSON["Includes"];
json shadersJSON = dataListJSON["Shaders"];
// Update DataList.json if needed
bool updatedDataLists = false;
updatedDataLists |= BuiltinResourcesHelper::updateJSON(
EditorRawIconsFolder,
BuiltinResourcesHelper::AssetType::Sprite,
iconsJSON);
updatedDataLists |= BuiltinResourcesHelper::updateJSON(
EditorRawShaderIncludeFolder,
BuiltinResourcesHelper::AssetType::Normal,
includesJSON);
updatedDataLists |= BuiltinResourcesHelper::updateJSON(
EditorRawShaderFolder,
BuiltinResourcesHelper::AssetType::Normal,
shadersJSON);
updatedDataLists |= BuiltinResourcesHelper::updateJSON(
EditorRawSkinFolder,
BuiltinResourcesHelper::AssetType::Sprite,
skinJSON);
dataListStream->close();
if (updatedDataLists)
{
FileSystem::remove(dataListsFilePath);
dataListJSON["Skin"] = skinJSON;
dataListJSON["Icons"] = iconsJSON;
dataListJSON["Includes"] = includesJSON;
dataListJSON["Shaders"] = shadersJSON;
String jsonString = dataListJSON.dump(4).c_str();
dataListStream = FileSystem::createAndOpenFile(dataListsFilePath);
dataListStream->writeString(jsonString);
dataListStream->close();
}
// If forcing import, clear all data folders since everything will be recreated anyway
Path shaderDependenciesFile = BuiltinDataFolder + "ShaderDependencies.json";
if(forceImport)
{
FileSystem::remove(EditorIconFolder);
FileSystem::remove(EditorShaderIncludeFolder);
FileSystem::remove(EditorShaderFolder);
FileSystem::remove(EditorSkinFolder);
FileSystem::remove(shaderDependenciesFile);
}
// Read shader dependencies JSON
json shaderDependenciesJSON;
if(FileSystem::exists(shaderDependenciesFile))
{
SPtr<DataStream> stream = FileSystem::openFile(shaderDependenciesFile);
shaderDependenciesJSON = json::parse(stream->getAsString().c_str());
stream->close();
}
// Import icons
{
BuiltinResourcesHelper::updateManifest(
EditorIconFolder,
iconsJSON,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Sprite);
Vector<bool> importFlags = BuiltinResourcesHelper::generateImportFlags(
iconsJSON,
EditorRawIconsFolder,
lastUpdateTime,
forceImport);
BuiltinResourcesHelper::importAssets(
iconsJSON,
importFlags,
EditorRawIconsFolder,
EditorIconFolder,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Sprite);
}
// Import shaders
{
BuiltinResourcesHelper::updateManifest(
EditorShaderIncludeFolder,
includesJSON,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal);
BuiltinResourcesHelper::updateManifest(
EditorShaderFolder,
shadersJSON,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal);
Vector<bool> includeImportFlags = BuiltinResourcesHelper::generateImportFlags(
includesJSON,
EditorRawShaderIncludeFolder,
lastUpdateTime,
forceImport);
Vector<bool> shaderImportFlags = BuiltinResourcesHelper::generateImportFlags(
shadersJSON,
EditorRawShaderFolder,
lastUpdateTime,
forceImport,
&shaderDependenciesJSON,
EditorRawShaderIncludeFolder);
// Hidden dependency: Includes must be imported before shaders, but import flags for shaders must be generated
// before includes are imported, since the process checks if imports changed
BuiltinResourcesHelper::importAssets(
includesJSON,
includeImportFlags,
EditorRawShaderIncludeFolder,
EditorShaderIncludeFolder,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal);
BuiltinResourcesHelper::importAssets(
shadersJSON,
shaderImportFlags,
EditorRawShaderFolder,
EditorShaderFolder,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Normal,
&shaderDependenciesJSON);
}
// Import GUI sprites
{
BuiltinResourcesHelper::updateManifest(
EditorSkinFolder,
skinJSON,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Sprite);
Vector<bool> includeImportFlags = BuiltinResourcesHelper::generateImportFlags(
skinJSON,
EditorRawSkinFolder,
lastUpdateTime,
forceImport);
BuiltinResourcesHelper::importAssets(
skinJSON,
includeImportFlags,
EditorRawSkinFolder,
EditorSkinFolder,
mResourceManifest,
BuiltinResourcesHelper::AssetType::Sprite);
}
// Update shader dependencies JSON
{
String jsonString = shaderDependenciesJSON.dump(4).c_str();
dataListStream = FileSystem::createAndOpenFile(shaderDependenciesFile);
dataListStream->writeString(jsonString);
dataListStream->close();
}
// Import fonts
BuiltinResourcesHelper::importFont(
BuiltinRawDataFolder + DefaultFontFilename,
DefaultFontFilename,
BuiltinDataFolder,
{ DefaultFontSize },
true,
UUID("6ce69053-00d7-4c60-a229-249b8d8fd60e"),
mResourceManifest);
BuiltinResourcesHelper::importFont(
BuiltinRawDataFolder + DefaultFontFilename,
DefaultAAFontFilename,
BuiltinDataFolder,
{ TitleFontSize },
true,
UUID("10999b74-d976-4116-9f72-21e489a7a8e4"),
mResourceManifest);
// Import splash screen
{
Path inputPath = BuiltinRawDataFolder + String(SplashScreenName);
Path outputPath = BuiltinDataFolder + (String(SplashScreenName) + ".asset");
auto textureIO = gImporter().createImportOptions<TextureImportOptions>(inputPath);
textureIO->setCPUCached(true);
textureIO->setGenerateMipmaps(false);
HTexture splashTexture = gImporter().import<Texture>(inputPath, textureIO);
SPtr<PixelData> splashPixelData = splashTexture->getProperties().allocBuffer(0, 0);
splashTexture->readCachedData(*splashPixelData);
FileEncoder fe(outputPath);
fe.encode(splashPixelData.get());
}
// Generate & save GUI skin
{
SPtr<GUISkin> skin = generateGUISkin();
Path outputPath = BuiltinDataFolder + (GUISkinFile + ".asset");
HResource skinResource = gResources()._createResourceHandle(skin, UUID("ec0ea68d-efa5-4a3b-a6fc-b15aaec9689f"));
gResources().save(skinResource, outputPath, true);
mResourceManifest->registerResource(skinResource.getUUID(), outputPath);
}
Resources::instance().unloadAllUnused();
}
