/// <summary>
/// This function is for post processing project imported audio assets.
/// </summary>
/// <param name="importConfiguration">Takes in the import configuration asset.</param>
/// <param name="assetPostprocessor">Takes in the asset postprocessor class.</param>
public static void ProcessAudioAsset(ConfigurationAsset importConfiguration, AssetPostprocessor assetPostprocessor)
{
// Trying to modify the audio importer settings.
try
{
// Getting the audio asset impoprter settings
var audioImporter = assetPostprocessor.assetImporter as AudioImporter;
// Getting the default audio importer sample settings from the new audio imported.
AudioImporterSampleSettings audioConfiguration = audioImporter.defaultSampleSettings;
// Applying the configured audio settings data to the imported audio asset.
audioConfiguration.loadType = importConfiguration.AudioImportConfiguration.LoadType;
audioConfiguration.sampleRateSetting = importConfiguration.AudioImportConfiguration.SampleRate;
audioConfiguration.compressionFormat = importConfiguration.AudioImportConfiguration.CompressionFormat;
// Assigning configured audio importer configurations.
audioImporter.defaultSampleSettings = audioConfiguration;
// Checking for active audio overide platorm option.
bool platformOverideEnabled = importConfiguration.AudioImportConfiguration.AudioOveridePlatormOption != PlatformOption.None;
// Checking if platform settings overide is enabled.
if (platformOverideEnabled)
{
// Overiding platform settings for selected runtime platform.
audioImporter.SetOverrideSampleSettings(importConfiguration.AudioImportConfiguration.AudioOveridePlatormOption.ToString(), audioConfiguration);
}
}
catch (Exception e)
{
// Throwing a new system exception.
Debugger.ThrowException(e);
}
}
/// <summary>
/// Updates all assets from the configuration asset's included diretories.
/// </summary>
/// <param name="configurationAsset">This function takes in a configuration asset file and use the data to find and update project affected assets.</param>
public static void OnUpdateIncludedAssetsUsingConfiguration(ConfigurationAsset configurationAsset)
{
// Checking if configuration file is valid
bool isValidConfigurationAssetFile = AssetImportDirectory.IsValidConfigurationAsset(configurationAsset);
// Checking if a configuration asset is not null.
if (isValidConfigurationAssetFile)
{
// Checking if the configuration asset's importer assets library has included directories assigned.
bool configurationIncludesDirectories = configurationAsset.GetIncludedAssetsDirectoryLibraryCount() > 0;
// Checking if directories are included.
if (configurationIncludesDirectories)
{
// Getting a list of all included asset directories in the configuration asset file.
AssetsDirectoryLibrary includedAssetDirectoryLibrary = configurationAsset.GetIncludedAssetsDirectoryLibrary();
// Checking through all the found included directories assigned in the configuration asset file.
foreach (string directory in includedAssetDirectoryLibrary.Directories)
{
// Reimporting assets from the included directory.
AssetsReimporter.ReimportAssetsAtPath(directory, configurationAsset);
}
}
else
{
// Checking if the configuration asset allow debug is enabled to log to messages to the console.
if (configurationAsset.AllowDebug)
{
// This message that will be logged to the unity's debug console.
string logMessage = "There are currently no included asset directories to update.";
// Logging a new warning message to the unity debug console.
Debugger.LogWarning(className: classLogName, message: logMessage);
}
return;
}
}
else
{
// Checking if the configuration asset allow debug is enabled.
if (configurationAsset.AllowDebug)
{
// This message that will be logged to the unity's debug console.
string logMessage = "Configuration file missing.";
// Logging a new warning message to the unity debug console.
Debugger.LogWarning(className: classLogName, message: logMessage);
}
return;
}
}
/// <summary>
/// Re-imports assets from a given asset path.
/// </summary>
/// <param name="assetsPath">Takes in a string object called asset path as the assets to re-import from directory path.</param>
/// <param name="configurationAsset">Takes in a configuration asset file used to configure re-imported assets.</param>
public static void ReimportAssetsAtPath(string assetsPath, ConfigurationAsset configurationAsset)
{
// Searching the asset folders to find importable assts that can be retroactively updated.
string[] importableAssetFilesEntries = Utilities.GetMultipleExtensionFileEntries(assetsPath);
// Checking if there were file entries found in the directories.
bool importableAssetsFound = importableAssetFilesEntries.Length > 0;
// Checking if assets were found.
if (importableAssetsFound)
{
// Going through found assets in the directory.
foreach (string importableAsset in importableAssetFilesEntries)
{
// Reimport an asset at the give directory.
AssetDatabase.ImportAsset(importableAsset);
// Checking if configuration aaset's debug is enabled.
if (configurationAsset.AllowDebug)
{
// Message to log in the unity debug console.
string logMessage = "Asset at path : " + importableAsset + " has been updated successfully.";
// Log a new message to the unity debug console.
Debugger.Log(className: classLogName, message: logMessage);
}
}
// Refreshing the asset data base.
AssetDatabase.Refresh();
}
else
{
// Checking if configuration aaset's debug is enabled.
if (configurationAsset.AllowDebug)
{
// Message to log in the unity debug console.
string logMessage = "No assets to update at path : " + assetsPath;
// Logging a new message to the unity debug console.
Debugger.Log(className: classLogName, message: logMessage);
}
return;
}
}
/// <summary>
/// Assigns asset directories to newly created configuration asset files.
/// This static function also adds the project affected or included asset directories to a newly created configuration asset file.
/// </summary>
/// <param name="configurationAsset">Takes in the newly created configuration asset.</param>
/// <param name="assetDirectory">Takes in the asset directory path.</param>
public static void AddConfigurationIncludedAssetDirectory(ConfigurationAsset configurationAsset, string assetDirectory)
{
// Checking if asset importer configuration doesn't include any directories.
bool configurationHasNoIncludedAssetDirectories = configurationAsset.GetIncludedAssetsDirectoryLibraryCount() <= 0;
// Checking if asset importer configuration loaded successfully and that it doesn't include directories.
if (AssetImportDirectory.IsValidConfigurationAsset(configurationAsset) && configurationHasNoIncludedAssetDirectories)
{
// Getting the directory of the newly created configuration asset.
string newConfigurationAssetDirectory = AssetImportDirectory.GetAssetDirectory(assetDirectory);
// Assigning the directory reference to the asset importer.
configurationAsset.AddConfigurationAssetIncludedDirectoryToLibrary(newConfigurationAssetDirectory);
// Checking for sub directories to include in the asset importer configuration directory.
string[] subDirectoriesToInclude = AssetDatabase.GetSubFolders(newConfigurationAssetDirectory);
// Checking if sun directories are found/initialized.
bool subDirectoriesFound = subDirectoriesToInclude.Length > 0;
// --Checking if sub directories were found in the asset directory.
if (subDirectoriesFound)
{
// Looping through found included sub directories to add to the asset importer configuration asset file.
foreach (string directory in subDirectoriesToInclude)
{
// Adding the scriptable object import configuration asset path to the newely created configuration asset file.
configurationAsset.AddConfigurationAssetIncludedDirectoryToLibrary(directory);
}
}
// Save asset data base.
AssetDatabase.SaveAssets();
// Refreshing the assets data base.
AssetDatabase.Refresh();
// Message to log in the unity debug console window.
string logMessage = "A new import configuration asset file was successfully created at path : " + newConfigurationAssetDirectory;
// Logging configuration asset creation successs message to the unity debugger console.
Debugger.Log(className: classLogName, message: logMessage);
}
}
/// <summary>
/// This function is for post processing project imported texture assets.
/// </summary>
/// <param name="importConfiguration">Takes in the import configuration asset.</param>
/// <param name="assetPostprocessor">Takes in the asset postprocessor class.</param>
public static void ProcessTextureAsset(ConfigurationAsset importConfiguration, AssetPostprocessor assetPostprocessor)
{
// Trying to modify the texture importer with import configuration.
try
{
// Converting texture overide platorm options to a string.
string runtimePlatformName = importConfiguration.TextureImportConfiguration.m_TextureOveridePlatormOption.ToString();
// Getting the texture impoprter settings from the imported asset.
var textureImporter = assetPostprocessor.assetImporter as TextureImporter;
// Getting the max size enum and converting it to a int value.
int maximumTextureSize = (int)importConfiguration.TextureImportConfiguration.MaximumTextureSize;
// Assigning texture importer platform settings maximum texture size.
textureImporter.maxTextureSize = maximumTextureSize;
// Assigning new settings.
textureImporter.anisoLevel = importConfiguration.TextureImportConfiguration.AnisotropicFilteringLevel;
// Getting current platform texture settings.
var platformTextureSettings = textureImporter.GetPlatformTextureSettings(runtimePlatformName);
// Checking if platform overide settings is enabled.
platformTextureSettings.overridden = importConfiguration.TextureImportConfiguration.m_TextureOveridePlatormOption != PlatformOption.None;
// Overiding setting for selected runtime platform.
platformTextureSettings.maxTextureSize = maximumTextureSize;
// Assigning final configured settings to the texture importer.
textureImporter.SetPlatformTextureSettings(platformTextureSettings);
}
catch (Exception e)
{
// Throwing a new system exception.
Debugger.ThrowException(e);
}
}
private static void CreateImportConfiguration()
{
// Creating a new importer configuration asset file instance.
ConfigurationAsset assetImportConfigurationAsset = CreateInstance <ConfigurationAsset>();
// Getting the path to save newely created scriptable object import configuration asset.
string importConfigurationAssetSavePath = EditorUtility.SaveFilePanelInProject("Asset Importer", "Asset Import Configuration", "asset", "");
// Checking if the configuration asset save path exist.
bool configurationAssetSavePathExist = !string.IsNullOrEmpty(importConfigurationAssetSavePath);
// Checking if the importer configuration asset's instance was created.
bool isConfigurationAssetCreated = assetImportConfigurationAsset != null;
// Check if the importer configuration instance and the asset save path exist.
if (isConfigurationAssetCreated && configurationAssetSavePathExist)
{
// Getting the selected import configuration asset directory where the configuration asset is created.
string configurationAssetCreationDirectory = AssetImportDirectory.GetAssetDirectory(importConfigurationAssetSavePath);
// Creating a new scriptable object import configuration asset to the import configuration path.
AssetDatabase.CreateAsset(assetImportConfigurationAsset, importConfigurationAssetSavePath);
// Save data base assets.
AssetDatabase.SaveAssets();
}
else
{
// Warning message to log in the unity debug console window.
string warningLogMessage = "Asset importer toolkit : Configuration file creation operation cancelled/failed: Import configuration asset file not created.";
// Logging a new warning message to the console when the configuration asset file creation is cancelled by the user.
Debugger.LogWarning(className: classLogName, message: warningLogMessage);
return;
}
}
/// <summary>
/// This function takes a configuration asset and checks if it's not null.
/// </summary>
/// <param name="configurationAsset">Takes in a configuration asset.</param>
/// <returns>Return true if the configuration asset is not null or invalid.</returns>
public static bool IsValidConfigurationAsset(ConfigurationAsset configurationAsset)
{
// Return true if configuration is not null.
return(configurationAsset != null);
}
