new blueprint actor

Author: 4sval

Snooper/Core/Containers/Resources/IndirectResources.cs

@@ -99,7 +99,7 @@ public ResourcesMetadata Add(PrimitiveComponent<TVertex, TInstanceData, TPerMate
             drawAllocations[i] = new DrawBufferAllocation(buffer.Add(command, draw, new PerDrawCulled(geometryHandle, section)), bufferType, section.MaterialIndex);
         }
 
-        component.MarkClean(DirtyFlags.All);
+        component.MarkClean(DirtyFlags.InstanceData | DirtyFlags.Visibility | DirtyFlags.Opacity | DirtyFlags.Outline | DirtyFlags.ManualLodSwap);
         return new ResourcesMetadata(geometryHandle, instanceAllocation, materialAllocation, drawAllocations);
     }
 

Snooper/Rendering/Actors/BlueprintActor.cs

@@ -1,4 +1,5 @@
-using CUE4Parse.UE4.Assets;
+using CUE4Parse.UE4.Assets.Exports;
+using CUE4Parse.UE4.Assets.Exports.Component;
 using CUE4Parse.UE4.Assets.Exports.Engine;
 using CUE4Parse.UE4.Objects.Core.Misc;
 using CUE4Parse.UE4.Objects.Engine;
@@ -10,100 +11,305 @@ namespace Snooper.Rendering.Actors;
 
 public class BlueprintActor : UnrealActor
 {
-    public BlueprintActor(UBlueprintGeneratedClass blueprint) : base(blueprint)
+    private const int MaxChildActorDepth = 8;
+
+    public BlueprintActor(UBlueprintGeneratedClass blueprint) : this(blueprint, [], 0)
     {
-        var bps = new List<UBlueprintGeneratedClass>();
-        var current = blueprint;
-        while (current != null)
+
+    }
+
+    private BlueprintActor(UBlueprintGeneratedClass blueprint, HashSet<string> ancestry, int depth) : base(blueprint)
+    {
+        _ancestry = ancestry;
+        _depth = depth;
+        _classKey = blueprint.GetPathName();
+
+        var chain = CollectClassChain(blueprint);
+        var deferred = BuildNativeComponents(chain);
+        BuildOverrideTable(chain);
+        ExecuteConstructionScripts(chain);
+
+        // non-scene native components (movement, audio, ...) carry no transform, so they must never become the root
+        foreach (var component in deferred)
         {
-            bps.Add(current);
-            if (current.Owner is { } pkg)
-                _blueprintPackages.Add(pkg);
+            Components.Add(component);
+        }
+
+        _nativeByName.Clear();
+        _byTemplatePtr.Clear();
+        _scsByVariable.Clear();
+        _scsByName.Clear();
+        _visitedNodes.Clear();
+        _overridesByGuid.Clear();
+        _overridesByKey.Clear();
+    }
+
+    public override string Icon => Settings.ClipboardListIcon;
 
-            current = current.Super?.Load<UBlueprintGeneratedClass>();
+    private readonly HashSet<string> _ancestry;
+    private readonly int _depth;
+    private readonly string _classKey;
+
+    private readonly Dictionary<string, SpatialComponent> _nativeByName = new(StringComparer.Ordinal);
+    private readonly Dictionary<FPackageIndex, SpatialComponent> _byTemplatePtr = [];
+    private readonly Dictionary<(string OwnerClass, string Variable), SpatialComponent> _scsByVariable = [];
+    private readonly Dictionary<string, SpatialComponent> _scsByName = new(StringComparer.Ordinal);
+    private readonly HashSet<FPackageIndex> _visitedNodes = [];
+    private readonly Dictionary<FGuid, FPackageIndex> _overridesByGuid = [];
+    private readonly Dictionary<(string OwnerClass, string Variable), FPackageIndex> _overridesByKey = [];
+
+    private List<UBlueprintGeneratedClass> CollectClassChain(UBlueprintGeneratedClass blueprint)
+    {
+        var chain = new List<UBlueprintGeneratedClass>();
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+
+        var current = blueprint;
+        while (current != null && seen.Add(current.GetPathName()))
+        {
+            chain.Add(current);
+            current = current.SuperStruct is { IsNull: false } super && super.TryLoad<UBlueprintGeneratedClass>(out var parent) ? parent : null;
         }
-        bps.Reverse();
 
-        foreach (var bp in bps)
+        return chain;
+    }
+
+    private List<SpatialComponent> BuildNativeComponents(List<UBlueprintGeneratedClass> chain)
+    {
+        // collect default subobjects of every class default object in the chain, the most-derived export of a given name wins
+        var subobjects = new Dictionary<string, FPackageIndex>(StringComparer.Ordinal);
+        UObject? mostDerivedCdo = null;
+        foreach (var bp in chain)
         {
-            var handler = bp.InheritableComponentHandler?.Load<UInheritableComponentHandler>();
-            if (handler == null) continue;
+            var cdoPtr = bp.ClassDefaultObject;
+            if (cdoPtr is not { IsNull: false } || cdoPtr.ResolvedObject is not { ExportIndex: >= 0 } cdo) continue;
 
-            foreach (var record in handler.Records)
+            mostDerivedCdo ??= cdoPtr.Load();
+
+            var package = cdo.Package;
+            for (var i = 0; i < package.ExportMapLength; i++)
             {
-                if (record.ComponentTemplate == null || record.ComponentTemplate.IsNull) continue;
-                _overrides[record.ComponentKey.AssociatedGuid] = record.ComponentTemplate;
+                var ptr = new FPackageIndex(package, i + 1);
+                var resolved = package.ResolvePackageIndex(ptr);
+                if (resolved?.Outer is not { } outer || outer.ExportIndex != cdo.ExportIndex || !ReferenceEquals(outer.Package, package)) continue;
+
+                subobjects.TryAdd(resolved.Name.Text, ptr);
             }
         }
 
-        var candidates = new HashSet<FPackageIndex?>();
-        foreach (var bp in bps)
+        var created = new List<(ComponentPair Pair, bool IsScene)>();
+        foreach (var (name, ptr) in subobjects)
         {
-            var script = bp.SimpleConstructionScript?.Load<USimpleConstructionScript>();
-            if (script == null) continue;
+            if (!ptr.TryLoad<UActorComponent>(out var actorComponent)) continue;
+
+            var pair = CreateComponentPair(ptr);
+            pair.Component.Name = name;
+            created.Add((pair, actorComponent is USceneComponent));
 
-            candidates.Add(script.DefaultSceneRootNode);
-            candidates.UnionWith(script.RootNodes);
+            _nativeByName[name] = pair.Component;
+            _byTemplatePtr[ptr] = pair.Component;
         }
 
-        foreach (var candidate in candidates)
+        // the attach parent pointer may target an ancestor package's export of the same subobject, so resolve it by name
+        foreach (var (pair, _) in created)
         {
-            if (candidate?.TryLoad<USCS_Node>(out var node) == true)
+            if (pair.ParentPtr is { IsNull: false } parentPtr && _nativeByName.TryGetValue(parentPtr.Name, out var parent) && parent != pair.Component)
             {
-                ProcessNode(node);
+                pair.Component.Relation = parent;
             }
         }
 
-        _overrides.Clear();
-        _blueprintPackages.Clear();
+        SpatialComponent? root = null;
+        if (mostDerivedCdo?.GetOrDefault<FPackageIndex?>("RootComponent") is { IsNull: false } rootPtr)
+        {
+            _nativeByName.TryGetValue(rootPtr.Name, out root);
+        }
+        root ??= created.FirstOrDefault(c => c.IsScene && c.Pair.Component.Relation is null).Pair.Component;
+
+        // the first spatial component added becomes the actor's root
+        var deferred = new List<SpatialComponent>();
+        if (root != null) Components.Add(root);
+        foreach (var (pair, isScene) in created)
+        {
+            if (pair.Component == root) continue;
+            if (isScene) Components.Add(pair.Component);
+            else deferred.Add(pair.Component);
+        }
+        return deferred;
     }
 
-    private readonly Dictionary<FGuid, FPackageIndex> _overrides = [];
-    private readonly List<IPackage> _blueprintPackages = [];
+    private void BuildOverrideTable(List<UBlueprintGeneratedClass> chain)
+    {
+        // base first so that the most-derived override wins
+        for (var i = chain.Count - 1; i >= 0; i--)
+        {
+            var handler = chain[i].InheritableComponentHandler?.Load<UInheritableComponentHandler>();
+            if (handler == null) continue;
+
+            foreach (var record in handler.Records)
+            {
+                if (record.ComponentTemplate is not { IsNull: false } template) continue;
+
+                var key = record.ComponentKey;
+                if (key.AssociatedGuid.IsValid())
+                {
+                    _overridesByGuid[key.AssociatedGuid] = template;
+                }
+
+                var ownerName = key.OwnerClass?.Name;
+                if (ownerName != null && key.SCSVariableName is { IsNone: false } variable)
+                {
+                    _overridesByKey[(ownerName, variable.Text)] = template;
+                }
+            }
+        }
+    }
 
-    private void ProcessNode(USCS_Node node, SpatialComponent? parent = null)
+    private void ExecuteConstructionScripts(List<UBlueprintGeneratedClass> chain)
     {
-        _overrides.TryGetValue(node.VariableGuid, out var templateOverride);
+        for (var i = chain.Count - 1; i >= 0; i--)
+        {
+            var owner = chain[i];
+            var script = owner.SimpleConstructionScript?.Load<USimpleConstructionScript>();
+            if (script == null) continue;
 
-        var template = templateOverride ?? node.ComponentTemplate;
-        if (template == null || template.IsNull)
+            var processedAny = false;
+            foreach (var nodePtr in script.RootNodes)
+            {
+                if (nodePtr is not { IsNull: false }) continue;
+
+                processedAny = true;
+                ProcessNode(nodePtr, owner, null);
+            }
+
+            // the default scene root only exists when nothing else can be the root
+            if (!processedAny && RootComponent is null && script.DefaultSceneRootNode is { IsNull: false } defaultRoot)
+            {
+                ProcessNode(defaultRoot, owner, null);
+            }
+        }
+    }
+
+    private void ProcessNode(FPackageIndex nodePtr, UBlueprintGeneratedClass owner, SpatialComponent? parentFromRecursion)
+    {
+        if (!_visitedNodes.Add(nodePtr) || !nodePtr.TryLoad<USCS_Node>(out var node)) return;
+
+        var variableName = node.InternalVariableName.Text;
+        var template = ResolveTemplate(node, owner.Name, variableName);
+        if (template is not { IsNull: false })
         {
-            Log.Warning("Node {NodeName} has no component template, skipping.", node.InternalVariableName.Text);
+            Log.Warning("Node {NodeName} has no component template, skipping", variableName);
+            foreach (var childPtr in node.ChildNodes)
+            {
+                if (childPtr is { IsNull: false }) ProcessNode(childPtr, owner, parentFromRecursion);
+            }
             return;
         }
 
-        var component = CreateComponentPair(template).Component;
-        component.AttachSocketName = node.GetOrDefault<FName?>("AttachToName")?.Text;
-        if (node.GetOrDefault<FName?>("InternalVariableName") is { } internalVariableName)
+        if (!_byTemplatePtr.TryGetValue(template, out var component))
         {
-            component.Name = internalVariableName.Text;
+            var pair = CreateComponentPair(template);
+            component = pair.Component;
+            component.Name = variableName;
+
+            if (node.GetOrDefault<FName?>("AttachToName") is { IsNone: false } socket)
+            {
+                component.AttachSocketName = socket.Text;
+            }
+
+            var parent = ResolveNodeParent(node, parentFromRecursion);
+            var isScene = template.ResolvedObject?.Object?.Value is USceneComponent;
+            if (RootComponent is null && isScene && parent is null)
+            {
+                // becomes the root
+            }
+            else
+            {
+                var expected = parent ?? RootComponent;
+                component.Relation = expected;
+                if (expected != null && component.Relation != expected)
+                {
+                    Log.Warning("Node {NodeName} could not be attached to {Parent}", variableName, expected.Name);
+                }
+            }
+
+            Components.Add(component);
+
+            _byTemplatePtr[template] = component;
+            _scsByVariable[(owner.Name, variableName)] = component;
+            _scsByName.TryAdd(variableName, component);
+
+            if (template.ResolvedObject?.Object?.Value is UChildActorComponent childActorComponent)
+            {
+                TryCreateChildActor(childActorComponent, component);
+            }
         }
-        if (node.GetOrDefault<FName?>("ParentComponentOrVariableName") is { } parentComponentOrVariableName)
+
+        foreach (var childPtr in node.ChildNodes)
         {
-            parent = node.GetOrDefault("bIsParentComponentNative", false) ? LoadNativeComponent(parentComponentOrVariableName.Text) : Components.OfType<SpatialComponent>().FirstOrDefault(c => c.Name == parentComponentOrVariableName.Text);
+            if (childPtr is { IsNull: false }) ProcessNode(childPtr, owner, component);
         }
-        component.Relation = parent;
-        Components.Add(component);
+    }
+
+    private FPackageIndex? ResolveTemplate(USCS_Node node, string ownerName, string variableName)
+    {
+        if (node.VariableGuid.IsValid() && _overridesByGuid.TryGetValue(node.VariableGuid, out var byGuid))
+            return byGuid;
+        if (_overridesByKey.TryGetValue((ownerName, variableName), out var byKey))
+            return byKey;
+        return node.ComponentTemplate;
+    }
+
+    private SpatialComponent? ResolveNodeParent(USCS_Node node, SpatialComponent? parentFromRecursion)
+    {
+        if (node.GetOrDefault<FName?>("ParentComponentOrVariableName") is not { IsNone: false } parentName)
+            return parentFromRecursion;
 
-        foreach (var child in node.GetChildNodes())
+        var name = parentName.Text;
+        if (node.GetOrDefault("bIsParentComponentNative", false))
+        {
+            if (_nativeByName.TryGetValue(name, out var native)) return native;
+        }
+        else
         {
-            ProcessNode(child, component);
+            if (node.GetOrDefault<FName?>("ParentComponentOwnerClassName") is { IsNone: false } ownerClassName &&
+                _scsByVariable.TryGetValue((ownerClassName.Text, name), out var scoped))
+                return scoped;
+            if (_scsByName.TryGetValue(name, out var byName)) return byName;
+            if (_nativeByName.TryGetValue(name, out var native)) return native;
         }
+
+        Log.Warning("Node {NodeName} references unknown parent {Parent}, attaching to root", node.InternalVariableName.Text, name);
+        return null;
     }
 
-    private SpatialComponent? LoadNativeComponent(string name)
+    private void TryCreateChildActor(UChildActorComponent childActorComponent, SpatialComponent component)
     {
-        foreach (var package in _blueprintPackages)
+        if (_depth >= MaxChildActorDepth)
+        {
+            Log.Warning("Child actor depth limit reached at {Component}", component.Name);
+            return;
+        }
+
+        if (childActorComponent.GetOrDefault<FPackageIndex?>("ChildActorClass") is not { IsNull: false } classPtr ||
+            !classPtr.TryLoad<UBlueprintGeneratedClass>(out var childClass))
+            return;
+
+        var childKey = childClass.GetPathName();
+        if (childKey == _classKey || _ancestry.Contains(childKey))
         {
-            var exportIdx = package.GetExportIndex(name);
-            if (exportIdx < 0) continue;
+            Log.Warning("Child actor {Class} would recurse into itself, skipping", childClass.Name);
+            return;
+        }
 
-            var component = CreateComponentPair(new FPackageIndex(package, exportIdx + 1)).Component;
-            Components.Add(component);
-            return component;
+        var ancestry = new HashSet<string>(_ancestry, StringComparer.Ordinal) { _classKey };
+        var child = new BlueprintActor(childClass, ancestry, _depth + 1);
+        Children.Add(child);
+
+        // OnChildAdded parents the child to our root, re-target it to the spawning component
+        if (child.RootComponent is { } childRoot)
+        {
+            childRoot.Relation = component;
+            childRoot.SetLocalTransform(Transform.Identity);
         }
-        return null;
     }
-
-    public override string Icon => "\uf46d";
 }

Snooper/Rendering/Actors/MeshActor.cs

@@ -1,6 +1,6 @@
 using CUE4Parse.UE4.Assets.Exports.Animation;
+using CUE4Parse.UE4.Assets.Exports.Engine;
 using CUE4Parse.UE4.Assets.Exports.GeometryCollection;
-using CUE4Parse.UE4.Assets.Exports.SkeletalMesh;
 using CUE4Parse.UE4.Assets.Exports.StaticMesh;
 using Snooper.Rendering.Components.Mesh;
 using Snooper.Rendering.Components.Transforms;
@@ -19,9 +19,9 @@ public MeshActor(UGeometryCollection geometryCollection, Transform? transform =
         Components.Add(new GeometryCollectionComponent(geometryCollection, transform));
     }
 
-    public MeshActor(USkeletalMesh skeletalMesh, Transform? transform = null) : base(skeletalMesh)
+    public MeshActor(USkinnedAsset skinnedAsset, Transform? transform = null) : base(skinnedAsset)
     {
-        Components.Add(new SkeletalMeshComponent(skeletalMesh, transform));
+        Components.Add(new SkeletalMeshComponent(skinnedAsset, transform));
     }
 
     public MeshActor(UAnimationAsset animation, float playPosition = 0f, float playRate = 1f) : base(animation)