UMU

1. Requirements and installation #

Requirements

• Unity 6000.3 or newer (developed and tested on 6000.3.20f1)
• Unity packages: com.unity.ugui, com.unity.inputsystem, com.unity.nuget.newtonsoft-json (they are not bundled, to avoid duplicates)

Installation

1. Import the UMU package through Assets > Import Package > Custom Package (or the Package Manager "My Assets" tab).
2. Wait for the compilation to finish. All UMU files live under Assets/UMU.
3. Open the UMU menu in the Unity menu bar. All editor tools are listed there.

Updating

Delete the Assets/UMU folder before importing a newer version, so no stale files remain. Keep your own settings assets outside the UMU folder, or back them up first.

How UMU is delivered

The code of UMU is delivered as two precompiled, obfuscated assemblies: UMU.dll (runtime) in Assets/UMU and UMU.Editor.dll (editor only) in Assets/UMU/Editor. The public API is intact, so you can call every class and method documented here, and you can derive from the classes that are meant to be extended (for example GuiManager, GuiPanel). Prefabs, scenes and ScriptableObjects reference the scripts inside the DLLs and work as in a source project.

2. Package contents #

The UMU editor menu contains one entry per tool.

3. GUI Manager #

The GUI Manager module opens, closes and tracks full screen panels and layered popups, keeps a navigation history, locks buttons during transitions, and ships a set of Unity UI selectables, anchoring and safe area helpers, and editor tools.

All runtime types live in the UMU.GuiManager namespace unless noted otherwise. Inside a namespace that starts with UMU, the simple name GuiManager resolves to the namespace, so write UMU.GuiManager.GuiManager there. In the global namespace, using UMU.GuiManager; is enough.

Core concepts used throughout this reference:

• Panel: a full screen screen. Only one panel is current at a time. Opening a panel closes the current one and records it in the history.
• Popup: a window that opens on top of the current panel. Several popups can be open at once, ordered by layer.
• Panel id: the string used to open a panel or popup. It is the path of the prefab inside a Resources folder, without extension (for example Demo Popup 1). The Settings window can generate a GuiPanels constants class with one constant per prefab.
• Messages: an optional Dictionary<object, object> passed to OpenPanel or OpenPopup and delivered to the panel's OnPreOpen.

Editor menu and window reference #

Menu overview #

The GameObject > UMU_Gui items are listed in that order in the menu (Button, Toggle, Slider, Scrollbar, Dropdown, Input Field).

Settings window (UMU > Gui Manager > Settings) #

Window title: "Gui Manager Settings". The window has a fixed size of 800 x 135 pixels. The values are stored in the Gui Manager plugin save file.

Generated constants (GuiPanels):

• Whenever a prefab inside the prefab folder is imported, deleted or moved, the constants script is regenerated and the Console logs "Created all gui constans".
• The script contains public static class GuiPanels with one public const string per prefab found in the folder (including sub folders).
• Constant names are derived from the prefab path: lower case, spaces and path separators replaced by underscores, characters other than letters, digits and underscores removed, and a panel_ prefix added when the name does not start with a letter (for example Demo Popup 1 becomes demo_popup_1).
• Constant values are the path after the last Resources/ folder, without extension.
• Any other file named GuiPanels.cs under Assets that is not inside the configured script folder is deleted when the script is generated.
• Nothing is generated while the prefab folder path is empty.

Panel Overview window (UMU > Gui Manager > Panel Overview) #

Window title: "GUI Panel Overview". It shows a grid of every prefab in the project whose root object carries a GuiPanel component, sorted by name.

Panel Optimizer (UMU > Gui Manager > Panel Optimizer) #

Scans every prefab in the project that has a GuiPanel on the root or on any child. The result is written to the Console as one report. Nothing is modified.

For each such prefab the report is printed when the prefab has any issue or any Graphic with Raycast Target on. Each printed entry contains the asset path and a line "graphics: N, raycastTarget on: N, masks: N" (masks counts Mask and RectMask2D components), followed by the issues:

The final line is "Panel Optimizer done. prefabs: N, issues: N, applied fixes: N".

Panel Optimizer - Apply Safe Fixes #

Runs the same scan and also changes the prefabs, then saves the assets:

• Graphics reported as "non-interactive Graphic with raycastTarget on" get Raycast Target turned off. In this mode they are not listed as issues, only counted in "fixed: N" for the prefab.
• Target Graphics reported as "unclickable" get Raycast Target turned on (the finding is still listed).
• The "GuiPanel without firstSelected" finding is only reported, never fixed.

The report line "applied fixes" shows the total number of changed Graphics.

Replace Unity UI To UMU Gui #

Works on the GameObject selected in the Hierarchy (Selection.activeGameObject) and on all of its children. With nothing selected it logs the error "No selected gameObject!".

It converts these Unity UI components to their UMU counterparts, copying the component values and keeping the GameObject:

Converted GameObjects are renamed to "<menu item name>_<old name>", for example "Gui Button_Button". Components that are already UMU Gui components are kept.

GameObject > UMU_Gui creators #

Each item runs Unity's own GameObject > UI > <type> command, then converts the new object to the UMU Gui component and names it.

Notes:

• Select a GameObject first (normally the panel or a container under a Canvas). The new object is parented to the selected object.
• All of the Inspector fields of the Unity component are kept, because the Gui components derive from the Unity components.

Inspector tools that belong to the editor module #

Inspector reference #

Unity shows serialized fields with their nicified names (for example blockInputDuringTransitions is shown as "Block Input During Transitions"). Components without a custom Inspector use these default labels. Fields marked [HideInInspector] are not listed unless the table says that the custom Inspector shows them.

GuiManager #

Add it to one GameObject in the scene. There is no custom Inspector. GuiManager.Instance finds the first manager in the scene and is also set in Awake.

Runtime behaviour worth knowing:

• Opening a panel with the id of the current panel, or with an empty id, does nothing. If a panel switch is already running, the new request is queued (only the latest queued request is kept) and starts when the running switch ends.
• The history records the panel that is left. Opening a panel that is already in the history cuts the history back to the entry before it. BackToPreviousPanel() opens the last history entry; with an empty history it only fires onBackPresedOnEmptyHistory.
• A popup opens immediately only if its layer is higher than the layer of every open popup that is not Always On Top (or it is Always On Top, or Dynamic Popup Layers applies). Otherwise it is queued and opened when a popup closes (the queued popup with the highest layer first).
• The popup is placed at local z = 0.001 x layer (Always On Top popups use 1,000,000 + layer). Children of the panel and popup roots are re-sorted by active state and z after each open.
• While a popup is open, the buttons (Lock) of the panel below and of lower layer popups are disabled. When popups close, the buttons of the top popup, or of the current panel when no popup is left, are restored.
• Back input: in the Editor and on Android the Escape key (the Android back button) is handled each frame, unless busy. With open popups it closes the top popup, otherwise it goes back to the previous panel. A panel with Allow Back Input off ignores it. SetBackInputChecker(false) disables the check.
• Panels are loaded with Resources.Load from their id when they are not registered yet. RegisterPanel registers an already instantiated panel instead.

Public events (plain Action fields, not shown in the Inspector): onBackPresedOnEmptyHistory, onOpenedPanel(string), onClosedPanel(string), onOpenedPopup(string), onClosedPopup(string), onPreOpenPanel(string), onPreClosePanel(string), onPreOpenPopup(string), onPreClosePopup(string).

GuiPanel (abstract base of every panel and popup) #

GuiPanel requires an Image and a CanvasRenderer. It has a custom Inspector: the default fields first, then the sections below.

Fields that exist but are not in the Inspector: id (string, assigned by the manager), result (object, see the popup result example), onClickSelectableItem, onPanelChangeProcessIsOver, onCustomTransition.

Lifecycle order when the manager opens a panel or popup (the manager level event is raised first):

1. PrepareOpen() (same frame as the activation, before a one frame wait).
2. Manager event onPreOpenPanel or onPreOpenPopup, then OnPreOpen(messages), then all buttons are locked.
3. StartOpenedAnimation(); the lifecycle waits until onPanelChangeProcessIsOver is raised (when Has Change Process is on).
4. Manager event onOpenedPanel or onOpenedPopup, then OnOpened().
5. The lifecycle waits while the previous panel is still closing, then the buttons are restored and First Selected is selected.

Closing: manager event onPreClosePanel or onPreClosePopup, OnPreClose(), buttons locked, StartClosedAnimation(), wait, OnWillClosed(), manager event onClosedPanel or onClosedPopup, then the GameObject is deactivated.

Nested type InspectorEvent (shown as Inspector Events):

An override that does not call the base method does not raise the matching Inspector event.

Nested type PanelChangeProcessData (one entry of Panel Change Process Settings, shown as a foldout):

An entry applies only when the manager's Use Panel Pair Transition Settings is on. Only the Exists and Waiting values of the entry take part in the decision whether the manager waits for the closing panel.

Nested type GuiLayer: a serializable wrapper of an int value with implicit conversion from and to int, the arithmetic operators +, -, *, and the comparison operators.

Public API of GuiPanel: ActivateButtons(), DeactivateButtons(), SelectableItemReInitialize<T>(T selectableObject, bool interactable = true) (registers or re-registers a Gui selectable that was added at runtime; the panel collects the Gui selectables in its children when the manager registers it), GetChangeProcessSettings(string otherPanelId).

GuiTweenPanel #

Requires a GuiScreenTransition on the same GameObject. It adds no serialized fields of its own; the Inspector shows the GuiPanel fields. It starts the open transition in StartOpenedAnimation and the close transition in StartClosedAnimation, and applies the hidden start state in PrepareOpen so that the finished window is never drawn for one frame. When Replace Builtin Transition is on and a custom transition is subscribed, PrepareOpen does nothing and only the custom transition runs.

GuiTweenControlledPanel and GuiAnimatorControlledPanel #

Two alternative ready made panels (both derive from GuiPanel).

GuiTweenControlledPanel (no Animator, no separate transition component):

TweenType values: None (no effect), Fade (alpha), SlideFromLeft, SlideFromRight, SlideFromTop, SlideFromBottom (moves from one panel width or height away to the original position), Scale (from almost zero to the original scale), FadeAndScale. A CanvasGroup is added automatically when missing. With Has Change Process off no effect is played.

GuiAnimatorControlledPanel (requires an Animator):

GuiScreenTransition #

Fade, slide or scale transition driven through a GuiTweenPanel. It adds a CanvasGroup to the GameObject when missing and remembers the anchored position and scale found in Awake as the resting state.

Style values and their start state when opening (closing plays the same motion in reverse; every style except None also fades the alpha between 0 and 1):

After a close the alpha is 0 and the position and scale are restored. If the GameObject is inactive when a transition is requested, the end state is applied and the completion callback fires immediately.

Public members: EffectiveMode (the resolved engine), PlayOpen(Action), PlayClose(Action), PrepareOpen(), KillTransition() (stops a running transition without raising its completion callback).

Project setting (GuiSettings): GuiSettings.Current.transitionMode (default Builtin) can also be assigned from code to override the engine at runtime.

GuiButton and the other Gui selectables #

All Gui selectables derive from the Unity UI component of the same name and keep every Unity Inspector field (Interactable, Transition, Target Graphic, Navigation, events and so on). Their custom Inspectors are the Unity editors of the base components. When the panel is registered it initializes them: they report user changes to the panel (which forwards them to GuiManager.OnClickSelectableItem), and the panel locks and restores them (interactable set to false during transitions and below popups; restored to the value interactable had at initialization).

GuiButton adds three Inspector fields and runs a panel action on click:

SpecialFunction values: None (does nothing besides reporting the click), OpenPanel (GuiManager.Instance.OpenPanel(panel.id)), BackToPreviousPanel, OpenPopup (OpenPopup(popup.id)), ClosePopup (ClosePopup(popup.id)), CloseAllPopup, CloseTopPopup.

GuiEventSystem derives from Unity's EventSystem and adds no fields.

SafeAreaFitter #

Keeps a RectTransform inside the device safe area (notches, camera cutouts, home indicator) by setting its anchors. Requires a RectTransform. Apply it to a full stretch container, and put the interactive content inside it.

Apply() can be called from code.

OverrideAnchor #

Positions and sizes a RectTransform relative to the edges of other RectTransforms (world space edge positions plus an offset). Requires a RectTransform. The custom Inspector shows a "General" section, and a "Normal Anchor" or "Advanced Anchor" section depending on Type.

Normal Anchor (Type = Normal). Nothing is applied while Target is empty. After placing the four edges, the size is set to the distance between the right and left, and the top and bottom positions.

Preset buttons (Normal Anchor section): Stretch, Top-Left, Top-Right, Bottom-Left, Bottom-Right, Center. A preset sets Type to Normal, writes the four anchor choices, and writes the four offsets. Stretch follows the target's top, bottom, left and right edges with zero offsets. The other presets pin all four sides to the same target edge (or to the target center for Center) and compute the offsets from the current width and height of the element. A preset can be undone with Undo.

Advanced Anchor (Type = Advanced). Each side has its own target, anchor choice and offset, with the same choices and defaults as Normal (Top, Right, Bottom and Left, each as: target, anchor, offset). A side without a target is left unchanged. The height is set only when both Top and Bottom have targets, and the width only when both Left and Right have targets.

ApplyAnchorSettings() can be called from code.

GuiLayerFollower #

Keeps the Unity sorting order of this object and its children in step with the GuiPanel layer found in a parent. Attach it to particle effects or nested canvases inside a panel or popup prefab.

GuiObjectPlatformChecker (namespace UMU.Platform) #

Shows or hides a GameObject depending on the platform, in Awake.

EnabledPlatformTypes values: All (always matches), Editor, Iphone, Android, AndroidTv. PreConditionLogic values: None, DebugModeActive, DebugModeInactive. The Android and Android TV platforms are told apart at runtime, so Android does not match a TV device.

GuiCamera #

GuiEventSystem #

Derives from Unity's EventSystem. It has no fields of its own.

Demo behaviours (Demo folder) #

The demo panels (DemoMainMenuPanel, DemoPanel1 to DemoPanel3, DemoPopup1 to DemoPopup4) derive from DemoProjectPanel or DemoProjectPopup, which derive from GuiTweenPanel. They add no fields. DemoGuiManager derives from GuiManager and shows the static Instance pattern.

Inheritance guide #

Which members can be overridden #

Members of GuiPanel and its derived panels:

Members of GuiTweenPanel: PrepareOpen() is protected internal override, StartOpenedAnimation() and StartClosedAnimation() are protected override, and can be overridden again.

Members of GuiAnimatorControlledPanel: TestAnimation(Action finished) and WaitForAnimToFinish(string animationStateName, Action finished) are protected virtual coroutines.

Members of GuiManager:

Deriving from GuiPanel #

A direct subclass must implement both animation methods. The lifecycle sets panelChangeProcessing to true, calls your Start...Animation, and waits until onPanelChangeProcessIsOver is invoked (when Has Change Process is on). Invoke it exactly once, either at the end of an animation or immediately when there is nothing to animate.

using System.Collections;
using System.Collections.Generic;
using UMU.GuiManager;
using UnityEngine;

public class FadePanel : GuiPanel
{
    public float duration = 0.3f;

    private CanvasGroup group;
    private string title;

    private CanvasGroup Group
    {
        get
        {
            if (group == null)
                group = GetComponent<CanvasGroup>();

            if (group == null)
                group = gameObject.AddComponent<CanvasGroup>();

            return group;
        }
    }

    // Hidden start state, applied when the panel is activated, before the first visible frame.
    protected override void PrepareOpen()
    {
        base.PrepareOpen();
        Group.alpha = 0f;
    }

    protected override void OnPreOpen(Dictionary<object, object> messages)
    {
        base.OnPreOpen(messages); // raises the On Pre Open inspector event

        title = null;

        if (messages != null && messages.TryGetValue("title", out object value))
            title = value as string;
    }

    protected override void OnOpened()
    {
        base.OnOpened();
        Debug.Log("Opened with title: " + title);
    }

    protected override void OnPreClose()
    {
        base.OnPreClose();
    }

    protected override void OnWillClosed()
    {
        base.OnWillClosed();
    }

    protected override void StartOpenedAnimation()
    {
        StartCoroutine(Fade(0f, 1f));
    }

    protected override void StartClosedAnimation()
    {
        StartCoroutine(Fade(1f, 0f));
    }

    private IEnumerator Fade(float from, float to)
    {
        float elapsed = 0f;

        while (elapsed < duration)
        {
            elapsed += Time.unscaledDeltaTime;
            Group.alpha = Mathf.Lerp(from, to, Mathf.Clamp01(elapsed / duration));
            yield return null;
        }

        Group.alpha = to;
        onPanelChangeProcessIsOver(); // exactly once, ends the transition
    }
}

A panel with no animation:

using UMU.GuiManager;

public class InstantPanel : GuiPanel
{
    protected override void StartOpenedAnimation()
    {
        onPanelChangeProcessIsOver();
    }

    protected override void StartClosedAnimation()
    {
        onPanelChangeProcessIsOver();
    }
}

Deriving from GuiTweenPanel #

GuiTweenPanel already plays the GuiScreenTransition and implements both animation methods. Override only the hooks you need. Keep the base calls so the transition and the inspector events keep working.

using System.Collections.Generic;
using UMU.GuiManager;
using UnityEngine;
using UnityEngine.UI;

public class ShopPanel : GuiTweenPanel
{
    public Text coinsLabel;

    protected override void PrepareOpen()
    {
        base.PrepareOpen();
        // refresh content here, before the first visible frame
    }

    protected override void OnPreOpen(Dictionary<object, object> messages)
    {
        base.OnPreOpen(messages);

        if (coinsLabel != null && messages != null && messages.TryGetValue("coins", out object coins))
            coinsLabel.text = coins.ToString();
    }

    protected override void OnOpened()
    {
        base.OnOpened();
        // the open transition has finished
    }

    protected override void OnPreClose()
    {
        base.OnPreClose();
    }

    protected override void OnWillClosed()
    {
        base.OnWillClosed();
    }

    // Optional: extend the open transition. Keep the base call, it ends the transition.
    protected override void StartOpenedAnimation()
    {
        base.StartOpenedAnimation();
    }
}

The panel prefab needs a GuiScreenTransition on the same GameObject (added automatically by RequireComponent).

Custom transitions (onCustomTransition and replaceBuiltinTransition) #

A host script can attach its own animation (for example a DOTween sequence or a coroutine) to any panel that calls RunTransition, which GuiTweenPanel, GuiAnimatorControlledPanel and your own panels can do. The subscriber receives (bool opening, Action finished) and must call finished() once when its animation is over. Until then the panel counts as busy (GuiManager.IsBusy stays true and the transition blocker stays visible).

• With replaceBuiltinTransition off (default), the built-in and the custom transition run in parallel and the lifecycle waits for both.
• With replaceBuiltinTransition on, only the custom transition runs.

Using RunTransition in your own panel:

using System;
using System.Collections;
using UMU.GuiManager;
using UnityEngine;

public class ScalePanel : GuiPanel
{
    protected override void StartOpenedAnimation()
    {
        // playBuiltin receives the callback to invoke when the built-in part ends.
        RunTransition(true, finished => StartCoroutine(Scale(0f, 1f, finished)));
    }

    protected override void StartClosedAnimation()
    {
        RunTransition(false, finished => StartCoroutine(Scale(1f, 0f, finished)));
    }

    private IEnumerator Scale(float from, float to, Action finished)
    {
        float elapsed = 0f;

        while (elapsed < 0.25f)
        {
            elapsed += Time.unscaledDeltaTime;
            transform.localScale = Vector3.one * Mathf.Lerp(from, to, elapsed / 0.25f);
            yield return null;
        }

        transform.localScale = Vector3.one * to;
        finished();
    }
}

Subscribing from a host script. Put it on an object that stays active (not on the panel itself, because a closed panel is deactivated):

using System;
using System.Collections;
using UMU.GuiManager;
using UnityEngine;

public class ShopPanelDecor : MonoBehaviour
{
    public string panelId = "Shop";
    public RectTransform title;

    private GuiPanel panel;

    private void Start()
    {
        panel = GuiManager.Instance.GetPanelWithId(panelId); // loads the panel when needed

        if (panel == null)
            return;

        panel.replaceBuiltinTransition = true; // the custom transition owns the animation
        panel.onCustomTransition += Play;
    }

    private void OnDestroy()
    {
        if (panel != null)
            panel.onCustomTransition -= Play;
    }

    private void Play(bool opening, Action finished)
    {
        StartCoroutine(Run(opening, finished));
    }

    private IEnumerator Run(bool opening, Action finished)
    {
        float elapsed = 0f;
        float from = opening ? 0f : 1f;
        float to = opening ? 1f : 0f;

        while (elapsed < 0.4f)
        {
            elapsed += Time.unscaledDeltaTime;
            title.localScale = Vector3.one * Mathf.Lerp(from, to, elapsed / 0.4f);
            yield return null;
        }

        title.localScale = Vector3.one * to;
        finished(); // required, exactly once
    }
}

Deriving from GuiManager #

The static Instance pattern hides the base property and casts the protected instance field. instance is assigned in Awake, so use Instance from Start onward or from other objects' Start.

using System.Collections;
using System.Collections.Generic;
using UMU.GuiManager;
using UnityEngine;

public class MyGuiManager : GuiManager
{
    public static new MyGuiManager Instance => (MyGuiManager)instance;

    // Called from Awake. Replaces overriding Awake, which is not virtual.
    protected override void Initializer()
    {
        base.Initializer(); // SetupInputModules, external lists, preloading
        Debug.Log("MyGuiManager initialized");
    }

    protected override void SetupInputModules()
    {
        base.SetupInputModules();
    }

    protected override void Start()
    {
        base.Start(); // opens the initially open panel
    }

    protected override void Update()
    {
        base.Update(); // back input, transition blocker, selection watcher
    }

    protected override void OnDestroy()
    {
        base.OnDestroy();
    }

    protected override void CheckBackInput()
    {
        base.CheckBackInput();
    }

    protected override void OnClickSelectableItem(IGuiSelectable selectable)
    {
        base.OnClickSelectableItem(selectable);
        // for example, play a click sound
    }

    // Panel events. Keep the base call, it raises the public Action events.
    protected override void OnPreOpenPanel(string id) { base.OnPreOpenPanel(id); }
    protected override void OnPreClosePanel(string id) { base.OnPreClosePanel(id); }
    protected override void OnOpenedPanel(string id) { base.OnOpenedPanel(id); }
    protected override void OnClosedPanel(string id) { base.OnClosedPanel(id); }

    // Popup events.
    protected override void OnPreOpenPopup(string id) { base.OnPreOpenPopup(id); }
    protected override void OnPreClosePopup(string id) { base.OnPreClosePopup(id); }
    protected override void OnOpenedPopup(string id) { base.OnOpenedPopup(id); }
    protected override void OnClosedPopup(string id) { base.OnClosedPopup(id); } // keeps popup callbacks and button locking working

    // The default loader uses Resources.Load with the panel id. You can wrap it, for example to log failures.
    protected override T LoadPrefab<T>(Transform root, string id, Dictionary<string, T> loaded)
    {
        T panel = base.LoadPrefab(root, id, loaded);

        if (panel == null)
            Debug.LogWarning("Panel prefab not found: " + id);

        return panel;
    }
}

Loading panels from a source other than Resources (Addressables, asset bundles). Init() is internal, so a LoadPrefab override cannot initialize a panel it instantiated itself. Use RegisterPanel instead, before the first OpenPanel or OpenPopup of that id. Do not call RegisterPanel from inside LoadPrefab: the manager subscribes its panel handlers again after LoadPrefab returns, so they would be subscribed twice.

RegisterPanel(string id, GuiPanel panel, bool isPopup = false) parents the instance under the panel or popup root, initializes it, subscribes the manager events, deactivates it, and returns it. If the id is already registered, the existing panel is returned and the new instance is not used (destroy it yourself).

using System.Collections;
using UMU.GuiManager;
using UnityEngine;

public class MyGuiManager2 : GuiManager
{
    public static new MyGuiManager2 Instance => (MyGuiManager2)instance;

    // Asynchronous loading, then registration, then opening.
    // The same shape works with Addressables: replace the load step with the
    // loaded prefab from your Addressables request.
    public IEnumerator LoadAndOpen(string id, string resourcesPath, bool isPopup)
    {
        if (!(isPopup ? IsLoadedPopup(id) : IsLoadedPanel(id)))
        {
            ResourceRequest request = Resources.LoadAsync<GuiPanel>(resourcesPath);
            yield return request;

            GuiPanel prefab = request.asset as GuiPanel;

            if (prefab == null)
                yield break;

            RegisterPanel(id, Instantiate(prefab), isPopup);
        }

        if (isPopup)
            OpenPopup(id);
        else
            OpenPanel(id);
    }
}

Start it with StartCoroutine(MyGuiManager2.Instance.LoadAndOpen("Shop", "Panels/Shop", false)); from any MonoBehaviour. Without any code, the External Panels and External Popups lists register prefabs by their prefab name at startup.

Opening, closing, messages and popup results #

Messages are an arbitrary Dictionary<object, object>; they reach OnPreOpen(messages) and the On Pre Open inspector event.

using System.Collections.Generic;
using UMU.GuiManager;
using UnityEngine;

public class MenuController : MonoBehaviour
{
    public void OpenShop()
    {
        var messages = new Dictionary<object, object>
        {
            { "coins", 120 },
            { "title", "Shop" }
        };

        GuiManager.Instance.OpenPanel("Shop", messages);
    }

    public void Back()
    {
        GuiManager.Instance.BackToPreviousPanel();
    }

    public void AskQuit()
    {
        // The callback runs when the popup has closed. It receives the popup panel;
        // read panel.result for the value the popup stored before closing.
        GuiManager.Instance.OpenPopup("ConfirmQuit", popup =>
        {
            bool confirmed = popup.result is bool answer && answer;

            if (confirmed)
                Application.Quit();
        });
    }
}

The popup stores its result and closes itself with its own id:

using UMU.GuiManager;

public class ConfirmQuitPopup : GuiTweenPanel
{
    // Assign these methods to the OnClick events of the buttons.
    public void Yes()
    {
        result = true;
        GuiManager.Instance.ClosePopup(id);
    }

    public void No()
    {
        result = false;
        GuiManager.Instance.ClosePopup(id);
    }
}

Notes:

• There is one pending onClosed callback per popup id; opening the same popup again with a new callback replaces the previous one. The callback runs once, and the manager does not change result itself.
• OpenPopup(id, messages) and OpenPopup(id, onClosed, messages) are the two overloads. Pass onClosed as a lambda or method group; passing a bare null as the second argument is ambiguous.
• Other calls: ClosePopup(id), CloseTopPopup(), CloseAllPopup(bool removeAllRequestToOpenPopups = false), CloseCurrentPanel(), GetCurrentPanelId(), GetPreviousPanelId(), GetTopPopupId(), GetOpenedPopupIds(), HasOpenPopup, OpenPopupCount, IsBusy, PreloadPanel(id), PreloadPopup(id), SetInitiallyOpen(panelId, preloadPanelIds, preloadPopupIds) (call before the manager's Start for the initial panel).
• A Gui selectable created at runtime inside a loaded panel is not known to the panel. Register it with panel.SelectableItemReInitialize(selectableComponent).
• Closing a popup from a derived GuiPanel uses GuiManager.Instance.ClosePopup(id); id is assigned by the manager when the panel is loaded or registered.

4. Audio #

The Audio module provides a pooled SFX player, a dual-source BGM player with crossfade, a voice channel, a dedicated UI channel, AudioMixer routing, linear to decibel volume control, persisted volume and mute state, and platform pause handling. Sounds are played by string id from an AudioDatabase, so game code never binds AudioClip assets directly.

Editor menu and window reference #

UmuMainMixer layout. The Master group contains four child groups: BGM, SFX, Voice, UI. The snapshot is named Normal. The BGM group has a Duck Volume effect (Threshold -20, Ratio 4, Attack Time 100, Release Time 500, Make-up Gain 0, Knee 10). The Voice group has a Send to the duck effect at 0 dB and the SFX group has a Send at -6 dB, so voice and SFX duck the music. Five volume parameters are exposed: MasterVolume, BGMVolume, SfxVolume, VoiceVolume, UIVolume. The mixer is built through Unity internal editor classes (reflection). If the Duck Volume effect cannot be created, the mixer is built without ducking and a warning is logged.

Audio import automation. AudioImportPostprocessor applies the first rule of the AudioImportConfig whose path prefix matches the imported audio file. It runs only on the first import of a file (when Unity has no stored importer settings yet). A file that was already imported keeps its settings. The first AudioImportConfig asset found in the project is used.

[AudioId] drawer. String fields marked [AudioId(channel)] are drawn as a dropdown filled from every AudioDatabase asset in the project (cached for 2 seconds). The channel selects the list: BGM lists BGM ids, Voice lists voice ids, every other channel lists SFX ids. The first entry is (none) and stores an empty string. A stored id that no database defines stays visible as <id> (missing). When no database defines any id for the channel, the plain text field is shown with an info box "No AudioDatabase ids found".

[AudioCategory] drawer. String fields marked [AudioCategory] are drawn as a dropdown of the categories list of the owning AudioDatabase. An empty list falls back to AudioCategories.Defaults. A stored value that is not in the list is shown as <value> (missing) (or (none) when empty).

Inspector reference #

AudioManager #

Persistent singleton (AudioManager.Instance). Placing it in the first scene is optional: if no instance exists after the first scene has loaded, a GameObject named "UMU AudioManager" is created automatically. A scene-placed instance always wins. A duplicate instance is destroyed. The object is moved to the root and marked DontDestroyOnLoad.

Runtime facts:

• Sources: two BGM sources (crossfade), one voice source, 4 UI sources (child "UI Pool"), Sfx Pool Size SFX sources (child "SFX Pool"). Each source is routed to the mixer group with the channel name (Master, BGM, SFX, Voice, UI).
• Volumes and mute states are saved to the file umu_audio_settings.json through the UMU save manager. Saving is delayed by 0.5 seconds after the last change, and also happens on pause, focus loss, destroy and quit (FlushSettings()).
• Persisted volumes are re-applied once on the frame after Awake.
• Linear volume (0 to 1) is converted to decibels with AudioManager.LinearToDb: values at or below 0.0001 give -80 dB, otherwise 20 * log10(value) clamped to the range -80 to 0.
• Mixer parameter names are available as constants: ParamMasterVolume ("MasterVolume"), ParamBgmVolume ("BGMVolume"), ParamSfxVolume ("SfxVolume"), ParamVoiceVolume ("VoiceVolume"), ParamUiVolume ("UIVolume").

Public API:

PlaySfxById, PlayUiSfx, PlayMusicById, PlayVoiceById do nothing when the id is empty, unknown, has no clip, or no database is assigned. The crossfade uses unscaled time, so it also finishes while Time.timeScale is 0.

AudioChannel (enum) #

Master, BGM, SFX, Voice, UI.

AudioCategories (static class) #

Constants UI ("UI"), Gameplay, Ambient, Notification, and the array Defaults containing all four. Categories are plain strings, so a project can use any names.

AudioDatabase (ScriptableObject) #

Lookups are built lazily and rebuilt in OnValidate. A duplicate id inside one array logs a warning in the Console and the later entry wins. API: SfxEntry GetSfx(string id), BgmEntry GetBgm(string id), VoiceEntry GetVoice(string id) (return null for an empty or unknown id), void BuildLookups() (call it after changing the entry arrays from code).

SfxEntry #

BgmEntry #

VoiceEntry #

UmuAudioSettings (serializable class, persisted state) #

Fields masterVolume, bgmVolume, sfxVolume, voiceVolume, uiVolume (float, default 1) and masterMuted, bgmMuted, sfxMuted, voiceMuted, uiMuted (bool, default false). Methods GetVolume/SetVolume/GetMuted/SetMuted(AudioChannel ...), static Load(string fileName), Save(string fileName).

AudioSettingsSliderBinder #

Requires a Slider. On enable the slider snaps to the persisted volume (retried in Start because the lazy manager may appear after OnEnable). Moving the slider sets and saves the volume. Any slider min/max range is mapped onto 0..1.

GuiButtonAudioBridge #

Requires a GuiButton. Plays on the UI channel. The hover sound is skipped for touch input and for non interactable buttons.

GuiPanelAudioBridge #

Requires a GuiPanel. Plays on the UI channel. Every transition has a "Pre" slot (starts together with the animation) and a "Post" slot (when the animation has finished). Any slot may stay empty.

UIAudioTrigger #

Works on any uGUI element (it implements the pointer click and enter handlers). If a Selectable is on the same object, its interactable state is honoured (including a parent CanvasGroup). Plays on the UI channel. Hover is ignored for touch input.

AudioImportConfig (editor ScriptableObject, namespace UMU.EditorTools.Audio) #

PathRule fields:

Starter rules created by the menu item:

Code examples #

Playing sounds, reading and writing volumes:

using UnityEngine;
using UMU.Audio;

public class AudioExample : MonoBehaviour
{
    [AudioId(AudioChannel.SFX)] [SerializeField] private string coinSfxId = "coin";
    [AudioId(AudioChannel.BGM)] [SerializeField] private string menuMusicId = "menu_theme";
    [AudioId(AudioChannel.Voice)] [SerializeField] private string greetingVoiceId = "greeting";
    [SerializeField] private AudioClip directClip;

    private void Start()
    {
        // Instance can be null in Awake (the lazy instance appears after the first scene loads).
        AudioManager audio = AudioManager.Instance;
        if (audio == null)
            return;

        audio.PlayMusicById(menuMusicId, 2f);   // 2 second crossfade
        audio.PlayVoiceById(greetingVoiceId);
        audio.PlaySfx(directClip, 0.8f);        // direct clip, no database lookup
    }

    public void OnCoinCollected()
    {
        AudioManager.Instance?.PlaySfxById(coinSfxId);
        // UI channel (follows the UI volume):
        AudioManager.Instance?.PlayUiSfx("ui_click");
    }

    public void ApplyMusicVolumeFromSlider(float value01)
    {
        AudioManager.Instance?.SetBgmVolume(value01);   // persisted automatically
    }

    public void ToggleSfxMute()
    {
        AudioManager audio = AudioManager.Instance;
        if (audio == null)
            return;

        audio.SetMuted(AudioChannel.SFX, !audio.IsMuted(AudioChannel.SFX));
        Debug.Log("SFX volume: " + audio.GetVolume(AudioChannel.SFX) + ", muted: " + audio.IsMuted(AudioChannel.SFX));
        audio.FlushSettings();                          // write to disk now
    }

    public void StopEverything()
    {
        AudioManager.Instance?.StopMusic();
        AudioManager.Instance?.StopAllSfx();
    }
}

Building a database in code and assigning it at runtime (a mixer can be assigned the same way with SetMixer):

using UnityEngine;
using UMU.Audio;

public class RuntimeDatabaseExample : MonoBehaviour
{
    [SerializeField] private AudioClip[] jumpVariants;
    [SerializeField] private AudioClip levelMusic;

    private void Start()
    {
        AudioDatabase db = ScriptableObject.CreateInstance<AudioDatabase>();
        db.sfxEntries = new[]
        {
            new SfxEntry
            {
                id = "jump",
                variants = jumpVariants,
                category = AudioCategories.Gameplay,
                baseVolume = 0.9f,
                pitchRange = new Vector2(0.95f, 1.05f)
            }
        };
        db.bgmEntries = new[] { new BgmEntry { id = "level", clip = levelMusic, loop = true } };
        db.BuildLookups();

        AudioManager.Instance.SetDatabase(db);
        AudioManager.Instance.PlayMusicById("level");
        AudioManager.Instance.PlaySfxById("jump");
    }
}

AudioManager has no virtual members and its lifecycle methods are private, so extend it by composition. A facade that exposes game specific operations:

using UnityEngine;
using UMU.Audio;

public static class GameAudio
{
    public static void PlayPurchase()
    {
        AudioManager audio = AudioManager.Instance;
        if (audio == null)
            return;

        audio.PlayUiSfx("purchase");
    }

    public static void SetAllVolumes(float value01)
    {
        AudioManager audio = AudioManager.Instance;
        if (audio == null)
            return;

        foreach (AudioChannel channel in System.Enum.GetValues(typeof(AudioChannel)))
            audio.SetVolume(channel, value01);
    }
}

AudioDatabase is not sealed, so a project can derive a database type with extra data. The manager accepts it through SetDatabase or the Inspector field:

using System.Collections.Generic;
using UnityEngine;
using UMU.Audio;

[CreateAssetMenu(fileName = "GameAudioDatabase", menuName = "MyGame/Game Audio Database")]
public class GameAudioDatabase : AudioDatabase
{
    public List<string> footstepIds = new List<string> { "step_a", "step_b" };

    public string RandomFootstepId()
    {
        return footstepIds.Count == 0 ? null : footstepIds[Random.Range(0, footstepIds.Count)];
    }
}

Custom component that binds a volume slider and reacts to the stored value:

using UnityEngine;
using UnityEngine.UI;
using UMU.Audio;

public class VolumeLabel : MonoBehaviour
{
    [SerializeField] private Slider slider;
    [SerializeField] private Text label;

    private void Update()
    {
        AudioManager audio = AudioManager.Instance;
        if (audio == null || label == null)
            return;

        label.text = Mathf.RoundToInt(audio.GetVolume(AudioChannel.Master) * 100f) + " %";
    }
}

5. Audio Cutter #

Splits an audio clip into equal pieces measured in musical beats, optionally appends a short amplified bridging piece to each cut, and saves the pieces as WAV files or as OGG files (through an external encoder).

Editor menu and window reference #

The window follows the Project selection: selecting an AudioClip asset automatically puts it into "Selected Clip". The window is divided into three sections.

Source

Cutting

Output

Button Cut runs the operation.

Behaviour details:

• File names are <clip name><special character><two digit index>, for example track_01.wav, track_02.wav. Indexes below 10 are padded with a zero.
• The WAV file is always written first (16 bit PCM, source sample rate and channel count).
• With OGG output the encoder is called for each piece with the arguments: input wav, -o output ogg, --downmix (only when Out Channel is 1 and the source has more than one channel), -q <Quality>, --resample 44100, -Q, --discard-comments.
• Encoder lookup: the "Ogg Encoder (oggenc)" path if the file exists, otherwise oggenc2 and then oggenc (with and without .exe) on the PATH. If none is found, a dialog asks to set the path, add the encoder to the PATH, or switch to wav, and nothing is cut.
• With OGG output, the intermediate .wav files written by the current run are deleted after encoding. Other files in the output folder are never touched.
• A progress bar is shown while cutting. Pressing Cancel on it stops the cut after the current piece. When finished, the window settings are saved, the AssetDatabase is refreshed and the window closes.
• The settings of the window are remembered between sessions.

Inspector reference #

The Audio Cutter has no component or ScriptableObject. All options are in the window described above. The runtime helper classes are listed in the code examples.

Code examples #

The same helpers the window uses are public and can be used from code (for example inside an editor script):

using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UMU.AudioCutter;

public static class CutterApiExample
{
    // Cut the first half of a clip, append a quiet copy of the next 10 percent and save as WAV.
    public static void CutAndSave(AudioClip source, string folder)
    {
        AudioClip main = AudioUtility.Cut(source, 0f, 0.5f);              // start/end as 0..1 ratios
        AudioClip bridge = AudioUtility.Cut(source, 0.5f, 0.6f, 0.05f);    // last argument: amplifier
        AudioClip joined = AudioUtility.AppendClips(new List<AudioClip> { main, bridge });

        bool saved = AudioClipManager.Save(joined, source.name + "_part", folder, ".wav");
        Debug.Log(saved ? "Saved to " + Path.Combine(folder, source.name + "_part.wav") : "Nothing saved");
    }

    // Remove leading and trailing silence (samples at or below the threshold).
    public static AudioClip Trim(AudioClip clip)
    {
        return clip.TrimSilence(0.001f);
    }
}

Other public helpers: AudioUtility.RemoveDataRange(clip, fromRatio, toRatio), AudioUtility.RemoveDataExceptRange(clip, fromRatio, toRatio), AudioUtility.CreateSpeakerSpecificClip(clip, channels, targetChannel), AudioUtility.DrawWaveForm(clip, width, height, waveColor, backColor, samplesStep, channelIndex).

6. Messenger #

A small mailbox plus push notification system for passing data between objects and across scene loads. Messages are stored with a lifetime, and listeners can additionally subscribe to be called immediately.

Editor menu and window reference #

The Messenger has no menu items, windows or wizards. The Messenger MonoBehaviour is created automatically (object name UMU_Messenger) the first time Messenger.Instance is used and no instance exists in the scene. It is marked DontDestroyOnLoad.

Inspector reference #

The Messenger has no serialized fields.

Message.Lifetime (enum nested in the Message struct):

Message fields: lifetime, id, actualScene, nextSceneLoaded, data.

Public API of Messenger:

Receiving removes the matched messages from the mailbox by default (removeMessage = true). A warning is logged when no message with the id exists. Subscribing does not remove anything: a sent message still lives in the mailbox with its lifetime. When Debug Mode is on, messages dropped on scene load are logged.

Code examples #

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UMU.Messenger;

public class ScoreSender : MonoBehaviour
{
    public void SendScore(int score)
    {
        // Typed payload, available to the next scene as well.
        Messenger.Instance.SendMessage<int>("score", Message.Lifetime.NextScene, score);
    }

    public void SendPlayerInfo()
    {
        var data = new Hashtable();
        data["name"] = "Anna";
        data["level"] = 7;
        Messenger.Instance.SendMessage("player_info", Message.Lifetime.ActualScene, data);
    }
}

public class ScoreReceiver : MonoBehaviour
{
    private IDisposable scoreSubscription;

    private void OnEnable()
    {
        // Push style: called immediately when "score" is sent.
        scoreSubscription = Messenger.Instance.Subscribe<int>("score", OnScore);
    }

    private void OnDisable()
    {
        scoreSubscription?.Dispose();
        scoreSubscription = null;
    }

    private void OnScore(int score)
    {
        Debug.Log("Score received: " + score);
    }

    private void Start()
    {
        // Mailbox style: read what was sent earlier (removes it from the mailbox).
        List<int> scores = Messenger.Instance.ReceiveMessages<int>("score");
        foreach (int s in scores)
            Debug.Log("Stored score: " + s);

        // Peek without removing:
        List<Hashtable> info = Messenger.Instance.ReceiveMessage("player_info", false);
        if (info.Count > 0)
            Debug.Log("Player: " + info[0]["name"]);
    }
}

public class TemporarySubscription : MonoBehaviour
{
    private void Start()
    {
        // using block: subscribed only for the duration of the block.
        using (IDisposable sub = Messenger.Instance.Subscribe<string>("chat", text => Debug.Log(text)))
        {
            Messenger.Instance.SendMessage<string>("chat", Message.Lifetime.ActualScene, "hello");
        }
    }
}

7. Logger #

The Logger module contains UMU.Development.Logger (an event based logger), the LogEntry data type and the Logger Console editor window. The window shows both Unity console messages and messages sent through Logger.Log.

Note: in code, the names Logger and LogType also exist in UnityEngine. When both namespaces are imported, qualify the UMU types (for example UMU.Development.Logger) or use a using alias.

Editor menu and window reference #

The window records entries only while it is open. Its content is stored between play mode changes.

Toolbar controls (left to right):

The toggle states are kept in the Editor preferences (keys with the prefix UMU_LOGGER_). The console collects entries while its window is open, so open it before you start the game to capture everything.

List behaviour:

Each row shows the first line of the message and the first relevant call stack line. The detail panel at the bottom shows the full message and call stack of the selected entry (selectable text, scrollable). Entries come from two sources: Unity messages (Application.logMessageReceived: Log, Warning, Error, Assert, Exception) and Logger.Log calls.

Inspector reference #

The Logger module has no component or ScriptableObject.

LogEntry (serializable struct):

UMU.Development.LogType values: Log, Warning, Assert, Error, Exception. LogEntry.Convert(UnityEngine.LogType) converts from the Unity type.

Logger API:

DebugLogger (non static class in UMU.Development, static methods) writes to the Unity Console and respects the Debug Mode log level (section 5):

Code examples #

using System;
using UnityEngine;
using UmuLogger = UMU.Development.Logger;   // avoids the clash with UnityEngine.Logger
using UMU.Development;

public class LoggerExample : MonoBehaviour
{
    private void OnEnable()
    {
        UmuLogger.logEvent += OnEntry;
    }

    private void OnDisable()
    {
        UmuLogger.logEvent -= OnEntry;
    }

    private void Start()
    {
        // Shows up in the Logger Console window (not in the Unity Console).
        UmuLogger.Log("Player spawned");

        // Unity Console, filtered by the Debug Mode log level.
        DebugLogger.Log("Loaded level 3");
        DebugLogger.Log("Special event", "ff8800");
        DebugLogger.LogWarning("Low memory");
        DebugLogger.LogError("Save failed");
        DebugLogger.LogException(new InvalidOperationException("Example"));
    }

    private void OnEntry(LogEntry entry)
    {
        // UMU.Development.LogType, written in full because UnityEngine.LogType also exists.
        if (entry.logType == UMU.Development.LogType.Error)
            Debug.Log("Error entry from " + entry.callerScriptPath + " line " + entry.callerLine);
    }

    private void ParseStack()
    {
        string path;
        int line;
        UmuLogger.FirstCall(StackTraceUtility.ExtractStackTrace(), out path, out line);
        Debug.Log(path + ":" + line);
    }

    private void BuildEntryManually()
    {
        var entry = new LogEntry(UMU.Development.LogType.Warning, "", null, -1, "Custom entry", "MyTag");
        UmuLogger.logEvent(entry);   // delivered to every subscriber, including the Logger Console
    }
}

8. Debug Mode #

Debug Mode is a project wide switch (stored in a settings asset) plus a log level. It controls DebugLogger, the in-game console, the FPS counter, and the debug options of other UMU components. Several tools are active only in the Editor and in development builds.

Editor menu and window reference #

Development Settings window

When the Editor loads, a saved password.txt is read automatically and applied to the Android keystore and key alias password in Player Settings.

Debug Mode Settings wizard (button "Apply")

Both fields start with the current stored values. Apply writes both values.

Scan Scene For Zero-Z Scaled Transforms. Finds every Transform (including inactive ones) in the open scenes whose localScale.z is zero or negative. Each one is logged as an error with its hierarchy path (clicking the message pings the object), all of them are selected, and a summary warning is logged. If none is found, an info message is logged.

Inspector reference #

DebugModeSettings (ScriptableObject) #

Stored at Assets/UMU/Debug Mode/Resources/DebugModeSettings.asset and created automatically in the Editor if missing. It is loaded at runtime from Resources under the name DebugModeSettings.

DebugMode.LOG values and effect (a level enables itself and every level listed before it, except None):

Debug.unityLogger.logEnabled is true for any level other than None. In the Editor, changing the level also updates the Player Settings: usePlayerLog, logObjCUncaughtExceptions and the stack trace type of each log type (ScriptOnly when the level is enabled, None otherwise).

DebugMode API: static bool IsDebug { get; set; }, static DebugMode.LOG LogType { get; set; }, static bool LogLevel(DebugMode.LOG log) (true if that kind is enabled), static void Awake() (re-applies the log mode). In the Editor, setting a value also saves the asset. Reading IsDebug returns false and LogType returns None when no settings asset exists.

FpsCounter (MonoBehaviour, requires a uGUI Text) #

Shows the frame rate in the text. Active only in the Editor and development builds (in release builds the component disables itself). The text is green at 60 FPS or more, yellow below 60, red below 30.

InGameDebugConsole (MonoBehaviour) #

Draws a log overlay with IMGUI for device testing. Works only in the Editor and development builds (the component destroys itself in release builds) and only while DebugMode.IsDebug is true (checked in Awake). The object is marked DontDestroyOnLoad. A "Show Logs"/"Hide Logs" button sits in the top right corner; the overlay opens automatically when an Error, Exception or Assert arrives. The overlay has the toggles Auto-scroll, Log, Warning, Error and a Clear button.

ScreenshotCreator (MonoBehaviour) #

Takes a screenshot when F12 is pressed (works with the Input System package or the legacy Input Manager). Active only in the Editor and development builds. Files are saved as PNG to <persistentDataPath>/Screenshots/Screenshot <yyyyMMddHHmmss> <width>x<height>.png.

API: void TakeScreenshot() (ignored while a capture is running), static string ScreenShotName(int width, int height).

Code examples #

using UnityEngine;
using UMU.Development;

public class DebugModeExample : MonoBehaviour
{
    private void Start()
    {
        // Read the state
        Debug.Log("Debug mode: " + DebugMode.IsDebug + ", level: " + DebugMode.LogType);

        // Change the state (saved to the settings asset in the Editor)
        DebugMode.LogType = DebugMode.LOG.Warning;
        DebugMode.IsDebug = true;

        // Level check before doing expensive logging work
        if (DebugMode.LogLevel(DebugMode.LOG.Log))
            Debug.Log("Verbose output is enabled");

        // Debug only features
        if (DebugMode.IsDebug && (Application.isEditor || Debug.isDebugBuild))
            ShowCheatPanel();
    }

    private void ShowCheatPanel()
    {
        Debug.Log("Cheat panel shown");
    }
}

Adding the debug tools from code:

using UnityEngine;
using UnityEngine.UI;
using UMU.Development;

public class DebugToolsBootstrap : MonoBehaviour
{
    [SerializeField] private Text fpsText;
    [SerializeField] private Camera mainCamera;

    private void Awake()
    {
        var console = gameObject.AddComponent<InGameDebugConsole>();
        console.maxEntries = 500;
        console.overlayHeightRatio = 0.6f;
        console.showLog = false;

        if (fpsText != null)
        {
            var fps = fpsText.gameObject.AddComponent<FpsCounter>();
            fps.updateInterval = 0.25f;
            fps.requireDebugMode = true;
        }

        var shots = gameObject.AddComponent<ScreenshotCreator>();
        shots.resWidth = 1920;
        shots.resHeight = 1080;
        shots.camerasInOrder = new[] { mainCamera };

        // Manual capture (same as pressing F12)
        shots.TakeScreenshot();
    }
}

9. Internet Checker #

Lightweight reachability check. It resolves host names (DNS) on a background thread and reports the result on the main thread. The callback is invoked exactly once. It also works in edit mode (the component is [ExecuteAlways]; in the Editor a queue pump drains pending callbacks).

Editor menu and window reference #

The Internet Checker has no menu items, windows or wizards.

Inspector reference #

InternetChecker (MonoBehaviour) #

API:

A host name that fails to resolve is reported with a warning (through DebugLogger, so it follows the Debug Mode log level). A null callback does nothing.

Code examples #

using UnityEngine;
using UMU.Net;

public class ConnectivityExample : MonoBehaviour
{
    private void Start()
    {
        InternetChecker checker = InternetChecker.EnsureInstance();

        // Default hosts
        checker.IsConnected(online => Debug.Log("Online (default hosts): " + online));

        // One host
        checker.IsConnected("example.org", online => Debug.Log("example.org reachable: " + online));

        // Custom list, any host that resolves counts as online
        string[] hosts = { "my-game-server.example.com", "cloudflare.com", "unity3d.com" };
        checker.IsConnected(hosts, online =>
        {
            if (online)
                StartOnlineFeatures();
            else
                ShowOfflineMessage();
        });
    }

    private void StartOnlineFeatures() { Debug.Log("Online features started"); }
    private void ShowOfflineMessage() { Debug.Log("No connection"); }
}

Changing the defaults from code:

using UnityEngine;
using UMU.Net;

public class ConnectivityConfig : MonoBehaviour
{
    private void Awake()
    {
        InternetChecker checker = InternetChecker.EnsureInstance();
        checker.defaultUrls = new[] { "my-game-server.example.com" };
    }
}

10. Hardware Detector #

Evaluates a rule set against the live device (SystemInfo, screen resolution and, on iOS, the device generation) and returns a performance tier: Low, Medium or High. The result can drive Unity's quality level.

Editor menu and window reference #

The Hardware Detector has no menu items, windows or wizards and no custom inspector. Configure it through the default Inspector of the HardwareDetector component (it has no Add Component menu entry; find it under Scripts or add it by name).

Inspector reference #

HardwareDetector (MonoBehaviour) #

Event and methods:

HardwareTier (enum) #

Low = 0, Medium = 1, High = 2.

HardwareDetectionRules #

HardwareDetectionRule #

HardwareFilterGroup #

HardwareFilterTerm #

HardwareDeviceInfo values:

IntFilterOperation values: Equal (device value equals Int Filter), LessThanOrEqual (device value is at most Int Filter), GreaterThanOrEqual (device value is at least Int Filter).

iOSDetectionRule #

Evaluation algorithm #

1. The result starts as High.
2. Each rule in Rules whose filter groups include at least one fully matching group lowers the result to the rule tier if that tier is lower than the current result.
3. On iOS devices, each matching iOSRules entry lowers the result in the same way.
4. A null rule set returns High.

HardwareTierEvaluator (static class) is usable on its own: static HardwareTier Evaluate(HardwareDetectionRules rules) and static void LogAllDeviceData() (writes the key SystemInfo values through DebugLogger).

Code examples #

Reacting to the result and driving the quality level:

using UnityEngine;
using UMU.Hardware;

public class HardwareExample : MonoBehaviour
{
    [SerializeField] private HardwareDetector detector;

    private void OnEnable()
    {
        detector.onTierEvaluated += OnTier;
    }

    private void OnDisable()
    {
        detector.onTierEvaluated -= OnTier;
    }

    private void OnTier(HardwareTier tier)
    {
        switch (tier)
        {
            case HardwareTier.Low:
                Application.targetFrameRate = 30;
                break;
            case HardwareTier.Medium:
                Application.targetFrameRate = 45;
                break;
            default:
                Application.targetFrameRate = 60;
                break;
        }
    }

    public void ReEvaluate()
    {
        HardwareTier tier = detector.Evaluate();
        Debug.Log("Tier: " + tier);
    }
}

Creating the detector and its rules fully in code:

using System.Collections.Generic;
using UnityEngine;
using UMU.Hardware;

public class HardwareRulesInCode : MonoBehaviour
{
    private void Awake()
    {
        var detector = gameObject.AddComponent<HardwareDetector>();
        detector.evaluateOnStart = false;
        detector.applyToUnityQuality = true;
        detector.qualityLevelByTier = new[] { 0, 1, 2 };

        // Low tier if the device has 3 GB RAM or less, OR it has an Adreno GPU numbered 530 or lower.
        var lowByMemory = new HardwareFilterGroup
        {
            terms = new List<HardwareFilterTerm>
            {
                new HardwareFilterTerm
                {
                    info = HardwareDeviceInfo.SystemMemorySize,
                    intFilterOperation = IntFilterOperation.LessThanOrEqual,
                    intFilter = 3072
                }
            }
        };

        var lowByGpu = new HardwareFilterGroup
        {
            terms = new List<HardwareFilterTerm>
            {
                new HardwareFilterTerm
                {
                    info = HardwareDeviceInfo.GraphicsDeviceName,
                    intFilterOperation = IntFilterOperation.LessThanOrEqual,
                    intFilter = 530,
                    stringFilters = new List<string> { "adreno" }
                }
            }
        };

        // Medium tier if at most 6 CPU cores AND a screen with 2 million pixels or fewer.
        var mediumGroup = new HardwareFilterGroup
        {
            terms = new List<HardwareFilterTerm>
            {
                new HardwareFilterTerm { info = HardwareDeviceInfo.ProcessorCount, intFilterOperation = IntFilterOperation.LessThanOrEqual, intFilter = 6 },
                new HardwareFilterTerm { info = HardwareDeviceInfo.ScreenResolution, intFilterOperation = IntFilterOperation.LessThanOrEqual, intFilter = 2000000 }
            }
        };

        detector.rules = new HardwareDetectionRules
        {
            rules = new List<HardwareDetectionRule>
            {
                new HardwareDetectionRule { tier = HardwareTier.Low, filterGroups = new List<HardwareFilterGroup> { lowByMemory, lowByGpu } },
                new HardwareDetectionRule { tier = HardwareTier.Medium, filterGroups = new List<HardwareFilterGroup> { mediumGroup } }
            },
            iOSRules = new List<iOSDetectionRule>
            {
                new iOSDetectionRule
                {
                    tier = HardwareTier.Low,
                    generationOperation = IntFilterOperation.LessThanOrEqual,
                    generation = UnityEngine.iOS.DeviceGeneration.iPhone6
                }
            }
        };

        detector.onTierEvaluated += tier => Debug.Log("Detected tier: " + tier);
        detector.Evaluate();
    }
}

Using the evaluator without a component:

using System.Collections.Generic;
using UnityEngine;
using UMU.Hardware;

public static class StandaloneTierCheck
{
    public static HardwareTier Check()
    {
        var rules = new HardwareDetectionRules();
        rules.rules.Add(new HardwareDetectionRule
        {
            tier = HardwareTier.Low,
            filterGroups = new List<HardwareFilterGroup>
            {
                new HardwareFilterGroup
                {
                    terms = new List<HardwareFilterTerm>
                    {
                        new HardwareFilterTerm { info = HardwareDeviceInfo.ProcessorCount, intFilterOperation = IntFilterOperation.LessThanOrEqual, intFilter = 2 }
                    }
                }
            }
        });

        HardwareTierEvaluator.LogAllDeviceData();
        return HardwareTierEvaluator.Evaluate(rules);
    }
}

11. Common and Utility #

Editor menu and window reference #

Menu items #

Plugin Save Files window (UMU > Plugin Save Files) #

The window is a Unity wizard. It is built from the public fields of the wizard class, so it uses the standard Inspector look.

Additional behaviour:

• Opening the window checks every module save file and creates the missing ones.
• After every asset import the same check runs again, so a deleted save file is recreated automatically.
• Save files use the extension .umusf (constant UMU_Constants.SaveFileExtension).

About window (UMU > About) #

The window is 500 pixels wide, with min and max size locked to the content height.

Constants (UMU.UMU_Constants) #

UMU_Constants.GetSaveFile(string pluginID) returns the full path of the save file pluginID + ".umusf", creating it when missing.

Inspector reference #

Property attributes and decorators #

These attributes change how a field or method is drawn in the Inspector. They are used on your own MonoBehaviour or ScriptableObject fields.

Rules for [ConditionalHide] and [HideCondition]:

• The two attributes must be on different members. [HideCondition] on a bool field, [ConditionalHide] on the field to hide.
• A condition field must be a public field. A condition method may be public or non public.
• When the same condition name exists in nested serializable classes, the member whose path matches the target field most closely is used.
• A hidden field takes no space in the Inspector.

[AssetPath] parameters and drawer controls #

Constructor: AssetPath(string filter, string searchInFolder, bool isUnityFilter = true, bool isDirectory = false, bool cutoffExtension = true, bool recursiveSearch = true)

Drawer controls (shown for a string field with [AssetPath]):

If the field is not a string the drawer shows the message "Use AssetPath with string."

Code examples #

Attributes on fields and methods #

using UnityEngine;
using UMU;
using UMU.Utility;

public enum SpawnMode { Single, Burst, Stream }

public class Spawner : MonoBehaviour
{
    [Comment("Configure how enemies are spawned.", CommentMessageType.Info)]
    public SpawnMode mode;

    [ShowIf("mode", SpawnMode.Burst)]
    public int burstCount = 5;

    public bool useCustomName;

    [ShowIf("useCustomName")]
    public string customName;

    [ReadOnly]
    public int spawnedSoFar;

    [Required("Assign the enemy prefab.")]
    public GameObject enemyPrefab;

    [AssetPath("*.*", "Assets", false, true)]
    public string outputFolder;

    [Button]
    private void SpawnOne()
    {
        if (enemyPrefab != null)
            Instantiate(enemyPrefab, transform.position, Quaternion.identity);

        spawnedSoFar++;
    }

    [Button("Reset counter")]
    public void ResetCounter()
    {
        spawnedSoFar = 0;
    }
}

ConditionalHide with HideCondition #

using UnityEngine;
using UMU.Utility;

public class WeaponSettings : MonoBehaviour
{
    // The bool decides about the field named "reloadTime".
    [HideCondition("reloadTime")]
    public bool needsReload;

    [ConditionalHide]
    public float reloadTime = 1.5f;

    public int level;

    // A method can decide too. It receives the field name and returns a bool.
    [HideCondition("legendaryBonus")]
    private bool ShowLegendaryBonus(string propertyName)
    {
        return level >= 10;
    }

    [ConditionalHide(defaultShow: true)]
    public float legendaryBonus = 2f;
}

AssetUtility #

using UnityEngine;
using UMU.Utility;

public class AssetUtilityExample : MonoBehaviour
{
    private void Start()
    {
        // Instantiate a prefab from a Resources path and remove the "(Clone)" suffix from its name.
        GameObject bullet = AssetUtility.CreateInstance<GameObject>("Prefabs/Bullet");

        // Same with position and rotation.
        GameObject bullet2 = AssetUtility.CreateInstance<GameObject>("Prefabs/Bullet", Vector3.zero, Quaternion.identity);

        // Convert an absolute path inside the project to an "Assets/..." path.
        string relative = AssetUtility.AbsoluteToRelativePath(Application.dataPath + "/Textures/Hero.png");
        Debug.Log(relative); // Assets/Textures/Hero.png
    }

#if UNITY_EDITOR
    [ContextMenu("Find asset by name")]
    private void FindAsset()
    {
        // Searches Application.dataPath recursively; the name is a file search pattern.
        string path = AssetUtility.GetAssetPathWithName("Hero.png");
        Texture2D tex = AssetUtility.GetAssetWithName<Texture2D>("Hero.png"); // editor only, null in a player
        Debug.Log(path + " " + tex);
    }
#endif
}

GetAssetWithName<T> needs the editor hook that UMU registers at editor load, so it returns null outside the editor.

SaveFileManager #

using UnityEngine;
using UMU.Utility;

public class SaveFileExample : MonoBehaviour
{
    private void OnEnable()
    {
        SaveFileManager.onFileNotExistsEvent += OnMissing;
        SaveFileManager.onExistsFileNotOverrideEvent += OnExists;
    }

    private void OnDisable()
    {
        SaveFileManager.onFileNotExistsEvent -= OnMissing;
        SaveFileManager.onExistsFileNotOverrideEvent -= OnExists;
    }

    private void OnMissing(FileErrorData data) { Debug.Log("Missing: " + data.path); }
    private void OnExists(FileErrorData data) { Debug.Log("Exists, not overwritten: " + data.path); }

    private void Start()
    {
        // persistentDataPath/saves/profile.txt
        bool saved = SaveFileManager.Save("profile.txt", SavePathPrefix.ApplicationDirectory, "saves", "hello", true);

        if (SaveFileManager.ExistsFile("profile.txt", SavePathPrefix.ApplicationDirectory, "saves"))
        {
            string text = SaveFileManager.Load("profile.txt", SavePathPrefix.ApplicationDirectory, "saves");
            Debug.Log(saved + " " + text);
        }

        // Absolute path overloads.
        string full = System.IO.Path.Combine(Application.persistentDataPath, "direct.txt");
        SaveFileManager.Save(full, "direct content", true);
        Debug.Log(SaveFileManager.Load(full));

        // Clean up.
        SaveFileManager.RemoveFile("profile.txt", SavePathPrefix.ApplicationDirectory, "saves");
        SaveFileManager.DeleteDirectory(SavePathPrefix.ApplicationDirectory, "saves");
    }
}

Notes: Save without overrideFile refuses to replace an existing file, raises onExistsFileNotOverrideEvent and returns false. In the editor outside play mode an overwrite question dialog is shown. Files are written as UTF-8 without BOM. SavePathPrefix.ApplicationDirectory is Application.persistentDataPath, SavePathPrefix.ProjectDirectory is Application.dataPath. Reading from ProjectDirectory while the game is playing loads a text asset from a Resources folder instead of the file system.

JsonSaveManager with version and encryption #

using System;
using System.Collections.Generic;
using UnityEngine;
using UMU.Utility;

[Serializable]
public class PlayerSave
{
    public string playerName;
    public int level;
    public List<string> items = new List<string>();
}

public class JsonSaveExample : MonoBehaviour
{
    private const string FileName = "player.sav";
    private const string Key = "my secret pass phrase";
    private const int CurrentVersion = 2;

    public void Save()
    {
        PlayerSave data = new PlayerSave { playerName = "Ada", level = 7 };
        data.items.Add("sword");

        // Stored as { "version": 2, "payload": "<AES encrypted, Base64>" } in persistentDataPath.
        bool ok = JsonSaveManager.Save(FileName, data, CurrentVersion, Key);
        Debug.Log("Saved: " + ok);
    }

    public PlayerSave Load()
    {
        int version;
        PlayerSave data = JsonSaveManager.Load<PlayerSave>(FileName, out version, Key);

        if (data == null)
            return new PlayerSave(); // missing file or wrong key

        if (version < CurrentVersion)
            data.level = Math.Max(1, data.level); // migrate old data here

        return data;
    }

    public PlayerSave LoadIgnoringVersion()
    {
        return JsonSaveManager.Load<PlayerSave>(FileName, Key);
    }
}

Signatures: Save<T>(string fileName, T data, int version = 1, string encryptionKey = null), Load<T>(string fileName, out int loadedVersion, string encryptionKey = null), Load<T>(string fileName, string encryptionKey = null). Without a key the payload is plain JSON. With a key the payload is encrypted with AES, the key is derived from your text with SHA 256 and a random initialisation vector is stored with the data. A load failure logs an error and returns default(T). JsonSaveManager uses the plain Newtonsoft converter, so store Unity structs as their components or serialize them with Serialization first.

Serialization of Unity types #

using UnityEngine;
using UMU.Utility;

public class SerializationExample : MonoBehaviour
{
    [System.Serializable]
    public class Marker
    {
        public Vector3 position;
        public Quaternion rotation;
        public Color color;
        public Vector2Int cell;
        public RectInt area;
        public string label;
        public string notSet; // null values are skipped
    }

    private void Start()
    {
        Marker marker = new Marker
        {
            position = new Vector3(1, 2, 3),
            rotation = Quaternion.identity,
            color = Color.red,
            cell = new Vector2Int(4, 5),
            area = new RectInt(0, 0, 10, 20),
            label = "A"
        };

        string json = Serialization.Serialize(marker);
        Debug.Log(json);

        Marker copy = Serialization.Deserialize<Marker>(json);
        Debug.Log(copy.position + " " + copy.color);
    }
}

Supported Unity types: Vector2, Vector3, Vector4, Vector2Int, Vector3Int, Quaternion, Color, Color32, RectInt. Output is indented, null values are not written and reference loops are ignored. Deserialize of an empty or null string returns default.

EditorDataSaveManager (class EditorDataManager) in an editor script #

The helper keeps the data of an editor window across play mode changes and editor restarts using EditorPrefs.

#if UNITY_EDITOR
using UnityEditor;
using UnityEngine;
using UMU.EDITOR;

public class CounterWindow : EditorWindow
{
    [System.Serializable]
    public struct CounterData : EditorDataManager.IEditorData
    {
        public bool initialized;
        public int counter;

        public EditorDataManager.IEditorData DefaultEditorData()
        {
            initialized = true;
            counter = 0;
            return this;
        }

        public bool Initialized() { return initialized; }
    }

    private const string EditorId = "MyCompany.CounterWindow";
    private CounterData data;

    [MenuItem("Window/Counter Window")]
    private static void Open() { GetWindow<CounterWindow>("Counter"); }

    private void OnEnable()
    {
        EditorApplication.playModeStateChanged += OnPlayModeChanged;
        EditorDataManager.CheckNullableEditorData(EditorId, ref data);
    }

    private void OnDisable()
    {
        EditorApplication.playModeStateChanged -= OnPlayModeChanged;
        EditorDataManager.SaveMyVariableValue(EditorId, data);
    }

    private void OnPlayModeChanged(PlayModeStateChange state)
    {
        EditorDataManager.OnPlayModeStateChanged(state, EditorId, ref data);
    }

    private void OnGUI()
    {
        data.counter = EditorGUILayout.IntField("Counter", data.counter);
    }
}
#endif

API: OnPlayModeStateChanged<T>(PlayModeStateChange state, string editorId, ref T data), CheckNullableEditorData<T>(string editorId, ref T data), SaveMyVariableValue<Type>(string id, Type obj), LoadMyVariableValue<Type>(string id), interface IEditorData with bool Initialized() and IEditorData DefaultEditorData(). The data type must have a parameterless constructor and be serializable by Serialization.

RichTextUtils #

using UnityEngine;
using UMU.Utility;

public class RichTextExample : MonoBehaviour
{
    private void Start()
    {
        string a = RichTextUtils.Colorize("Warning", Color.yellow);
        string b = RichTextUtils.Colorize("Error", new Color32(255, 0, 0, 255));
        string c = RichTextUtils.Colorize("Custom", "FF8800");      // RRGGBB or RRGGBBAA
        string d = RichTextUtils.Bold(RichTextUtils.Italic("Both"));
        string e = RichTextUtils.Size("Big", 32);
        byte byteValue = RichTextUtils.ToByte(0.5f);                // 127

        Debug.Log(a + " " + b + " " + c + " " + d + " " + e + " " + byteValue);
    }
}

Simplex.Noise #

Namespace Simplex. Calc1D, Calc2D and Calc3D return values in the range 0 to 256 centred on 128 (the noise value in the range -1 to 1 multiplied by 128, plus 128). Generate(float x) returns the raw 1D value in the range -1 to 1. Setting Seed to a non zero value builds a new random permutation table, setting it to 0 restores the default one.

using UnityEngine;

public class NoiseExample : MonoBehaviour
{
    private void Start()
    {
        Simplex.Noise.Seed = 1234;

        float[] line = Simplex.Noise.Calc1D(64, 0.05f);
        float[,] map = Simplex.Noise.Calc2D(128, 128, 0.02f);
        float[,,] volume = Simplex.Noise.Calc3D(16, 16, 16, 0.1f);
        float raw = Simplex.Noise.Generate(3.7f);

        Texture2D tex = new Texture2D(128, 128);

        for (int x = 0; x < 128; x++)
            for (int y = 0; y < 128; y++)
            {
                float v = map[x, y] / 255f;
                tex.SetPixel(x, y, new Color(v, v, v));
            }

        tex.Apply();
        Debug.Log(line.Length + " " + volume.GetLength(0) + " " + raw);
    }
}

ListShuffler #

using System.Collections.Generic;
using UnityEngine;
using UMU.Utility;

public class ShuffleExample : MonoBehaviour
{
    private void Start()
    {
        List<int> cards = new List<int> { 1, 2, 3, 4, 5, 6 };

        cards.Shuffle();                          // uses UnityEngine.Random

        System.Random seeded = new System.Random(42);
        cards.Shuffle(seeded);                    // reproducible order

        int[] array = { 1, 2, 3 };
        array.Shuffle();                          // works on any IList<T>
    }
}

ComponentExtension #

Namespace UMU. Copies fields and properties from one component to another. Members that cannot be copied are skipped and the exception is logged.

using UnityEngine;
using UMU;

public class CopyExample : MonoBehaviour
{
    public MyScript template;

    private void Start()
    {
        // Add a new component to this object and copy all values from the template.
        MyScript added = gameObject.AddComponent(template);

        // Copy values onto an existing component.
        MyScript other = gameObject.AddComponent<MyScript>();
        other.GetCopyOf(template);

        // Copy only the members shared between a parent type and a child type.
        // gameObject.AddComponent<ParentScript, ChildScript>(parentInstance);
    }
}

public class MyScript : MonoBehaviour
{
    public int value = 3;
    public string title = "x";
}

Signatures: GetCopyOf<T>(this Component comp, T other, bool seeAllBase = true), GetCopyOf<TParent, TChild>(this Component comp, TParent parent, bool seeAllBase = true), AddComponent<T>(this GameObject go, T toAdd), AddComponent<TParent, TChild>(this GameObject go, TParent toAdd). With seeAllBase true the members of base classes up to Component are copied as well.

ClassCloneCreator #

Namespace UMU.Reflection. Makes a copy of a class instance by copying all public fields. Arrays are copied with Array.Clone, List<T> and LinkedList<T> get new lists. A field value that implements ICloneableClass is cloned with its own Clone(), every other value is copied by assignment.

using System.Collections.Generic;
using UnityEngine;
using UMU.Reflection;

public class Item : ICloneableClass
{
    public string name = "";
    public int power;

    public object Clone()
    {
        return new Item { name = name, power = power };
    }
}

public class Inventory
{
    public int gold;
    public Item main = new Item();
    public List<Item> bag = new List<Item>();
    public int[] slots = new int[4];
}

public class CloneExample : MonoBehaviour
{
    private void Start()
    {
        Inventory original = new Inventory { gold = 10 };
        original.bag.Add(new Item { name = "Potion", power = 2 });

        Inventory copy = ClassCloneCreator.Clone(original); // T must have a public parameterless constructor
        copy.bag[0].power = 99;

        Debug.Log(original.bag[0].power); // 2
    }
}

Reflection helpers (UMU.Reflection.ReflectionUtilility, REF) #

The utility class name is spelled ReflectionUtilility in the code. It provides IsCollection, IsCloneable, IsArray, IsList, GetList(Type), GetLinkedList(Type), SearchObjectDataWithName, SearchObjectWithAttribute<T>, SearchObject and LengthOfMatch. The REF class holds SearchParameters, SearchCondition, ObjectInfoType, ObjectInfo and ObjectData.

using System;
using System.Collections.Generic;
using UnityEngine;
using UMU.Reflection;

[AttributeUsage(AttributeTargets.Field | AttributeTargets.Method)]
public class MarkAttribute : Attribute { }

public class Config
{
    [Mark] public int speed = 3;
    public string title = "demo";
}

public class ReflectionExample : MonoBehaviour
{
    private void Start()
    {
        Config root = new Config();

        REF.SearchParameters parameters = new REF.SearchParameters(REF.SearchCondition.BasedOnAttributes, typeof(MarkAttribute), root, 5);
        List<REF.ObjectData<MarkAttribute>> found = ReflectionUtilility.SearchObjectWithAttribute<MarkAttribute>(parameters);

        foreach (REF.ObjectData<MarkAttribute> data in found)
            Debug.Log(data.objectPath + " = " + data.objectReference);

        List<REF.ObjectData> byName = ReflectionUtilility.SearchObjectDataWithName(root, "title");
        Debug.Log(byName.Count);
    }
}

The search walks public fields, then properties, then (for attribute searches) methods. Depth is limited by maxDepth.

JsonFormatter #

using UnityEngine;
using UMU.Utility;

public class JsonFormatterExample : MonoBehaviour
{
    private void Start()
    {
        string compact = "{\"a\":1,\"b\":[1,2,3],\"c\":{\"d\":\"x\"}}";
        string pretty = JsonFormatter.FormatJson(compact); // 4 space indentation
        Debug.Log(pretty);
    }
}

MiniJSON #

Namespace UMU.Utility. Objects decode to Hashtable, arrays to ArrayList, every number to double. The parser does not throw; use lastDecodeSuccessful() to check the result.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UMU.Utility;

public class MiniJsonExample : MonoBehaviour
{
    private void Start()
    {
        string json = "{\"name\":\"Ada\",\"scores\":[1,2,3],\"level\":7}";

        Hashtable table = MiniJSON.jsonDecode(json) as Hashtable;

        if (!MiniJSON.lastDecodeSuccessful())
        {
            Debug.LogError(MiniJSON.getLastErrorIndex() + ": " + MiniJSON.getLastErrorSnippet());
            return;
        }

        string name = (string)table["name"];
        double level = (double)table["level"];
        ArrayList scores = (ArrayList)table["scores"];
        Debug.Log(name + " " + level + " " + scores.Count);

        // Encode.
        Hashtable output = new Hashtable();
        output["id"] = 5;
        output["tags"] = new ArrayList { "a", "b" };
        string text = MiniJSON.jsonEncode(output);

        // Extension methods.
        Hashtable again = text.hashtableFromJson();
        ArrayList list = "[1,2,3]".arrayListFromJson();
        string fromDict = new Dictionary<string, string> { { "k", "v" } }.toJson();
        string fromTable = output.toJson();
        Debug.Log(again.Count + " " + list.Count + " " + fromDict + " " + fromTable);
    }
}

TextureToBase64Tool #

Namespace TeamUtilityEditor. Texture2DToBase64(Texture2D) copies the texture into an RGB24 texture with Graphics.CopyTexture, encodes it as JPG (quality 100) and returns the Base64 text. Base64ToTexture2D(string) returns a new RGB24 texture with point filtering and the flag HideAndDontSave.

using UnityEngine;
using TeamUtilityEditor;

public class Base64Example : MonoBehaviour
{
    public Texture2D source;

    private void Start()
    {
        string text = TextureToBase64Tool.Texture2DToBase64(source);
        Texture2D back = TextureToBase64Tool.Base64ToTexture2D(text);
        Debug.Log(text.Length + " " + back.width);
    }
}

Editor helper classes (editor only) #

#if UNITY_EDITOR
using UnityEditor;
using UnityEngine;
using UnityEngine.UIElements;
using UMU;

public class HeroData : MonoBehaviour
{
    public int health = 100;
    public float speed = 3f;
}

[CustomEditor(typeof(HeroData))]
public class HeroDataEditor : UMU_InspectorEditor
{
    public override VisualElement CreateInspectorGUI()
    {
        VisualElement root = new VisualElement();
        VisualElement section = UMU_EditorUI.Section(root, "Stats");
        ShowProperty(section, "health", "Health");
        ShowSeparator(section);
        ShowProperty(section, "speed", "Speed");
        root.Add(UMU_EditorUI.PrimaryButton("Heal", () => { ((HeroData)target).health = 100; EditorUtility.SetDirty(target); }));
        return root;
    }
}
#endif

12. Android Manifest Editor #

Edits the file Assets/Plugins/Android/AndroidManifest.xml with a form, without touching XML.

Editor menu and window reference #

Menu item: UMU > Android Manifest Editor. The window title is "Android Manifest Editor". The window content scrolls.

If the manifest file or its folder does not exist, the editor creates Assets/Plugins/Android and writes a default manifest with:

• manifest attributes: package="", theme @android:style/Theme.NoTitleBar, versionName 1.0, versionCode 1, installLocation preferExternal
• supports-screens for all sizes
• an application (icon @drawable/app_icon, label @string/app_name, debuggable false) with one activity com.unity3d.player.UnityPlayerNativeActivity (landscape, singleTask, exported true, MAIN and LAUNCHER intent filter, Unity meta data)
• uses-sdk with minSdkVersion 23 and targetSdkVersion 36
• uses-feature glEsVersion 0x00020000

Window level controls #

Templates are kept in the Unity editor preferences (keys BBMANIFEST0, BBMANIFEST1, and so on), so they are available in every project on the same machine and user account.

Every element has its own Remove button (the button text differs per element, see the tables below). Removing is applied when you press Apply Changes.

Inspector reference (fields of every manifest element) #

The model classes are not Inspector components. Their fields are shown in the window. The following tables list every field as shown. Attributes that are empty or equal to the Android default are not written to the file, except android:exported, which is always written for activities, receivers, services and providers.

Application #

Activity (foldout "Activity: <name>") #

Receiver (foldout "Receiver: <name>") #

Fields: Name:, Attributes: with Enabled: (on), Exported: (on, always written), Icon:, Label:, Permission:, Process:. Lists: Intent-Filters: (n) with "New Intent-Filter", Meta-Data: (n) with "New Meta-Data" (the count shown next to Meta-Data in a receiver is the number of intent filters). Button: Remove Receiver.

Service (foldout "Service: <name>") #

Fields: Name:, Attributes: with Enabled: (on), Exported: (on, always written), Icon:, Isolated Process: (off), Label:, Permission:, Process:, Foreground Service Type: (multi select: camera, connectedDevice, dataSync, health, location, mediaPlayback, mediaProjection, microphone, phoneCall, remoteMessaging, shortService, specialUse, systemExempted). Lists: Intent-Filters: (n), Meta-Data: (n). Button: Remove Service.

Provider (foldout "Provider: <name>") #

Fields: Name:, Attributes: with one text box per authority (each with a Remove button, authorities are written joined with ;), Enabled: (on), Exported: (on, always written), Grant URI Permissions: (off), Icon:, Init Order: (0, not written when 0), Label:, Multiprocess: (off), Permission:, Process:, Read Permission:, Syncable: (off), Write Permission:. Lists: Meta-Data: (n), Grant-Uri-Permissions: (n) with "New Grant-Uri-Permission", Path-Permissions: (n) with "New Path-Permission". Button: Remove Provider. Authorities that already exist in the file are listed and can be edited or removed.

Intent-Filter (foldout "Intent-Filter: <name>") #

Meta-Data (foldout "Meta-Data: <name>") #

Uses-Library #

Permission (foldout "Permission: <name>") #

Uses-Permission (foldout "Uses-Permission: <name>") #

Uses-Feature #

Grant-Uri-Permission #

Fields: Path:, PathPattern:, PathPrefix:, button "Remove ". Path is always written, the other two only when not empty.

Path-Permission #

Fields: Path:, PathPattern:, PathPrefix:, Permission:, Read Permission:, Write Permission:, button "Remove Path-Permission ".

Template storage and merge behaviour #

• Save as Template stores the template name followed by the full manifest XML in the editor preferences.
• Import appends the template elements and replaces elements with the same name.
• Templates can be edited and saved independently of the manifest file.

Validate button rules #

Validate loads the manifest from disk and reports each finding as an error or a warning in a dialog and in the Console log. The dialog title shows the number of errors and warnings. With no findings it shows "No issues found" for Android 12, 13 and 14.

The target SDK is read from uses-sdk. If it is missing, the value is treated as 0 and the SDK dependent rules are not triggered.

Code examples #

All classes are in the namespace UMU and are editor only. Place the code in an Editor folder.

Validate a manifest string #

#if UNITY_EDITOR
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;
using UMU;

public static class ManifestValidationExample
{
    [MenuItem("Tools/Validate Sample Manifest")]
    private static void Run()
    {
        string xml =
            "<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\">" +
            "<uses-sdk android:targetSdkVersion=\"34\" />" +
            "<application><activity android:name=\"com.example.Main\">" +
            "<intent-filter><action android:name=\"android.intent.action.MAIN\" /></intent-filter>" +
            "</activity></application></manifest>";

        AndroidXmlEditor editor = new AndroidXmlEditor(xml);
        List<ManifestValidator.Issue> issues = ManifestValidator.Validate(editor.document);

        foreach (ManifestValidator.Issue issue in issues)
            Debug.Log((issue.isError ? "ERROR " : "WARN ") + issue.element + ": " + issue.message);
    }
}
#endif

AndroidXmlEditor() (no argument) opens the real file Assets/Plugins/Android/AndroidManifest.xml. AndroidXmlEditor(string xml) works on text only and never writes the file.

Add a permission and an activity with the model API #

#if UNITY_EDITOR
using UnityEditor;
using UnityEngine;
using UMU;

public static class ManifestEditExample
{
    [MenuItem("Tools/Add Internet Permission")]
    private static void AddPermission()
    {
        AndroidWindowData data = AndroidWindowData.CreateInstance(new AndroidXmlEditor());

        ManifestUsesPermission permission = ManifestUsesPermission.CreateInstance();
        permission.name = "INTERNET"; // written as android.permission.INTERNET
        data.usesPermissionList.Add(permission);

        ManifestActivity activity = ManifestActivity.CreateInstance();
        activity.name = "com.example.SecondActivity";
        data.activityList.Add(activity);

        data.ApplyChanges(); // saves Assets/Plugins/Android/AndroidManifest.xml
        Debug.Log("Manifest updated");
    }

    [MenuItem("Tools/List Manifest Content")]
    private static void List()
    {
        AndroidWindowData data = AndroidWindowData.CreateInstance(new AndroidXmlEditor());
        Debug.Log("Activities: " + data.activityList.Count);
        Debug.Log("Services: " + data.serviceList.Count);
        Debug.Log("Uses-permissions: " + data.usesPermissionList.Count);

        foreach (AndroidWindowData template in AndroidTemplateManager.GetTemplates())
            Debug.Log("Template: " + template.name);
    }
}
#endif

Useful public members: AndroidWindowData has the lists activityList, receiverList, serviceList, providerList, metaDataList, usesLibraryList, permissionList, usesPermissionList, usesFeatureList and the field application. Merge(AndroidWindowData) imports a template, ApplyChanges() saves. AndroidTemplateManager offers SaveTemplate, GetTemplates, ReloadTemplate(int), DeleteTemplate. Every element class has a static CreateInstance() for a new element and CreateInstance(XmlNode) for an existing one. Elements store their edit state in ElementEditStatus (NONE, REMOVED, EDITED); set it to REMOVED to delete an element on the next ApplyChanges.

13. Xcode Settings Editor #

Collects iOS project changes in a form and stores them in a JSON settings file. After an iOS build, a post process applies the settings to the generated Xcode project.

Editor menu and window reference #

Menu item: UMU > Xcode Project Editor. The window title is "Xcode Project Editor", minimum size 600 by 400. The content scrolls.

The settings are stored in the file UMU_XCODE_SETTINGS.iosProjmod. The editor looks for this file anywhere under Assets. If it does not exist, it is created as Assets/UMU/XcodeSettings/UMU_XCODE_SETTINGS.iosProjmod.

Top button rows #

Adding a path that is already in the list logs the warning "Already importing: <path>" and adds nothing. Paths inside the Assets folder are stored relative to Assets.

Global fields #

Lists #

Bottom buttons #

Changes are not saved until Apply Changes is pressed.

Inspector reference #

This module has no components or assets in the Inspector. All settings are edited in the window described above.

JSON settings file and post process behaviour #

Keys written by the window: