diff --git a/Assets/Scripts/Assembly-CSharp/Properties.meta b/Assets/Editor.meta
similarity index 57%
rename from Assets/Scripts/Assembly-CSharp/Properties.meta
rename to Assets/Editor.meta
index 71d1da11..60eecd71 100644
--- a/Assets/Scripts/Assembly-CSharp/Properties.meta
+++ b/Assets/Editor.meta
@@ -1,9 +1,8 @@
fileFormatVersion: 2
-guid: 0ab42e016d1c1ae48a0bc2938df987f4
+guid: 196a32b5a66d86f4994f5517006e9d0f
folderAsset: yes
-timeCreated: 1749670530
-licenseType: Free
DefaultImporter:
+ externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
diff --git a/Assets/Editor/FullInspector-Editor.dll b/Assets/Editor/FullInspector-Editor.dll
new file mode 100644
index 00000000..d84964b5
Binary files /dev/null and b/Assets/Editor/FullInspector-Editor.dll differ
diff --git a/Assets/Editor/FullInspector-Editor.dll.meta b/Assets/Editor/FullInspector-Editor.dll.meta
new file mode 100644
index 00000000..29982feb
--- /dev/null
+++ b/Assets/Editor/FullInspector-Editor.dll.meta
@@ -0,0 +1,30 @@
+fileFormatVersion: 2
+guid: 1005e38d5b37b114a83640a41095cce5
+PluginImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ iconMap: {}
+ executionOrder: {}
+ isPreloaded: 0
+ isOverridable: 0
+ platformData:
+ - first:
+ Any:
+ second:
+ enabled: 0
+ settings: {}
+ - first:
+ Editor: Editor
+ second:
+ enabled: 1
+ settings:
+ DefaultValueInitialized: true
+ - first:
+ Windows Store Apps: WindowsStoreApps
+ second:
+ enabled: 0
+ settings:
+ CPU: AnyCPU
+ userData:
+ assetBundleName:
+ assetBundleVariant:
diff --git a/Assets/Editor/FullInspector-Editor.xml b/Assets/Editor/FullInspector-Editor.xml
new file mode 100644
index 00000000..2d7ac40c
--- /dev/null
+++ b/Assets/Editor/FullInspector-Editor.xml
@@ -0,0 +1,2555 @@
+
+
+
+ FullInspector-Editor
+
+
+
+
+ A list of all types that have a CustomBehaviorEditorAttribute attribute.
+
+
+
+
+ Cached property editors.
+
+
+
+
+ If there are multiple user-defined property editors that report that they can edit a
+ specific type, we sort the applicability of the property editor based on how close it's
+ reported edited type is to the actual property type. This allows for, say, the
+ IListPropertyEditor to override the ICollectionPropertyEditor.
+
+
+
+
+ Returns a set of property editors that can be used to edit the given property type.
+
+
+
+
+ Returns a behavior editor that can be used to edit the given behavior type.
+
+ The type of behavior to edit. This should derive from
+ BaseBehavior.
+
+
+
+ Returns true if the given dataType matches the given behaviorType. If the dataType is
+ generic and the behaviorType is a generic definition, then the behaviorType will be
+ instantiated with the same generic arguments as dataType.
+
+
+
+
+ Creates a new instance of the given editorType. It is assumed that editorType extends
+ IBehaviorEditor.
+
+
+
+
+ Attempt to create a new IBehaviorEditor instance.
+
+ The data type that is used for comparison with the behavior
+ editor.
+ The actual data type that that usedEditedType was derived
+ from.
+ The type of editor we are trying to create.
+
+
+
+
+ Attempts to create a behavior editor for the given edited data type from the given
+ editor type.
+
+ The type that is being edited.
+ The editor type.
+ A behavior editor that can edit the given edited type.
+
+
+
+ Allows an IPropertyEditor to be used as an attribute property editor.
+
+
+
+
+ The attribute type that activates this property editor.
+
+
+
+
+ If true, then this attribute property editor will replace other property editors beneath
+ it.
+
+
+
+
+ Construct a new attribute instance.
+
+ The attribute type that activates this property
+ editor.
+
+
+
+ Construct a new attribute instance.
+
+ The attribute type that activates this property
+ editor.
+ If true, then this attribute property editor will replace
+ other property editors beneath it.
+
+
+
+ Mark a type as a custom behavior editor. That editor needs to derive from
+ BehaviorEditor{TBehavior} and will be used as the editor for that behavior type.
+
+
+
+
+ The behavior type to edit.
+
+
+
+
+ True if this should editor should apply to derived types. Defaults to true.
+
+
+
+
+ An annotation that signals that a class is a property editor for a given property type.
+
+
+ If the property editor is editing a generic type, then PropertyType should just be an open
+ generic type reflecting the edited type. For example, for a List property editor,
+ PropertyType should be typeof(List{}) (where {} are angle brackets).
+
+
+
+
+ The type of property that this class is a property editor for. This can be either a
+ non-generic type or an open generic type (List{} is an open generic type, but List[int]
+ is not).
+
+
+
+
+ Should this editor type be used for inherited PropertyTypes? If Inherit is true, then
+ the first generic parameter of your property editor type will be automatically populated
+ with the derived type that the property editor is being used to edit.
+
+
+
+
+ Internal bool to prevent a warning emission if this property editor targets UnityObject
+ types.
+
+
+
+
+ Mark this type as an IPropertyEditor. It will be instantiated automatically.
+
+ The type of property that this PropertyEditor is
+ editing.
+
+
+
+ Mark this type as an IPropertyEditor. It will be instantiated automatically.
+
+ The type of property that this PropertyEditor is
+ editing.
+ If true, then this PropertyEditor will also be used for types that
+ derive from propertyType. If true, then this also has implications on the generic
+ parameter list. See the documentation on the member variable for more
+ information.
+
+
+
+ The default behavior editor is used whenever there is not a user-defined one that should be
+ used instead.
+
+
+
+
+ If you wish to just extend the default behavior editor by adding a section before/after it, you
+ can just extend this class and override the appropriate methods.
+
+
+
+
+ An editor that provides a good inspector experience for types which derive from
+ ISerializedObject.
+
+
+
+
+ This is accessed by the BaseBehaviorEditor (using reflection) to determine if the editor
+ should show the value for _serializedState.
+
+
+
+
+ Draws an open script button for the given object.
+
+
+
+
+ An IAttributePropertyEditor is identical to an IPropertyEditor, except that it also
+ contains an Attribute parameter.
+
+
+
+
+ The attribute that was used to create this editor.
+
+
+
+
+ A property editor is the core editing abstraction used within FI. This allows for
+ overriding of the default inspector logic for elements of a custom type. PropertyEditors
+ are extremely similar to Unity's PropertyDrawers, except that they support generics and
+ are fully type-safe. The AttributePropertyEditor is identical to the PropertyEditor, except
+ that it is activated when a user adds an attribute to a type.
+
+
+ Recall that to get FI to actually use the property editor, you need to add the
+ [CustomAttributePropertyEditor] attribute to the type with appropriate parameters.
+
+ The element type that the editor will edit
+
+
+
+ Notification that the inspector/editor is now active.
+
+
+
+
+ Notification that the inspector/editor is no longer active.
+
+
+
+
+ This method makes it easy to use a typical behavior editor as a GUILayout style method,
+ where the rect is taken care of.
+
+ The editor that is being used.
+ The element that is being edited.
+
+
+
+ Marks an object as a property editor.
+
+
+ This interface is split up into two parts, the core one that user's typically access,
+ IPropertyEditor, and one that implements the actual editing API, IPropertyEditorEditAPI.
+
+ You almost certainly want to extend PropertyEditor{T} instead of this
+ interface. It provides an automatic implementation for all methods and gives type-safety to
+ your editor.
+
+
+
+
+ The editing chain that this editor is within. This can be used to fetch the next editor
+ to use and the like.
+
+
+
+
+ Can the editor edit the given type?
+
+
+
+
+ An optional annotation for a property editor to specify its default foldout state.
+
+
+
+
+ The default foldout state for the property editor. If set to false, then the editor
+ will be collapsed immediately.
+
+
+
+
+ A property editor is the core editing abstraction used within FI. This allows for overriding
+ of the default inspector logic for elements of a custom type. PropertyEditors are extremely
+ similar to Unity's PropertyDrawers, except that they support generics and are fully
+ type-safe.
+
+
+ Recall that to get FI to actually use the property editor, you need to add the
+ [CustomPropertyEditor] attribute to the type with appropriate parameters.
+
+ The element type that the editor will edit
+
+
+
+ This is the core editing API that property editors use. We split the editing API and the
+ IPropertyEditor interfaces into two as we define extension methods on IPropertyEditor that
+ allows FI to run arbitrary code before/after the actual edit method executes.
+
+
+
+
+ Display a Unity inspector GUI that provides an editing interface for the given object.
+
+ The rect on the screen to draw the GUI controls.
+ The label to label the controls with.
+ The element itself to edit. This can be mutated directly. For
+ values which cannot be mutated, such as structs, the return value is used to update the
+ stored value.
+ An updated instance of the element.
+
+
+
+ Returns the height of the region that needs editing.
+
+ The label that will be used when editing.
+ The element that will be edited.
+ The height of the region that needs editing.
+
+
+
+ Returns a header that should be used for the foldout. An item is displayed within a
+ foldout when this property editor reaches a certain height.
+
+ The current foldout label.
+ The current object element.
+ An updated label.
+
+
+
+ Draw an optional scene GUI.
+
+ The object instance to edit using the scene GUI.
+ An updated object instance.
+
+
+
+ Does this editor display a standard label that can instead be rendered with EditorGUI.Foldout?
+
+
+
+
+ The cached height metadata is used to optimize CPU/execution time for some memory so that
+ we don't have to recompute heights multiple times over. In essence, if we call
+ GetElementHeight from Edit, then GetElementHeight will short-circuit and just return a
+ cached height.
+
+
+
+
+ We store the current
+
+
+
+
+ The current method that we are invoking.
+
+
+
+
+ Helper method to fetch the editing API for an IPropertyEditor.
+
+
+
+
+ Display a Unity inspector GUI that provides an editing interface for the given object.
+
+ The rect on the screen to draw the GUI controls.
+ The label to label the controls with.
+ The element itself to edit. This can be mutated directly. For
+ values which cannot be mutated, such as structs, the return value is used to update the
+ stored value.
+ An updated instance of the element.
+
+
+
+ Fetches the dropdown metadata instance that should be used. This performs any necessary initialization.
+
+
+
+
+ Returns the height of the region that needs editing.
+
+ The label that will be used when editing.
+ The element that will be edited.
+ The height of the region that needs editing.
+
+
+
+ Returns a header that should be used for the foldout. An item is displayed within a
+ foldout when this property editor reaches a certain height.
+
+ The current foldout label.
+ The current object element.
+ An updated label.
+
+
+
+ Draw an optional scene GUI.
+
+ The object instance to edit using the scene GUI.
+ An updated object instance.
+
+
+
+ This method makes it easy to use a typical property editor as a GUILayout style method,
+ where the rect is taken care of.
+
+ The editor that is being used.
+ The label to edit the region with.
+ The element that is being edited.
+
+
+
+ Detects when Unity is recompiling code. Before a recompile happens, all state is saved and
+ after the recompilation is finished all state is restored.
+
+
+
+
+ True if we have detected a compile but have already saved. This is set to false by Unity
+ after a compilation has finished.
+
+
+
+
+ True if everything has been restored. This is set to false by Unity after a compilation
+ / reload has occurred.
+
+
+
+
+ Detects when the editor has entered or left play mode or has paused.
+
+
+ This class is currently disabled / not used, but it remains here because the code is tricky
+ to get right and may be useful in the future.
+
+
+
+
+ A transition that the editor can go through.
+
+
+
+
+ The editor is about to enter play mode but has yet to go through Unity
+ serialization.
+
+
+
+
+ The editor is about to enter play mode and has just gone through Unity
+ serialization.
+
+
+
+
+ The editor is leaving play mode and has just gone through Unity serialization.
+
+
+
+
+ The editor is about to enter pause mode
+
+
+
+
+ The editor is about to leave pause mode
+
+
+
+
+ The last playing state
+
+
+
+
+ The last paused state
+
+
+
+
+ This function is called when the editor is undergoing a play mode related transition.
+
+
+
+
+ This processor saves the state of any unsaved BaseBehavior instances when the scene has been
+ saved. This type isn't necessary as the BaseBehaviorEditor manages saving everything, but it
+ provides some extra data protection.
+
+
+
+
+ Manages the discovery of PropertyEditor class instances.
+
+
+
+
+ The type of the edited object.
+
+
+
+
+ The attributes associated with the edited type.
+
+
+
+
+ A list of all types that have a CustomPropertyEditorAttribute attribute.
+
+
+
+
+ Cached property editors.
+
+
+
+
+ If there are multiple user-defined property editors that report that they can edit a
+ specific type, we sort the applicability of the property editor based on how close it's
+ reported edited type is to the actual property type. This allows for, say, the
+ IListPropertyEditor to override the ICollectionPropertyEditor.
+
+
+
+
+ Returns a set of property editors that can be used to edit the given property type.
+
+
+
+
+ Returns a PropertyEditorChain that can edit the given type. The PropertyEditorChain will
+ contain all of the IPropertyEditor instances which reported that they could edit the
+ given type (with the associated set of attributes). To get an actual property editor,
+ use chain.FirstEditor or a similar method.
+
+ The type of property/field that is being edited.
+ Provides attributes that may override the default
+ property editor. This parameter can safely be set to null.
+ A property editor chain composed of property editors which can edit the given
+ property type.
+
+
+
+ In Full Inspector, there are typically a large number of property editors that can be used
+ for each type, for example, a user defined editor, then the abstract editor, then the
+ reflected editor. PropertyEditorChain encapsulates this idea and makes it easy to retrieve
+ the next editor that will be used.
+
+
+
+
+ The editing chain. The most applicable editor is at index 0 (followed by the next most
+ applicable at index 1, ...).
+
+
+
+
+ Adds an editor to the end of this chain.
+
+
+
+
+ Returns true if there is another editor after the given one.
+
+
+
+
+ Returns the next editor that will be used, or null if the given editor is either the
+ last one or was not found in the chain.
+
+ The editor that is currently being used.
+ The next editor, or null if there is no next one.
+
+
+
+ Returns the first property editor in this chain that is not an instance of any of the
+ given types.
+
+
+
+
+ Returns the first property editor in this chain.
+
+
+
+
+ Returns true if the given dataType matches the given propertyType. If the dataType is
+ generic and the propertyType is a generic definition, then the propertyType will be
+ instantiated with the same generic arguments as dataType.
+
+
+
+
+ Creates a new instance of the given editorType. It is assumed that editorType extends
+ IPropertyEditor.
+
+
+
+
+ Attempt to create a new IPropertyEditor instance.
+
+ The data type that is used for comparison with the property
+ editor.
+ The actual data type that that usedEditedType was derived
+ from.
+ The type of editor we are trying to create.
+
+
+
+
+ Attempts to create a property editor for the given edited data type from the given
+ editor type.
+
+ The type that is being edited.
+ The editor type.
+ The attributes that were specified for the type.
+ Should inheritance behavior be forced? The expected value is false.
+ A property editor that can edit the given edited type.
+
+
+
+ We only animate the abstract type height when we have changed types ourselves. If we
+ always animate when a height change occurs and the inside is also animating, then we
+ will create an "animation lag" which looks awful.
+
+
+
+
+ Provides a property editor for types which cannot be instantiated directly and require the
+ user to select a specific instance to instantiate.
+
+
+
+
+ A map of attribute type to the IPropertyEditor type that is associated with that
+ attribute (via the CustomAttributePropertyEditorAttribute annotation).
+
+
+
+
+ A map of attribute type to if that property editor should replace all other editors
+ after it.
+
+
+
+
+ Provides a property editor for enums.
+
+
+
+
+ A property editor for nullable types.
+
+
+
+
+ The general property editor that takes over when there is no specific override. This uses
+ reflection to discover what values to edit.
+
+
+
+
+ The maximum depth that the reflected editor will go to for automatic object reference
+ instantiation. Beyond this depth, the user will have the manually instantiate
+ references. We have a depth limit so that we don't end up in an infinite object
+ construction cycle.
+
+
+
+
+ This returns true if automatic instantiation should be enabled. Automatic instantiation
+ gets disabled after the reflected editor has gone a x calls deep into itself in an
+ attempt to prevent infinite recursion.
+
+
+
+
+ How tall buttons should be.
+
+
+
+
+ How tall the label element should be.
+
+
+
+
+ How much space is between each element.
+
+
+
+
+ The height of the category toolbar.
+
+
+
+
+ Returns true if the given GUIContent element contains any content.
+
+
+
+
+ Draws a label at the given region. Returns an indented rectangle that can be used for
+ drawing properties directly under the label.
+
+
+
+
+ A helper method that draws the inspector for a field/property at the given location.
+
+
+
+
+ A helper method that draws a button at the given region.
+
+
+
+
+ Draws the actual property editors.
+
+
+
+
+ Manages the options that are displayed to the user in the instance selection drop-down.
+
+
+
+
+ Setup the instance option manager for the given type.
+
+
+
+
+ Returns an array of options that should be displayed.
+
+
+
+
+ Remove any options from the set of display options that are not permanently visible.
+
+
+
+
+ Returns the index of the option that should be displayed (from GetDisplayOptions())
+ based on the current object instance.
+
+
+
+
+ Changes the instance of the given object, if necessary.
+
+
+
+
+ This class assists with cycle detection in an object graph.
+
+
+
+
+ Factory we use for allocation HashSets (to minimize GC pressure).
+
+
+
+
+ Cycle detectors that we are depending on / derived from.
+
+
+
+
+ The objects we have encountered so far.
+
+
+
+
+ The recursion depth level that we're at.
+
+
+
+
+ The current recursion / nesting depth.
+
+
+
+
+ Increase the recursion / nesting depth.
+
+
+
+
+ Decrease the recursion / nesting depth.
+
+
+
+
+ Tries to mark an object. Returns false if the object is already in the cycle detector,
+ ie, it has already been encountered (which implies that it's part of a cycle).
+
+
+
+
+ Returns true if the object is in the cycle detector, ie, the object is part of a cycle.
+
+
+
+
+ An editor that is displayed while we are generating the PropertyDrawer bindings.
+
+
+
+
+ The current version string.
+
+
+
+
+ Full Inspector will effectively force the user to do a clean import if any of the following types are found in
+ the assembly.
+
+
+
+
+ A wrapper around AnimFloat that makes it easier to use.
+
+
+
+
+ Update the height of the editor.
+
+ The new height.
+ Should animation be allowed? Sometimes animation is not
+ desired if a sub-item is animation. If this item animations when a sub-item is
+ animating, then there will be visible UX jerk.
+ If true, then a transition is occurring and the animation is rendering.
+
+
+
+ Returns true if animation is occurring.
+
+
+
+
+ The current height of the animation.
+
+
+
+
+ Draws a normal EditorGUI.ObjectField, except it includes the component type.
+
+
+
+
+ Draws a button with a label in front of the button.
+
+
+
+
+ Draws a button with a label in front of the button.
+
+
+
+
+ Draws an editor for the given control at the given rect.
+
+ The rect to draw the editor within.
+ The label for the edited control.
+ The element to edit.
+ The metadata to use when editing.
+ The actual control that will be used for the editor.
+ The updated element instance.
+
+
+
+ Draws an editor for the given control at the given rect.
+
+ The element to edit.
+ The label for the edited control.
+ The metadata to use when editing.
+ The actual control that will be used for the editor.
+ The height that is needed to fully display this control.
+
+
+
+ Draws a GUI for editing the given property and returns the updated value. This does
+ *not* write the updated value to a container.
+
+
+
+
+ Draws a GUI for editing the given property and returns the updated value. This does
+ *not* write the updated value to a container.
+
+ An optional context that the property value came from. If this is not given, then a prefab context menu will not be displayable.
+
+
+
+ This class is used to cache results for some expensive fiEditorUtility method calls.
+
+
+
+
+ Returns the paths of all .scene files in the Unity project.
+
+
+
+
+ Find all prefabs of a given type, regardless of location.
+
+ The type of object to fetch
+ Please note that this method can return UnityObject instances that have been deleted.
+
+
+
+ Find all assets of a given type, regardless of location.
+
+ The (ScriptableObject derived) type of object to fetch
+ Please note that this method can return UnityObject instances that have been deleted.
+
+
+
+ This will sent a repaint request to every active editor.
+
+
+
+
+ Add to this list if the editor should be repainted upon a general repaint request.
+
+
+
+
+ If enabled, then the inspector should be constantly redrawn. This is used to work around
+ some rendering issues within Unity.
+
+
+
+
+ Attempts to fetch a MonoScript that is associated with the given obj.
+
+ The object to fetch the script for.
+ The script, if found.
+ True if there was a script, false otherwise.
+
+
+
+ Returns true if the given obj has a MonoScript associated with it.
+
+
+
+
+ Returns an associated object for another object.
+
+
+
+
+ A mapping from the objects that contain metadata to their metadata.
+
+
+
+
+ Returns true if there is metadata for the given item.
+
+
+
+
+ Sets the metadata instance for the given item and type.
+
+
+
+
+ Fetch a metadata instance for the given item.
+
+
+
+
+ Utility functions for working with prefab overrides.
+
+
+
+
+ Returns true if the period separate property path contains the given property name.
+
+
+
+
+ Attempts to extract the name of serialized key for the given property modification.
+
+ The object that that modification is applied to.
+ The modification.
+ An output parameter containing the name of the key that the
+ modification maps to.
+ True if the key was found, false otherwise.
+
+
+
+ Reverts the given property on the instance to the prefab value.
+
+ The prefab instance to revert the value on.
+ The property to revert.
+
+
+
+ Returns true if the given property on the given object instance has a prefab override.
+
+ The object instance.
+ The property to check.
+ True if the property is prefab override, false otherwise.
+
+ Currently, this method only works for MonoBehavior targets.
+
+
+
+
+ A cache of all types that derive the key type in the AppDomain. The cache is
+ automatically destroyed upon assembly loads.
+
+
+
+
+ Returns all types that derive from the base type. This includes generic type
+ definitions, which when returned will have appropriate constructor values injected.
+
+ The base parent type.
+
+
+
+ A candidate type that can potentially be used as a generic parameter argument.
+
+
+
+
+ The actual type that will be the generic parameter.
+
+
+
+
+ The name of the generic parameter that this type came from.
+
+
+
+
+ Helper method to return the index of the Type in the array that has the given Name (or
+ - 1 if the item is not in the array).
+
+
+
+
+ Orders the given types parameter array so that the order most closely matches the given
+ genericArguments array
+
+ The types that have been collected as potential candidates
+ for generic parameter arguments
+ The type that we are going to use the candidateTypes for
+ constructing a closed generic type on
+ An array of types that can (hopefully) be used to construct a closed generic
+ type from the given openGenericType.
+
+
+
+ Attempts to create an instance of openGenericType such that it is can be assigned to
+ baseType.
+
+ An open generic type that derives baseType
+ A generic type with fully populated type parameters.
+ Just baseType.GetGenericTypeDefinition()
+ Just baseType.GetGenericArguments()
+ If this function returns true, then this value is set to
+ the created type that is assignable to baseType and an instance of
+ openGenericType.
+ True if a type was constructed, false otherwise.
+
+
+
+ Searches for a particular implementation of the given parent type inside of the type.
+ This is particularly useful if the interface type is an open type, ie, typeof(IFace{}),
+ because this method will then return IFace{} but with appropriate type parameters
+ inserted.
+
+ The base type to search for interface
+ The parent type to search for. Can be an open generic
+ type.
+ The actual interface type that the type contains, or null if there is no
+ implementation of the given interfaceType on type.
+
+
+
+ Tries to fetch the given CSharpName of the given object type, or null if the object is
+ null.
+
+
+
+
+ Returns the value of a boolean, field, or property.
+
+
+
+
+ A few APIs to forcibly call SaveState and RestoreState on every type
+ that implements ISerializedObject.
+
+
+
+
+ Forcibly save the state of all objects which derive from ISerializedObject.
+ ISerializedObject saving is managed automatically when you use the editor (and can be
+ customized in fiSettings).
+
+
+
+
+ Forcibly restore the state of all objects which derive from ISerializedObject.
+
+
+
+
+ This will clean all of the FI data from the scene.
+
+
+
+
+ Returns the object that this serialized property is currently storing.
+
+
+
+
+ This class contains methods that do not use public Unity API. These are subject to
+ break/change per update.
+
+
+
+
+ Attempts to enable/disable the bold font that is used by Unity when an object has a
+ value different from its prefab.
+
+ True if the bold font is set, false if it is not.
+
+
+
+ Helper to write the C# file containing the selected serializer information.
+
+
+
+
+ Contains editing logic common to the backup window and the inline backup viewer.
+
+
+
+
+ The backup editor window.
+
+
+
+
+ The central API that end-users might be interested in. Provides key functions such as
+ creating a new backup and restoring an old one.
+
+
+
+
+ Returns all backups for the given object.
+
+
+
+
+ Creates a new backup of the given component. Only guaranteed to work for types that
+ derive from CommonBaseBehavior, but there is a good chance it'll work for most/all
+ types derived from Component.
+
+
+
+
+ Helper function that just ignores a few FI internal types for serialization since the
+ backup solution serializes all inspected properties, not just those that are serialized
+
+
+
+
+ Restores a backup that was previously created.
+
+
+
+
+ Creates a serialized object from the given component.
+
+
+
+
+ Manages backups stored in prefab storage container. The prefab container stores backups
+ when Unity is in play-mode and when the backup target does not live in the scene (an
+ example would be a backup targeting another prefab).
+
+
+
+
+ Manages the backup storage that lives in the scene.
+
+
+
+
+ This class provides a unified API for accessing backups across scene and prefab storage.
+
+
+
+
+ Returns the storage component that is currently best suited for use.
+
+
+
+
+ Removes the given backup instance.
+
+
+
+
+ Removes backups that are no longer valid (their target got destroyed, etc).
+
+
+
+
+ Attempts to migrate prefab storage into scene storage.
+
+
+
+
+ Returns true if there is a backup for the given behavior.
+
+
+
+
+ Returns every serialized object.
+
+
+
+
+ Reorderable list adapter for arrays.
+
+
+
+
+ Reorderable list adapter for ICollection types
+
+
+
+
+ Returns the height of the given element.
+
+
+
+
+ Provides an editor for the given element.
+
+
+
+
+ Metadata we use for the callbacks.
+
+
+
+
+ Stores all of the elements
+
+
+
+
+ A cached version of the collection optimized for item lookup.
+
+
+
+
+ For performance reasons, the CollectionAdaptor stores an array version of the
+ collection. If the adapted collection has been structurally modified, for example, an
+ item has been added, then the local cache is invalid. Calling this method updates the
+ cache, which will restore proper adapter semantics.
+
+
+
+
+ Reorderable list adapter for generic list.
+
+
+ This adapter can be subclassed to add special logic to item height calculation. You
+ may want to implement a custom adapter class where specialized functionality is
+ needed.
+
+
+
+ The list which can be reordered.
+ Callback to draw list item.
+ Height of list item in pixels.
+
+
+
+ This is the base collection property editor with a set of extension points for the other
+ property editors. All Rotorz-style collection editors use this as the base editor. It
+ provides automatic support for paging.
+
+ The actual type of the collection, ie, List{T}. This is used for instance creation.
+ The collection interface, ie, IList{T}, or List{T}. The property editor
+ selection logic will choose the most associated editor using this type.
+ The type of items stored inside of the collection, ie, {T} in List{T}.
+ The type of item that is added to a collection, ie,
+ TAddItem = {K} in TActual = Dictionary{K, V} where TItem = KeyValuePair{K, V}
+
+
+
+ Fetch an adaptor for the collection.
+
+
+
+
+ Called after an edit cycle is done if the collection needs to be updated from the adaptor.
+
+
+
+
+ An item has been added to the collection.
+
+
+
+
+ Should the item added to the collection be customized *before* adding it?
+
+
+
+
+ Can we reorder elements inside of the collection?
+
+
+
+
+ Provides a relatively simple editor for IList{T} types that only views one element at a
+ time. This is useful if the list is massive, or perhaps to just reduce information overload
+ when editing.
+
+
+
+
+ Returns true if there is currently an item that is being edited.
+
+
+
+
+ Attempts to ensure that the current editing index is not out of range. However, if the
+ edited list is empty, then the index will always be out of range.
+
+
+
+
+ The metadata we store on each item that we edit so that we know what the active editing
+ item is.
+
+
+
+
+ Adaptor allowing reorderable list control to interface with list data.
+
+
+
+
+ Gets count of elements in list.
+
+
+
+
+ Determines whether an item can be reordered by dragging mouse.
+
+
+ This should be a light-weight method since it will be used to determine whether
+ grab handle should be included for each item in a reorderable list. Please
+ note that returning a value of false does not prevent movement on list item since
+ other draggable items can be moved around it.
+
+ Zero-based index for list element.
+ A value of true if item can be dragged; otherwise /c>.
+
+
+
+ Determines whether an item can be removed from list.
+
+
+ This should be a light-weight method since it will be used to determine whether
+ remove button should be included for each item in list. This is redundant
+ when is specified.
+
+ Zero-based index for list element.
+ A value of true if item can be removed; otherwise /c>.
+
+
+
+ Add new element at end of list.
+
+
+
+
+ Insert new element at specified index.
+
+ Zero-based index for list element.
+
+
+
+ Duplicate existing element.
+
+ Zero-based index of list element.
+
+
+
+ Remove element at specified index.
+
+ Zero-based index of list element.
+
+
+
+ Move element from source index to destination index.
+
+ Zero-based index of source element.
+ Zero-based index of destination element.
+
+
+
+ Clear all elements from list.
+
+
+
+
+ Draw interface for list element.
+
+ Position in GUI.
+ Zero-based index of array element.
+
+
+
+ Gets height of list item in pixels.
+
+ Zero-based index of array element.
+ Measurement in pixels.
+
+
+
+ Resources to assist with reorderable list control.
+
+
+
+
+ Resource assets for light skin.
+
+
+ Resource assets are PNG images which have been encoded using a base-64 string so
+ that actual asset files are not necessary.
+
+
+
+
+ Resource assets for dark skin.
+
+
+ Resource assets are PNG images which have been encoded using a base-64 string so
+ that actual asset files are not necessary.
+
+
+
+
+ Gets light or dark texture "add_button.png".
+
+
+
+
+ Gets light or dark texture "add_button_active.png".
+
+
+
+
+ Gets light or dark texture "container_background.png".
+
+
+
+
+ Gets light or dark texture "grab_handle.png".
+
+
+
+
+ Gets light or dark texture "remove_button.png".
+
+
+
+
+ Gets light or dark texture "remove_button_active.png".
+
+
+
+
+ Gets light or dark texture "title_background.png".
+
+
+
+
+ Generate special textures.
+
+
+
+
+ Create 1x1 pixel texture of specified color.
+
+ Name for texture object.
+ Pixel color.
+ The new Texture2D instance.
+
+
+
+ Read textures from base-64 encoded strings. Automatically selects assets based upon
+ whether the light or dark (pro) skin is active.
+
+
+
+
+ Read width and height if PNG file in pixels.
+
+ PNG image data.
+ Width of image in pixels.
+ Height of image in pixels.
+
+
+
+ Utility functions to assist with GUIs.
+
+
+
+
+ Gets visible rectangle within GUI.
+
+
+ VisibleRect = TopmostRect + scrollViewOffsets
+
+
+
+
+ Focus control and text editor where applicable.
+
+
+
+
+ Arguments which are passed to .
+
+
+
+
+ Gets adaptor to reorderable list container which contains element.
+
+
+
+
+ Gets zero-based index of item which was inserted.
+
+
+
+
+ Indicates if inserted item was duplicated from another item.
+
+
+
+
+ Initializes a new instance of .
+
+ Reorderable list adaptor.
+ Zero-based index of item.
+ Indicates if inserted item was duplicated from another
+ item.
+
+
+
+ An event handler which is invoked after new list item is inserted.
+
+ Object which raised event.
+ Event arguments.
+
+
+
+ Arguments which are passed to .
+
+
+
+
+ Gets adaptor to reorderable list container which contains element.
+
+
+
+
+ Gets zero-based index of item which was inserted.
+
+
+
+
+ Initializes a new instance of .
+
+ Reorderable list adaptor.
+ Zero-based index of item.
+
+
+
+ An event handler which is invoked before a list item is removed.
+
+
+ Item removal can be cancelled by setting to
+ true.
+
+ Object which raised event.
+ Event arguments.
+
+
+
+ Base class for custom reorderable list control.
+
+
+
+
+ Invoked to draw list item.
+
+
+ GUI controls must be positioned absolutely within the given rectangle since list
+ items must be sized consistently.
+
+
+ The following listing presents a text field for each list item:
+ wishlist = new
+ List();
+
+ private void OnGUI() { ReorderableListGUI.ListField(wishlist, DrawListItem); }
+
+ private string DrawListItem(Rect position, string value) { // Text fields do not like
+ `null` values! if (value == null) value = ""; return EditorGUI.TextField(position,
+ value) ; } } ]]> ;
+
+ function OnGUI() { ReorderableListGUI.ListField(wishlist, DrawListItem); }
+
+ function DrawListItem(position:Rect, value:String):String { // Text fields do not like
+ `null` values! if (value == null) value = ''; return EditorGUI.TextField(position,
+ value) ; } } ]]>
+
+ Type of item list.
+ Position of list item.
+ The list item.
+ The modified value.
+
+
+
+ Invoked to draw content for empty list.
+
+
+ Callback should make use of GUILayout to present controls.
+
+
+ The following listing displays a label for empty list control:
+ _list;
+
+ private void OnEnable() { _list = new List(); } private void OnGUI() {
+ ReorderableListGUI.ListField(_list, ReorderableListGUI.TextFieldItemDrawer,
+ DrawEmptyMessage) ; }
+
+ private string DrawEmptyMessage() { GUILayout.Label("List is empty!",
+ EditorStyles.miniLabel); } } ]]> ;
+
+ function OnEnable() { _list = new List.(); } function OnGUI() {
+ ReorderableListGUI.ListField(_list, ReorderableListGUI.TextFieldItemDrawer,
+ DrawEmptyMessage) ; }
+
+ function DrawEmptyMessage() { GUILayout.Label('List is empty!', EditorStyles.miniLabel);
+ } } ]]>
+
+
+
+
+ Invoked to draw content for empty list with absolute positioning.
+
+ Position of empty content.
+
+
+
+ Background color of anchor list item.
+
+
+
+
+ Background color of target slot when dragging list item.
+
+
+
+
+ Style for right-aligned label for element number prefix.
+
+
+
+
+ Generate and draw control from state object.
+
+ Reorderable list adaptor.
+ Delegate for drawing empty list.
+ Optional flags to pass into list field.
+
+
+
+ Generate and draw control from state object.
+
+ Position of control.
+ Reorderable list adaptor.
+ Delegate for drawing empty list.
+ Optional flags to pass into list field.
+
+
+
+ Position of mouse upon anchoring item for drag.
+
+
+
+
+ Zero-based index of anchored list item.
+
+
+
+
+ Zero-based index of target list item for reordering.
+
+
+
+
+ Unique ID of list control which should be automatically focused. A value of zero
+ indicates that no control is to be focused.
+
+
+
+
+ Zero-based index of item which should be focused.
+
+
+
+
+ Zero-based index of list item which is currently being drawn.
+
+
+
+
+ Gets zero-based index of list item which is currently being drawn; or a value of -1 if
+ no item is currently being drawn.
+
+
+ Use instead.
+
+
+
+
+ Gets or sets flags which affect behavior of control.
+
+
+
+
+ Gets a value indicating whether add button is shown.
+
+
+
+
+ Gets a value indicating whether remove buttons are shown.
+
+
+
+
+ Occurs after list item is inserted or duplicated.
+
+
+
+
+ Raises event after list item is inserted or duplicated.
+
+ Event arguments.
+
+
+
+ Occurs before list item is removed and allows removal to be cancelled.
+
+
+
+
+ Raises event before list item is removed and provides oppertunity to cancel.
+
+ Event arguments.
+
+
+
+ Initializes a new instance of .
+
+
+
+
+ Initializes a new instance of .
+
+ Optional flags which affect behavior of control.
+
+
+
+ Unique Id of control.
+
+
+
+
+ Visible rectangle of control.
+
+
+
+
+ Width of index label in pixels (zero indicates no label).
+
+
+
+
+ Indicates whether item is currently being dragged within control.
+
+
+
+
+ Indicates if reordering is allowed.
+
+
+
+
+ Prepare initial state for list control.
+
+ Unique ID of list control.
+ Reorderable list adaptor.
+
+
+
+ Indicate that first control of list item should be automatically focused if possible.
+
+ Unique ID of list control.
+ Zero-based index of list item.
+
+
+
+ Draw add item button.
+
+ Position of button.
+ Unique ID of list control.
+ Reorderable list adaptor.
+
+
+
+ Draw remove button.
+
+ Position of button.
+ Indicates if control is visible within GUI.
+ A value of true if clicked; otherwise /c>.
+
+
+
+ Begin tracking drag and drop within list.
+
+ Unique ID of list control.
+ Zero-based index of item which is going to be dragged.
+
+
+
+ Stop tracking drag and drop.
+
+
+
+
+ Gets a value indicating whether item in current list is currently being tracked.
+
+ Unique ID of list control.
+ A value of true if item is being tracked; otherwise /c>.
+
+
+
+ Accept reordering.
+
+ Reorderable list adaptor.
+
+
+
+ Draw list container and items.
+
+ Position of list control in GUI.
+ Unique ID of list control.
+ Reorderable list adaptor.
+
+
+
+ Checks to see if list control needs to be automatically focused.
+
+ Unique ID of list control.
+
+
+
+ Draw additional controls below list control and highlight drop target.
+
+ Position of list control in GUI.
+ Unique ID of list control.
+ Reorderable list adaptor.
+
+
+
+ Cache of container heights mapped by control ID.
+
+
+
+
+ Do layout version of list field.
+
+ Unique ID of list control.
+ Reorderable list adaptor.
+ Position of list container area in GUI (excludes footer area).
+
+
+
+ Draw content for empty list (layout version).
+
+ Callback to draw empty content.
+ Position of list container area in GUI (excludes footer area).
+
+
+
+ Draw content for empty list (layout version).
+
+ Position of list control in GUI.
+ Callback to draw empty content.
+
+
+
+ Correct if for some reason one or more styles are missing!
+
+
+
+
+ Draw layout version of list control.
+
+ Unique ID of list control.
+ Reorderable list adaptor.
+ Delegate for drawing empty list.
+
+
+
+
+
+
+
+
+
+ Draw list control with absolute positioning.
+
+ Position of list control in GUI.
+ Unique ID of list control.
+ Reorderable list adaptor.
+ Delegate for drawing empty list.
+
+
+
+ Draw list control with absolute positioning.
+
+ Position of list control in GUI.
+ Reorderable list adaptor.
+ Delegate for drawing empty list.
+
+
+
+
+
+
+ Content for "Move to Top" command.
+
+
+
+
+ Content for "Move to Bottom" command.
+
+
+
+
+ Content for "Insert Above" command.
+
+
+
+
+ Content for "Insert Below" command.
+
+
+
+
+ Content for "Duplicate" command.
+
+
+
+
+ Content for "Remove" command.
+
+
+
+
+ Content for "Clear All" command.
+
+
+
+
+ Default functionality to handle context command.
+
+
+ Can be used when adding custom items to the context menu: