native created components

Snooper/Rendering/Actors/LevelActor.cs

@@ -17,11 +17,6 @@ public class LevelActor : UnrealActor
     public LevelActor(UObject actor) : base(actor)
     {
         EnqueuePointers(actor.GetOrDefault<FPackageIndex?>("RootComponent"));
-        EnqueuePointers(actor.GetOrDefault<FPackageIndex?[]>("InstanceComponents", []));
-        EnqueuePointers(actor.GetOrDefault<FPackageIndex?[]>("BlueprintCreatedComponents", []));
-        EnqueuePointers(actor.GetOrDefault<FPackageIndex?[]>("LandscapeComponents", []));
-        EnqueuePointers(actor.GetOrDefault<FPackageIndex?>("SplineComponent"));
-        EnqueuePointers(actor.GetOrDefault<FPackageIndex?>("CameraComponent"));
 
         if (actor is AInstancedFoliageActor { FoliageInfos: { } foliages })
         {
@@ -46,7 +41,7 @@ public LevelActor(UObject actor) : base(actor)
         actor.TryGetValue(out _additionalWorlds, "AdditionalWorlds");
     }
 
-    public void ProcessEnqueuedComponents(Dictionary<FPackageIndex, SpatialComponent> components, Dictionary<ResolvedObject, LevelActor> actors)
+    public void ProcessEnqueuedComponents(Dictionary<ResolvedObject, SpatialComponent> components, Dictionary<ResolvedObject, LevelActor> actors)
     {
         foreach (var ptr in _ptrs)
         {
@@ -63,9 +58,9 @@ public void ProcessEnqueuedComponents(Dictionary<FPackageIndex, SpatialComponent
         _additionalWorlds = null;
     }
 
-    private void CreateComponentRecursive(Dictionary<FPackageIndex, SpatialComponent> components, Dictionary<ResolvedObject, LevelActor> actors, FPackageIndex ptr)
+    private void CreateComponentRecursive(Dictionary<ResolvedObject, SpatialComponent> components, Dictionary<ResolvedObject, LevelActor> actors, FPackageIndex ptr)
     {
-        if (components.ContainsKey(ptr)) return;
+        if (ptr.ResolvedObject is not { } resolved || components.ContainsKey(resolved)) return;
 
         if (ptr.Load()?.Outer is { } outer && actors.TryGetValue(outer, out var owner) && owner != this)
         {
@@ -87,24 +82,24 @@ private void CreateComponentRecursive(Dictionary<FPackageIndex, SpatialComponent
             }
         }
 
-        if (pair.ParentPtr is { IsNull: false })
+        if (pair.ParentPtr is { ResolvedObject: { } parent })
         {
             CreateComponentRecursive(components, actors, pair.ParentPtr);
-            pair.Component.Relation = components[pair.ParentPtr];
+            pair.Component.Relation = components[parent];
         }
 
-        if (pair is { LeaderPtr: { IsNull: false } leaderPtr, Component: SkinnedMeshComponent skinned })
+        if (pair is { LeaderPtr: { ResolvedObject: { } leader } leaderPtr, Component: SkinnedMeshComponent skinned })
         {
             CreateComponentRecursive(components, actors, leaderPtr);
-            skinned.Leader = components[leaderPtr] as SkinnedMeshComponent;
+            skinned.Leader = components[leader] as SkinnedMeshComponent;
         }
 
-        components.TryAdd(ptr, pair.Component);
+        components.TryAdd(resolved, pair.Component);
         Components.Add(pair.Component);
     }
 
     private readonly HashSet<FPackageIndex> _ptrs = [];
-    private void EnqueuePointers(params FPackageIndex?[] ptrs)
+    internal void EnqueuePointers(params FPackageIndex?[] ptrs)
     {
         foreach (var ptr in ptrs)
         {

Snooper/Rendering/Actors/UnrealActor.cs

@@ -11,6 +11,7 @@
 using CUE4Parse.UE4.Assets.Exports.Component.StaticMesh;
 using CUE4Parse.UE4.Assets.Exports.Component.TextRender;
 using CUE4Parse.UE4.Assets.Exports.GeometryCollection;
+using CUE4Parse.UE4.Assets.Exports.Landscape;
 using CUE4Parse.UE4.Assets.Exports.SkeletalMesh;
 using CUE4Parse.UE4.Assets.Exports.StaticMesh;
 using CUE4Parse.UE4.Objects.UObject;
@@ -52,6 +53,7 @@ protected ComponentPair CreateComponentPair(FPackageIndex ptr)
                             UHierarchicalInstancedStaticMeshComponent hism => new HierarchicalInstancedStaticMeshComponent(mesh, hism),
                             UInstancedStaticMeshComponent ism => new InstancedStaticMeshComponent(mesh, ism),
                             USplineMeshComponent spline => new SplineMeshComponent(mesh, spline),
+                            ULandscapeNaniteComponent landscape => new SpatialComponent(landscape), // we already render landscape via ULandscapeComponent
                             _ => new StaticMeshComponent(mesh, sm)
                         },
                         UIRMeshComponent ir when ir.Mesh.TryLoad<UIRMesh>(out var mesh) => new ContainerComponent(mesh, ir), // Custom

Snooper/Rendering/Actors/WorldActor.cs

@@ -4,6 +4,7 @@
 using CUE4Parse.UE4.Assets.Exports;
 using CUE4Parse.UE4.Assets.Exports.Actor;
 using CUE4Parse.UE4.Assets.Exports.Engine;
+using CUE4Parse.UE4.Assets.Exports.Component;
 using CUE4Parse.UE4.Assets.Exports.WorldPartition;
 using CUE4Parse.UE4.Assets.Exports.WorldPartition.DataLayer;
 using CUE4Parse.UE4.Objects.Engine;
@@ -45,8 +46,22 @@ public WorldActor(UWorld world, IProgress<string>? progress = null, Cancellation
         }
         length = actors.Count;
 
+        if (level.Owner is { } package)
+        {
+            // an actor owns every component outered to it
+            for (var i = 0; i < package.ExportMapLength; i++)
+            {
+                var export = new FPackageIndex(package, i + 1);
+                if (package.ResolvePackageIndex(export) is { Outer: { } outer } resolved && actors.TryGetValue(outer, out var owner) &&
+                    resolved.GetObjectType() is { } type && type.IsAssignableTo(typeof(UActorComponent)))
+                {
+                    owner.EnqueuePointers(export);
+                }
+            }
+        }
+
         var processed = 0;
-        var components = new Dictionary<FPackageIndex, SpatialComponent>();
+        var components = new Dictionary<ResolvedObject, SpatialComponent>();
         foreach (var actor in actors.Values)
         {
             ct.ThrowIfCancellationRequested();

Snooper/Rendering/Cache/MaterialNode.cs

@@ -188,6 +188,12 @@ void ReadCachedData(UMaterialInterface cooked)
                 _referencedTextures.Clear();
                 _referencedTextures.AddRange(ordered);
             }
+
+            if (cooked.FlattenedTexture is { IsNull: false }) _textures.TryAdd("Diffuse", new TextureParameter(cooked.FlattenedTexture, provider));
+            if (cooked.MobileBaseTexture is { IsNull: false }) _textures.TryAdd("Diffuse", new TextureParameter(cooked.MobileBaseTexture, provider));
+            if (cooked.MobileNormalTexture is { IsNull: false }) _textures.TryAdd("Normal", new TextureParameter(cooked.MobileNormalTexture, provider));
+            if (cooked.MobileMaskTexture is { IsNull: false }) _textures.TryAdd("SpecularMasks", new TextureParameter(cooked.MobileMaskTexture, provider));
+            if (cooked is { bUseMobileSpecular: true, MobileSpecularMask: EMobileSpecularMask.MSM_Constant }) _scalars.TryAdd("Specular", cooked.MobileSpecularPower);
         }
 
         void ReadShaderMaps(UMaterialInterface cooked)