Skip to main content

Table of contents

Introduction​

World Graph Editor — is a user-friendly, node-based tool that makes it easy to define connections between scenes, streamlining the creation of multi-scene projects. The tool also includes built-in transition mechanics with support for awaiting asynchronous tasks.

Materials​

Core features​

  • Node-based editor to define how your scenes connect and how the player moves between them.
  • Three connection types: undirected, one-way, and shortcut.
  • Visual highlighting and labeling of GameObjects that represent ports in the graph.
  • Keeps Build Settings in sync with the graph; validation on Play Mode and Build.
  • Scene thumbnails on graph nodes for faster navigation in large projects.
  • Reachability checks to catch disconnected or unreachable parts of your graph.
  • Works with 2D and 3D; Undo/Redo support; Unity 6 compatible.

Additional features​

  • TransitionManager prefab for runtime scene transitions; optional auto-spawn of the player prefab.
  • Async work during transitions (registration with priorities and cancellation).
  • Scene View overlays: graph/container status, capture settings for node previews.
  • Main Toolbar shortcuts: quick open Transition Manager, scene switching modes (Neighbours, Build Settings, All Scenes).
  • Project Settings page for graph appearance, Hierarchy highlighting, toolbar, and custom scene validation tests.
  • Includes a demo with multiple scenes; extend with custom port components (ITransitionComponent).

Technical details​

Supported operating systems:

Windows, macOS, Linux

The tool runs inside the Unity editor and has been tested on Windows and macOS. Linux is expected to work but has not been fully tested.

Supported platforms:

Windows, macOS, WebGL

No platform-specific blockers are known, but other targets have not been explicitly tested.

Upgrading from version 1.0​

If you are upgrading from version 1.0, read this section carefully. It covers migrating data from 1.0 to 1.1 and later (including current 1.2).

New save system​

Starting with 1.1, the save format is incompatible with 1.0. To convert your data:

  1. Open the project and ensure every scene used in the graph is in Build Settings. Open your container in the graph and click Save.
  2. Select the container in the Project window. In the Inspector, open the ⋮ menu and choose To Json. On success, a .json file with the same name appears next to the container.
  3. Remove the current World Graph Editor package and install the new version.
  4. Create a new container or use an existing one. Important: its name must match the .json file and live in the same folder.
  5. Select the container in the Inspector, open ⋮, and choose Load From Json. If successful, the container fills with data and a nested Editor Only Data asset appears.
  6. Open the graph for that container and click Save.

Video: link

Updated async handler registration​

Starting with 1.1, RegisterAsyncHandler and UnregisterAsyncHandler take Func<CancellationToken, Task> instead of Func<Task>. Older overloads are marked [Obsolete] and will fail to compile.

Add a CancellationToken parameter to your async method:

Before:

TransitionManager.RegisterAsyncHandler(eventType, DoSomething, 0);

private async Task DoSomething()
{
    await Awaitable.WaitForSecondsAsync(1f);
}

TransitionManager.UnregisterAsyncHandler(_eventType, DoSomething);

After:

TransitionManager.RegisterAsyncHandler(eventType, DoSomething, 0);

private async Task DoSomething(CancellationToken token)
{
    await Awaitable.WaitForSecondsAsync(1f, token);
}

TransitionManager.UnregisterAsyncHandler(_eventType, DoSomething);

Upgrading from version 1.1​

If you are upgrading from 1.1 to 1.2, note the following API and editor changes.

Interface ITransitionComponent​

  • Editor method: void Refresh(RefreshContext context) (older samples sometimes used TransitionManager— use RefreshContext).
  • To fill a PortsDropdown with ports from the currently active scene, call context.FillPortsDropdownData(dropdown).
  • To fill the list with all ports in the graph, call context.FillAllPortsDropdownData(dropdown).

For manual data access, use context.Manager and WorldGraphContainer.EditorData.

