public static AudioClipLoadType GetAudioClipLoadType(AudioClip audioClip)
{
AudioClipLoadType result = (AudioClipLoadType)(-1);
if ((UnityEngine.Object)audioClip != (UnityEngine.Object)null)
{
result = audioClip.loadType;
Manager.audioClipLoadType.TryGetValue(audioClip, out result);
}
return(result);
}
public static AudioClipLoadType GetAudioClipLoadType(AudioClip audioClip)
{
AudioClipLoadType result = (AudioClipLoadType)(-1);
if (audioClip != null)
{
result = audioClip.loadType;
audioClipLoadType.TryGetValue(audioClip, out result);
}
return(result);
}
public void GetAudio(string url, AudioClipLoadType loadType, Action <AudioClip> callback)
{
AudioClip asset = LoadEditorAsset <AudioClip>(url);
if (asset != null)
{
callback.Call(asset);
}
else
{
fallback.GetAudio(url, loadType, callback);
}
}
static void Uncompressed()
{
string[] folder =
{
"Assets/assetbundle/sound",
};
string [] acs = AssetDatabase.FindAssets("t:AudioClip", folder);
int n = acs.Length;
AssetDatabase.StartAssetEditing();
for (int i = 0; i < n; i++)
{
string path = AssetDatabase.GUIDToAssetPath(acs[i]);
if (EditorUtility.DisplayCancelableProgressBar(string.Format("{0}", path), i + "/" + acs.Length, (float)i / (float)acs.Length))
{
break;
}
// Debug.LogFormat("reimport {0}/{1}: {2}", i+1, n, path);
AudioImporter audioImporter = AssetImporter.GetAtPath(path) as AudioImporter;
if (audioImporter == null)
{
continue;
}
AudioClipLoadType t = AudioClipLoadType.DecompressOnLoad;
AudioClip clip = AssetDatabase.LoadAssetAtPath <AudioClip>(path);
if (clip.length >= 5)
{
t = AudioClipLoadType.Streaming;
}
AudioImporterSampleSettings audioImporterSampleSettings = audioImporter.defaultSampleSettings;
if (audioImporterSampleSettings.loadType != t)
{
Debug.LogFormat("{0} {1} {2}", path, clip.length, t);
audioImporterSampleSettings.loadType = AudioClipLoadType.Streaming;
audioImporter.defaultSampleSettings = audioImporterSampleSettings;
audioImporter.SaveAndReimport();
}
}
AssetDatabase.StopAssetEditing();
// AssetDatabase.SaveAssets();
// AssetDatabase.Refresh();
EditorUtility.ClearProgressBar();
}
/// <summary>
/// Facilitates a user settable/gettable AudioClip.loadType
/// </summary>
/// <returns>-1 if audioClip is null or audioClip.loadType if this manager did not touch the audioClip</returns>
public static AudioClipLoadType GetAudioClipLoadType(AudioClip audioClip)
{
AudioClipLoadType ret = (AudioClipLoadType)(-1);
#if UNITY_4 || UNITY_4_0 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7
// audioClipLoadType.TryGetValue(audioClip, out ret); //TODO: fix
#else
if (audioClip != null)
{
ret = audioClip.loadType;
audioClipToLoadType.TryGetValue(audioClip, out ret);
}
#endif
return(ret);
}
public override void ApplyDefaults()
{
base.ApplyDefaults();
this.SuffixFilter = ".ogg";
this.forceToMono = false;
this.normalize = true;
this.loadInBackground = true;
this.ambisonic = false;
this.loadType = AudioClipLoadType.Streaming;
this.preloadAudioData = true;
this.compressionFormat = AudioCompressionFormat.Vorbis;
this.quality = 100;
this.sampleRateSetting = AudioSampleRateSetting.PreserveSampleRate;
}
public AudioViewerData(string mode, AudioInfo audioInfo)
{
_mode = (AudioViewerMode)Enum.Parse(typeof(AudioViewerMode), mode);
ForceToMono = audioInfo.ForceToMono;
LoadInBackground = audioInfo.LoadInBackground;
Ambisonic = audioInfo.Ambisonic;
StandAloneAudioClipLoadType = audioInfo.StandAloneAudioClipLoadType;
AndroidAudioClipLoadType = audioInfo.AndroidAudioClipLoadType;
iOSAudioClipLoadType = audioInfo.iOSAudioClipLoadType;
StandAloneAudioCompressionFormat = audioInfo.StandAloneAudioCompressionFormat;
AndroidAudioCompressionFormat = audioInfo.AndroidAudioCompressionFormat;
iOSAudioCompressionFormat = audioInfo.iOSAudioCompressionFormat;
OriginSize = audioInfo.OriginSize;
CompressedSize = audioInfo.CompressedSize;
All = "All";
}
public override void DrawRuleGUI()
{
base.DrawRuleGUI();
GUILayout.Space(10);
EditorGUILayout.LabelField("Audio Import Settings", EditorStyles.boldLabel);
EditorGUI.DrawRect(EditorGUILayout.GetControlRect(false, 2), QuickEditorColors.DarkGrayX11);
GUILayout.Space(3);
forceToMono = EditorGUILayout.Toggle(AssetImportStyles.Audio.ForceToMono, forceToMono);
EditorGUI.indentLevel++;
EditorGUI.BeginDisabledGroup(forceToMono);
normalize = EditorGUILayout.Toggle(AssetImportStyles.Audio.Normalize, normalize);
EditorGUI.EndDisabledGroup();
EditorGUI.indentLevel--;
loadInBackground = EditorGUILayout.Toggle(AssetImportStyles.Audio.LoadBackground, loadInBackground);
ambisonic = EditorGUILayout.Toggle(AssetImportStyles.Audio.Ambisonic, ambisonic);
GUILayout.Space(6);
EditorGUILayout.LabelField("Default Import Settings", EditorStyles.boldLabel);
EditorGUI.DrawRect(EditorGUILayout.GetControlRect(false, 2), QuickEditorColors.DarkGrayX11);
GUILayout.Space(3);
loadType = (AudioClipLoadType)EditorGUILayout.EnumPopup(AssetImportStyles.Audio.LoadType, loadType);
EditorGUI.BeginDisabledGroup(loadType == AudioClipLoadType.Streaming ? true : false);
preloadAudioData = EditorGUILayout.Toggle(AssetImportStyles.Audio.PreloadAudioData, preloadAudioData);
EditorGUI.EndDisabledGroup();
if (loadType == AudioClipLoadType.Streaming)
{
preloadAudioData = false;
}
int compressionFormatIndex = Math.Max(Array.FindIndex(AssetImportStyles.Audio.CompressionEnumOpts, opt => opt.Equals(compressionFormat)), 0);
compressionFormatIndex = EditorGUILayout.Popup(AssetImportStyles.Audio.CompressionFormat, compressionFormatIndex, AssetImportStyles.Audio.CompressionFormatOpts);
compressionFormat = AssetImportStyles.Audio.CompressionEnumOpts[compressionFormatIndex];
EditorGUI.BeginDisabledGroup(compressionFormat != AudioCompressionFormat.Vorbis ? true : false);
quality = EditorGUILayout.IntSlider(AssetImportStyles.Audio.Quality, quality, 1, 100);
EditorGUI.EndDisabledGroup();
sampleRateSetting = (AudioSampleRateSetting)EditorGUILayout.EnumPopup(AssetImportStyles.Audio.SampleRateSetting, sampleRateSetting);
if (sampleRateSetting == AudioSampleRateSetting.OverrideSampleRate)
{
sampleRate = (SampleRates)EditorGUILayout.EnumPopup(AssetImportStyles.Audio.SampleRate, sampleRate);
}
}
// Apply settings Method which searches and adds all audio clips in an array, and for each clip, adds the settings, overrides it for the selected platform
// and imports the newly applied asset again, therefore applying all the settings properly.
static void ApplySettings(uint sampleRate, AudioCompressionFormat format, AudioClipLoadType loadType, string platform)
{
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;
AudioImporterSampleSettings settings = audioImporter.defaultSampleSettings;
settings.compressionFormat = format;
settings.sampleRateSetting = AudioSampleRateSetting.OverrideSampleRate;
settings.sampleRateOverride = sampleRate;
settings.loadType = loadType;
audioImporter.SetOverrideSampleSettings(platform, settings);
AssetDatabase.ImportAsset(path);
}
}
public void GetAudio(string url, AudioClipLoadType loadType, Action <AudioClip> callback, string alias = null)
{
VerifyUrl(url);
if (!url.IsEmpty())
{
AudioClip c = assetCache.Get(url) as AudioClip;
if (c != null)
{
callback(c);
}
else
{
if (url.Is(FileType.Asset))
{
GetAsset <AudioClip>(url, callback, false);
}
else
{
callbacks.Add(url, callback);
if (callbacks.GetCount(url) == 1)
{
log.Debug("Loading {0}", url);
loader.GetAudio(pathConverter(url), loadType, clip =>
{
if (clip != null)
{
AddToCache(alias, url, clip);
}
List <Delegate> slot = callbacks.GetSlot(url);
foreach (Delegate d in slot)
{
((Action <AudioClip>)d)(clip);
}
callbacks.Remove(url);
});
}
}
}
}
else
{
callback(null);
}
}
private static int get_loadType(IntPtr L)
{
object obj = null;
int result;
try
{
obj = ToLua.ToObject(L, 1);
AudioClip audioClip = (AudioClip)obj;
AudioClipLoadType loadType = audioClip.get_loadType();
ToLua.Push(L, loadType);
result = 1;
}
catch (Exception ex)
{
result = LuaDLL.toluaL_exception(L, ex, (obj != null) ? ex.get_Message() : "attempt to index loadType on a nil value");
}
return(result);
}
public void GetAudio(string url, AudioClipLoadType loadType, Action <AudioClip> callback)
{
bool streaming = (loadType & AudioClipLoadType.Streaming) != 0;
bool threeD = (loadType & AudioClipLoadType.ThreeD) != 0;
bool compressed = (loadType & AudioClipLoadType.Compressed) != 0;
#if WWW_MODULE
GetWWW(url, !streaming, www => {
if (www != null)
{
AudioClip a = compressed? www.GetAudioClipCompressed(threeD): www.GetAudioClip(threeD, streaming);
callback(a);
}
else
{
fallback.GetAudio(url, loadType, callback);
}
});
#else
throw new Exception("Not implemented");
#endif
}
static void SetAudioLoadType(AudioClip clip, AudioClipLoadType loadType, bool refreshImmediately)
{
if (clip != null)
{
string assetPath = AssetDatabase.GetAssetPath(clip);
AudioImporter importer = AssetImporter.GetAtPath(assetPath) as AudioImporter;
if (importer != null)
{
if (loadType != importer.defaultSampleSettings.loadType)
{
AudioImporterSampleSettings settings = importer.defaultSampleSettings;
settings.loadType = loadType;
importer.defaultSampleSettings = settings;
AssetDatabase.ImportAsset(assetPath);
if (refreshImmediately)
{
AssetDatabase.Refresh();
}
}
}
}
}
public override void DrawInnerGUI()
{
DrawFilterGUI();
GUILayout.Space(6);
EditorGUILayout.LabelField("Audio", EditorStyles.boldLabel);
EditorGUI.DrawRect(EditorGUILayout.GetControlRect(false, 2), QuickEditorColors.DarkGrayX11);
GUILayout.Space(3);
m_forceToMono = EditorGUILayout.Toggle("Force To Mono", m_forceToMono);
m_loadInBackground = EditorGUILayout.Toggle("Load In Background", m_loadInBackground);
GUILayout.Space(6);
EditorGUILayout.LabelField("Default Import Settings", EditorStyles.boldLabel);
EditorGUI.DrawRect(EditorGUILayout.GetControlRect(false, 2), QuickEditorColors.DarkGrayX11);
GUILayout.Space(3);
m_AudioClipLoadType = (AudioClipLoadType)EditorGUILayout.EnumPopup("Load Type", m_AudioClipLoadType);
EditorGUI.BeginDisabledGroup(m_AudioClipLoadType == AudioClipLoadType.Streaming ? true : false);
m_preloadAudioData = EditorGUILayout.Toggle("Preload Audio Data", m_preloadAudioData);
EditorGUI.EndDisabledGroup();
if (m_AudioClipLoadType == AudioClipLoadType.Streaming)
{
m_preloadAudioData = false;
}
m_audioCompressionFormat = (AudioCompressionFormat)EditorGUILayout.EnumPopup("Compression Format", m_audioCompressionFormat);
m_audioQuality = EditorGUILayout.IntSlider("Quality", m_audioQuality, 1, 100);
m_sampleRateSetting = (AudioSampleRateSetting)EditorGUILayout.EnumPopup("Sample Rate Setting", m_sampleRateSetting);
if (m_sampleRateSetting == AudioSampleRateSetting.OverrideSampleRate)
{
m_sampleRateOverride = (SampleOverrideValues)EditorGUILayout.EnumPopup("Sample Rate Setting", m_sampleRateOverride);
}
}
public static void DealAudioImporter(AudioClip clip, AudioImporter importer, bool forceMono, bool bSensitive = false, bool compressSampleRate = true)
{
bool bChange = false;
if (clip == null)
{
return;
}
AudioImporterSampleSettings androidSetting = importer.GetOverrideSampleSettings("Android");
AudioImporterSampleSettings iosSetting = importer.GetOverrideSampleSettings("iPhone");
if (clip.length >= 10)
{
if (androidSetting.loadType != AudioClipLoadType.Streaming)
{
androidSetting.loadType = AudioClipLoadType.Streaming;
iosSetting.loadType = AudioClipLoadType.Streaming;
bChange = true;
}
AudioCompressionFormat newFmt = AudioCompressionFormat.Vorbis;
if (newFmt != androidSetting.compressionFormat)
{
androidSetting.compressionFormat = newFmt;
iosSetting.compressionFormat = newFmt;
androidSetting.quality = 0.01f;
iosSetting.quality = 0.01f;
bChange = true;
}
}
else if (clip.length < 10 && clip.length >= 1)
{
AudioClipLoadType newLoadType = AudioClipLoadType.CompressedInMemory;
if (newLoadType != androidSetting.loadType)
{
androidSetting.loadType = newLoadType;
iosSetting.loadType = newLoadType;
bChange = true;
}
AudioCompressionFormat newFmt = bSensitive ? AudioCompressionFormat.ADPCM : AudioCompressionFormat.Vorbis;
if (newFmt != androidSetting.compressionFormat)
{
androidSetting.compressionFormat = newFmt;
iosSetting.compressionFormat = newFmt;
bChange = true;
if (newFmt == AudioCompressionFormat.Vorbis)
{
androidSetting.quality = 0.01f;
iosSetting.quality = 0.01f;
}
}
}
else if (clip.length < 1)
{
AudioClipLoadType newLoadType = bSensitive ? AudioClipLoadType.DecompressOnLoad : AudioClipLoadType.CompressedInMemory;
if (androidSetting.loadType != newLoadType)
{
androidSetting.loadType = newLoadType;
iosSetting.loadType = newLoadType;
bChange = true;
}
AudioCompressionFormat newFmt = AudioCompressionFormat.ADPCM;
if (newFmt != androidSetting.compressionFormat)
{
androidSetting.compressionFormat = newFmt;
iosSetting.compressionFormat = newFmt;
bChange = true;
}
}
var sampleRate = (uint)(compressSampleRate ? 22050 : 44100);
if (androidSetting.sampleRateSetting != AudioSampleRateSetting.OverrideSampleRate || androidSetting.sampleRateOverride != sampleRate)
{
androidSetting.sampleRateSetting = AudioSampleRateSetting.OverrideSampleRate;
iosSetting.sampleRateSetting = AudioSampleRateSetting.OverrideSampleRate;
androidSetting.sampleRateOverride = sampleRate;
iosSetting.sampleRateOverride = sampleRate;
bChange = true;
}
if (importer.forceToMono != forceMono)
{
importer.forceToMono = forceMono;
bChange = true;
}
if (importer.loadInBackground && androidSetting.loadType != AudioClipLoadType.Streaming)
{
importer.loadInBackground = false;
bChange = true;
}
if (importer.preloadAudioData)
{
importer.preloadAudioData = false;
bChange = true;
}
if (bChange)
{
importer.SetOverrideSampleSettings("Android", androidSetting);
importer.SetOverrideSampleSettings("iPhone", iosSetting);
importer.SaveAndReimport();
}
}
public void GetAudio(string url, AudioClipLoadType loadType, Action <AudioClip> callback)
{
log.Warn("Failed to access {0}", url);
callback.Call(null);
}
//オーディオファイルの設定を変更する
private static void ChangeSetting(string audioPath, bool forceToMono, bool normalize, bool ambisonic, bool loadInBackground, AudioClipLoadType loadType, float quality, AudioCompressionFormat compressionFormat, AudioSampleRateSetting sampleRateSetting)
{
if (AssetDatabase.LoadAssetAtPath <AudioClip>(audioPath) == null)
{
return;
}
var importer = AssetImporter.GetAtPath(audioPath) as AudioImporter;
importer.forceToMono = forceToMono;
var serializedObject = new SerializedObject(importer);
var normalizeProperty = serializedObject.FindProperty("m_Normalize");
normalizeProperty.boolValue = normalize;
serializedObject.ApplyModifiedProperties();
importer.ambisonic = ambisonic;
importer.loadInBackground = loadInBackground;
var settings = importer.defaultSampleSettings;
settings.loadType = loadType;
settings.quality = quality;
settings.compressionFormat = compressionFormat;
settings.sampleRateSetting = sampleRateSetting;
importer.defaultSampleSettings = settings;
Debug.Log(audioPath + "の設定を変更しました");
}
void DrawEntryBoard(List <string> pathList)
{
if (currentAudioEntry == null)
{
currentAudioEntry = new AudioEntry();
displayId = "";
}
EditorGUILayout.BeginVertical("box", GUILayout.Width(200));
string key = displayId, path = pathList[0];
int loadLevel = currentAudioEntry.loadLevel;
AudioType type = currentAudioEntry.type;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("ID:"), GUILayout.Width(50));
key = EditorGUILayout.TextField(key);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Path:"), GUILayout.Width(50));
Color oldColor = GUI.color;
GUI.color = Color.yellow;
EditorGUILayout.LabelField(path);
GUI.color = oldColor;
EditorGUILayout.EndHorizontal();
float inherentVolume = currentAudioEntry.inherentVolume;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Volume:"), GUILayout.Width(50));
inherentVolume = EditorGUILayout.Slider(inherentVolume, 0.0f, 1.0f);
EditorGUILayout.EndHorizontal();
currentAudioEntry.inherentVolume = inherentVolume;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Load Level:"), GUILayout.Width(60));
loadLevel = EditorGUILayout.IntField(loadLevel, GUILayout.Width(15));
AudioClipLoadType aclt = currentAudioEntry.loadType;
EditorGUILayout.Space();
EditorGUILayout.LabelField(new GUIContent("Type:"), GUILayout.Width(30));
aclt = (AudioClipLoadType)EditorGUILayout.EnumPopup(aclt, GUILayout.Width(140));
currentAudioEntry.loadType = aclt;
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Type:"));
type = (AudioType)EditorGUILayout.EnumPopup(type, GUILayout.Width(50));
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
displayId = key;
currentAudioEntry.path = path;
currentAudioEntry.loadLevel = loadLevel;
currentAudioEntry.type = type;
}
private void OnSampleSettingGUI(BuildTargetGroup platform, MultiValueStatus status, bool selectionContainsTrackerFile, ref SampleSettingProperties properties, bool disablePreloadAudioDataOption)
{
//Load Type
EditorGUI.showMixedValue = status.multiLoadType && !properties.loadTypeChanged;
EditorGUI.BeginChangeCheck();
AudioClipLoadType newLoadType = (AudioClipLoadType)EditorGUILayout.EnumPopup("Load Type", properties.settings.loadType);
if (EditorGUI.EndChangeCheck())
{
properties.settings.loadType = newLoadType;
properties.loadTypeChanged = true;
}
using (new EditorGUI.DisabledScope(disablePreloadAudioDataOption))
{
if (disablePreloadAudioDataOption)
{
EditorGUILayout.Toggle("Preload Audio Data", false);
}
else
{
EditorGUILayout.PropertyField(m_PreloadAudioData);
}
}
if (!selectionContainsTrackerFile)
{
//Compression format
AudioCompressionFormat[] allowedFormats = GetFormatsForPlatform(platform);
EditorGUI.showMixedValue = status.multiCompressionFormat && !properties.compressionFormatChanged;
EditorGUI.BeginChangeCheck();
AudioCompressionFormat newFormat = (AudioCompressionFormat)EditorGUILayout.IntPopup("Compression Format",
(int)properties.settings.compressionFormat,
Array.ConvertAll(allowedFormats, value => value.ToString()),
Array.ConvertAll(allowedFormats, value => (int)value));
if (EditorGUI.EndChangeCheck())
{
properties.settings.compressionFormat = newFormat;
properties.compressionFormatChanged = true;
}
//Quality
if (CompressionFormatHasQuality(properties.settings.compressionFormat))
{
EditorGUI.showMixedValue = status.multiQuality && !properties.qualityChanged;
EditorGUI.BeginChangeCheck();
int newQuality = EditorGUILayout.IntSlider("Quality", (int)Mathf.Clamp(properties.settings.quality * 100.0f, 1.0f, 100.0f), 1, 100);
if (EditorGUI.EndChangeCheck())
{
properties.settings.quality = 0.01f * newQuality;
properties.qualityChanged = true;
}
}
if (platform != BuildTargetGroup.WebGL)
{
//Sample rate settings
EditorGUI.showMixedValue = status.multiSampleRateSetting && !properties.sampleRateSettingChanged;
EditorGUI.BeginChangeCheck();
AudioSampleRateSetting newSetting = (AudioSampleRateSetting)EditorGUILayout.EnumPopup("Sample Rate Setting", properties.settings.sampleRateSetting);
if (EditorGUI.EndChangeCheck())
{
properties.settings.sampleRateSetting = newSetting;
properties.sampleRateSettingChanged = true;
}
//Sample rate settings
if (properties.settings.sampleRateSetting == AudioSampleRateSetting.OverrideSampleRate)
{
EditorGUI.showMixedValue = status.multiSampleRateOverride && !properties.sampleRateOverrideChanged;
EditorGUI.BeginChangeCheck();
int newRate = EditorGUILayout.IntPopup("Sample Rate", (int)properties.settings.sampleRateOverride,
Styles.kSampleRateStrings, Styles.kSampleRateValues);
if (EditorGUI.EndChangeCheck())
{
properties.settings.sampleRateOverride = (uint)newRate;
properties.sampleRateOverrideChanged = true;
}
}
}
//TODO include the settings for things like HEVAG
EditorGUI.showMixedValue = false;
}
}
void DrawEntryBoard(Dictionary <string, AudioEntry> dictionary)
{
if (dictionary == null)
{
return;
}
if (displayId != "" && currentAudioEntry == null)
{
if (dictionary.TryGetValue(displayId, out currentAudioEntry))
{
}
}
if (currentAudioEntry == null)
{
currentAudioEntry = new AudioEntry( );
}
EditorGUILayout.BeginVertical("box", GUILayout.Width(200));
string key = displayId, path = currentAudioEntry.path;
int loadLevel = currentAudioEntry.loadLevel;
AudioType type = currentAudioEntry.type;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("ID:"), GUILayout.Width(50));
key = EditorGUILayout.TextField(key);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Path:"), GUILayout.Width(50));
Color oldColor = GUI.color;
GUI.color = Color.yellow;
EditorGUILayout.LabelField(path);
GUI.color = oldColor;
EditorGUILayout.EndHorizontal();
if (GUILayout.Button("Get Asset Path"))
{
Object selectedObj = Selection.activeObject;
if (selectedObj != null)
{
AudioClip audioClip = (AudioClip)selectedObj;
if (audioClip != null)
{
path = AssetDatabase.GetAssetPath(audioClip.GetInstanceID());
DebugWrapper.Log(path);
string[] pathSplitted = path.Split('/');
bool startAdding = false;
string fileName = "";
for (int splitedIndex = 0; splitedIndex < pathSplitted.Length; splitedIndex++)
{
if (startAdding)
{
fileName += pathSplitted [splitedIndex] + "/";
}
if (pathSplitted [splitedIndex] == "Resources")
{
startAdding = true;
}
}
string[] fileNameSplited = fileName.Split('.');
path = fileNameSplited[0];
DebugWrapper.Log(path);
}
}
}
float inherentVolume = currentAudioEntry.inherentVolume;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Volume:"), GUILayout.Width(50));
inherentVolume = EditorGUILayout.Slider(inherentVolume, 0.0f, 1.0f);
EditorGUILayout.EndHorizontal();
currentAudioEntry.inherentVolume = inherentVolume;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Load Level:"), GUILayout.Width(60));
loadLevel = EditorGUILayout.IntField(loadLevel, GUILayout.Width(15));
AudioClipLoadType aclt = currentAudioEntry.loadType;
EditorGUILayout.Space();
EditorGUILayout.LabelField(new GUIContent("Type:"), GUILayout.Width(30));
aclt = (AudioClipLoadType)EditorGUILayout.EnumPopup(aclt, GUILayout.Width(140));
currentAudioEntry.loadType = aclt;
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("Type:"));
type = (AudioType)EditorGUILayout.EnumPopup(type, GUILayout.Width(50));
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
displayId = key;
currentAudioEntry.path = path;
currentAudioEntry.loadLevel = loadLevel;
currentAudioEntry.type = type;
}
public static void SetAudioClipLoadType(AudioClip audioClip, AudioClipLoadType newLoadType)
{
audioClipLoadType[audioClip] = newLoadType;
}
public AudioInformation(string fullPath, string name, bool forceMono, bool loadInBG, bool preload, AudioClipLoadType loadType, AudioCompressionFormat compressionFormat, float quality, AudioSampleRateSetting sampleRateSetting, int sampleRateOverride)
{
OrigForceMono = forceMono;
ForceMono = forceMono;
OrigLoadBG = loadInBG;
LoadBG = loadInBG;
OrigPreload = preload;
Preload = preload;
OrigLoadType = loadType;
LoadType = loadType;
OrigCompressionFormat = compressionFormat;
CompressionFormat = compressionFormat;
OrigSampleRateSetting = sampleRateSetting;
SampleRateSetting = sampleRateSetting;
OrigQuality = quality;
Quality = quality;
OrigSampleRateOverride = sampleRateOverride;
SampleRateOverride = sampleRateOverride;
FullPath = fullPath;
Name = name;
IsSelected = false;
HasChanged = false;
LastUpdated = DateTime.MinValue.Ticks;
}
private void OnGUI()
{
// Grabbing game object which holds configuration
ImportProperties importProperties = (ImportProperties)AssetDatabase.LoadAssetAtPath("Assets/Prefabs/ImportProperties.prefab", typeof(ImportProperties));
// Basic Editor Setup
EditorGUILayout.BeginVertical();
scrollPos = EditorGUILayout.BeginScrollView(scrollPos, GUILayout.Height(300));
// Boolean For Applying Editor Props
GUILayout.Label("Enable Custom Import Settings", EditorStyles.boldLabel);
enableCustomImportSettings = EditorGUILayout.Toggle("Enable Custom Import Settings", enableCustomImportSettings);
// Add toggle for if user wants to apply their own import settings
if (enableCustomImportSettings)
{
importProperties.enableCustomImportSetting = enableCustomImportSettings;
}
else
{
importProperties.enableCustomImportSetting = enableCustomImportSettings;
}
// Texture Settings
GUILayout.Label("Texture Import Settings", EditorStyles.boldLabel);
maxTextureSizeSelected = EditorGUILayout.Popup("Max Texture Size", maxTextureSizeSelected, maxTextureSizes);
mipMapLevel = EditorGUILayout.IntField("Mip Map Level", mipMapLevel);
// Android Texture Overrides
overrideTexturesForAndroid = EditorGUILayout.BeginToggleGroup("Override Texture Settings For Android", overrideTexturesForAndroid);
maxTextureSizeSelectedForAndroid = EditorGUILayout.Popup("Max Texture Size", maxTextureSizeSelectedForAndroid, maxTextureSizes);
mipMapLevelForAndroid = EditorGUILayout.IntField("Mip Map Level", mipMapLevelForAndroid);
EditorGUILayout.EndToggleGroup();
// Audio Settings
GUILayout.Label("Audio Import Settings", EditorStyles.boldLabel);
audioCompressionFormat = (AudioCompressionFormat)EditorGUILayout.EnumPopup("Audio Compression Format", audioCompressionFormat);
audioSampleRateSetting = (AudioSampleRateSetting)EditorGUILayout.EnumPopup("Audio Sample Rate Setting", audioSampleRateSetting);
audioClipLoadType = (AudioClipLoadType)EditorGUILayout.EnumPopup("Audio Clip Load Type", audioClipLoadType);
// Android Audio Overrides
overrideAudioForAndroid = EditorGUILayout.BeginToggleGroup("Override Audio Settings For Android", overrideAudioForAndroid);
audioCompressionFormatForAndroid = (AudioCompressionFormat)EditorGUILayout.EnumPopup("Audio Compression Format", audioCompressionFormatForAndroid);
audioSampleRateSettingForAndroid = (AudioSampleRateSetting)EditorGUILayout.EnumPopup("Audio Sample Rate Setting", audioSampleRateSettingForAndroid);
audioClipLoadTypeForAndroid = (AudioClipLoadType)EditorGUILayout.EnumPopup("Audio Clip Load Type", audioClipLoadTypeForAndroid);
EditorGUILayout.EndToggleGroup();
EditorGUILayout.EndScrollView();
EditorGUILayout.EndVertical();
bool assignImportSettingsButton = GUILayout.Button("Assign Import Settings");
if (assignImportSettingsButton)
{
if (importProperties)
{
// Texture Settings
if (maxTextureSizeSelected >= 0)
{
importProperties.maxTextureSizeSelected = int.Parse(maxTextureSizes[maxTextureSizeSelected]);
}
if (overrideTexturesForAndroid)
{
importProperties.overrideTexturesForAndroid = overrideTexturesForAndroid;
importProperties.maxTextureSizeSelectedForAndroid = int.Parse(maxTextureSizes[maxTextureSizeSelectedForAndroid]);
}
// Audio Settings
importProperties.audioCompressionFormat = audioCompressionFormat;
importProperties.audioSampleRateSetting = audioSampleRateSetting;
importProperties.audioClipLoadType = audioClipLoadType;
if (overrideAudioForAndroid)
{
importProperties.overrideAudioForAndroid = overrideAudioForAndroid;
importProperties.audioCompressionFormatForAndroid = audioCompressionFormatForAndroid;
importProperties.audioSampleRateSettingForAndroid = audioSampleRateSettingForAndroid;
importProperties.audioClipLoadTypeForAndroid = audioClipLoadTypeForAndroid;
}
}
Debug.Log("Assigned Import Settings");
}
}
private void OnGUI()
{
style.normal.textColor = Color.red;
GUILayout.Label("建议 小于200k : " + AudioClipLoadType.DecompressOnLoad + " 大于200k小于1M : " + AudioClipLoadType.CompressedInMemory + " 大于1M : " + AudioClipLoadType.Streaming, style);
style.normal.textColor = Color.black;
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.LabelField("Path:");
currenAudioClipImportData.AssetPath = EditorGUILayout.TextField(currenAudioClipImportData.AssetPath);
EditorGUILayout.LabelField("NameFilter:", GUILayout.MinWidth(200));
currenAudioClipImportData.FileFilter = EditorGUILayout.TextField(currenAudioClipImportData.FileFilter);
if (GUILayout.Button("Save", GUILayout.MinWidth(100)))
{
SetSelectIndexDataInfo();
}
if (GUILayout.Button("Delete", GUILayout.MinWidth(100)))
{
AudioClipImportManager.ImportRule.Delete(currentSelectIndex);
}
if (GUILayout.Button("New Data", GUILayout.MinWidth(100)))
{
if (string.IsNullOrEmpty(currenAudioClipImportData.AssetPath) ||
string.IsNullOrEmpty(currenAudioClipImportData.FileFilter))
{
return;
}
AudioClipImportManager.AudioClipImportRule.AudioClipImportData data = GetNextAudioClipImportData();
data.AssetPath = currenAudioClipImportData.AssetPath;
data.FileFilter = currenAudioClipImportData.FileFilter;
AudioClipImportManager.ImportRule.Add(data);
currenAudioClipImportData = data;
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
{
androidClipType =
(AudioCompressionFormat)EditorGUILayout.EnumPopup("Android Compression类型", androidClipType);
androidLoadType = (AudioClipLoadType)EditorGUILayout.EnumPopup("Android Load类型", androidLoadType);
SetAndroidFormatInfo();
iPhoneClipType =
(AudioCompressionFormat)EditorGUILayout.EnumPopup("iPhone Compression类型", iPhoneClipType);
iPhoneLoadType = (AudioClipLoadType)EditorGUILayout.EnumPopup("iPhone Load类型", iPhoneLoadType);
SetiPhoneFormatInfo();
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
{
currenAudioClipImportData.IsForceToMono =
EditorGUILayout.ToggleLeft("是否开启ForceToMono", currenAudioClipImportData.IsForceToMono);
currenAudioClipImportData.IsLoadInBackground =
EditorGUILayout.ToggleLeft("是否开启LoadInBackground", currenAudioClipImportData.IsLoadInBackground);
currenAudioClipImportData.IsAmbisonic =
EditorGUILayout.ToggleLeft("是否开启Ambisonic", currenAudioClipImportData.IsAmbisonic);
currenAudioClipImportData.IsPreloadAudioClip =
EditorGUILayout.ToggleLeft("是否开启PreloadAudioClip", currenAudioClipImportData.IsPreloadAudioClip);
currenAudioClipImportData.Index =
EditorGUILayout.IntField("Rule Index", currenAudioClipImportData.Index);
currenAudioClipImportData.Quality =
EditorGUILayout.IntField("Quality", currenAudioClipImportData.Quality);
}
EditorGUILayout.EndHorizontal();
GUILayout.Space(25);
int height = (AudioClipImportManager.ImportRule.AudioClipImportDatas.Count + 1) * 20;
AudioClipImportManager.AudioClipImportRule.AudioClipImportData rule =
AudioClipImportManager.ImportRule.GetRule(currentSelectIndex);
string[] guids = null;
if (null != rule)
{
guids = AssetDatabase.FindAssets("t:AudioClip", new string[] { rule.AssetPath });
height += (guids.Length + 1) * 20;
}
scrollPosition = GUI.BeginScrollView(new Rect(0, 30, position.width, position.height - 30), scrollPosition,
new Rect(0, 0, 1250, height));
EditorGUILayout.BeginHorizontal();
{
GUILayout.Label("AssetPath", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("FileFilter", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("Index", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("ForceToMono", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("LoadInBackground", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("Ambisonic", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("PreloadAudioClip", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("Quality", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("AndroidFormat", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("AndroidLoadType", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("iPhoneFormat", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("iPhoneLoadType", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label("Apply", EditorStyles.label, GUILayout.MinWidth(100));
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
style = GUI.skin.textField;
for (int i = 0; i < AudioClipImportManager.ImportRule.AudioClipImportDatas.Count; i++)
{
EditorGUILayout.BeginHorizontal();
AudioClipImportManager.AudioClipImportRule.AudioClipImportData data =
AudioClipImportManager.ImportRule.AudioClipImportDatas[i];
GUI.color = data.Index == currentSelectIndex ? Color.green : new Color(0.8f, 0.8f, 0.8f, 1);
if (GUILayout.Button(data.AssetPath, style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.FileFilter, style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.Index.ToString(), style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.IsForceToMono.ToString(), style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.IsLoadInBackground.ToString(), style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.IsAmbisonic.ToString(), style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.IsPreloadAudioClip.ToString(), style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.Quality.ToString(), style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.AndroidCompressionFormat.ToString(), style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.AndroidAudioClipLoadType.ToString(), style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.iPhoneCompressionFormat.ToString(), style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button(data.iPhoneClipLoadType.ToString(), style, GUILayout.MinWidth(100)))
{
currentSelectIndex = data.Index;
GetSelectIndexDataInfo(data);
}
if (GUILayout.Button("Apply", GUILayout.MinWidth(100)))
{
AudioClipImportManager.ReImportAudioClips(data);
}
EditorGUILayout.EndHorizontal();
}
if (null != guids)
{
int count = 0;
for (int i = 0; i < guids.Length; i++)
{
string path = AssetDatabase.GUIDToAssetPath(guids[i]);
if (string.IsNullOrEmpty(path))
{
continue;
}
string dir = path.Remove(path.LastIndexOf('/'));
if (!dir.Equals(currenAudioClipImportData.AssetPath))
{
continue;
}
string fileName = path.Substring(path.LastIndexOf('/') + 1);
if (!currenAudioClipImportData.IsMatch(fileName))
{
continue;
}
AudioImporter ai = AssetImporter.GetAtPath(path) as AudioImporter;
if (null != ai)
{
EditorGUILayout.BeginHorizontal();
{
GUILayout.Label(fileName, EditorStyles.label, GUILayout.MinWidth(120));
GUILayout.Label("", EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label((++count).ToString(), EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label(ai.forceToMono.ToString(), EditorStyles.label, GUILayout.MinWidth(120));
GUILayout.Label(ai.loadInBackground.ToString(), EditorStyles.label,
GUILayout.MinWidth(120));
GUILayout.Label(ai.ambisonic.ToString(), EditorStyles.label, GUILayout.MinWidth(100));
GUILayout.Label(ai.preloadAudioData.ToString(), EditorStyles.label,
GUILayout.MinWidth(100));
AudioImporterSampleSettings settingAndroid = ai.GetOverrideSampleSettings("Android");
AudioImporterSampleSettings settingiPhone = ai.GetOverrideSampleSettings("iOS");
GUILayout.Label(settingAndroid.quality.ToString(), EditorStyles.label,
GUILayout.MinWidth(100));
GUILayout.Label(settingAndroid.compressionFormat.ToString(), EditorStyles.label,
GUILayout.MinWidth(100));
GUILayout.Label(settingAndroid.loadType.ToString(), EditorStyles.label,
GUILayout.MinWidth(100));
GUILayout.Label(settingiPhone.compressionFormat.ToString(), EditorStyles.label,
GUILayout.MinWidth(100));
GUILayout.Label(settingiPhone.loadType.ToString(), EditorStyles.label,
GUILayout.MinWidth(100));
GUILayout.Label("", EditorStyles.label, GUILayout.MinWidth(100));
}
EditorGUILayout.EndHorizontal();
}
}
}
GUI.EndScrollView();
if (EditorUtility.IsDirty(AudioClipImportManager.ImportRule))
{
EditorUtility.SetDirty(AudioClipImportManager.ImportRule);
AssetDatabase.Refresh();
}
}
/**************************************************************************************************/
/*!
* \fn static void SelectedSetCompressionBitrate(int newCompressionBitrate)
* Audioデータの一括設定を行う実際の処理(ビットレート)
* \param newCompressionBitrate : ビットレート （例：156000）
* \date 2014.12.25(Thu)
* \author Masayoshi.Matsuyama@Donuts
*/
/**************************************************************************************************/
/*
static void SelectedSetCompressionBitrate(int newCompressionBitrate) {
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.compressionBitrate = newCompressionBitrate;
AssetDatabase.ImportAsset(path);
}
}
*/
/**************************************************************************************************/
/*!
* \fn static void SelectedSetLoadType(AudioImporterLoadType loadtype)
* Audioデータの一括設定を行う実際の処理(LoadType)
* \param loadType : ロードタイプ
* \date 2014.12.25(Thu)
* \author Masayoshi.Matsuyama@Donuts
*/
/**************************************************************************************************/
static void SelectedSetLoadType(AudioClipLoadType loadtype) {
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;
AssetDatabase.ImportAsset(path);
}
}
/// <summary>
/// 更改音效设置
/// </summary>
/// <param name="importer"></param>
/// <param name="platform"></param>
/// <param name="loadType"></param>
public static void SetAudioSettingExt(this AudioImporter importer, string platform, AudioClipLoadType loadType, AudioCompressionFormat format, float quality = 1)
{
AudioImporterSampleSettings settings = importer.GetOverrideSampleSettings(platform);
settings.loadType = loadType;
settings.compressionFormat = format;
settings.quality = quality;
importer.SetOverrideSampleSettings(platform, settings);
}
private void OnSampleSettingGUI(BuildTargetGroup platform, AudioImporterInspector.MultiValueStatus status, bool selectionContainsTrackerFile, ref AudioImporterInspector.SampleSettingProperties properties, bool disablePreloadAudioDataOption)
{
EditorGUI.showMixedValue = status.multiLoadType && !properties.loadTypeChanged;
EditorGUI.BeginChangeCheck();
AudioClipLoadType audioClipLoadType = (AudioClipLoadType)EditorGUILayout.EnumPopup("Load Type", (Enum)properties.settings.loadType, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
properties.settings.loadType = audioClipLoadType;
properties.loadTypeChanged = true;
}
EditorGUI.BeginDisabledGroup(disablePreloadAudioDataOption);
if (disablePreloadAudioDataOption)
{
EditorGUILayout.Toggle("Preload Audio Data", false, new GUILayoutOption[0]);
}
else
{
EditorGUILayout.PropertyField(this.m_PreloadAudioData);
}
EditorGUI.EndDisabledGroup();
if (selectionContainsTrackerFile)
{
return;
}
AudioCompressionFormat[] formatsForPlatform = this.GetFormatsForPlatform(platform);
EditorGUI.showMixedValue = status.multiCompressionFormat && !properties.compressionFormatChanged;
EditorGUI.BeginChangeCheck();
AudioCompressionFormat compressionFormat = (AudioCompressionFormat)EditorGUILayout.IntPopup("Compression Format", (int)properties.settings.compressionFormat, Array.ConvertAll <AudioCompressionFormat, string>(formatsForPlatform, (Converter <AudioCompressionFormat, string>)(value => value.ToString())), Array.ConvertAll <AudioCompressionFormat, int>(formatsForPlatform, (Converter <AudioCompressionFormat, int>)(value => (int)value)), new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
properties.settings.compressionFormat = compressionFormat;
properties.compressionFormatChanged = true;
}
if (this.CompressionFormatHasQuality(properties.settings.compressionFormat))
{
EditorGUI.showMixedValue = status.multiQuality && !properties.qualityChanged;
EditorGUI.BeginChangeCheck();
int num = EditorGUILayout.IntSlider("Quality", (int)Mathf.Clamp(properties.settings.quality * 100f, 1f, 100f), 1, 100, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
properties.settings.quality = 0.01f * (float)num;
properties.qualityChanged = true;
}
}
EditorGUI.showMixedValue = status.multiSampleRateSetting && !properties.sampleRateSettingChanged;
EditorGUI.BeginChangeCheck();
AudioSampleRateSetting sampleRateSetting = (AudioSampleRateSetting)EditorGUILayout.EnumPopup("Sample Rate Setting", (Enum)properties.settings.sampleRateSetting, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
properties.settings.sampleRateSetting = sampleRateSetting;
properties.sampleRateSettingChanged = true;
}
if (properties.settings.sampleRateSetting == AudioSampleRateSetting.OverrideSampleRate)
{
EditorGUI.showMixedValue = status.multiSampleRateOverride && !properties.sampleRateOverrideChanged;
EditorGUI.BeginChangeCheck();
int num = EditorGUILayout.IntPopup("Sample Rate", (int)properties.settings.sampleRateOverride, AudioImporterInspector.Styles.kSampleRateStrings, AudioImporterInspector.Styles.kSampleRateValues, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
properties.settings.sampleRateOverride = (uint)num;
properties.sampleRateOverrideChanged = true;
}
}
EditorGUI.showMixedValue = false;
}
