SaintsField Documentation

Unity does not support enums with a long or ulong base type. You can bypass this limitation by applying [SaintsSerialized] to the enum field.

Requirements:

1. The containing MonoBehaviour/ScriptableObject must be partial.
2. The enum field must have the [SaintsSerialized] attribute.
3. If the enum is used inside a normal class/struct, that class/struct must also be partial.

EnumToggleButtons is fully supported with these enums.

public partial class MyBehavior: MonoBehaviour
{
    [Flags]
    public enum TestULongEnum: ulong
    {
        None = 0,
        First = 1,
        Second = 1 << 1,
    }

    [SaintsSerialized] public TestULongEnum ULongEnumPub;
    [SaintsSerialized, EnumToggleButtons] public TestULongEnum ULongEnumPubBtns;
}

SaintsField provides tools for Unity AI Navigation (NavMesh) in the SaintsField.AiNavigation namespace. These are only active if the AI Navigation package is installed.

To disable these components, add the macro SAINTSFIELD_AI_NAVIGATION_DISABLED to your project.

Available Attributes:

• [NavMeshAreaMask]: A picker to select a NavMesh area bit mask for an integer field.
• [NavMeshArea]: A picker to select a NavMesh area for string or integer fields, with support for bit masks or single area values.

using SaintsField.AiNavigation;

[NavMeshAreaMask]
public int areaMask;

[NavMeshArea]
public int areaSingleMask;

The EMode enum is used to determine the current context of the Unity Editor or the target object:

• EMode.Edit: Editor is not playing.
• EMode.Play: Editor is playing.
• EMode.InstanceInScene: Target is a prefab placed in a scene.
• EMode.InstanceInPrefab: Target is inside a prefab (but not the root).
• EMode.Regular: Target is at the top root of a prefab.
• EMode.Variant: Target is a variant prefab root.
• EMode.NonPrefabInstance: Target is not a prefab.
• EMode.PrefabInstance: Alias for InstanceInPrefab | InstanceInScene.
• EMode.PrefabAsset: Alias for Variant | Regular.

In addition to standard axes like ancestor::, ancestor-or-self::, parent::, and parent-or-self::, Saints XPath provides specialized axes to target Unity-specific resources:

• ancestor-inside-prefab::: Traverses ancestors within a prefab boundary.
• ancestor-or-self-inside-prefab::: Traverses ancestors or self within a prefab boundary.
• parent-inside-prefab::: Traverses the parent within a prefab boundary.
• parent-or-self-inside-prefab::: Traverses the parent or self within a prefab boundary.
• scene::: Targets the scene root node.
• prefab::: Targets the prefab root node.
• resources::: Targets resources.
• asset::: Targets AssetDatabase resources.

SaintsField provides a suite of attributes in the SaintsField.Spine namespace that improve upon standard Unity Spine attributes. These attributes support searching, are compatible with the Auto Validator tool, and work with Unity's default right-click context menu.

Most attributes allow you to specify a skeletonTarget (a SkeletonData, SkeletonRenderer, component, or GameObject with a SkeletonRenderer) to define the source of the data. If null, it defaults to GetComponent<SkeletonRenderer>() on the current object.

using SaintsField.Spine;

// Example of targeting a specific field as the source
public SkeletonAnimation _spine;
[SpineAnimationPicker(nameof(_spine))] private AnimationReferenceAsset animationRef;

SaintsField allows you to inspect interfaces and collections like Dictionary<TKey, TValue> or IReadOnlyDictionary<TKey, TValue> directly in the Unity Inspector using the [ShowInInspector] attribute. For interfaces, the inspector will automatically show an object picker or a field editor depending on whether the underlying type is a UnityObject or a general class/struct.

public class GeneralDummyClass: IDummy
{
    public string GetComment() => "DummyClass";
    public int MyInt { get; set; }
    public int GenDumInt;
    public string GenDumString;
}

[ShowInInspector] private static IDummy _dummy;

[Button]
private void DebugDummy() => Debug.Log(_dummy);

You can create hierarchical dropdown menus by nesting Dropdown<T> objects within each other. A Dropdown<T> item can either be a direct value or a group containing IEnumerable<Dropdown<T>> children. You can also insert separators using Dropdown<T>.Separator().

[Dropdown(nameof(AdvDropdown))] public int drops;

public Dropdown<int> AdvDropdown()
{
    return new Dropdown<int>("First Half")
    {
        new Dropdown<int>("Monday", 1, icon: "eye.png"),
        new Dropdown<int>("Tuesday", 2),
    };
}

Saints XPath is a subset of the standard XPath language designed for Unity. It uses a step-based structure to traverse nodes.

Basic Structure: step/step/step/...

A step follows the pattern: axisname::nodetest[predicate]

Key Syntax Rules:

• Axes and Attributes: You can select attributes using @. For example, name@attribute is valid, but you cannot mix :: and @ in the same segment (e.g., ancestor::name@attr is invalid; use ancestor::name/@attr instead).
• Predicates: Predicates are enclosed in square brackets []. They can filter by attributes using @, but they do not select the attribute itself.
• Predicates Requirement: There must be a space before the predicate (e.g., node [@attr=val]).
• Limitations: Complex XPath features like forward/backward assertions (e.g., name[ancestor::note()[@attr=1]]) are not supported.