ContainerEditorData and scene paths​

  • Preferred API: GetPortsDropdownData(string scenePath) — path to the scene .unity asset (same as Scene.path / SceneManager.GetActiveScene().path).
  • GetPortsDropdownData(int buildIndex) is marked [Obsolete] for compatibility; prefer the scene-path overload in new code.

TransitionManager.RefreshPorts()​

  • TransitionManager.RefreshPorts() is [Obsolete] and does nothing. In the editor, port lists and ITransitionComponent refresh automatically on scene/hierarchy/graph changes. Do not call this from OnValidate or gameplay code.

Demo project​

The tool is render-pipeline agnostic; demo scenes use URP and the legacy Input Manager.

How to run​

  1. Import World Graph Editor into your project.
  2. Open Assets/WorldGraphEditor/Resources/TransitionManager.prefab and click Refresh Build Settings under the Container field to register demo scenes.
  3. Open Assets/WorldGraphEditor/Examples/Scenes/Example 1.unity.
  4. Enter Play Mode.

Possible issues​

After importing the demo, the character may not jump. This is usually because the ground layer mask is not set.

How to fix​

  1. Create a physics layer, e.g. MyGround.
  2. Open Assets/WorldGraphEditor/Examples/Prefabs/Player.prefab and set LayerMask to that layer.
  3. In each demo scene under Assets/WorldGraphEditor/Examples/Scenes, assign that layer (MyGround) to all children of the Ground object.

Jumping should work after that.

Usage​

Getting started​

Project settings​

Open Edit → Project Settings → World Graph Editor. You can configure:

  • Node background opacity in the graph window;
  • Port highlighting in Hierarchy (names and colors, names only, or off);
  • Main toolbar extensions: quick open for the Transition Manager prefab (TM label), scene dropdown with Neighbours (graph neighbours for the active scene), Build Settings, and All Scenes;
  • Custom scene validation tests.

Creating a WorldGraphContainer​

  1. In the Project window, create a WorldGraphContainer: Right-click → Create → World Graph Editor → World Graph Container.
  2. Double-click the asset to open the graph editor window.

Adding scenes​

Drag scenes into the graph window to create nodes. Each node is a scene; each port on a node is a transition point to another scene.

[!WARNING]
Do not add duplicate scenes—they cause errors and are highlighted in red.

Port types​

When you click + on a node, you can create:

  • Left Passage, Right Passage, Top Passage, Bottom Passage — connection ports used to link nodes.
  • Additional Port — not for graph connections; useful for systems like fast travel.

Creating ports and connections​

  1. Click + on a node and create a connection port.
  2. Drag from a port on the first node to the middle of the second node.
  3. If valid, a connection appears between the nodes.

This defines which passages connect your scenes. Extra port options are in the Inspector when a node is selected.

[!WARNING]
Each port name on a node must be unique and cannot be empty or whitespace-only.

Types of connections between nodes​

  • Undirected — Default. Movement through passages works in both directions.
  • Shortcut — The passage is only available from one side at first (e.g. a locked door). Can be handled in a custom port implementation to block travel under conditions.
  • One-Way — Travel only in the configured direction.

Change the type from the context menu (right-click an existing connection).

Saving and configuration​

Saving the graph​

When you are done editing, click Save.

[!NOTE] On save, unlinked ports are removed except Additional Port entries.

[!NOTE] You will be prompted to add all used scenes to Build Settings, which is required for transitions.

Configuring TransitionManager​

  1. Ensure the prefab exists at Assets/WorldGraphEditor/Resources/TransitionManager. If not, use Tools → World Graph Editor → Create Transition Manager Prefab.
  2. Assign your saved WorldGraphContainer to Container on TransitionManager.
  3. Set AutoLoad to true so the manager loads automatically at startup.
  4. Enable the checkbox next to PlayerPrefab and assign your player prefab.

A player instance is spawned on each loaded scene. If you need a different bootstrap, you can use your own approach.

Configuring scenes​

Add components that represent ports on the scene. Defaults:

  • Passage2D — Moves the player to the opposite port using graph connections.
  • Teleport2D — Moves the player to any other port on the graph.

You can place a DefaultSpawnPosition object. If no output port (OutputTransitionComponent) is found, the player spawns there.

Configuring components​

  • Passage2D
    • In AssignedPort, pick the passage name that matches a port on the graph.
  • Teleport2D
    • In AssignedPort, pick the passage name that matches a port on the graph.
    • In GoTo, pick the destination port.

[!TIP] Each AssignedPort on the scene must map to exactly one port on the node.

You can also write custom implementations.

Verification​

Expected behavior​

  • On play, a TransitionManager instance is created under DontDestroyOnLoad.
  • Touching a port moves the player to the target scene at the correct port position.

Errors​

If the target port is missing on the scene:

  • The player spawns at DefaultSpawnPoint, or (0, 0, 0) if none is set.
  • An error is logged.

[!WARNING] Play stops automatically if:

  • TransitionManager is missing at Assets/WorldGraphEditor/Resources/TransitionManager
  • Container on TransitionManager is empty
  • The container has validation errors
  • Scenes were removed, disabled, or reordered in Build Settings

The console shows an error with guidance.

Scene View overlays​

In the Scene window, two built-in overlays are available: Scene Inspector WGE and Screenshot Utility WGE. You can toggle, dock, and hide them like any Scene View overlay.

Scene Inspector WGE​

Shows a short status for Transition Manager and the container: whether a container is assigned, data errors, and Build Settings consistency. For the active scene, it summarizes graph alignment (scene and port data). Buttons: Validate (run scene checks and write results to the project validation asset) and Open TM (open the Transition Manager prefab).

Screenshot Utility WGE​

Captures a preview of the current scene for the graph window node. Configure framing (position, size, rotation), camera distance and mode (perspective / orthographic), and image settings (resolution, non-power-of-two texture handling). You can save per-scene (Save Scene Preset), set a global default (Save as Global Default), or reset (Reset to Built-In). Take Screenshot saves the image; Scene View shows handles and the frame.

Customization​

Custom port implementation​

General​

To implement your own ports:

  • Inherit from PassageBase or TeleportBase, or implement ITransitionComponent.
  • Use the PortsDropdown class and low-level EditorData / PortsDropdown access for dropdowns that bind to the current port or any port on the graph.
  • Implement GetGuid() returning the current port Guid.
  • In the editor, implement Refresh(RefreshContext context) and call context.FillPortsDropdownData / context.FillAllPortsDropdownData or use context.Manager and EditorData (see Upgrading from version 1.1).

PassageBase, TeleportBase, and ITransitionComponent​

PassageBase and TeleportBase are abstract bases for passage and teleport: they already wire up PortsDropdown and fields. For most cases, inherit one of them and override methods such as GetSpawnPosition().

ITransitionComponent is the minimal “port on a scene” contract:

  • string GetGuid() — port id in the graph.
  • Vector3 GetSpawnPosition() — spawn position at this port.

In the editor, implement void Refresh(RefreshContext context) and typically call context.FillPortsDropdownData / context.FillAllPortsDropdownData and read Guid values from PortsDropdown.

If you do not want the base classes, implement only ITransitionComponent (see GoTo / GoFrom examples).

[!TIP] Wrap Refresh() in #if UNITY_EDITOR— it is editor-only.

Extension methods​

ITransitionComponent also has extension helpers. IsInput() and IsOutput() tell whether the component is the entry or exit side of a transition.

MethodPurpose
IsOutput()true if this is the component where the transition ends.
IsInput()true if this is the component where the transition starts.

IsShortcutOutput() and IsShortcutInput() describe shortcut connections between scenes.

MethodPurpose
IsShortcutOutput()true if this is the shortcut “output” side.
IsShortcutInput()true if this is the shortcut “input” side.

[!TIP] If the connection is not a shortcut, both return false.

RefreshContext​

RefreshContext is passed to void Refresh(RefreshContext context) on ITransitionComponent implementations. Editor-only. Called when scenes, hierarchy, or the graph change so PortsDropdown fields stay in sync.

Fields:

NameTypeDescription
ManagerITransitionManagerReference to TransitionManager. Manager.Container exposes WorldGraphContainer and EditorData for manual data access.

Methods:

MethodPurpose
void FillPortsDropdownData(PortsDropdown dropdown)Fills the dropdown with ports on the active scene.
void FillAllPortsDropdownData(PortsDropdown dropdown)Fills the dropdown with all ports from the container.

Transition methods on TransitionManager​

Task LoadScene(int buildIndex, TransitionContext context = null)

Loads a scene by build index.

Parameters:

NameTypeDescription
buildIndexintScene build index
contextTransitionContextOptional delay between transition phases
void GoFrom(string currentPortGuid, bool ignoreShortcuts, TransitionContext context = null)

Moves the player to the opposite port using graph connections.

Parameters:

NameTypeDescription
currentPortGuidstringCurrent port Guid
ignoreShortcutsboolWhether to ignore shortcuts
contextTransitionContextOptional delay between transition phases
void GoTo(string currentPortGuid, string targetPortGuid, TransitionContext context = null)

Moves the player to any port. Does not rely on graph connectivity.

Parameters:

NameTypeDescription
currentPortGuidstringCurrent port Guid
targetPortGuidstringTarget port Guid
contextTransitionContextOptional delay between transition phases

GoTo/GoFrom examples​

Minimal passage example using GoFrom:

using UnityEngine;  

namespace WorldGraphEditor.Examples  
{  
    public class ExamplePassage : MonoBehaviour, ITransitionComponent  
    {  
        [SerializeField] private PortsDropdown _assignedPort = new();  
        private string _currentGuid;  
        
        // Any trigger, e.g. OnTriggerEnter
        private void OnTriggerEnter(Collider other)  
        {  
            // GoFrom call
            TransitionManager.Instance.GoFrom(_currentGuid, false);  
        }  
        
#if UNITY_EDITOR  
        public void Refresh(RefreshContext context)  
        {  
            context.FillPortsDropdownData(_assignedPort);  
            _currentGuid = _assignedPort.GetSelectedValue();  
        }  
#endif  

        public Vector3 GetSpawnPosition() => transform.position;  

        public string GetGuid() => _currentGuid;  
    }  
}

Minimal teleport example using GoTo:

using UnityEngine;  

namespace WorldGraphEditor.Examples  
{  
    public class ExampleTeleport : MonoBehaviour, ITransitionComponent  
    {  
        [SerializeField] private PortsDropdown _assignedPort = new();  
        [SerializeField] private PortsDropdown _targetPort = new();

        private string _currentGuid;    
        private string _targetGuid;  

        // Any trigger, e.g. OnTriggerEnter
        private void OnTriggerEnter(Collider other)  
        {  
            // GoTo call
            TransitionManager.Instance.GoTo(_currentGuid, _targetGuid);  
        }  
        
#if UNITY_EDITOR  
        public void Refresh(RefreshContext context)  
        { 
            context.FillPortsDropdownData(_assignedPort);  
            context.FillAllPortsDropdownData(_targetPort);  

            _currentGuid = _assignedPort.GetSelectedValue();  
            _targetGuid = _targetPort.GetSelectedValue();  
        }  
#endif  

        public Vector3 GetSpawnPosition() => transform.position;  

        public string GetGuid() => _currentGuid;  
    }  
}

TransitionContext​

TransitionContext lets you override the delay between transition phases for the current transition. Pass it to GoTo, GoFrom, or LoadScene.

Example​

TransitionManager.Instance.GoFrom(_port.GetSelectedValue(), true,  
    new TransitionContext  
    {  
        PortEnteredDelay = new TransitionDelayData(DelayType.ThisFrame),  
        TransitionStartedDelay = new TransitionDelayData(DelayType.CustomDelay, 1.2f)  
    });

PortsDropdown​

PortsDropdown builds editor dropdowns bound to graph ports and keeps the selected value stable when ports are renamed or counts change.

Two methods:

string GetSelectedValue()

Returns the selected value.

Returns:

TypeDescription
stringSelected value (Guid)
void SetData(IEnumerable<(string Guid, string DisplayName)> data)

Sets dropdown entries as Guid + display name pairs.

Parameters:

NameTypeDescription
dataIEnumerable<(string Guid, string DisplayName)>Items with Guid and label

Low-level access: EditorData and PortsDropdown​

Usually, in Refresh(RefreshContext context), call context.FillPortsDropdownData(dropdown) or context.FillAllPortsDropdownData(dropdown) — see Upgrading from version 1.1.

The following are methods on EditorData of WorldGraphContainer: raw sequences for SetData when you need filtering, merging, or custom lists. EditorOnly.

IEnumerable<(string Guid, string Name)> FillPortsDropdownData(string scenePath)

Parameters:

NameTypeDescription
scenePathstringPath to the scene .unity asset, same as Scene.path.

Returns:

TypeDescription
IEnumerable<(string Guid, string Name)>All ports on that scene (Guid + display name).

Example​

Preferred path via RefreshContext:

using UnityEngine;  

namespace WorldGraphEditor.Examples  
{  
    public class MyComponentWithDropdown : MonoBehaviour, ITransitionComponent  
    {  
        [SerializeField] private PortsDropdown _dropdown = new();  

        private string _currentPortGuid;  

#if UNITY_EDITOR  
        public void Refresh(RefreshContext context)  
        {  
            context.FillPortsDropdownData(_dropdown);  
            _currentPortGuid = _dropdown.GetSelectedValue();  
        }  
#endif  

        // public Vector3 GetSpawnPosition() {}
        // public string GetGuid() {}
    }  
}

Using EditorData:

using UnityEngine;  
using UnityEngine.SceneManagement;  

namespace WorldGraphEditor.Examples  
{  
  public class MyComponentWithDropdown : MonoBehaviour, ITransitionComponent  
  {  
      [SerializeField] private PortsDropdown _dropdown = new();  
      
      private string _currentPortGuid;  

#if UNITY_EDITOR  
      public void Refresh(RefreshContext context)  
      {  
          var container = context.Manager.Container;  
          var scenePath = SceneManager.GetActiveScene().path;  
          var scenePortsData = container.EditorData.GetPortsDropdownData(scenePath);  
          _dropdown.SetData(scenePortsData);  
          _currentPortGuid = _dropdown.GetSelectedValue();  
      }  
#endif  

      // public Vector3 GetSpawnPosition() {}
      // public string GetGuid() {}
  }  
}

[!NOTE] GetPortsDropdownData(int buildIndex) is [Obsolete]. Prefer scenePath so you are not tied to Build Settings order.

IEnumerable<(string Guid, string Path)> FillAllPortsDropdownData()

Returns all ports on the graph, grouped by scene.

Returns:

TypeDescription
IEnumerable<(string Guid, string Path)>All ports on the graph

Example​

Preferred via RefreshContext:

using System;  
using UnityEngine;  

namespace WorldGraphEditor.Examples  
{  
    public class MyComponentWithDropdown : MonoBehaviour, ITransitionComponent  
    {  
        [SerializeField] private PortsDropdown _dropdown = new();  

        private string _currentPortGuid;  

#if UNITY_EDITOR  
        public void Refresh(RefreshContext context)  
        {  
            context.FillAllPortsDropdownData(_dropdown);  
            _currentPortGuid = _dropdown.GetSelectedValue();  
        }  
#endif  

        // public Vector3 GetSpawnPosition() {}
        // public string GetGuid() {}
    }  
}

Using EditorData:

using System;  
using UnityEngine;  

namespace WorldGraphEditor.Examples  
{  
    public class MyComponentWithDropdown : MonoBehaviour, ITransitionComponent  
    {  
        [SerializeField] private PortsDropdown _dropdown = new();  

        private string _currentPortGuid;  

#if UNITY_EDITOR  
        public void Refresh(RefreshContext context)  
        {  
            var container = context.Manager.Container;  
            var allPortsData = container.EditorData.GetAllPortsDropdownData(); 
             
            _dropdown.SetData(allPortsData);  
            _currentPortGuid = _dropdown.GetSelectedValue();
        }  
#endif  

        // public Vector3 GetSpawnPosition() {}
        // public string GetGuid() {}
    }  
}

Pushing out of passages​

Add a “push” force for a port by implementing IPusher and GetPushData() returning PushData.

PushData contains:

  • Force — push vector
  • Exists — whether a push is active
public readonly struct PushData
{
    public readonly Vector3 Force;
    public readonly bool Exists;

    public PushData(Vector3 force)
    {
        Force = force;
        Exists = true;
    }
}

Example​

using UnityEngine;
  
namespace WorldGraphEditor.Examples
{
    public class MyPushingPassage : PassageBase, IPusher
    {
        [SerializeField] private Vector2 _pushForce;

        public PushData GetPushData()
        {
            if (_pushForce == Vector2.zero)
                return default;

            return new PushData(_pushForce);
        }  
        
        // public void Refresh(RefreshContext context) {}
        // public Vector3 GetSpawnPosition() {}
        // public string GetGuid() {}
    }

}

Apply the force using TransitionManager.Instance.PushData after transitions.

Example​

using UnityEngine;

namespace WorldGraphEditor.Examples
{
    public class PlayerController : MonoBehaviour
    {
        [SerializeField] private Rigidbody2D _rigidbody;

        private void OnTransitionEnded()
        {
            var pushData = TransitionManager.Instance.PushData;

            if (pushData.Exists)
                _rigidbody.AddForce(pushData.Force, ForceMode2D.Impulse);
        }

        private void Awake()
        {
            TransitionManager.OnTransitionEnded += OnTransitionEnded;
        }
        
        private void OnDestroy()
        {
            TransitionManager.OnTransitionEnded -= OnTransitionEnded;
        }
    }
}

Custom TransitionManager bootstrap​

By default TransitionManager loads automatically at startup; you can create it manually when needed.

Disabling auto-load​

  1. Set AutoLoad to false.
  2. Call TransitionManager.CreateInstance() when you want the manager.

Example​

using UnityEngine;

namespace WorldGraphEditor.Examples
{
    public class MyCustomTransitionManagerLoader : MonoBehaviour
    {
        [SerializeField] private float _loadDelay = 2f;

        private void Start()
        {
            Invoke(nameof(MyLoadMethod), _loadDelay);
        }

        private void MyLoadMethod()
        {
            TransitionManager.CreateInstance();
        }
    }
}

[!NOTE] LoadFromResources() only returns an instance from Resources and does not place it under DontDestroyOnLoad. It is mainly for editor access. Prefer CreateInstance()—it prevents duplicate instances.

Events and async code​

TransitionManager exposes events for transition phases:

  • OnInitialized — after TransitionManager initializes
  • OnDestroyed — in OnDestroy() of TransitionManager
  • OnPortEntered — when GoFrom() or GoTo() runs
  • OnTransitionStarted — before loading the next scene
  • OnSceneLoaded — after the scene loads and the output port / spawn position are resolved
  • OnTransitionEnded — after the player prefab spawns (still fires if no prefab)
  • OnPortLeaved — after OnTransitionEnded

Delay between transition phases​

Configure delays before async handlers run using EventCallConfig:

  1. Create: Right-click → Create → World Graph Editor → Event Call Config
  2. Pick a delay mode:
    • This Frame — same frame
    • Next Frame — next frame
    • Physics Update — in FixedUpdate()
    • Custom Delay — after a time
  3. Assign the asset to TransitionManager

Waiting for async methods​

Register async work with priorities via TransitionManager.RegisterAsyncHandler(). Higher priority runs first.

[!TIP] Per phase, order is:

  1. Transition event (OnPortEntered / OnTransitionStarted / OnSceneLoaded / OnTransitionEnded)
  2. Wait for EventCallConfig delay
  3. Await registered async methods

The starting event is chosen with EventType.

Async registration is available for:

public enum EventType
{
    OnPortEntered,
    OnTransitionStarted,
    OnSceneLoaded,
    OnTransitionEnded,
}

Working with async methods​

static void RegisterAsyncHandler(EventType eventType, Func<CancellationToken, Task> func, int priority)

Parameters:

NameTypeDescription
eventTypeEventTypeEvent after which async methods start
funcFunc<CancellationToken, Task>Async method taking CancellationToken, returning Task
priorityintCall priority
static void UnregisterAsyncHandler(EventType eventType, Func<CancellationToken, Task> func)

Parameters:

NameTypeDescription
eventTypeEventTypeEvent to unregister from
funcFunc<CancellationToken, Task>Same async method reference

[!NOTE] OnDestroy on TransitionManager cancels the CancellationTokenSource and unregisters handlers.

Example​

using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.UI;

namespace WorldGraphEditor.Examples
{
    public class AsyncAfterSceneLoadedExample : MonoBehaviour
    {
        private readonly EventType _event = EventType.OnSceneLoaded;

        private void Awake()
        {
            TransitionManager.RegisterAsyncHandler(_event, RunAfterSceneLoaded, 0);
        }

        private async Task RunAfterSceneLoaded(CancellationToken token)
        {
            await Awaitable.WaitForSecondsAsync(0.25f, token);
        }
        
        private void OnDisable()
        {
            TransitionManager.UnregisterAsyncHandler(_event, RunAfterSceneLoaded);
        }
    }
}

Roadmap​

  • Multiple scene variants per node
  • Custom TransitionManager implementations
  • Customizable graph nodes
  • Pathfinding through selected scenes

Changelog​

Version 1.2.0​

New Features:

  • Scene previews on graph nodes.
  • Scene Inspector WGE overlay for the active scene.
  • Screenshot Utility WGE for scene previews.
  • Toolbar scene switching buttons.
  • Asset settings window at Edit → Project Settings → World Graph Editor.
  • Manual per-transition phase delays via TransitionContext.
  • Scene validator.
  • Custom validation tests.
  • Graph reachability checks.
  • API quality-of-life improvements.

Changes:

  • ITransitionComponent.Refresh() now takes RefreshContext instead of TransitionManager.
  • Automatic Refresh() when scene/hierarchy/graph changes.
  • Dropped support for Unity 2022.3.

Fixes:

  • Leading/trailing spaces in port names are invalid (e.g. "Left", "Left ", " Left" are treated as the same invalid case).
  • Minor improvements and internal fixes.

Version 1.1.0​

New Features:

  • RegisterAsyncHandler / UnregisterAsyncHandler support CancellationToken.
  • Migration path from 1.0 to 1.1+.

Changes:

  • Changed the way data is stored in WorldGraphContainer.
  • EditorOnly APIs moved to WorldGraphContainer.EditorData.
  • Func<Task> overloads removed; use Func<CancellationToken, Task>.

Fixes:

  • TransitionManager.LoadScene() now respects DefaultSpawnPoint instead of always (0, 0, 0).
  • Async tasks are cancelled when exiting Play Mode.

Version 1.0.0​

  • First Release.