From bd366ea12fdad7905c6fe893994f2d7397e52850 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 28 Feb 2026 09:52:13 +0000
Subject: [PATCH 01/52] Initial plan


From ba9bb323a385ce648ad32f9b21c12d9b34efcbff Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 28 Feb 2026 10:05:39 +0000
Subject: [PATCH 02/52] Add animation blueprint graph viewer with
 node/connection extraction and visualization

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 136 ++++++++
 FModel/ViewModels/CUE4ParseViewModel.cs |  16 +
 FModel/Views/AnimGraphViewer.xaml       |  60 ++++
 FModel/Views/AnimGraphViewer.xaml.cs    | 431 ++++++++++++++++++++++++
 4 files changed, 643 insertions(+)
 create mode 100644 FModel/ViewModels/AnimGraphViewModel.cs
 create mode 100644 FModel/Views/AnimGraphViewer.xaml
 create mode 100644 FModel/Views/AnimGraphViewer.xaml.cs

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
new file mode 100644
index 00000000..9f4cf23a
--- /dev/null
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -0,0 +1,136 @@
+using System.Collections.Generic;
+using System.Linq;
+using CUE4Parse.UE4.Assets;
+using CUE4Parse.UE4.Assets.Exports;
+using CUE4Parse.UE4.Assets.Exports.EdGraph;
+using CUE4Parse.UE4.Objects.Engine.EdGraph;
+
+namespace FModel.ViewModels;
+
+public class AnimGraphNode
+{
+    public string Name { get; set; } = string.Empty;
+    public string ExportType { get; set; } = string.Empty;
+    public string NodeComment { get; set; } = string.Empty;
+    public int NodePosX { get; set; }
+    public int NodePosY { get; set; }
+    public List<AnimGraphPin> Pins { get; set; } = [];
+
+    public override string ToString() => $"{ExportType} ({Name})";
+}
+
+public class AnimGraphPin
+{
+    public string PinName { get; set; } = string.Empty;
+    public EEdGraphPinDirection Direction { get; set; }
+    public string PinType { get; set; } = string.Empty;
+    public string DefaultValue { get; set; } = string.Empty;
+    public AnimGraphNode OwnerNode { get; set; } = null!;
+}
+
+public class AnimGraphConnection
+{
+    public AnimGraphNode SourceNode { get; set; } = null!;
+    public string SourcePinName { get; set; } = string.Empty;
+    public AnimGraphNode TargetNode { get; set; } = null!;
+    public string TargetPinName { get; set; } = string.Empty;
+}
+
+public class AnimGraphViewModel
+{
+    public string PackageName { get; set; } = string.Empty;
+    public List<AnimGraphNode> Nodes { get; } = [];
+    public List<AnimGraphConnection> Connections { get; } = [];
+
+    public static AnimGraphViewModel ExtractFromPackage(IPackage package)
+    {
+        var vm = new AnimGraphViewModel { PackageName = package.Name };
+
+        var allExports = package.GetExports().ToList();
+
+        // Map from UObject to AnimGraphNode for connection resolution
+        var nodeMap = new Dictionary<UObject, AnimGraphNode>();
+
+        // First pass: extract all graph nodes
+        foreach (var export in allExports)
+        {
+            if (export is not UEdGraphNode graphNode) continue;
+
+            var node = new AnimGraphNode
+            {
+                Name = graphNode.Name,
+                ExportType = graphNode.ExportType,
+                NodePosX = graphNode.GetOrDefault("NodePosX", 0),
+                NodePosY = graphNode.GetOrDefault("NodePosY", 0),
+                NodeComment = graphNode.GetOrDefault<string>("NodeComment", string.Empty)
+            };
+
+            // Extract pins
+            foreach (var pinRef in graphNode.Pins)
+            {
+                if (pinRef is not UEdGraphPin pin) continue;
+
+                var graphPin = new AnimGraphPin
+                {
+                    PinName = pin.PinName.Text ?? string.Empty,
+                    Direction = pin.Direction,
+                    PinType = pin.PinType?.PinCategory.Text ?? string.Empty,
+                    DefaultValue = pin.DefaultValue ?? string.Empty,
+                    OwnerNode = node
+                };
+                node.Pins.Add(graphPin);
+            }
+
+            nodeMap[graphNode] = node;
+            vm.Nodes.Add(node);
+        }
+
+        // Second pass: resolve connections via LinkedTo references
+        foreach (var export in allExports)
+        {
+            if (export is not UEdGraphNode graphNode) continue;
+            if (!nodeMap.TryGetValue(graphNode, out var sourceNode)) continue;
+
+            foreach (var pinRef in graphNode.Pins)
+            {
+                if (pinRef is not UEdGraphPin pin) continue;
+
+                foreach (var linkedRef in pin.LinkedTo)
+                {
+                    if (linkedRef == null) continue;
+
+                    // Resolve the owning node of the linked pin
+                    var linkedNodeObj = linkedRef.OwningNode.ResolvedObject?.Object?.Value;
+                    if (linkedNodeObj == null || !nodeMap.TryGetValue(linkedNodeObj, out var targetNode)) continue;
+
+                    // Only add connection from output to input to avoid duplicates
+                    if (pin.Direction != EEdGraphPinDirection.EGPD_Output) continue;
+
+                    // Try to find the target pin name
+                    var targetPinName = string.Empty;
+                    if (linkedNodeObj is UEdGraphNode linkedGraphNode)
+                    {
+                        foreach (var tp in linkedGraphNode.Pins)
+                        {
+                            if (tp is UEdGraphPin targetPin && targetPin.PinId == linkedRef.PinId)
+                            {
+                                targetPinName = targetPin.PinName.Text ?? string.Empty;
+                                break;
+                            }
+                        }
+                    }
+
+                    vm.Connections.Add(new AnimGraphConnection
+                    {
+                        SourceNode = sourceNode,
+                        SourcePinName = pin.PinName.Text ?? string.Empty,
+                        TargetNode = targetNode,
+                        TargetPinName = targetPinName
+                    });
+                }
+            }
+        }
+
+        return vm;
+    }
+}
diff --git a/FModel/ViewModels/CUE4ParseViewModel.cs b/FModel/ViewModels/CUE4ParseViewModel.cs
index defb2bf0..48b40a93 100644
--- a/FModel/ViewModels/CUE4ParseViewModel.cs
+++ b/FModel/ViewModels/CUE4ParseViewModel.cs
@@ -49,6 +49,7 @@ using CUE4Parse.UE4.IO;
 using CUE4Parse.UE4.Localization;
 using CUE4Parse.UE4.Objects.Core.Serialization;
 using CUE4Parse.UE4.Objects.Engine;
+using CUE4Parse.UE4.Objects.Engine.Animation;
 using CUE4Parse.UE4.Objects.UObject;
 using CUE4Parse.UE4.Objects.UObject.Editor;
 using CUE4Parse.UE4.Oodle.Objects;
@@ -1265,6 +1266,21 @@ public class CUE4ParseViewModel : ViewModel
 
                 return false;
             }
+            case UAnimBlueprintGeneratedClass when isNone:
+            {
+                var graphVm = AnimGraphViewModel.ExtractFromPackage(pkg);
+                if (graphVm.Nodes.Count > 0)
+                {
+                    Application.Current.Dispatcher.Invoke(() =>
+                    {
+                        Helper.OpenWindow<AnimGraphViewer>("Animation Blueprint Graph Viewer", () =>
+                        {
+                            new AnimGraphViewer(graphVm).Show();
+                        });
+                    });
+                }
+                return true;
+            }
             case UWorld when isNone && UserSettings.Default.PreviewWorlds:
             case UBlueprintGeneratedClass when isNone && UserSettings.Default.PreviewWorlds && TabControl.SelectedTab.ParentExportType switch
             {
diff --git a/FModel/Views/AnimGraphViewer.xaml b/FModel/Views/AnimGraphViewer.xaml
new file mode 100644
index 00000000..55aec8d7
--- /dev/null
+++ b/FModel/Views/AnimGraphViewer.xaml
@@ -0,0 +1,60 @@
+<adonisControls:AdonisWindow x:Class="FModel.Views.AnimGraphViewer"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:converters="clr-namespace:FModel.Views.Resources.Converters"
+        xmlns:adonisUi="clr-namespace:AdonisUI;assembly=AdonisUI"
+        xmlns:adonisControls="clr-namespace:AdonisUI.Controls;assembly=AdonisUI"
+        xmlns:adonisExtensions="clr-namespace:AdonisUI.Extensions;assembly=AdonisUI"
+        WindowStartupLocation="CenterScreen" IconVisibility="Collapsed"
+        Height="{Binding Source={x:Static SystemParameters.MaximizedPrimaryScreenHeight}, Converter={converters:RatioConverter}, ConverterParameter='0.75'}"
+        Width="{Binding Source={x:Static SystemParameters.MaximizedPrimaryScreenWidth}, Converter={converters:RatioConverter}, ConverterParameter='0.75'}">
+    <adonisControls:AdonisWindow.Style>
+        <Style TargetType="adonisControls:AdonisWindow" BasedOn="{StaticResource {x:Type adonisControls:AdonisWindow}}">
+            <Setter Property="Title" Value="Animation Blueprint Graph Viewer"/>
+        </Style>
+    </adonisControls:AdonisWindow.Style>
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <!-- Toolbar -->
+        <Border Grid.Row="0" Padding="8 4"
+                Background="{DynamicResource {x:Static adonisUi:Brushes.Layer1BackgroundBrush}}"
+                adonisExtensions:LayerExtension.IncreaseLayer="True">
+            <StackPanel Orientation="Horizontal">
+                <TextBlock x:Name="PackageNameText" VerticalAlignment="Center" FontWeight="SemiBold" Margin="0 0 16 0"/>
+                <TextBlock x:Name="NodeCountText" VerticalAlignment="Center" Margin="0 0 16 0"/>
+                <TextBlock x:Name="ConnectionCountText" VerticalAlignment="Center" Margin="0 0 16 0"/>
+                <Button Content="Fit to View" MinWidth="78" Margin="4 0" Click="OnFitToView"/>
+                <Button Content="Reset Zoom" MinWidth="78" Margin="4 0" Click="OnResetZoom"/>
+            </StackPanel>
+        </Border>
+
+        <!-- Graph Canvas -->
+        <Border Grid.Row="1" ClipToBounds="True" Background="#1E1E2E"
+                MouseWheel="OnMouseWheel" MouseLeftButtonDown="OnCanvasMouseDown"
+                MouseLeftButtonUp="OnCanvasMouseUp" MouseMove="OnCanvasMouseMove">
+            <Canvas x:Name="GraphCanvas" RenderTransformOrigin="0,0">
+                <Canvas.RenderTransform>
+                    <TransformGroup>
+                        <ScaleTransform x:Name="ScaleTransform" ScaleX="1" ScaleY="1"/>
+                        <TranslateTransform x:Name="TranslateTransform" X="0" Y="0"/>
+                    </TransformGroup>
+                </Canvas.RenderTransform>
+            </Canvas>
+        </Border>
+
+        <!-- Status bar -->
+        <Border Grid.Row="2" Padding="8 4"
+                Background="{DynamicResource {x:Static adonisUi:Brushes.Layer1BackgroundBrush}}"
+                adonisExtensions:LayerExtension.IncreaseLayer="True">
+            <StackPanel Orientation="Horizontal">
+                <TextBlock x:Name="ZoomText" Text="Zoom: 100%" VerticalAlignment="Center" Margin="0 0 16 0"/>
+                <TextBlock x:Name="SelectedNodeText" VerticalAlignment="Center"/>
+            </StackPanel>
+        </Border>
+    </Grid>
+</adonisControls:AdonisWindow>
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
new file mode 100644
index 00000000..a0558bc9
--- /dev/null
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -0,0 +1,431 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Shapes;
+using CUE4Parse.UE4.Objects.Engine.EdGraph;
+using FModel.ViewModels;
+
+namespace FModel.Views;
+
+public partial class AnimGraphViewer
+{
+    private const double NodeWidth = 200;
+    private const double NodeHeaderHeight = 28;
+    private const double PinRowHeight = 22;
+    private const double PinRadius = 6;
+    private const double NodeCornerRadius = 4;
+    private const double ScaleFactor = 0.6;
+
+    private readonly AnimGraphViewModel _viewModel;
+    private readonly Dictionary<AnimGraphNode, Point> _nodePositions = new();
+    private readonly Dictionary<AnimGraphNode, (Border border, double width, double height)> _nodeVisuals = new();
+    private readonly Dictionary<(AnimGraphNode node, string pinName, EEdGraphPinDirection dir), Point> _pinPositions = new();
+
+    private bool _isPanning;
+    private Point _lastMousePos;
+
+    public AnimGraphViewer(AnimGraphViewModel viewModel)
+    {
+        _viewModel = viewModel;
+        InitializeComponent();
+        Loaded += OnLoaded;
+    }
+
+    private void OnLoaded(object sender, RoutedEventArgs e)
+    {
+        PackageNameText.Text = _viewModel.PackageName;
+        NodeCountText.Text = $"Nodes: {_viewModel.Nodes.Count}";
+        ConnectionCountText.Text = $"Connections: {_viewModel.Connections.Count}";
+
+        DrawGraph();
+        FitToView();
+    }
+
+    private void DrawGraph()
+    {
+        GraphCanvas.Children.Clear();
+        _nodePositions.Clear();
+        _nodeVisuals.Clear();
+        _pinPositions.Clear();
+
+        // Calculate positions from UE node coordinates
+        foreach (var node in _viewModel.Nodes)
+        {
+            _nodePositions[node] = new Point(node.NodePosX * ScaleFactor, node.NodePosY * ScaleFactor);
+        }
+
+        // Auto-layout nodes that have 0,0 positions
+        AutoLayoutZeroPositionNodes();
+
+        // Draw connections first (behind nodes)
+        foreach (var conn in _viewModel.Connections)
+        {
+            DrawConnection(conn);
+        }
+
+        // Draw nodes on top
+        foreach (var node in _viewModel.Nodes)
+        {
+            DrawNode(node);
+        }
+
+        // Update connection lines with actual pin positions
+        GraphCanvas.Children.OfType<Path>().ToList().ForEach(p => GraphCanvas.Children.Remove(p));
+        foreach (var conn in _viewModel.Connections)
+        {
+            DrawConnectionLine(conn);
+        }
+    }
+
+    private void AutoLayoutZeroPositionNodes()
+    {
+        var zeroNodes = _viewModel.Nodes.Where(n => n.NodePosX == 0 && n.NodePosY == 0).ToList();
+        if (zeroNodes.Count <= 1) return;
+
+        // If most nodes have zero positions, do a simple grid layout
+        var nonZeroCount = _viewModel.Nodes.Count - zeroNodes.Count;
+        if (nonZeroCount > zeroNodes.Count) return; // Only a few are zero, leave them
+
+        var cols = (int)Math.Ceiling(Math.Sqrt(zeroNodes.Count));
+        for (var i = 0; i < zeroNodes.Count; i++)
+        {
+            var col = i % cols;
+            var row = i / cols;
+            _nodePositions[zeroNodes[i]] = new Point(col * (NodeWidth + 80), row * 200);
+        }
+    }
+
+    private void DrawNode(AnimGraphNode node)
+    {
+        var pos = _nodePositions[node];
+        var inputPins = node.Pins.Where(p => p.Direction == EEdGraphPinDirection.EGPD_Input).ToList();
+        var outputPins = node.Pins.Where(p => p.Direction == EEdGraphPinDirection.EGPD_Output).ToList();
+        var maxPins = Math.Max(inputPins.Count, outputPins.Count);
+        var nodeHeight = NodeHeaderHeight + Math.Max(maxPins, 1) * PinRowHeight + 8;
+
+        // Node background
+        var border = new Border
+        {
+            Width = NodeWidth,
+            Height = nodeHeight,
+            CornerRadius = new CornerRadius(NodeCornerRadius),
+            Background = new SolidColorBrush(Color.FromRgb(45, 45, 65)),
+            BorderBrush = new SolidColorBrush(Color.FromRgb(80, 80, 110)),
+            BorderThickness = new Thickness(1),
+            SnapsToDevicePixels = true
+        };
+
+        var grid = new Grid();
+        grid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(NodeHeaderHeight) });
+        grid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
+
+        // Header
+        var headerBorder = new Border
+        {
+            Background = GetNodeHeaderBrush(node.ExportType),
+            CornerRadius = new CornerRadius(NodeCornerRadius, NodeCornerRadius, 0, 0)
+        };
+
+        var headerText = new TextBlock
+        {
+            Text = GetNodeDisplayName(node),
+            Foreground = Brushes.White,
+            FontSize = 11,
+            FontWeight = FontWeights.SemiBold,
+            VerticalAlignment = VerticalAlignment.Center,
+            HorizontalAlignment = HorizontalAlignment.Center,
+            TextTrimming = TextTrimming.CharacterEllipsis,
+            Margin = new Thickness(4, 0, 4, 0)
+        };
+        headerBorder.Child = headerText;
+        Grid.SetRow(headerBorder, 0);
+        grid.Children.Add(headerBorder);
+
+        // Pins area
+        var pinsGrid = new Grid();
+        pinsGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+        pinsGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+
+        // Input pins
+        var inputPanel = new StackPanel { Margin = new Thickness(4, 4, 0, 0) };
+        foreach (var pin in inputPins)
+        {
+            inputPanel.Children.Add(CreatePinLabel(pin, HorizontalAlignment.Left));
+        }
+        Grid.SetColumn(inputPanel, 0);
+        pinsGrid.Children.Add(inputPanel);
+
+        // Output pins
+        var outputPanel = new StackPanel { Margin = new Thickness(0, 4, 4, 0) };
+        foreach (var pin in outputPins)
+        {
+            outputPanel.Children.Add(CreatePinLabel(pin, HorizontalAlignment.Right));
+        }
+        Grid.SetColumn(outputPanel, 1);
+        pinsGrid.Children.Add(outputPanel);
+
+        Grid.SetRow(pinsGrid, 1);
+        grid.Children.Add(pinsGrid);
+
+        border.Child = grid;
+
+        Canvas.SetLeft(border, pos.X);
+        Canvas.SetTop(border, pos.Y);
+        Panel.SetZIndex(border, 1);
+        GraphCanvas.Children.Add(border);
+
+        _nodeVisuals[node] = (border, NodeWidth, nodeHeight);
+
+        // Calculate pin positions for connections
+        for (var i = 0; i < inputPins.Count; i++)
+        {
+            var pinPos = new Point(pos.X, pos.Y + NodeHeaderHeight + 4 + i * PinRowHeight + PinRowHeight / 2);
+            _pinPositions[(node, inputPins[i].PinName, EEdGraphPinDirection.EGPD_Input)] = pinPos;
+        }
+
+        for (var i = 0; i < outputPins.Count; i++)
+        {
+            var pinPos = new Point(pos.X + NodeWidth, pos.Y + NodeHeaderHeight + 4 + i * PinRowHeight + PinRowHeight / 2);
+            _pinPositions[(node, outputPins[i].PinName, EEdGraphPinDirection.EGPD_Output)] = pinPos;
+        }
+
+        // Add tooltip
+        border.ToolTip = BuildNodeTooltip(node);
+
+        // Click to select
+        border.MouseLeftButtonDown += (s, e) =>
+        {
+            SelectedNodeText.Text = $"Selected: {node.ExportType} - {node.Name}";
+            e.Handled = true;
+        };
+    }
+
+    private static TextBlock CreatePinLabel(AnimGraphPin pin, HorizontalAlignment alignment)
+    {
+        var displayName = string.IsNullOrEmpty(pin.PinName) ? "(unnamed)" : pin.PinName;
+        var pinColor = GetPinColor(pin.PinType);
+
+        return new TextBlock
+        {
+            Text = alignment == HorizontalAlignment.Left ? $"● {displayName}" : $"{displayName} ●",
+            Foreground = new SolidColorBrush(pinColor),
+            FontSize = 10,
+            Height = PinRowHeight,
+            HorizontalAlignment = alignment,
+            VerticalAlignment = VerticalAlignment.Center,
+            TextTrimming = TextTrimming.CharacterEllipsis,
+            Padding = new Thickness(2, 2, 2, 0)
+        };
+    }
+
+    private void DrawConnection(AnimGraphConnection conn)
+    {
+        // Placeholder - actual lines drawn after node layout
+    }
+
+    private void DrawConnectionLine(AnimGraphConnection conn)
+    {
+        var sourceKey = (conn.SourceNode, conn.SourcePinName, EEdGraphPinDirection.EGPD_Output);
+        var targetKey = (conn.TargetNode, conn.TargetPinName, EEdGraphPinDirection.EGPD_Input);
+
+        if (!_pinPositions.TryGetValue(sourceKey, out var startPos))
+        {
+            // Fallback: use node center-right
+            if (_nodePositions.TryGetValue(conn.SourceNode, out var srcNodePos))
+                startPos = new Point(srcNodePos.X + NodeWidth, srcNodePos.Y + NodeHeaderHeight + 10);
+            else
+                return;
+        }
+
+        if (!_pinPositions.TryGetValue(targetKey, out var endPos))
+        {
+            // Fallback: use node center-left
+            if (_nodePositions.TryGetValue(conn.TargetNode, out var tgtNodePos))
+                endPos = new Point(tgtNodePos.X, tgtNodePos.Y + NodeHeaderHeight + 10);
+            else
+                return;
+        }
+
+        var dx = Math.Abs(endPos.X - startPos.X) * 0.5;
+        var pathFigure = new PathFigure { StartPoint = startPos };
+        pathFigure.Segments.Add(new BezierSegment(
+            new Point(startPos.X + dx, startPos.Y),
+            new Point(endPos.X - dx, endPos.Y),
+            endPos, true));
+
+        var pathGeometry = new PathGeometry();
+        pathGeometry.Figures.Add(pathFigure);
+
+        var path = new Path
+        {
+            Data = pathGeometry,
+            Stroke = new SolidColorBrush(Color.FromRgb(180, 180, 200)),
+            StrokeThickness = 1.5,
+            Opacity = 0.7,
+            SnapsToDevicePixels = true
+        };
+        Panel.SetZIndex(path, 0);
+        GraphCanvas.Children.Add(path);
+    }
+
+    private static string GetNodeDisplayName(AnimGraphNode node)
+    {
+        var type = node.ExportType;
+        // Clean up common prefixes
+        if (type.StartsWith("AnimGraphNode_"))
+            type = type["AnimGraphNode_".Length..];
+        else if (type.StartsWith("K2Node_"))
+            type = type["K2Node_".Length..];
+
+        if (!string.IsNullOrEmpty(node.NodeComment))
+            return $"{type}: {node.NodeComment}";
+
+        return type;
+    }
+
+    private static Brush GetNodeHeaderBrush(string exportType)
+    {
+        return exportType switch
+        {
+            _ when exportType.Contains("AnimGraphNode") => new SolidColorBrush(Color.FromRgb(0, 120, 80)),
+            _ when exportType.Contains("K2Node") => new SolidColorBrush(Color.FromRgb(60, 60, 160)),
+            _ when exportType.Contains("State") => new SolidColorBrush(Color.FromRgb(140, 60, 20)),
+            _ when exportType.Contains("Transition") => new SolidColorBrush(Color.FromRgb(140, 120, 0)),
+            _ when exportType.Contains("Result") => new SolidColorBrush(Color.FromRgb(120, 40, 40)),
+            _ => new SolidColorBrush(Color.FromRgb(70, 70, 90))
+        };
+    }
+
+    private static Color GetPinColor(string pinType)
+    {
+        return pinType switch
+        {
+            "exec" => Color.FromRgb(255, 255, 255),
+            "bool" => Color.FromRgb(139, 0, 0),
+            "float" or "real" or "double" => Color.FromRgb(140, 255, 140),
+            "int" or "int64" => Color.FromRgb(80, 220, 180),
+            "struct" => Color.FromRgb(0, 120, 215),
+            "object" => Color.FromRgb(0, 160, 200),
+            "string" or "text" or "name" => Color.FromRgb(255, 80, 180),
+            "delegate" => Color.FromRgb(255, 56, 56),
+            "pose" => Color.FromRgb(0, 160, 100),
+            _ => Color.FromRgb(180, 180, 200)
+        };
+    }
+
+    private static string BuildNodeTooltip(AnimGraphNode node)
+    {
+        var lines = new List<string>
+        {
+            $"Name: {node.Name}",
+            $"Type: {node.ExportType}",
+            $"Position: ({node.NodePosX}, {node.NodePosY})"
+        };
+
+        if (!string.IsNullOrEmpty(node.NodeComment))
+            lines.Add($"Comment: {node.NodeComment}");
+
+        lines.Add($"Input Pins: {node.Pins.Count(p => p.Direction == EEdGraphPinDirection.EGPD_Input)}");
+        lines.Add($"Output Pins: {node.Pins.Count(p => p.Direction == EEdGraphPinDirection.EGPD_Output)}");
+
+        foreach (var pin in node.Pins)
+        {
+            var dir = pin.Direction == EEdGraphPinDirection.EGPD_Input ? "In" : "Out";
+            var defaultVal = string.IsNullOrEmpty(pin.DefaultValue) ? "" : $" = {pin.DefaultValue}";
+            lines.Add($"  [{dir}] {pin.PinName} ({pin.PinType}){defaultVal}");
+        }
+
+        return string.Join("\n", lines);
+    }
+
+    // Zoom & Pan
+    private void OnMouseWheel(object sender, MouseWheelEventArgs e)
+    {
+        var factor = e.Delta > 0 ? 1.1 : 1.0 / 1.1;
+        var pos = e.GetPosition(GraphCanvas);
+
+        ScaleTransform.ScaleX *= factor;
+        ScaleTransform.ScaleY *= factor;
+
+        // Zoom toward mouse position
+        TranslateTransform.X = pos.X * (1 - factor) + TranslateTransform.X * factor;
+        TranslateTransform.Y = pos.Y * (1 - factor) + TranslateTransform.Y * factor;
+
+        // Prevent ScaleX from going through the roof causing WPF layout issues
+        ScaleTransform.ScaleX = Math.Clamp(ScaleTransform.ScaleX, 0.05, 5.0);
+        ScaleTransform.ScaleY = Math.Clamp(ScaleTransform.ScaleY, 0.05, 5.0);
+
+        ZoomText.Text = $"Zoom: {ScaleTransform.ScaleX * 100:F0}%";
+    }
+
+    private void OnCanvasMouseDown(object sender, MouseButtonEventArgs e)
+    {
+        _isPanning = true;
+        _lastMousePos = e.GetPosition(this);
+        ((UIElement)sender).CaptureMouse();
+    }
+
+    private void OnCanvasMouseUp(object sender, MouseButtonEventArgs e)
+    {
+        _isPanning = false;
+        ((UIElement)sender).ReleaseMouseCapture();
+    }
+
+    private void OnCanvasMouseMove(object sender, MouseEventArgs e)
+    {
+        if (!_isPanning) return;
+        var currentPos = e.GetPosition(this);
+        var delta = currentPos - _lastMousePos;
+        TranslateTransform.X += delta.X;
+        TranslateTransform.Y += delta.Y;
+        _lastMousePos = currentPos;
+    }
+
+    private void OnFitToView(object sender, RoutedEventArgs e)
+    {
+        FitToView();
+    }
+
+    private void FitToView()
+    {
+        if (_nodePositions.Count == 0) return;
+
+        var minX = _nodePositions.Values.Min(p => p.X);
+        var minY = _nodePositions.Values.Min(p => p.Y);
+        var maxX = _nodePositions.Values.Max(p => p.X) + NodeWidth;
+        var maxY = _nodePositions.Values.Max(p => p.Y) + 150;
+
+        var graphWidth = maxX - minX;
+        var graphHeight = maxY - minY;
+        if (graphWidth < 1 || graphHeight < 1) return;
+
+        var viewWidth = ActualWidth > 0 ? ActualWidth : 800;
+        var viewHeight = ActualHeight > 0 ? ActualHeight - 80 : 600;
+
+        var scaleX = viewWidth / graphWidth * 0.9;
+        var scaleY = viewHeight / graphHeight * 0.9;
+        var scale = Math.Min(Math.Min(scaleX, scaleY), 2.0);
+
+        ScaleTransform.ScaleX = scale;
+        ScaleTransform.ScaleY = scale;
+
+        TranslateTransform.X = -minX * scale + (viewWidth - graphWidth * scale) / 2;
+        TranslateTransform.Y = -minY * scale + (viewHeight - graphHeight * scale) / 2;
+
+        ZoomText.Text = $"Zoom: {scale * 100:F0}%";
+    }
+
+    private void OnResetZoom(object sender, RoutedEventArgs e)
+    {
+        ScaleTransform.ScaleX = 1;
+        ScaleTransform.ScaleY = 1;
+        TranslateTransform.X = 0;
+        TranslateTransform.Y = 0;
+        ZoomText.Text = "Zoom: 100%";
+    }
+}

From 3a12c8bfc685637a876509795a132debe82636ba Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 28 Feb 2026 10:06:53 +0000
Subject: [PATCH 03/52] Address code review feedback: cleanup comment, remove
 empty method, improve null handling

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs |  3 ++-
 FModel/Views/AnimGraphViewer.xaml.cs    | 13 +------------
 2 files changed, 3 insertions(+), 13 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 9f4cf23a..6dad1d61 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -100,7 +100,8 @@ public class AnimGraphViewModel
                     if (linkedRef == null) continue;
 
                     // Resolve the owning node of the linked pin
-                    var linkedNodeObj = linkedRef.OwningNode.ResolvedObject?.Object?.Value;
+                    var resolvedObject = linkedRef.OwningNode.ResolvedObject;
+                    var linkedNodeObj = resolvedObject?.Object?.Value;
                     if (linkedNodeObj == null || !nodeMap.TryGetValue(linkedNodeObj, out var targetNode)) continue;
 
                     // Only add connection from output to input to avoid duplicates
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index a0558bc9..af582c3b 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -62,12 +62,6 @@ public partial class AnimGraphViewer
         // Auto-layout nodes that have 0,0 positions
         AutoLayoutZeroPositionNodes();
 
-        // Draw connections first (behind nodes)
-        foreach (var conn in _viewModel.Connections)
-        {
-            DrawConnection(conn);
-        }
-
         // Draw nodes on top
         foreach (var node in _viewModel.Nodes)
         {
@@ -223,11 +217,6 @@ public partial class AnimGraphViewer
         };
     }
 
-    private void DrawConnection(AnimGraphConnection conn)
-    {
-        // Placeholder - actual lines drawn after node layout
-    }
-
     private void DrawConnectionLine(AnimGraphConnection conn)
     {
         var sourceKey = (conn.SourceNode, conn.SourcePinName, EEdGraphPinDirection.EGPD_Output);
@@ -356,7 +345,7 @@ public partial class AnimGraphViewer
         TranslateTransform.X = pos.X * (1 - factor) + TranslateTransform.X * factor;
         TranslateTransform.Y = pos.Y * (1 - factor) + TranslateTransform.Y * factor;
 
-        // Prevent ScaleX from going through the roof causing WPF layout issues
+        // Prevent ScaleX from exceeding limits that would cause WPF layout issues
         ScaleTransform.ScaleX = Math.Clamp(ScaleTransform.ScaleX, 0.05, 5.0);
         ScaleTransform.ScaleY = Math.Clamp(ScaleTransform.ScaleY, 0.05, 5.0);
 

From b897cd4185b9dfbbf291264aff49fe515c1daa95 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 28 Feb 2026 10:11:10 +0000
Subject: [PATCH 04/52] Remove unused imports and constants

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index af582c3b..463fe7a2 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
@@ -17,7 +16,6 @@ public partial class AnimGraphViewer
     private const double NodeWidth = 200;
     private const double NodeHeaderHeight = 28;
     private const double PinRowHeight = 22;
-    private const double PinRadius = 6;
     private const double NodeCornerRadius = 4;
     private const double ScaleFactor = 0.6;
 

From 788cc6d4103506e70d3a976b3c0318ed8df2998c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 02:01:27 +0000
Subject: [PATCH 05/52] Fix animation blueprint node extraction to read from
 ChildProperties and CDO instead of exports

In cooked UE assets, UEdGraphNode objects are stripped as editor-only data
(PKG_FilterEditorOnly). The actual animation node information is stored in:
- UAnimBlueprintGeneratedClass.ChildProperties (FStructProperty entries describing node types)
- ClassDefaultObject properties (FStructFallback values with node data)
- FPoseLink/FComponentSpacePoseLink structs with LinkID for connections

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 267 +++++++++++++++++-------
 FModel/ViewModels/CUE4ParseViewModel.cs |   4 +-
 FModel/Views/AnimGraphViewer.xaml.cs    |  53 +++--
 3 files changed, 221 insertions(+), 103 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 6dad1d61..fd133123 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -1,9 +1,10 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using CUE4Parse.UE4.Assets;
 using CUE4Parse.UE4.Assets.Exports;
-using CUE4Parse.UE4.Assets.Exports.EdGraph;
-using CUE4Parse.UE4.Objects.Engine.EdGraph;
+using CUE4Parse.UE4.Assets.Objects;
+using CUE4Parse.UE4.Assets.Objects.Properties;
+using CUE4Parse.UE4.Objects.UObject;
 
 namespace FModel.ViewModels;
 
@@ -15,6 +16,7 @@ public class AnimGraphNode
     public int NodePosX { get; set; }
     public int NodePosY { get; set; }
     public List<AnimGraphPin> Pins { get; set; } = [];
+    public Dictionary<string, string> AdditionalProperties { get; set; } = new();
 
     public override string ToString() => $"{ExportType} ({Name})";
 }
@@ -22,7 +24,7 @@ public class AnimGraphNode
 public class AnimGraphPin
 {
     public string PinName { get; set; } = string.Empty;
-    public EEdGraphPinDirection Direction { get; set; }
+    public bool IsOutput { get; set; }
     public string PinType { get; set; } = string.Empty;
     public string DefaultValue { get; set; } = string.Empty;
     public AnimGraphNode OwnerNode { get; set; } = null!;
@@ -42,96 +44,203 @@ public class AnimGraphViewModel
     public List<AnimGraphNode> Nodes { get; } = [];
     public List<AnimGraphConnection> Connections { get; } = [];
 
-    public static AnimGraphViewModel ExtractFromPackage(IPackage package)
+    /// <summary>
+    /// Extracts animation graph node information from a UAnimBlueprintGeneratedClass.
+    /// In cooked assets, graph nodes (UEdGraphNode) are stripped as editor-only data.
+    /// The actual animation node data is stored in:
+    /// - ChildProperties (FField[]) on the class: describes the struct property types (e.g., FAnimNode_StateMachine)
+    /// - ClassDefaultObject properties: contains the actual struct values (FStructFallback) with node data
+    /// </summary>
+    public static AnimGraphViewModel ExtractFromClass(UClass animBlueprintClass)
     {
-        var vm = new AnimGraphViewModel { PackageName = package.Name };
+        var vm = new AnimGraphViewModel { PackageName = animBlueprintClass.Owner?.Name ?? animBlueprintClass.Name };
 
-        var allExports = package.GetExports().ToList();
+        // Load the ClassDefaultObject which contains the actual property values
+        var cdo = animBlueprintClass.ClassDefaultObject.Load();
 
-        // Map from UObject to AnimGraphNode for connection resolution
-        var nodeMap = new Dictionary<UObject, AnimGraphNode>();
+        // Extract animation node properties from ChildProperties metadata
+        // and their corresponding values from the CDO
+        var childProps = animBlueprintClass.ChildProperties;
+        if (childProps == null || childProps.Length == 0)
+            return vm;
 
-        // First pass: extract all graph nodes
-        foreach (var export in allExports)
+        // Collect all anim node struct properties from the class definition
+        var animNodeProps = new List<(string name, string structType)>();
+        foreach (var field in childProps)
         {
-            if (export is not UEdGraphNode graphNode) continue;
+            if (field is not FStructProperty structProp) continue;
 
-            var node = new AnimGraphNode
-            {
-                Name = graphNode.Name,
-                ExportType = graphNode.ExportType,
-                NodePosX = graphNode.GetOrDefault("NodePosX", 0),
-                NodePosY = graphNode.GetOrDefault("NodePosY", 0),
-                NodeComment = graphNode.GetOrDefault<string>("NodeComment", string.Empty)
-            };
+            var structName = structProp.Struct.ResolvedObject?.Name.Text ?? string.Empty;
+            // Animation node structs typically start with "FAnimNode_" or "AnimNode_"
+            if (!IsAnimNodeStruct(structName) && !IsAnimNodeStruct(field.Name.Text))
+                continue;
 
-            // Extract pins
-            foreach (var pinRef in graphNode.Pins)
-            {
-                if (pinRef is not UEdGraphPin pin) continue;
-
-                var graphPin = new AnimGraphPin
-                {
-                    PinName = pin.PinName.Text ?? string.Empty,
-                    Direction = pin.Direction,
-                    PinType = pin.PinType?.PinCategory.Text ?? string.Empty,
-                    DefaultValue = pin.DefaultValue ?? string.Empty,
-                    OwnerNode = node
-                };
-                node.Pins.Add(graphPin);
-            }
-
-            nodeMap[graphNode] = node;
-            vm.Nodes.Add(node);
+            animNodeProps.Add((field.Name.Text, structName));
         }
 
-        // Second pass: resolve connections via LinkedTo references
-        foreach (var export in allExports)
+        // Build nodes from the collected properties
+        var nodeByName = new Dictionary<string, AnimGraphNode>();
+        var nodeIndex = 0;
+        foreach (var (propName, structType) in animNodeProps)
         {
-            if (export is not UEdGraphNode graphNode) continue;
-            if (!nodeMap.TryGetValue(graphNode, out var sourceNode)) continue;
-
-            foreach (var pinRef in graphNode.Pins)
+            var node = new AnimGraphNode
             {
-                if (pinRef is not UEdGraphPin pin) continue;
+                Name = propName,
+                ExportType = structType,
+                NodePosX = nodeIndex % 4 * 300,
+                NodePosY = nodeIndex / 4 * 200
+            };
 
-                foreach (var linkedRef in pin.LinkedTo)
-                {
-                    if (linkedRef == null) continue;
-
-                    // Resolve the owning node of the linked pin
-                    var resolvedObject = linkedRef.OwningNode.ResolvedObject;
-                    var linkedNodeObj = resolvedObject?.Object?.Value;
-                    if (linkedNodeObj == null || !nodeMap.TryGetValue(linkedNodeObj, out var targetNode)) continue;
-
-                    // Only add connection from output to input to avoid duplicates
-                    if (pin.Direction != EEdGraphPinDirection.EGPD_Output) continue;
-
-                    // Try to find the target pin name
-                    var targetPinName = string.Empty;
-                    if (linkedNodeObj is UEdGraphNode linkedGraphNode)
-                    {
-                        foreach (var tp in linkedGraphNode.Pins)
-                        {
-                            if (tp is UEdGraphPin targetPin && targetPin.PinId == linkedRef.PinId)
-                            {
-                                targetPinName = targetPin.PinName.Text ?? string.Empty;
-                                break;
-                            }
-                        }
-                    }
-
-                    vm.Connections.Add(new AnimGraphConnection
-                    {
-                        SourceNode = sourceNode,
-                        SourcePinName = pin.PinName.Text ?? string.Empty,
-                        TargetNode = targetNode,
-                        TargetPinName = targetPinName
-                    });
-                }
+            // Try to extract property values from the CDO
+            if (cdo != null)
+            {
+                ExtractNodeProperties(cdo, propName, node);
             }
+
+            // Add a default output pin for each node
+            node.Pins.Add(new AnimGraphPin
+            {
+                PinName = "Output",
+                IsOutput = true,
+                PinType = "pose",
+                OwnerNode = node
+            });
+
+            nodeByName[propName] = node;
+            vm.Nodes.Add(node);
+            nodeIndex++;
+        }
+
+        // Resolve connections between nodes using CDO property values
+        if (cdo != null)
+        {
+            ResolveConnections(cdo, animNodeProps, nodeByName, vm);
         }
 
         return vm;
     }
+
+    private static bool IsAnimNodeStruct(string name)
+    {
+        return name.StartsWith("FAnimNode_", StringComparison.OrdinalIgnoreCase) ||
+               name.StartsWith("AnimNode_", StringComparison.OrdinalIgnoreCase) ||
+               name.StartsWith("AnimGraphNode_", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static void ExtractNodeProperties(UObject cdo, string propName, AnimGraphNode node)
+    {
+        // Try to get the struct fallback value for this node property
+        if (!cdo.TryGetValue(out FStructFallback structValue, propName))
+            return;
+
+        // Extract useful properties from the struct
+        foreach (var prop in structValue.Properties)
+        {
+            var name = prop.Name.Text;
+            var value = prop.Tag?.ToString() ?? string.Empty;
+
+            switch (name)
+            {
+                case "NodeComment":
+                    node.NodeComment = value;
+                    break;
+                default:
+                    // Store additional properties for display in tooltip
+                    if (value.Length <= 100)
+                        node.AdditionalProperties[name] = value;
+                    break;
+            }
+        }
+
+        // Add input pins based on struct properties that reference other poses/nodes
+        foreach (var prop in structValue.Properties)
+        {
+            var name = prop.Name.Text;
+
+            // Properties referencing other animation poses are connections
+            if (IsPoseProperty(name) || IsLinkedNodeProperty(name))
+            {
+                node.Pins.Add(new AnimGraphPin
+                {
+                    PinName = name,
+                    IsOutput = false,
+                    PinType = "pose",
+                    OwnerNode = node
+                });
+            }
+        }
+    }
+
+    private static bool IsPoseProperty(string name)
+    {
+        return name.Contains("Pose", StringComparison.OrdinalIgnoreCase) &&
+               !name.Contains("PoseSnapshot", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static bool IsLinkedNodeProperty(string name)
+    {
+        return name.Equals("BasePose", StringComparison.OrdinalIgnoreCase) ||
+               name.Equals("InputPose", StringComparison.OrdinalIgnoreCase) ||
+               name.Equals("SourcePose", StringComparison.OrdinalIgnoreCase) ||
+               name.Equals("ComponentPose", StringComparison.OrdinalIgnoreCase) ||
+               name.Contains("LinkedAnimGraph", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static void ResolveConnections(UObject cdo, List<(string name, string structType)> animNodeProps,
+        Dictionary<string, AnimGraphNode> nodeByName, AnimGraphViewModel vm)
+    {
+        // Animation node connections in cooked assets are encoded via
+        // FPoseLink / FComponentSpacePoseLink struct properties within each node.
+        // These contain a "LinkID" integer that maps to the index of the target node
+        // in the class's animation node property list.
+
+        foreach (var (propName, _) in animNodeProps)
+        {
+            if (!cdo.TryGetValue(out FStructFallback structValue, propName))
+                continue;
+
+            if (!nodeByName.TryGetValue(propName, out var sourceNode))
+                continue;
+
+            foreach (var prop in structValue.Properties)
+            {
+                var tag = prop.Tag;
+                if (tag == null) continue;
+
+                // Check if this property is a pose link (FPoseLink or FComponentSpacePoseLink)
+                TryResolvePoseLink(tag, prop.Name.Text, sourceNode, animNodeProps, nodeByName, vm);
+            }
+        }
+    }
+
+    private static void TryResolvePoseLink(FPropertyTagType tag, string pinName,
+        AnimGraphNode sourceNode, List<(string name, string structType)> animNodeProps,
+        Dictionary<string, AnimGraphNode> nodeByName, AnimGraphViewModel vm)
+    {
+        // A PoseLink/ComponentSpacePoseLink is a struct with a LinkID property
+        if (tag.GetValue(typeof(FStructFallback)) is not FStructFallback linkStruct)
+            return;
+
+        if (!linkStruct.TryGetValue(out int linkId, "LinkID"))
+            return;
+
+        // LinkID of -1 means not connected
+        if (linkId < 0 || linkId >= animNodeProps.Count)
+            return;
+
+        var targetPropName = animNodeProps[linkId].name;
+        if (!nodeByName.TryGetValue(targetPropName, out var targetNode))
+            return;
+
+        // Avoid self-connections
+        if (sourceNode == targetNode) return;
+
+        vm.Connections.Add(new AnimGraphConnection
+        {
+            SourceNode = targetNode,
+            SourcePinName = "Output",
+            TargetNode = sourceNode,
+            TargetPinName = pinName
+        });
+    }
 }
diff --git a/FModel/ViewModels/CUE4ParseViewModel.cs b/FModel/ViewModels/CUE4ParseViewModel.cs
index 48b40a93..efc2828f 100644
--- a/FModel/ViewModels/CUE4ParseViewModel.cs
+++ b/FModel/ViewModels/CUE4ParseViewModel.cs
@@ -1266,9 +1266,9 @@ public class CUE4ParseViewModel : ViewModel
 
                 return false;
             }
-            case UAnimBlueprintGeneratedClass when isNone:
+            case UAnimBlueprintGeneratedClass when isNone && pointer.Object.Value is UAnimBlueprintGeneratedClass animBpClass:
             {
-                var graphVm = AnimGraphViewModel.ExtractFromPackage(pkg);
+                var graphVm = AnimGraphViewModel.ExtractFromClass(animBpClass);
                 if (graphVm.Nodes.Count > 0)
                 {
                     Application.Current.Dispatcher.Invoke(() =>
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 463fe7a2..a9823ddf 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -6,7 +6,6 @@ using System.Windows.Controls;
 using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Shapes;
-using CUE4Parse.UE4.Objects.Engine.EdGraph;
 using FModel.ViewModels;
 
 namespace FModel.Views;
@@ -17,12 +16,11 @@ public partial class AnimGraphViewer
     private const double NodeHeaderHeight = 28;
     private const double PinRowHeight = 22;
     private const double NodeCornerRadius = 4;
-    private const double ScaleFactor = 0.6;
 
     private readonly AnimGraphViewModel _viewModel;
     private readonly Dictionary<AnimGraphNode, Point> _nodePositions = new();
     private readonly Dictionary<AnimGraphNode, (Border border, double width, double height)> _nodeVisuals = new();
-    private readonly Dictionary<(AnimGraphNode node, string pinName, EEdGraphPinDirection dir), Point> _pinPositions = new();
+    private readonly Dictionary<(AnimGraphNode node, string pinName, bool isOutput), Point> _pinPositions = new();
 
     private bool _isPanning;
     private Point _lastMousePos;
@@ -51,10 +49,10 @@ public partial class AnimGraphViewer
         _nodeVisuals.Clear();
         _pinPositions.Clear();
 
-        // Calculate positions from UE node coordinates
+        // Use positions from the view model (auto-layout grid positions)
         foreach (var node in _viewModel.Nodes)
         {
-            _nodePositions[node] = new Point(node.NodePosX * ScaleFactor, node.NodePosY * ScaleFactor);
+            _nodePositions[node] = new Point(node.NodePosX, node.NodePosY);
         }
 
         // Auto-layout nodes that have 0,0 positions
@@ -66,8 +64,7 @@ public partial class AnimGraphViewer
             DrawNode(node);
         }
 
-        // Update connection lines with actual pin positions
-        GraphCanvas.Children.OfType<Path>().ToList().ForEach(p => GraphCanvas.Children.Remove(p));
+        // Draw connection lines with actual pin positions
         foreach (var conn in _viewModel.Connections)
         {
             DrawConnectionLine(conn);
@@ -95,8 +92,8 @@ public partial class AnimGraphViewer
     private void DrawNode(AnimGraphNode node)
     {
         var pos = _nodePositions[node];
-        var inputPins = node.Pins.Where(p => p.Direction == EEdGraphPinDirection.EGPD_Input).ToList();
-        var outputPins = node.Pins.Where(p => p.Direction == EEdGraphPinDirection.EGPD_Output).ToList();
+        var inputPins = node.Pins.Where(p => !p.IsOutput).ToList();
+        var outputPins = node.Pins.Where(p => p.IsOutput).ToList();
         var maxPins = Math.Max(inputPins.Count, outputPins.Count);
         var nodeHeight = NodeHeaderHeight + Math.Max(maxPins, 1) * PinRowHeight + 8;
 
@@ -177,13 +174,13 @@ public partial class AnimGraphViewer
         for (var i = 0; i < inputPins.Count; i++)
         {
             var pinPos = new Point(pos.X, pos.Y + NodeHeaderHeight + 4 + i * PinRowHeight + PinRowHeight / 2);
-            _pinPositions[(node, inputPins[i].PinName, EEdGraphPinDirection.EGPD_Input)] = pinPos;
+            _pinPositions[(node, inputPins[i].PinName, false)] = pinPos;
         }
 
         for (var i = 0; i < outputPins.Count; i++)
         {
             var pinPos = new Point(pos.X + NodeWidth, pos.Y + NodeHeaderHeight + 4 + i * PinRowHeight + PinRowHeight / 2);
-            _pinPositions[(node, outputPins[i].PinName, EEdGraphPinDirection.EGPD_Output)] = pinPos;
+            _pinPositions[(node, outputPins[i].PinName, true)] = pinPos;
         }
 
         // Add tooltip
@@ -217,8 +214,8 @@ public partial class AnimGraphViewer
 
     private void DrawConnectionLine(AnimGraphConnection conn)
     {
-        var sourceKey = (conn.SourceNode, conn.SourcePinName, EEdGraphPinDirection.EGPD_Output);
-        var targetKey = (conn.TargetNode, conn.TargetPinName, EEdGraphPinDirection.EGPD_Input);
+        var sourceKey = (conn.SourceNode, conn.SourcePinName, true);
+        var targetKey = (conn.TargetNode, conn.TargetPinName, false);
 
         if (!_pinPositions.TryGetValue(sourceKey, out var startPos))
         {
@@ -263,8 +260,12 @@ public partial class AnimGraphViewer
     private static string GetNodeDisplayName(AnimGraphNode node)
     {
         var type = node.ExportType;
-        // Clean up common prefixes
-        if (type.StartsWith("AnimGraphNode_"))
+        // Clean up common prefixes for display
+        if (type.StartsWith("FAnimNode_"))
+            type = type["FAnimNode_".Length..];
+        else if (type.StartsWith("AnimNode_"))
+            type = type["AnimNode_".Length..];
+        else if (type.StartsWith("AnimGraphNode_"))
             type = type["AnimGraphNode_".Length..];
         else if (type.StartsWith("K2Node_"))
             type = type["K2Node_".Length..];
@@ -279,11 +280,13 @@ public partial class AnimGraphViewer
     {
         return exportType switch
         {
-            _ when exportType.Contains("AnimGraphNode") => new SolidColorBrush(Color.FromRgb(0, 120, 80)),
-            _ when exportType.Contains("K2Node") => new SolidColorBrush(Color.FromRgb(60, 60, 160)),
-            _ when exportType.Contains("State") => new SolidColorBrush(Color.FromRgb(140, 60, 20)),
+            _ when exportType.Contains("StateMachine") => new SolidColorBrush(Color.FromRgb(140, 60, 20)),
             _ when exportType.Contains("Transition") => new SolidColorBrush(Color.FromRgb(140, 120, 0)),
-            _ when exportType.Contains("Result") => new SolidColorBrush(Color.FromRgb(120, 40, 40)),
+            _ when exportType.Contains("BlendSpace") => new SolidColorBrush(Color.FromRgb(60, 60, 160)),
+            _ when exportType.Contains("Blend") => new SolidColorBrush(Color.FromRgb(80, 80, 160)),
+            _ when exportType.Contains("Sequence") => new SolidColorBrush(Color.FromRgb(0, 120, 120)),
+            _ when exportType.Contains("Result") || exportType.Contains("Root") => new SolidColorBrush(Color.FromRgb(120, 40, 40)),
+            _ when exportType.Contains("AnimNode") || exportType.Contains("FAnimNode") => new SolidColorBrush(Color.FromRgb(0, 120, 80)),
             _ => new SolidColorBrush(Color.FromRgb(70, 70, 90))
         };
     }
@@ -317,16 +320,22 @@ public partial class AnimGraphViewer
         if (!string.IsNullOrEmpty(node.NodeComment))
             lines.Add($"Comment: {node.NodeComment}");
 
-        lines.Add($"Input Pins: {node.Pins.Count(p => p.Direction == EEdGraphPinDirection.EGPD_Input)}");
-        lines.Add($"Output Pins: {node.Pins.Count(p => p.Direction == EEdGraphPinDirection.EGPD_Output)}");
+        lines.Add($"Input Pins: {node.Pins.Count(p => !p.IsOutput)}");
+        lines.Add($"Output Pins: {node.Pins.Count(p => p.IsOutput)}");
 
         foreach (var pin in node.Pins)
         {
-            var dir = pin.Direction == EEdGraphPinDirection.EGPD_Input ? "In" : "Out";
+            var dir = pin.IsOutput ? "Out" : "In";
             var defaultVal = string.IsNullOrEmpty(pin.DefaultValue) ? "" : $" = {pin.DefaultValue}";
             lines.Add($"  [{dir}] {pin.PinName} ({pin.PinType}){defaultVal}");
         }
 
+        // Show additional properties
+        foreach (var (key, value) in node.AdditionalProperties)
+        {
+            lines.Add($"  {key}: {value}");
+        }
+
         return string.Join("\n", lines);
     }
 

From d80132b87653cd3beeecfd17099972c1e8f5f6d6 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 02:03:04 +0000
Subject: [PATCH 06/52] Address code review feedback: extract constants,
 improve self-connection check, fix comment

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 18 ++++++++++++------
 FModel/Views/AnimGraphViewer.xaml.cs    |  2 +-
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index fd133123..6b85b367 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -40,6 +40,11 @@ public class AnimGraphConnection
 
 public class AnimGraphViewModel
 {
+    private const int GridColumns = 4;
+    private const int NodeHorizontalSpacing = 300;
+    private const int NodeVerticalSpacing = 200;
+    private const int MaxPropertyValueDisplayLength = 100;
+
     public string PackageName { get; set; } = string.Empty;
     public List<AnimGraphNode> Nodes { get; } = [];
     public List<AnimGraphConnection> Connections { get; } = [];
@@ -87,8 +92,8 @@ public class AnimGraphViewModel
             {
                 Name = propName,
                 ExportType = structType,
-                NodePosX = nodeIndex % 4 * 300,
-                NodePosY = nodeIndex / 4 * 200
+                NodePosX = nodeIndex % GridColumns * NodeHorizontalSpacing,
+                NodePosY = nodeIndex / GridColumns * NodeVerticalSpacing
             };
 
             // Try to extract property values from the CDO
@@ -146,7 +151,7 @@ public class AnimGraphViewModel
                     break;
                 default:
                     // Store additional properties for display in tooltip
-                    if (value.Length <= 100)
+                    if (value.Length <= MaxPropertyValueDisplayLength)
                         node.AdditionalProperties[name] = value;
                     break;
             }
@@ -229,11 +234,12 @@ public class AnimGraphViewModel
             return;
 
         var targetPropName = animNodeProps[linkId].name;
-        if (!nodeByName.TryGetValue(targetPropName, out var targetNode))
-            return;
 
         // Avoid self-connections
-        if (sourceNode == targetNode) return;
+        if (targetPropName == sourceNode.Name) return;
+
+        if (!nodeByName.TryGetValue(targetPropName, out var targetNode))
+            return;
 
         vm.Connections.Add(new AnimGraphConnection
         {
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index a9823ddf..1f23287c 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -64,7 +64,7 @@ public partial class AnimGraphViewer
             DrawNode(node);
         }
 
-        // Draw connection lines with actual pin positions
+        // Draw connection lines between pin positions
         foreach (var conn in _viewModel.Connections)
         {
             DrawConnectionLine(conn);

From ea5546b5cf6b318d6a94117cb7488548e5c7c75d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 02:35:34 +0000
Subject: [PATCH 07/52] Add layer tabs and properties panel to AnimGraph viewer

- AnimGraphViewModel: Add AnimGraphLayer class and BuildLayers() to group
  nodes into connected subgraphs displayed as separate tabs
- AnimGraphViewModel: Add topological layout (LayoutLayerNodes) so nodes
  flow left-to-right by dependency depth instead of grid
- AnimGraphViewer.xaml: Replace single canvas with TabControl for layers
  and a right-side properties panel with GridSplitter
- AnimGraphViewer.xaml.cs: Per-layer canvas state, node selection with
  property panel population, per-tab zoom/pan

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 213 +++++++++++-
 FModel/Views/AnimGraphViewer.xaml       |  51 ++-
 FModel/Views/AnimGraphViewer.xaml.cs    | 416 +++++++++++++++++-------
 3 files changed, 544 insertions(+), 136 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 6b85b367..6f2619a9 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -38,6 +38,18 @@ public class AnimGraphConnection
     public string TargetPinName { get; set; } = string.Empty;
 }
 
+/// <summary>
+/// Represents a layer/sub-graph within the animation blueprint,
+/// similar to how UE's Animation Blueprint editor organizes nodes
+/// into separate tabs (AnimGraph, StateMachine sub-graphs, etc.).
+/// </summary>
+public class AnimGraphLayer
+{
+    public string Name { get; set; } = string.Empty;
+    public List<AnimGraphNode> Nodes { get; } = [];
+    public List<AnimGraphConnection> Connections { get; } = [];
+}
+
 public class AnimGraphViewModel
 {
     private const int GridColumns = 4;
@@ -48,6 +60,7 @@ public class AnimGraphViewModel
     public string PackageName { get; set; } = string.Empty;
     public List<AnimGraphNode> Nodes { get; } = [];
     public List<AnimGraphConnection> Connections { get; } = [];
+    public List<AnimGraphLayer> Layers { get; } = [];
 
     /// <summary>
     /// Extracts animation graph node information from a UAnimBlueprintGeneratedClass.
@@ -85,15 +98,12 @@ public class AnimGraphViewModel
 
         // Build nodes from the collected properties
         var nodeByName = new Dictionary<string, AnimGraphNode>();
-        var nodeIndex = 0;
         foreach (var (propName, structType) in animNodeProps)
         {
             var node = new AnimGraphNode
             {
                 Name = propName,
-                ExportType = structType,
-                NodePosX = nodeIndex % GridColumns * NodeHorizontalSpacing,
-                NodePosY = nodeIndex / GridColumns * NodeVerticalSpacing
+                ExportType = structType
             };
 
             // Try to extract property values from the CDO
@@ -113,7 +123,6 @@ public class AnimGraphViewModel
 
             nodeByName[propName] = node;
             vm.Nodes.Add(node);
-            nodeIndex++;
         }
 
         // Resolve connections between nodes using CDO property values
@@ -122,9 +131,201 @@ public class AnimGraphViewModel
             ResolveConnections(cdo, animNodeProps, nodeByName, vm);
         }
 
+        // Group nodes into layers (connected subgraphs)
+        BuildLayers(vm);
+
         return vm;
     }
 
+    /// <summary>
+    /// Groups nodes into layers by finding connected components in the graph.
+    /// Each connected component becomes a separate layer/tab, named after
+    /// its most prominent node (Root, StateMachine, etc.).
+    /// </summary>
+    private static void BuildLayers(AnimGraphViewModel vm)
+    {
+        if (vm.Nodes.Count == 0) return;
+
+        // Build adjacency sets (undirected) for connected component detection
+        var adjacency = new Dictionary<AnimGraphNode, HashSet<AnimGraphNode>>();
+        foreach (var node in vm.Nodes)
+            adjacency[node] = [];
+
+        foreach (var conn in vm.Connections)
+        {
+            adjacency[conn.SourceNode].Add(conn.TargetNode);
+            adjacency[conn.TargetNode].Add(conn.SourceNode);
+        }
+
+        // Find connected components via BFS
+        var visited = new HashSet<AnimGraphNode>();
+        var components = new List<List<AnimGraphNode>>();
+
+        foreach (var node in vm.Nodes)
+        {
+            if (visited.Contains(node)) continue;
+
+            var component = new List<AnimGraphNode>();
+            var queue = new Queue<AnimGraphNode>();
+            queue.Enqueue(node);
+            visited.Add(node);
+
+            while (queue.Count > 0)
+            {
+                var current = queue.Dequeue();
+                component.Add(current);
+
+                foreach (var neighbor in adjacency[current])
+                {
+                    if (visited.Add(neighbor))
+                        queue.Enqueue(neighbor);
+                }
+            }
+
+            components.Add(component);
+        }
+
+        // Create a layer for each connected component
+        var layerIndex = 0;
+        foreach (var component in components)
+        {
+            var componentSet = new HashSet<AnimGraphNode>(component);
+            var layerName = GetLayerName(component, layerIndex);
+
+            var layer = new AnimGraphLayer { Name = layerName };
+            layer.Nodes.AddRange(component);
+
+            // Add only the connections that belong to this component
+            foreach (var conn in vm.Connections)
+            {
+                if (componentSet.Contains(conn.SourceNode) && componentSet.Contains(conn.TargetNode))
+                    layer.Connections.Add(conn);
+            }
+
+            // Layout nodes within this layer in a grid
+            LayoutLayerNodes(layer);
+
+            vm.Layers.Add(layer);
+            layerIndex++;
+        }
+    }
+
+    /// <summary>
+    /// Determines a display name for a layer based on the types of nodes it contains.
+    /// </summary>
+    private static string GetLayerName(List<AnimGraphNode> nodes, int index)
+    {
+        // Look for a prominent node type to name the layer
+        var rootNode = nodes.FirstOrDefault(n =>
+            n.ExportType.Contains("Root", StringComparison.OrdinalIgnoreCase));
+        if (rootNode != null)
+            return "AnimGraph";
+
+        var stateMachine = nodes.FirstOrDefault(n =>
+            n.ExportType.Contains("StateMachine", StringComparison.OrdinalIgnoreCase));
+        if (stateMachine != null)
+            return $"StateMachine ({stateMachine.Name})";
+
+        var blend = nodes.FirstOrDefault(n =>
+            n.ExportType.Contains("Blend", StringComparison.OrdinalIgnoreCase));
+        if (blend != null)
+            return $"Blend ({blend.Name})";
+
+        if (nodes.Count == 1)
+            return GetShortTypeName(nodes[0].ExportType);
+
+        return $"Layer {index}";
+    }
+
+    private static string GetShortTypeName(string exportType)
+    {
+        if (exportType.StartsWith("FAnimNode_"))
+            return exportType["FAnimNode_".Length..];
+        if (exportType.StartsWith("AnimNode_"))
+            return exportType["AnimNode_".Length..];
+        return exportType;
+    }
+
+    /// <summary>
+    /// Arranges nodes within a layer in a left-to-right flow layout
+    /// based on connection topology (sinks on the left, sources on the right).
+    /// </summary>
+    private static void LayoutLayerNodes(AnimGraphLayer layer)
+    {
+        if (layer.Nodes.Count == 0) return;
+
+        // Build directed adjacency: target -> sources (who feeds into target)
+        var incomingEdges = new Dictionary<AnimGraphNode, List<AnimGraphNode>>();
+        var outgoingEdges = new Dictionary<AnimGraphNode, List<AnimGraphNode>>();
+        foreach (var node in layer.Nodes)
+        {
+            incomingEdges[node] = [];
+            outgoingEdges[node] = [];
+        }
+
+        foreach (var conn in layer.Connections)
+        {
+            // SourceNode's output feeds into TargetNode's input
+            outgoingEdges[conn.SourceNode].Add(conn.TargetNode);
+            incomingEdges[conn.TargetNode].Add(conn.SourceNode);
+        }
+
+        // Topological sort to assign depth levels (longest path from leaves)
+        var depth = new Dictionary<AnimGraphNode, int>();
+        var layerSet = new HashSet<AnimGraphNode>(layer.Nodes);
+
+        // Find sink nodes (nodes with no outgoing edges within this layer)
+        var sinkNodes = layer.Nodes.Where(n => outgoingEdges[n].Count == 0).ToList();
+
+        // BFS from sinks to assign depth
+        foreach (var node in layer.Nodes)
+            depth[node] = 0;
+
+        var queue = new Queue<AnimGraphNode>();
+        foreach (var sink in sinkNodes)
+        {
+            depth[sink] = 0;
+            queue.Enqueue(sink);
+        }
+
+        while (queue.Count > 0)
+        {
+            var current = queue.Dequeue();
+            foreach (var source in incomingEdges[current])
+            {
+                var newDepth = depth[current] + 1;
+                if (newDepth > depth[source])
+                {
+                    depth[source] = newDepth;
+                    queue.Enqueue(source);
+                }
+            }
+        }
+
+        // Group by depth level and assign positions
+        var maxDepth = depth.Values.DefaultIfEmpty(0).Max();
+        var nodesAtDepth = new Dictionary<int, List<AnimGraphNode>>();
+        foreach (var (node, d) in depth)
+        {
+            if (!nodesAtDepth.TryGetValue(d, out var list))
+                nodesAtDepth[d] = list = [];
+            list.Add(node);
+        }
+
+        // Position: sources (high depth) on the right, sinks (depth 0) on the left
+        for (var d = 0; d <= maxDepth; d++)
+        {
+            if (!nodesAtDepth.TryGetValue(d, out var nodesInColumn)) continue;
+
+            var x = (maxDepth - d) * NodeHorizontalSpacing;
+            for (var i = 0; i < nodesInColumn.Count; i++)
+            {
+                nodesInColumn[i].NodePosX = x;
+                nodesInColumn[i].NodePosY = i * NodeVerticalSpacing;
+            }
+        }
+    }
+
     private static bool IsAnimNodeStruct(string name)
     {
         return name.StartsWith("FAnimNode_", StringComparison.OrdinalIgnoreCase) ||
@@ -150,7 +351,7 @@ public class AnimGraphViewModel
                     node.NodeComment = value;
                     break;
                 default:
-                    // Store additional properties for display in tooltip
+                    // Store additional properties for display
                     if (value.Length <= MaxPropertyValueDisplayLength)
                         node.AdditionalProperties[name] = value;
                     break;
diff --git a/FModel/Views/AnimGraphViewer.xaml b/FModel/Views/AnimGraphViewer.xaml
index 55aec8d7..76e204f7 100644
--- a/FModel/Views/AnimGraphViewer.xaml
+++ b/FModel/Views/AnimGraphViewer.xaml
@@ -33,19 +33,44 @@
             </StackPanel>
         </Border>
 
-        <!-- Graph Canvas -->
-        <Border Grid.Row="1" ClipToBounds="True" Background="#1E1E2E"
-                MouseWheel="OnMouseWheel" MouseLeftButtonDown="OnCanvasMouseDown"
-                MouseLeftButtonUp="OnCanvasMouseUp" MouseMove="OnCanvasMouseMove">
-            <Canvas x:Name="GraphCanvas" RenderTransformOrigin="0,0">
-                <Canvas.RenderTransform>
-                    <TransformGroup>
-                        <ScaleTransform x:Name="ScaleTransform" ScaleX="1" ScaleY="1"/>
-                        <TranslateTransform x:Name="TranslateTransform" X="0" Y="0"/>
-                    </TransformGroup>
-                </Canvas.RenderTransform>
-            </Canvas>
-        </Border>
+        <!-- Main content: Graph + Properties panel -->
+        <Grid Grid.Row="1">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" MinWidth="200"/>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="280" MinWidth="200"/>
+            </Grid.ColumnDefinitions>
+
+            <!-- Layer tabs with graph canvas -->
+            <TabControl x:Name="LayerTabControl" Grid.Column="0" SelectionChanged="OnLayerTabChanged"
+                        Background="{DynamicResource {x:Static adonisUi:Brushes.Layer0BackgroundBrush}}"/>
+
+            <GridSplitter Grid.Column="1" Width="4" HorizontalAlignment="Center" VerticalAlignment="Stretch"
+                          Background="{DynamicResource {x:Static adonisUi:Brushes.Layer1BorderBrush}}"/>
+
+            <!-- Node properties panel -->
+            <Border Grid.Column="2"
+                    Background="{DynamicResource {x:Static adonisUi:Brushes.Layer1BackgroundBrush}}"
+                    adonisExtensions:LayerExtension.IncreaseLayer="True">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                    </Grid.RowDefinitions>
+
+                    <!-- Properties header -->
+                    <Border Grid.Row="0" Padding="8 6"
+                            Background="{DynamicResource {x:Static adonisUi:Brushes.Layer2BackgroundBrush}}">
+                        <TextBlock x:Name="PropertiesTitleText" Text="Properties" FontWeight="SemiBold" FontSize="13"/>
+                    </Border>
+
+                    <!-- Properties list -->
+                    <ScrollViewer Grid.Row="1" VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto">
+                        <StackPanel x:Name="PropertiesPanel" Margin="8 4"/>
+                    </ScrollViewer>
+                </Grid>
+            </Border>
+        </Grid>
 
         <!-- Status bar -->
         <Border Grid.Row="2" Padding="8 4"
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 1f23287c..abcd2cc2 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -18,9 +18,14 @@ public partial class AnimGraphViewer
     private const double NodeCornerRadius = 4;
 
     private readonly AnimGraphViewModel _viewModel;
-    private readonly Dictionary<AnimGraphNode, Point> _nodePositions = new();
-    private readonly Dictionary<AnimGraphNode, (Border border, double width, double height)> _nodeVisuals = new();
-    private readonly Dictionary<(AnimGraphNode node, string pinName, bool isOutput), Point> _pinPositions = new();
+
+    // Per-layer state
+    private readonly Dictionary<AnimGraphLayer, LayerCanvasState> _layerStates = new();
+    private LayerCanvasState? _currentLayerState;
+
+    // Currently selected node (for properties panel)
+    private AnimGraphNode? _selectedNode;
+    private Border? _selectedBorder;
 
     private bool _isPanning;
     private Point _lastMousePos;
@@ -38,60 +43,122 @@ public partial class AnimGraphViewer
         NodeCountText.Text = $"Nodes: {_viewModel.Nodes.Count}";
         ConnectionCountText.Text = $"Connections: {_viewModel.Connections.Count}";
 
-        DrawGraph();
-        FitToView();
+        BuildLayerTabs();
     }
 
-    private void DrawGraph()
+    /// <summary>
+    /// Creates a tab for each layer in the animation graph.
+    /// Each tab contains its own canvas with zoom/pan support.
+    /// </summary>
+    private void BuildLayerTabs()
     {
-        GraphCanvas.Children.Clear();
-        _nodePositions.Clear();
-        _nodeVisuals.Clear();
-        _pinPositions.Clear();
+        LayerTabControl.Items.Clear();
+        _layerStates.Clear();
 
-        // Use positions from the view model (auto-layout grid positions)
-        foreach (var node in _viewModel.Nodes)
+        // If no layers were built (empty graph), show nothing
+        if (_viewModel.Layers.Count == 0)
+            return;
+
+        foreach (var layer in _viewModel.Layers)
         {
-            _nodePositions[node] = new Point(node.NodePosX, node.NodePosY);
+            var tabItem = new System.Windows.Controls.TabItem
+            {
+                Header = layer.Name,
+                Tag = layer
+            };
+
+            // Create canvas container for this layer
+            var canvasBorder = new Border
+            {
+                ClipToBounds = true,
+                Background = new SolidColorBrush(Color.FromRgb(30, 30, 46))
+            };
+
+            var canvas = new Canvas { RenderTransformOrigin = new Point(0, 0) };
+            var scaleTransform = new ScaleTransform(1, 1);
+            var translateTransform = new TranslateTransform(0, 0);
+            var transformGroup = new TransformGroup();
+            transformGroup.Children.Add(scaleTransform);
+            transformGroup.Children.Add(translateTransform);
+            canvas.RenderTransform = transformGroup;
+
+            canvasBorder.Child = canvas;
+            canvasBorder.MouseWheel += OnMouseWheel;
+            canvasBorder.MouseLeftButtonDown += OnCanvasMouseDown;
+            canvasBorder.MouseLeftButtonUp += OnCanvasMouseUp;
+            canvasBorder.MouseMove += OnCanvasMouseMove;
+
+            tabItem.Content = canvasBorder;
+
+            var state = new LayerCanvasState
+            {
+                Layer = layer,
+                Canvas = canvas,
+                ScaleTransform = scaleTransform,
+                TranslateTransform = translateTransform
+            };
+            _layerStates[layer] = state;
+
+            LayerTabControl.Items.Add(tabItem);
         }
 
-        // Auto-layout nodes that have 0,0 positions
-        AutoLayoutZeroPositionNodes();
+        // Select the first tab
+        if (LayerTabControl.Items.Count > 0)
+            LayerTabControl.SelectedIndex = 0;
+    }
 
-        // Draw nodes on top
-        foreach (var node in _viewModel.Nodes)
+    private void OnLayerTabChanged(object sender, SelectionChangedEventArgs e)
+    {
+        if (LayerTabControl.SelectedItem is not System.Windows.Controls.TabItem { Tag: AnimGraphLayer layer })
+            return;
+
+        if (!_layerStates.TryGetValue(layer, out var state))
+            return;
+
+        _currentLayerState = state;
+
+        // Draw graph for this layer if not yet drawn
+        if (!state.IsDrawn)
         {
-            DrawNode(node);
+            DrawLayerGraph(state);
+            state.IsDrawn = true;
+
+            // Fit to view after first draw
+            Dispatcher.BeginInvoke(new Action(() => FitToView(state)));
         }
 
-        // Draw connection lines between pin positions
-        foreach (var conn in _viewModel.Connections)
+        ZoomText.Text = $"Zoom: {state.ScaleTransform.ScaleX * 100:F0}%";
+    }
+
+    private void DrawLayerGraph(LayerCanvasState state)
+    {
+        state.Canvas.Children.Clear();
+        state.NodePositions.Clear();
+        state.NodeVisuals.Clear();
+        state.PinPositions.Clear();
+
+        // Use positions from the view model
+        foreach (var node in state.Layer.Nodes)
         {
-            DrawConnectionLine(conn);
+            state.NodePositions[node] = new Point(node.NodePosX, node.NodePosY);
+        }
+
+        // Draw nodes
+        foreach (var node in state.Layer.Nodes)
+        {
+            DrawNode(state, node);
+        }
+
+        // Draw connections
+        foreach (var conn in state.Layer.Connections)
+        {
+            DrawConnectionLine(state, conn);
         }
     }
 
-    private void AutoLayoutZeroPositionNodes()
+    private void DrawNode(LayerCanvasState state, AnimGraphNode node)
     {
-        var zeroNodes = _viewModel.Nodes.Where(n => n.NodePosX == 0 && n.NodePosY == 0).ToList();
-        if (zeroNodes.Count <= 1) return;
-
-        // If most nodes have zero positions, do a simple grid layout
-        var nonZeroCount = _viewModel.Nodes.Count - zeroNodes.Count;
-        if (nonZeroCount > zeroNodes.Count) return; // Only a few are zero, leave them
-
-        var cols = (int)Math.Ceiling(Math.Sqrt(zeroNodes.Count));
-        for (var i = 0; i < zeroNodes.Count; i++)
-        {
-            var col = i % cols;
-            var row = i / cols;
-            _nodePositions[zeroNodes[i]] = new Point(col * (NodeWidth + 80), row * 200);
-        }
-    }
-
-    private void DrawNode(AnimGraphNode node)
-    {
-        var pos = _nodePositions[node];
+        var pos = state.NodePositions[node];
         var inputPins = node.Pins.Where(p => !p.IsOutput).ToList();
         var outputPins = node.Pins.Where(p => p.IsOutput).ToList();
         var maxPins = Math.Max(inputPins.Count, outputPins.Count);
@@ -106,7 +173,8 @@ public partial class AnimGraphViewer
             Background = new SolidColorBrush(Color.FromRgb(45, 45, 65)),
             BorderBrush = new SolidColorBrush(Color.FromRgb(80, 80, 110)),
             BorderThickness = new Thickness(1),
-            SnapsToDevicePixels = true
+            SnapsToDevicePixels = true,
+            Cursor = Cursors.Hand
         };
 
         var grid = new Grid();
@@ -166,34 +234,157 @@ public partial class AnimGraphViewer
         Canvas.SetLeft(border, pos.X);
         Canvas.SetTop(border, pos.Y);
         Panel.SetZIndex(border, 1);
-        GraphCanvas.Children.Add(border);
+        state.Canvas.Children.Add(border);
 
-        _nodeVisuals[node] = (border, NodeWidth, nodeHeight);
+        state.NodeVisuals[node] = (border, NodeWidth, nodeHeight);
 
         // Calculate pin positions for connections
         for (var i = 0; i < inputPins.Count; i++)
         {
             var pinPos = new Point(pos.X, pos.Y + NodeHeaderHeight + 4 + i * PinRowHeight + PinRowHeight / 2);
-            _pinPositions[(node, inputPins[i].PinName, false)] = pinPos;
+            state.PinPositions[(node, inputPins[i].PinName, false)] = pinPos;
         }
 
         for (var i = 0; i < outputPins.Count; i++)
         {
             var pinPos = new Point(pos.X + NodeWidth, pos.Y + NodeHeaderHeight + 4 + i * PinRowHeight + PinRowHeight / 2);
-            _pinPositions[(node, outputPins[i].PinName, true)] = pinPos;
+            state.PinPositions[(node, outputPins[i].PinName, true)] = pinPos;
         }
 
-        // Add tooltip
-        border.ToolTip = BuildNodeTooltip(node);
+        // Add tooltip with basic info
+        border.ToolTip = $"{node.ExportType}\n{node.Name}";
 
-        // Click to select
+        // Click to select node and show properties
         border.MouseLeftButtonDown += (s, e) =>
         {
-            SelectedNodeText.Text = $"Selected: {node.ExportType} - {node.Name}";
+            SelectNode(node, border);
             e.Handled = true;
         };
     }
 
+    /// <summary>
+    /// Selects a node and populates the properties panel with its details.
+    /// </summary>
+    private void SelectNode(AnimGraphNode node, Border border)
+    {
+        // Deselect previous
+        if (_selectedBorder != null)
+        {
+            _selectedBorder.BorderBrush = new SolidColorBrush(Color.FromRgb(80, 80, 110));
+            _selectedBorder.BorderThickness = new Thickness(1);
+        }
+
+        // Highlight selected
+        _selectedNode = node;
+        _selectedBorder = border;
+        border.BorderBrush = new SolidColorBrush(Color.FromRgb(0, 160, 255));
+        border.BorderThickness = new Thickness(2);
+
+        SelectedNodeText.Text = $"Selected: {node.ExportType} - {node.Name}";
+        PopulatePropertiesPanel(node);
+    }
+
+    /// <summary>
+    /// Fills the properties panel with the selected node's information,
+    /// similar to UE's Details panel when a node is selected.
+    /// </summary>
+    private void PopulatePropertiesPanel(AnimGraphNode node)
+    {
+        PropertiesPanel.Children.Clear();
+        PropertiesTitleText.Text = $"Properties - {GetNodeDisplayName(node)}";
+
+        // Node header section
+        AddPropertySection("Node Info");
+        AddPropertyRow("Name", node.Name);
+        AddPropertyRow("Type", node.ExportType);
+        if (!string.IsNullOrEmpty(node.NodeComment))
+            AddPropertyRow("Comment", node.NodeComment);
+
+        // Pins section
+        var inputPins = node.Pins.Where(p => !p.IsOutput).ToList();
+        var outputPins = node.Pins.Where(p => p.IsOutput).ToList();
+
+        if (inputPins.Count > 0)
+        {
+            AddPropertySection("Input Pins");
+            foreach (var pin in inputPins)
+            {
+                var defaultVal = string.IsNullOrEmpty(pin.DefaultValue) ? "" : $" = {pin.DefaultValue}";
+                AddPropertyRow(pin.PinName, $"{pin.PinType}{defaultVal}");
+            }
+        }
+
+        if (outputPins.Count > 0)
+        {
+            AddPropertySection("Output Pins");
+            foreach (var pin in outputPins)
+            {
+                AddPropertyRow(pin.PinName, pin.PinType);
+            }
+        }
+
+        // Additional properties
+        if (node.AdditionalProperties.Count > 0)
+        {
+            AddPropertySection("Details");
+            foreach (var (key, value) in node.AdditionalProperties)
+            {
+                AddPropertyRow(key, value);
+            }
+        }
+    }
+
+    private void AddPropertySection(string title)
+    {
+        PropertiesPanel.Children.Add(new TextBlock
+        {
+            Text = title,
+            FontWeight = FontWeights.SemiBold,
+            FontSize = 12,
+            Margin = new Thickness(0, PropertiesPanel.Children.Count > 0 ? 12 : 4, 0, 4),
+            Foreground = new SolidColorBrush(Color.FromRgb(180, 200, 220))
+        });
+
+        PropertiesPanel.Children.Add(new Separator
+        {
+            Margin = new Thickness(0, 0, 0, 4),
+            Opacity = 0.3
+        });
+    }
+
+    private void AddPropertyRow(string key, string value)
+    {
+        var rowGrid = new Grid { Margin = new Thickness(0, 1, 0, 1) };
+        rowGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(100) });
+        rowGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+
+        var keyText = new TextBlock
+        {
+            Text = key,
+            FontSize = 11,
+            Foreground = new SolidColorBrush(Color.FromRgb(140, 160, 180)),
+            TextTrimming = TextTrimming.CharacterEllipsis,
+            VerticalAlignment = VerticalAlignment.Top,
+            Margin = new Thickness(4, 2, 4, 2)
+        };
+        Grid.SetColumn(keyText, 0);
+        rowGrid.Children.Add(keyText);
+
+        var valueText = new TextBlock
+        {
+            Text = value,
+            FontSize = 11,
+            Foreground = new SolidColorBrush(Color.FromRgb(220, 220, 240)),
+            TextWrapping = TextWrapping.Wrap,
+            VerticalAlignment = VerticalAlignment.Top,
+            Margin = new Thickness(4, 2, 4, 2)
+        };
+        Grid.SetColumn(valueText, 1);
+        rowGrid.Children.Add(valueText);
+
+        PropertiesPanel.Children.Add(rowGrid);
+    }
+
     private static TextBlock CreatePinLabel(AnimGraphPin pin, HorizontalAlignment alignment)
     {
         var displayName = string.IsNullOrEmpty(pin.PinName) ? "(unnamed)" : pin.PinName;
@@ -212,24 +403,24 @@ public partial class AnimGraphViewer
         };
     }
 
-    private void DrawConnectionLine(AnimGraphConnection conn)
+    private void DrawConnectionLine(LayerCanvasState state, AnimGraphConnection conn)
     {
         var sourceKey = (conn.SourceNode, conn.SourcePinName, true);
         var targetKey = (conn.TargetNode, conn.TargetPinName, false);
 
-        if (!_pinPositions.TryGetValue(sourceKey, out var startPos))
+        if (!state.PinPositions.TryGetValue(sourceKey, out var startPos))
         {
             // Fallback: use node center-right
-            if (_nodePositions.TryGetValue(conn.SourceNode, out var srcNodePos))
+            if (state.NodePositions.TryGetValue(conn.SourceNode, out var srcNodePos))
                 startPos = new Point(srcNodePos.X + NodeWidth, srcNodePos.Y + NodeHeaderHeight + 10);
             else
                 return;
         }
 
-        if (!_pinPositions.TryGetValue(targetKey, out var endPos))
+        if (!state.PinPositions.TryGetValue(targetKey, out var endPos))
         {
             // Fallback: use node center-left
-            if (_nodePositions.TryGetValue(conn.TargetNode, out var tgtNodePos))
+            if (state.NodePositions.TryGetValue(conn.TargetNode, out var tgtNodePos))
                 endPos = new Point(tgtNodePos.X, tgtNodePos.Y + NodeHeaderHeight + 10);
             else
                 return;
@@ -254,7 +445,7 @@ public partial class AnimGraphViewer
             SnapsToDevicePixels = true
         };
         Panel.SetZIndex(path, 0);
-        GraphCanvas.Children.Add(path);
+        state.Canvas.Children.Add(path);
     }
 
     private static string GetNodeDisplayName(AnimGraphNode node)
@@ -308,55 +499,26 @@ public partial class AnimGraphViewer
         };
     }
 
-    private static string BuildNodeTooltip(AnimGraphNode node)
-    {
-        var lines = new List<string>
-        {
-            $"Name: {node.Name}",
-            $"Type: {node.ExportType}",
-            $"Position: ({node.NodePosX}, {node.NodePosY})"
-        };
-
-        if (!string.IsNullOrEmpty(node.NodeComment))
-            lines.Add($"Comment: {node.NodeComment}");
-
-        lines.Add($"Input Pins: {node.Pins.Count(p => !p.IsOutput)}");
-        lines.Add($"Output Pins: {node.Pins.Count(p => p.IsOutput)}");
-
-        foreach (var pin in node.Pins)
-        {
-            var dir = pin.IsOutput ? "Out" : "In";
-            var defaultVal = string.IsNullOrEmpty(pin.DefaultValue) ? "" : $" = {pin.DefaultValue}";
-            lines.Add($"  [{dir}] {pin.PinName} ({pin.PinType}){defaultVal}");
-        }
-
-        // Show additional properties
-        foreach (var (key, value) in node.AdditionalProperties)
-        {
-            lines.Add($"  {key}: {value}");
-        }
-
-        return string.Join("\n", lines);
-    }
-
     // Zoom & Pan
     private void OnMouseWheel(object sender, MouseWheelEventArgs e)
     {
-        var factor = e.Delta > 0 ? 1.1 : 1.0 / 1.1;
-        var pos = e.GetPosition(GraphCanvas);
+        if (_currentLayerState == null) return;
 
-        ScaleTransform.ScaleX *= factor;
-        ScaleTransform.ScaleY *= factor;
+        var factor = e.Delta > 0 ? 1.1 : 1.0 / 1.1;
+        var pos = e.GetPosition(_currentLayerState.Canvas);
+
+        _currentLayerState.ScaleTransform.ScaleX *= factor;
+        _currentLayerState.ScaleTransform.ScaleY *= factor;
 
         // Zoom toward mouse position
-        TranslateTransform.X = pos.X * (1 - factor) + TranslateTransform.X * factor;
-        TranslateTransform.Y = pos.Y * (1 - factor) + TranslateTransform.Y * factor;
+        _currentLayerState.TranslateTransform.X = pos.X * (1 - factor) + _currentLayerState.TranslateTransform.X * factor;
+        _currentLayerState.TranslateTransform.Y = pos.Y * (1 - factor) + _currentLayerState.TranslateTransform.Y * factor;
 
-        // Prevent ScaleX from exceeding limits that would cause WPF layout issues
-        ScaleTransform.ScaleX = Math.Clamp(ScaleTransform.ScaleX, 0.05, 5.0);
-        ScaleTransform.ScaleY = Math.Clamp(ScaleTransform.ScaleY, 0.05, 5.0);
+        // Clamp scale
+        _currentLayerState.ScaleTransform.ScaleX = Math.Clamp(_currentLayerState.ScaleTransform.ScaleX, 0.05, 5.0);
+        _currentLayerState.ScaleTransform.ScaleY = Math.Clamp(_currentLayerState.ScaleTransform.ScaleY, 0.05, 5.0);
 
-        ZoomText.Text = $"Zoom: {ScaleTransform.ScaleX * 100:F0}%";
+        ZoomText.Text = $"Zoom: {_currentLayerState.ScaleTransform.ScaleX * 100:F0}%";
     }
 
     private void OnCanvasMouseDown(object sender, MouseButtonEventArgs e)
@@ -374,54 +536,74 @@ public partial class AnimGraphViewer
 
     private void OnCanvasMouseMove(object sender, MouseEventArgs e)
     {
-        if (!_isPanning) return;
+        if (!_isPanning || _currentLayerState == null) return;
         var currentPos = e.GetPosition(this);
         var delta = currentPos - _lastMousePos;
-        TranslateTransform.X += delta.X;
-        TranslateTransform.Y += delta.Y;
+        _currentLayerState.TranslateTransform.X += delta.X;
+        _currentLayerState.TranslateTransform.Y += delta.Y;
         _lastMousePos = currentPos;
     }
 
     private void OnFitToView(object sender, RoutedEventArgs e)
     {
-        FitToView();
+        if (_currentLayerState != null)
+            FitToView(_currentLayerState);
     }
 
-    private void FitToView()
+    private void FitToView(LayerCanvasState state)
     {
-        if (_nodePositions.Count == 0) return;
+        if (state.NodePositions.Count == 0) return;
 
-        var minX = _nodePositions.Values.Min(p => p.X);
-        var minY = _nodePositions.Values.Min(p => p.Y);
-        var maxX = _nodePositions.Values.Max(p => p.X) + NodeWidth;
-        var maxY = _nodePositions.Values.Max(p => p.Y) + 150;
+        var minX = state.NodePositions.Values.Min(p => p.X);
+        var minY = state.NodePositions.Values.Min(p => p.Y);
+        var maxX = state.NodePositions.Values.Max(p => p.X) + NodeWidth;
+        var maxY = state.NodePositions.Values.Max(p => p.Y) + 150;
 
         var graphWidth = maxX - minX;
         var graphHeight = maxY - minY;
         if (graphWidth < 1 || graphHeight < 1) return;
 
-        var viewWidth = ActualWidth > 0 ? ActualWidth : 800;
-        var viewHeight = ActualHeight > 0 ? ActualHeight - 80 : 600;
+        // Get available size from the tab content area
+        var tabContent = LayerTabControl.SelectedContent as FrameworkElement;
+        var viewWidth = tabContent?.ActualWidth > 0 ? tabContent.ActualWidth : (ActualWidth > 0 ? ActualWidth * 0.65 : 800);
+        var viewHeight = tabContent?.ActualHeight > 0 ? tabContent.ActualHeight : (ActualHeight > 0 ? ActualHeight - 120 : 600);
 
         var scaleX = viewWidth / graphWidth * 0.9;
         var scaleY = viewHeight / graphHeight * 0.9;
         var scale = Math.Min(Math.Min(scaleX, scaleY), 2.0);
 
-        ScaleTransform.ScaleX = scale;
-        ScaleTransform.ScaleY = scale;
+        state.ScaleTransform.ScaleX = scale;
+        state.ScaleTransform.ScaleY = scale;
 
-        TranslateTransform.X = -minX * scale + (viewWidth - graphWidth * scale) / 2;
-        TranslateTransform.Y = -minY * scale + (viewHeight - graphHeight * scale) / 2;
+        state.TranslateTransform.X = -minX * scale + (viewWidth - graphWidth * scale) / 2;
+        state.TranslateTransform.Y = -minY * scale + (viewHeight - graphHeight * scale) / 2;
 
         ZoomText.Text = $"Zoom: {scale * 100:F0}%";
     }
 
     private void OnResetZoom(object sender, RoutedEventArgs e)
     {
-        ScaleTransform.ScaleX = 1;
-        ScaleTransform.ScaleY = 1;
-        TranslateTransform.X = 0;
-        TranslateTransform.Y = 0;
+        if (_currentLayerState == null) return;
+        _currentLayerState.ScaleTransform.ScaleX = 1;
+        _currentLayerState.ScaleTransform.ScaleY = 1;
+        _currentLayerState.TranslateTransform.X = 0;
+        _currentLayerState.TranslateTransform.Y = 0;
         ZoomText.Text = "Zoom: 100%";
     }
+
+    /// <summary>
+    /// Holds per-layer canvas state (positions, visuals, transforms).
+    /// </summary>
+    private class LayerCanvasState
+    {
+        public AnimGraphLayer Layer { get; init; } = null!;
+        public Canvas Canvas { get; init; } = null!;
+        public ScaleTransform ScaleTransform { get; init; } = null!;
+        public TranslateTransform TranslateTransform { get; init; } = null!;
+        public bool IsDrawn { get; set; }
+
+        public Dictionary<AnimGraphNode, Point> NodePositions { get; } = new();
+        public Dictionary<AnimGraphNode, (Border border, double width, double height)> NodeVisuals { get; } = new();
+        public Dictionary<(AnimGraphNode node, string pinName, bool isOutput), Point> PinPositions { get; } = new();
+    }
 }

From e5eac1702b52567f9203e4af2708da06f9b7adc3 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 02:40:09 +0000
Subject: [PATCH 08/52] Address code review feedback: remove redundant
 assignments, extract constants

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 1 -
 FModel/Views/AnimGraphViewer.xaml.cs    | 7 ++++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 6f2619a9..c1b9bb5b 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -284,7 +284,6 @@ public class AnimGraphViewModel
         var queue = new Queue<AnimGraphNode>();
         foreach (var sink in sinkNodes)
         {
-            depth[sink] = 0;
             queue.Enqueue(sink);
         }
 
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index abcd2cc2..45b34372 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -16,6 +16,7 @@ public partial class AnimGraphViewer
     private const double NodeHeaderHeight = 28;
     private const double PinRowHeight = 22;
     private const double NodeCornerRadius = 4;
+    private const double DefaultGraphWidthRatio = 0.65;
 
     private readonly AnimGraphViewModel _viewModel;
 
@@ -74,7 +75,7 @@ public partial class AnimGraphViewer
                 Background = new SolidColorBrush(Color.FromRgb(30, 30, 46))
             };
 
-            var canvas = new Canvas { RenderTransformOrigin = new Point(0, 0) };
+            var canvas = new Canvas();
             var scaleTransform = new ScaleTransform(1, 1);
             var translateTransform = new TranslateTransform(0, 0);
             var transformGroup = new TransformGroup();
@@ -124,7 +125,7 @@ public partial class AnimGraphViewer
             state.IsDrawn = true;
 
             // Fit to view after first draw
-            Dispatcher.BeginInvoke(new Action(() => FitToView(state)));
+            Dispatcher.BeginInvoke(() => FitToView(state));
         }
 
         ZoomText.Text = $"Zoom: {state.ScaleTransform.ScaleX * 100:F0}%";
@@ -565,7 +566,7 @@ public partial class AnimGraphViewer
 
         // Get available size from the tab content area
         var tabContent = LayerTabControl.SelectedContent as FrameworkElement;
-        var viewWidth = tabContent?.ActualWidth > 0 ? tabContent.ActualWidth : (ActualWidth > 0 ? ActualWidth * 0.65 : 800);
+        var viewWidth = tabContent?.ActualWidth > 0 ? tabContent.ActualWidth : (ActualWidth > 0 ? ActualWidth * DefaultGraphWidthRatio : 800);
         var viewHeight = tabContent?.ActualHeight > 0 ? tabContent.ActualHeight : (ActualHeight > 0 ? ActualHeight - 120 : 600);
 
         var scaleX = viewWidth / graphWidth * 0.9;

From 3280bfeb258a6382a45c5a6ea30b875e14957332 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 02:50:47 +0000
Subject: [PATCH 09/52] Fix zoom jumping and improve connection line visibility

- Fix OnMouseWheel: get mouse position relative to parent Border (stable
  coords) instead of Canvas (transformed coords that shift during zoom);
  compute canvas-local point manually and preserve it after scale change
- Fix OnCanvasMouseDown/Move: use parent Border coords for consistent
  panning behavior
- Improve connection lines: thicker stroke (2px), higher opacity (0.8),
  minimum bezier tangent length (50px) for smoother short-distance curves

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 39 ++++++++++++++++------------
 1 file changed, 23 insertions(+), 16 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 45b34372..ae249100 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -427,7 +427,8 @@ public partial class AnimGraphViewer
                 return;
         }
 
-        var dx = Math.Abs(endPos.X - startPos.X) * 0.5;
+        // Ensure a minimum tangent length for smooth curves even when nodes are close
+        var dx = Math.Max(Math.Abs(endPos.X - startPos.X) * 0.5, 50);
         var pathFigure = new PathFigure { StartPoint = startPos };
         pathFigure.Segments.Add(new BezierSegment(
             new Point(startPos.X + dx, startPos.Y),
@@ -440,9 +441,9 @@ public partial class AnimGraphViewer
         var path = new Path
         {
             Data = pathGeometry,
-            Stroke = new SolidColorBrush(Color.FromRgb(180, 180, 200)),
-            StrokeThickness = 1.5,
-            Opacity = 0.7,
+            Stroke = new SolidColorBrush(Color.FromRgb(200, 200, 220)),
+            StrokeThickness = 2,
+            Opacity = 0.8,
             SnapsToDevicePixels = true
         };
         Panel.SetZIndex(path, 0);
@@ -506,26 +507,32 @@ public partial class AnimGraphViewer
         if (_currentLayerState == null) return;
 
         var factor = e.Delta > 0 ? 1.1 : 1.0 / 1.1;
-        var pos = e.GetPosition(_currentLayerState.Canvas);
 
-        _currentLayerState.ScaleTransform.ScaleX *= factor;
-        _currentLayerState.ScaleTransform.ScaleY *= factor;
+        // Get mouse position relative to the parent Border (stable coordinate space)
+        var mousePos = e.GetPosition((UIElement)sender);
 
-        // Zoom toward mouse position
-        _currentLayerState.TranslateTransform.X = pos.X * (1 - factor) + _currentLayerState.TranslateTransform.X * factor;
-        _currentLayerState.TranslateTransform.Y = pos.Y * (1 - factor) + _currentLayerState.TranslateTransform.Y * factor;
+        var oldScale = _currentLayerState.ScaleTransform.ScaleX;
+        var newScale = Math.Clamp(oldScale * factor, 0.05, 5.0);
 
-        // Clamp scale
-        _currentLayerState.ScaleTransform.ScaleX = Math.Clamp(_currentLayerState.ScaleTransform.ScaleX, 0.05, 5.0);
-        _currentLayerState.ScaleTransform.ScaleY = Math.Clamp(_currentLayerState.ScaleTransform.ScaleY, 0.05, 5.0);
+        // Calculate the canvas-local point under the mouse cursor
+        var canvasX = (mousePos.X - _currentLayerState.TranslateTransform.X) / oldScale;
+        var canvasY = (mousePos.Y - _currentLayerState.TranslateTransform.Y) / oldScale;
 
-        ZoomText.Text = $"Zoom: {_currentLayerState.ScaleTransform.ScaleX * 100:F0}%";
+        // Apply new scale
+        _currentLayerState.ScaleTransform.ScaleX = newScale;
+        _currentLayerState.ScaleTransform.ScaleY = newScale;
+
+        // Adjust translate so the canvas point under the mouse stays fixed
+        _currentLayerState.TranslateTransform.X = mousePos.X - canvasX * newScale;
+        _currentLayerState.TranslateTransform.Y = mousePos.Y - canvasY * newScale;
+
+        ZoomText.Text = $"Zoom: {newScale * 100:F0}%";
     }
 
     private void OnCanvasMouseDown(object sender, MouseButtonEventArgs e)
     {
         _isPanning = true;
-        _lastMousePos = e.GetPosition(this);
+        _lastMousePos = e.GetPosition((UIElement)sender);
         ((UIElement)sender).CaptureMouse();
     }
 
@@ -538,7 +545,7 @@ public partial class AnimGraphViewer
     private void OnCanvasMouseMove(object sender, MouseEventArgs e)
     {
         if (!_isPanning || _currentLayerState == null) return;
-        var currentPos = e.GetPosition(this);
+        var currentPos = e.GetPosition((UIElement)sender);
         var delta = currentPos - _lastMousePos;
         _currentLayerState.TranslateTransform.X += delta.X;
         _currentLayerState.TranslateTransform.Y += delta.Y;

From 2c0f915a64f1ff465f3c11ce3703c3f6b584b021 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 03:04:41 +0000
Subject: [PATCH 10/52] Fix clicking on animation nodes causing UI jumping

In WPF, MouseLeftButtonDown is a Direct routed event that fires
independently on each UIElement with a fresh Handled=false. Setting
e.Handled=true in the node's click handler does NOT prevent
OnCanvasMouseDown on the parent canvasBorder from firing. This caused
clicking a node to both select it AND start panning, making the graph
jump when the mouse moved.

Fix: check e.OriginalSource != sender in OnCanvasMouseDown so panning
only starts when clicking directly on the canvas background.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index ae249100..39aeffec 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -531,6 +531,13 @@ public partial class AnimGraphViewer
 
     private void OnCanvasMouseDown(object sender, MouseButtonEventArgs e)
     {
+        // Only start panning when clicking on the canvas background, not on a node.
+        // MouseLeftButtonDown is a Direct routed event in WPF — it fires independently
+        // on each UIElement with a fresh Handled=false, so the node's e.Handled=true
+        // does NOT prevent this handler from firing.
+        if (e.OriginalSource != sender)
+            return;
+
         _isPanning = true;
         _lastMousePos = e.GetPosition((UIElement)sender);
         ((UIElement)sender).CaptureMouse();

From 6a2ef86a3fc7d29fb570d57c16bffd8a503c9391 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 03:25:29 +0000
Subject: [PATCH 11/52] Fix animation node UI: replace OriginalSource guard
 with drag-threshold panning

The previous fix (e.OriginalSource != sender) blocked panning entirely
when clicking on nodes, making them feel like buttons. Connection Path
elements also received mouse events, potentially interfering.

Fix:
- Use a drag-threshold mechanism: clicking selects a node without
  jumping, dragging from anywhere (including nodes) starts panning
  after a 5px threshold is exceeded.
- Register MouseLeftButtonDown with AddHandler(handledEventsToo: true)
  so the panning handler fires even when nodes set e.Handled = true.
- Set IsHitTestVisible = false on connection Path elements so they
  don't interfere with mouse events.
- Check e.LeftButton state in OnCanvasMouseMove to prevent stale pan
  state when the button is released unexpectedly.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 46 ++++++++++++++++++++--------
 1 file changed, 33 insertions(+), 13 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 39aeffec..e0a43ab4 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -29,7 +29,10 @@ public partial class AnimGraphViewer
     private Border? _selectedBorder;
 
     private bool _isPanning;
+    private bool _potentialPan;
+    private Point _panStartPos;
     private Point _lastMousePos;
+    private const double PanThreshold = 5.0;
 
     public AnimGraphViewer(AnimGraphViewModel viewModel)
     {
@@ -85,7 +88,8 @@ public partial class AnimGraphViewer
 
             canvasBorder.Child = canvas;
             canvasBorder.MouseWheel += OnMouseWheel;
-            canvasBorder.MouseLeftButtonDown += OnCanvasMouseDown;
+            canvasBorder.AddHandler(UIElement.MouseLeftButtonDownEvent,
+                new MouseButtonEventHandler(OnCanvasMouseDown), true);
             canvasBorder.MouseLeftButtonUp += OnCanvasMouseUp;
             canvasBorder.MouseMove += OnCanvasMouseMove;
 
@@ -444,7 +448,8 @@ public partial class AnimGraphViewer
             Stroke = new SolidColorBrush(Color.FromRgb(200, 200, 220)),
             StrokeThickness = 2,
             Opacity = 0.8,
-            SnapsToDevicePixels = true
+            SnapsToDevicePixels = true,
+            IsHitTestVisible = false
         };
         Panel.SetZIndex(path, 0);
         state.Canvas.Children.Add(path);
@@ -531,28 +536,43 @@ public partial class AnimGraphViewer
 
     private void OnCanvasMouseDown(object sender, MouseButtonEventArgs e)
     {
-        // Only start panning when clicking on the canvas background, not on a node.
-        // MouseLeftButtonDown is a Direct routed event in WPF — it fires independently
-        // on each UIElement with a fresh Handled=false, so the node's e.Handled=true
-        // does NOT prevent this handler from firing.
-        if (e.OriginalSource != sender)
-            return;
-
-        _isPanning = true;
-        _lastMousePos = e.GetPosition((UIElement)sender);
-        ((UIElement)sender).CaptureMouse();
+        _potentialPan = true;
+        _isPanning = false;
+        _panStartPos = e.GetPosition((UIElement)sender);
+        _lastMousePos = _panStartPos;
     }
 
     private void OnCanvasMouseUp(object sender, MouseButtonEventArgs e)
     {
         _isPanning = false;
+        _potentialPan = false;
         ((UIElement)sender).ReleaseMouseCapture();
     }
 
     private void OnCanvasMouseMove(object sender, MouseEventArgs e)
     {
-        if (!_isPanning || _currentLayerState == null) return;
+        if (!_potentialPan || _currentLayerState == null || e.LeftButton != MouseButtonState.Pressed)
+        {
+            _potentialPan = false;
+            _isPanning = false;
+            return;
+        }
+
         var currentPos = e.GetPosition((UIElement)sender);
+
+        if (!_isPanning)
+        {
+            // Start panning only after the mouse moves beyond the threshold
+            if (Math.Abs(currentPos.X - _panStartPos.X) > PanThreshold ||
+                Math.Abs(currentPos.Y - _panStartPos.Y) > PanThreshold)
+            {
+                _isPanning = true;
+                ((UIElement)sender).CaptureMouse();
+                _lastMousePos = currentPos;
+            }
+            return;
+        }
+
         var delta = currentPos - _lastMousePos;
         _currentLayerState.TranslateTransform.X += delta.X;
         _currentLayerState.TranslateTransform.Y += delta.Y;

From 652b7cfeaa74dc49ac23fd022fa1aafc48f6c5e1 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 03:49:37 +0000
Subject: [PATCH 12/52] Redesign animation nodes to match UE Animation
 Blueprint visual style

- Dark translucent node body with gradient title bar color-coded by type
- Proper pin circles (Ellipses) on node edges replacing text bullets
- Connection wires colored by source pin type with thicker strokes
- Subtle drop shadow behind each node
- Orange selection highlight matching UE's selection color
- Darker canvas background matching UE blueprint editor
- Extract named constants for pin label offset and gradient factor

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 231 ++++++++++++++++++---------
 1 file changed, 156 insertions(+), 75 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index e0a43ab4..e01dd0a8 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -5,6 +5,7 @@ using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
 using System.Windows.Media;
+using System.Windows.Media.Effects;
 using System.Windows.Shapes;
 using FModel.ViewModels;
 
@@ -12,10 +13,13 @@ namespace FModel.Views;
 
 public partial class AnimGraphViewer
 {
-    private const double NodeWidth = 200;
-    private const double NodeHeaderHeight = 28;
-    private const double PinRowHeight = 22;
-    private const double NodeCornerRadius = 4;
+    private const double NodeWidth = 220;
+    private const double NodeHeaderHeight = 26;
+    private const double PinRowHeight = 24;
+    private const double NodeCornerRadius = 6;
+    private const double PinCircleRadius = 5;
+    private const double PinLabelOffset = 14; // PinCircleRadius * 2 + padding
+    private const double HeaderGradientDarkenFactor = 0.6;
     private const double DefaultGraphWidthRatio = 0.65;
 
     private readonly AnimGraphViewModel _viewModel;
@@ -75,7 +79,7 @@ public partial class AnimGraphViewer
             var canvasBorder = new Border
             {
                 ClipToBounds = true,
-                Background = new SolidColorBrush(Color.FromRgb(30, 30, 46))
+                Background = new SolidColorBrush(Color.FromRgb(24, 24, 24))
             };
 
             var canvas = new Canvas();
@@ -167,30 +171,59 @@ public partial class AnimGraphViewer
         var inputPins = node.Pins.Where(p => !p.IsOutput).ToList();
         var outputPins = node.Pins.Where(p => p.IsOutput).ToList();
         var maxPins = Math.Max(inputPins.Count, outputPins.Count);
-        var nodeHeight = NodeHeaderHeight + Math.Max(maxPins, 1) * PinRowHeight + 8;
+        var nodeHeight = NodeHeaderHeight + Math.Max(maxPins, 1) * PinRowHeight + 10;
 
-        // Node background
+        // Node shadow
+        var shadow = new Border
+        {
+            Width = NodeWidth,
+            Height = nodeHeight,
+            CornerRadius = new CornerRadius(NodeCornerRadius),
+            Background = Brushes.Black,
+            Opacity = 0.4,
+            Effect = new BlurEffect { Radius = 8 }
+        };
+        Canvas.SetLeft(shadow, pos.X + 3);
+        Canvas.SetTop(shadow, pos.Y + 3);
+        Panel.SetZIndex(shadow, 0);
+        state.Canvas.Children.Add(shadow);
+
+        // Node body
         var border = new Border
         {
             Width = NodeWidth,
             Height = nodeHeight,
             CornerRadius = new CornerRadius(NodeCornerRadius),
-            Background = new SolidColorBrush(Color.FromRgb(45, 45, 65)),
-            BorderBrush = new SolidColorBrush(Color.FromRgb(80, 80, 110)),
-            BorderThickness = new Thickness(1),
-            SnapsToDevicePixels = true,
-            Cursor = Cursors.Hand
+            Background = new SolidColorBrush(Color.FromArgb(230, 42, 42, 42)),
+            BorderBrush = new SolidColorBrush(Color.FromRgb(20, 20, 20)),
+            BorderThickness = new Thickness(1.5),
+            SnapsToDevicePixels = true
         };
 
         var grid = new Grid();
         grid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(NodeHeaderHeight) });
         grid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
 
-        // Header
+        // Header with gradient
+        var headerColor = GetNodeHeaderColor(node.ExportType);
+        var headerBrush = new LinearGradientBrush
+        {
+            StartPoint = new Point(0, 0),
+            EndPoint = new Point(0, 1)
+        };
+        headerBrush.GradientStops.Add(new GradientStop(headerColor, 0.0));
+        headerBrush.GradientStops.Add(new GradientStop(
+            Color.FromArgb(headerColor.A,
+                (byte)(headerColor.R * HeaderGradientDarkenFactor),
+                (byte)(headerColor.G * HeaderGradientDarkenFactor),
+                (byte)(headerColor.B * HeaderGradientDarkenFactor)), 1.0));
+
         var headerBorder = new Border
         {
-            Background = GetNodeHeaderBrush(node.ExportType),
-            CornerRadius = new CornerRadius(NodeCornerRadius, NodeCornerRadius, 0, 0)
+            Background = headerBrush,
+            CornerRadius = new CornerRadius(NodeCornerRadius, NodeCornerRadius, 0, 0),
+            BorderBrush = new SolidColorBrush(Color.FromArgb(40, 255, 255, 255)),
+            BorderThickness = new Thickness(0, 0, 0, 1)
         };
 
         var headerText = new TextBlock
@@ -200,39 +233,32 @@ public partial class AnimGraphViewer
             FontSize = 11,
             FontWeight = FontWeights.SemiBold,
             VerticalAlignment = VerticalAlignment.Center,
-            HorizontalAlignment = HorizontalAlignment.Center,
-            TextTrimming = TextTrimming.CharacterEllipsis,
-            Margin = new Thickness(4, 0, 4, 0)
+            Margin = new Thickness(10, 0, 10, 0),
+            TextTrimming = TextTrimming.CharacterEllipsis
         };
         headerBorder.Child = headerText;
         Grid.SetRow(headerBorder, 0);
         grid.Children.Add(headerBorder);
 
         // Pins area
-        var pinsGrid = new Grid();
-        pinsGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
-        pinsGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+        var pinsCanvas = new Canvas();
 
-        // Input pins
-        var inputPanel = new StackPanel { Margin = new Thickness(4, 4, 0, 0) };
-        foreach (var pin in inputPins)
+        for (var i = 0; i < inputPins.Count; i++)
         {
-            inputPanel.Children.Add(CreatePinLabel(pin, HorizontalAlignment.Left));
+            var pinY = 6 + i * PinRowHeight + PinRowHeight / 2;
+            var pinColor = GetPinColor(inputPins[i].PinType);
+            AddPinVisual(pinsCanvas, inputPins[i], pinY, true, pinColor);
         }
-        Grid.SetColumn(inputPanel, 0);
-        pinsGrid.Children.Add(inputPanel);
 
-        // Output pins
-        var outputPanel = new StackPanel { Margin = new Thickness(0, 4, 4, 0) };
-        foreach (var pin in outputPins)
+        for (var i = 0; i < outputPins.Count; i++)
         {
-            outputPanel.Children.Add(CreatePinLabel(pin, HorizontalAlignment.Right));
+            var pinY = 6 + i * PinRowHeight + PinRowHeight / 2;
+            var pinColor = GetPinColor(outputPins[i].PinType);
+            AddPinVisual(pinsCanvas, outputPins[i], pinY, false, pinColor);
         }
-        Grid.SetColumn(outputPanel, 1);
-        pinsGrid.Children.Add(outputPanel);
 
-        Grid.SetRow(pinsGrid, 1);
-        grid.Children.Add(pinsGrid);
+        Grid.SetRow(pinsCanvas, 1);
+        grid.Children.Add(pinsCanvas);
 
         border.Child = grid;
 
@@ -243,20 +269,34 @@ public partial class AnimGraphViewer
 
         state.NodeVisuals[node] = (border, NodeWidth, nodeHeight);
 
-        // Calculate pin positions for connections
+        // Calculate pin positions for connections (in canvas space)
         for (var i = 0; i < inputPins.Count; i++)
         {
-            var pinPos = new Point(pos.X, pos.Y + NodeHeaderHeight + 4 + i * PinRowHeight + PinRowHeight / 2);
+            var pinPos = new Point(pos.X, pos.Y + NodeHeaderHeight + 6 + i * PinRowHeight + PinRowHeight / 2);
             state.PinPositions[(node, inputPins[i].PinName, false)] = pinPos;
         }
 
         for (var i = 0; i < outputPins.Count; i++)
         {
-            var pinPos = new Point(pos.X + NodeWidth, pos.Y + NodeHeaderHeight + 4 + i * PinRowHeight + PinRowHeight / 2);
+            var pinPos = new Point(pos.X + NodeWidth, pos.Y + NodeHeaderHeight + 6 + i * PinRowHeight + PinRowHeight / 2);
             state.PinPositions[(node, outputPins[i].PinName, true)] = pinPos;
         }
 
-        // Add tooltip with basic info
+        // Draw pin circles on the node edges (over the border)
+        for (var i = 0; i < inputPins.Count; i++)
+        {
+            var pinY = pos.Y + NodeHeaderHeight + 6 + i * PinRowHeight + PinRowHeight / 2;
+            var pinColor = GetPinColor(inputPins[i].PinType);
+            DrawPinCircle(state, pos.X, pinY, pinColor);
+        }
+
+        for (var i = 0; i < outputPins.Count; i++)
+        {
+            var pinY = pos.Y + NodeHeaderHeight + 6 + i * PinRowHeight + PinRowHeight / 2;
+            var pinColor = GetPinColor(outputPins[i].PinType);
+            DrawPinCircle(state, pos.X + NodeWidth, pinY, pinColor);
+        }
+
         border.ToolTip = $"{node.ExportType}\n{node.Name}";
 
         // Click to select node and show properties
@@ -267,6 +307,64 @@ public partial class AnimGraphViewer
         };
     }
 
+    private void AddPinVisual(Canvas pinsCanvas, AnimGraphPin pin, double y, bool isInput, Color pinColor)
+    {
+        var displayName = string.IsNullOrEmpty(pin.PinName) ? "(unnamed)" : pin.PinName;
+        var label = new TextBlock
+        {
+            Text = displayName,
+            Foreground = new SolidColorBrush(Color.FromRgb(200, 200, 200)),
+            FontSize = 10,
+            VerticalAlignment = VerticalAlignment.Center,
+            TextTrimming = TextTrimming.CharacterEllipsis
+        };
+
+        if (isInput)
+        {
+            Canvas.SetLeft(label, PinLabelOffset);
+        }
+        else
+        {
+            label.TextAlignment = TextAlignment.Right;
+            label.Width = NodeWidth - PinLabelOffset;
+            Canvas.SetLeft(label, -PinLabelOffset);
+        }
+
+        Canvas.SetTop(label, y - label.FontSize * 0.7);
+        pinsCanvas.Children.Add(label);
+    }
+
+    private static void DrawPinCircle(LayerCanvasState state, double cx, double cy, Color pinColor)
+    {
+        // Outer ring
+        var outerCircle = new Ellipse
+        {
+            Width = PinCircleRadius * 2 + 2,
+            Height = PinCircleRadius * 2 + 2,
+            Fill = new SolidColorBrush(Color.FromRgb(20, 20, 20)),
+            Stroke = new SolidColorBrush(pinColor),
+            StrokeThickness = 1.5,
+            IsHitTestVisible = false
+        };
+        Canvas.SetLeft(outerCircle, cx - PinCircleRadius - 1);
+        Canvas.SetTop(outerCircle, cy - PinCircleRadius - 1);
+        Panel.SetZIndex(outerCircle, 2);
+        state.Canvas.Children.Add(outerCircle);
+
+        // Inner filled circle
+        var innerCircle = new Ellipse
+        {
+            Width = PinCircleRadius,
+            Height = PinCircleRadius,
+            Fill = new SolidColorBrush(pinColor),
+            IsHitTestVisible = false
+        };
+        Canvas.SetLeft(innerCircle, cx - PinCircleRadius / 2);
+        Canvas.SetTop(innerCircle, cy - PinCircleRadius / 2);
+        Panel.SetZIndex(innerCircle, 3);
+        state.Canvas.Children.Add(innerCircle);
+    }
+
     /// <summary>
     /// Selects a node and populates the properties panel with its details.
     /// </summary>
@@ -275,14 +373,14 @@ public partial class AnimGraphViewer
         // Deselect previous
         if (_selectedBorder != null)
         {
-            _selectedBorder.BorderBrush = new SolidColorBrush(Color.FromRgb(80, 80, 110));
-            _selectedBorder.BorderThickness = new Thickness(1);
+            _selectedBorder.BorderBrush = new SolidColorBrush(Color.FromRgb(20, 20, 20));
+            _selectedBorder.BorderThickness = new Thickness(1.5);
         }
 
         // Highlight selected
         _selectedNode = node;
         _selectedBorder = border;
-        border.BorderBrush = new SolidColorBrush(Color.FromRgb(0, 160, 255));
+        border.BorderBrush = new SolidColorBrush(Color.FromRgb(230, 160, 0));
         border.BorderThickness = new Thickness(2);
 
         SelectedNodeText.Text = $"Selected: {node.ExportType} - {node.Name}";
@@ -390,24 +488,6 @@ public partial class AnimGraphViewer
         PropertiesPanel.Children.Add(rowGrid);
     }
 
-    private static TextBlock CreatePinLabel(AnimGraphPin pin, HorizontalAlignment alignment)
-    {
-        var displayName = string.IsNullOrEmpty(pin.PinName) ? "(unnamed)" : pin.PinName;
-        var pinColor = GetPinColor(pin.PinType);
-
-        return new TextBlock
-        {
-            Text = alignment == HorizontalAlignment.Left ? $"● {displayName}" : $"{displayName} ●",
-            Foreground = new SolidColorBrush(pinColor),
-            FontSize = 10,
-            Height = PinRowHeight,
-            HorizontalAlignment = alignment,
-            VerticalAlignment = VerticalAlignment.Center,
-            TextTrimming = TextTrimming.CharacterEllipsis,
-            Padding = new Thickness(2, 2, 2, 0)
-        };
-    }
-
     private void DrawConnectionLine(LayerCanvasState state, AnimGraphConnection conn)
     {
         var sourceKey = (conn.SourceNode, conn.SourcePinName, true);
@@ -415,7 +495,6 @@ public partial class AnimGraphViewer
 
         if (!state.PinPositions.TryGetValue(sourceKey, out var startPos))
         {
-            // Fallback: use node center-right
             if (state.NodePositions.TryGetValue(conn.SourceNode, out var srcNodePos))
                 startPos = new Point(srcNodePos.X + NodeWidth, srcNodePos.Y + NodeHeaderHeight + 10);
             else
@@ -424,14 +503,16 @@ public partial class AnimGraphViewer
 
         if (!state.PinPositions.TryGetValue(targetKey, out var endPos))
         {
-            // Fallback: use node center-left
             if (state.NodePositions.TryGetValue(conn.TargetNode, out var tgtNodePos))
                 endPos = new Point(tgtNodePos.X, tgtNodePos.Y + NodeHeaderHeight + 10);
             else
                 return;
         }
 
-        // Ensure a minimum tangent length for smooth curves even when nodes are close
+        // Determine wire color from source pin type
+        var sourcePin = conn.SourceNode.Pins.FirstOrDefault(p => p.PinName == conn.SourcePinName && p.IsOutput);
+        var wireColor = sourcePin != null ? GetPinColor(sourcePin.PinType) : Color.FromRgb(200, 200, 220);
+
         var dx = Math.Max(Math.Abs(endPos.X - startPos.X) * 0.5, 50);
         var pathFigure = new PathFigure { StartPoint = startPos };
         pathFigure.Segments.Add(new BezierSegment(
@@ -445,9 +526,9 @@ public partial class AnimGraphViewer
         var path = new Path
         {
             Data = pathGeometry,
-            Stroke = new SolidColorBrush(Color.FromRgb(200, 200, 220)),
-            StrokeThickness = 2,
-            Opacity = 0.8,
+            Stroke = new SolidColorBrush(wireColor),
+            StrokeThickness = 2.5,
+            Opacity = 0.85,
             SnapsToDevicePixels = true,
             IsHitTestVisible = false
         };
@@ -474,18 +555,18 @@ public partial class AnimGraphViewer
         return type;
     }
 
-    private static Brush GetNodeHeaderBrush(string exportType)
+    private static Color GetNodeHeaderColor(string exportType)
     {
         return exportType switch
         {
-            _ when exportType.Contains("StateMachine") => new SolidColorBrush(Color.FromRgb(140, 60, 20)),
-            _ when exportType.Contains("Transition") => new SolidColorBrush(Color.FromRgb(140, 120, 0)),
-            _ when exportType.Contains("BlendSpace") => new SolidColorBrush(Color.FromRgb(60, 60, 160)),
-            _ when exportType.Contains("Blend") => new SolidColorBrush(Color.FromRgb(80, 80, 160)),
-            _ when exportType.Contains("Sequence") => new SolidColorBrush(Color.FromRgb(0, 120, 120)),
-            _ when exportType.Contains("Result") || exportType.Contains("Root") => new SolidColorBrush(Color.FromRgb(120, 40, 40)),
-            _ when exportType.Contains("AnimNode") || exportType.Contains("FAnimNode") => new SolidColorBrush(Color.FromRgb(0, 120, 80)),
-            _ => new SolidColorBrush(Color.FromRgb(70, 70, 90))
+            _ when exportType.Contains("StateMachine") => Color.FromRgb(200, 80, 20),
+            _ when exportType.Contains("Transition") => Color.FromRgb(180, 150, 0),
+            _ when exportType.Contains("BlendSpace") => Color.FromRgb(60, 80, 180),
+            _ when exportType.Contains("Blend") => Color.FromRgb(70, 100, 180),
+            _ when exportType.Contains("Sequence") => Color.FromRgb(0, 140, 140),
+            _ when exportType.Contains("Result") || exportType.Contains("Root") => Color.FromRgb(160, 50, 50),
+            _ when exportType.Contains("AnimNode") || exportType.Contains("FAnimNode") => Color.FromRgb(20, 140, 80),
+            _ => Color.FromRgb(80, 80, 100)
         };
     }
 

From 1ba3afb4832b20e731d2da7c7fc0c5afdfaea599 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 05:52:14 +0000
Subject: [PATCH 13/52] Show only final output pose layer initially in
 AnimGraph viewer

Only the AnimGraph layer (containing Root/Result nodes) is shown
when first opening the animation blueprint, instead of all layer tabs.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index e01dd0a8..01d4f31b 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -55,8 +55,8 @@ public partial class AnimGraphViewer
     }
 
     /// <summary>
-    /// Creates a tab for each layer in the animation graph.
-    /// Each tab contains its own canvas with zoom/pan support.
+    /// Creates a tab for the final output pose layer only.
+    /// Only the AnimGraph layer (containing the Root node) is shown initially.
     /// </summary>
     private void BuildLayerTabs()
     {
@@ -67,7 +67,15 @@ public partial class AnimGraphViewer
         if (_viewModel.Layers.Count == 0)
             return;
 
-        foreach (var layer in _viewModel.Layers)
+        // Show only the final output pose layer (AnimGraph) initially
+        var outputLayer = _viewModel.Layers.FirstOrDefault(l =>
+            l.Nodes.Any(n => n.ExportType.Contains("Root", StringComparison.OrdinalIgnoreCase) ||
+                             n.ExportType.Contains("Result", StringComparison.OrdinalIgnoreCase)))
+            ?? _viewModel.Layers[0];
+
+        var layersToShow = new[] { outputLayer };
+
+        foreach (var layer in layersToShow)
         {
             var tabItem = new System.Windows.Controls.TabItem
             {

From c1962c77bec8cfd47f326cd206fdf97bcdc1296b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 06:31:15 +0000
Subject: [PATCH 14/52] Fix output pose layer detection to use
 AnimGraphNode_Root Name="AnimGraph"

The output pose layer is now correctly identified by finding the node
whose Name property is "AnimGraph" (stored on AnimGraphNode_Root),
instead of incorrectly matching any node with "Root" in ExportType.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 4 ++--
 FModel/Views/AnimGraphViewer.xaml.cs    | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index c1b9bb5b..f1e4061e 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -215,9 +215,9 @@ public class AnimGraphViewModel
     /// </summary>
     private static string GetLayerName(List<AnimGraphNode> nodes, int index)
     {
-        // Look for a prominent node type to name the layer
+        // The final output pose layer contains an AnimGraphNode_Root with Name="AnimGraph"
         var rootNode = nodes.FirstOrDefault(n =>
-            n.ExportType.Contains("Root", StringComparison.OrdinalIgnoreCase));
+            n.Name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase));
         if (rootNode != null)
             return "AnimGraph";
 
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 01d4f31b..773b0044 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -67,10 +67,10 @@ public partial class AnimGraphViewer
         if (_viewModel.Layers.Count == 0)
             return;
 
-        // Show only the final output pose layer (AnimGraph) initially
+        // Show only the final output pose layer (AnimGraph) initially.
+        // The root node of the output layer is an AnimGraphNode_Root with Name="AnimGraph".
         var outputLayer = _viewModel.Layers.FirstOrDefault(l =>
-            l.Nodes.Any(n => n.ExportType.Contains("Root", StringComparison.OrdinalIgnoreCase) ||
-                             n.ExportType.Contains("Result", StringComparison.OrdinalIgnoreCase)))
+            l.Nodes.Any(n => n.Name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase)))
             ?? _viewModel.Layers[0];
 
         var layersToShow = new[] { outputLayer };

From 84df34b4dc09f569b3952253f7d5605a6b4e2d15 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 06:42:01 +0000
Subject: [PATCH 15/52] Fix output pose layer detection to use
 AdditionalProperties["Name"] instead of node.Name

The root node's meaningful identifier "AnimGraph" is stored in the
struct's "Name" property (AdditionalProperties["Name"]), not the
node's generated Name field (e.g. "AnimGraphNode_Root_0").

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 6 ++++--
 FModel/Views/AnimGraphViewer.xaml.cs    | 6 ++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index f1e4061e..5785b3d6 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -215,9 +215,11 @@ public class AnimGraphViewModel
     /// </summary>
     private static string GetLayerName(List<AnimGraphNode> nodes, int index)
     {
-        // The final output pose layer contains an AnimGraphNode_Root with Name="AnimGraph"
+        // The final output pose layer contains an AnimGraphNode_Root whose
+        // "Name" property (in AdditionalProperties) is set to "AnimGraph"
         var rootNode = nodes.FirstOrDefault(n =>
-            n.Name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase));
+            n.AdditionalProperties.TryGetValue("Name", out var name) &&
+            name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase));
         if (rootNode != null)
             return "AnimGraph";
 
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 773b0044..c6eb207d 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -68,9 +68,11 @@ public partial class AnimGraphViewer
             return;
 
         // Show only the final output pose layer (AnimGraph) initially.
-        // The root node of the output layer is an AnimGraphNode_Root with Name="AnimGraph".
+        // The root node of the output layer has a "Name" property set to "AnimGraph"
+        // in its AdditionalProperties (from the AnimGraphNode_Root struct).
         var outputLayer = _viewModel.Layers.FirstOrDefault(l =>
-            l.Nodes.Any(n => n.Name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase)))
+            l.Nodes.Any(n => n.AdditionalProperties.TryGetValue("Name", out var name) &&
+                             name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase)))
             ?? _viewModel.Layers[0];
 
         var layersToShow = new[] { outputLayer };

From fc71b8eea8b470e99e1c63bd1baebb0394372f9c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 07:11:08 +0000
Subject: [PATCH 16/52] Fix ExtractNodeProperties to use GenericValue for clean
 property values

FPropertyTagType.ToString() returns "Value (TypeName)" format, including
extra type information. Using GenericValue?.ToString() returns just the
raw value, which fixes property value extraction and root node detection.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 5785b3d6..9b0e7466 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -344,7 +344,7 @@ public class AnimGraphViewModel
         foreach (var prop in structValue.Properties)
         {
             var name = prop.Name.Text;
-            var value = prop.Tag?.ToString() ?? string.Empty;
+            var value = prop.Tag?.GenericValue?.ToString() ?? string.Empty;
 
             switch (name)
             {

From 6516fab7a9bbe53632e5fe8021ad01b6921497b4 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 2 Mar 2026 09:14:57 +0000
Subject: [PATCH 17/52] Fix lost connections for array-based pose links in
 animation graph

TryResolvePoseLink only handled direct struct properties (single
FPoseLink). Many animation nodes use arrays of pose links (e.g.,
BlendPose TArray<FPoseLink> in blend list nodes). Added handling for
UScriptArray to iterate array elements and resolve each as a pose link.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 9b0e7466..ca5e616a 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -424,6 +424,16 @@ public class AnimGraphViewModel
         AnimGraphNode sourceNode, List<(string name, string structType)> animNodeProps,
         Dictionary<string, AnimGraphNode> nodeByName, AnimGraphViewModel vm)
     {
+        // Handle arrays of pose links (e.g., BlendPose TArray<FPoseLink>)
+        if (tag.GenericValue is UScriptArray array)
+        {
+            for (var i = 0; i < array.Properties.Count; i++)
+            {
+                TryResolvePoseLink(array.Properties[i], $"{pinName}[{i}]", sourceNode, animNodeProps, nodeByName, vm);
+            }
+            return;
+        }
+
         // A PoseLink/ComponentSpacePoseLink is a struct with a LinkID property
         if (tag.GetValue(typeof(FStructFallback)) is not FStructFallback linkStruct)
             return;

From 1d2ef5905e767d0c7afeb23b399ecb2ac7acfbd6 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 08:08:23 +0000
Subject: [PATCH 18/52] Add LinkedAnimLayer double-click to open layer
 sub-graph tab

Generalized GetLayerName to use any Root node's "Name" property as the
layer name (not just "AnimGraph"), enabling proper naming for
LinkedAnimLayer sub-graphs.

Added double-click handling on nodes: double-clicking a LinkedAnimLayer
node finds the matching layer and opens/selects a tab for it.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs |  14 ++-
 FModel/Views/AnimGraphViewer.xaml.cs    | 141 +++++++++++++++---------
 2 files changed, 96 insertions(+), 59 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index ca5e616a..c6be01cf 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -212,16 +212,18 @@ public class AnimGraphViewModel
 
     /// <summary>
     /// Determines a display name for a layer based on the types of nodes it contains.
+    /// A Root node's "Name" property defines the layer/sub-graph name
+    /// (e.g., "AnimGraph" for the main output pose, or a specific name for LinkedAnimLayer sub-graphs).
     /// </summary>
     private static string GetLayerName(List<AnimGraphNode> nodes, int index)
     {
-        // The final output pose layer contains an AnimGraphNode_Root whose
-        // "Name" property (in AdditionalProperties) is set to "AnimGraph"
         var rootNode = nodes.FirstOrDefault(n =>
-            n.AdditionalProperties.TryGetValue("Name", out var name) &&
-            name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase));
-        if (rootNode != null)
-            return "AnimGraph";
+            n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase) &&
+            n.AdditionalProperties.TryGetValue("Name", out _));
+        if (rootNode != null &&
+            rootNode.AdditionalProperties.TryGetValue("Name", out var rootName) &&
+            !string.IsNullOrEmpty(rootName))
+            return rootName;
 
         var stateMachine = nodes.FirstOrDefault(n =>
             n.ExportType.Contains("StateMachine", StringComparison.OrdinalIgnoreCase));
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index c6eb207d..4cb6c787 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -63,69 +63,67 @@ public partial class AnimGraphViewer
         LayerTabControl.Items.Clear();
         _layerStates.Clear();
 
-        // If no layers were built (empty graph), show nothing
         if (_viewModel.Layers.Count == 0)
             return;
 
-        // Show only the final output pose layer (AnimGraph) initially.
-        // The root node of the output layer has a "Name" property set to "AnimGraph"
-        // in its AdditionalProperties (from the AnimGraphNode_Root struct).
+        // Show only the AnimGraph layer initially
         var outputLayer = _viewModel.Layers.FirstOrDefault(l =>
-            l.Nodes.Any(n => n.AdditionalProperties.TryGetValue("Name", out var name) &&
-                             name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase)))
+            l.Name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase))
             ?? _viewModel.Layers[0];
 
-        var layersToShow = new[] { outputLayer };
+        AddLayerTab(outputLayer);
 
-        foreach (var layer in layersToShow)
-        {
-            var tabItem = new System.Windows.Controls.TabItem
-            {
-                Header = layer.Name,
-                Tag = layer
-            };
-
-            // Create canvas container for this layer
-            var canvasBorder = new Border
-            {
-                ClipToBounds = true,
-                Background = new SolidColorBrush(Color.FromRgb(24, 24, 24))
-            };
-
-            var canvas = new Canvas();
-            var scaleTransform = new ScaleTransform(1, 1);
-            var translateTransform = new TranslateTransform(0, 0);
-            var transformGroup = new TransformGroup();
-            transformGroup.Children.Add(scaleTransform);
-            transformGroup.Children.Add(translateTransform);
-            canvas.RenderTransform = transformGroup;
-
-            canvasBorder.Child = canvas;
-            canvasBorder.MouseWheel += OnMouseWheel;
-            canvasBorder.AddHandler(UIElement.MouseLeftButtonDownEvent,
-                new MouseButtonEventHandler(OnCanvasMouseDown), true);
-            canvasBorder.MouseLeftButtonUp += OnCanvasMouseUp;
-            canvasBorder.MouseMove += OnCanvasMouseMove;
-
-            tabItem.Content = canvasBorder;
-
-            var state = new LayerCanvasState
-            {
-                Layer = layer,
-                Canvas = canvas,
-                ScaleTransform = scaleTransform,
-                TranslateTransform = translateTransform
-            };
-            _layerStates[layer] = state;
-
-            LayerTabControl.Items.Add(tabItem);
-        }
-
-        // Select the first tab
         if (LayerTabControl.Items.Count > 0)
             LayerTabControl.SelectedIndex = 0;
     }
 
+    /// <summary>
+    /// Creates a new tab for the given layer and selects it.
+    /// </summary>
+    private void AddLayerTab(AnimGraphLayer layer)
+    {
+        var tabItem = new System.Windows.Controls.TabItem
+        {
+            Header = layer.Name,
+            Tag = layer
+        };
+
+        var canvasBorder = new Border
+        {
+            ClipToBounds = true,
+            Background = new SolidColorBrush(Color.FromRgb(24, 24, 24))
+        };
+
+        var canvas = new Canvas();
+        var scaleTransform = new ScaleTransform(1, 1);
+        var translateTransform = new TranslateTransform(0, 0);
+        var transformGroup = new TransformGroup();
+        transformGroup.Children.Add(scaleTransform);
+        transformGroup.Children.Add(translateTransform);
+        canvas.RenderTransform = transformGroup;
+
+        canvasBorder.Child = canvas;
+        canvasBorder.MouseWheel += OnMouseWheel;
+        canvasBorder.AddHandler(UIElement.MouseLeftButtonDownEvent,
+            new MouseButtonEventHandler(OnCanvasMouseDown), true);
+        canvasBorder.MouseLeftButtonUp += OnCanvasMouseUp;
+        canvasBorder.MouseMove += OnCanvasMouseMove;
+
+        tabItem.Content = canvasBorder;
+
+        var state = new LayerCanvasState
+        {
+            Layer = layer,
+            Canvas = canvas,
+            ScaleTransform = scaleTransform,
+            TranslateTransform = translateTransform
+        };
+        _layerStates[layer] = state;
+
+        LayerTabControl.Items.Add(tabItem);
+        LayerTabControl.SelectedItem = tabItem;
+    }
+
     private void OnLayerTabChanged(object sender, SelectionChangedEventArgs e)
     {
         if (LayerTabControl.SelectedItem is not System.Windows.Controls.TabItem { Tag: AnimGraphLayer layer })
@@ -309,9 +307,15 @@ public partial class AnimGraphViewer
 
         border.ToolTip = $"{node.ExportType}\n{node.Name}";
 
-        // Click to select node and show properties
+        // Click to select, double-click to open linked layer
         border.MouseLeftButtonDown += (s, e) =>
         {
+            if (e.ClickCount == 2)
+            {
+                TryOpenLinkedLayer(node);
+                e.Handled = true;
+                return;
+            }
             SelectNode(node, border);
             e.Handled = true;
         };
@@ -397,6 +401,37 @@ public partial class AnimGraphViewer
         PopulatePropertiesPanel(node);
     }
 
+    /// <summary>
+    /// When a LinkedAnimLayer node is double-clicked, opens its corresponding
+    /// layer sub-graph in a new tab. The layer is identified by matching the
+    /// node's "Layer" property with a layer whose Root node has the same "Name".
+    /// </summary>
+    private void TryOpenLinkedLayer(AnimGraphNode node)
+    {
+        if (!node.ExportType.Contains("LinkedAnimLayer", StringComparison.OrdinalIgnoreCase))
+            return;
+
+        if (!node.AdditionalProperties.TryGetValue("Layer", out var layerName) || string.IsNullOrEmpty(layerName))
+            return;
+
+        var targetLayer = _viewModel.Layers.FirstOrDefault(l =>
+            l.Name.Equals(layerName, StringComparison.OrdinalIgnoreCase));
+        if (targetLayer == null)
+            return;
+
+        // If tab already exists, just select it
+        foreach (System.Windows.Controls.TabItem tab in LayerTabControl.Items)
+        {
+            if (tab.Tag == targetLayer)
+            {
+                LayerTabControl.SelectedItem = tab;
+                return;
+            }
+        }
+
+        AddLayerTab(targetLayer);
+    }
+
     /// <summary>
     /// Fills the properties panel with the selected node's information,
     /// similar to UE's Details panel when a node is selected.

From 08a9253f4e0e32b258accfc14190164869980fa9 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 08:53:16 +0000
Subject: [PATCH 19/52] Add StateMachine double-click to open sub-graph tab

Read BakedStateMachines from the animation blueprint class to extract
machine names. Associate FAnimNode_StateMachine nodes with their machine
name via StateMachineIndexInClass, and mark internal state root nodes
with BelongsToStateMachine for correct layer naming.

Extend TryOpenSubGraph to handle both LinkedAnimLayer and StateMachine
node types for double-click tab navigation.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 89 +++++++++++++++++++++++++
 FModel/Views/AnimGraphViewer.xaml.cs    | 21 +++---
 2 files changed, 102 insertions(+), 8 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index c6be01cf..54dbffe3 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -131,6 +131,9 @@ public class AnimGraphViewModel
             ResolveConnections(cdo, animNodeProps, nodeByName, vm);
         }
 
+        // Associate state machine nodes with their baked machine names
+        AssociateStateMachineNames(animBlueprintClass, cdo, animNodeProps, nodeByName);
+
         // Group nodes into layers (connected subgraphs)
         BuildLayers(vm);
 
@@ -225,6 +228,14 @@ public class AnimGraphViewModel
             !string.IsNullOrEmpty(rootName))
             return rootName;
 
+        // Check if any node belongs to a baked state machine
+        var smNode = nodes.FirstOrDefault(n =>
+            n.AdditionalProperties.TryGetValue("BelongsToStateMachine", out _));
+        if (smNode != null &&
+            smNode.AdditionalProperties.TryGetValue("BelongsToStateMachine", out var smName) &&
+            !string.IsNullOrEmpty(smName))
+            return smName;
+
         var stateMachine = nodes.FirstOrDefault(n =>
             n.ExportType.Contains("StateMachine", StringComparison.OrdinalIgnoreCase));
         if (stateMachine != null)
@@ -250,6 +261,84 @@ public class AnimGraphViewModel
         return exportType;
     }
 
+    /// <summary>
+    /// Reads BakedStateMachines from the animation blueprint class to associate
+    /// FAnimNode_StateMachine nodes with their machine names and mark internal
+    /// state root nodes so they can be grouped into correctly named layers.
+    /// </summary>
+    private static void AssociateStateMachineNames(UClass animBlueprintClass, UObject? cdo,
+        List<(string name, string structType)> animNodeProps,
+        Dictionary<string, AnimGraphNode> nodeByName)
+    {
+        // BakedStateMachines is a UPROPERTY on UAnimBlueprintGeneratedClass
+        // Try reading from both the class and CDO
+        UScriptArray? bakedMachines = null;
+        if (animBlueprintClass.TryGetValue(out UScriptArray classBaked, "BakedStateMachines"))
+            bakedMachines = classBaked;
+        else if (cdo != null && cdo.TryGetValue(out UScriptArray cdoBaked, "BakedStateMachines"))
+            bakedMachines = cdoBaked;
+
+        if (bakedMachines == null || bakedMachines.Properties.Count == 0)
+            return;
+
+        for (var machineIdx = 0; machineIdx < bakedMachines.Properties.Count; machineIdx++)
+        {
+            if (bakedMachines.Properties[machineIdx].GetValue(typeof(FStructFallback)) is not FStructFallback machineStruct)
+                continue;
+
+            // Extract MachineName
+            var machineName = string.Empty;
+            foreach (var prop in machineStruct.Properties)
+            {
+                if (prop.Name.Text == "MachineName")
+                {
+                    machineName = prop.Tag?.GenericValue?.ToString() ?? string.Empty;
+                    break;
+                }
+            }
+            if (string.IsNullOrEmpty(machineName))
+                continue;
+
+            // Associate FAnimNode_StateMachine nodes that reference this machine index
+            var machineIdxStr = machineIdx.ToString();
+            foreach (var (propName, structType) in animNodeProps)
+            {
+                if (!structType.Contains("StateMachine", StringComparison.OrdinalIgnoreCase))
+                    continue;
+                if (!nodeByName.TryGetValue(propName, out var smNode))
+                    continue;
+                if (!smNode.AdditionalProperties.TryGetValue("StateMachineIndexInClass", out var idxStr))
+                    continue;
+                if (idxStr == machineIdxStr)
+                    smNode.AdditionalProperties["StateMachineName"] = machineName;
+            }
+
+            // Mark state root nodes with BelongsToStateMachine so their layers get the machine name
+            foreach (var prop in machineStruct.Properties)
+            {
+                if (prop.Name.Text != "States") continue;
+                if (prop.Tag?.GenericValue is not UScriptArray states) break;
+
+                foreach (var stateProp in states.Properties)
+                {
+                    if (stateProp.GetValue(typeof(FStructFallback)) is not FStructFallback stateStruct)
+                        continue;
+
+                    if (!stateStruct.TryGetValue(out int stateRootIndex, "StateRootNodeIndex"))
+                        continue;
+
+                    if (stateRootIndex < 0 || stateRootIndex >= animNodeProps.Count)
+                        continue;
+
+                    var rootPropName = animNodeProps[stateRootIndex].name;
+                    if (nodeByName.TryGetValue(rootPropName, out var rootNode))
+                        rootNode.AdditionalProperties["BelongsToStateMachine"] = machineName;
+                }
+                break;
+            }
+        }
+    }
+
     /// <summary>
     /// Arranges nodes within a layer in a left-to-right flow layout
     /// based on connection topology (sinks on the left, sources on the right).
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 4cb6c787..f40f5cc4 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -312,7 +312,7 @@ public partial class AnimGraphViewer
         {
             if (e.ClickCount == 2)
             {
-                TryOpenLinkedLayer(node);
+                TryOpenSubGraph(node);
                 e.Handled = true;
                 return;
             }
@@ -402,16 +402,21 @@ public partial class AnimGraphViewer
     }
 
     /// <summary>
-    /// When a LinkedAnimLayer node is double-clicked, opens its corresponding
-    /// layer sub-graph in a new tab. The layer is identified by matching the
-    /// node's "Layer" property with a layer whose Root node has the same "Name".
+    /// When a LinkedAnimLayer or StateMachine node is double-clicked, opens its
+    /// corresponding sub-graph in a new tab.
+    /// - LinkedAnimLayer: matches "Layer" property → layer name from Root node's "Name"
+    /// - StateMachine: matches "StateMachineName" property → layer name from BakedStateMachines
     /// </summary>
-    private void TryOpenLinkedLayer(AnimGraphNode node)
+    private void TryOpenSubGraph(AnimGraphNode node)
     {
-        if (!node.ExportType.Contains("LinkedAnimLayer", StringComparison.OrdinalIgnoreCase))
-            return;
+        string? layerName = null;
 
-        if (!node.AdditionalProperties.TryGetValue("Layer", out var layerName) || string.IsNullOrEmpty(layerName))
+        if (node.ExportType.Contains("LinkedAnimLayer", StringComparison.OrdinalIgnoreCase))
+            node.AdditionalProperties.TryGetValue("Layer", out layerName);
+        else if (node.ExportType.Contains("StateMachine", StringComparison.OrdinalIgnoreCase))
+            node.AdditionalProperties.TryGetValue("StateMachineName", out layerName);
+
+        if (string.IsNullOrEmpty(layerName))
             return;
 
         var targetLayer = _viewModel.Layers.FirstOrDefault(l =>

From 58a0a50ac59a75b08d1b0b80ed7d9149d58c64a3 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 09:39:51 +0000
Subject: [PATCH 20/52] Add path prefix to StateMachine sub-graph tab names to
 avoid collisions

StateMachine internal layer tabs are now named with a parent path
(e.g., "AnimGraph > Locomotion") to avoid collisions when a state
machine shares a name with a LinkedAnimLayer layer.

PrefixStateMachineLayerNames runs after BuildLayers to find each SM
node's parent layer and prepend its name. TryOpenSubGraph constructs
the same path for lookup. The path separator is a shared constant.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 44 +++++++++++++++++++++++++
 FModel/Views/AnimGraphViewer.xaml.cs    | 11 ++++++-
 2 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 54dbffe3..417db9cd 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -56,6 +56,7 @@ public class AnimGraphViewModel
     private const int NodeHorizontalSpacing = 300;
     private const int NodeVerticalSpacing = 200;
     private const int MaxPropertyValueDisplayLength = 100;
+    internal const string SubGraphPathSeparator = " > ";
 
     public string PackageName { get; set; } = string.Empty;
     public List<AnimGraphNode> Nodes { get; } = [];
@@ -137,6 +138,9 @@ public class AnimGraphViewModel
         // Group nodes into layers (connected subgraphs)
         BuildLayers(vm);
 
+        // Prefix state machine internal layers with their parent path to avoid name collisions
+        PrefixStateMachineLayerNames(vm);
+
         return vm;
     }
 
@@ -213,6 +217,46 @@ public class AnimGraphViewModel
         }
     }
 
+    /// <summary>
+    /// Renames state machine internal layers with a parent path prefix
+    /// (e.g., "AnimGraph > Locomotion") to avoid name collisions with
+    /// linked anim layer sub-graphs that may share the same base name.
+    /// </summary>
+    private static void PrefixStateMachineLayerNames(AnimGraphViewModel vm)
+    {
+        // Map: machineName → parent layer name (where the StateMachine node lives)
+        var smParentLayer = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var layer in vm.Layers)
+        {
+            foreach (var node in layer.Nodes)
+            {
+                if (node.AdditionalProperties.TryGetValue("StateMachineName", out var machineName))
+                    smParentLayer.TryAdd(machineName, layer.Name);
+            }
+        }
+
+        // Rename layers whose nodes belong to a state machine
+        foreach (var layer in vm.Layers)
+        {
+            var smName = string.Empty;
+            foreach (var node in layer.Nodes)
+            {
+                if (node.AdditionalProperties.TryGetValue("BelongsToStateMachine", out var val) &&
+                    !string.IsNullOrEmpty(val))
+                {
+                    smName = val;
+                    break;
+                }
+            }
+
+            if (string.IsNullOrEmpty(smName))
+                continue;
+
+            if (smParentLayer.TryGetValue(smName, out var parentName))
+                layer.Name = $"{parentName}{SubGraphPathSeparator}{smName}";
+        }
+    }
+
     /// <summary>
     /// Determines a display name for a layer based on the types of nodes it contains.
     /// A Root node's "Name" property defines the layer/sub-graph name
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index f40f5cc4..8eb77079 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -412,9 +412,18 @@ public partial class AnimGraphViewer
         string? layerName = null;
 
         if (node.ExportType.Contains("LinkedAnimLayer", StringComparison.OrdinalIgnoreCase))
+        {
             node.AdditionalProperties.TryGetValue("Layer", out layerName);
+        }
         else if (node.ExportType.Contains("StateMachine", StringComparison.OrdinalIgnoreCase))
-            node.AdditionalProperties.TryGetValue("StateMachineName", out layerName);
+        {
+            // State machine internal layers are prefixed with parent path
+            if (node.AdditionalProperties.TryGetValue("StateMachineName", out var smName))
+            {
+                var parentName = _currentLayerState?.Layer.Name ?? "AnimGraph";
+                layerName = $"{parentName}{AnimGraphViewModel.SubGraphPathSeparator}{smName}";
+            }
+        }
 
         if (string.IsNullOrEmpty(layerName))
             return;

From 22ba7668eb1a054eecbd9a0ff3a95c79e9f68526 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 10:17:04 +0000
Subject: [PATCH 21/52] Add state machine overview layers with Entry, State
 nodes, and Transition connections

Parse States and Transitions from BakedStateMachines to build state-level
overview layers for each state machine. Each overview shows:
- Entry node (filled circle) connecting to the initial state
- State nodes (rounded rectangles) with their names
- Directional transition arrows between states

The overview layer replaces the old internal per-state layer and is opened
via double-click on StateMachine nodes in the parent graph.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 211 ++++++++++++++++++-
 FModel/Views/AnimGraphViewer.xaml.cs    | 259 +++++++++++++++++++++---
 2 files changed, 440 insertions(+), 30 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 417db9cd..746212e8 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -15,6 +15,8 @@ public class AnimGraphNode
     public string NodeComment { get; set; } = string.Empty;
     public int NodePosX { get; set; }
     public int NodePosY { get; set; }
+    public bool IsStateMachineState { get; set; }
+    public bool IsEntryNode { get; set; }
     public List<AnimGraphPin> Pins { get; set; } = [];
     public Dictionary<string, string> AdditionalProperties { get; set; } = new();
 
@@ -50,11 +52,24 @@ public class AnimGraphLayer
     public List<AnimGraphConnection> Connections { get; } = [];
 }
 
+/// <summary>
+/// Holds metadata extracted from BakedStateMachines for building
+/// state machine overview layers (Entry + State nodes + Transition connections).
+/// </summary>
+internal class StateMachineMetadata
+{
+    public string MachineName { get; init; } = string.Empty;
+    public List<string> StateNames { get; } = [];
+    public List<(int PreviousState, int NextState)> Transitions { get; } = [];
+}
+
 public class AnimGraphViewModel
 {
     private const int GridColumns = 4;
     private const int NodeHorizontalSpacing = 300;
     private const int NodeVerticalSpacing = 200;
+    private const int StateNodeHorizontalSpacing = 250;
+    private const int StateNodeVerticalSpacing = 150;
     private const int MaxPropertyValueDisplayLength = 100;
     internal const string SubGraphPathSeparator = " > ";
 
@@ -133,7 +148,9 @@ public class AnimGraphViewModel
         }
 
         // Associate state machine nodes with their baked machine names
-        AssociateStateMachineNames(animBlueprintClass, cdo, animNodeProps, nodeByName);
+        // and collect state machine metadata for overview layers
+        var smMetadata = new List<StateMachineMetadata>();
+        AssociateStateMachineNames(animBlueprintClass, cdo, animNodeProps, nodeByName, smMetadata);
 
         // Group nodes into layers (connected subgraphs)
         BuildLayers(vm);
@@ -141,6 +158,9 @@ public class AnimGraphViewModel
         // Prefix state machine internal layers with their parent path to avoid name collisions
         PrefixStateMachineLayerNames(vm);
 
+        // Build state machine overview layers (Entry + State nodes + Transitions)
+        BuildStateMachineOverviewLayers(vm, smMetadata);
+
         return vm;
     }
 
@@ -257,6 +277,142 @@ public class AnimGraphViewModel
         }
     }
 
+    /// <summary>
+    /// Creates state machine overview layers with synthetic Entry + State nodes
+    /// and transition connections between states, providing a UE-like state machine
+    /// editor view. The overview layer is named with the path prefix to match
+    /// double-click navigation from StateMachine nodes.
+    /// </summary>
+    private static void BuildStateMachineOverviewLayers(AnimGraphViewModel vm, List<StateMachineMetadata> smMetadata)
+    {
+        // Map: machineName → parent layer name (where the StateMachine node lives)
+        var smParentLayer = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var layer in vm.Layers)
+        {
+            foreach (var node in layer.Nodes)
+            {
+                if (node.AdditionalProperties.TryGetValue("StateMachineName", out var machineName))
+                    smParentLayer.TryAdd(machineName, layer.Name);
+            }
+        }
+
+        foreach (var sm in smMetadata)
+        {
+            if (sm.StateNames.Count == 0) continue;
+
+            // Determine the path-prefixed layer name
+            var parentName = smParentLayer.GetValueOrDefault(sm.MachineName, "AnimGraph");
+            var overviewLayerName = $"{parentName}{SubGraphPathSeparator}{sm.MachineName}";
+
+            // Remove existing internal layers with this name (they'll be replaced by the overview)
+            vm.Layers.RemoveAll(l => l.Name.Equals(overviewLayerName, StringComparison.OrdinalIgnoreCase));
+
+            var overviewLayer = new AnimGraphLayer { Name = overviewLayerName };
+            var stateNodes = new List<AnimGraphNode>();
+
+            // Create Entry node
+            var entryNode = new AnimGraphNode
+            {
+                Name = "Entry",
+                ExportType = "Entry",
+                IsEntryNode = true
+            };
+            entryNode.Pins.Add(new AnimGraphPin
+            {
+                PinName = "Output",
+                IsOutput = true,
+                PinType = "transition",
+                OwnerNode = entryNode
+            });
+            overviewLayer.Nodes.Add(entryNode);
+
+            // Create State nodes
+            for (var i = 0; i < sm.StateNames.Count; i++)
+            {
+                var stateNode = new AnimGraphNode
+                {
+                    Name = sm.StateNames[i],
+                    ExportType = "State",
+                    IsStateMachineState = true
+                };
+                stateNode.Pins.Add(new AnimGraphPin
+                {
+                    PinName = "In",
+                    IsOutput = false,
+                    PinType = "transition",
+                    OwnerNode = stateNode
+                });
+                stateNode.Pins.Add(new AnimGraphPin
+                {
+                    PinName = "Out",
+                    IsOutput = true,
+                    PinType = "transition",
+                    OwnerNode = stateNode
+                });
+                stateNodes.Add(stateNode);
+                overviewLayer.Nodes.Add(stateNode);
+            }
+
+            // Entry connects to first state (state index 0)
+            if (stateNodes.Count > 0)
+            {
+                overviewLayer.Connections.Add(new AnimGraphConnection
+                {
+                    SourceNode = entryNode,
+                    SourcePinName = "Output",
+                    TargetNode = stateNodes[0],
+                    TargetPinName = "In"
+                });
+            }
+
+            // Transition connections between states
+            foreach (var (prevIdx, nextIdx) in sm.Transitions)
+            {
+                if (prevIdx < stateNodes.Count && nextIdx < stateNodes.Count)
+                {
+                    overviewLayer.Connections.Add(new AnimGraphConnection
+                    {
+                        SourceNode = stateNodes[prevIdx],
+                        SourcePinName = "Out",
+                        TargetNode = stateNodes[nextIdx],
+                        TargetPinName = "In"
+                    });
+                }
+            }
+
+            // Layout state nodes in a grid arrangement
+            LayoutStateMachineOverview(overviewLayer, entryNode, stateNodes);
+
+            vm.Layers.Add(overviewLayer);
+        }
+    }
+
+    /// <summary>
+    /// Arranges state machine overview nodes: Entry on the left, state nodes in a grid.
+    /// </summary>
+    private static void LayoutStateMachineOverview(AnimGraphLayer layer, AnimGraphNode entryNode, List<AnimGraphNode> stateNodes)
+    {
+        // Place Entry on the far left
+        entryNode.NodePosX = 0;
+        entryNode.NodePosY = 0;
+
+        if (stateNodes.Count == 0) return;
+
+        // Arrange state nodes in a grid to the right of Entry
+        var cols = Math.Max(1, (int)Math.Ceiling(Math.Sqrt(stateNodes.Count)));
+        for (var i = 0; i < stateNodes.Count; i++)
+        {
+            var col = i % cols;
+            var row = i / cols;
+            stateNodes[i].NodePosX = StateNodeHorizontalSpacing + col * StateNodeHorizontalSpacing;
+            stateNodes[i].NodePosY = row * StateNodeVerticalSpacing;
+        }
+
+        // Center Entry vertically relative to state nodes
+        var maxRow = (stateNodes.Count - 1) / cols;
+        entryNode.NodePosY = maxRow * StateNodeVerticalSpacing / 2;
+    }
+
     /// <summary>
     /// Determines a display name for a layer based on the types of nodes it contains.
     /// A Root node's "Name" property defines the layer/sub-graph name
@@ -307,12 +463,13 @@ public class AnimGraphViewModel
 
     /// <summary>
     /// Reads BakedStateMachines from the animation blueprint class to associate
-    /// FAnimNode_StateMachine nodes with their machine names and mark internal
-    /// state root nodes so they can be grouped into correctly named layers.
+    /// FAnimNode_StateMachine nodes with their machine names, mark internal
+    /// state root nodes, and collect state/transition metadata for overview layers.
     /// </summary>
     private static void AssociateStateMachineNames(UClass animBlueprintClass, UObject? cdo,
         List<(string name, string structType)> animNodeProps,
-        Dictionary<string, AnimGraphNode> nodeByName)
+        Dictionary<string, AnimGraphNode> nodeByName,
+        List<StateMachineMetadata> smMetadata)
     {
         // BakedStateMachines is a UPROPERTY on UAnimBlueprintGeneratedClass
         // Try reading from both the class and CDO
@@ -357,17 +514,30 @@ public class AnimGraphViewModel
                     smNode.AdditionalProperties["StateMachineName"] = machineName;
             }
 
-            // Mark state root nodes with BelongsToStateMachine so their layers get the machine name
+            var metadata = new StateMachineMetadata { MachineName = machineName };
+
+            // Extract state names and mark root nodes with BelongsToStateMachine
             foreach (var prop in machineStruct.Properties)
             {
                 if (prop.Name.Text != "States") continue;
                 if (prop.Tag?.GenericValue is not UScriptArray states) break;
 
-                foreach (var stateProp in states.Properties)
+                for (var stateIdx = 0; stateIdx < states.Properties.Count; stateIdx++)
                 {
-                    if (stateProp.GetValue(typeof(FStructFallback)) is not FStructFallback stateStruct)
+                    if (states.Properties[stateIdx].GetValue(typeof(FStructFallback)) is not FStructFallback stateStruct)
+                    {
+                        metadata.StateNames.Add($"State_{stateIdx}");
                         continue;
+                    }
 
+                    // Extract state name
+                    var stateName = $"State_{stateIdx}";
+                    if (stateStruct.TryGetValue(out FName stateNameProp, "StateName"))
+                        stateName = stateNameProp.Text;
+
+                    metadata.StateNames.Add(stateName);
+
+                    // Mark root node
                     if (!stateStruct.TryGetValue(out int stateRootIndex, "StateRootNodeIndex"))
                         continue;
 
@@ -380,6 +550,33 @@ public class AnimGraphViewModel
                 }
                 break;
             }
+
+            // Extract machine-level transitions (PreviousState → NextState)
+            foreach (var prop in machineStruct.Properties)
+            {
+                if (prop.Name.Text != "Transitions") continue;
+                if (prop.Tag?.GenericValue is not UScriptArray transitions) break;
+
+                foreach (var transProp in transitions.Properties)
+                {
+                    if (transProp.GetValue(typeof(FStructFallback)) is not FStructFallback transStruct)
+                        continue;
+
+                    if (!transStruct.TryGetValue(out int previousState, "PreviousState"))
+                        continue;
+                    if (!transStruct.TryGetValue(out int nextState, "NextState"))
+                        continue;
+
+                    if (previousState >= 0 && nextState >= 0 &&
+                        previousState < metadata.StateNames.Count && nextState < metadata.StateNames.Count)
+                    {
+                        metadata.Transitions.Add((previousState, nextState));
+                    }
+                }
+                break;
+            }
+
+            smMetadata.Add(metadata);
         }
     }
 
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 8eb77079..3b9ce7aa 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -21,6 +21,11 @@ public partial class AnimGraphViewer
     private const double PinLabelOffset = 14; // PinCircleRadius * 2 + padding
     private const double HeaderGradientDarkenFactor = 0.6;
     private const double DefaultGraphWidthRatio = 0.65;
+    private const double StateNodeWidth = 180;
+    private const double StateNodeHeight = 50;
+    private const double StateNodeCornerRadius = 24;
+    private const double EntryNodeSize = 30;
+    private const double TransitionArrowSize = 10;
 
     private readonly AnimGraphViewModel _viewModel;
 
@@ -160,17 +165,22 @@ public partial class AnimGraphViewer
             state.NodePositions[node] = new Point(node.NodePosX, node.NodePosY);
         }
 
-        // Draw nodes
-        foreach (var node in state.Layer.Nodes)
-        {
-            DrawNode(state, node);
-        }
-
-        // Draw connections
+        // Draw connections first (behind nodes) for state machine overview
         foreach (var conn in state.Layer.Connections)
         {
             DrawConnectionLine(state, conn);
         }
+
+        // Draw nodes
+        foreach (var node in state.Layer.Nodes)
+        {
+            if (node.IsEntryNode)
+                DrawEntryNode(state, node);
+            else if (node.IsStateMachineState)
+                DrawStateNode(state, node);
+            else
+                DrawNode(state, node);
+        }
     }
 
     private void DrawNode(LayerCanvasState state, AnimGraphNode node)
@@ -321,6 +331,142 @@ public partial class AnimGraphViewer
         };
     }
 
+    /// <summary>
+    /// Draws an Entry node as a small filled circle, matching UE's state machine editor.
+    /// </summary>
+    private void DrawEntryNode(LayerCanvasState state, AnimGraphNode node)
+    {
+        var pos = state.NodePositions[node];
+
+        var circle = new Ellipse
+        {
+            Width = EntryNodeSize,
+            Height = EntryNodeSize,
+            Fill = new SolidColorBrush(Color.FromRgb(80, 80, 80)),
+            Stroke = new SolidColorBrush(Color.FromRgb(200, 200, 200)),
+            StrokeThickness = 2,
+            SnapsToDevicePixels = true
+        };
+        Canvas.SetLeft(circle, pos.X);
+        Canvas.SetTop(circle, pos.Y);
+        Panel.SetZIndex(circle, 1);
+        state.Canvas.Children.Add(circle);
+
+        var label = new TextBlock
+        {
+            Text = "Entry",
+            Foreground = Brushes.White,
+            FontSize = 10,
+            FontWeight = FontWeights.SemiBold,
+            TextAlignment = TextAlignment.Center
+        };
+        label.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
+        Canvas.SetLeft(label, pos.X + EntryNodeSize / 2 - label.DesiredSize.Width / 2);
+        Canvas.SetTop(label, pos.Y + EntryNodeSize + 4);
+        Panel.SetZIndex(label, 1);
+        state.Canvas.Children.Add(label);
+
+        // Output pin position (right edge of circle)
+        state.PinPositions[(node, "Output", true)] = new Point(
+            pos.X + EntryNodeSize, pos.Y + EntryNodeSize / 2);
+
+        // Store visuals with a dummy border for selection
+        var hitArea = new Border
+        {
+            Width = EntryNodeSize,
+            Height = EntryNodeSize,
+            Background = Brushes.Transparent,
+            CornerRadius = new CornerRadius(EntryNodeSize / 2)
+        };
+        Canvas.SetLeft(hitArea, pos.X);
+        Canvas.SetTop(hitArea, pos.Y);
+        Panel.SetZIndex(hitArea, 2);
+        state.Canvas.Children.Add(hitArea);
+        state.NodeVisuals[node] = (hitArea, EntryNodeSize, EntryNodeSize);
+
+        hitArea.MouseLeftButtonDown += (s, e) =>
+        {
+            SelectNode(node, hitArea);
+            e.Handled = true;
+        };
+    }
+
+    /// <summary>
+    /// Draws a state machine state node as a rounded rectangle with a centered name,
+    /// matching UE's state machine editor visual style.
+    /// </summary>
+    private void DrawStateNode(LayerCanvasState state, AnimGraphNode node)
+    {
+        var pos = state.NodePositions[node];
+
+        // Shadow
+        var shadow = new Border
+        {
+            Width = StateNodeWidth,
+            Height = StateNodeHeight,
+            CornerRadius = new CornerRadius(StateNodeCornerRadius),
+            Background = Brushes.Black,
+            Opacity = 0.4,
+            Effect = new BlurEffect { Radius = 6 }
+        };
+        Canvas.SetLeft(shadow, pos.X + 2);
+        Canvas.SetTop(shadow, pos.Y + 2);
+        Panel.SetZIndex(shadow, 0);
+        state.Canvas.Children.Add(shadow);
+
+        // State body
+        var border = new Border
+        {
+            Width = StateNodeWidth,
+            Height = StateNodeHeight,
+            CornerRadius = new CornerRadius(StateNodeCornerRadius),
+            Background = new SolidColorBrush(Color.FromArgb(240, 55, 55, 55)),
+            BorderBrush = new SolidColorBrush(Color.FromRgb(120, 120, 120)),
+            BorderThickness = new Thickness(2),
+            SnapsToDevicePixels = true
+        };
+
+        var nameText = new TextBlock
+        {
+            Text = node.Name,
+            Foreground = Brushes.White,
+            FontSize = 13,
+            FontWeight = FontWeights.SemiBold,
+            HorizontalAlignment = HorizontalAlignment.Center,
+            VerticalAlignment = VerticalAlignment.Center,
+            TextTrimming = TextTrimming.CharacterEllipsis,
+            TextAlignment = TextAlignment.Center
+        };
+        border.Child = nameText;
+
+        Canvas.SetLeft(border, pos.X);
+        Canvas.SetTop(border, pos.Y);
+        Panel.SetZIndex(border, 1);
+        state.Canvas.Children.Add(border);
+
+        state.NodeVisuals[node] = (border, StateNodeWidth, StateNodeHeight);
+
+        // Pin positions (left = input, right = output)
+        state.PinPositions[(node, "In", false)] = new Point(
+            pos.X, pos.Y + StateNodeHeight / 2);
+        state.PinPositions[(node, "Out", true)] = new Point(
+            pos.X + StateNodeWidth, pos.Y + StateNodeHeight / 2);
+
+        border.ToolTip = $"State: {node.Name}";
+
+        border.MouseLeftButtonDown += (s, e) =>
+        {
+            if (e.ClickCount == 2)
+            {
+                TryOpenSubGraph(node);
+                e.Handled = true;
+                return;
+            }
+            SelectNode(node, border);
+            e.Handled = true;
+        };
+    }
+
     private void AddPinVisual(Canvas pinsCanvas, AnimGraphPin pin, double y, bool isInput, Color pinColor)
     {
         var displayName = string.IsNullOrEmpty(pin.PinName) ? "(unnamed)" : pin.PinName;
@@ -415,6 +561,13 @@ public partial class AnimGraphViewer
         {
             node.AdditionalProperties.TryGetValue("Layer", out layerName);
         }
+        else if (node.IsStateMachineState)
+        {
+            // State nodes within an overview: try to open internal per-state layer
+            // Internal layers share the state machine's path prefix name
+            // (future: individual state layers could be opened here)
+            return;
+        }
         else if (node.ExportType.Contains("StateMachine", StringComparison.OrdinalIgnoreCase))
         {
             // State machine internal layers are prefixed with parent path
@@ -571,28 +724,87 @@ public partial class AnimGraphViewer
         // Determine wire color from source pin type
         var sourcePin = conn.SourceNode.Pins.FirstOrDefault(p => p.PinName == conn.SourcePinName && p.IsOutput);
         var wireColor = sourcePin != null ? GetPinColor(sourcePin.PinType) : Color.FromRgb(200, 200, 220);
+        var isTransition = (conn.SourceNode.IsStateMachineState || conn.SourceNode.IsEntryNode) &&
+                           (conn.TargetNode.IsStateMachineState || conn.TargetNode.IsEntryNode);
 
-        var dx = Math.Max(Math.Abs(endPos.X - startPos.X) * 0.5, 50);
-        var pathFigure = new PathFigure { StartPoint = startPos };
-        pathFigure.Segments.Add(new BezierSegment(
-            new Point(startPos.X + dx, startPos.Y),
-            new Point(endPos.X - dx, endPos.Y),
-            endPos, true));
-
-        var pathGeometry = new PathGeometry();
-        pathGeometry.Figures.Add(pathFigure);
-
-        var path = new Path
+        if (isTransition)
         {
-            Data = pathGeometry,
-            Stroke = new SolidColorBrush(wireColor),
+            DrawTransitionArrow(state, startPos, endPos, wireColor);
+        }
+        else
+        {
+            var dx = Math.Max(Math.Abs(endPos.X - startPos.X) * 0.5, 50);
+            var pathFigure = new PathFigure { StartPoint = startPos };
+            pathFigure.Segments.Add(new BezierSegment(
+                new Point(startPos.X + dx, startPos.Y),
+                new Point(endPos.X - dx, endPos.Y),
+                endPos, true));
+
+            var pathGeometry = new PathGeometry();
+            pathGeometry.Figures.Add(pathFigure);
+
+            var path = new Path
+            {
+                Data = pathGeometry,
+                Stroke = new SolidColorBrush(wireColor),
+                StrokeThickness = 2.5,
+                Opacity = 0.85,
+                SnapsToDevicePixels = true,
+                IsHitTestVisible = false
+            };
+            Panel.SetZIndex(path, 0);
+            state.Canvas.Children.Add(path);
+        }
+    }
+
+    /// <summary>
+    /// Draws a directional transition arrow between state machine state nodes,
+    /// with an arrowhead at the target end.
+    /// </summary>
+    private static void DrawTransitionArrow(LayerCanvasState state, Point startPos, Point endPos, Color wireColor)
+    {
+        var brush = new SolidColorBrush(wireColor);
+
+        // Main line
+        var line = new Line
+        {
+            X1 = startPos.X,
+            Y1 = startPos.Y,
+            X2 = endPos.X,
+            Y2 = endPos.Y,
+            Stroke = brush,
             StrokeThickness = 2.5,
-            Opacity = 0.85,
             SnapsToDevicePixels = true,
             IsHitTestVisible = false
         };
-        Panel.SetZIndex(path, 0);
-        state.Canvas.Children.Add(path);
+        Panel.SetZIndex(line, 0);
+        state.Canvas.Children.Add(line);
+
+        // Arrowhead
+        var dx = endPos.X - startPos.X;
+        var dy = endPos.Y - startPos.Y;
+        var length = Math.Sqrt(dx * dx + dy * dy);
+        if (length < 1) return;
+
+        var ux = dx / length;
+        var uy = dy / length;
+        var arrowBase = new Point(endPos.X - ux * TransitionArrowSize, endPos.Y - uy * TransitionArrowSize);
+        var perpX = -uy * TransitionArrowSize * 0.5;
+        var perpY = ux * TransitionArrowSize * 0.5;
+
+        var arrowHead = new Polygon
+        {
+            Points =
+            [
+                endPos,
+                new Point(arrowBase.X + perpX, arrowBase.Y + perpY),
+                new Point(arrowBase.X - perpX, arrowBase.Y - perpY)
+            ],
+            Fill = brush,
+            IsHitTestVisible = false
+        };
+        Panel.SetZIndex(arrowHead, 0);
+        state.Canvas.Children.Add(arrowHead);
     }
 
     private static string GetNodeDisplayName(AnimGraphNode node)
@@ -642,6 +854,7 @@ public partial class AnimGraphViewer
             "string" or "text" or "name" => Color.FromRgb(255, 80, 180),
             "delegate" => Color.FromRgb(255, 56, 56),
             "pose" => Color.FromRgb(0, 160, 100),
+            "transition" => Color.FromRgb(200, 200, 200),
             _ => Color.FromRgb(180, 180, 200)
         };
     }

From 2711be76e03da97bc229acb275515eac83cd0173 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 12:15:40 +0000
Subject: [PATCH 22/52] Add double-click state node to open per-state sub-graph
 tab

- GetLayerName: also match _StateResult nodes for per-state layer naming
- PrefixStateMachineLayerNames: per-state layers get 3-level path prefix
  (e.g., "AnimGraph > Locomotion > Idle")
- TryOpenSubGraph: state nodes navigate to per-state sub-graph layer

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 16 ++++++++++++----
 FModel/Views/AnimGraphViewer.xaml.cs    |  8 ++++----
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 746212e8..4da8f3bc 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -239,8 +239,8 @@ public class AnimGraphViewModel
 
     /// <summary>
     /// Renames state machine internal layers with a parent path prefix
-    /// (e.g., "AnimGraph > Locomotion") to avoid name collisions with
-    /// linked anim layer sub-graphs that may share the same base name.
+    /// (e.g., "AnimGraph > Locomotion" for the overview, or
+    /// "AnimGraph > Locomotion > Idle" for per-state sub-graphs).
     /// </summary>
     private static void PrefixStateMachineLayerNames(AnimGraphViewModel vm)
     {
@@ -272,7 +272,14 @@ public class AnimGraphViewModel
             if (string.IsNullOrEmpty(smName))
                 continue;
 
-            if (smParentLayer.TryGetValue(smName, out var parentName))
+            if (!smParentLayer.TryGetValue(smName, out var parentName))
+                continue;
+
+            // Per-state layers have a name different from the machine name
+            // (named after the StateResult node's Name property)
+            if (!layer.Name.Equals(smName, StringComparison.OrdinalIgnoreCase))
+                layer.Name = $"{parentName}{SubGraphPathSeparator}{smName}{SubGraphPathSeparator}{layer.Name}";
+            else
                 layer.Name = $"{parentName}{SubGraphPathSeparator}{smName}";
         }
     }
@@ -421,7 +428,8 @@ public class AnimGraphViewModel
     private static string GetLayerName(List<AnimGraphNode> nodes, int index)
     {
         var rootNode = nodes.FirstOrDefault(n =>
-            n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase) &&
+            (n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase) ||
+             n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase)) &&
             n.AdditionalProperties.TryGetValue("Name", out _));
         if (rootNode != null &&
             rootNode.AdditionalProperties.TryGetValue("Name", out var rootName) &&
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 3b9ce7aa..d4375367 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -563,10 +563,10 @@ public partial class AnimGraphViewer
         }
         else if (node.IsStateMachineState)
         {
-            // State nodes within an overview: try to open internal per-state layer
-            // Internal layers share the state machine's path prefix name
-            // (future: individual state layers could be opened here)
-            return;
+            // State nodes within an overview: open the per-state internal sub-graph
+            // Per-state layers are named "overviewPath > stateName"
+            var overviewName = _currentLayerState?.Layer.Name ?? string.Empty;
+            layerName = $"{overviewName}{AnimGraphViewModel.SubGraphPathSeparator}{node.Name}";
         }
         else if (node.ExportType.Contains("StateMachine", StringComparison.OrdinalIgnoreCase))
         {

From 5b4cb7e4ee2a7cb50c1bdfbf75cee55be0afc927 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 12:35:43 +0000
Subject: [PATCH 23/52] Use StateRootNodeIndex for per-state sub-graph lookup
 instead of name matching

- StateMachineMetadata: store root node property names per state via StateRootPropNames
- AssociateStateMachineNames: capture root prop name from StateRootNodeIndex
- BuildStateMachineOverviewLayers: store StateRootNodeName on overview state nodes
- TryOpenSubGraph: find per-state layer by root node reference, not name path

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 17 +++++++++++-----
 FModel/Views/AnimGraphViewer.xaml.cs    | 26 +++++++++++++++++++++----
 2 files changed, 34 insertions(+), 9 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 4da8f3bc..e8f04b13 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -60,6 +60,7 @@ internal class StateMachineMetadata
 {
     public string MachineName { get; init; } = string.Empty;
     public List<string> StateNames { get; } = [];
+    public List<string> StateRootPropNames { get; } = [];
     public List<(int PreviousState, int NextState)> Transitions { get; } = [];
 }
 
@@ -342,6 +343,9 @@ public class AnimGraphViewModel
                     ExportType = "State",
                     IsStateMachineState = true
                 };
+                // Store root node property name for StateRootNodeIndex-based lookup
+                if (i < sm.StateRootPropNames.Count && !string.IsNullOrEmpty(sm.StateRootPropNames[i]))
+                    stateNode.AdditionalProperties["StateRootNodeName"] = sm.StateRootPropNames[i];
                 stateNode.Pins.Add(new AnimGraphPin
                 {
                     PinName = "In",
@@ -535,6 +539,7 @@ public class AnimGraphViewModel
                     if (states.Properties[stateIdx].GetValue(typeof(FStructFallback)) is not FStructFallback stateStruct)
                     {
                         metadata.StateNames.Add($"State_{stateIdx}");
+                        metadata.StateRootPropNames.Add(string.Empty);
                         continue;
                     }
 
@@ -545,14 +550,16 @@ public class AnimGraphViewModel
 
                     metadata.StateNames.Add(stateName);
 
-                    // Mark root node
-                    if (!stateStruct.TryGetValue(out int stateRootIndex, "StateRootNodeIndex"))
-                        continue;
-
-                    if (stateRootIndex < 0 || stateRootIndex >= animNodeProps.Count)
+                    // Mark root node via StateRootNodeIndex
+                    if (!stateStruct.TryGetValue(out int stateRootIndex, "StateRootNodeIndex") ||
+                        stateRootIndex < 0 || stateRootIndex >= animNodeProps.Count)
+                    {
+                        metadata.StateRootPropNames.Add(string.Empty);
                         continue;
+                    }
 
                     var rootPropName = animNodeProps[stateRootIndex].name;
+                    metadata.StateRootPropNames.Add(rootPropName);
                     if (nodeByName.TryGetValue(rootPropName, out var rootNode))
                         rootNode.AdditionalProperties["BelongsToStateMachine"] = machineName;
                 }
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index d4375367..5bbc8fa0 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -563,10 +563,28 @@ public partial class AnimGraphViewer
         }
         else if (node.IsStateMachineState)
         {
-            // State nodes within an overview: open the per-state internal sub-graph
-            // Per-state layers are named "overviewPath > stateName"
-            var overviewName = _currentLayerState?.Layer.Name ?? string.Empty;
-            layerName = $"{overviewName}{AnimGraphViewModel.SubGraphPathSeparator}{node.Name}";
+            // State nodes within an overview: find the per-state layer by StateRootNodeIndex
+            // The root node's property name is stored on the overview state node
+            if (node.AdditionalProperties.TryGetValue("StateRootNodeName", out var rootNodeName) &&
+                !string.IsNullOrEmpty(rootNodeName))
+            {
+                var targetLayer = _viewModel.Layers.FirstOrDefault(l =>
+                    l.Nodes.Any(n => n.Name == rootNodeName));
+                if (targetLayer != null)
+                {
+                    // If tab already exists, just select it
+                    foreach (System.Windows.Controls.TabItem tab in LayerTabControl.Items)
+                    {
+                        if (tab.Tag == targetLayer)
+                        {
+                            LayerTabControl.SelectedItem = tab;
+                            return;
+                        }
+                    }
+                    AddLayerTab(targetLayer);
+                    return;
+                }
+            }
         }
         else if (node.ExportType.Contains("StateMachine", StringComparison.OrdinalIgnoreCase))
         {

From b29f93fbf346f6e463714e5bddb936d1905c2114 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 12:51:03 +0000
Subject: [PATCH 24/52] Separate layer and state sub-graph identification in
 BuildLayers

GetLayerName now distinguishes animation blueprint layers (_Root nodes,
found by Name property) from state machine state sub-graphs (_StateResult
nodes, found by unique property name from StateRootNodeIndex). This avoids
duplicate name collisions when multiple states share the same display name.

PrefixStateMachineLayerNames resolves the _StateResult node's Name
additional property for the display portion of path-prefixed names.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 27 ++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index e8f04b13..2973ee62 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -276,10 +276,15 @@ public class AnimGraphViewModel
             if (!smParentLayer.TryGetValue(smName, out var parentName))
                 continue;
 
-            // Per-state layers have a name different from the machine name
-            // (named after the StateResult node's Name property)
+            // Per-state layers are named by the _StateResult root node's property name (unique);
+            // use the _StateResult node's Name additional property for the display portion
             if (!layer.Name.Equals(smName, StringComparison.OrdinalIgnoreCase))
-                layer.Name = $"{parentName}{SubGraphPathSeparator}{smName}{SubGraphPathSeparator}{layer.Name}";
+            {
+                var stateResultNode = layer.Nodes.FirstOrDefault(n =>
+                    n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase));
+                var stateName = stateResultNode?.AdditionalProperties.GetValueOrDefault("Name") ?? layer.Name;
+                layer.Name = $"{parentName}{SubGraphPathSeparator}{smName}{SubGraphPathSeparator}{stateName}";
+            }
             else
                 layer.Name = $"{parentName}{SubGraphPathSeparator}{smName}";
         }
@@ -426,20 +431,28 @@ public class AnimGraphViewModel
 
     /// <summary>
     /// Determines a display name for a layer based on the types of nodes it contains.
-    /// A Root node's "Name" property defines the layer/sub-graph name
-    /// (e.g., "AnimGraph" for the main output pose, or a specific name for LinkedAnimLayer sub-graphs).
+    /// Animation blueprint layers use the _Root node's "Name" property (e.g., "AnimGraph").
+    /// State machine state sub-graphs use the _StateResult root node's unique property name
+    /// (from StateRootNodeIndex) to avoid duplicate name collisions.
     /// </summary>
     private static string GetLayerName(List<AnimGraphNode> nodes, int index)
     {
+        // Animation blueprint layers: use _Root node's Name property
         var rootNode = nodes.FirstOrDefault(n =>
-            (n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase) ||
-             n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase)) &&
+            n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase) &&
             n.AdditionalProperties.TryGetValue("Name", out _));
         if (rootNode != null &&
             rootNode.AdditionalProperties.TryGetValue("Name", out var rootName) &&
             !string.IsNullOrEmpty(rootName))
             return rootName;
 
+        // State machine state sub-graphs: use the _StateResult root node's property name
+        // (unique identifier from StateRootNodeIndex, avoids duplicate state name collisions)
+        var stateResultNode = nodes.FirstOrDefault(n =>
+            n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase));
+        if (stateResultNode != null)
+            return stateResultNode.Name;
+
         // Check if any node belongs to a baked state machine
         var smNode = nodes.FirstOrDefault(n =>
             n.AdditionalProperties.TryGetValue("BelongsToStateMachine", out _));

From 7b6f9aac79a3251ee4087e154bf38ef90f56e968 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 13:05:43 +0000
Subject: [PATCH 25/52] Rewrite BuildLayers to use root-node-based layer
 grouping

Instead of using connected components (undirected BFS), BuildLayers now
groups nodes by their defining root nodes. Each AnimGraphNode_Root defines
an animation blueprint layer and each AnimGraphNode_StateResult defines a
state machine state sub-graph. For each root, we trace upstream through
directed connections to collect all nodes that feed into it.

Remaining unassigned nodes fall back to connected-component grouping.
Extracted AddLayer helper to reduce duplication.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 133 ++++++++++++++++--------
 1 file changed, 89 insertions(+), 44 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 2973ee62..c0a1d50b 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -166,78 +166,123 @@ public class AnimGraphViewModel
     }
 
     /// <summary>
-    /// Groups nodes into layers by finding connected components in the graph.
-    /// Each connected component becomes a separate layer/tab, named after
-    /// its most prominent node (Root, StateMachine, etc.).
+    /// Groups nodes into layers based on root nodes. In Unreal Engine, each
+    /// animation blueprint layer has a unique AnimGraphNode_Root, and each
+    /// state machine state sub-graph has a unique AnimGraphNode_StateResult.
+    /// Starting from each root node, we trace upstream through directed
+    /// connections to collect all nodes that feed into it.
     /// </summary>
     private static void BuildLayers(AnimGraphViewModel vm)
     {
         if (vm.Nodes.Count == 0) return;
 
-        // Build adjacency sets (undirected) for connected component detection
-        var adjacency = new Dictionary<AnimGraphNode, HashSet<AnimGraphNode>>();
+        // Build upstream map: for each node, which nodes feed into it
+        // Connection direction: SourceNode (provider) → TargetNode (consumer)
+        var upstreamOf = new Dictionary<AnimGraphNode, List<AnimGraphNode>>();
         foreach (var node in vm.Nodes)
-            adjacency[node] = [];
+            upstreamOf[node] = [];
 
         foreach (var conn in vm.Connections)
+            upstreamOf[conn.TargetNode].Add(conn.SourceNode);
+
+        // Find all root nodes that define layers:
+        // _Root nodes define animation blueprint layers
+        // _StateResult nodes define state machine state sub-graphs
+        var rootNodes = vm.Nodes
+            .Where(n => n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase) ||
+                        n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase))
+            .ToList();
+
+        var assigned = new HashSet<AnimGraphNode>();
+        var layerIndex = 0;
+
+        // For each root node, BFS upstream to find all nodes in the layer
+        foreach (var rootNode in rootNodes)
         {
-            adjacency[conn.SourceNode].Add(conn.TargetNode);
-            adjacency[conn.TargetNode].Add(conn.SourceNode);
-        }
+            if (!assigned.Add(rootNode)) continue;
 
-        // Find connected components via BFS
-        var visited = new HashSet<AnimGraphNode>();
-        var components = new List<List<AnimGraphNode>>();
-
-        foreach (var node in vm.Nodes)
-        {
-            if (visited.Contains(node)) continue;
-
-            var component = new List<AnimGraphNode>();
+            var layerNodes = new List<AnimGraphNode> { rootNode };
             var queue = new Queue<AnimGraphNode>();
-            queue.Enqueue(node);
-            visited.Add(node);
+            queue.Enqueue(rootNode);
 
             while (queue.Count > 0)
             {
                 var current = queue.Dequeue();
-                component.Add(current);
-
-                foreach (var neighbor in adjacency[current])
+                foreach (var upstream in upstreamOf[current])
                 {
-                    if (visited.Add(neighbor))
-                        queue.Enqueue(neighbor);
+                    if (assigned.Add(upstream))
+                    {
+                        layerNodes.Add(upstream);
+                        queue.Enqueue(upstream);
+                    }
                 }
             }
 
-            components.Add(component);
+            AddLayer(vm, layerNodes, layerIndex++);
         }
 
-        // Create a layer for each connected component
-        var layerIndex = 0;
-        foreach (var component in components)
+        // Any remaining unassigned nodes go into fallback layers (connected components)
+        var remaining = vm.Nodes.Where(n => !assigned.Contains(n)).ToList();
+        if (remaining.Count == 0) return;
+
+        var adjacency = new Dictionary<AnimGraphNode, HashSet<AnimGraphNode>>();
+        foreach (var node in remaining)
+            adjacency[node] = [];
+
+        foreach (var conn in vm.Connections)
         {
-            var componentSet = new HashSet<AnimGraphNode>(component);
-            var layerName = GetLayerName(component, layerIndex);
-
-            var layer = new AnimGraphLayer { Name = layerName };
-            layer.Nodes.AddRange(component);
-
-            // Add only the connections that belong to this component
-            foreach (var conn in vm.Connections)
+            if (adjacency.ContainsKey(conn.SourceNode) && adjacency.ContainsKey(conn.TargetNode))
             {
-                if (componentSet.Contains(conn.SourceNode) && componentSet.Contains(conn.TargetNode))
-                    layer.Connections.Add(conn);
+                adjacency[conn.SourceNode].Add(conn.TargetNode);
+                adjacency[conn.TargetNode].Add(conn.SourceNode);
+            }
+        }
+
+        foreach (var node in remaining)
+        {
+            if (!assigned.Add(node)) continue;
+
+            var component = new List<AnimGraphNode> { node };
+            var queue = new Queue<AnimGraphNode>();
+            queue.Enqueue(node);
+
+            while (queue.Count > 0)
+            {
+                var current = queue.Dequeue();
+                foreach (var neighbor in adjacency[current])
+                {
+                    if (assigned.Add(neighbor))
+                    {
+                        component.Add(neighbor);
+                        queue.Enqueue(neighbor);
+                    }
+                }
             }
 
-            // Layout nodes within this layer in a grid
-            LayoutLayerNodes(layer);
-
-            vm.Layers.Add(layer);
-            layerIndex++;
+            AddLayer(vm, component, layerIndex++);
         }
     }
 
+    /// <summary>
+    /// Creates an <see cref="AnimGraphLayer"/> from a set of nodes, assigns
+    /// the relevant connections, lays out the nodes and adds the layer to the VM.
+    /// </summary>
+    private static void AddLayer(AnimGraphViewModel vm, List<AnimGraphNode> nodes, int index)
+    {
+        var nodeSet = new HashSet<AnimGraphNode>(nodes);
+        var layer = new AnimGraphLayer { Name = GetLayerName(nodes, index) };
+        layer.Nodes.AddRange(nodes);
+
+        foreach (var conn in vm.Connections)
+        {
+            if (nodeSet.Contains(conn.SourceNode) && nodeSet.Contains(conn.TargetNode))
+                layer.Connections.Add(conn);
+        }
+
+        LayoutLayerNodes(layer);
+        vm.Layers.Add(layer);
+    }
+
     /// <summary>
     /// Renames state machine internal layers with a parent path prefix
     /// (e.g., "AnimGraph > Locomotion" for the overview, or

From 6620463154fcff101cd89f124457437cd9814dbd Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 13:35:18 +0000
Subject: [PATCH 26/52] Separate _Root and _StateResult into independent passes
 in BuildLayers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Split BuildLayers into two distinct passes:
- Pass 1: AnimGraphNode_Root nodes → graph layers
- Pass 2: AnimGraphNode_StateResult nodes → state sub-graphs

Previously these were incorrectly mixed in a single loop. Each type
defines a fundamentally different concept in UE and must be processed
independently. Extracted CollectUpstream helper to share BFS logic.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 89 +++++++++++++++----------
 1 file changed, 55 insertions(+), 34 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index c0a1d50b..e4e8cda1 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -166,11 +166,11 @@ public class AnimGraphViewModel
     }
 
     /// <summary>
-    /// Groups nodes into layers based on root nodes. In Unreal Engine, each
-    /// animation blueprint layer has a unique AnimGraphNode_Root, and each
-    /// state machine state sub-graph has a unique AnimGraphNode_StateResult.
-    /// Starting from each root node, we trace upstream through directed
-    /// connections to collect all nodes that feed into it.
+    /// Groups nodes into layers based on root nodes. In Unreal Engine:
+    /// - Each animation blueprint layer has a unique AnimGraphNode_Root
+    /// - Each state machine state sub-graph has a unique AnimGraphNode_StateResult
+    /// These two types are processed in separate passes to keep graph layers
+    /// and state machine state sub-graphs independent.
     /// </summary>
     private static void BuildLayers(AnimGraphViewModel vm)
     {
@@ -185,43 +185,36 @@ public class AnimGraphViewModel
         foreach (var conn in vm.Connections)
             upstreamOf[conn.TargetNode].Add(conn.SourceNode);
 
-        // Find all root nodes that define layers:
-        // _Root nodes define animation blueprint layers
-        // _StateResult nodes define state machine state sub-graphs
-        var rootNodes = vm.Nodes
-            .Where(n => n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase) ||
-                        n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase))
-            .ToList();
-
         var assigned = new HashSet<AnimGraphNode>();
         var layerIndex = 0;
 
-        // For each root node, BFS upstream to find all nodes in the layer
-        foreach (var rootNode in rootNodes)
+        // Pass 1: Build graph layers from AnimGraphNode_Root nodes.
+        // Each _Root node defines an animation blueprint layer (e.g. "AnimGraph").
+        var graphRoots = vm.Nodes
+            .Where(n => n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase))
+            .ToList();
+
+        foreach (var rootNode in graphRoots)
         {
             if (!assigned.Add(rootNode)) continue;
-
-            var layerNodes = new List<AnimGraphNode> { rootNode };
-            var queue = new Queue<AnimGraphNode>();
-            queue.Enqueue(rootNode);
-
-            while (queue.Count > 0)
-            {
-                var current = queue.Dequeue();
-                foreach (var upstream in upstreamOf[current])
-                {
-                    if (assigned.Add(upstream))
-                    {
-                        layerNodes.Add(upstream);
-                        queue.Enqueue(upstream);
-                    }
-                }
-            }
-
+            var layerNodes = CollectUpstream(rootNode, upstreamOf, assigned);
             AddLayer(vm, layerNodes, layerIndex++);
         }
 
-        // Any remaining unassigned nodes go into fallback layers (connected components)
+        // Pass 2: Build state machine state sub-graphs from AnimGraphNode_StateResult nodes.
+        // Each _StateResult node defines a state's sub-graph within a state machine.
+        var stateResultRoots = vm.Nodes
+            .Where(n => n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase))
+            .ToList();
+
+        foreach (var stateResultNode in stateResultRoots)
+        {
+            if (!assigned.Add(stateResultNode)) continue;
+            var layerNodes = CollectUpstream(stateResultNode, upstreamOf, assigned);
+            AddLayer(vm, layerNodes, layerIndex++);
+        }
+
+        // Fallback: any remaining unassigned nodes go into connected-component layers
         var remaining = vm.Nodes.Where(n => !assigned.Contains(n)).ToList();
         if (remaining.Count == 0) return;
 
@@ -263,6 +256,34 @@ public class AnimGraphViewModel
         }
     }
 
+    /// <summary>
+    /// Collects a root node and all its upstream providers via BFS.
+    /// </summary>
+    private static List<AnimGraphNode> CollectUpstream(
+        AnimGraphNode root,
+        Dictionary<AnimGraphNode, List<AnimGraphNode>> upstreamOf,
+        HashSet<AnimGraphNode> assigned)
+    {
+        var nodes = new List<AnimGraphNode> { root };
+        var queue = new Queue<AnimGraphNode>();
+        queue.Enqueue(root);
+
+        while (queue.Count > 0)
+        {
+            var current = queue.Dequeue();
+            foreach (var upstream in upstreamOf[current])
+            {
+                if (assigned.Add(upstream))
+                {
+                    nodes.Add(upstream);
+                    queue.Enqueue(upstream);
+                }
+            }
+        }
+
+        return nodes;
+    }
+
     /// <summary>
     /// Creates an <see cref="AnimGraphLayer"/> from a set of nodes, assigns
     /// the relevant connections, lays out the nodes and adds the layer to the VM.

From c37dc3013323a25ce2107080cbfb50c48d936652 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 13:52:03 +0000
Subject: [PATCH 27/52] Fix CS0136 compilation error: rename inner targetLayer
 to stateLayer to avoid scope conflict

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 5bbc8fa0..0cc4f840 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -568,20 +568,20 @@ public partial class AnimGraphViewer
             if (node.AdditionalProperties.TryGetValue("StateRootNodeName", out var rootNodeName) &&
                 !string.IsNullOrEmpty(rootNodeName))
             {
-                var targetLayer = _viewModel.Layers.FirstOrDefault(l =>
+                var stateLayer = _viewModel.Layers.FirstOrDefault(l =>
                     l.Nodes.Any(n => n.Name == rootNodeName));
-                if (targetLayer != null)
+                if (stateLayer != null)
                 {
                     // If tab already exists, just select it
                     foreach (System.Windows.Controls.TabItem tab in LayerTabControl.Items)
                     {
-                        if (tab.Tag == targetLayer)
+                        if (tab.Tag == stateLayer)
                         {
                             LayerTabControl.SelectedItem = tab;
                             return;
                         }
                     }
-                    AddLayerTab(targetLayer);
+                    AddLayerTab(stateLayer);
                     return;
                 }
             }

From 4fab6d97470fb44c279a5c88ce322d1d3ef7223c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 14:04:50 +0000
Subject: [PATCH 28/52] Separate graph layers and state machine state
 sub-graphs into distinct containers

- Add StateSubGraphs dictionary to AnimGraphViewModel keyed by root node property name
- BuildLayers Pass 2 now stores _StateResult sub-graphs in StateSubGraphs via AddStateSubGraph
- PrefixStateMachineLayerNames iterates StateSubGraphs instead of Layers for renaming
- BuildStateMachineOverviewLayers no longer removes from Layers (sub-graphs are separate)
- AnimGraphViewer uses StateSubGraphs.TryGetValue for direct dictionary lookup by node index

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 55 ++++++++++++++++++-------
 FModel/Views/AnimGraphViewer.xaml.cs    | 24 +++++------
 2 files changed, 49 insertions(+), 30 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index e4e8cda1..61f7789d 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -77,7 +77,15 @@ public class AnimGraphViewModel
     public string PackageName { get; set; } = string.Empty;
     public List<AnimGraphNode> Nodes { get; } = [];
     public List<AnimGraphConnection> Connections { get; } = [];
+    /// <summary>
+    /// Animation blueprint graph layers, each defined by a unique AnimGraphNode_Root.
+    /// </summary>
     public List<AnimGraphLayer> Layers { get; } = [];
+    /// <summary>
+    /// State machine state sub-graphs, keyed by the _StateResult root node's property name
+    /// (derived from StateRootNodeIndex) for unique identification.
+    /// </summary>
+    public Dictionary<string, AnimGraphLayer> StateSubGraphs { get; } = new();
 
     /// <summary>
     /// Extracts animation graph node information from a UAnimBlueprintGeneratedClass.
@@ -203,6 +211,7 @@ public class AnimGraphViewModel
 
         // Pass 2: Build state machine state sub-graphs from AnimGraphNode_StateResult nodes.
         // Each _StateResult node defines a state's sub-graph within a state machine.
+        // These are stored in StateSubGraphs keyed by the root node's property name.
         var stateResultRoots = vm.Nodes
             .Where(n => n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase))
             .ToList();
@@ -211,7 +220,7 @@ public class AnimGraphViewModel
         {
             if (!assigned.Add(stateResultNode)) continue;
             var layerNodes = CollectUpstream(stateResultNode, upstreamOf, assigned);
-            AddLayer(vm, layerNodes, layerIndex++);
+            AddStateSubGraph(vm, layerNodes, stateResultNode.Name, layerIndex++);
         }
 
         // Fallback: any remaining unassigned nodes go into connected-component layers
@@ -304,6 +313,27 @@ public class AnimGraphViewModel
         vm.Layers.Add(layer);
     }
 
+    /// <summary>
+    /// Creates an <see cref="AnimGraphLayer"/> for a state machine state sub-graph
+    /// and stores it in <see cref="AnimGraphViewModel.StateSubGraphs"/> keyed by the
+    /// root node's property name (from StateRootNodeIndex).
+    /// </summary>
+    private static void AddStateSubGraph(AnimGraphViewModel vm, List<AnimGraphNode> nodes, string rootNodePropName, int index)
+    {
+        var nodeSet = new HashSet<AnimGraphNode>(nodes);
+        var layer = new AnimGraphLayer { Name = GetLayerName(nodes, index) };
+        layer.Nodes.AddRange(nodes);
+
+        foreach (var conn in vm.Connections)
+        {
+            if (nodeSet.Contains(conn.SourceNode) && nodeSet.Contains(conn.TargetNode))
+                layer.Connections.Add(conn);
+        }
+
+        LayoutLayerNodes(layer);
+        vm.StateSubGraphs[rootNodePropName] = layer;
+    }
+
     /// <summary>
     /// Renames state machine internal layers with a parent path prefix
     /// (e.g., "AnimGraph > Locomotion" for the overview, or
@@ -322,8 +352,8 @@ public class AnimGraphViewModel
             }
         }
 
-        // Rename layers whose nodes belong to a state machine
-        foreach (var layer in vm.Layers)
+        // Rename state sub-graphs whose nodes belong to a state machine
+        foreach (var (key, layer) in vm.StateSubGraphs)
         {
             var smName = string.Empty;
             foreach (var node in layer.Nodes)
@@ -342,17 +372,11 @@ public class AnimGraphViewModel
             if (!smParentLayer.TryGetValue(smName, out var parentName))
                 continue;
 
-            // Per-state layers are named by the _StateResult root node's property name (unique);
-            // use the _StateResult node's Name additional property for the display portion
-            if (!layer.Name.Equals(smName, StringComparison.OrdinalIgnoreCase))
-            {
-                var stateResultNode = layer.Nodes.FirstOrDefault(n =>
-                    n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase));
-                var stateName = stateResultNode?.AdditionalProperties.GetValueOrDefault("Name") ?? layer.Name;
-                layer.Name = $"{parentName}{SubGraphPathSeparator}{smName}{SubGraphPathSeparator}{stateName}";
-            }
-            else
-                layer.Name = $"{parentName}{SubGraphPathSeparator}{smName}";
+            // Per-state layers: use the _StateResult node's Name additional property for display
+            var stateResultNode = layer.Nodes.FirstOrDefault(n =>
+                n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase));
+            var stateName = stateResultNode?.AdditionalProperties.GetValueOrDefault("Name") ?? layer.Name;
+            layer.Name = $"{parentName}{SubGraphPathSeparator}{smName}{SubGraphPathSeparator}{stateName}";
         }
     }
 
@@ -383,8 +407,7 @@ public class AnimGraphViewModel
             var parentName = smParentLayer.GetValueOrDefault(sm.MachineName, "AnimGraph");
             var overviewLayerName = $"{parentName}{SubGraphPathSeparator}{sm.MachineName}";
 
-            // Remove existing internal layers with this name (they'll be replaced by the overview)
-            vm.Layers.RemoveAll(l => l.Name.Equals(overviewLayerName, StringComparison.OrdinalIgnoreCase));
+            // State sub-graphs are now in StateSubGraphs (no need to remove from Layers)
 
             var overviewLayer = new AnimGraphLayer { Name = overviewLayerName };
             var stateNodes = new List<AnimGraphNode>();
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 0cc4f840..d51faf1c 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -563,27 +563,23 @@ public partial class AnimGraphViewer
         }
         else if (node.IsStateMachineState)
         {
-            // State nodes within an overview: find the per-state layer by StateRootNodeIndex
+            // State nodes within an overview: find the per-state sub-graph by StateRootNodeIndex
             // The root node's property name is stored on the overview state node
             if (node.AdditionalProperties.TryGetValue("StateRootNodeName", out var rootNodeName) &&
-                !string.IsNullOrEmpty(rootNodeName))
+                !string.IsNullOrEmpty(rootNodeName) &&
+                _viewModel.StateSubGraphs.TryGetValue(rootNodeName, out var stateLayer))
             {
-                var stateLayer = _viewModel.Layers.FirstOrDefault(l =>
-                    l.Nodes.Any(n => n.Name == rootNodeName));
-                if (stateLayer != null)
+                // If tab already exists, just select it
+                foreach (System.Windows.Controls.TabItem tab in LayerTabControl.Items)
                 {
-                    // If tab already exists, just select it
-                    foreach (System.Windows.Controls.TabItem tab in LayerTabControl.Items)
+                    if (tab.Tag == stateLayer)
                     {
-                        if (tab.Tag == stateLayer)
-                        {
-                            LayerTabControl.SelectedItem = tab;
-                            return;
-                        }
+                        LayerTabControl.SelectedItem = tab;
+                        return;
                     }
-                    AddLayerTab(stateLayer);
-                    return;
                 }
+                AddLayerTab(stateLayer);
+                return;
             }
         }
         else if (node.ExportType.Contains("StateMachine", StringComparison.OrdinalIgnoreCase))

From e3030cb0a0a5530d401f35eacada8515ba139eb8 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 14:05:28 +0000
Subject: [PATCH 29/52] Address code review: document rootNodePropName param,
 use discard for unused key

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 61f7789d..2040cc10 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -315,8 +315,8 @@ public class AnimGraphViewModel
 
     /// <summary>
     /// Creates an <see cref="AnimGraphLayer"/> for a state machine state sub-graph
-    /// and stores it in <see cref="AnimGraphViewModel.StateSubGraphs"/> keyed by the
-    /// root node's property name (from StateRootNodeIndex).
+    /// and stores it in <see cref="AnimGraphViewModel.StateSubGraphs"/> keyed by
+    /// <paramref name="rootNodePropName"/> (the root node's property name from StateRootNodeIndex).
     /// </summary>
     private static void AddStateSubGraph(AnimGraphViewModel vm, List<AnimGraphNode> nodes, string rootNodePropName, int index)
     {
@@ -353,7 +353,7 @@ public class AnimGraphViewModel
         }
 
         // Rename state sub-graphs whose nodes belong to a state machine
-        foreach (var (key, layer) in vm.StateSubGraphs)
+        foreach (var (_, layer) in vm.StateSubGraphs)
         {
             var smName = string.Empty;
             foreach (var node in layer.Nodes)

From c2ea844f0c244bbf6d2de135d4e0f42f2d52f702 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 03:33:25 +0000
Subject: [PATCH 30/52] Fix StateRootNodeIndex mapping: use (Count - 1 - index)
 for reverse ChildProperties order

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 2040cc10..7228a49e 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -653,6 +653,8 @@ public class AnimGraphViewModel
                     metadata.StateNames.Add(stateName);
 
                     // Mark root node via StateRootNodeIndex
+                    // UE stores node indices in reverse order relative to ChildProperties,
+                    // so the actual index into animNodeProps is (Count - 1 - stateRootIndex).
                     if (!stateStruct.TryGetValue(out int stateRootIndex, "StateRootNodeIndex") ||
                         stateRootIndex < 0 || stateRootIndex >= animNodeProps.Count)
                     {
@@ -660,7 +662,8 @@ public class AnimGraphViewModel
                         continue;
                     }
 
-                    var rootPropName = animNodeProps[stateRootIndex].name;
+                    var mappedIndex = animNodeProps.Count - 1 - stateRootIndex;
+                    var rootPropName = animNodeProps[mappedIndex].name;
                     metadata.StateRootPropNames.Add(rootPropName);
                     if (nodeByName.TryGetValue(rootPropName, out var rootNode))
                         rootNode.AdditionalProperties["BelongsToStateMachine"] = machineName;

From 5aa4b60d2eb084cdeff9380079585dc96d4352ac Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 04:45:00 +0000
Subject: [PATCH 31/52] Add edge-to-edge transition arrows with selection and
 properties display

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs |  27 ++-
 FModel/Views/AnimGraphViewer.xaml.cs    | 303 ++++++++++++++++++++----
 2 files changed, 276 insertions(+), 54 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 7228a49e..99562970 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -38,6 +38,10 @@ public class AnimGraphConnection
     public string SourcePinName { get; set; } = string.Empty;
     public AnimGraphNode TargetNode { get; set; } = null!;
     public string TargetPinName { get; set; } = string.Empty;
+    /// <summary>
+    /// Additional properties for state machine transitions (e.g. CrossfadeDuration, LogicType).
+    /// </summary>
+    public Dictionary<string, string> TransitionProperties { get; set; } = new();
 }
 
 /// <summary>
@@ -61,7 +65,7 @@ internal class StateMachineMetadata
     public string MachineName { get; init; } = string.Empty;
     public List<string> StateNames { get; } = [];
     public List<string> StateRootPropNames { get; } = [];
-    public List<(int PreviousState, int NextState)> Transitions { get; } = [];
+    public List<(int PreviousState, int NextState, Dictionary<string, string> Properties)> Transitions { get; } = [];
 }
 
 public class AnimGraphViewModel
@@ -471,17 +475,20 @@ public class AnimGraphViewModel
             }
 
             // Transition connections between states
-            foreach (var (prevIdx, nextIdx) in sm.Transitions)
+            foreach (var (prevIdx, nextIdx, transProps) in sm.Transitions)
             {
                 if (prevIdx < stateNodes.Count && nextIdx < stateNodes.Count)
                 {
-                    overviewLayer.Connections.Add(new AnimGraphConnection
+                    var conn = new AnimGraphConnection
                     {
                         SourceNode = stateNodes[prevIdx],
                         SourcePinName = "Out",
                         TargetNode = stateNodes[nextIdx],
                         TargetPinName = "In"
-                    });
+                    };
+                    foreach (var (k, v) in transProps)
+                        conn.TransitionProperties[k] = v;
+                    overviewLayer.Connections.Add(conn);
                 }
             }
 
@@ -690,7 +697,17 @@ public class AnimGraphViewModel
                     if (previousState >= 0 && nextState >= 0 &&
                         previousState < metadata.StateNames.Count && nextState < metadata.StateNames.Count)
                     {
-                        metadata.Transitions.Add((previousState, nextState));
+                        var transProps = new Dictionary<string, string>();
+                        foreach (var tp in transStruct.Properties)
+                        {
+                            var name = tp.Name.Text;
+                            if (name is "PreviousState" or "NextState") continue;
+                            var val = tp.Tag?.GenericValue?.ToString();
+                            if (!string.IsNullOrEmpty(val))
+                                transProps[name] = val.Length > MaxPropertyValueDisplayLength
+                                    ? val[..MaxPropertyValueDisplayLength] + "…" : val;
+                        }
+                        metadata.Transitions.Add((previousState, nextState, transProps));
                     }
                 }
                 break;
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index d51faf1c..0d125f50 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -26,6 +26,7 @@ public partial class AnimGraphViewer
     private const double StateNodeCornerRadius = 24;
     private const double EntryNodeSize = 30;
     private const double TransitionArrowSize = 10;
+    private const double DistanceEpsilon = 0.001;
 
     private readonly AnimGraphViewModel _viewModel;
 
@@ -37,6 +38,11 @@ public partial class AnimGraphViewer
     private AnimGraphNode? _selectedNode;
     private Border? _selectedBorder;
 
+    // Currently selected transition (for properties panel)
+    private AnimGraphConnection? _selectedTransition;
+    private Path? _selectedTransitionPath;
+    private Color _selectedTransitionOriginalColor;
+
     private bool _isPanning;
     private bool _potentialPan;
     private Point _panStartPos;
@@ -530,13 +536,24 @@ public partial class AnimGraphViewer
     /// </summary>
     private void SelectNode(AnimGraphNode node, Border border)
     {
-        // Deselect previous
+        // Deselect previous node
         if (_selectedBorder != null)
         {
             _selectedBorder.BorderBrush = new SolidColorBrush(Color.FromRgb(20, 20, 20));
             _selectedBorder.BorderThickness = new Thickness(1.5);
         }
 
+        // Deselect previous transition
+        if (_selectedTransitionPath != null)
+        {
+            var restoreBrush = new SolidColorBrush(_selectedTransitionOriginalColor);
+            _selectedTransitionPath.Stroke = restoreBrush;
+            _selectedTransitionPath.Fill = restoreBrush;
+            _selectedTransitionPath.StrokeThickness = 2.5;
+            _selectedTransitionPath = null;
+        }
+        _selectedTransition = null;
+
         // Highlight selected
         _selectedNode = node;
         _selectedBorder = border;
@@ -719,34 +736,37 @@ public partial class AnimGraphViewer
         var sourceKey = (conn.SourceNode, conn.SourcePinName, true);
         var targetKey = (conn.TargetNode, conn.TargetPinName, false);
 
-        if (!state.PinPositions.TryGetValue(sourceKey, out var startPos))
-        {
-            if (state.NodePositions.TryGetValue(conn.SourceNode, out var srcNodePos))
-                startPos = new Point(srcNodePos.X + NodeWidth, srcNodePos.Y + NodeHeaderHeight + 10);
-            else
-                return;
-        }
-
-        if (!state.PinPositions.TryGetValue(targetKey, out var endPos))
-        {
-            if (state.NodePositions.TryGetValue(conn.TargetNode, out var tgtNodePos))
-                endPos = new Point(tgtNodePos.X, tgtNodePos.Y + NodeHeaderHeight + 10);
-            else
-                return;
-        }
+        var isTransition = (conn.SourceNode.IsStateMachineState || conn.SourceNode.IsEntryNode) &&
+                           (conn.TargetNode.IsStateMachineState || conn.TargetNode.IsEntryNode);
 
         // Determine wire color from source pin type
         var sourcePin = conn.SourceNode.Pins.FirstOrDefault(p => p.PinName == conn.SourcePinName && p.IsOutput);
         var wireColor = sourcePin != null ? GetPinColor(sourcePin.PinType) : Color.FromRgb(200, 200, 220);
-        var isTransition = (conn.SourceNode.IsStateMachineState || conn.SourceNode.IsEntryNode) &&
-                           (conn.TargetNode.IsStateMachineState || conn.TargetNode.IsEntryNode);
 
         if (isTransition)
         {
-            DrawTransitionArrow(state, startPos, endPos, wireColor);
+            // Compute edge-to-edge shortest path between node bounding boxes
+            var (startPos, endPos) = ComputeEdgeToEdgePoints(state, conn.SourceNode, conn.TargetNode);
+            DrawTransitionArrow(state, conn, startPos, endPos, wireColor);
         }
         else
         {
+            if (!state.PinPositions.TryGetValue(sourceKey, out var startPos))
+            {
+                if (state.NodePositions.TryGetValue(conn.SourceNode, out var srcNodePos))
+                    startPos = new Point(srcNodePos.X + NodeWidth, srcNodePos.Y + NodeHeaderHeight + 10);
+                else
+                    return;
+            }
+
+            if (!state.PinPositions.TryGetValue(targetKey, out var endPos))
+            {
+                if (state.NodePositions.TryGetValue(conn.TargetNode, out var tgtNodePos))
+                    endPos = new Point(tgtNodePos.X, tgtNodePos.Y + NodeHeaderHeight + 10);
+                else
+                    return;
+            }
+
             var dx = Math.Max(Math.Abs(endPos.X - startPos.X) * 0.5, 50);
             var pathFigure = new PathFigure { StartPoint = startPos };
             pathFigure.Segments.Add(new BezierSegment(
@@ -772,29 +792,114 @@ public partial class AnimGraphViewer
     }
 
     /// <summary>
-    /// Draws a directional transition arrow between state machine state nodes,
-    /// with an arrowhead at the target end.
+    /// Computes the shortest straight-line connection points between two node edges.
+    /// For state nodes (rounded rectangles) and entry nodes (circles), finds the
+    /// intersection of the center-to-center line with each node's bounding shape.
     /// </summary>
-    private static void DrawTransitionArrow(LayerCanvasState state, Point startPos, Point endPos, Color wireColor)
+    private (Point start, Point end) ComputeEdgeToEdgePoints(LayerCanvasState state, AnimGraphNode sourceNode, AnimGraphNode targetNode)
+    {
+        var srcCenter = GetNodeCenter(state, sourceNode);
+        var tgtCenter = GetNodeCenter(state, targetNode);
+
+        var startEdge = ClipToNodeEdge(state, sourceNode, srcCenter, tgtCenter);
+        var endEdge = ClipToNodeEdge(state, targetNode, tgtCenter, srcCenter);
+
+        return (startEdge, endEdge);
+    }
+
+    private static Point GetNodeCenter(LayerCanvasState state, AnimGraphNode node)
+    {
+        if (!state.NodePositions.TryGetValue(node, out var pos))
+            return default;
+
+        if (node.IsEntryNode)
+            return new Point(pos.X + EntryNodeSize / 2, pos.Y + EntryNodeSize / 2);
+
+        if (node.IsStateMachineState)
+            return new Point(pos.X + StateNodeWidth / 2, pos.Y + StateNodeHeight / 2);
+
+        return new Point(pos.X + NodeWidth / 2, pos.Y + NodeHeaderHeight / 2);
+    }
+
+    /// <summary>
+    /// Clips a line from <paramref name="from"/> toward <paramref name="to"/>
+    /// to the edge of the node's bounding shape.
+    /// </summary>
+    private static Point ClipToNodeEdge(LayerCanvasState state, AnimGraphNode node, Point from, Point to)
+    {
+        if (!state.NodePositions.TryGetValue(node, out var pos))
+            return from;
+
+        if (node.IsEntryNode)
+        {
+            // Circle clipping
+            var cx = pos.X + EntryNodeSize / 2;
+            var cy = pos.Y + EntryNodeSize / 2;
+            var radius = EntryNodeSize / 2;
+            var dx = to.X - cx;
+            var dy = to.Y - cy;
+            var dist = Math.Sqrt(dx * dx + dy * dy);
+            if (dist < DistanceEpsilon) return from;
+            return new Point(cx + dx / dist * radius, cy + dy / dist * radius);
+        }
+
+        // Rectangle clipping (state nodes or regular nodes)
+        double w, h;
+        if (node.IsStateMachineState)
+        {
+            w = StateNodeWidth;
+            h = StateNodeHeight;
+        }
+        else
+        {
+            w = NodeWidth;
+            h = state.NodeVisuals.TryGetValue(node, out var vis) ? vis.height : 60;
+        }
+
+        var rectCx = pos.X + w / 2;
+        var rectCy = pos.Y + h / 2;
+        var dirX = to.X - rectCx;
+        var dirY = to.Y - rectCy;
+        if (Math.Abs(dirX) < DistanceEpsilon && Math.Abs(dirY) < DistanceEpsilon)
+            return from;
+
+        // Find intersection with rectangle edges
+        var halfW = w / 2;
+        var halfH = h / 2;
+        double tMin = double.MaxValue;
+
+        // Check left/right edges
+        if (Math.Abs(dirX) > DistanceEpsilon)
+        {
+            var t = (dirX > 0 ? halfW : -halfW) / dirX;
+            var iy = dirY * t;
+            if (t > 0 && Math.Abs(iy) <= halfH)
+                tMin = Math.Min(tMin, t);
+        }
+        // Check top/bottom edges
+        if (Math.Abs(dirY) > DistanceEpsilon)
+        {
+            var t = (dirY > 0 ? halfH : -halfH) / dirY;
+            var ix = dirX * t;
+            if (t > 0 && Math.Abs(ix) <= halfW)
+                tMin = Math.Min(tMin, t);
+        }
+
+        if (tMin < double.MaxValue)
+            return new Point(rectCx + dirX * tMin, rectCy + dirY * tMin);
+
+        return from;
+    }
+
+    /// <summary>
+    /// Draws a directional transition arrow between state machine state nodes,
+    /// with an arrowhead at the target end. The arrow is clickable to select
+    /// the transition and view its properties.
+    /// </summary>
+    private void DrawTransitionArrow(LayerCanvasState state, AnimGraphConnection conn, Point startPos, Point endPos, Color wireColor)
     {
         var brush = new SolidColorBrush(wireColor);
 
-        // Main line
-        var line = new Line
-        {
-            X1 = startPos.X,
-            Y1 = startPos.Y,
-            X2 = endPos.X,
-            Y2 = endPos.Y,
-            Stroke = brush,
-            StrokeThickness = 2.5,
-            SnapsToDevicePixels = true,
-            IsHitTestVisible = false
-        };
-        Panel.SetZIndex(line, 0);
-        state.Canvas.Children.Add(line);
-
-        // Arrowhead
         var dx = endPos.X - startPos.X;
         var dy = endPos.Y - startPos.Y;
         var length = Math.Sqrt(dx * dx + dy * dy);
@@ -802,23 +907,123 @@ public partial class AnimGraphViewer
 
         var ux = dx / length;
         var uy = dy / length;
-        var arrowBase = new Point(endPos.X - ux * TransitionArrowSize, endPos.Y - uy * TransitionArrowSize);
+
+        // Pull the endpoint back by the arrowhead size so the line ends at the arrow base
+        var lineEnd = new Point(endPos.X - ux * TransitionArrowSize, endPos.Y - uy * TransitionArrowSize);
+
+        // Build a single path containing the line + arrowhead for hit testing
+        var pathFigure = new PathFigure { StartPoint = startPos };
+        pathFigure.Segments.Add(new LineSegment(lineEnd, true));
+
+        var arrowBase = lineEnd;
         var perpX = -uy * TransitionArrowSize * 0.5;
         var perpY = ux * TransitionArrowSize * 0.5;
+        var arrowFigure = new PathFigure { StartPoint = endPos, IsFilled = true };
+        arrowFigure.Segments.Add(new LineSegment(new Point(arrowBase.X + perpX, arrowBase.Y + perpY), true));
+        arrowFigure.Segments.Add(new LineSegment(new Point(arrowBase.X - perpX, arrowBase.Y - perpY), true));
+        arrowFigure.IsClosed = true;
 
-        var arrowHead = new Polygon
+        var pathGeometry = new PathGeometry();
+        pathGeometry.Figures.Add(pathFigure);
+        pathGeometry.Figures.Add(arrowFigure);
+        pathGeometry.Freeze();
+
+        var path = new Path
         {
-            Points =
-            [
-                endPos,
-                new Point(arrowBase.X + perpX, arrowBase.Y + perpY),
-                new Point(arrowBase.X - perpX, arrowBase.Y - perpY)
-            ],
+            Data = pathGeometry,
+            Stroke = brush,
+            StrokeThickness = 2.5,
             Fill = brush,
-            IsHitTestVisible = false
+            SnapsToDevicePixels = true,
+            IsHitTestVisible = true,
+            Cursor = System.Windows.Input.Cursors.Hand
         };
-        Panel.SetZIndex(arrowHead, 0);
-        state.Canvas.Children.Add(arrowHead);
+        Panel.SetZIndex(path, 0);
+        state.Canvas.Children.Add(path);
+
+        // Invisible wider hit area for easier clicking
+        var hitPath = new Path
+        {
+            Data = pathGeometry,
+            Stroke = Brushes.Transparent,
+            StrokeThickness = 10,
+            Fill = Brushes.Transparent,
+            IsHitTestVisible = true,
+            Cursor = System.Windows.Input.Cursors.Hand
+        };
+        Panel.SetZIndex(hitPath, 0);
+        state.Canvas.Children.Add(hitPath);
+
+        hitPath.MouseLeftButtonDown += (s, e) =>
+        {
+            SelectTransition(conn, path, wireColor);
+            e.Handled = true;
+        };
+        path.MouseLeftButtonDown += (s, e) =>
+        {
+            SelectTransition(conn, path, wireColor);
+            e.Handled = true;
+        };
+    }
+
+    /// <summary>
+    /// Selects a transition arrow and shows its properties in the properties panel.
+    /// </summary>
+    private void SelectTransition(AnimGraphConnection conn, Path transitionPath, Color originalColor)
+    {
+        // Deselect previous node selection
+        if (_selectedBorder != null)
+        {
+            _selectedBorder.BorderBrush = new SolidColorBrush(Color.FromRgb(20, 20, 20));
+            _selectedBorder.BorderThickness = new Thickness(1.5);
+            _selectedBorder = null;
+        }
+        _selectedNode = null;
+
+        // Deselect previous transition
+        if (_selectedTransitionPath != null)
+        {
+            var restoreBrush = new SolidColorBrush(_selectedTransitionOriginalColor);
+            _selectedTransitionPath.Stroke = restoreBrush;
+            _selectedTransitionPath.Fill = restoreBrush;
+            _selectedTransitionPath.StrokeThickness = 2.5;
+        }
+
+        // Highlight selected transition
+        _selectedTransition = conn;
+        _selectedTransitionPath = transitionPath;
+        _selectedTransitionOriginalColor = originalColor;
+        var highlightBrush = new SolidColorBrush(Color.FromRgb(230, 160, 0));
+        transitionPath.Stroke = highlightBrush;
+        transitionPath.Fill = highlightBrush;
+        transitionPath.StrokeThickness = 3.5;
+
+        var sourceName = conn.SourceNode.Name;
+        var targetName = conn.TargetNode.Name;
+        SelectedNodeText.Text = $"Selected: Transition {sourceName} → {targetName}";
+        PopulateTransitionProperties(conn);
+    }
+
+    /// <summary>
+    /// Fills the properties panel with the selected transition's information.
+    /// </summary>
+    private void PopulateTransitionProperties(AnimGraphConnection conn)
+    {
+        PropertiesPanel.Children.Clear();
+        PropertiesTitleText.Text = $"Properties - Transition";
+
+        AddPropertySection("Transition Info");
+        AddPropertyRow("From", conn.SourceNode.Name);
+        AddPropertyRow("To", conn.TargetNode.Name);
+
+        if (conn.TransitionProperties.Count > 0)
+        {
+            AddPropertySection("Details");
+            foreach (var (key, value) in conn.TransitionProperties)
+            {
+                AddPropertyRow(key, value);
+            }
+        }
     }
 
     private static string GetNodeDisplayName(AnimGraphNode node)

From 8dd66a1f35dc4d4ad752351e21fe5a3613526f03 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 05:48:53 +0000
Subject: [PATCH 32/52] Add transition midpoint circles for multi-transition
 selection

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 181 +++++++++++++++++++++------
 1 file changed, 143 insertions(+), 38 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 0d125f50..9d367390 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -26,6 +26,8 @@ public partial class AnimGraphViewer
     private const double StateNodeCornerRadius = 24;
     private const double EntryNodeSize = 30;
     private const double TransitionArrowSize = 10;
+    private const double TransitionCircleRadius = 8;
+    private const double TransitionMultiOffset = 12;
     private const double DistanceEpsilon = 0.001;
 
     private readonly AnimGraphViewModel _viewModel;
@@ -41,6 +43,7 @@ public partial class AnimGraphViewer
     // Currently selected transition (for properties panel)
     private AnimGraphConnection? _selectedTransition;
     private Path? _selectedTransitionPath;
+    private Ellipse? _selectedTransitionCircle;
     private Color _selectedTransitionOriginalColor;
 
     private bool _isPanning;
@@ -172,9 +175,35 @@ public partial class AnimGraphViewer
         }
 
         // Draw connections first (behind nodes) for state machine overview
+        // Group transition connections by (source, target) pair to offset multiple transitions
+        var transitionGroups = new Dictionary<(AnimGraphNode, AnimGraphNode), List<AnimGraphConnection>>();
         foreach (var conn in state.Layer.Connections)
         {
-            DrawConnectionLine(state, conn);
+            var isTransition = (conn.SourceNode.IsStateMachineState || conn.SourceNode.IsEntryNode) &&
+                               (conn.TargetNode.IsStateMachineState || conn.TargetNode.IsEntryNode);
+            if (isTransition)
+            {
+                var key = (conn.SourceNode, conn.TargetNode);
+                if (!transitionGroups.TryGetValue(key, out var list))
+                {
+                    list = [];
+                    transitionGroups[key] = list;
+                }
+                list.Add(conn);
+            }
+            else
+            {
+                DrawConnectionLine(state, conn);
+            }
+        }
+
+        // Draw grouped transitions with offset when multiple exist between the same pair
+        foreach (var (_, group) in transitionGroups)
+        {
+            for (var i = 0; i < group.Count; i++)
+            {
+                DrawConnectionLine(state, group[i], i, group.Count);
+            }
         }
 
         // Draw nodes
@@ -544,15 +573,7 @@ public partial class AnimGraphViewer
         }
 
         // Deselect previous transition
-        if (_selectedTransitionPath != null)
-        {
-            var restoreBrush = new SolidColorBrush(_selectedTransitionOriginalColor);
-            _selectedTransitionPath.Stroke = restoreBrush;
-            _selectedTransitionPath.Fill = restoreBrush;
-            _selectedTransitionPath.StrokeThickness = 2.5;
-            _selectedTransitionPath = null;
-        }
-        _selectedTransition = null;
+        DeselectTransition();
 
         // Highlight selected
         _selectedNode = node;
@@ -731,7 +752,7 @@ public partial class AnimGraphViewer
         PropertiesPanel.Children.Add(rowGrid);
     }
 
-    private void DrawConnectionLine(LayerCanvasState state, AnimGraphConnection conn)
+    private void DrawConnectionLine(LayerCanvasState state, AnimGraphConnection conn, int transitionIndex = 0, int transitionCount = 1)
     {
         var sourceKey = (conn.SourceNode, conn.SourcePinName, true);
         var targetKey = (conn.TargetNode, conn.TargetPinName, false);
@@ -747,6 +768,25 @@ public partial class AnimGraphViewer
         {
             // Compute edge-to-edge shortest path between node bounding boxes
             var (startPos, endPos) = ComputeEdgeToEdgePoints(state, conn.SourceNode, conn.TargetNode);
+
+            // Offset lines when multiple transitions share the same source→target pair
+            if (transitionCount > 1)
+            {
+                var cdx = endPos.X - startPos.X;
+                var cdy = endPos.Y - startPos.Y;
+                var cLen = Math.Sqrt(cdx * cdx + cdy * cdy);
+                if (cLen > DistanceEpsilon)
+                {
+                    // Perpendicular unit vector
+                    var px = -cdy / cLen;
+                    var py = cdx / cLen;
+                    // Center the offsets: e.g. for 3 transitions: -1, 0, +1
+                    var offsetAmount = (transitionIndex - (transitionCount - 1) / 2.0) * TransitionMultiOffset;
+                    startPos = new Point(startPos.X + px * offsetAmount, startPos.Y + py * offsetAmount);
+                    endPos = new Point(endPos.X + px * offsetAmount, endPos.Y + py * offsetAmount);
+                }
+            }
+
             DrawTransitionArrow(state, conn, startPos, endPos, wireColor);
         }
         else
@@ -893,8 +933,8 @@ public partial class AnimGraphViewer
 
     /// <summary>
     /// Draws a directional transition arrow between state machine state nodes,
-    /// with an arrowhead at the target end. The arrow is clickable to select
-    /// the transition and view its properties.
+    /// with an arrowhead at the target end and a small circle at the midpoint
+    /// for easy click selection (matching UE's transition icon style).
     /// </summary>
     private void DrawTransitionArrow(LayerCanvasState state, AnimGraphConnection conn, Point startPos, Point endPos, Color wireColor)
     {
@@ -911,7 +951,7 @@ public partial class AnimGraphViewer
         // Pull the endpoint back by the arrowhead size so the line ends at the arrow base
         var lineEnd = new Point(endPos.X - ux * TransitionArrowSize, endPos.Y - uy * TransitionArrowSize);
 
-        // Build a single path containing the line + arrowhead for hit testing
+        // Build a single path containing the line + arrowhead
         var pathFigure = new PathFigure { StartPoint = startPos };
         pathFigure.Segments.Add(new LineSegment(lineEnd, true));
 
@@ -935,13 +975,12 @@ public partial class AnimGraphViewer
             StrokeThickness = 2.5,
             Fill = brush,
             SnapsToDevicePixels = true,
-            IsHitTestVisible = true,
-            Cursor = System.Windows.Input.Cursors.Hand
+            IsHitTestVisible = false
         };
         Panel.SetZIndex(path, 0);
         state.Canvas.Children.Add(path);
 
-        // Invisible wider hit area for easier clicking
+        // Invisible wider hit area on the line for fallback clicking
         var hitPath = new Path
         {
             Data = pathGeometry,
@@ -949,19 +988,66 @@ public partial class AnimGraphViewer
             StrokeThickness = 10,
             Fill = Brushes.Transparent,
             IsHitTestVisible = true,
-            Cursor = System.Windows.Input.Cursors.Hand
+            Cursor = Cursors.Hand
         };
-        Panel.SetZIndex(hitPath, 0);
+        Panel.SetZIndex(hitPath, 1);
         state.Canvas.Children.Add(hitPath);
 
-        hitPath.MouseLeftButtonDown += (s, e) =>
+        // Small circle at the midpoint for easy click selection (UE transition icon style)
+        var midX = (startPos.X + endPos.X) / 2;
+        var midY = (startPos.Y + endPos.Y) / 2;
+        var circle = new Ellipse
         {
-            SelectTransition(conn, path, wireColor);
+            Width = TransitionCircleRadius * 2,
+            Height = TransitionCircleRadius * 2,
+            Fill = brush,
+            Stroke = new SolidColorBrush(Color.FromRgb(30, 30, 30)),
+            StrokeThickness = 1.5,
+            SnapsToDevicePixels = true,
+            IsHitTestVisible = true,
+            Cursor = Cursors.Hand,
+            ToolTip = $"{conn.SourceNode.Name} → {conn.TargetNode.Name}"
+        };
+        Canvas.SetLeft(circle, midX - TransitionCircleRadius);
+        Canvas.SetTop(circle, midY - TransitionCircleRadius);
+        Panel.SetZIndex(circle, 2);
+        state.Canvas.Children.Add(circle);
+
+        // Draw a small direction arrow icon inside the circle
+        var iconSize = TransitionCircleRadius * 0.7;
+        var iconGeometry = new PathGeometry();
+        var iconFigure = new PathFigure
+        {
+            StartPoint = new Point(midX + ux * iconSize, midY + uy * iconSize),
+            IsFilled = true
+        };
+        var iconPerpX = -uy * iconSize * 0.6;
+        var iconPerpY = ux * iconSize * 0.6;
+        iconFigure.Segments.Add(new LineSegment(
+            new Point(midX - ux * iconSize * 0.5 + iconPerpX, midY - uy * iconSize * 0.5 + iconPerpY), true));
+        iconFigure.Segments.Add(new LineSegment(
+            new Point(midX - ux * iconSize * 0.5 - iconPerpX, midY - uy * iconSize * 0.5 - iconPerpY), true));
+        iconFigure.IsClosed = true;
+        iconGeometry.Figures.Add(iconFigure);
+        iconGeometry.Freeze();
+
+        var iconPath = new Path
+        {
+            Data = iconGeometry,
+            Fill = Brushes.White,
+            IsHitTestVisible = false
+        };
+        Panel.SetZIndex(iconPath, 3);
+        state.Canvas.Children.Add(iconPath);
+
+        circle.MouseLeftButtonDown += (s, e) =>
+        {
+            SelectTransition(conn, path, circle, wireColor);
             e.Handled = true;
         };
-        path.MouseLeftButtonDown += (s, e) =>
+        hitPath.MouseLeftButtonDown += (s, e) =>
         {
-            SelectTransition(conn, path, wireColor);
+            SelectTransition(conn, path, circle, wireColor);
             e.Handled = true;
         };
     }
@@ -969,7 +1055,7 @@ public partial class AnimGraphViewer
     /// <summary>
     /// Selects a transition arrow and shows its properties in the properties panel.
     /// </summary>
-    private void SelectTransition(AnimGraphConnection conn, Path transitionPath, Color originalColor)
+    private void SelectTransition(AnimGraphConnection conn, Path transitionPath, Ellipse transitionCircle, Color originalColor)
     {
         // Deselect previous node selection
         if (_selectedBorder != null)
@@ -981,27 +1067,46 @@ public partial class AnimGraphViewer
         _selectedNode = null;
 
         // Deselect previous transition
+        DeselectTransition();
+
+        // Highlight selected transition
+        _selectedTransition = conn;
+        _selectedTransitionPath = transitionPath;
+        _selectedTransitionCircle = transitionCircle;
+        _selectedTransitionOriginalColor = originalColor;
+        var highlightBrush = new SolidColorBrush(Color.FromRgb(230, 160, 0));
+        transitionPath.Stroke = highlightBrush;
+        transitionPath.Fill = highlightBrush;
+        transitionPath.StrokeThickness = 3.5;
+        transitionCircle.Fill = highlightBrush;
+        transitionCircle.Stroke = new SolidColorBrush(Color.FromRgb(255, 200, 50));
+
+        var sourceName = conn.SourceNode.Name;
+        var targetName = conn.TargetNode.Name;
+        SelectedNodeText.Text = $"Selected: Transition {sourceName} → {targetName}";
+        PopulateTransitionProperties(conn);
+    }
+
+    /// <summary>
+    /// Restores the previously selected transition to its original appearance.
+    /// </summary>
+    private void DeselectTransition()
+    {
         if (_selectedTransitionPath != null)
         {
             var restoreBrush = new SolidColorBrush(_selectedTransitionOriginalColor);
             _selectedTransitionPath.Stroke = restoreBrush;
             _selectedTransitionPath.Fill = restoreBrush;
             _selectedTransitionPath.StrokeThickness = 2.5;
+            _selectedTransitionPath = null;
         }
-
-        // Highlight selected transition
-        _selectedTransition = conn;
-        _selectedTransitionPath = transitionPath;
-        _selectedTransitionOriginalColor = originalColor;
-        var highlightBrush = new SolidColorBrush(Color.FromRgb(230, 160, 0));
-        transitionPath.Stroke = highlightBrush;
-        transitionPath.Fill = highlightBrush;
-        transitionPath.StrokeThickness = 3.5;
-
-        var sourceName = conn.SourceNode.Name;
-        var targetName = conn.TargetNode.Name;
-        SelectedNodeText.Text = $"Selected: Transition {sourceName} → {targetName}";
-        PopulateTransitionProperties(conn);
+        if (_selectedTransitionCircle != null)
+        {
+            _selectedTransitionCircle.Fill = new SolidColorBrush(_selectedTransitionOriginalColor);
+            _selectedTransitionCircle.Stroke = new SolidColorBrush(Color.FromRgb(30, 30, 30));
+            _selectedTransitionCircle = null;
+        }
+        _selectedTransition = null;
     }
 
     /// <summary>

From 30bef7fdf2e2003c3c133df2383f7b249730f0fc Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 08:32:35 +0000
Subject: [PATCH 33/52] Fix transition layout: opposite sides for different
 directions, offset circles for same direction

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 80 +++++++++++++++++-----------
 1 file changed, 50 insertions(+), 30 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 9d367390..e7af1ff9 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -27,6 +27,7 @@ public partial class AnimGraphViewer
     private const double EntryNodeSize = 30;
     private const double TransitionArrowSize = 10;
     private const double TransitionCircleRadius = 8;
+    private const double TransitionCircleSpacing = 3;
     private const double TransitionMultiOffset = 12;
     private const double DistanceEpsilon = 0.001;
 
@@ -175,19 +176,22 @@ public partial class AnimGraphViewer
         }
 
         // Draw connections first (behind nodes) for state machine overview
-        // Group transition connections by (source, target) pair to offset multiple transitions
-        var transitionGroups = new Dictionary<(AnimGraphNode, AnimGraphNode), List<AnimGraphConnection>>();
+        // Group transition connections by unordered node pair so A→B and B→A are handled together
+        var pairGroups = new Dictionary<(AnimGraphNode, AnimGraphNode), List<AnimGraphConnection>>();
         foreach (var conn in state.Layer.Connections)
         {
             var isTransition = (conn.SourceNode.IsStateMachineState || conn.SourceNode.IsEntryNode) &&
                                (conn.TargetNode.IsStateMachineState || conn.TargetNode.IsEntryNode);
             if (isTransition)
             {
-                var key = (conn.SourceNode, conn.TargetNode);
-                if (!transitionGroups.TryGetValue(key, out var list))
+                // Stable unordered key: use node Name for deterministic ordering
+                var a = conn.SourceNode;
+                var b = conn.TargetNode;
+                var key = string.Compare(a.Name, b.Name, StringComparison.Ordinal) <= 0 ? (a, b) : (b, a);
+                if (!pairGroups.TryGetValue(key, out var list))
                 {
                     list = [];
-                    transitionGroups[key] = list;
+                    pairGroups[key] = list;
                 }
                 list.Add(conn);
             }
@@ -197,13 +201,19 @@ public partial class AnimGraphViewer
             }
         }
 
-        // Draw grouped transitions with offset when multiple exist between the same pair
-        foreach (var (_, group) in transitionGroups)
+        // Draw transitions: different directions on opposite sides, same-direction circles offset along line
+        foreach (var (pair, allConns) in pairGroups)
         {
-            for (var i = 0; i < group.Count; i++)
-            {
-                DrawConnectionLine(state, group[i], i, group.Count);
-            }
+            var (nodeA, nodeB) = pair;
+            var forward = allConns.Where(c => c.SourceNode == nodeA).ToList();
+            var backward = allConns.Where(c => c.SourceNode == nodeB).ToList();
+            var hasBothDirections = forward.Count > 0 && backward.Count > 0;
+
+            for (var i = 0; i < forward.Count; i++)
+                DrawConnectionLine(state, forward[i], i, forward.Count, perpSide: 1, hasBothDirections: hasBothDirections);
+
+            for (var i = 0; i < backward.Count; i++)
+                DrawConnectionLine(state, backward[i], i, backward.Count, perpSide: -1, hasBothDirections: hasBothDirections);
         }
 
         // Draw nodes
@@ -752,7 +762,9 @@ public partial class AnimGraphViewer
         PropertiesPanel.Children.Add(rowGrid);
     }
 
-    private void DrawConnectionLine(LayerCanvasState state, AnimGraphConnection conn, int transitionIndex = 0, int transitionCount = 1)
+    private void DrawConnectionLine(LayerCanvasState state, AnimGraphConnection conn,
+        int sameDirectionIndex = 0, int sameDirectionCount = 1,
+        int perpSide = 0, bool hasBothDirections = false)
     {
         var sourceKey = (conn.SourceNode, conn.SourcePinName, true);
         var targetKey = (conn.TargetNode, conn.TargetPinName, false);
@@ -769,25 +781,33 @@ public partial class AnimGraphViewer
             // Compute edge-to-edge shortest path between node bounding boxes
             var (startPos, endPos) = ComputeEdgeToEdgePoints(state, conn.SourceNode, conn.TargetNode);
 
-            // Offset lines when multiple transitions share the same source→target pair
-            if (transitionCount > 1)
+            // Offset lines: different directions go on opposite perpendicular sides
+            var cdx = endPos.X - startPos.X;
+            var cdy = endPos.Y - startPos.Y;
+            var cLen = Math.Sqrt(cdx * cdx + cdy * cdy);
+            double circleLineOffset = 0;
+
+            if (cLen > DistanceEpsilon)
             {
-                var cdx = endPos.X - startPos.X;
-                var cdy = endPos.Y - startPos.Y;
-                var cLen = Math.Sqrt(cdx * cdx + cdy * cdy);
-                if (cLen > DistanceEpsilon)
+                var px = -cdy / cLen; // perpendicular unit X
+                var py = cdx / cLen;  // perpendicular unit Y
+
+                // Different directions on opposite perpendicular sides
+                if (hasBothDirections)
                 {
-                    // Perpendicular unit vector
-                    var px = -cdy / cLen;
-                    var py = cdx / cLen;
-                    // Center the offsets: e.g. for 3 transitions: -1, 0, +1
-                    var offsetAmount = (transitionIndex - (transitionCount - 1) / 2.0) * TransitionMultiOffset;
-                    startPos = new Point(startPos.X + px * offsetAmount, startPos.Y + py * offsetAmount);
-                    endPos = new Point(endPos.X + px * offsetAmount, endPos.Y + py * offsetAmount);
+                    var sideOffset = perpSide * TransitionMultiOffset;
+                    startPos = new Point(startPos.X + px * sideOffset, startPos.Y + py * sideOffset);
+                    endPos = new Point(endPos.X + px * sideOffset, endPos.Y + py * sideOffset);
+                }
+
+                // Same-direction transitions: offset circles along the line direction
+                if (sameDirectionCount > 1)
+                {
+                    circleLineOffset = (sameDirectionIndex - (sameDirectionCount - 1) / 2.0) * TransitionCircleRadius * TransitionCircleSpacing;
                 }
             }
 
-            DrawTransitionArrow(state, conn, startPos, endPos, wireColor);
+            DrawTransitionArrow(state, conn, startPos, endPos, wireColor, circleLineOffset);
         }
         else
         {
@@ -936,7 +956,7 @@ public partial class AnimGraphViewer
     /// with an arrowhead at the target end and a small circle at the midpoint
     /// for easy click selection (matching UE's transition icon style).
     /// </summary>
-    private void DrawTransitionArrow(LayerCanvasState state, AnimGraphConnection conn, Point startPos, Point endPos, Color wireColor)
+    private void DrawTransitionArrow(LayerCanvasState state, AnimGraphConnection conn, Point startPos, Point endPos, Color wireColor, double circleLineOffset = 0)
     {
         var brush = new SolidColorBrush(wireColor);
 
@@ -993,9 +1013,9 @@ public partial class AnimGraphViewer
         Panel.SetZIndex(hitPath, 1);
         state.Canvas.Children.Add(hitPath);
 
-        // Small circle at the midpoint for easy click selection (UE transition icon style)
-        var midX = (startPos.X + endPos.X) / 2;
-        var midY = (startPos.Y + endPos.Y) / 2;
+        // Small circle at the midpoint (offset along line for same-direction transitions)
+        var midX = (startPos.X + endPos.X) / 2 + ux * circleLineOffset;
+        var midY = (startPos.Y + endPos.Y) / 2 + uy * circleLineOffset;
         var circle = new Ellipse
         {
             Width = TransitionCircleRadius * 2,

From 7d93810623655aaffa3d202f2814f005d7ce57d0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 09:22:23 +0000
Subject: [PATCH 34/52] Fix transition layout: different directions on opposite
 sides, same-direction circles spread perpendicular

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 41 ++++++++++++++++------------
 1 file changed, 24 insertions(+), 17 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index e7af1ff9..69c28d49 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -27,7 +27,6 @@ public partial class AnimGraphViewer
     private const double EntryNodeSize = 30;
     private const double TransitionArrowSize = 10;
     private const double TransitionCircleRadius = 8;
-    private const double TransitionCircleSpacing = 3;
     private const double TransitionMultiOffset = 12;
     private const double DistanceEpsilon = 0.001;
 
@@ -781,33 +780,41 @@ public partial class AnimGraphViewer
             // Compute edge-to-edge shortest path between node bounding boxes
             var (startPos, endPos) = ComputeEdgeToEdgePoints(state, conn.SourceNode, conn.TargetNode);
 
-            // Offset lines: different directions go on opposite perpendicular sides
+            // Offset each transition line perpendicular to the center-to-center direction:
+            //  - Different directions (A→B vs B→A) go on opposite perpendicular sides
+            //  - Multiple same-direction transitions spread outward so circles don't overlap
             var cdx = endPos.X - startPos.X;
             var cdy = endPos.Y - startPos.Y;
             var cLen = Math.Sqrt(cdx * cdx + cdy * cdy);
-            double circleLineOffset = 0;
 
             if (cLen > DistanceEpsilon)
             {
                 var px = -cdy / cLen; // perpendicular unit X
                 var py = cdx / cLen;  // perpendicular unit Y
 
-                // Different directions on opposite perpendicular sides
+                var circleSpread = TransitionCircleRadius * 2 + 4; // circle diameter + gap
+                double perpOffset;
+
                 if (hasBothDirections)
                 {
-                    var sideOffset = perpSide * TransitionMultiOffset;
-                    startPos = new Point(startPos.X + px * sideOffset, startPos.Y + py * sideOffset);
-                    endPos = new Point(endPos.X + px * sideOffset, endPos.Y + py * sideOffset);
+                    // Each direction on its own perpendicular side; stack outward for multiples
+                    perpOffset = perpSide * (TransitionMultiOffset + sameDirectionIndex * circleSpread);
+                }
+                else if (sameDirectionCount > 1)
+                {
+                    // Single direction, multiple transitions: spread symmetrically around center
+                    perpOffset = (sameDirectionIndex - (sameDirectionCount - 1) / 2.0) * circleSpread;
+                }
+                else
+                {
+                    perpOffset = 0;
                 }
 
-                // Same-direction transitions: offset circles along the line direction
-                if (sameDirectionCount > 1)
-                {
-                    circleLineOffset = (sameDirectionIndex - (sameDirectionCount - 1) / 2.0) * TransitionCircleRadius * TransitionCircleSpacing;
-                }
+                startPos = new Point(startPos.X + px * perpOffset, startPos.Y + py * perpOffset);
+                endPos = new Point(endPos.X + px * perpOffset, endPos.Y + py * perpOffset);
             }
 
-            DrawTransitionArrow(state, conn, startPos, endPos, wireColor, circleLineOffset);
+            DrawTransitionArrow(state, conn, startPos, endPos, wireColor);
         }
         else
         {
@@ -956,7 +963,7 @@ public partial class AnimGraphViewer
     /// with an arrowhead at the target end and a small circle at the midpoint
     /// for easy click selection (matching UE's transition icon style).
     /// </summary>
-    private void DrawTransitionArrow(LayerCanvasState state, AnimGraphConnection conn, Point startPos, Point endPos, Color wireColor, double circleLineOffset = 0)
+    private void DrawTransitionArrow(LayerCanvasState state, AnimGraphConnection conn, Point startPos, Point endPos, Color wireColor)
     {
         var brush = new SolidColorBrush(wireColor);
 
@@ -1013,9 +1020,9 @@ public partial class AnimGraphViewer
         Panel.SetZIndex(hitPath, 1);
         state.Canvas.Children.Add(hitPath);
 
-        // Small circle at the midpoint (offset along line for same-direction transitions)
-        var midX = (startPos.X + endPos.X) / 2 + ux * circleLineOffset;
-        var midY = (startPos.Y + endPos.Y) / 2 + uy * circleLineOffset;
+        // Small circle at the midpoint of the (already perpendicular-offset) line
+        var midX = (startPos.X + endPos.X) / 2;
+        var midY = (startPos.Y + endPos.Y) / 2;
         var circle = new Ellipse
         {
             Width = TransitionCircleRadius * 2,

From cb4d6ac91234d5cf3c7643b9dafcf53175fc14fe Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 09:23:14 +0000
Subject: [PATCH 35/52] Extract TransitionCircleGap constant for circle spacing

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 69c28d49..feadb882 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -27,6 +27,7 @@ public partial class AnimGraphViewer
     private const double EntryNodeSize = 30;
     private const double TransitionArrowSize = 10;
     private const double TransitionCircleRadius = 8;
+    private const double TransitionCircleGap = 4;
     private const double TransitionMultiOffset = 12;
     private const double DistanceEpsilon = 0.001;
 
@@ -792,7 +793,7 @@ public partial class AnimGraphViewer
                 var px = -cdy / cLen; // perpendicular unit X
                 var py = cdx / cLen;  // perpendicular unit Y
 
-                var circleSpread = TransitionCircleRadius * 2 + 4; // circle diameter + gap
+                var circleSpread = TransitionCircleRadius * 2 + TransitionCircleGap;
                 double perpOffset;
 
                 if (hasBothDirections)

From 335be6217d4908bcc53e6641f1a08b138322ec30 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 09:47:46 +0000
Subject: [PATCH 36/52] Only separate different-direction transitions;
 same-direction share one line with circles offset along it

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 42 +++++++++++-----------------
 1 file changed, 17 insertions(+), 25 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index feadb882..1da66575 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -27,7 +27,7 @@ public partial class AnimGraphViewer
     private const double EntryNodeSize = 30;
     private const double TransitionArrowSize = 10;
     private const double TransitionCircleRadius = 8;
-    private const double TransitionCircleGap = 4;
+    private const double TransitionCircleSpacing = 3;
     private const double TransitionMultiOffset = 12;
     private const double DistanceEpsilon = 0.001;
 
@@ -781,41 +781,33 @@ public partial class AnimGraphViewer
             // Compute edge-to-edge shortest path between node bounding boxes
             var (startPos, endPos) = ComputeEdgeToEdgePoints(state, conn.SourceNode, conn.TargetNode);
 
-            // Offset each transition line perpendicular to the center-to-center direction:
-            //  - Different directions (A→B vs B→A) go on opposite perpendicular sides
-            //  - Multiple same-direction transitions spread outward so circles don't overlap
+            // Offset lines: different directions go on opposite perpendicular sides
             var cdx = endPos.X - startPos.X;
             var cdy = endPos.Y - startPos.Y;
             var cLen = Math.Sqrt(cdx * cdx + cdy * cdy);
+            double circleLineOffset = 0;
 
             if (cLen > DistanceEpsilon)
             {
                 var px = -cdy / cLen; // perpendicular unit X
                 var py = cdx / cLen;  // perpendicular unit Y
 
-                var circleSpread = TransitionCircleRadius * 2 + TransitionCircleGap;
-                double perpOffset;
-
+                // Different directions on opposite perpendicular sides
                 if (hasBothDirections)
                 {
-                    // Each direction on its own perpendicular side; stack outward for multiples
-                    perpOffset = perpSide * (TransitionMultiOffset + sameDirectionIndex * circleSpread);
-                }
-                else if (sameDirectionCount > 1)
-                {
-                    // Single direction, multiple transitions: spread symmetrically around center
-                    perpOffset = (sameDirectionIndex - (sameDirectionCount - 1) / 2.0) * circleSpread;
-                }
-                else
-                {
-                    perpOffset = 0;
+                    var sideOffset = perpSide * TransitionMultiOffset;
+                    startPos = new Point(startPos.X + px * sideOffset, startPos.Y + py * sideOffset);
+                    endPos = new Point(endPos.X + px * sideOffset, endPos.Y + py * sideOffset);
                 }
 
-                startPos = new Point(startPos.X + px * perpOffset, startPos.Y + py * perpOffset);
-                endPos = new Point(endPos.X + px * perpOffset, endPos.Y + py * perpOffset);
+                // Multiple same-direction transitions: offset circles along the line direction
+                if (sameDirectionCount > 1)
+                {
+                    circleLineOffset = (sameDirectionIndex - (sameDirectionCount - 1) / 2.0) * TransitionCircleRadius * TransitionCircleSpacing;
+                }
             }
 
-            DrawTransitionArrow(state, conn, startPos, endPos, wireColor);
+            DrawTransitionArrow(state, conn, startPos, endPos, wireColor, circleLineOffset);
         }
         else
         {
@@ -964,7 +956,7 @@ public partial class AnimGraphViewer
     /// with an arrowhead at the target end and a small circle at the midpoint
     /// for easy click selection (matching UE's transition icon style).
     /// </summary>
-    private void DrawTransitionArrow(LayerCanvasState state, AnimGraphConnection conn, Point startPos, Point endPos, Color wireColor)
+    private void DrawTransitionArrow(LayerCanvasState state, AnimGraphConnection conn, Point startPos, Point endPos, Color wireColor, double circleLineOffset = 0)
     {
         var brush = new SolidColorBrush(wireColor);
 
@@ -1021,9 +1013,9 @@ public partial class AnimGraphViewer
         Panel.SetZIndex(hitPath, 1);
         state.Canvas.Children.Add(hitPath);
 
-        // Small circle at the midpoint of the (already perpendicular-offset) line
-        var midX = (startPos.X + endPos.X) / 2;
-        var midY = (startPos.Y + endPos.Y) / 2;
+        // Small circle at the midpoint (offset along line for same-direction transitions)
+        var midX = (startPos.X + endPos.X) / 2 + ux * circleLineOffset;
+        var midY = (startPos.Y + endPos.Y) / 2 + uy * circleLineOffset;
         var circle = new Ellipse
         {
             Width = TransitionCircleRadius * 2,

From f346803d46e9219e126eb5c4c55b83f078e5316b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 01:09:42 +0000
Subject: [PATCH 37/52] Fix bidirectional transition separation: use canonical
 pair perpendicular vector
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The perpendicular vector was being computed per-connection from its own
direction. For B→A connections the perp flipped vs A→B, and when multiplied
by the negative perpSide the offsets cancelled out — both lines landed on
the same position.

Now a stable perpendicular is computed once from the canonical pair direction
(nodeA→nodeB centers) and passed to DrawConnectionLine, so perpSide=+1/-1
correctly separates them to opposite sides.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 34 +++++++++++++++++++++-------
 1 file changed, 26 insertions(+), 8 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 1da66575..c034db3c 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -209,11 +209,31 @@ public partial class AnimGraphViewer
             var backward = allConns.Where(c => c.SourceNode == nodeB).ToList();
             var hasBothDirections = forward.Count > 0 && backward.Count > 0;
 
+            // Compute a stable perpendicular vector based on the canonical pair direction (nodeA→nodeB)
+            // so that forward and backward connections are offset to opposite sides consistently
+            var pairPerpX = 0.0;
+            var pairPerpY = 0.0;
+            if (hasBothDirections)
+            {
+                var centerA = GetNodeCenter(state, nodeA);
+                var centerB = GetNodeCenter(state, nodeB);
+                var pdx = centerB.X - centerA.X;
+                var pdy = centerB.Y - centerA.Y;
+                var pLen = Math.Sqrt(pdx * pdx + pdy * pdy);
+                if (pLen > DistanceEpsilon)
+                {
+                    pairPerpX = -pdy / pLen;
+                    pairPerpY = pdx / pLen;
+                }
+            }
+
             for (var i = 0; i < forward.Count; i++)
-                DrawConnectionLine(state, forward[i], i, forward.Count, perpSide: 1, hasBothDirections: hasBothDirections);
+                DrawConnectionLine(state, forward[i], i, forward.Count,
+                    pairPerpX, pairPerpY, perpSide: 1, hasBothDirections: hasBothDirections);
 
             for (var i = 0; i < backward.Count; i++)
-                DrawConnectionLine(state, backward[i], i, backward.Count, perpSide: -1, hasBothDirections: hasBothDirections);
+                DrawConnectionLine(state, backward[i], i, backward.Count,
+                    pairPerpX, pairPerpY, perpSide: -1, hasBothDirections: hasBothDirections);
         }
 
         // Draw nodes
@@ -764,6 +784,7 @@ public partial class AnimGraphViewer
 
     private void DrawConnectionLine(LayerCanvasState state, AnimGraphConnection conn,
         int sameDirectionIndex = 0, int sameDirectionCount = 1,
+        double pairPerpX = 0, double pairPerpY = 0,
         int perpSide = 0, bool hasBothDirections = false)
     {
         var sourceKey = (conn.SourceNode, conn.SourcePinName, true);
@@ -789,15 +810,12 @@ public partial class AnimGraphViewer
 
             if (cLen > DistanceEpsilon)
             {
-                var px = -cdy / cLen; // perpendicular unit X
-                var py = cdx / cLen;  // perpendicular unit Y
-
-                // Different directions on opposite perpendicular sides
+                // Use the pre-computed canonical pair perpendicular for bidirectional separation
                 if (hasBothDirections)
                 {
                     var sideOffset = perpSide * TransitionMultiOffset;
-                    startPos = new Point(startPos.X + px * sideOffset, startPos.Y + py * sideOffset);
-                    endPos = new Point(endPos.X + px * sideOffset, endPos.Y + py * sideOffset);
+                    startPos = new Point(startPos.X + pairPerpX * sideOffset, startPos.Y + pairPerpY * sideOffset);
+                    endPos = new Point(endPos.X + pairPerpX * sideOffset, endPos.Y + pairPerpY * sideOffset);
                 }
 
                 // Multiple same-direction transitions: offset circles along the line direction

From 7e0e897a91455a5944873e19166d4c358ec7ee30 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 01:27:21 +0000
Subject: [PATCH 38/52] Fix nested state machine double-click navigation

PrefixStateMachineLayerNames and BuildStateMachineOverviewLayers only
scanned vm.Layers for StateMachine nodes, missing nested SM nodes in
vm.StateSubGraphs. This caused overview layers for nested SMs to be
named incorrectly (e.g. "AnimGraph > NestedSM" instead of
"AnimGraph > OuterSM > StateName > NestedSM"), so double-click from
a state sub-graph could not find the matching overview layer.

Fix: iteratively discover nested SM nodes in state sub-graphs and
also scan StateSubGraphs in BuildStateMachineOverviewLayers.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 72 ++++++++++++++++++-------
 1 file changed, 52 insertions(+), 20 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 99562970..41573382 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -356,31 +356,54 @@ public class AnimGraphViewModel
             }
         }
 
-        // Rename state sub-graphs whose nodes belong to a state machine
-        foreach (var (_, layer) in vm.StateSubGraphs)
+        // Iteratively rename state sub-graphs and discover nested StateMachine nodes.
+        // Each pass renames sub-graphs whose parent SM is already known, then registers
+        // any nested SM nodes found in the newly-renamed sub-graphs for the next pass.
+        bool changed = true;
+        while (changed)
         {
-            var smName = string.Empty;
-            foreach (var node in layer.Nodes)
+            changed = false;
+            foreach (var (_, layer) in vm.StateSubGraphs)
             {
-                if (node.AdditionalProperties.TryGetValue("BelongsToStateMachine", out var val) &&
-                    !string.IsNullOrEmpty(val))
+                var smName = string.Empty;
+                foreach (var node in layer.Nodes)
                 {
-                    smName = val;
-                    break;
+                    if (node.AdditionalProperties.TryGetValue("BelongsToStateMachine", out var val) &&
+                        !string.IsNullOrEmpty(val))
+                    {
+                        smName = val;
+                        break;
+                    }
+                }
+
+                if (string.IsNullOrEmpty(smName))
+                    continue;
+
+                if (!smParentLayer.TryGetValue(smName, out var parentName))
+                    continue;
+
+                // Per-state layers: use the _StateResult node's Name additional property for display
+                var stateResultNode = layer.Nodes.FirstOrDefault(n =>
+                    n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase));
+                var stateName = stateResultNode?.AdditionalProperties.GetValueOrDefault("Name") ?? layer.Name;
+                var expectedName = $"{parentName}{SubGraphPathSeparator}{smName}{SubGraphPathSeparator}{stateName}";
+
+                if (layer.Name != expectedName)
+                {
+                    layer.Name = expectedName;
+                    changed = true;
+                }
+
+                // Register any nested StateMachine nodes within this sub-graph
+                foreach (var node in layer.Nodes)
+                {
+                    if (node.AdditionalProperties.TryGetValue("StateMachineName", out var nestedMachineName))
+                    {
+                        if (smParentLayer.TryAdd(nestedMachineName, layer.Name))
+                            changed = true;
+                    }
                 }
             }
-
-            if (string.IsNullOrEmpty(smName))
-                continue;
-
-            if (!smParentLayer.TryGetValue(smName, out var parentName))
-                continue;
-
-            // Per-state layers: use the _StateResult node's Name additional property for display
-            var stateResultNode = layer.Nodes.FirstOrDefault(n =>
-                n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase));
-            var stateName = stateResultNode?.AdditionalProperties.GetValueOrDefault("Name") ?? layer.Name;
-            layer.Name = $"{parentName}{SubGraphPathSeparator}{smName}{SubGraphPathSeparator}{stateName}";
         }
     }
 
@@ -402,6 +425,15 @@ public class AnimGraphViewModel
                     smParentLayer.TryAdd(machineName, layer.Name);
             }
         }
+        // Also scan state sub-graphs for nested StateMachine nodes (already renamed by PrefixStateMachineLayerNames)
+        foreach (var (_, layer) in vm.StateSubGraphs)
+        {
+            foreach (var node in layer.Nodes)
+            {
+                if (node.AdditionalProperties.TryGetValue("StateMachineName", out var machineName))
+                    smParentLayer.TryAdd(machineName, layer.Name);
+            }
+        }
 
         foreach (var sm in smMetadata)
         {

From 5998953bfe595aa4a388e80353562c8b247ea337 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 02:14:42 +0000
Subject: [PATCH 39/52] Add closable tabs and single-line tab strip layout
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Tab headers for dynamically-opened sub-graphs now include a close
  button (×). The initial AnimGraph tab is not closable.
- TabControl uses a custom template with horizontal ScrollViewer to
  keep all tabs in a single line instead of wrapping.
- Long tab names are truncated with ellipsis (MaxWidth=200).

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml    | 19 ++++++++-
 FModel/Views/AnimGraphViewer.xaml.cs | 63 +++++++++++++++++++++++++---
 2 files changed, 74 insertions(+), 8 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml b/FModel/Views/AnimGraphViewer.xaml
index 76e204f7..d689a80e 100644
--- a/FModel/Views/AnimGraphViewer.xaml
+++ b/FModel/Views/AnimGraphViewer.xaml
@@ -41,9 +41,24 @@
                 <ColumnDefinition Width="280" MinWidth="200"/>
             </Grid.ColumnDefinitions>
 
-            <!-- Layer tabs with graph canvas -->
+            <!-- Layer tabs with graph canvas (single-line, scrollable tab strip) -->
             <TabControl x:Name="LayerTabControl" Grid.Column="0" SelectionChanged="OnLayerTabChanged"
-                        Background="{DynamicResource {x:Static adonisUi:Brushes.Layer0BackgroundBrush}}"/>
+                        Background="{DynamicResource {x:Static adonisUi:Brushes.Layer0BackgroundBrush}}">
+                <TabControl.Template>
+                    <ControlTemplate TargetType="TabControl">
+                        <Grid>
+                            <Grid.RowDefinitions>
+                                <RowDefinition Height="Auto"/>
+                                <RowDefinition Height="*"/>
+                            </Grid.RowDefinitions>
+                            <ScrollViewer Grid.Row="0" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Disabled">
+                                <TabPanel IsItemsHost="True"/>
+                            </ScrollViewer>
+                            <ContentPresenter Grid.Row="1" ContentSource="SelectedContent"/>
+                        </Grid>
+                    </ControlTemplate>
+                </TabControl.Template>
+            </TabControl>
 
             <GridSplitter Grid.Column="1" Width="4" HorizontalAlignment="Center" VerticalAlignment="Stretch"
                           Background="{DynamicResource {x:Static adonisUi:Brushes.Layer1BorderBrush}}"/>
diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index c034db3c..1836a315 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -86,7 +86,7 @@ public partial class AnimGraphViewer
             l.Name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase))
             ?? _viewModel.Layers[0];
 
-        AddLayerTab(outputLayer);
+        AddLayerTab(outputLayer, closable: false);
 
         if (LayerTabControl.Items.Count > 0)
             LayerTabControl.SelectedIndex = 0;
@@ -95,13 +95,46 @@ public partial class AnimGraphViewer
     /// <summary>
     /// Creates a new tab for the given layer and selects it.
     /// </summary>
-    private void AddLayerTab(AnimGraphLayer layer)
+    private void AddLayerTab(AnimGraphLayer layer, bool closable = true)
     {
-        var tabItem = new System.Windows.Controls.TabItem
+        var tabItem = new System.Windows.Controls.TabItem { Tag = layer };
+
+        if (closable)
         {
-            Header = layer.Name,
-            Tag = layer
-        };
+            // Build a header with text + close button
+            var headerPanel = new StackPanel { Orientation = Orientation.Horizontal };
+            headerPanel.Children.Add(new TextBlock
+            {
+                Text = layer.Name,
+                VerticalAlignment = VerticalAlignment.Center,
+                MaxWidth = 200,
+                TextTrimming = TextTrimming.CharacterEllipsis
+            });
+            var closeBtn = new Button
+            {
+                Content = "×",
+                FontSize = 12,
+                Padding = new Thickness(4, 0, 4, 0),
+                Margin = new Thickness(6, 0, 0, 0),
+                VerticalAlignment = VerticalAlignment.Center,
+                Background = Brushes.Transparent,
+                BorderThickness = new Thickness(0),
+                Cursor = Cursors.Hand,
+                Foreground = Brushes.Gray
+            };
+            closeBtn.Click += (_, _) => CloseTab(tabItem);
+            headerPanel.Children.Add(closeBtn);
+            tabItem.Header = headerPanel;
+        }
+        else
+        {
+            tabItem.Header = new TextBlock
+            {
+                Text = layer.Name,
+                MaxWidth = 200,
+                TextTrimming = TextTrimming.CharacterEllipsis
+            };
+        }
 
         var canvasBorder = new Border
         {
@@ -139,6 +172,24 @@ public partial class AnimGraphViewer
         LayerTabControl.SelectedItem = tabItem;
     }
 
+    /// <summary>
+    /// Closes the given tab and cleans up its layer state.
+    /// </summary>
+    private void CloseTab(System.Windows.Controls.TabItem tabItem)
+    {
+        if (tabItem.Tag is AnimGraphLayer layer)
+            _layerStates.Remove(layer);
+
+        var index = LayerTabControl.Items.IndexOf(tabItem);
+        LayerTabControl.Items.Remove(tabItem);
+
+        // Select the previous tab or the first one
+        if (LayerTabControl.Items.Count > 0)
+        {
+            LayerTabControl.SelectedIndex = Math.Max(0, index - 1);
+        }
+    }
+
     private void OnLayerTabChanged(object sender, SelectionChangedEventArgs e)
     {
         if (LayerTabControl.SelectedItem is not System.Windows.Controls.TabItem { Tag: AnimGraphLayer layer })

From d6efa832c446a38adeb3e2259c16013be90b04ce Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 02:34:46 +0000
Subject: [PATCH 40/52] Skip drawing connection lines between SaveCachedPose
 and UseCachedPose nodes

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 1836a315..6529059d 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -231,6 +231,10 @@ public partial class AnimGraphViewer
         var pairGroups = new Dictionary<(AnimGraphNode, AnimGraphNode), List<AnimGraphConnection>>();
         foreach (var conn in state.Layer.Connections)
         {
+            // Skip connections between SaveCachedPose and UseCachedPose nodes
+            if (IsCachedPoseConnection(conn))
+                continue;
+
             var isTransition = (conn.SourceNode.IsStateMachineState || conn.SourceNode.IsEntryNode) &&
                                (conn.TargetNode.IsStateMachineState || conn.TargetNode.IsEntryNode);
             if (isTransition)
@@ -920,6 +924,28 @@ public partial class AnimGraphViewer
         }
     }
 
+    /// <summary>
+    /// Returns true if the connection links a SaveCachedPose node to a UseCachedPose node
+    /// (or vice-versa). These connections are not drawn because the cached pose link is
+    /// an implicit data dependency, not a visible wire in UE's animation blueprint editor.
+    /// </summary>
+    private static bool IsCachedPoseConnection(AnimGraphConnection conn)
+    {
+        var srcType = conn.SourceNode.ExportType;
+        var tgtType = conn.TargetNode.ExportType;
+
+        var srcIsSave = srcType.Contains("SaveCachedPose", StringComparison.OrdinalIgnoreCase) ||
+                        conn.SourceNode.Name.Contains("SaveCachedPose", StringComparison.OrdinalIgnoreCase);
+        var srcIsUse  = srcType.Contains("UseCachedPose", StringComparison.OrdinalIgnoreCase) ||
+                        conn.SourceNode.Name.Contains("UseCachedPose", StringComparison.OrdinalIgnoreCase);
+        var tgtIsSave = tgtType.Contains("SaveCachedPose", StringComparison.OrdinalIgnoreCase) ||
+                        conn.TargetNode.Name.Contains("SaveCachedPose", StringComparison.OrdinalIgnoreCase);
+        var tgtIsUse  = tgtType.Contains("UseCachedPose", StringComparison.OrdinalIgnoreCase) ||
+                        conn.TargetNode.Name.Contains("UseCachedPose", StringComparison.OrdinalIgnoreCase);
+
+        return (srcIsSave && tgtIsUse) || (srcIsUse && tgtIsSave);
+    }
+
     /// <summary>
     /// Computes the shortest straight-line connection points between two node edges.
     /// For state nodes (rounded rectangles) and entry nodes (circles), finds the

From 2b83e975854a8648820cbe637200dc3504cd8f54 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 02:35:28 +0000
Subject: [PATCH 41/52] Refactor IsCachedPoseConnection to extract
 NodeMatchesType helper

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 6529059d..9e8cabbf 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -931,21 +931,20 @@ public partial class AnimGraphViewer
     /// </summary>
     private static bool IsCachedPoseConnection(AnimGraphConnection conn)
     {
-        var srcType = conn.SourceNode.ExportType;
-        var tgtType = conn.TargetNode.ExportType;
-
-        var srcIsSave = srcType.Contains("SaveCachedPose", StringComparison.OrdinalIgnoreCase) ||
-                        conn.SourceNode.Name.Contains("SaveCachedPose", StringComparison.OrdinalIgnoreCase);
-        var srcIsUse  = srcType.Contains("UseCachedPose", StringComparison.OrdinalIgnoreCase) ||
-                        conn.SourceNode.Name.Contains("UseCachedPose", StringComparison.OrdinalIgnoreCase);
-        var tgtIsSave = tgtType.Contains("SaveCachedPose", StringComparison.OrdinalIgnoreCase) ||
-                        conn.TargetNode.Name.Contains("SaveCachedPose", StringComparison.OrdinalIgnoreCase);
-        var tgtIsUse  = tgtType.Contains("UseCachedPose", StringComparison.OrdinalIgnoreCase) ||
-                        conn.TargetNode.Name.Contains("UseCachedPose", StringComparison.OrdinalIgnoreCase);
+        var srcIsSave = NodeMatchesType(conn.SourceNode, "SaveCachedPose");
+        var srcIsUse  = NodeMatchesType(conn.SourceNode, "UseCachedPose");
+        var tgtIsSave = NodeMatchesType(conn.TargetNode, "SaveCachedPose");
+        var tgtIsUse  = NodeMatchesType(conn.TargetNode, "UseCachedPose");
 
         return (srcIsSave && tgtIsUse) || (srcIsUse && tgtIsSave);
     }
 
+    private static bool NodeMatchesType(AnimGraphNode node, string typeFragment)
+    {
+        return node.ExportType.Contains(typeFragment, StringComparison.OrdinalIgnoreCase) ||
+               node.Name.Contains(typeFragment, StringComparison.OrdinalIgnoreCase);
+    }
+
     /// <summary>
     /// Computes the shortest straight-line connection points between two node edges.
     /// For state nodes (rounded rectangles) and entry nodes (circles), finds the

From 4358ae166308550b7e5c1dd2435624bc410559fb Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 03:09:13 +0000
Subject: [PATCH 42/52] Move SaveCachedPose nodes and their input chains to the
 outer AnimGraph layer

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 50 ++++++++++++++++++++++++-
 1 file changed, 48 insertions(+), 2 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 41573382..8447187a 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -206,16 +206,19 @@ public class AnimGraphViewModel
             .Where(n => n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase))
             .ToList();
 
+        AnimGraphLayer? primaryGraphLayer = null;
         foreach (var rootNode in graphRoots)
         {
             if (!assigned.Add(rootNode)) continue;
             var layerNodes = CollectUpstream(rootNode, upstreamOf, assigned);
             AddLayer(vm, layerNodes, layerIndex++);
+            primaryGraphLayer ??= vm.Layers[^1];
         }
 
         // Pass 2: Build state machine state sub-graphs from AnimGraphNode_StateResult nodes.
         // Each _StateResult node defines a state's sub-graph within a state machine.
         // These are stored in StateSubGraphs keyed by the root node's property name.
+        // SaveCachedPose nodes are excluded because they belong to the parent AnimGraph layer.
         var stateResultRoots = vm.Nodes
             .Where(n => n.ExportType.EndsWith("_StateResult", StringComparison.OrdinalIgnoreCase))
             .ToList();
@@ -223,10 +226,42 @@ public class AnimGraphViewModel
         foreach (var stateResultNode in stateResultRoots)
         {
             if (!assigned.Add(stateResultNode)) continue;
-            var layerNodes = CollectUpstream(stateResultNode, upstreamOf, assigned);
+            var layerNodes = CollectUpstream(stateResultNode, upstreamOf, assigned,
+                excludeNode: IsSaveCachedPoseNode);
             AddStateSubGraph(vm, layerNodes, stateResultNode.Name, layerIndex++);
         }
 
+        // Pass 3: Move unassigned SaveCachedPose nodes and their input chains
+        // to the primary AnimGraph layer. In UE, SaveCachedPose can only exist at
+        // the animation blueprint's top-level layer, not inside state machine sub-graphs.
+        if (primaryGraphLayer != null)
+        {
+            var unassignedSavePoseNodes = vm.Nodes
+                .Where(n => !assigned.Contains(n) && IsSaveCachedPoseNode(n))
+                .ToList();
+
+            if (unassignedSavePoseNodes.Count > 0)
+            {
+                foreach (var saveNode in unassignedSavePoseNodes)
+                {
+                    if (!assigned.Add(saveNode)) continue;
+                    var inputChain = CollectUpstream(saveNode, upstreamOf, assigned);
+                    primaryGraphLayer.Nodes.AddRange(inputChain);
+                }
+
+                // Rebuild connections for the expanded primary layer
+                var nodeSet = new HashSet<AnimGraphNode>(primaryGraphLayer.Nodes);
+                primaryGraphLayer.Connections.Clear();
+                foreach (var conn in vm.Connections)
+                {
+                    if (nodeSet.Contains(conn.SourceNode) && nodeSet.Contains(conn.TargetNode))
+                        primaryGraphLayer.Connections.Add(conn);
+                }
+
+                LayoutLayerNodes(primaryGraphLayer);
+            }
+        }
+
         // Fallback: any remaining unassigned nodes go into connected-component layers
         var remaining = vm.Nodes.Where(n => !assigned.Contains(n)).ToList();
         if (remaining.Count == 0) return;
@@ -271,11 +306,14 @@ public class AnimGraphViewModel
 
     /// <summary>
     /// Collects a root node and all its upstream providers via BFS.
+    /// When <paramref name="excludeNode"/> is provided, matching upstream nodes
+    /// are skipped (not collected and their inputs are not traversed).
     /// </summary>
     private static List<AnimGraphNode> CollectUpstream(
         AnimGraphNode root,
         Dictionary<AnimGraphNode, List<AnimGraphNode>> upstreamOf,
-        HashSet<AnimGraphNode> assigned)
+        HashSet<AnimGraphNode> assigned,
+        Func<AnimGraphNode, bool>? excludeNode = null)
     {
         var nodes = new List<AnimGraphNode> { root };
         var queue = new Queue<AnimGraphNode>();
@@ -286,6 +324,8 @@ public class AnimGraphViewModel
             var current = queue.Dequeue();
             foreach (var upstream in upstreamOf[current])
             {
+                if (excludeNode != null && excludeNode(upstream))
+                    continue;
                 if (assigned.Add(upstream))
                 {
                     nodes.Add(upstream);
@@ -835,6 +875,12 @@ public class AnimGraphViewModel
                name.StartsWith("AnimGraphNode_", StringComparison.OrdinalIgnoreCase);
     }
 
+    private static bool IsSaveCachedPoseNode(AnimGraphNode node)
+    {
+        return node.ExportType.Contains("SaveCachedPose", StringComparison.OrdinalIgnoreCase) ||
+               node.Name.Contains("SaveCachedPose", StringComparison.OrdinalIgnoreCase);
+    }
+
     private static void ExtractNodeProperties(UObject cdo, string propName, AnimGraphNode node)
     {
         // Try to get the struct fallback value for this node property

From fd99fc2cc3206e1595db46e96f3b970a783af27b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 03:12:01 +0000
Subject: [PATCH 43/52] Add clarifying comment for null primaryGraphLayer
 fallback case

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 8447187a..3e56020e 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -234,6 +234,7 @@ public class AnimGraphViewModel
         // Pass 3: Move unassigned SaveCachedPose nodes and their input chains
         // to the primary AnimGraph layer. In UE, SaveCachedPose can only exist at
         // the animation blueprint's top-level layer, not inside state machine sub-graphs.
+        // If no _Root layer exists, these nodes fall through to the fallback handler below.
         if (primaryGraphLayer != null)
         {
             var unassignedSavePoseNodes = vm.Nodes

From e91dbffdd22e71f7ffbe4f5171b07b85354bca9e Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 03:24:44 +0000
Subject: [PATCH 44/52] Add double-click navigation from UseCachedPose to
 SaveCachedPose node

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 86 +++++++++++++++++++++++++++-
 1 file changed, 84 insertions(+), 2 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 9e8cabbf..029cf430 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -671,15 +671,23 @@ public partial class AnimGraphViewer
     }
 
     /// <summary>
-    /// When a LinkedAnimLayer or StateMachine node is double-clicked, opens its
-    /// corresponding sub-graph in a new tab.
+    /// When a LinkedAnimLayer, StateMachine, or UseCachedPose node is double-clicked,
+    /// opens its corresponding sub-graph/layer in a new tab.
     /// - LinkedAnimLayer: matches "Layer" property → layer name from Root node's "Name"
     /// - StateMachine: matches "StateMachineName" property → layer name from BakedStateMachines
+    /// - UseCachedPose: finds the matching SaveCachedPose node via connections
+    ///   and navigates to the layer containing it
     /// </summary>
     private void TryOpenSubGraph(AnimGraphNode node)
     {
         string? layerName = null;
 
+        if (NodeMatchesType(node, "UseCachedPose"))
+        {
+            TryNavigateToSaveCachedPose(node);
+            return;
+        }
+
         if (node.ExportType.Contains("LinkedAnimLayer", StringComparison.OrdinalIgnoreCase))
         {
             node.AdditionalProperties.TryGetValue("Layer", out layerName);
@@ -736,6 +744,80 @@ public partial class AnimGraphViewer
         AddLayerTab(targetLayer);
     }
 
+    /// <summary>
+    /// Navigates from a UseCachedPose node to its corresponding SaveCachedPose node.
+    /// Finds the SaveCachedPose through direct connections in the graph, locates the
+    /// layer containing it, switches to that layer's tab, and selects the node.
+    /// </summary>
+    private void TryNavigateToSaveCachedPose(AnimGraphNode useCachedPoseNode)
+    {
+        // Find the matching SaveCachedPose node via connections
+        AnimGraphNode? savePoseNode = null;
+        foreach (var conn in _viewModel.Connections)
+        {
+            if (conn.SourceNode == useCachedPoseNode && NodeMatchesType(conn.TargetNode, "SaveCachedPose"))
+            {
+                savePoseNode = conn.TargetNode;
+                break;
+            }
+            if (conn.TargetNode == useCachedPoseNode && NodeMatchesType(conn.SourceNode, "SaveCachedPose"))
+            {
+                savePoseNode = conn.SourceNode;
+                break;
+            }
+        }
+
+        if (savePoseNode == null)
+            return;
+
+        // Find which layer contains the SaveCachedPose node
+        AnimGraphLayer? targetLayer = null;
+        foreach (var layer in _viewModel.Layers)
+        {
+            if (layer.Nodes.Contains(savePoseNode))
+            {
+                targetLayer = layer;
+                break;
+            }
+        }
+        if (targetLayer == null)
+        {
+            foreach (var (_, layer) in _viewModel.StateSubGraphs)
+            {
+                if (layer.Nodes.Contains(savePoseNode))
+                {
+                    targetLayer = layer;
+                    break;
+                }
+            }
+        }
+        if (targetLayer == null)
+            return;
+
+        // Switch to the layer's tab (or open it)
+        System.Windows.Controls.TabItem? existingTab = null;
+        foreach (System.Windows.Controls.TabItem tab in LayerTabControl.Items)
+        {
+            if (tab.Tag == targetLayer)
+            {
+                existingTab = tab;
+                break;
+            }
+        }
+
+        if (existingTab != null)
+            LayerTabControl.SelectedItem = existingTab;
+        else
+            AddLayerTab(targetLayer);
+
+        // Select and highlight the SaveCachedPose node in the target layer
+        if (_layerStates.TryGetValue(targetLayer, out var state) &&
+            state.NodeVisuals.TryGetValue(savePoseNode, out var visual))
+        {
+            SelectNode(savePoseNode, visual.border);
+        }
+    }
+
     /// <summary>
     /// Fills the properties panel with the selected node's information,
     /// similar to UE's Details panel when a node is selected.

From 164d065b057eedee8297e1b62f4ef2ae24acbec5 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 03:27:44 +0000
Subject: [PATCH 45/52] Defer SaveCachedPose node selection to ensure visual
 tree is ready

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 029cf430..471f90a9 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -810,12 +810,17 @@ public partial class AnimGraphViewer
         else
             AddLayerTab(targetLayer);
 
-        // Select and highlight the SaveCachedPose node in the target layer
-        if (_layerStates.TryGetValue(targetLayer, out var state) &&
-            state.NodeVisuals.TryGetValue(savePoseNode, out var visual))
+        // Select and highlight the SaveCachedPose node in the target layer.
+        // Use Dispatcher.BeginInvoke to ensure the visual tree is fully updated
+        // after the tab switch before attempting to select the node.
+        Dispatcher.BeginInvoke(() =>
         {
-            SelectNode(savePoseNode, visual.border);
-        }
+            if (_layerStates.TryGetValue(targetLayer, out var state) &&
+                state.NodeVisuals.TryGetValue(savePoseNode, out var visual))
+            {
+                SelectNode(savePoseNode, visual.border);
+            }
+        });
     }
 
     /// <summary>

From 8da0986147d6d9a4eff02f7ca2fec964ae89360a Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 03:58:41 +0000
Subject: [PATCH 46/52] Exclude SaveCachedPose from Pass 1 upstream BFS to fix
 layer assignment

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 3e56020e..58c7fcc3 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -202,6 +202,8 @@ public class AnimGraphViewModel
 
         // Pass 1: Build graph layers from AnimGraphNode_Root nodes.
         // Each _Root node defines an animation blueprint layer (e.g. "AnimGraph").
+        // SaveCachedPose nodes are excluded so their input chains don't get pulled
+        // into Root layers; Pass 3 assigns SaveCachedPose nodes to the correct layer.
         var graphRoots = vm.Nodes
             .Where(n => n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase))
             .ToList();
@@ -210,7 +212,8 @@ public class AnimGraphViewModel
         foreach (var rootNode in graphRoots)
         {
             if (!assigned.Add(rootNode)) continue;
-            var layerNodes = CollectUpstream(rootNode, upstreamOf, assigned);
+            var layerNodes = CollectUpstream(rootNode, upstreamOf, assigned,
+                excludeNode: IsSaveCachedPoseNode);
             AddLayer(vm, layerNodes, layerIndex++);
             primaryGraphLayer ??= vm.Layers[^1];
         }

From 99aa9d518fa086bc6bbadbbf9c43013dbfce7471 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 04:53:36 +0000
Subject: [PATCH 47/52] Fix SaveCachedPose layer assignment with robust
 enforcement step

- Revert Pass 1 exclusion so SaveCachedPose is naturally collected into
  the correct _Root layer when reachable via BFS
- Add EnforceSaveCachedPoseInAnimBlueprintLayer as a final post-processing
  step that scans all non-_Root layers (state sub-graphs and fallback
  layers) and moves any stray SaveCachedPose nodes to the primary _Root
  layer
- Extract RebuildLayerConnections helper for DRY connection rebuilding

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 170 +++++++++++++++++-------
 1 file changed, 121 insertions(+), 49 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index 58c7fcc3..c449f2ab 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -202,8 +202,6 @@ public class AnimGraphViewModel
 
         // Pass 1: Build graph layers from AnimGraphNode_Root nodes.
         // Each _Root node defines an animation blueprint layer (e.g. "AnimGraph").
-        // SaveCachedPose nodes are excluded so their input chains don't get pulled
-        // into Root layers; Pass 3 assigns SaveCachedPose nodes to the correct layer.
         var graphRoots = vm.Nodes
             .Where(n => n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase))
             .ToList();
@@ -212,8 +210,7 @@ public class AnimGraphViewModel
         foreach (var rootNode in graphRoots)
         {
             if (!assigned.Add(rootNode)) continue;
-            var layerNodes = CollectUpstream(rootNode, upstreamOf, assigned,
-                excludeNode: IsSaveCachedPoseNode);
+            var layerNodes = CollectUpstream(rootNode, upstreamOf, assigned);
             AddLayer(vm, layerNodes, layerIndex++);
             primaryGraphLayer ??= vm.Layers[^1];
         }
@@ -234,10 +231,9 @@ public class AnimGraphViewModel
             AddStateSubGraph(vm, layerNodes, stateResultNode.Name, layerIndex++);
         }
 
-        // Pass 3: Move unassigned SaveCachedPose nodes and their input chains
-        // to the primary AnimGraph layer. In UE, SaveCachedPose can only exist at
-        // the animation blueprint's top-level layer, not inside state machine sub-graphs.
-        // If no _Root layer exists, these nodes fall through to the fallback handler below.
+        // Pass 3: Catch any still-unassigned SaveCachedPose nodes and their input
+        // chains, adding them to the primary AnimGraph layer before the fallback
+        // handles remaining nodes.
         if (primaryGraphLayer != null)
         {
             var unassignedSavePoseNodes = vm.Nodes
@@ -253,59 +249,135 @@ public class AnimGraphViewModel
                     primaryGraphLayer.Nodes.AddRange(inputChain);
                 }
 
-                // Rebuild connections for the expanded primary layer
-                var nodeSet = new HashSet<AnimGraphNode>(primaryGraphLayer.Nodes);
-                primaryGraphLayer.Connections.Clear();
-                foreach (var conn in vm.Connections)
-                {
-                    if (nodeSet.Contains(conn.SourceNode) && nodeSet.Contains(conn.TargetNode))
-                        primaryGraphLayer.Connections.Add(conn);
-                }
-
-                LayoutLayerNodes(primaryGraphLayer);
+                RebuildLayerConnections(vm, primaryGraphLayer);
             }
         }
 
         // Fallback: any remaining unassigned nodes go into connected-component layers
         var remaining = vm.Nodes.Where(n => !assigned.Contains(n)).ToList();
-        if (remaining.Count == 0) return;
-
-        var adjacency = new Dictionary<AnimGraphNode, HashSet<AnimGraphNode>>();
-        foreach (var node in remaining)
-            adjacency[node] = [];
-
-        foreach (var conn in vm.Connections)
+        if (remaining.Count > 0)
         {
-            if (adjacency.ContainsKey(conn.SourceNode) && adjacency.ContainsKey(conn.TargetNode))
+            var adjacency = new Dictionary<AnimGraphNode, HashSet<AnimGraphNode>>();
+            foreach (var node in remaining)
+                adjacency[node] = [];
+
+            foreach (var conn in vm.Connections)
             {
-                adjacency[conn.SourceNode].Add(conn.TargetNode);
-                adjacency[conn.TargetNode].Add(conn.SourceNode);
-            }
-        }
-
-        foreach (var node in remaining)
-        {
-            if (!assigned.Add(node)) continue;
-
-            var component = new List<AnimGraphNode> { node };
-            var queue = new Queue<AnimGraphNode>();
-            queue.Enqueue(node);
-
-            while (queue.Count > 0)
-            {
-                var current = queue.Dequeue();
-                foreach (var neighbor in adjacency[current])
+                if (adjacency.ContainsKey(conn.SourceNode) && adjacency.ContainsKey(conn.TargetNode))
                 {
-                    if (assigned.Add(neighbor))
-                    {
-                        component.Add(neighbor);
-                        queue.Enqueue(neighbor);
-                    }
+                    adjacency[conn.SourceNode].Add(conn.TargetNode);
+                    adjacency[conn.TargetNode].Add(conn.SourceNode);
                 }
             }
 
-            AddLayer(vm, component, layerIndex++);
+            foreach (var node in remaining)
+            {
+                if (!assigned.Add(node)) continue;
+
+                var component = new List<AnimGraphNode> { node };
+                var queue = new Queue<AnimGraphNode>();
+                queue.Enqueue(node);
+
+                while (queue.Count > 0)
+                {
+                    var current = queue.Dequeue();
+                    foreach (var neighbor in adjacency[current])
+                    {
+                        if (assigned.Add(neighbor))
+                        {
+                            component.Add(neighbor);
+                            queue.Enqueue(neighbor);
+                        }
+                    }
+                }
+
+                AddLayer(vm, component, layerIndex++);
+            }
         }
+
+        // Final enforcement: SaveCachedPose nodes can only exist in animation
+        // blueprint layers (layers that contain a _Root node). After all passes
+        // above, scan every non-_Root layer (state sub-graphs and fallback layers)
+        // and move any SaveCachedPose nodes to the primary _Root layer.
+        if (primaryGraphLayer != null)
+        {
+            EnforceSaveCachedPoseInAnimBlueprintLayer(vm, primaryGraphLayer);
+        }
+    }
+
+    /// <summary>
+    /// Ensures every SaveCachedPose node resides in an animation blueprint layer
+    /// (one that contains a _Root node). Any SaveCachedPose found in a state
+    /// sub-graph or a fallback connected-component layer is moved to
+    /// <paramref name="targetLayer"/> and the affected layers are rebuilt.
+    /// </summary>
+    private static void EnforceSaveCachedPoseInAnimBlueprintLayer(
+        AnimGraphViewModel vm, AnimGraphLayer targetLayer)
+    {
+        var moved = false;
+
+        // Identify animation-blueprint layers (layers that contain a _Root node)
+        var animBlueprintLayers = new HashSet<AnimGraphLayer>();
+        foreach (var layer in vm.Layers)
+        {
+            if (layer.Nodes.Any(n => n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase)))
+                animBlueprintLayers.Add(layer);
+        }
+
+        // Scan non-animation-blueprint layers in vm.Layers
+        var affectedLayers = new HashSet<AnimGraphLayer>();
+        foreach (var layer in vm.Layers)
+        {
+            if (animBlueprintLayers.Contains(layer)) continue;
+            var toMove = layer.Nodes.Where(IsSaveCachedPoseNode).ToList();
+            if (toMove.Count == 0) continue;
+
+            foreach (var node in toMove)
+            {
+                layer.Nodes.Remove(node);
+                targetLayer.Nodes.Add(node);
+            }
+            affectedLayers.Add(layer);
+            moved = true;
+        }
+
+        // Scan state sub-graphs
+        foreach (var (_, layer) in vm.StateSubGraphs)
+        {
+            var toMove = layer.Nodes.Where(IsSaveCachedPoseNode).ToList();
+            if (toMove.Count == 0) continue;
+
+            foreach (var node in toMove)
+            {
+                layer.Nodes.Remove(node);
+                targetLayer.Nodes.Add(node);
+            }
+            affectedLayers.Add(layer);
+            moved = true;
+        }
+
+        if (!moved) return;
+
+        // Rebuild connections for the target layer and all affected source layers
+        RebuildLayerConnections(vm, targetLayer);
+        foreach (var layer in affectedLayers)
+            RebuildLayerConnections(vm, layer);
+    }
+
+    /// <summary>
+    /// Rebuilds a layer's connection list from vm.Connections based on which
+    /// nodes are currently in the layer, then re-runs layout.
+    /// </summary>
+    private static void RebuildLayerConnections(AnimGraphViewModel vm, AnimGraphLayer layer)
+    {
+        var nodeSet = new HashSet<AnimGraphNode>(layer.Nodes);
+        layer.Connections.Clear();
+        foreach (var conn in vm.Connections)
+        {
+            if (nodeSet.Contains(conn.SourceNode) && nodeSet.Contains(conn.TargetNode))
+                layer.Connections.Add(conn);
+        }
+        LayoutLayerNodes(layer);
     }
 
     /// <summary>

From 87cb948dfb273cf0343259099ef54ec7776726d8 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 06:07:49 +0000
Subject: [PATCH 48/52] Fix SaveCachedPose to be placed in correct ancestor
 _Root layer
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Instead of always placing SaveCachedPose in the primary (first) _Root
layer, trace downstream UseCachedPose consumers through the state
machine hierarchy (BelongsToStateMachine → StateMachineName) to find
the correct ancestor animation blueprint layer.

For example, a SaveCachedPose used by UseCachedPose in
AnimGraph > BaseLayer > LocomotionStates > IdleState is now correctly
placed in BaseLayer (the _Root layer containing LocomotionStates)
instead of AnimGraph.

- Add FindOwnerRootLayer: traces SaveCachedPose downstream consumers
  to find the correct _Root layer
- Add GetAncestorRootLayer: walks up the layer hierarchy via
  BelongsToStateMachine → StateMachineName chain
- Add BuildLayerLookups/LayerLookups: pre-computed lookup maps for
  efficient multi-node queries
- Update EnforceSaveCachedPoseInRootLayers to use smart layer detection

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 178 ++++++++++++++++++------
 1 file changed, 139 insertions(+), 39 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index c449f2ab..aa69ecb9 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -231,9 +231,10 @@ public class AnimGraphViewModel
             AddStateSubGraph(vm, layerNodes, stateResultNode.Name, layerIndex++);
         }
 
-        // Pass 3: Catch any still-unassigned SaveCachedPose nodes and their input
-        // chains, adding them to the primary AnimGraph layer before the fallback
-        // handles remaining nodes.
+        // Pass 3: Assign unassigned SaveCachedPose nodes to their correct _Root layer.
+        // SaveCachedPose can only exist in animation blueprint layers (defined by _Root nodes).
+        // Determine the correct _Root layer by tracing downstream UseCachedPose consumers
+        // back through the state machine hierarchy to their parent animation blueprint layer.
         if (primaryGraphLayer != null)
         {
             var unassignedSavePoseNodes = vm.Nodes
@@ -242,14 +243,20 @@ public class AnimGraphViewModel
 
             if (unassignedSavePoseNodes.Count > 0)
             {
+                var lookups = BuildLayerLookups(vm);
+                var affectedLayers = new HashSet<AnimGraphLayer>();
+
                 foreach (var saveNode in unassignedSavePoseNodes)
                 {
                     if (!assigned.Add(saveNode)) continue;
+                    var targetLayer = FindOwnerRootLayer(saveNode, vm, lookups) ?? primaryGraphLayer;
                     var inputChain = CollectUpstream(saveNode, upstreamOf, assigned);
-                    primaryGraphLayer.Nodes.AddRange(inputChain);
+                    targetLayer.Nodes.AddRange(inputChain);
+                    affectedLayers.Add(targetLayer);
                 }
 
-                RebuildLayerConnections(vm, primaryGraphLayer);
+                foreach (var layer in affectedLayers)
+                    RebuildLayerConnections(vm, layer);
             }
         }
 
@@ -298,24 +305,23 @@ public class AnimGraphViewModel
         // Final enforcement: SaveCachedPose nodes can only exist in animation
         // blueprint layers (layers that contain a _Root node). After all passes
         // above, scan every non-_Root layer (state sub-graphs and fallback layers)
-        // and move any SaveCachedPose nodes to the primary _Root layer.
+        // and move any SaveCachedPose nodes to the correct _Root layer.
         if (primaryGraphLayer != null)
         {
-            EnforceSaveCachedPoseInAnimBlueprintLayer(vm, primaryGraphLayer);
+            EnforceSaveCachedPoseInRootLayers(vm, primaryGraphLayer);
         }
     }
 
     /// <summary>
     /// Ensures every SaveCachedPose node resides in an animation blueprint layer
     /// (one that contains a _Root node). Any SaveCachedPose found in a state
-    /// sub-graph or a fallback connected-component layer is moved to
-    /// <paramref name="targetLayer"/> and the affected layers are rebuilt.
+    /// sub-graph or a fallback connected-component layer is moved to the correct
+    /// _Root layer determined by tracing its UseCachedPose consumers.
+    /// Falls back to <paramref name="fallbackLayer"/> if no better target is found.
     /// </summary>
-    private static void EnforceSaveCachedPoseInAnimBlueprintLayer(
-        AnimGraphViewModel vm, AnimGraphLayer targetLayer)
+    private static void EnforceSaveCachedPoseInRootLayers(
+        AnimGraphViewModel vm, AnimGraphLayer fallbackLayer)
     {
-        var moved = false;
-
         // Identify animation-blueprint layers (layers that contain a _Root node)
         var animBlueprintLayers = new HashSet<AnimGraphLayer>();
         foreach (var layer in vm.Layers)
@@ -324,46 +330,140 @@ public class AnimGraphViewModel
                 animBlueprintLayers.Add(layer);
         }
 
-        // Scan non-animation-blueprint layers in vm.Layers
-        var affectedLayers = new HashSet<AnimGraphLayer>();
+        // Collect SaveCachedPose nodes from non-_Root layers and state sub-graphs
+        var moves = new List<(AnimGraphNode node, AnimGraphLayer sourceLayer)>();
+
         foreach (var layer in vm.Layers)
         {
             if (animBlueprintLayers.Contains(layer)) continue;
-            var toMove = layer.Nodes.Where(IsSaveCachedPoseNode).ToList();
-            if (toMove.Count == 0) continue;
-
-            foreach (var node in toMove)
-            {
-                layer.Nodes.Remove(node);
-                targetLayer.Nodes.Add(node);
-            }
-            affectedLayers.Add(layer);
-            moved = true;
+            foreach (var node in layer.Nodes.Where(IsSaveCachedPoseNode).ToList())
+                moves.Add((node, layer));
         }
 
-        // Scan state sub-graphs
         foreach (var (_, layer) in vm.StateSubGraphs)
         {
-            var toMove = layer.Nodes.Where(IsSaveCachedPoseNode).ToList();
-            if (toMove.Count == 0) continue;
-
-            foreach (var node in toMove)
-            {
-                layer.Nodes.Remove(node);
-                targetLayer.Nodes.Add(node);
-            }
-            affectedLayers.Add(layer);
-            moved = true;
+            foreach (var node in layer.Nodes.Where(IsSaveCachedPoseNode).ToList())
+                moves.Add((node, layer));
         }
 
-        if (!moved) return;
+        if (moves.Count == 0) return;
+
+        var lookups = BuildLayerLookups(vm);
+        var affectedLayers = new HashSet<AnimGraphLayer>();
+        foreach (var (node, sourceLayer) in moves)
+        {
+            var targetLayer = FindOwnerRootLayer(node, vm, lookups) ?? fallbackLayer;
+            sourceLayer.Nodes.Remove(node);
+            targetLayer.Nodes.Add(node);
+            affectedLayers.Add(sourceLayer);
+            affectedLayers.Add(targetLayer);
+        }
 
-        // Rebuild connections for the target layer and all affected source layers
-        RebuildLayerConnections(vm, targetLayer);
         foreach (var layer in affectedLayers)
             RebuildLayerConnections(vm, layer);
     }
 
+    /// <summary>
+    /// Pre-computed lookup maps for layer hierarchy traversal.
+    /// </summary>
+    private readonly struct LayerLookups(
+        Dictionary<AnimGraphNode, AnimGraphLayer> nodeToLayer,
+        Dictionary<string, AnimGraphLayer> machineToLayer)
+    {
+        public Dictionary<AnimGraphNode, AnimGraphLayer> NodeToLayer { get; } = nodeToLayer;
+        public Dictionary<string, AnimGraphLayer> MachineToLayer { get; } = machineToLayer;
+    }
+
+    /// <summary>
+    /// Builds the lookup maps needed by <see cref="FindOwnerRootLayer"/> and
+    /// <see cref="GetAncestorRootLayer"/>. Call once and reuse for multiple queries.
+    /// </summary>
+    private static LayerLookups BuildLayerLookups(AnimGraphViewModel vm)
+    {
+        var nodeToLayer = new Dictionary<AnimGraphNode, AnimGraphLayer>();
+        foreach (var layer in vm.Layers)
+            foreach (var node in layer.Nodes)
+                nodeToLayer.TryAdd(node, layer);
+        foreach (var (_, subGraph) in vm.StateSubGraphs)
+            foreach (var node in subGraph.Nodes)
+                nodeToLayer.TryAdd(node, subGraph);
+
+        var machineToLayer = new Dictionary<string, AnimGraphLayer>(StringComparer.OrdinalIgnoreCase);
+        foreach (var layer in vm.Layers)
+            foreach (var node in layer.Nodes)
+                if (node.AdditionalProperties.TryGetValue("StateMachineName", out var mn))
+                    machineToLayer.TryAdd(mn, layer);
+        foreach (var (_, subGraph) in vm.StateSubGraphs)
+            foreach (var node in subGraph.Nodes)
+                if (node.AdditionalProperties.TryGetValue("StateMachineName", out var mn))
+                    machineToLayer.TryAdd(mn, subGraph);
+
+        return new LayerLookups(nodeToLayer, machineToLayer);
+    }
+
+    /// <summary>
+    /// Finds the correct animation blueprint layer (_Root layer) for a SaveCachedPose node
+    /// by tracing its downstream UseCachedPose consumers through the state machine
+    /// hierarchy to find the parent animation blueprint layer.
+    /// Returns null if no suitable layer is found.
+    /// </summary>
+    private static AnimGraphLayer? FindOwnerRootLayer(
+        AnimGraphNode saveNode, AnimGraphViewModel vm, LayerLookups lookups)
+    {
+        // Find downstream consumers (UseCachedPose nodes referencing this SaveCachedPose)
+        // Trace each consumer up to find the ancestor _Root layer
+        foreach (var conn in vm.Connections)
+        {
+            if (conn.SourceNode != saveNode) continue;
+
+            if (!lookups.NodeToLayer.TryGetValue(conn.TargetNode, out var consumerLayer))
+                continue;
+
+            var rootLayer = GetAncestorRootLayer(consumerLayer, lookups.MachineToLayer);
+            if (rootLayer != null)
+                return rootLayer;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Walks up the layer hierarchy to find the nearest ancestor animation blueprint
+    /// layer (one containing a _Root node). For state sub-graphs, traces through the
+    /// BelongsToStateMachine → StateMachineName chain to find the parent layer.
+    /// </summary>
+    private static AnimGraphLayer? GetAncestorRootLayer(
+        AnimGraphLayer layer,
+        Dictionary<string, AnimGraphLayer> machineToLayer)
+    {
+        var visited = new HashSet<AnimGraphLayer>();
+        var current = layer;
+
+        while (current != null && visited.Add(current))
+        {
+            // If this layer contains a _Root node, it's an animation blueprint layer
+            if (current.Nodes.Any(n => n.ExportType.EndsWith("_Root", StringComparison.OrdinalIgnoreCase)))
+                return current;
+
+            // Find the state machine this sub-graph belongs to
+            string? smName = null;
+            foreach (var node in current.Nodes)
+            {
+                if (node.AdditionalProperties.TryGetValue("BelongsToStateMachine", out var val) &&
+                    !string.IsNullOrEmpty(val))
+                {
+                    smName = val;
+                    break;
+                }
+            }
+
+            if (string.IsNullOrEmpty(smName) || !machineToLayer.TryGetValue(smName, out current))
+                break;
+        }
+
+        return null;
+    }
+
     /// <summary>
     /// Rebuilds a layer's connection list from vm.Connections based on which
     /// nodes are currently in the layer, then re-runs layout.

From cc03da7bb1cc26c7ecf9813591288ba65e64f6c0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 06:52:35 +0000
Subject: [PATCH 49/52] Fix SaveCachedPose chaining: exclude other
 SaveCachedPose from upstream collection in Pass 3

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index aa69ecb9..c1438ad8 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -235,6 +235,8 @@ public class AnimGraphViewModel
         // SaveCachedPose can only exist in animation blueprint layers (defined by _Root nodes).
         // Determine the correct _Root layer by tracing downstream UseCachedPose consumers
         // back through the state machine hierarchy to their parent animation blueprint layer.
+        // Each SaveCachedPose's upstream chain excludes other SaveCachedPose nodes so that
+        // chained SaveCachedPose → UseCachedPose → SaveCachedPose are independently placed.
         if (primaryGraphLayer != null)
         {
             var unassignedSavePoseNodes = vm.Nodes
@@ -250,7 +252,8 @@ public class AnimGraphViewModel
                 {
                     if (!assigned.Add(saveNode)) continue;
                     var targetLayer = FindOwnerRootLayer(saveNode, vm, lookups) ?? primaryGraphLayer;
-                    var inputChain = CollectUpstream(saveNode, upstreamOf, assigned);
+                    var inputChain = CollectUpstream(saveNode, upstreamOf, assigned,
+                        excludeNode: IsSaveCachedPoseNode);
                     targetLayer.Nodes.AddRange(inputChain);
                     affectedLayers.Add(targetLayer);
                 }

From 6fe04442dd263f91bc7700b37352cbbc5e447fe8 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 07:57:38 +0000
Subject: [PATCH 50/52] Fix SaveCachedPose placement: use common ancestor for
 multi-consumer cases and outermost AnimGraph layer for fallback

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 37 +++++++++++++++++++------
 1 file changed, 28 insertions(+), 9 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index c1438ad8..e9e2a70d 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -215,6 +215,12 @@ public class AnimGraphViewModel
             primaryGraphLayer ??= vm.Layers[^1];
         }
 
+        // Determine the outermost animation blueprint layer for fallback.
+        // In UE, the outermost layer is always named "AnimGraph".
+        // If found, use it; otherwise fall back to the first _Root layer.
+        var outermostGraphLayer = vm.Layers.FirstOrDefault(l =>
+            l.Name.Equals("AnimGraph", StringComparison.OrdinalIgnoreCase)) ?? primaryGraphLayer;
+
         // Pass 2: Build state machine state sub-graphs from AnimGraphNode_StateResult nodes.
         // Each _StateResult node defines a state's sub-graph within a state machine.
         // These are stored in StateSubGraphs keyed by the root node's property name.
@@ -237,7 +243,7 @@ public class AnimGraphViewModel
         // back through the state machine hierarchy to their parent animation blueprint layer.
         // Each SaveCachedPose's upstream chain excludes other SaveCachedPose nodes so that
         // chained SaveCachedPose → UseCachedPose → SaveCachedPose are independently placed.
-        if (primaryGraphLayer != null)
+        if (outermostGraphLayer != null)
         {
             var unassignedSavePoseNodes = vm.Nodes
                 .Where(n => !assigned.Contains(n) && IsSaveCachedPoseNode(n))
@@ -251,7 +257,7 @@ public class AnimGraphViewModel
                 foreach (var saveNode in unassignedSavePoseNodes)
                 {
                     if (!assigned.Add(saveNode)) continue;
-                    var targetLayer = FindOwnerRootLayer(saveNode, vm, lookups) ?? primaryGraphLayer;
+                    var targetLayer = FindOwnerRootLayer(saveNode, vm, lookups) ?? outermostGraphLayer;
                     var inputChain = CollectUpstream(saveNode, upstreamOf, assigned,
                         excludeNode: IsSaveCachedPoseNode);
                     targetLayer.Nodes.AddRange(inputChain);
@@ -309,9 +315,9 @@ public class AnimGraphViewModel
         // blueprint layers (layers that contain a _Root node). After all passes
         // above, scan every non-_Root layer (state sub-graphs and fallback layers)
         // and move any SaveCachedPose nodes to the correct _Root layer.
-        if (primaryGraphLayer != null)
+        if (outermostGraphLayer != null)
         {
-            EnforceSaveCachedPoseInRootLayers(vm, primaryGraphLayer);
+            EnforceSaveCachedPoseInRootLayers(vm, outermostGraphLayer);
         }
     }
 
@@ -406,15 +412,17 @@ public class AnimGraphViewModel
 
     /// <summary>
     /// Finds the correct animation blueprint layer (_Root layer) for a SaveCachedPose node
-    /// by tracing its downstream UseCachedPose consumers through the state machine
-    /// hierarchy to find the parent animation blueprint layer.
+    /// by tracing ALL downstream UseCachedPose consumers through the state machine
+    /// hierarchy to find each consumer's ancestor _Root layer. If all consumers trace
+    /// to the same _Root layer, that layer is used. If consumers span different _Root
+    /// layers, the SaveCachedPose must be placed in the outermost layer (AnimGraph).
     /// Returns null if no suitable layer is found.
     /// </summary>
     private static AnimGraphLayer? FindOwnerRootLayer(
         AnimGraphNode saveNode, AnimGraphViewModel vm, LayerLookups lookups)
     {
-        // Find downstream consumers (UseCachedPose nodes referencing this SaveCachedPose)
-        // Trace each consumer up to find the ancestor _Root layer
+        // Collect ancestor _Root layers from ALL consumers
+        var consumerRootLayers = new HashSet<AnimGraphLayer>();
         foreach (var conn in vm.Connections)
         {
             if (conn.SourceNode != saveNode) continue;
@@ -424,9 +432,20 @@ public class AnimGraphViewModel
 
             var rootLayer = GetAncestorRootLayer(consumerLayer, lookups.MachineToLayer);
             if (rootLayer != null)
-                return rootLayer;
+                consumerRootLayers.Add(rootLayer);
         }
 
+        if (consumerRootLayers.Count == 0)
+            return null;
+
+        // If all consumers trace to the same _Root layer, use it
+        if (consumerRootLayers.Count == 1)
+            return consumerRootLayers.First();
+
+        // Consumers span different _Root layers: the SaveCachedPose must be placed
+        // in the outermost animation blueprint layer (AnimGraph) since it needs to
+        // be accessible from all consumer layers. Return null to trigger fallback
+        // to the outermost layer.
         return null;
     }
 

From 933bfa0ec0c5a45ac378803cc6df217847381d8b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 08:23:09 +0000
Subject: [PATCH 51/52] Fix incorrect layer for chained
 SaveCachedPose/UseCachedPose dependencies

When sequential Save/Use dependencies exist (e.g., UseCachedPose(A)->
SaveCachedPose(B)->UseCachedPose(B)->SaveCachedPose(C)), the stale
BuildLayerLookups built once before the loop caused FindOwnerRootLayer
to miss consumers assigned during earlier iterations.

The fix iteratively processes SaveCachedPose nodes: each pass rebuilds
lookups and resolves nodes whose consumers are already placed, deferring
nodes with unresolved consumers. A maxPasses guard prevents infinite loops.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/ViewModels/AnimGraphViewModel.cs | 63 ++++++++++++++++++++++---
 1 file changed, 56 insertions(+), 7 deletions(-)

diff --git a/FModel/ViewModels/AnimGraphViewModel.cs b/FModel/ViewModels/AnimGraphViewModel.cs
index e9e2a70d..f535aa70 100644
--- a/FModel/ViewModels/AnimGraphViewModel.cs
+++ b/FModel/ViewModels/AnimGraphViewModel.cs
@@ -243,25 +243,74 @@ public class AnimGraphViewModel
         // back through the state machine hierarchy to their parent animation blueprint layer.
         // Each SaveCachedPose's upstream chain excludes other SaveCachedPose nodes so that
         // chained SaveCachedPose → UseCachedPose → SaveCachedPose are independently placed.
+        //
+        // When chains exist (e.g. UseCachedPose(A) → … → SaveCachedPose(B) →
+        // UseCachedPose(B) → … → SaveCachedPose(C)), the UseCachedPose consumers of
+        // upstream SaveCachedPose nodes may only appear in a layer after the downstream
+        // SaveCachedPose is processed. We therefore iterate: each pass rebuilds lookups
+        // and resolves nodes whose consumers are already placed, deferring the rest.
         if (outermostGraphLayer != null)
         {
-            var unassignedSavePoseNodes = vm.Nodes
+            var pending = vm.Nodes
                 .Where(n => !assigned.Contains(n) && IsSaveCachedPoseNode(n))
                 .ToList();
 
-            if (unassignedSavePoseNodes.Count > 0)
+            if (pending.Count > 0)
             {
-                var lookups = BuildLayerLookups(vm);
                 var affectedLayers = new HashSet<AnimGraphLayer>();
 
-                foreach (var saveNode in unassignedSavePoseNodes)
+                bool madeProgress;
+                var maxPasses = pending.Count;
+                do
+                {
+                    madeProgress = false;
+                    var lookups = BuildLayerLookups(vm);
+
+                    for (var i = pending.Count - 1; i >= 0; i--)
+                    {
+                        var saveNode = pending[i];
+                        var targetLayer = FindOwnerRootLayer(saveNode, vm, lookups);
+
+                        // If no layer was found, check whether the failure is because
+                        // some consumer nodes are not yet in any layer (deferred
+                        // dependency). If so, skip this node and retry next pass.
+                        if (targetLayer == null)
+                        {
+                            var hasDeferredConsumer = false;
+                            foreach (var conn in vm.Connections)
+                            {
+                                if (conn.SourceNode == saveNode &&
+                                    !lookups.NodeToLayer.ContainsKey(conn.TargetNode))
+                                {
+                                    hasDeferredConsumer = true;
+                                    break;
+                                }
+                            }
+
+                            if (hasDeferredConsumer)
+                                continue;
+
+                            targetLayer = outermostGraphLayer;
+                        }
+
+                        assigned.Add(saveNode);
+                        var inputChain = CollectUpstream(saveNode, upstreamOf, assigned,
+                            excludeNode: IsSaveCachedPoseNode);
+                        targetLayer.Nodes.AddRange(inputChain);
+                        affectedLayers.Add(targetLayer);
+                        pending.RemoveAt(i);
+                        madeProgress = true;
+                    }
+                } while (madeProgress && pending.Count > 0 && --maxPasses > 0);
+
+                // Fallback: remaining nodes (circular deps or truly unresolvable)
+                foreach (var saveNode in pending)
                 {
                     if (!assigned.Add(saveNode)) continue;
-                    var targetLayer = FindOwnerRootLayer(saveNode, vm, lookups) ?? outermostGraphLayer;
                     var inputChain = CollectUpstream(saveNode, upstreamOf, assigned,
                         excludeNode: IsSaveCachedPoseNode);
-                    targetLayer.Nodes.AddRange(inputChain);
-                    affectedLayers.Add(targetLayer);
+                    outermostGraphLayer.Nodes.AddRange(inputChain);
+                    affectedLayers.Add(outermostGraphLayer);
                 }
 
                 foreach (var layer in affectedLayers)

From faea101c9bcc93486be3093079134a00a00df9e7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 08:47:00 +0000
Subject: [PATCH 52/52] Center SaveCachedPose node in view when navigating from
 UseCachedPose

When double-clicking a UseCachedPose node to jump to the SaveCachedPose
node's tab, the view now centers on the target node. Added CenterOnNode
helper that adjusts TranslateTransform to place the node at the viewport
center while preserving the current zoom level.

Co-authored-by: LoogLong <86428208+LoogLong@users.noreply.github.com>
---
 FModel/Views/AnimGraphViewer.xaml.cs | 36 +++++++++++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

diff --git a/FModel/Views/AnimGraphViewer.xaml.cs b/FModel/Views/AnimGraphViewer.xaml.cs
index 471f90a9..677b7aa4 100644
--- a/FModel/Views/AnimGraphViewer.xaml.cs
+++ b/FModel/Views/AnimGraphViewer.xaml.cs
@@ -810,7 +810,7 @@ public partial class AnimGraphViewer
         else
             AddLayerTab(targetLayer);
 
-        // Select and highlight the SaveCachedPose node in the target layer.
+        // Select, highlight, and center the SaveCachedPose node in the target layer.
         // Use Dispatcher.BeginInvoke to ensure the visual tree is fully updated
         // after the tab switch before attempting to select the node.
         Dispatcher.BeginInvoke(() =>
@@ -819,6 +819,7 @@ public partial class AnimGraphViewer
                 state.NodeVisuals.TryGetValue(savePoseNode, out var visual))
             {
                 SelectNode(savePoseNode, visual.border);
+                CenterOnNode(savePoseNode, state);
             }
         });
     }
@@ -1504,6 +1505,39 @@ public partial class AnimGraphViewer
         ZoomText.Text = "Zoom: 100%";
     }
 
+    /// <summary>
+    /// Adjusts the translate transform so that the specified node is centered
+    /// in the viewport, keeping the current zoom level unchanged.
+    /// </summary>
+    private void CenterOnNode(AnimGraphNode node, LayerCanvasState state)
+    {
+        if (!state.NodePositions.TryGetValue(node, out var pos))
+            return;
+
+        var scale = state.ScaleTransform.ScaleX;
+
+        // Determine node dimensions
+        double nodeW = NodeWidth, nodeH = 150;
+        if (state.NodeVisuals.TryGetValue(node, out var vis))
+        {
+            nodeW = vis.width;
+            nodeH = vis.height;
+        }
+
+        // Viewport size
+        var tabContent = LayerTabControl.SelectedContent as FrameworkElement;
+        var viewWidth = tabContent?.ActualWidth > 0 ? tabContent.ActualWidth : (ActualWidth > 0 ? ActualWidth * DefaultGraphWidthRatio : 800);
+        var viewHeight = tabContent?.ActualHeight > 0 ? tabContent.ActualHeight : (ActualHeight > 0 ? ActualHeight - 120 : 600);
+
+        // Center of the node in graph space
+        var nodeCenterX = pos.X + nodeW / 2;
+        var nodeCenterY = pos.Y + nodeH / 2;
+
+        // Set translate so that the node center maps to the viewport center
+        state.TranslateTransform.X = viewWidth / 2 - nodeCenterX * scale;
+        state.TranslateTransform.Y = viewHeight / 2 - nodeCenterY * scale;
+    }
+
     /// <summary>
     /// Holds per-layer canvas state (positions, visuals, transforms).
     /// </summary>