public static void Copy(SerializedProperty feedbackList)
{
if (feedbackList == null)
{
return;
}
CopiedFeedbacks.Clear();
for (int i = 0; i < feedbackList.arraySize; i++)
{
SerializedProperty prop = feedbackList.GetArrayElementAtIndex(i);
FeedbackCopyData data = new FeedbackCopyData {
type = prop.objectReferenceValue.GetType(),
};
SerializedProperty property = new SerializedObject(prop
.objectReferenceValue).GetIterator();
property.Next(true);
do
{
if (!FeedbackCopyHelper.IgnoreList.Contains(property.name))
{
data.properties.Add(property.Copy());
}
} while (property.Next(false));
CopiedFeedbacks.Add(data);
}
}
public override void OnInspectorGUI()
{
if (GUILayout.Button("Regenerate ItemDatabase"))
{
ItemDatabaseUtility.GenerateItemDatabase();
}
GUILayout.Space(5);
var listProperty = new SerializedObject((ItemDatabase)target).FindProperty("items");
if (listProperty.propertyType == SerializedPropertyType.Generic)
{
// Use Copy() to avoid unwanted iterating.
var listCount = listProperty.Copy().arraySize;
GUILayout.Label("Items (" + listCount + ")");
foreach (SerializedProperty itemProperty in listProperty)
{
if (itemProperty.propertyType == SerializedPropertyType.ObjectReference)
{
using (new EditorGUI.DisabledScope(true)) {
EditorGUILayout.PropertyField(itemProperty, GUIContent.none);
}
}
}
}
}
public static T Copy <T>(this SerializedObject srcSO, T dest)
where T : Object
{
Assert.IsNotNull(srcSO.targetObject);
Assert.AreEqual(typeof(T), srcSO.targetObject.GetType(), $"Don't be different type...");
return(srcSO.Copy(new SerializedObject(dest)).targetObject as T);
}
public static T Copy <T>(T src, T dest)
where T : Object
{
var srcSO = new SerializedObject(src);
return(srcSO.Copy(new SerializedObject(dest)).targetObject as T);
}
void FindMissingReference(Object obj)
{
if (!objectHS.Add(obj))
{
return;
}
EditorUtility.DisplayProgressBar("Search Objects", objectHS.Count.ToString() + " " + obj.GetType().Name + " " + obj, 0);
var sp = new SerializedObject(obj).GetIterator();
while (sp.NextVisible(true))
{
if (sp.propertyType == SerializedPropertyType.ObjectReference)
{
var value = sp.objectReferenceValue;
if (value == null && sp.objectReferenceInstanceIDValue != 0)
{
propertyList.Add(sp.Copy());
}
else if (value != null)
{
FindMissingReference(value);
}
}
}
}
internal static void SetValue <T>(SerializedProperty target, T data, bool applyModifiedProperties = true)
{
if (!ValueContainerRegistry.TryGetContainerType(typeof(T), out var containerType))
{
var typeName = typeof(T).Name;
Debug.LogError(
$"Trying to set a value of type {typeName}, but it's not got a registered container type!\n" +
$"Please ensure that this type exists: internal class {typeName}Container : ValueContainer<{typeName}> {{}}");
return;
}
ValueContainer <T> dataValueContainer = (ValueContainer <T>)ScriptableObject.CreateInstance(containerType);
dataValueContainer.t = data;
var dataSp = new SerializedObject(dataValueContainer).FindProperty("t");
var dataIter = dataSp.Copy();
var targetIter = target.Copy();
bool next;
do
{
CopySerializedProp(dataIter, targetIter);
next = dataIter.NextVisible(true);
targetIter.NextVisible(true);
} while (next);
if (applyModifiedProperties)
{
target.serializedObject.ApplyModifiedProperties();
}
}
/// <summary>
/// Check a UnityObject for missing serialized references
/// </summary>
/// <param name="obj">The UnityObject to be scanned</param>
/// <param name="properties">A list to which properties with missing references will be added</param>
/// <param name="options">User-configurable options for this view</param>
/// <returns>True if the object has any missing references</returns>
protected static void CheckForMissingReferences(UnityObject obj, List <SerializedProperty> properties, Options options)
{
if (obj == null)
{
return;
}
var property = new SerializedObject(obj).GetIterator();
while (property.NextVisible(true)) // enterChildren = true to scan all properties
{
if (CheckForMissingReferences(property, options))
{
properties.Add(property.Copy()); // Use a copy of this property because we are iterating on it
}
}
}
private static IEnumerable <string> GetInputManagerAxes()
{
List <string> inputAxes = new List <string>();
SerializedProperty inputAxesProperty =
new SerializedObject(AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/InputManager.asset")[0])
.FindProperty("m_Axes");
inputAxesProperty.Next(true);
inputAxesProperty.Next(true);
while (inputAxesProperty.Next(false))
{
SerializedProperty axes = inputAxesProperty.Copy();
axes.Next(true);
inputAxes.Add(axes.stringValue);
}
return(inputAxes);
}
public void CopyPasses()
{
var obj = ScriptableObject.CreateInstance <TestClass>();
obj.value = 100;
obj.sub = new TestSubClass(100);
var SO = new SerializedObject(obj);
var destObj = ScriptableObject.CreateInstance <TestClass>();
var dest = new SerializedObject(destObj);
SO.Copy(dest);
Assert.AreEqual(100, destObj.value);
Assert.AreEqual(100, dest.FindProperty("value").intValue);
Assert.AreEqual(obj.sub, destObj.sub);
Assert.AreEqual(SO.FindProperty("sub").FindPropertyRelative("v").floatValue,
dest.FindProperty("sub").FindPropertyRelative("v").floatValue);
}
private static IEnumerable <SerializedProperty> GatherProperties(UnityEngine.Object profile)
{
List <SerializedProperty> properties = new List <SerializedProperty>();
SerializedProperty iterator = new SerializedObject(profile).GetIterator();
bool hasNextProperty = iterator.Next(true);
while (hasNextProperty)
{
if (!serializedPropertiesToIgnore.Contains(iterator.name) && iterator.depth < maxChildSearchDepth)
{
properties.Add(iterator.Copy());
}
if (serializedPropertyTypesToFlatten.Contains(iterator.type))
{
hasNextProperty = iterator.Next(false);
}
else
{
hasNextProperty = iterator.Next(true);
}
}
return(properties);
}
