void OnPreprocessAudio()
{
AudioImporter importer = assetImporter as AudioImporter;
settingsAsset = AssetDatabase.LoadAssetAtPath <AssetsPreProcessor>(path);
if (settingsAsset == null || settingsAsset.importActions.Count == 0)
{
return;
}
if (File.Exists(importer.assetPath + ".meta"))
{
//Debug.Log (audioImporter.assetPath + ".meta" + " already exists");
}
else
{
List <int> actionsToApply = FilterActionsToApply(importer.assetPath);
if (importer != null)
{
foreach (int element in actionsToApply)
{
if (settingsAsset.importActions[element].newImportSettings.overrideAudios)
{
AudioImporterSampleSettings sampleSettings = new AudioImporterSampleSettings();
sampleSettings.loadType = settingsAsset.importActions[element].newImportSettings.audioSettings.loadType;
sampleSettings.compressionFormat = settingsAsset.importActions[element].newImportSettings.audioSettings.compressionFormat;
sampleSettings.quality = ((float)settingsAsset.importActions[element].newImportSettings.audioSettings.quality * 0.01f);
sampleSettings.sampleRateSetting = settingsAsset.importActions[element].newImportSettings.audioSettings.sampleRateSetting;
sampleSettings.sampleRateOverride = (uint)settingsAsset.importActions[element].newImportSettings.audioSettings.sampleRate;
importer.forceToMono = settingsAsset.importActions[element].newImportSettings.audioSettings.forceToMono;
importer.loadInBackground = settingsAsset.importActions[element].newImportSettings.audioSettings.loadInBackground;
importer.ambisonic = settingsAsset.importActions[element].newImportSettings.audioSettings.ambisonic;
importer.preloadAudioData = settingsAsset.importActions[element].newImportSettings.audioSettings.preloadAudioData;
// ? audioImporter.normalize = settingsAsset.actions[element].settings.audios.normalize;
importer.defaultSampleSettings = sampleSettings;
}
}
}
}
}
//设置短音频格式
static void SetShortAudio(string path)
{
AudioImporter ai = AssetImporter.GetAtPath(path) as AudioImporter;
if (ai != null)
{
AudioImporterSampleSettings ais = ai.defaultSampleSettings;
ai.loadInBackground = true;
ais.loadType = ShortAudio;
ai.defaultSampleSettings = ais;
ai.SetOverrideSampleSettings(Standalone, ais);
Debug.Log("处理的短音频===>" + path);
}
else
{
Debug.LogError("导入此路径的文件不是音频类型===>" + path);
}
}
private bool IsEqual(AudioImporter target)
{
AudioImporter reference = referenceImporter as AudioImporter;
UnityEngine.Assertions.Assert.IsNotNull(reference);
// defaultSampleSettings
if (target.defaultSampleSettings.compressionFormat != reference.defaultSampleSettings.compressionFormat)
{
return(false);
}
if (target.defaultSampleSettings.loadType != reference.defaultSampleSettings.loadType)
{
return(false);
}
if (target.defaultSampleSettings.quality != reference.defaultSampleSettings.quality)
{
return(false);
}
if (target.defaultSampleSettings.sampleRateOverride != reference.defaultSampleSettings.sampleRateOverride)
{
return(false);
}
if (target.defaultSampleSettings.sampleRateSetting != reference.defaultSampleSettings.sampleRateSetting)
{
return(false);
}
if (target.forceToMono != reference.forceToMono)
{
return(false);
}
if (target.loadInBackground != reference.loadInBackground)
{
return(false);
}
if (target.preloadAudioData != reference.preloadAudioData)
{
return(false);
}
return(true);
}
static void SelectedGaplessLoopingSettings(bool enabled)
{
Object[] audioclips = GetSelectedAudioclips();
Selection.objects = new Object[0];
foreach (AudioClip audioclip in audioclips)
{
string path = AssetDatabase.GetAssetPath(audioclip);
AudioImporter audioImporter = AssetImporter.GetAtPath(path) as AudioImporter;
if (audioImporter.loopable != enabled)
{
audioImporter.loopable = enabled;
AssetDatabase.ImportAsset(path);
}
}
}
public bool Check(string path)
{
_assetPath = path;
AudioImporter audioImporter = AssetImporter.GetAtPath(path) as AudioImporter;
if (audioImporter == null)
{
return(true);
}
bool right = true;
if (!audioImporter.forceToMono)
{
right = false;
}
return(right);
}
void SetAudioImporterFormat(AudioClip audio)
{
if (audio == null)
{
return;
}
string assetPath = AssetDatabase.GetAssetPath(audio);
AudioImporter importer = AudioImporter.GetAtPath(assetPath) as AudioImporter;
if (importer != null)
{
importer.threeD = false;
importer.loadType = AudioImporterLoadType.StreamFromDisc;
AssetDatabase.ImportAsset(assetPath);
AssetDatabase.Refresh();
}
}
public void OnPreprocessAudio()
{
AudioImporter importer = (AudioImporter)assetImporter;
if (!importer.forceToMono)
{
if (fixForceToMono)
{
importer.forceToMono = true;
importer.SaveAndReimport();
Debug.Log("Audio auto check forceToMono:" + importer.assetPath);
}
else
{
Debug.LogWarning("Audio forceToMono is unchecked:" + importer.assetPath);
}
}
}
private void ApplyClipChanges(AudioInfo info, bool writeChanges)
{
Selection.objects = new UnityEngine.Object[] { }; // unselect to get "Apply" to work automatically.
var importer = (AudioImporter)AudioImporter.GetAtPath(info._fullPath);
importer.compressionBitrate = info._compressionBitrate;
importer.forceToMono = info._forceMono;
importer.format = info._format;
importer.loadType = info._loadType;
importer.threeD = info._is3d;
AssetDatabase.ImportAsset(info._fullPath, ImportAssetOptions.ForceUpdate);
info._hasChanged = true;
if (writeChanges)
{
WriteFile(clipList);
}
}
public static Texture2D GetAudioClipTexture(AudioClip clip, float width, float height)
{
if (clip == null)
{
return(null);
}
AudioImporter importer = (AudioImporter)AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(clip));
MethodInfo getWaveForm = typeof(Editor).Assembly.GetType("UnityEditor.AudioUtil").GetMethod("GetWaveForm",
BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod);
Texture2D[] waveForms = new Texture2D[clip.channels];
for (int channel = 0; channel < clip.channels; ++channel)
{
waveForms[channel] = (Texture2D)getWaveForm.Invoke(null, new object[] { clip, importer, channel, width, height / clip.channels });
}
// waveForms[channel] = AudioUtil.GetWaveForm(clip, importer, channel, width, height / clip.channels);
return(CombineWaveForms(waveForms));
}
void OnPostprocessAudio(AudioClip clip)
{
AudioImporter model = (AudioImporter)assetImporter;
if (model != null)
{
if (!model.forceToMono)
{
Debug.LogError("声音导入需要设为Force Mono", clip);
}
if (clip.length > AudioCheck.MAX_LENGTH)
{
AudioImporterSampleSettings setting = model.defaultSampleSettings;
if (setting.loadType != AudioClipLoadType.Streaming)
{
Debug.LogError("长度超过10秒的声音，需要加载类型设置为Streaming", clip);
}
}
}
}
public void Apply(AudioImporter importer)
{
if (apply &&
path != null &&
importer.assetPath.Contains(path) &&
(importer.userData == null || !importer.userData.Contains(USER_DATA_KEY))
)
{
importer.forceToMono = forceToMono;
if (string.IsNullOrEmpty(importer.userData))
{
importer.userData = USER_DATA_KEY;
}
else
{
importer.userData += "," + USER_DATA_KEY;
}
}
}
public static void modifyAttributes()
{
Debug.Log("Rodger is awesome sauce");
var importer = new AudioImporter();
if (importer == null)
{
Debug.Log("hope you not entering here");
return;
}
AudioImporterSampleSettings sampleSettings = importer.defaultSampleSettings;
sampleSettings.loadType = AudioClipLoadType.CompressedInMemory;
sampleSettings.compressionFormat = AudioCompressionFormat.AAC;
importer.defaultSampleSettings = sampleSettings;
// throw new System.NotImplementedException();
}
private static Texture2D GetWaveForm(AudioClip clip, int channel, float width, float height)
{
Assembly unityEditorAssembly = typeof(AudioImporter).Assembly;
Type audioUtilClass = unityEditorAssembly.GetType("UnityEditor.AudioUtil");
MethodInfo method = audioUtilClass.GetMethod("GetWaveForm", BindingFlags.Static | BindingFlags.Public);
string path = AssetDatabase.GetAssetPath(clip);
AudioImporter importer = (AudioImporter)AssetImporter.GetAtPath(path);
if (method == null)
{
Debug.Log("Null Method:");
}
if (importer == null)
{
Debug.Log("Null importer");
}
Texture2D texture = (Texture2D)method.Invoke(null, new object[] { clip, importer, channel, width, height });
return(texture);
}
public void OnPreprocessAudio()
{
AudioImporter audioImporter = this.assetImporter as AudioImporter;
audioImporter.forceToMono = true;
audioImporter.loadInBackground = true;
AudioImporterSampleSettings audioImporterSampleSettings = audioImporter.defaultSampleSettings;
//audioImporterSampleSettingsIOS.quality = .8f;
//audio. = AudioCompressionFormat.MP3;
if (assetPath.Contains("/BGM/"))
{
audioImporterSampleSettings.loadType = AudioClipLoadType.CompressedInMemory;
}
else if (assetPath.Contains("/Effect/"))
{
audioImporterSampleSettings.loadType = AudioClipLoadType.DecompressOnLoad;
}
audioImporter.defaultSampleSettings = audioImporterSampleSettings;
Debug.Log("初始化音频资源成功：" + assetPath);
}
public void OnPreprocessAudio()
{
AudioImporter audioImporter = (AudioImporter)assetImporter;
AudioImporterSampleSettings settings = audioImporter.defaultSampleSettings;
if (audioImporter.assetPath.IndexOf("bg") > -1)
{
// audioImporter.forceToMono = true;
audioImporter.loadInBackground = true;
settings.loadType = AudioClipLoadType.CompressedInMemory;
settings.compressionFormat = AudioCompressionFormat.ADPCM;
}
else
{
audioImporter.forceToMono = true;
audioImporter.loadInBackground = false;
settings.loadType = AudioClipLoadType.DecompressOnLoad;
settings.compressionFormat = AudioCompressionFormat.ADPCM;
}
audioImporter.defaultSampleSettings = settings;
}
protected void PreprocessAudio()
{
if (!IsIncludedFolder(assetPath))
{
return;
}
if (DefaultsSet)
{
return;
}
AudioImporter importer = (AudioImporter)assetImporter;
importer.threeD = audio3DDefault;
// Other settings will happen in OnPostProcessAudio, since we want access to the audio clip's length.
// Setting DefaultsSet to true won't happen here yet either. That way, PostProcessAudio can also still run.
Debug.Log("AssetPostprocessor: preprocessed " + assetPath + ".");
}
public void OnPreprocessAudio(string importAssetPath, AssetImporter assetImporter)
{
AudioImporter templateImporter = GetTemplateAssetImporter(importAssetPath) as AudioImporter;
if (templateImporter == null)
{
return;
}
// 如果模板被更改，那么更新全部资源
if (Path.GetFileName(importAssetPath) == Path.GetFileName(templateImporter.assetPath))
{
ProcessAllAudio(templateImporter);
return;
}
AudioImporter targetImporter = assetImporter as AudioImporter;
ImportCopyer.CopyAudioImporter(targetImporter, templateImporter);
Debug.Log($"[DefaultProcessor] 资源格式设置完毕 : {importAssetPath}");
}
public override void ApplySettings(UnityEditor.AssetImporter assetImporter)
{
AudioImporter importer = assetImporter as AudioImporter;
if (importer == null)
{
return;
}
importer.loadInBackground = LoadBackground;
AudioImporterSampleSettings sampleSetting = importer.defaultSampleSettings;
sampleSetting.loadType = LoadType;
sampleSetting.compressionFormat = CompressionFormat;
sampleSetting.sampleRateSetting = SampleRate;
// importer.GetOverrideSampleSettings("Android");
// importer.SaveAndReimport();
}
private void InitializeComponents()
{
m_songPlayer = gameObject.AddComponent <SongPlayer>();
m_songPlayer.InitializeSettings(m_mainSound,
m_partsToListenTo,
m_partPlaybackFadeTimeSeconds,
m_timeSlider.value,
m_timeSlider.maxValue,
m_seekIntervalSeconds,
m_holdSongKeyCode,
m_seekForwardKeyCode,
m_seekBackwardKeyCode);
m_importer = gameObject.AddComponent <NAudioImporter>();
m_timeSlider.onValueChanged.AddListener(delegate { TimeSliderChanged(); });
m_uiSound.loop = false;
m_statusText.text = "[ SYSTEM ] Press (F1) for controls";
}
static void SetAudioImportSettings(bool enableHardwareDecoding = true, AudioImporterFormat newFormat = AudioImporterFormat.Native,
int newCompressionBitrate = 90, AudioImporterLoadType decompressOnLoadType = AudioImporterLoadType.StreamFromDisc,
bool is3D = false, bool forceToMono = false
)
{
Object[] audioclips = GetSelectedAudioclips();
Selection.objects = new Object[0];
foreach (AudioClip audioclip in audioclips)
{
string path = AssetDatabase.GetAssetPath(audioclip);
AudioImporter audioImporter = AssetImporter.GetAtPath(path) as AudioImporter;
audioImporter.hardware = enableHardwareDecoding;
audioImporter.format = newFormat;
audioImporter.compressionBitrate = newCompressionBitrate;
audioImporter.loadType = decompressOnLoadType;
audioImporter.threeD = is3D;
audioImporter.forceToMono = forceToMono;
AssetDatabase.ImportAsset(path);
}
}
static void SetAudioPreload(AudioClip clip, bool preload, bool refreshImmediately)
{
if (clip != null)
{
string assetPath = AssetDatabase.GetAssetPath(clip);
AudioImporter importer = AssetImporter.GetAtPath(assetPath) as AudioImporter;
if (importer != null)
{
if (preload != importer.preloadAudioData)
{
importer.preloadAudioData = preload;
AssetDatabase.ImportAsset(assetPath);
if (refreshImmediately)
{
AssetDatabase.Refresh();
}
}
}
}
}
static void ProcessStep()
{
if ((progress >= assets.Length) || EditorUtility.DisplayCancelableProgressBar("Collecting stats", "" + progress + "/" + assets.Length, (float)progress / assets.Length))
{
Stop();
return;
}
var item = assets[progress];
++progress;
var path = AssetDatabase.GUIDToAssetPath(item);
AudioImporter audioImporter = AssetImporter.GetAtPath(path) as AudioImporter;
if (audioImporter == null)
{
return;
}
excelWorksheet.SetValue(excelRow, 1, path.Substring(6));
excelWorksheet.SetValue(excelRow, 2, audioImporter.defaultSampleSettings.loadType.ToString());
excelWorksheet.SetValue(excelRow, 3, audioImporter.defaultSampleSettings.compressionFormat.ToString());
excelWorksheet.SetValue(excelRow, 4, audioImporter.defaultSampleSettings.sampleRateSetting.ToString());
excelWorksheet.SetValue(excelRow, 7, audioImporter.assetBundleName);
excelWorksheet.SetValue(excelRow, 8, audioImporter.loadInBackground);
var originalSize = new FileInfo(Path.Combine(rootDir, path)).Length;
var exppath = Path.Combine(rootDir, "Library/metadata/" + item.Substring(0, 2) + "/" + item);
var exportedSize = new FileInfo(exppath).Length;
excelWorksheet.SetValue(excelRow, 5, originalSize);
excelWorksheet.SetValue(excelRow, 6, exportedSize);
var audio = AssetDatabase.LoadAssetAtPath <AudioClip>(path);
excelWorksheet.SetValue(excelRow, 9, Profiler.GetRuntimeMemorySizeLong(audio));
++excelRow;
}
public static void RefreshAudioAssetBundleName()
{
// 需要处理掉开头的 Assets 路径
if (Directory.Exists(EditorAppDefine.AudioAssetRoot))
{
string[] fileFullNameArray = Directory.GetFiles(EditorAppDefine.AudioAssetRoot, "*.*", SearchOption.AllDirectories);
EditorUtility.DisplayProgressBar("设置音效AB名称", "正在设置AssetName名称中...", 0f);
for (int index = 0; index < fileFullNameArray.Length; index++)
{
string fileFullName = fileFullNameArray[index];
EditorUtility.DisplayProgressBar("设置音效AB名称", "正在设置AssetName名称中...", 1f * index / fileFullNameArray.Length);
if (fileFullName.EndsWith(".meta"))
{
continue;
}
string relativePath = FileUtil.GetProjectRelativePath(fileFullName);
AudioImporter importer = AssetImporter.GetAtPath(relativePath) as AudioImporter;
if (importer != null)
{
string dirctoryName = Path.GetDirectoryName(relativePath).Replace('\\', '/');
int findIndex = dirctoryName.LastIndexOf('/');
if (findIndex != -1)
{
string abName = dirctoryName.Substring(findIndex + 1);
importer.assetBundleName = "audio_" + abName + EditorAppDefine.AssetBundleExtension;
}
else
{
importer.assetBundleName = Path.GetFileNameWithoutExtension(relativePath) + EditorAppDefine.AssetBundleExtension;
}
}
}
EditorUtility.ClearProgressBar();
AssetDatabase.RemoveUnusedAssetBundleNames();
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
}
}
public override void SetResObj(Object obj)
{
resObj = obj;
clip = obj as AudioClip;
audioImporter = AssetImporter.GetAtPath(path) as AudioImporter;
setting = ResourceAuditingSetting.GetIntance();
if (clip.length > setting.autioLengthThreshold)
{
autioType = "Long";
}
else
{
autioType = "Short";
}
//standalone_setting = GetPlatformSetting(audioImporter.GetOverrideSampleSettings(EditPlatform.Standalone), new TextuteFormatKey[] { }, new TextuteFormatKey[] { });
ios_setting = GetPlatformSetting(audioImporter.GetOverrideSampleSettings(EditPlatform.iPhone), EditPlatform.iPhone,
setting.audioClipLoadType_Short_Ios, setting.compressionFormat_Short_Ios,
setting.audioClipLoadType_Long_Ios, setting.compressionFormat_Long_Ios);
android_setting = GetPlatformSetting(audioImporter.GetOverrideSampleSettings(EditPlatform.Android), EditPlatform.Android,
setting.audioClipLoadType_Short_Android, setting.compressionFormat_Short_Android,
setting.audioClipLoadType_Long_Android, setting.compressionFormat_Long_Android);
}
private void OverwriteImportSettings(AudioImporter importer)
{
var reference = referenceImporter as AudioImporter;
UnityEngine.Assertions.Assert.IsNotNull(reference);
importer.defaultSampleSettings = reference.defaultSampleSettings;
importer.forceToMono = reference.forceToMono;
importer.preloadAudioData = reference.preloadAudioData;
foreach (var g in NodeGUIUtility.SupportedBuildTargetGroups)
{
var platformName = BuildTargetUtility.TargetToAssetBundlePlatformName(g,
BuildTargetUtility.PlatformNameType.AudioImporter);
if (reference.ContainsSampleSettingsOverride(platformName))
{
var setting = reference.GetOverrideSampleSettings(platformName);
if (!importer.SetOverrideSampleSettings(platformName, setting))
{
LogUtility.Logger.LogError("AudioImporter",
string.Format("Failed to set override setting for {0}: {1}", platformName, importer.assetPath));
}
}
else
{
importer.ClearSampleSettingOverride(platformName);
}
}
// using "!UNITY_5_6_OR_NEWER" instead of "Unity_5_6" because loadInBackground became obsolete after Unity 5.6b3.
#if !UNITY_5_6_OR_NEWER
importer.loadInBackground = reference.loadInBackground;
#endif
#if UNITY_2017_1_OR_NEWER
importer.ambisonic = reference.ambisonic;
#endif
}
private void ApplyClipChanges(AudioInformation info, bool writeChanges)
{
Selection.objects = new Object[] { }; // unselect to get "Apply" to work automatically.
// ReSharper disable once AccessToStaticMemberViaDerivedType
var importer = (AudioImporter)AudioImporter.GetAtPath(info.FullPath);
importer.compressionBitrate = info.CompressionBitrate;
importer.forceToMono = info.ForceMono;
importer.format = info.Format;
importer.loadType = info.LoadType;
importer.threeD = info.Is3D;
AssetDatabase.ImportAsset(info.FullPath, ImportAssetOptions.ForceUpdate);
info.HasChanged = true;
if (writeChanges)
{
WriteFile(_clipList);
}
}
public static bool IsSameAudioSetting(AudioImporter target, AudioImporter compareBase)
{
// defaultSampleSettings
if (target.defaultSampleSettings.compressionFormat != compareBase.defaultSampleSettings.compressionFormat)
{
return(false);
}
if (target.defaultSampleSettings.loadType != compareBase.defaultSampleSettings.loadType)
{
return(false);
}
if (target.defaultSampleSettings.quality != compareBase.defaultSampleSettings.quality)
{
return(false);
}
if (target.defaultSampleSettings.sampleRateOverride != compareBase.defaultSampleSettings.sampleRateOverride)
{
return(false);
}
if (target.defaultSampleSettings.sampleRateSetting != compareBase.defaultSampleSettings.sampleRateSetting)
{
return(false);
}
if (target.forceToMono != compareBase.forceToMono)
{
return(false);
}
if (target.loadInBackground != compareBase.loadInBackground)
{
return(false);
}
if (target.preloadAudioData != compareBase.preloadAudioData)
{
return(false);
}
return(true);
}
static void SelectedSetCompressionBitrate(float newCompressionBitrate)
{
Object[] audioclips = GetSelectedAudioclips();
if (deselectAfterCompletion)
{
Selection.objects = new Object[0];
}
foreach (AudioClip audioclip in audioclips)
{
string path = AssetDatabase.GetAssetPath(audioclip);
AudioImporter audioImporter = AssetImporter.GetAtPath(path) as AudioImporter;
if (audioImporter.compressionBitrate != (int)newCompressionBitrate)
{
audioImporter.compressionBitrate = (int)newCompressionBitrate;
AssetDatabase.ImportAsset(path);
}
}
}
static void SelectedToggleForceToMonoSettings(bool enabled)
{
Object[] audioclips = GetSelectedAudioclips();
if (deselectAfterCompletion)
{
Selection.objects = new Object[0];
}
foreach (AudioClip audioclip in audioclips)
{
string path = AssetDatabase.GetAssetPath(audioclip);
AudioImporter audioImporter = AssetImporter.GetAtPath(path) as AudioImporter;
if (audioImporter.forceToMono != enabled)
{
audioImporter.forceToMono = enabled;
AssetDatabase.ImportAsset(path);
}
}
}
private static void ClearHighSampleRate()
{
AudioClip[] clip = Selection.GetFiltered <AudioClip>(SelectionMode.DeepAssets);
AssetDatabase.StartAssetEditing();
{
int guidCount = clip.Length;
for (int i = 0; i < guidCount; ++i)
{
string assetPath = AssetDatabase.GetAssetPath(clip[i]);
EditorUtility.DisplayProgressBar(string.Format("Setting Import Settings [{0} / {1}]", i, guidCount), assetPath, i / (float)guidCount);
AudioImporter importer = (AudioImporter)AudioImporter.GetAtPath(assetPath);
if (importer != null)
{
bool changed = false;
AudioImporterSampleSettings settings = importer.defaultSampleSettings;
if (changed |= clip[i].frequency > 48000)
{
settings.sampleRateSetting = AudioSampleRateSetting.OverrideSampleRate;
settings.sampleRateOverride = 48000;
}
if (changed == true)
{
importer.defaultSampleSettings = settings;
importer.SaveAndReimport();
}
}
}
EditorUtility.ClearProgressBar();
}
AssetDatabase.StopAssetEditing();
AssetDatabase.SaveAssets();
}
