ReorderableList CreateGPUCacheSizeOverrideList(SerializedProperty property, ReorderableList.ElementCallbackDelegate drawCallback)
{
ReorderableList list = new ReorderableList(property.serializedObject, property);
list.drawHeaderCallback =
(Rect rect) =>
{
GUI.Label(rect, s_Styles.gpuCacheSize);
};
list.drawElementCallback = drawCallback;
#if ENABLE_VIRTUALTEXTURES
list.onAddCallback = (l) =>
{
List <GraphicsFormat> availableFormats = new List <GraphicsFormat>(EditorHelpers.QuerySupportedFormats());
// We can't just pass in existing settings as a parameter to CreateGPUCacheSizeOverrideList() because lambdas can't capture ref params.
GPUCacheSettingSRP[] existingSettings = GetGPUCacheSizeOverrideArrayFromProperty(serializedRPAsset.virtualTexturingSettings.streamingGpuCacheSettings);
RemoveOverriddenFormats(availableFormats, existingSettings);
int index = property.arraySize;
property.InsertArrayElementAtIndex(index);
var newItemProperty = property.GetArrayElementAtIndex(index);
newItemProperty.FindPropertyRelative("format").intValue = availableFormats.Count > 0 ? (int)availableFormats[0] : 0;
newItemProperty.FindPropertyRelative("sizeInMegaBytes").intValue = 64;
};
#endif
return(list);
}
public static ReorderableList SetDrawEachFunction(this ReorderableList _list,
ReorderableList.ElementCallbackDelegate _drawEach)
{
_list.drawElementCallback = _drawEach;
return(_list);
}
private void InitList(ReorderableList.ElementCallbackDelegate drawCallback, ReorderableList.ElementHeightCallbackDelegate heightCallback)
{
List = new ReorderableList(_property.serializedObject, _property);
List.drawHeaderCallback += rect => _property.isExpanded = EditorGUI.ToggleLeft(rect, _property.displayName, _property.isExpanded, EditorStyles.boldLabel);
List.onCanRemoveCallback += (list) => { return(List.count > 0); };
List.drawElementCallback += drawCallback;
List.elementHeightCallback += heightCallback;
}
public void Init(List <T> dataList, ReorderableList.ElementCallbackDelegate callback)
{
if (reorderableList != null)
{
return;
}
reorderableList = new ReorderableList(dataList, typeof(T));
reorderableList.drawElementCallback = callback;
}
/// <summary>
/// Draws the states within a ReorderableList.
/// </summary>
public static ReorderableList DrawStates(ReorderableList reorderableList, SerializedObject serializedObject, SerializedProperty states, string selectedIndexKey,
ReorderableList.ElementCallbackDelegate drawCallback, ReorderableList.AddCallbackDelegate addCallback,
ReorderableList.ReorderCallbackDelegate reorderCallback, ReorderableList.RemoveCallbackDelegate removeCallback)
{
// Initialize the reorder list on first run.
if (reorderableList == null)
{
reorderableList = new ReorderableList(serializedObject, states, !Application.isPlaying, true, !Application.isPlaying, !Application.isPlaying && states.arraySize > 1);
reorderableList.drawHeaderCallback = rect =>
{
// Setup the field sizings.
rect.x += 14;
rect.x -= EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth;
var fieldWidth = rect.width / 5;
var blockedByWidth = Mathf.Max(c_MinBlockedByWidth, Mathf.Min(c_MaxBlockedByWidth, fieldWidth)) + EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth;
fieldWidth = rect.width / 7;
var persistWidth = Mathf.Max(c_MinPersistWidth, Mathf.Min(c_MaxPersistWidth, fieldWidth));
var activateWidth = Mathf.Max(c_MinActivateWidth, Mathf.Min(c_MaxActivateWidth, fieldWidth));
fieldWidth = (rect.width - blockedByWidth - persistWidth - activateWidth) / 2 - (c_WidthBuffer * 3);
var presetWidth = Mathf.Min(c_MaxPresetWidth, fieldWidth) + EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth * 2;
var nameWidth = Mathf.Max(0, rect.width - presetWidth - blockedByWidth - persistWidth - activateWidth - (c_WidthBuffer * 6)) + EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth * 3;
var startRectX = rect.x;
EditorGUI.LabelField(new Rect(startRectX, rect.y + 1, nameWidth, EditorGUIUtility.singleLineHeight), "Name");
startRectX += nameWidth + c_WidthBuffer - EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth;
EditorGUI.LabelField(new Rect(startRectX, rect.y + 1, presetWidth, EditorGUIUtility.singleLineHeight), "Preset");
startRectX += presetWidth - c_WidthBuffer * 3 - EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth;
EditorGUI.LabelField(new Rect(startRectX, rect.y + 1, blockedByWidth + EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth, EditorGUIUtility.singleLineHeight), "Blocked By");
startRectX += blockedByWidth + c_WidthBuffer * 5 - EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth;
EditorGUI.LabelField(new Rect(startRectX, rect.y + 1, persistWidth + EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth, EditorGUIUtility.singleLineHeight), "Persist");
startRectX += persistWidth;
EditorGUI.LabelField(new Rect(startRectX, rect.y + 1, activateWidth + EditorGUI.indentLevel * Utility.InspectorUtility.IndentWidth, EditorGUIUtility.singleLineHeight), "Activate");
};
reorderableList.drawElementCallback = drawCallback;
reorderableList.onAddCallback = addCallback;
reorderableList.onReorderCallback = reorderCallback;
reorderableList.onRemoveCallback = removeCallback;
reorderableList.onSelectCallback = list =>
{
EditorPrefs.SetInt(selectedIndexKey, list.index);
};
if (EditorPrefs.GetInt(selectedIndexKey, -1) != -1)
{
reorderableList.index = EditorPrefs.GetInt(selectedIndexKey, -1);
}
}
// Indent the list so it lines up with the rest of the content.
var listRect = GUILayoutUtility.GetRect(0, reorderableList.GetHeight());
listRect.x += Utility.InspectorUtility.IndentWidth * (EditorGUI.indentLevel + 1);
listRect.xMax -= Utility.InspectorUtility.IndentWidth * (EditorGUI.indentLevel + 1);
reorderableList.DoList(listRect);
return(reorderableList);
}
protected void DrawOrderedSidebar(SerializedProperty prop, ReorderableList.ElementCallbackDelegate drawElementCallback = default)
{
if (list == null)
{
InitiateReorderableList(prop, drawElementCallback);
}
list.DoLayoutList();
if (!string.IsNullOrEmpty(_selectedPropertyPath))
{
SelectedProperty = SerializedObject.FindProperty(_selectedPropertyPath);
}
}
/************************************************************************************************************************/
/// <summary>Creates and initialises a new <see cref="ReorderableList"/>.</summary>
private static ReorderableList CreateReorderableList <T>(List <T> list, string name,
ReorderableList.ElementCallbackDelegate drawElementCallback)
{
return(new ReorderableList(list, typeof(T))
{
drawHeaderCallback = (area) => GUI.Label(area, name),
drawElementCallback = drawElementCallback,
elementHeight = EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing,
footerHeight = 0,
displayAdd = false,
displayRemove = false,
});
}
/************************************************************************************************************************/
/// <summary>Creates and initialises a new <see cref="ReorderableList"/>.</summary>
private static ReorderableList CreateReorderableList <T>(List <T> list, string name,
ReorderableList.ElementCallbackDelegate drawElementCallback, bool showFooter = false)
{
var reorderableList = new ReorderableList(list, typeof(T))
{
drawHeaderCallback = (area) => GUI.Label(area, name),
drawElementCallback = drawElementCallback,
elementHeight = EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing,
};
if (!showFooter)
{
reorderableList.footerHeight = 0;
reorderableList.displayAdd = false;
reorderableList.displayRemove = false;
}
return(reorderableList);
}
public static void DrawReorderableList(ReorderableList list, SerializedProperty property, float?height = null,
ReorderableList.HeaderCallbackDelegate drawHeaderCallback = null,
ReorderableList.ElementCallbackDelegate drawElementCallback = null)
{
list.drawHeaderCallback = drawHeaderCallback ?? (rect =>
{
property.arraySize = Mathf.Max(0, EditorGUI.DelayedIntField(rect, "Size", property.arraySize));
});
list.drawElementCallback = drawElementCallback ?? ((rect, index, isActive, isFocused) =>
{
var element = property.GetArrayElementAtIndex(index);
rect.y += 2f;
EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width, height ?? EditorGUIUtility.singleLineHeight), element);
});
list.DoLayoutList();
property.serializedObject.TryApplyModifiedProperties();
}
private ReorderableList.ElementCallbackDelegate getDrawCallBack(ReorderableList batchList)
{
ReorderableList.ElementCallbackDelegate drawElementCallBack =
(Rect rect, int index, bool isActive, bool isFocused) =>
{
SerializedProperty element = batchList.serializedProperty.GetArrayElementAtIndex(index);
SerializedProperty waitTime = element.FindPropertyRelative("waitTime");
SerializedProperty spawnTime = element.FindPropertyRelative("spawnTime");
SerializedProperty enemyCount = element.FindPropertyRelative("enemyCount");
SerializedProperty enemyType = element.FindPropertyRelative("enemyType");
EditorGUI.LabelField(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), "Batch " + index);
waitTime.floatValue = EditorGUI.FloatField(new Rect(rect.x + 50, rect.y, 40, EditorGUIUtility.singleLineHeight), waitTime.floatValue);
spawnTime.floatValue = EditorGUI.FloatField(new Rect(rect.x + 100, rect.y, 40, EditorGUIUtility.singleLineHeight), spawnTime.floatValue);
enemyCount.intValue = EditorGUI.IntField(new Rect(rect.x + 150, rect.y, 40, EditorGUIUtility.singleLineHeight), enemyCount.intValue);
enemyType.enumValueIndex = (int)(EnemyType)EditorGUI.EnumPopup(new Rect(rect.x + 200, rect.y, 100, EditorGUIUtility.singleLineHeight), (EnemyType)Enum.GetValues(typeof(EnemyType)).GetValue(enemyType.enumValueIndex));
};
return(drawElementCallBack);
}
private void InitiateReorderableList(SerializedProperty prop, ReorderableList.ElementCallbackDelegate drawElementCallback)
{
list = new ReorderableList(SerializedObject, prop, true, false, true, true)
{
multiSelect = false,
onSelectCallback = reorderableList =>
_selectedPropertyPath = reorderableList.serializedProperty
.GetArrayElementAtIndex(reorderableList.selectedIndices.Single())
.propertyPath,
onChangedCallback = reorderableList =>
{
for (var x = 0; x < reorderableList.serializedProperty.arraySize; x++)
{
reorderableList.serializedProperty.GetArrayElementAtIndex(x).FindPropertyRelative("ID")
.intValue = x;
}
},
drawElementCallback = drawElementCallback
};
}
/// <summary>
/// Create a <c>UnityEditorInternal.ReorderableList</c> with common settings.
/// </summary>
///
/// <remarks>
/// I.e., the property label as the header, click to fold or expand the list, basic add and remove buttons.
/// </remarks>
///
/// <returns>The reorderable list.</returns>
/// <param name="property">Property.</param>
/// <param name="drawElementCallback">Draw element callback.</param>
/// <param name="elementHeightCallback">Element height callback.</param>
/*
* The reference of reorderable list:
* http://va.lent.in/unity-make-your-lists-functional-with-reorderablelist/
*
* Set draggable again since it becomes false if the property is not editable.
*/
public static ReorderableList Create(
SerializedProperty property,
ReorderableList.ElementCallbackDelegate drawElementCallback = null,
ReorderableList.ElementHeightCallbackDelegate elementHeightCallback = null
)
{
if (null == property)
{
throw new ArgumentNullException("property");
}
var _result = new ReorderableList(property.serializedObject, property, true, true, true, true);
_result.draggable = true;
_result.drawElementCallback = drawElementCallback;
_result.elementHeightCallback = elementHeightCallback;
Wrap(_result);
return(_result);
}
/// <summary>
/// Draws the AnimatorAudioStateSet.
/// </summary>
public static void DrawAnimatorAudioStateSet(UnityEngine.Object target, AnimatorAudioStateSet animatorAudioStateSet, string animatorAudioStateSetFieldName, bool randomDefaultSelector,
ref ReorderableList reorderableList, ReorderableList.ElementCallbackDelegate drawCallback, ReorderableList.SelectCallbackDelegate selectCallback,
ReorderableList.AddCallbackDelegate addCallback, ReorderableList.RemoveCallbackDelegate removeCallback, string preferencesKey,
ref ReorderableList reorderableAudioList, ReorderableList.ElementCallbackDelegate drawAudioElementCallback,
ReorderableList.AddCallbackDelegate addAudioCallback, ReorderableList.RemoveCallbackDelegate removeAudioCallback,
ref ReorderableList reorderableStateList, ReorderableList.ElementCallbackDelegate stateDrawElementCallback,
ReorderableList.AddCallbackDelegate stateAddCallback, ReorderableList.ReorderCallbackDelegate stateReorderCallback,
ReorderableList.RemoveCallbackDelegate stateRemoveCallback, string statePreferencesKey)
{
PopulateAnimatorAudioStateSelectorTypes();
if (s_SelectorTypeNameCache != null)
{
var selected = 0;
var forceUpdate = true;
if (animatorAudioStateSet.AnimatorAudioStateSelectorData != null && !string.IsNullOrEmpty(animatorAudioStateSet.AnimatorAudioStateSelectorData.ObjectType))
{
for (int i = 0; i < s_SelectorTypeCache.Count; ++i)
{
if (s_SelectorTypeCache[i].FullName == animatorAudioStateSet.AnimatorAudioStateSelectorData.ObjectType)
{
selected = i;
forceUpdate = false;
break;
}
}
}
var newSelected = EditorGUILayout.Popup("Selector", selected, s_SelectorTypeNameCache.ToArray());
if (newSelected != selected || forceUpdate)
{
// Use the Sequence selector as the default (or recoil in the case of a melee weapon).
if (forceUpdate)
{
for (int i = 0; i < s_SelectorTypeCache.Count; ++i)
{
if ((randomDefaultSelector && s_SelectorTypeCache[i].FullName == "Opsive.UltimateCharacterController.Items.AnimatorAudioStates.Sequence") ||
(!randomDefaultSelector && s_SelectorTypeCache[i].FullName == "Opsive.UltimateCharacterController.Items.AnimatorAudioStates.ConstantRecoil"))
{
newSelected = i;
break;
}
}
}
var animatorAudioOutputSelector = Activator.CreateInstance(s_SelectorTypeCache[newSelected]) as AnimatorAudioStateSelector;
animatorAudioStateSet.AnimatorAudioStateSelectorData = Serialization.Serialize(animatorAudioOutputSelector);
InspectorUtility.SetDirty(target);
}
}
if (animatorAudioStateSet.AnimatorAudioStateSelector != null)
{
EditorGUI.indentLevel++;
InspectorUtility.DrawObject(animatorAudioStateSet.AnimatorAudioStateSelector, false, true, target, false, () => {
animatorAudioStateSet.AnimatorAudioStateSelectorData = Serialization.Serialize(animatorAudioStateSet.AnimatorAudioStateSelector);
InspectorUtility.SetDirty(target);
});
EditorGUI.indentLevel--;
}
if (animatorAudioStateSet.States == null || animatorAudioStateSet.States.Length == 0)
{
animatorAudioStateSet.States = new AnimatorAudioStateSet.AnimatorAudioState[] { new AnimatorAudioStateSet.AnimatorAudioState() };
}
var serializedObject = new SerializedObject(target);
var serializedProperty = serializedObject.FindProperty(animatorAudioStateSetFieldName).FindPropertyRelative("m_States");
if (reorderableList == null)
{
reorderableList = new ReorderableList(animatorAudioStateSet.States, typeof(AnimatorAudioStateSet.AnimatorAudioState), false, true, true, animatorAudioStateSet.States.Length > 1);
reorderableList.drawHeaderCallback = OnAnimatorAudioStateListHeaderDraw;
reorderableList.drawElementCallback = drawCallback;
reorderableList.onSelectCallback = selectCallback;
reorderableList.onAddCallback = addCallback;
reorderableList.onRemoveCallback = removeCallback;
reorderableList.serializedProperty = serializedProperty;
if (EditorPrefs.GetInt(preferencesKey, -1) != -1)
{
reorderableList.index = EditorPrefs.GetInt(preferencesKey, -1);
}
}
// ReorderableLists do not like indentation.
var indentLevel = EditorGUI.indentLevel;
while (EditorGUI.indentLevel > 0)
{
EditorGUI.indentLevel--;
}
var listRect = GUILayoutUtility.GetRect(0, reorderableList.GetHeight());
// Indent the list so it lines up with the rest of the content.
listRect.x += InspectorUtility.IndentWidth * indentLevel;
listRect.xMax -= InspectorUtility.IndentWidth * indentLevel;
EditorGUI.BeginChangeCheck();
var prevPref = EditorPrefs.GetInt(preferencesKey, 0);
reorderableList.DoList(listRect);
while (EditorGUI.indentLevel < indentLevel)
{
EditorGUI.indentLevel++;
}
if (EditorGUI.EndChangeCheck() || prevPref != EditorPrefs.GetInt(preferencesKey, 0))
{
reorderableList = null;
reorderableAudioList = null;
reorderableStateList = null;
return;
}
if (EditorPrefs.GetInt(preferencesKey, 0) >= animatorAudioStateSet.States.Length)
{
EditorPrefs.SetInt(preferencesKey, 0);
}
serializedProperty = serializedProperty.GetArrayElementAtIndex(EditorPrefs.GetInt(preferencesKey, 0));
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(serializedProperty.FindPropertyRelative("m_AllowDuringMovement"));
EditorGUILayout.PropertyField(serializedProperty.FindPropertyRelative("m_RequireGrounded"));
EditorGUILayout.PropertyField(serializedProperty.FindPropertyRelative("m_StateName"));
EditorGUILayout.PropertyField(serializedProperty.FindPropertyRelative("m_ItemSubstateIndex"));
if (EditorGUI.EndChangeCheck())
{
serializedObject.ApplyModifiedProperties();
}
var animatorAudioState = animatorAudioStateSet.States[EditorPrefs.GetInt(preferencesKey, 0)];
AudioClipSetInspector.DrawAudioClipSet(animatorAudioState.AudioClipSet, serializedProperty.FindPropertyRelative("m_AudioClipSet"), ref reorderableAudioList, drawAudioElementCallback, addAudioCallback, removeAudioCallback);
if (InspectorUtility.Foldout(animatorAudioState, new GUIContent("States"), false))
{
EditorGUI.indentLevel--;
// The MovementType class derives from system.object at the base level and reorderable lists can only operate on Unity objects. To get around this restriction
// create a dummy array within a Unity object that corresponds to the number of elements within the ability's state list. When the reorderable list is drawn
// the ability object will be used so it's like the dummy object never existed.
var gameObject = new GameObject();
var stateIndexHelper = gameObject.AddComponent <StateInspectorHelper>();
stateIndexHelper.StateIndexData = new int[animatorAudioState.States.Length];
for (int i = 0; i < stateIndexHelper.StateIndexData.Length; ++i)
{
stateIndexHelper.StateIndexData[i] = i;
}
var stateIndexSerializedObject = new SerializedObject(stateIndexHelper);
reorderableStateList = StateInspector.DrawStates(reorderableStateList, new SerializedObject(target), stateIndexSerializedObject.FindProperty("m_StateIndexData"),
statePreferencesKey, stateDrawElementCallback, stateAddCallback,
stateReorderCallback, stateRemoveCallback);
GameObject.DestroyImmediate(gameObject);
EditorGUI.indentLevel++;
}
GUILayout.Space(5);
}
/// <summary>
/// Draws the AudioClipSet.
/// </summary>
public static ReorderableList DrawAudioClipSet(AudioClipSet audioClipSet, ReorderableList reorderableList, ReorderableList.ElementCallbackDelegate drawElementCallback,
ReorderableList.AddCallbackDelegate addCallback, ReorderableList.RemoveCallbackDelegate removeCallback)
{
audioClipSet.AudioConfig = (AudioConfig)EditorGUILayout.ObjectField("Audio Config", audioClipSet.AudioConfig, typeof(AudioConfig), false);
EditorGUILayout.Space(5);
if (audioClipSet.AudioConfig != null)
{
return(null);
}
if (reorderableList == null || audioClipSet.AudioClips != reorderableList.list)
{
if (audioClipSet.AudioClips == null)
{
audioClipSet.AudioClips = new AudioClip[0];
}
reorderableList = new ReorderableList(audioClipSet.AudioClips, typeof(AudioClip), true, true, true, true);
reorderableList.drawHeaderCallback = OnAudioClipListHeaderDraw;
reorderableList.drawElementCallback = drawElementCallback;
reorderableList.onAddCallback = addCallback;
reorderableList.onRemoveCallback = removeCallback;
}
// ReorderableLists do not like indentation.
var indentLevel = EditorGUI.indentLevel;
while (EditorGUI.indentLevel > 0)
{
EditorGUI.indentLevel--;
}
var listRect = GUILayoutUtility.GetRect(0, reorderableList.GetHeight());
// Indent the list so it lines up with the rest of the content.
listRect.x += Shared.Editor.Inspectors.Utility.InspectorUtility.IndentWidth * indentLevel;
listRect.xMax -= Shared.Editor.Inspectors.Utility.InspectorUtility.IndentWidth * indentLevel;
reorderableList.DoList(listRect);
while (EditorGUI.indentLevel < indentLevel)
{
EditorGUI.indentLevel++;
}
GUILayout.Space(5);
return(reorderableList);
}
/// <summary>
/// Draws the hitbox.
/// </summary>
public static void DrawHitbox(ref ReorderableList reorderableList, SerializedObject serializedObject, SerializedProperty hitboxProperty, ReorderableList.ElementCallbackDelegate elementCallback)
{
if (reorderableList == null)
{
reorderableList = new ReorderableList(serializedObject, hitboxProperty, true, true, true, true);
reorderableList.drawHeaderCallback = OnHitboxHeaderDraw;
reorderableList.onAddCallback = OnHitboxListAdd;
reorderableList.drawElementCallback = elementCallback;
}
// Indent the list so it lines up with the rest of the content.
var rect = GUILayoutUtility.GetRect(0, reorderableList.GetHeight());
rect.x += EditorGUI.indentLevel * InspectorUtility.IndentWidth;
rect.xMax -= EditorGUI.indentLevel * InspectorUtility.IndentWidth;
reorderableList.DoList(rect);
}
private void CreateReorderableList(string title, int height, ref ReorderableList reorderableList, SerializedProperty soList, ReorderableList.ElementCallbackDelegate drawCallback)
{
reorderableList = new ReorderableList(serializedObject, soList, true, false, true, true);
reorderableList.elementHeight = height;
reorderableList.drawHeaderCallback = (rect) => {
GUI.Label(rect, title);
};
reorderableList.drawElementCallback = drawCallback;
reorderableList.onAddDropdownCallback = (buttonRect, list) => {
if (matchingAnimatorEvent.Count == 0)
{
return;
}
var menu = new GenericMenu();
for (int i = 0; i < eventsAvailable.Count; i++)
{
int j = i;
menu.AddItem(new GUIContent(matchingAnimatorEvent[0].GetEventById(eventsAvailable[i]).name),
false, (data) => {
serializedObject.Update();
soList.InsertArrayElementAtIndex(soList.arraySize);
soList.GetArrayElementAtIndex(soList.arraySize - 1).FindPropertyRelative("callbackId").intValue = eventsAvailable[j];
serializedObject.ApplyModifiedProperties();
}, eventsAvailable[i]);
}
menu.ShowAsContext();
};
}
/// <summary>
/// Draws the AudioClipSet.
/// </summary>
public static ReorderableList DrawAudioClipSet(AudioClipSet audioClipSet, SerializedProperty serializedProperty, ReorderableList reorderableList, ReorderableList.ElementCallbackDelegate drawElementCallback,
ReorderableList.AddCallbackDelegate addCallback, ReorderableList.RemoveCallbackDelegate removeCallback)
{
if (serializedProperty != null)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(serializedProperty.FindPropertyRelative("m_Delay"));
if (EditorGUI.EndChangeCheck())
{
serializedProperty.serializedObject.ApplyModifiedProperties();
}
}
else
{
audioClipSet.Delay = EditorGUILayout.FloatField("Audio Delay", audioClipSet.Delay);
}
if (reorderableList == null || audioClipSet.AudioClips != reorderableList.list)
{
if (audioClipSet.AudioClips == null)
{
audioClipSet.AudioClips = new AudioClip[0];
}
reorderableList = new ReorderableList(audioClipSet.AudioClips, typeof(AudioClip), true, true, true, true);
reorderableList.drawHeaderCallback = OnAudioClipListHeaderDraw;
reorderableList.drawElementCallback = drawElementCallback;
reorderableList.onAddCallback = addCallback;
reorderableList.onRemoveCallback = removeCallback;
}
// ReorderableLists do not like indentation.
var indentLevel = EditorGUI.indentLevel;
while (EditorGUI.indentLevel > 0)
{
EditorGUI.indentLevel--;
}
var listRect = GUILayoutUtility.GetRect(0, reorderableList.GetHeight());
// Indent the list so it lines up with the rest of the content.
listRect.x += InspectorUtility.IndentWidth * indentLevel;
listRect.xMax -= InspectorUtility.IndentWidth * indentLevel;
reorderableList.DoList(listRect);
while (EditorGUI.indentLevel < indentLevel)
{
EditorGUI.indentLevel++;
}
GUILayout.Space(5);
return(reorderableList);
}
public ReorderableListProperty(SerializedProperty prop, bool indentElems = false, ReorderableList.ElementCallbackDelegate drawCallback = null, ReorderableList.ElementHeightCallbackDelegate heightCallback = null)
{
_property = prop;
indentElements = indentElems;
if (drawCallback == null)
{
drawCallback = DrawElement;
}
if (heightCallback == null)
{
heightCallback = (idx) => { return(Mathf.Max(EditorGUIUtility.singleLineHeight, EditorGUI.GetPropertyHeight(_property.GetArrayElementAtIndex(idx), GUIContent.none, true)) + 4.0f); };
}
InitList(drawCallback, heightCallback);
}
/// <summary>
/// Draws the ReorderableList.
/// </summary>
public static void DrawReorderableList(ref ReorderableList reorderableList, InspectorBase inspector, Array drawnObject, string serializedData,
ReorderableList.HeaderCallbackDelegate drawHeaderCallback, ReorderableList.ElementCallbackDelegate drawElementCallback,
ReorderableList.ReorderCallbackDelegate reorderCallback, ReorderableList.AddCallbackDelegate addCallback,
ReorderableList.RemoveCallbackDelegate removeCallback, ReorderableList.SelectCallbackDelegate selectCallback,
Action <int> drawSelectedElementCallback, string key, bool requireOne, bool indentList)
{
// Initialize the reorder list on first run.
if (reorderableList == null)
{
var data = inspector.PropertyFromName(inspector.serializedObject, serializedData);
reorderableList = new ReorderableList(inspector.serializedObject, data, (reorderCallback != null), true, !Application.isPlaying,
!Application.isPlaying && (!requireOne || (drawnObject != null && drawnObject.Length > 1)));
reorderableList.drawHeaderCallback = (Rect rect) =>
{
EditorGUI.LabelField(rect, "Name");
};
if (drawHeaderCallback != null)
{
reorderableList.drawHeaderCallback = drawHeaderCallback;
}
reorderableList.drawElementCallback = drawElementCallback;
if (reorderCallback != null)
{
reorderableList.onReorderCallback = reorderCallback;
}
reorderableList.onAddCallback = addCallback;
reorderableList.onRemoveCallback = removeCallback;
reorderableList.onSelectCallback = selectCallback;
if (EditorPrefs.GetInt(key, -1) != -1)
{
reorderableList.index = EditorPrefs.GetInt(key, -1);
}
}
var indentLevel = EditorGUI.indentLevel;
if (indentList)
{
// ReorderableLists do not like indentation.
while (EditorGUI.indentLevel > 0)
{
EditorGUI.indentLevel--;
}
}
var listRect = GUILayoutUtility.GetRect(0, reorderableList.GetHeight());
// Indent the list so it lines up with the rest of the content.
if (indentList)
{
listRect.x += Shared.Editor.Inspectors.Utility.InspectorUtility.IndentWidth * indentLevel;
listRect.xMax -= Shared.Editor.Inspectors.Utility.InspectorUtility.IndentWidth * indentLevel;
}
reorderableList.DoList(listRect);
while (EditorGUI.indentLevel < indentLevel)
{
EditorGUI.indentLevel++;
}
if (reorderableList != null && reorderableList.index != -1)
{
if (drawnObject != null && reorderableList.index < drawnObject.Length)
{
drawSelectedElementCallback(reorderableList.index);
}
}
}
public static void DrawReorderableList(ReorderableList list, SerializedProperty property, string label, ref bool unfold,
float?height = null,
ReorderableList.HeaderCallbackDelegate drawHeaderCallback = null,
ReorderableList.ElementCallbackDelegate drawElementCallback = null) =>
DrawListFolder(label, ref unfold, () => DrawReorderableList(list, property, height, drawHeaderCallback, drawElementCallback));
void SetupList(ref ReorderableList list, SerializedObject _sObj, SerializedProperty _sProp, ReorderableList.ElementCallbackDelegate element)
{
list = new ReorderableList(_sObj, _sProp, true, true, true, true);
list.drawHeaderCallback = ((Rect rect) => {
EditorGUI.LabelField(rect, _sProp.displayName);
});
list.drawElementCallback = element;
list.onAddCallback = ((ReorderableList l) =>
{
l.serializedProperty.InsertArrayElementAtIndex(l.serializedProperty.arraySize);
l.serializedProperty.GetArrayElementAtIndex(l.serializedProperty.arraySize - 1).FindPropertyRelative("varName").stringValue = "Variable Name";
serializedObject.ApplyModifiedProperties();
});
list.onRemoveCallback = ((ReorderableList l) =>
{
l.serializedProperty.DeleteArrayElementAtIndex(l.index);
serializedObject.ApplyModifiedProperties();
});
}
public static ReorderableList GetReorderableList(int hash, System.Collections.IList list,Type type, ReorderableList.ElementCallbackDelegate drawElementCallback, ReorderableList.AddCallbackDelegate addCallbackDelegate, ReorderableList.RemoveCallbackDelegate removeCallbackDelegate)
{
if (reorderableListDic.ContainsKey(hash) == false)
{
reorderableListDic[hash] = new ReorderableList(list, type, true, false, true, true);
reorderableListDic[hash].drawElementCallback = drawElementCallback;
reorderableListDic[hash].onAddCallback = addCallbackDelegate;
reorderableListDic[hash].onRemoveCallback = removeCallbackDelegate;
}
return reorderableListDic[hash];
}
protected ReorderableList AddReorderableList <T>(string Header, List <T> List, ReorderableList.ElementCallbackDelegate ElementCallback, bool Draggable = true)
{
ReorderableList ReorderList = new ReorderableList(List, typeof(T), Draggable, true, true, true);
ReorderList.drawHeaderCallback = (Rect rect) => {
EditorGUI.LabelField(rect, Header);
};
ReorderList.drawElementCallback = ElementCallback;
Lists.Add(ReorderList);
return(ReorderList);
}
public static CachedReorderableList GetListDrawer(SerializedProperty property, ReorderableList.HeaderCallbackDelegate drawHeaderCallback, ReorderableList.ElementHeightCallbackDelegate getElementHeightCallback, ReorderableList.ElementCallbackDelegate drawElementCallback,
ReorderableList.FooterCallbackDelegate drawFooterCallback = null,
ReorderableList.AddCallbackDelegate onAddCallback = null, ReorderableList.RemoveCallbackDelegate onRemoveCallback = null, ReorderableList.SelectCallbackDelegate onSelectCallback = null,
ReorderableList.ChangedCallbackDelegate onChangedCallback = null, ReorderableList.ReorderCallbackDelegate onReorderCallback = null, ReorderableList.CanRemoveCallbackDelegate onCanRemoveCallback = null,
ReorderableList.AddDropdownCallbackDelegate onAddDropdownCallback = null)
{
if (property == null)
{
throw new System.ArgumentNullException("property");
}
if (!property.isArray)
{
throw new System.ArgumentException("SerializedProperty must be a property for an Array or List", "property");
}
int hash = GetPropertyHash(property);
CachedReorderableList lst;
if (_lstCache.TryGetValue(hash, out lst))
{
lst.ReInit(property.serializedObject, property);
}
else
{
lst = new CachedReorderableList(property.serializedObject, property);
_lstCache[hash] = lst;
}
lst.drawHeaderCallback = drawHeaderCallback;
lst.elementHeightCallback = getElementHeightCallback;
lst.drawElementCallback = drawElementCallback;
lst.drawFooterCallback = drawFooterCallback;
lst.onAddCallback = onAddCallback;
lst.onRemoveCallback = onRemoveCallback;
lst.onSelectCallback = onSelectCallback;
lst.onChangedCallback = onChangedCallback;
lst.onReorderCallback = onReorderCallback;
lst.onCanRemoveCallback = onCanRemoveCallback;
lst.onAddDropdownCallback = onAddDropdownCallback;
return(lst);
}
/// <summary>
/// Creates a cached ReorderableList that can be used on a IList. The serializedProperty passed is used for look-up and is not used in the ReorderableList itself.
/// </summary>
/// <param name="memberList"></param>
/// <param name="tokenProperty"></param>
/// <param name="drawHeaderCallback"></param>
/// <param name="drawElementCallback"></param>
/// <param name="onAddCallback"></param>
/// <param name="onRemoveCallback"></param>
/// <param name="onSelectCallback"></param>
/// <param name="onChangedCallback"></param>
/// <param name="onReorderCallback"></param>
/// <param name="onCanRemoveCallback"></param>
/// <param name="onAddDropdownCallback"></param>
/// <returns></returns>
public static CachedReorderableList GetListDrawer(System.Collections.IList memberList, SerializedProperty tokenProperty, ReorderableList.HeaderCallbackDelegate drawHeaderCallback, ReorderableList.ElementCallbackDelegate drawElementCallback,
ReorderableList.AddCallbackDelegate onAddCallback = null, ReorderableList.RemoveCallbackDelegate onRemoveCallback = null, ReorderableList.SelectCallbackDelegate onSelectCallback = null,
ReorderableList.ChangedCallbackDelegate onChangedCallback = null, ReorderableList.ReorderCallbackDelegate onReorderCallback = null, ReorderableList.CanRemoveCallbackDelegate onCanRemoveCallback = null,
ReorderableList.AddDropdownCallbackDelegate onAddDropdownCallback = null)
{
if (memberList == null)
{
throw new System.ArgumentNullException("memberList");
}
if (tokenProperty == null)
{
throw new System.ArgumentNullException("property");
}
int hash = PropertyHandlerCache.GetIndexRespectingPropertyHash(tokenProperty);
CachedReorderableList lst;
if (_lstCache.TryGetValue(hash, out lst))
{
lst.ReInit(memberList);
}
else
{
lst = new CachedReorderableList(memberList);
_lstCache[hash] = lst;
}
lst.drawHeaderCallback = drawHeaderCallback;
lst.drawElementCallback = drawElementCallback;
lst.onAddCallback = onAddCallback;
lst.onRemoveCallback = onRemoveCallback;
lst.onSelectCallback = onSelectCallback;
lst.onChangedCallback = onChangedCallback;
lst.onReorderCallback = onReorderCallback;
lst.onCanRemoveCallback = onCanRemoveCallback;
lst.onAddDropdownCallback = onAddDropdownCallback;
return(lst);
}
