Alchemy for Unity

Alchemy is an open-source library for Unity that provides advanced inspector and editor-extension capabilities. Compared to other popular libraries, Alchemy distinguishes itself with the following features:

• Open Source: Unlike Odin Inspector, Alchemy is open source.
• Editing NonSerialized Members: Alchemy allows editing of members that are not marked with [SerializeField] or are otherwise non-serialized.
• SerializeReference Support: Full support for [SerializeReference.
• Serialization Extension: Alchemy can extend serialization using partial types (whereas Odin requires inheritance from dedicated base types).
• UI Toolkit Support: Native support for Unity's UI Toolkit.
• EditorWindow & Hierarchy Extensions: Provides extensions for both EditorWindow and the Unity Hierarchy, which are not available in NaughtyAttributes, Tri Inspector, or Odin Inspector.
• Button Attributes: Supports button attributes with arguments, unlike NaughtyAttributes or Unity Editor Toolbox which only support them without arguments.

Alchemy uses a source generator to implement Unity's ISerializationCallbackReceiver on any type marked with the [AlchemySerialize] attribute.

The Process:

1. Collection: The source generator identifies all fields marked with [AlchemySerializeField].
2. JSON Conversion: It uses the Unity.Serialization package to convert these fields into JSON data.
3. Object Reference Handling: Since UnityEngine.Object instances (like GameObject, Texture, etc.) cannot be represented directly in JSON, Alchemy extracts them into a separate list of UnityEngine.Object references and writes their indices into the JSON string.
4. Lifecycle Hooks:
   • OnBeforeSerialize: Clears the reference list, converts the marked fields to JSON, and populates the reference list.
   • OnAfterDeserialize: Parses the JSON and reconstructs the fields using the stored object references.

Performance Note: Using [AlchemySerializeField] introduces serialization and deserialization overhead. You should only use it for fields that Unity's native serialization cannot handle (e.g., certain complex collections or types).

using UnityEngine;
using Alchemy.Serialization;

[AlchemySerialize]
public partial class MySerializedClass : MonoBehaviour
{
    // This field will be handled by Alchemy's custom serialization
    [AlchemySerializeField, NonSerialized]
    public Dictionary<string, GameObject> myDictionary = new();
}

Instead of inheriting from EditorWindow, inherit from AlchemyEditorWindow to use Alchemy attributes (like [Button], [HorizontalGroup], or [ListViewSettings]) to build your tool's UI.

Data for windows inheriting from AlchemyEditorWindow is automatically saved as JSON in the project's ProjectSettings folder.

using UnityEditor;
using UnityEngine;
using Alchemy.Editor;
using Alchemy.Inspector;
using System.Collections.Generic;

public class EditorWindowExample : AlchemyEditorWindow
{
    [MenuItem("Window/Example")]
    static void Open()
    {
        var window = GetWindow<EditorWindowExample>("Example");
        window.Show();
    }
    
    [Serializable]
    [HorizontalGroup]
    public class DatabaseItem
    {
        [LabelWidth(30f)]
        public float foo;
    }

    [ListViewSettings(ShowAlternatingRowBackgrounds = AlternatingRowBackground.All, ShowFoldoutHeader = false)]
    public List<DatabaseItem> items;

    [Button, HorizontalGroup]
    public void Button1() { }
}

By default, any editor window derived from AlchemyEditorWindow automatically saves its data as JSON in the project's ProjectSettings folder.

To change where the data is stored or how it is serialized, you must override the following three methods in your class:

1. GetWindowDataPath(): Return a string representing the custom destination path for the data.
2. LoadWindowData(string dataPath): Implement the logic to read and apply data from the specified path.
3. SaveWindowData(string dataPath): Implement the logic to serialize and write data to the specified path.

using UnityEditor;
using UnityEngine;
using Alchemy.Editor;

public class EditorWindowExample : AlchemyEditorWindow
{
    [MenuItem("Window/Example")]
    static void Open()
    {
        var window = GetWindow<EditorWindowExample>("Example");
        window.Show();
    }

    protected override string GetWindowDataPath()
    {
        // Return the path where the data will be saved
        return "Assets/MyCustomPath/window_data.json";
    }

    protected override void LoadWindowData(string dataPath)
    {
        // Implement the loading process here
        ...
    }

    protected override void SaveWindowData(string dataPath)
    {
        // Implement the saving process here
        ...
    }
}